AOP的JDK动态代理和CGLIB的代理

在程序里面定义简单的AOP切面类

Java代码

1. /**  
2.  * 定义Aspect  
3.  */  
4. @Aspect  
5. public class ShopAddCheck {   
6.     /**  
7.      * 定义Pointcut,Pointcut的名称就是allAddMethod，  
8.      * 此方法不能有返回值和参数，该方法只是一个标识  
9.      * Pointcut的内容是一个表达式，描述那些对象的那些方法（订阅Joinpoint）  
10.      */  
11.     @Pointcut("execution(* save*(..))")   
12.     public void allAddMethod(){};   
13.        
14.     /**  
15.      * 定义Advice，标识在那个切入点何处织入此方法  
16.      */  
17.     @Before("allAddMethod()")   
18.     public void checkShop(){   
19.         System.out.println("Check Shop");   
20.     }   
21. }   
22.   
23. //测试代码   
24. BeanFactory bean = new ClassPathXmlApplicationContext("*.xml");   
25.         ShopManager shopManager = (ShopManager) bean.getBean("shopManagerImp");   
26.         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代码

1. <aop:aspectj-autoproxy/>     
2. <bean id="shopAddCheck" class="com.langhua.spring.ShopAddCheck"/>      
3.     <bean id="shopManagerImp" class="com.langhua.spring.ShopManagerImp"/>   

<aop:aspectj-autoproxy/>	
<bean id="shopAddCheck" class="com.langhua.spring.ShopAddCheck"/>   
    <bean id="shopManagerImp" class="com.langhua.spring.ShopManagerImp"/> 

如果不在程序里面定义，也可以在配置文件里面定义

Java代码

1. <bean id="shopAddCheck" class="com.langhua.spring.ShopAddCheck"/>   
2.     <bean id="shopManagerImp" class="com.langhua.spring.ShopManagerImp"/>   
3.        
4.     <aop:config>   
5.         <aop:aspect id="check" ref="shopAddCheck">       
6.             <!-- addMethods只是一个标识 -->    
7.             <aop:pointcut id="addMethods" expression="execution(* com.langhua.spring.*.save*(..))"/>   
8.             <!-- checkShop表示具体要调用的方法 -->   
9.             <aop:before method="checkShop" pointcut-ref="addMethods"/>   
10.         </aop:aspect>        
11.     </aop:config>  

<bean id="shopAddCheck" class="com.langhua.spring.ShopAddCheck"/>
	<bean id="shopManagerImp" class="com.langhua.spring.ShopManagerImp"/>
	
	<aop:config>
		<aop:aspect id="check" ref="shopAddCheck">	
			<!-- addMethods只是一个标识 -->	
			<aop:pointcut id="addMethods" expression="execution(* com.langhua.spring.*.save*(..))"/>
			<!-- checkShop表示具体要调用的方法 -->
			<aop:before method="checkShop" pointcut-ref="addMethods"/>
		</aop:aspect>		
	</aop:config>

在AOP的方法中可以使用JoinPoint获得被切入方法的参数等信息

Java代码

1. public void checkShop(JoinPoint joinPoint){   
2.     //获得切入方法传过来的参数,返回Ojbect数组   
3.     joinPoint.getArgs();   
4.     //获得切入方法的方法名   
5.     joinPoint.getSignature().getName();   
6. }  

	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配置文件中加入<aop:aspectj-autoproxy proxy-target-class="true"/>就能强制使用

3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换（没有实现接口的就用CGLIB代理，使用了接口的类就用JDK动态代理）


JDK动态代理和CGLIB字节码生成的区别？
* JDK动态代理只能对实现了接口的类生成代理，而不能针对类
* CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法
  因为是继承，所以该类或方法最好不要声明成final

JDK动态代理的例子

Java代码

1. //接口   
2. public interface ShopManager {   
3.     public void addShop();   
4.     public void delShop();   
5.     public void saveShop();   
6.     public String findShopName();   
7. }   
8.   
9. //具体实现   
10. public class ShopManagerImp implements ShopManager {   
11.   
12.     public void addShop() {   
13.         System.out.println("调用add方法");   
14.     }   
15.   
16.     public void delShop() {   
17.         System.out.println("调用del方法");   
18.     }   
19.   
20.     public String findShopName() {   
21.         System.out.println("调用find方法");   
22.         return null;   
23.     }   
24.   
25.     public void saveShop() {   
26.         System.out.println("调用save方法");   
27.     }   
28.   
29. }   
30.   
31. //JDK动态代理   
32. import java.lang.reflect.InvocationHandler;   
33. import java.lang.reflect.Method;   
34. import java.lang.reflect.Proxy;   
35.   
36. public class ShopCheck implements InvocationHandler {   
37.   
38.     private Object proxyObj;   
39.        
40.     public Object newProxy(Object proxyObj){   
41.         this.proxyObj = proxyObj;   
42.         //返回一个代理对象   
43.         return Proxy.newProxyInstance(proxyObj.getClass().getClassLoader(),    
44.                                       proxyObj.getClass().getInterfaces(),    
45.                                       this);   
46.     }   
47.     //在使用shopManager类的时候会先调用这个方法(AOP)   
48.     public Object invoke(Object proxy, Method method, Object[] args)   
49.             throws Throwable {   
50.         //插入方法   
51.         checkShop();   
52.         //再调用代理对象的方法   
53.         Object obj = method.invoke(this.proxyObj, args);   
54.         return obj;   
55.     }   
56.        
57.     public void checkShop(){   
58.         System.out.println("-------------CheckShop()------------");   
59.     }   
60.   
61. }   
62.   
63. //最后的测试   
64. public class Click {   
65.     public static void main(String[] args){   
66.            
67.         ShopCheck shopcheck = new ShopCheck();   
68.         ShopManager shopManager = (ShopManager) shopcheck.newProxy(new ShopManagerImp());   
69.         shopManager.addShop();   
70.            
71.     }   
72. }