动态代理模式

 这篇博客对应上篇博客《静态代理模式》，我们来说一下动态代理，静态代理之所以扩展和维护比较困难，是因为代码写的太死，没有可替换的余地；针对代码写得死能想到什么解决办法？对，就是反射。

    使用反射可以很到的解决决定加载哪个代理类的问题，避免了每个代理类都要重复写的问题，话不多说，来看代码。

动态代理

    接口UserManager

 /***
  * 用户控制接口
  * @author Administrator
  *
  */
 public interface UserManager {

     public void addUser(String userId,String userName);
     public void modifyUser(String userId,String userName);
     public void delUser(String userId);
     public String findUser(String userId);
 }

    实现类UserManagerImpl

 /****
  * 用户管理真正的实现类
  * @author Administrator
  *
  */
 public class UserManagerImpl implements UserManager {

     /*****
      * 添加用户
      */
     public void addUser(String userId, String userName) {
             System.out.println("正在添加用户,用户为："+userId+userName+"……");
     }
     /*****
      * 删除用户
      */
     public void delUser(String userId) {
         System.out.println("delUser,userId="+userId);
     }
     /***
      * 查找用户
      */
     public String findUser(String userId) {
         System.out.println("findUser,userId="+userId);
         return userId;
     }

     public void modifyUser(String userId, String userName) {
         System.out.println("modifyUser,userId="+userId);
     }
 }

    代理类LogHandler

 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;

 public class LogHandler implements InvocationHandler {

     private Object targetObject;

     public Object newProxyInstance(Object targetObject) {
         this.targetObject = targetObject;
         return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
                                targetObject.getClass().getInterfaces(), this);
     }

     public Object invoke(Object proxy, Method method, Object[] args)
             throws Throwable {
         Object ret = null;

         try {
             System.out.println("正在进行操作前的准备工作……");
             //调用目标方法
             ret = method.invoke(targetObject, args);
             System.out.println("操作成功，正在进行确认处理……");
         } catch (Exception e) {
             e.printStackTrace();
             System.out.println("error-->>" + method.getName());
             throw e;
         }
         return ret;
     }
 }

    客户端Client

 public class Client {

     /**
      * @param args
      */
     public static void main(String[] args) {
         LogHandler logHandler = new LogHandler();
         UserManager userManager = (UserManager)logHandler.newProxyInstance(new UserManagerImpl());
         userManager.findUser("0001");
     }
 }

    运行结果

    

    时序图

    

总结

    动态代理模式通过使用反射，可以在运行期决定加载哪个类，避免了一个类对应一个代理的问题；同时，通过统一的invoke方法，统一了代理类对原函数的处理过程，使用动态代理很大程度上减少了重复的代码，降低了维护的复杂性和成本。