从JDK动态代理到SPRING AOP

代理模式 
   代理模式是常用的java设计模式，它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。 
   代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类对象的相关方法，来提供特定的服务。 
代理分类 
   静态代理：由程序员创建或特定工具自动生成源代码。在程序运行前，代理类的.class文件就已经存在了。 
   动态代理：在程序运行时，运用反射机制动态创建而成。 
静态代理代码示例

首先创建接口：

Java代码  

1. <span style="font-size: x-small;">package org.iti.wxl.staticproxy;  
2. /** 
3.  * 接口 
4.  */  
5. public interface UserService {  
6.              public void saveUser();  
7.              public void deleteUser();  
8. }</span>  

对接口的实现：（这里就不连接数据库了，只做简单的实例）

Java代码  

1. <span style="font-size: x-small;">package org.iti.wxl.staticproxy;  
2.   
3. public class UserServiceImpl implements UserService {  
4.     @Override  
5.     public void saveUser() {  
6.         System.out.println("==user saved!==");  
7.     }  
8.     @Override  
9.     public void deleteUser() {  
10.         System.out.println("==user deleted!==");  
11.     }  
12. }</span>  

代理类：

Java代码  

1. <span style="font-size: x-small;">package org.iti.wxl.staticproxy;  
2.   
3. public class UserServiceImplProxy implements UserService {  
4.       
5.     private UserServiceImpl userServiceImpl;  
6.     public UserServiceImplProxy(UserServiceImpl userServiceImpl) {  
7.         this.userServiceImpl = userServiceImpl;  
8.     }  
9.   
10.     @Override  
11.     public void saveUser() {  
12.         System.out.println("save begin!");  
13.         userServiceImpl.saveUser();  
14.         System.out.println("save end!");  
15.     }  
16.       
17.     @Override  
18.     public void deleteUser() {  
19.         System.out.println("delete begin!");  
20.         userServiceImpl.deleteUser();  
21.         System.out.println("delete end!");  
22.     }  
23. }</span>  

      代理类同样实现了UserService接口，代理类持有UserServiceImpl，并且重写了UserService接口里的方法，在方法里添加了逻辑。

测试方法：

Java代码  

1. <span style="font-size: x-small;">package org.iti.wxl.staticproxy;  
2.   
3. public class StaticProxy {  
4.     //静态代理方法测试  
5.     public static void main(String[] args) {  
6.         UserServiceImpl userServiceImpl = new UserServiceImpl();  
7.         UserServiceImplProxy userServiceImplProxy =   
8.                 new UserServiceImplProxy(userServiceImpl);  
9.         userServiceImplProxy.saveUser();  
10.         System.out.println("=============");  
11.         userServiceImplProxy.deleteUser();  
12.     }  
13. }  
14. </span>  

把创建的UserServiceImpl交给代理类UserServiceImplProxy，由它的实例执行数据逻辑操作。

方法运行结果如下：

Java代码  

1. <span style="font-size: x-small;">save begin!  
2. ==user saved!==  
3. save end!  
4. =============  
5. delete begin!  
6. ==user deleted!==  
7. delete end!</span>  

  代理类中添加的逻辑在方法运行时被执行了。 

    观察代码可以发现每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。

    解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。

 jdk动态代理

    jdk动态代理中包含一个类和一个接口，用到了java的反射机制：

Java代码  

1. <span style="font-size: x-small;">public interface InvocationHandler {   
2. public Object invoke(Object proxy,Method method,Object[] args);  
3. }  
4. </span>  

  参数说明： 
      Object proxy：代理类对象。    
      Method method：要调用的方法   
      Object[] args：方法调用时所需要的参数

    下面用代码说明jdk动态代理的使用

接口类：

Java代码  

1. <span style="font-size: x-small;">package org.iti.wxl.dynamicproxy;  
2.   
3. public interface UserService {  
4.     public void addUser();  
5.     public void deleteUSer();  
6. }</span>  

对接口的实现：

Java代码  

1. <span style="font-size: x-small;">package org.iti.wxl.dynamicproxy;  
2.   
3. public class UserServiceImpl implements UserService {  
4.     @Override  
5.     public void addUser() {  
6.         System.out.println("==add user==");  
7.     }  
8.     @Override  
9.     public void deleteUSer() {  
10.         System.out.println("==delete user==");  
11.     }  
12. }</span>  

代理类：

Java代码  

1. <span style="font-size: x-small;">package org.iti.wxl.dynamicproxy;  
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Method;  
5. import java.lang.reflect.Proxy;  
6. public class UserServiceImplProxy implements InvocationHandler {  
7.     private Object target;  
8.       
9.     public Object bind(Object target){  
10.         this.target = target;  
11.         return Proxy.newProxyInstance(target.getClass().getClassLoader(),   
12.                 target.getClass().getInterfaces(), this);  
13.     }  
14.     @Override  
15.     public Object invoke(Object proxy, Method method, Object[] args)   
16.             throws Throwable {  
17.         Object result = null;  
18.         System.out.println("user add begin!");  
19.         result = method.invoke(target, args);  
20.         System.out.println("user add end!");  
21.         return result;  
22.     }