Java设计模式（代理模式）

来源：互联网发布：java web高级编程高清编辑：程序博客网时间：2024/04/25 14:56

什么是代理模式

代理模式(Proxy Pattern)是23种Java常用设计模式之一。
代理模式的定义：Provide a surrogate or placeholder for another object to controlaccess to it.(为其他对象提供一种代理以控制对这个对象的访问)。
使用代理模式创建代理对象，让代理对象控制目标对象的访问(目标对象可以是远程的对象、创建开销大的对象或需要安全控制的对象),并且可以在不改变目标对象的情况下添加一些额外的功能。
我理解的代理模式就像球员的经纪人一样，谈工作安排，球员薪资都和经纪人（所谓的代理）谈，球员只要踢好球就行了，使球员隐藏在经纪人（代理的后面）。

代理模式实例

静态代理模式

静态代理模式实例
下面这个实例是调用静态代理实现UserManager接口的addUser方法的打印日志的功能：

interface UserManager{    void addUser(String userId, String userName);//添加    void delUser(String userId);//删除     String findUser(String userId);//查找        void modifyUser(String userId, String userName);//修改 }class UserManagerImpl implements UserManager {        @Override      public void addUser(String userId, String userName) {          System.out.println("UserManagerImpl.addUser");      }      @Override      public void delUser(String userId) {          System.out.println("UserManagerImpl.delUser");      }      @Override      public String findUser(String userId) {          System.out.println("UserManagerImpl.findUser");          return "张三";      }      @Override      public void modifyUser(String userId, String userName) {        System.out.println("UserManagerImpl.modifyUser");      }  } class UserManagerImplProxy implements UserManager {        private UserManager userManager;  // 目标对象     // 通过构造方法传入目标对象      public UserManagerImplProxy(UserManager userManager){          this.userManager=userManager;      }      @Override      public void addUser(String userId, String userName) {          try{            //添加打印日志的功能                  //开始添加用户                  System.out.println("start-->addUser()");                  userManager.addUser(userId, userName);                  //添加用户成功                  System.out.println("success-->addUser()");          }catch(Exception e){                  //添加用户失败                  System.out.println("error-->addUser()");          }      }      @Override      public void delUser(String userId) {          userManager.delUser(userId);      }      @Override      public String findUser(String userId) {          userManager.findUser(userId);          return "张三";      }      @Override      public void modifyUser(String userId, String userName) {          userManager.modifyUser(userId,userName);      }  }//客户端调用public class ProxyTest {    public static void main(String[] args){          //UserManager userManager=new UserManagerImpl();          UserManager userManager = new UserManagerImplProxy(new UserManagerImpl());          userManager.addUser("1111", "张三");          //userManager.findUser("1111");     }  }/*Outputstart-->addUser()UserManagerImpl.addUsersuccess-->addUser()*/

静态代理模式优缺点
优点：
代理使客户端不需要知道实现类是什么，怎么做的，而客户端只需知道代理即可（解耦合），对于如上的客户端代码，newUserManagerImpl()可以应用工厂将它隐藏，如上只是举个例子而已。
缺点：
1）代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
例：如果我们在上例的基础上还想要为findUser方法打印日志，这时我们必须修改代码如下

    @Override      public String findUser(String userId) {          try{            //添加打印日志的功能                  //开始查找用户                  System.out.println("start-->findUser()");                  userManager.findUser(userId);                  //查找用户结束                  System.out.println("success-->findUser()");              }catch(Exception e){                  //添加用户失败                  System.out.println("error-->findUser()");              }              userManager.findUser(userId);              return "张三";      } //客户端调用public class ProxyTest {    public static void main(String[] args){          UserManager userManager = new UserManagerImplProxy(new UserManagerImpl());          userManager.findUser("1111");     }  }

2）代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。如上的代码是只为UserManager类的访问提供了代理，但是如果还要为其他类如Department类提供代理的话，就需要我们再次添加代理Department的代理类。
举例说明：代理可以对实现类进行统一的管理，如在调用具体实现类之前，需要打印日志等信息，这样我们只需要添加一个代理类，在代理类中添加打印日志的功能，然后调用实现类，这样就避免了修改具体实现类。满足我们所说的开闭原则。但是如果想让每个实现类都添加打印日志的功能的话，就需要添加多个代理类，以及代理类中各个方法都需要添加打印日志功能（如上的代理方法中删除，修改，以及查询都需要添加上打印日志的功能）
即静态代理类只能为特定的接口(Service)服务。如想要为多个接口服务则需要建立很多个代理类。

动态代理模式

动态代理模式实例

import java.lang.reflect.*;class UserManagerImpl1 implements UserManager {      @Override      public void addUser(String userId, String userName) {          System.out.println("UserManagerImpl.addUser");      }      @Override      public void delUser(String userId) {          System.out.println("UserManagerImpl.delUser");      }      @Override      public String findUser(String userId) {          System.out.println("UserManagerImpl.findUser");          return "张三";      }      @Override      public void modifyUser(String userId, String userName) {          System.out.println("UserManagerImpl.modifyUser");      }  } class LogHandler implements InvocationHandler {           // 目标对象      private Object targetObject;      //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。                  public Object newProxyInstance(Object targetObject){          this.targetObject=targetObject;          //该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例            //第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器          //第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口          //第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法          //根据传入的目标返回一个代理对象          return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),                  targetObject.getClass().getInterfaces(),this);      }      @Override      //关联的这个实现类的方法被调用时将被执行      /*InvocationHandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数*/      public Object invoke(Object proxy, Method method, Object[] args)              throws Throwable {          System.out.println("start-->>");          for(int i=0;i<args.length;i++){              System.out.println(args[i]);          }          Object ret=null;          try{              /*原对象方法调用前处理日志信息*/              System.out.println("satrt-->>");              //调用目标方法              ret=method.invoke(targetObject, args);              /*原对象方法调用后处理日志信息*/              System.out.println("success-->>");          }catch(Exception e){              e.printStackTrace();              System.out.println("error-->>");              throw e;          }          return ret;      }  }  public class DynamicProxyTest {    public static void main(String[] args){          LogHandler logHandler=new LogHandler();          UserManager userManager=(UserManager)logHandler.newProxyInstance(new UserManagerImpl());          //UserManager userManager=new UserManagerImpl();          userManager.addUser("1111", "张三");         Department departmentManager=(Department)logHandler.newProxyInstance(new DepartmentImpl());         departmentManager.addDepartment("1111", "财务处");     }  }

动态代理模式优缺点

参考文献

http://blog.csdn.net/jackiehff/article/details/8621517
http://blog.csdn.net/jianghuxiaoxiami/article/details/3403924
http://blog.csdn.net/hejingyuan6/article/details/36203505
Thinking In Java
Head First Design Patterns

0 0