은성이의 프로그램X파일

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import aop.core.CoreClass;

public class TestMain {
 public static void main(String[] args) {
  ApplicationContext ctx = new ClassPathXmlApplicationContext("aop/config/aop.xml");
  CoreClass cls = (CoreClass) ctx.getBean("core");
  System.out.println("------------정상처리----------------");
  cls.businessMethod(10);
  System.out.println("------------에러내기----------------");
  cls.businessMethod(-1);
 }

}

package aop.common;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AdviceClass {
 @Before("within(aop.core.CoreClass)")//pointcut 지정
 public void beforLogger(){
  System.out.println("AdviceClass.before.beforeLogger()---------------------");
 }
 @AfterThrowing(pointcut="within(aop.core.CoreClass)",throwing="ex")
 public void afterThrowLogger(Throwable ex){
  System.out.println("AdviceClass.afterThrowLogger()----------------------");
  System.out.println(ex.getMessage());
 }
 @AfterReturning(pointcut="within(aop.core.CoreClass)",returning="ret")
 public void afterReturnLogger(Object ret){
  System.out.println("AdviceClass.afterReturnLogger()--------------");
  System.out.println(ret);
 }
 @After("within(aop.core.CoreClass)")//pointcut만 적용할 경우 pointcut=을 생략하고 within 정의
 public void afterLogger(){
  System.out.println("AdviceClass.afterLogger()----------------------");
 }
 @Around("within(aop.core.CoreClass)")
 public Object aroundLogger(ProceedingJoinPoint jp)throws Throwable{
  System.out.println("AdviceClass.aroundLogger() 실행----------------");
  return jp.proceed();
 }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
 <aop:aspectj-autoproxy/>
 <!-- 타겟 -->
 <bean name="core" class="aop.core.CoreClass"/>
 <!-- Advice -->
 <bean name="advice" class="aop.common.AdviceClass"/>

</beans>

package aop.core;

public class CoreClass {
 public void businessMethod(int i){
  if(i<0){
   throw new RuntimeException("i가 0보다 작다");
  }
  System.out.println("Business메소드가 실행되었습니다.");
 }
}

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import aop.cust.service.CustomerService;

public class TestMain {
 public static void main(String[] args) {
  
  ApplicationContext ctx = new ClassPathXmlApplicationContext("aop/config/aop.xml");
  CustomerService cs = (CustomerService) ctx.getBean("customerService");
  System.currentTimeMillis();//시간재기
  
  try{
   cs.registerCustomer();
   System.out.println("-------------등록끝----------------");
   cs.modifyCustomer();
   System.out.println("-------------수정끝----------------");
  }catch (Exception e) {
   e.printStackTrace();
  }
 }

}
 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
 
 <bean id="customerDAO" class="aop.cust.dao.CustomerDAOImpl"/>
 <bean id="customerService" class="aop.cust.service.CustomerServiceImpl">
  <property name="DAO" ref="customerDAO"/>
 </bean>
 <!-- Advice등록 -->
 <bean id="around" class="aop.cust.advice.AroundAdvice"/>
 <!-- aop설정 -->
 <aop:config>
 <!-- 내 방법 -->
 <!--<aop:aspect id="timeCheckAS" ref="around"> -->
   <!-- <aop:around method="timeCheckAdvice" pointcut="bean(customer*)"/> -->
   <!-- <aop:around method="timeCheckAdvice" pointcut="execution(public * aop..Customer*.*(..))"/>
  </aop:aspect>
   -->
   <!-- 강사님 방법 -->
  <aop:pointcut expression="within(aop.cust.service.*ServiceImpl)" id="custServicePC"/>
  <aop:pointcut expression="within(aop.cust.dao.*DAOImpl)" id="custDAOPC"/>
  <aop:aspect id="timeCheckAS" ref="around">
   <aop:around method="timeCheckAdvice" pointcut-ref="custServicePC"/>
   <aop:around method="timeCheckAdvice" pointcut-ref="custDAOPC"/>
  </aop:aspect>
 </aop:config>

</beans>

package aop.cust.advice;

import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.util.StopWatch;

public class AroundAdvice {
/*
 * CustomerDAOImpl.selectCustomerById : 500ms
 * CustomerDAOImpl.insertCustomer : 370ms
 * CustomerServiceImple.registerCustomer : 870ms
 * DAO와 Service 메소드들이 실행한 시간을 로그로 남긴다.
 * Target Class.method : 걸린시간
 */
 public Object timeCheckAdvice(ProceedingJoinPoint jp)throws Throwable{
//  StopWatch sw = new StopWatch();
//  sw.start();
//  Object retvalue = jp.proceed();
//  sw.stop();
//  long time = sw.getTotalTimeMillis();
//  System.out.println(jp.getTarget().getClass().getName()+"."+jp.getSignature().getName()+"() : "+time+"ms");
//  return retvalue;
  long endTime = 0;
  long startTime = 0;
  try{
   startTime =  System.currentTimeMillis();
   Object retValue = jp.proceed();//클라이언트가 요청한 메소드를 실제 호출
   System.out.print(jp.getTarget().getClass().getName()+"."+jp.getSignature().getName()+"()");
   return retValue;
  }catch (Throwable ta) {
   throw ta;
  }finally{
   endTime = System.currentTimeMillis();
   System.out.println(" : "+(endTime-startTime)+"ms");
  }

 }
}

package aop.cust.dao;

public interface CustomerDAO {

 public abstract void insertCustomer() throws Exception;

 public abstract void updateCustomer() throws Exception;

 public abstract void selectCustomerById() throws Exception;

}

package aop.cust.dao;

public class CustomerDAOImpl implements CustomerDAO {
 @Override
 public void insertCustomer() throws Exception{
  Thread.sleep(380);
 }
 @Override
 public void updateCustomer() throws Exception{
  Thread.sleep(520);
 }
 @Override
 public void selectCustomerById() throws Exception{
  Thread.sleep(620);
 }
}

package aop.cust.service;

import aop.cust.dao.CustomerDAO;

public interface CustomerService {

 public abstract void setDAO(CustomerDAO dao);

 public abstract void registerCustomer() throws Exception;

 public abstract void modifyCustomer() throws Exception;

}

package aop.cust.service;

import aop.cust.dao.CustomerDAO;

public class CustomerServiceImpl implements CustomerService {
 private CustomerDAO dao;
 @Override
 public void setDAO(CustomerDAO dao){
  this.dao = dao;
 }
 @Override
 public void registerCustomer() throws Exception{
  dao.selectCustomerById();
  dao.insertCustomer();
 }
 @Override
 public void modifyCustomer() throws Exception{
  dao.selectCustomerById();
  dao.updateCustomer();
 }
}

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

 
import aop.service.MemberService;

public class TestMain {
 public static void main(String[] args) {
  ApplicationContext ctx = new ClassPathXmlApplicationContext("aop/config/aop.xml");
  MemberService service = (MemberService)ctx.getBean("memberService");
  service.a();
  String str = service.c();
  System.out.println("main : "+str);
  
 

 }

}

package aop.advice;

import org.aspectj.lang.ProceedingJoinPoint;

public class LoggerAdvice {
 public Object aroundLogger(ProceedingJoinPoint jp)throws Throwable{
  System.out.println("---------before");
  try{
  Object retValue = jp.proceed();//클라이언트가 호출한 핵심 로칙 처리 메소드 호출
  System.out.println("---------after-returning : 리턴값 : "+retValue);
  
//  retValue = "asdfsdf";//String 값도 주소값으로 넘어다니기 때문에 retValue의 main에서의 값이 변한다.
  return retValue;
  }catch (Throwable ta) {
   System.out.println("--------after-throwing");
   throw ta;//여기서 예외를 처리하는 것이 아니기 때문에 호출한 곳으로 예외를 던져준다.
  }finally{
   System.out.println("--------after");
  }
  
 }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
 
 <bean name="memberService" class="aop.service.MemberService"/>
 <bean name="logger" class="aop.advice.LoggerAdvice"/>
 <aop:config>
  <aop:aspect id="loggerAS" ref="logger">
   <aop:around method="aroundLogger" pointcut="bean(*Service)"/>
  </aop:aspect>
 </aop:config>

</beans>

package aop.service;

public class MemberService {
 public void a(){
  System.out.println("MemberService.a() 실행");
 }
 public void b(){
  System.out.println("MemberService.b() 실행");
 }
 public String c(){
  System.out.println("MemberService.c() 실행");
  return "abc";
 }
}

package shop.common;

import org.aspectj.lang.JoinPoint;

import shop.service.InsufficientInventoryException;

public class OrderAspect {
 //꽃이나 책과 관련된 business로직 처리 도중 오류 발생시 호출된 advice메소드 작성
 //재고 부족시 - 꽃 재고 부족 : 주문량 - 15
 
 public void orderLogger(Exception ex){
  //주문시 오류처리
  System.out.println("주문처리시 오류발생");
  System.out.print(ex.getMessage());
  if(ex instanceof InsufficientInventoryException){
   InsufficientInventoryException ie = (InsufficientInventoryException)ex;
   System.out.println(" : "+ie.getOrderCount());
  }
 }

}

package shop.data;

public class WareHouse {
 private static WareHouse instance=new WareHouse();
 private int flowerCount=10;
 private int bookCount=10;
 private WareHouse(){}
 public static WareHouse getInstance(){
  return instance;
 }
 public int getFlowerCount() {
  return flowerCount;
 }
 public int getBookCount() {
  return bookCount;
 }
 
}

package shop.service;

import shop.data.WareHouse;

public class BookServiceImpl implements StoreService {
 private WareHouse wareHouse;
 
 public BookServiceImpl() {
 }
 public BookServiceImpl(WareHouse wareHouse){
  this.wareHouse=wareHouse;
 }
 @Override
 public void sell(int count) throws InsufficientInventoryException{
  if(wareHouse.getBookCount()<count){
   throw new InsufficientInventoryException("Book 재고가 부족!",count);
  }
  System.out.println("책 "+count+"권 판매 ok!");
 }
}

package shop.service;

import shop.data.WareHouse;

public class FlowerServiceImpl implements StoreService {
 private WareHouse wareHouse; 
 public FlowerServiceImpl(WareHouse wareHouse) {
  super();
  this.wareHouse = wareHouse;
 }
 @Override
 public void sell(int count) throws InsufficientInventoryException {
  if(wareHouse.getFlowerCount()<count){
   throw new InsufficientInventoryException("꽃 재고 부족",count);
  }
  System.out.println("꽃 "+count+" 송이 판매!");
 }
}

package shop.service;

//재고 부족시 발생시킬 Exception객체
public class InsufficientInventoryException extends Exception {
 private int orderCount;
 public InsufficientInventoryException() {
 }

 public InsufficientInventoryException(String message, int orderCount) {
  super(message);
  this.orderCount = orderCount;
 }
 public int getOrderCount(){
  return orderCount;
 }

}

package shop.service;

public interface StoreService {

 public abstract void sell(int count) throws InsufficientInventoryException;

}

package shop.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import shop.service.InsufficientInventoryException;
import shop.service.StoreService;

public class Test {
 public static void main(String[] args) {
  ApplicationContext context
          = new ClassPathXmlApplicationContext("shop.xml");
  StoreService fs=(StoreService)context.getBean("flower");
  StoreService bs=(StoreService)context.getBean("book");  
  try {
   fs.sell(80);
  } catch (InsufficientInventoryException e) {
   System.out.println(e.getMessage());
  }
  try {
   bs.sell(1);
  } catch (InsufficientInventoryException e) {
   System.out.println(e.getMessage());
  }
  
 }
}
//로그메세지 : 주문량 - 주문개수
//꽃 재고 부족 : 주문량 - 15

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
 <bean id="wh" class="shop.data.WareHouse" factory-method="getInstance"/><!-- 싱글턴 패턴으로 작성이 되어 있어서 factory-method="getInstance"를 사용-->
 <bean name="book" class="shop.service.BookServiceImpl">
  <constructor-arg ref="wh"/>
 </bean>
 <bean name="flower" class="shop.service.FlowerServiceImpl">
  <constructor-arg ref="wh"/>
 </bean>
 
 <!-- 공통로직 처리 bean -->
 <bean name="orderAspect" class="shop.common.OrderAspect"/>
 <aop:config>
  <aop:aspect id="logger" ref="orderAspect">
   <aop:after-throwing method="orderLogger" pointcut="execution(public * shop..*Service.sell(..))" throwing="ex"/>
  </aop:aspect>
 </aop:config>

</beans>

import java.util.ArrayList;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import aop.dto.MemberDTO;
import aop.service.MemberService;

public class TestMain {
 public static void main(String[] args) {
  ApplicationContext ctx = new ClassPathXmlApplicationContext("aop/config/aop.xml");
  MemberService service = (MemberService)ctx.getBean("memberService");
  MemberDTO mto = service.selectMemberById("abcde");
  System.out.println("main() : "+mto);
  ArrayList list = service.selectAllMember();
  System.out.println("main() : "+list);
  try{
   service.registerMember(null);
  }catch (Exception e) {
   System.out.println(e.getMessage());
  }
  
 }

}

package aop.advice;

import aop.dto.MemberDTO;

public class LoggerAdvice {
 //로그 남기는 공통로직 처리
 public void afterReturnLogger(){
  System.out.println("------------LoggerAdvice.afterReturnLogger 시작--------------");
  System.out.println("------------LoggerAdvice.afterReturnLogger 종료--------------");
 }
 public void afterReturnLogger2(Object ret){
  System.out.println("------------LoggerAdvice.afterReturnLogger2 시작--------------");
  System.out.println("ret : "+ret);
  if(ret instanceof MemberDTO){
   MemberDTO mto = (MemberDTO)ret;
   mto.setAge(1000);//mto는 객체로 주소가 이동하기 때문에 age의 값이 1000으로 변경(main에서 mto를 호출해도 age는 1000임)
  }
  System.out.println("------------LoggerAdvice.afterReturnLogger2 종료--------------");
 }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
 
 <bean name="memberService" class="aop.service.MemberServiceImpl"/>
 <!-- 공통로직 -->
 <bean name="loggerAdvice" class="aop.advice.LoggerAdvice"/>
 <!-- aop설정 -->
 <aop:config>
  <aop:aspect id="afterAS" ref="loggerAdvice">
   <aop:after-returning pointcut="execution(* aop.service..*Service.*(..)) " method="afterReturnLogger"/>
   <aop:after-returning pointcut="within(aop.service.*ServiceImpl)" method="afterReturnLogger2" returning="ret"/>
  </aop:aspect>
 </aop:config>
</beans>

package aop.dto;

public class MemberDTO {
 private String id;
 private String name;
 private int age;
 public MemberDTO() {
  super();
 }
 public MemberDTO(String id, String name, int age) {
  super();
  this.id = id;
  this.name = name;
  this.age = age;
 }
 public String getId() {
  return id;
 }
 public void setId(String id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 @Override
 public String toString() {
  return "MemberDTO [id=" + id + ", name=" + name + ", age=" + age + "]";
 }
 @Override
 public int hashCode() {
  final int prime = 31;
  int result = 1;
  result = prime * result + age;
  result = prime * result + ((id == null) ? 0 : id.hashCode());
  result = prime * result + ((name == null) ? 0 : name.hashCode());
  return result;
 }
 @Override
 public boolean equals(Object obj) {
  if (this == obj)
   return true;
  if (obj == null)
   return false;
  if (getClass() != obj.getClass())
   return false;
  MemberDTO other = (MemberDTO) obj;
  if (age != other.age)
   return false;
  if (id == null) {
   if (other.id != null)
    return false;
  } else if (!id.equals(other.id))
   return false;
  if (name == null) {
   if (other.name != null)
    return false;
  } else if (!name.equals(other.name))
   return false;
  return true;
 }
 
}

package aop.service;

import java.util.ArrayList;

import aop.dto.MemberDTO;

public interface MemberService {

 public abstract MemberDTO selectMemberById(String id);

 public abstract ArrayList selectAllMember();

 public abstract void registerMember(MemberDTO mto);

 public abstract void modifyMember(MemberDTO mto);

}

package aop.service;

import java.util.ArrayList;

import aop.dto.MemberDTO;

public class MemberServiceImpl implements MemberService {

 @Override
 public MemberDTO selectMemberById(String id){
  System.out.println("MemberServiceImpl.selectMemberById() 실행");
  return new MemberDTO(id, "홍길동", 33);
 }
 
 @Override
 public ArrayList selectAllMember(){
  System.out.println("MemberServiceImpl.selectAllMember() 실행");
  return new ArrayList();
 }
 
 @Override
 public void registerMember(MemberDTO mto){
  System.out.println("MemberServiceImpl.registerMember(mto) 실행");
  throw new RuntimeException("가입도중 오류 발생");
 }
 
 @Override
 public void modifyMember(MemberDTO mto){
  System.out.println("MemberServiceImpl.modifyMember(mto) 실행");
  throw new RuntimeException("회원 정보 수정 도충 오류발생");
 }
}

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import aop.core.Service;

public class TestAOP {
 public static void main(String[] args) {
  ApplicationContext ctx = new ClassPathXmlApplicationContext("aop/config/aop.xml");
  Service service = (Service) ctx.getBean("customerService");
  service.register();
  service.modify();
  String name = service.selectMemberNameById("111");
  System.out.println(name);
 }
}

package aop.common;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;

public class Logger {
 public void log(){
  System.out.println("-------------------------------");
  System.out.println("로그 처리");
  System.out.println("-------------------------------"); 
 }
 public void logJp(JoinPoint jp){
  Object target = jp.getTarget();//Target객체 return
  System.out.println("타겟 객체 이름 : "+target.getClass().getName());
  Object[] args = jp.getArgs();//client 단에서 Business Losic 메소드 호출시 넘긴 인수값.
  System.out.println("-----------인수값-------------");
  for(Object obj:args){
   System.out.println(obj);
  }
  Signature sig = jp.getSignature();//target의 구문 정보를 뽑아냄
  System.out.println("sig.getName() : "+sig.getName());
  System.out.println("sig.toShortString() : "+sig.toShortString());
  System.out.println("sig.toLongString() : "+sig.toLongString());
  
 }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
 <!-- 공통관심사항을 처리하는 객체 등록 -->
 <bean name="logger" class="aop.common.Logger"/>
 <!-- 핵심관심사항(Business로직) 처리 객체 등록 -->
 <bean name="customerService" class="aop.core.CustomerService"/>
 <!-- aop 설정 -->
 <aop:config>
  <aop:aspect id="loggerAS" ref="logger"><!-- 공통 관심사항을 가지고 있는 객체 등록(logger) , id는 아무거나 등록 -->
   <aop:pointcut expression="within(aop.core.*Service)" id="csPT"/><!-- within은 클래스 기준으로 service로 끝나는 모든 타입을 표현한다. -->
   <aop:before pointcut-ref="csPT" method="log"/><!-- before로 service로 끝나는 모든 메소드가 실행 될때 마다 logger에 있는 log메소드를 실행한다. -->
  </aop:aspect>
  
  <aop:aspect id="loggerJp" ref="logger">
   <aop:before pointcut="execution(public * aop..*Service.select*(..))" method="logJp"/><!-- pointcut을 직접 지정할 수도 있다. -->
  </aop:aspect>
 </aop:config>
 
 
</beans>

package aop.core;

public class CustomerService implements Service{
 public void register(){  
  System.out.println("고객 등록 처리");
 }
 public void modify(){
  System.out.println("고객 정보 수정 처리");
 }
 public String selectMemberNameById(String id) {
  System.out.println(id+"의 이름을 조회합니다.");
  return "홍길동";
 }
}

package aop.core;

public interface Service {

 public abstract void register();

 public abstract void modify();
 
 public String selectMemberNameById(String id);
}