Spring-AOP-1静态代理和动态代理

代理模式分为静态代理和动态代理。静态代理就是我们自己定义的代理类，动态代理是程序在运行时生成的代理类。

静态代理示例

Service.java

Java代码  

1. <span style="font-size: medium;">package com.javacrazyer.dao;  
2.   
3. public interface Service {  
4.     public void outPut();  
5.     public void putOut();  
6. }</span><span style="font-size: medium;">  
7. </span>  

ServiceImpl.java

Java代码  

1. <span style="font-size: medium;">package com.javacrazyer.dao;  
2.   
3. public class ServiceImpl implements Service {  
4.   
5.     @Override  
6.     public void outPut() {  
7.         System.out.println("I am method outPut");  
8.     }  
9.   
10.     @Override  
11.     public void putOut() {  
12.         System.out.println("I am method putOut.");  
13.     }  
14.   
15. }</span><span style="font-size: medium;">  
16. </span>  

 至于上面两个类大家随便举例子，无论是增删改还是什么都可以的

测试类TestProxy.java

Java代码  

1. <span style="font-size: medium;">package com.javacrazyer.dao;  
2.   
3. public class TestProxy {  
4.     public static void main(String[] args) {  
5.           Service serviceImp = new ServiceImpl();  
6.           serviceImp.outPut();  
7.           serviceImp.putOut();  
8.     }  
9.   
10. }  
11. </span>  

 如我们所想，理所当然的输出了

I am method outPut
I am method putOut

下面我们需要加入安全性检查，就是调用方法前我们需要进行验证，比较常见的就是权限验证，验证用户是否拥有权限，

比较常见的做法就是在ServiceManagerImplProxy类中定义一个检查安全性的方法：

好了，这样一说，又得出现一个ServiceManagerImplProxy.java

Java代码  

1. <span style="font-size: medium;">package com.javacrazyer.dao;  
2.   
3.   
4. public class ServiceManagerImplProxy implements Service {  
5.   
6.     private Service service;  
7.     public ServiceManagerImplProxy(Service service){  
8.         this.service=service;  
9.     }  
10.       
11.     @Override  
12.     public void outPut() {  
13.         //在调用方法前调用验证方法  
14.        this.checkSecurity();  
15.        this.service.outPut();  
16.     }  
17.   
18.     @Override  
19.     public void putOut() {  
20.         //在调用方法前调用验证方法  
21.         this.checkSecurity();  
22.         this.service.putOut();  
23.     }  
24.     public void checkSecurity()     
25.     {     
26.         System.out.println("--------ServiceManagerImpl.checkSecurity()----------");     
27.     }   
28.   
29. }  
30. </span>  

 修改下测试代码

Java代码  

1. <span style="font-size: medium;">package com.javacrazyer.dao;  
2.   
3. public class TestProxy {  
4.     public static void main(String[] args) {  
5.           ServiceManagerImplProxy serviceImp = new ServiceManagerImplProxy(new ServiceImpl());  
6.           serviceImp.outPut();  
7.           serviceImp.putOut();  
8.     }  
9.   
10. }  
11. </span>  

 

输出结果

--------ServiceManagerImpl.checkSecurity()----------
I am method outPut
--------ServiceManagerImpl.checkSecurity()----------
I am method putOut

这样总的来说比较灵活。这个依赖关系是我们自己做的，我们完全可以交给spring处理。

按照上面的这种做法有一个缺点，如果接口中方法很多，那么我们实现每一个方法都要添加检查方法checkSecurity()，影响了我们的业务处理。采用静态代理模式我们是没法解决的，这时我们需要使用AOP思想。【AOP底层原理就是动态代理和反射机制】

 

动态代理示例

     使用动态代理我们需要声明一个类SecurityHandler，那么之前的ServiceManagerImplProxy类就不需要了，这个类要实现InvocationHandler接口。在类中定义一个产生动态代理的方法newProxy();同时把我们验证的代码放到这个类中。通过SecurityHandler，当我们调用方法时默认会调用SecurityHandler类invoke方法，我们在这个方法中进行安全性检查，检查通过后在调用真实的方法。需要注意的是目标对象接口中的部分方法是存在返回值的。

SecurityHandler.java

Java代码  

1. <span style="font-size: medium;">package com.javacrazyer.dao;  
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Method;  
5. import java.lang.reflect.Proxy;  
6. /** 
7.  * 动态代理的处理类: 只针对实现了接口的类才能创建出它的代理对象 
8.  * @author cheneywu 
9.  * 
10.  */  
11. public class SecurityHandler implements InvocationHandler {  
12.   
13.     private Object originalObject;  
14.   
15.     // 将欲代理的对象传入，返回一个代理对象  
16.     public Object newProxy(Object obj) {  
17.         this.originalObject = obj;  
18.   
19.         // 三个参数，第一个是欲代理对象的类加载器，第二个是得到这个类的接口集合，第三个参数是一个handler  
20.         return (Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj  
21.                 .getClass().getInterfaces(), this));  
22.     }  
23.   
24.     // 对欲代理对象的方法的调用将会调用这个代理对象的invoke方法  
25.     // 第一个参数是这个代理对象，第二个参数是欲代理对象实现方法，第三个是方法的参数集合  
26.     public Object invoke(Object proxy, Method method, Object[] args)  
27.             throws Throwable {  
28.         checkSecurity();  
29.         // 若方法名以out开头则调用下面逻辑  
30.         if (method.getName().startsWith("out")) {  
31.             System.out.println("This is a method invoking before the method that was intercepted.");  
32.             // 调用欲代理对象的相应方法  
33.             method.invoke(originalObject, args);  
34.               
35.             System.out.println("This is a method invoking after the method that was intercepted.");  
36.         } else {  
37.             // 若不是需要拦截的方法则正常执行方法  
38.             method.invoke(originalObject, args);  
39.         }  
40.         return null;  
41.     }  
42.   
43.     public void checkSecurity()     
44.     {     
45.         System.out.println("--------ServiceManagerImpl.checkSecurity()----------");     
46.     }   
47.   
48. }  
49. </span>  

 输出结果

--------ServiceManagerImpl.checkSecurity()----------
This is a method invoking before the method that was intercepted.
I am method outPut
This is a method invoking after the method that was intercepted.
--------ServiceManagerImpl.checkSecurity()----------
I am method putOut

跟预期效果一致，

 

使用这种方式维护起来相对比较好，我想进行安全性检查就进行，不想就不进行，很方便。