AOP 의 JDK 동적 에이전트 와 CGLIB 의 에이전트

간단 한 AOP 절단면 클래스 를 프로그램 에서 정의 합 니 다.
자바 코드

/**  

 * 정의 Aspect 

 */  

@Aspect  

public class ShopAddCheck {   

    /**  

     * Pointcut 을 정의 합 니 다.Pointcut 의 이름 은 allAddMethod 입 니 다. 

     * 이 방법 은 반환 값 과 매개 변수 가 있 을 수 없습니다.이 방법 은 하나의 표지 일 뿐 입 니 다. 

     * Pointcut 의 내용 은 대상 의 방법 을 설명 하 는 표현 식 입 니 다.(Joinpoint 구독) 

     */  

    @Pointcut("execution(* save*(..))")   

    public void allAddMethod(){};   

       

    /**  

     * Advice 를 정의 합 니 다.이 접근 점 에서 표 지 를 짜 는 방법 입 니 다. 

     */  

    @Before("allAddMethod()")   

    public void checkShop(){   

        System.out.println("Check Shop");   

    }   

}   

  

테스트 코드  

BeanFactory bean = new ClassPathXmlApplicationContext("*.xml");   

        ShopManager shopManager = (ShopManager) bean.getBean("shopManagerImp");   

        shopManager.saveShop();  

/**
 *   Aspect
 */
@Aspect
public class ShopAddCheck {
	/**
	 *   Pointcut,Pointcut     allAddMethod，
	 *             ，         
	 * Pointcut         ，           （  Joinpoint）
	 */
	@Pointcut("execution(* save*(..))")
	public void allAddMethod(){};
	
	/**
	 *   Advice，               
	 */
	@Before("allAddMethod()")
	public void checkShop(){
		System.out.println("Check Shop");
	}
}

//    
BeanFactory bean = new ClassPathXmlApplicationContext("*.xml");
		ShopManager shopManager = (ShopManager) bean.getBean("shopManagerImp");
		shopManager.saveShop();

프로필 에 추가
Xml 코드

     

      

       

	
spring.ShopAddCheck"/>   
    spring.ShopManagerImp"/> 

프로그램 에서 정의 하지 않 으 면 설정 파일 에서 도 정의 할 수 있 습 니 다.
자바 코드

"shopAddCheck" class="com.langhua.spring.ShopAddCheck"/>   

    "shopManagerImp" class="com.langhua.spring.ShopManagerImp"/>   

       

       

        "check" ref="shopAddCheck">       

                

            "addMethods" expression="execution(* com.langhua.spring.*.save*(..))"/>   

               

            "checkShop" pointcut-ref="addMethods"/>   

                

      

spring.ShopAddCheck"/>
	spring.ShopManagerImp"/>
	
	
			
				
			spring.*.save*(..))"/>
			
			
				
	

AOP 의 방법 에서 JoinPoint 를 사용 하여 절 입 된 방법의 인자 등 정 보 를 얻 을 수 있 습 니 다.
자바 코드

public void checkShop(JoinPoint joinPoint){   

    //접근 방법 으로 전 달 된 인 자 를 가 져 와 Ojbect 배열 로 되 돌려 줍 니 다.  

    joinPoint.getArgs();   

    //접근 방법 을 가 져 오 는 방법 명  

    joinPoint.getSignature().getName();   

}  

	public void checkShop(JoinPoint joinPoint){
		//            ,  Ojbect  
		joinPoint.getArgs();
		//          
		joinPoint.getSignature().getName();
	}

JDK 대리 와 CGLIB 대리 의 총 결(생 성 대리 대상 의 전 제 는 AOP 접근)1.목표 대상 이 인 터 페 이 스 를 실현 하면 기본 적 인 상황 에서 JDK 의 동적 대 리 를 이용 하여 AOP 를 실현 합 니 다.단순 한 IOC 로 대상 을 생 성 하 는 경우 에 도 AOP 접근 이 없 으 면 대리 가 생 성 되 지 않 고 NEW 의 인 스 턴 스 만 사용 하여 Spring 의 Bean 공장 2,목표 대상 에 게 인 터 페 이 스 를 실현 하면CGLIB 를 사용 하여 AOP 를 강제 할 수 있 습 니 다.CGLIB 를 사용 하여 AOP 를 실현 하 는 방법*CGLIB 라 이브 러 리 를 추가 합 니 다.*spring 프로필 에 추가 하면 3 을 강제 사용 할 수 있 습 니 다.대상 이 인 터 페 이 스 를 실현 하지 못 하면 CGLIB 라 이브 러 리 를 사용 해 야 합 니 다.spring 은 자동 으로 JDK 동적 에이전트 와 CGLIB 사이 에서 전환 합 니 다.(인터페이스 가 실현 되 지 않 은 경우 CGLIB 에이 전 트 를 사용 합 니 다.인터페이스 클래스 를 사용 하면 JDK 동적 에이전트)JDK 동적 에이전트 와 CGLIB 바이트 코드 로 생 성 되 는 차이 점 은?*JDK 동적 에이 전 트 는 인 터 페 이 스 를 실현 한 클래스 만 생 성 할 수 있 고 클래스*CGLIB 는 클래스 를 대상 으로 에이 전 트 를 실현 할 수 없습니다.주로 지 정 된 클래스 에 하위 클래스 를 생 성하 여 덮어 쓰 는 방법 입 니 다.  상속 이기 때문에 이런 종류 나 방법 은 final JDK 동적 에이전트 의 예 로 밝 히 지 않 는 것 이 좋 습 니 다.
자바 코드
인터페이스  

public interface ShopManager {   

    public void addShop();   

    public void delShop();   

    public void saveShop();   

    public String findShopName();   

}   

  

구체 적 실현  

public class ShopManagerImp implements ShopManager {   

  

    public void addShop() {   

        System.out.println("add 방법 호출");  

    }   

  

    public void delShop() {   

        System.out.println("del 방법 호출");  

    }   

  

    public String findShopName() {   

        System.out.println("find 방법 호출");  

        return null;   

    }   

  

    public void saveShop() {   

        System.out.println("save 방법 호출");  

    }   

  

}   

  

JDK 동적 에이전트  

import java.lang.reflect.InvocationHandler;   

import java.lang.reflect.Method;   

import java.lang.reflect.Proxy;   

  

public class ShopCheck implements InvocationHandler {   

  

    private Object proxyObj;   

       

    public Object newProxy(Object proxyObj){   

        this.proxyObj = proxyObj;   

        //프 록 시 대상 되 돌리 기  

        return Proxy.newProxyInstance(proxyObj.getClass().getClassLoader(),    

                                      proxyObj.getClass().getInterfaces(),    

                                      this);   

    }   

    //shopManager 클래스 를 사용 할 때 이 방법 을 먼저 사용 합 니 다(AOP)  

    public Object invoke(Object proxy, Method method, Object[] args)   

            throws Throwable {   

        //삽입 방법  

        checkShop();   

        //대리 대상 을 재 호출 하 는 방법  

        Object obj = method.invoke(this.proxyObj, args);   

        return obj;   

    }   

       

    public void checkShop(){   

        System.out.println("-------------CheckShop()------------");   

    }   

  

}   

  

마지막 테스트  

public class Click {   

    public static void main(String[] args){   

           

        ShopCheck shopcheck = new ShopCheck();   

        ShopManager shopManager = (ShopManager) shopcheck.newProxy(new ShopManagerImp());   

        shopManager.addShop();   

           

    }   

}