二十三种设计模式之代理模式

代理模式分类：

• 静态代理模式

  • 角色分析:
  • 抽象角色:一般会使用接口或者抽象类来解决。
  • 真实角色︰被代理的角色。
  • 代理角色∶代理真实角色，代理真实角色后，我们一般会做一些附属操作。
  • 客户:访问代理对象的人!

• 代码步骤:

  • 接口

  // 租房
  public interface Rent {
      public void rent();
  }
  

  • 真实角色

  // 房东
  public class Host implements Rent {
      @Override
      public void rent() {
          System.out.println("房东出租房子");
      }
  }
  

  • 代理角色

  public class Proxy {
      private Host host;
  
      public Proxy() {
      }
  
      public Proxy(Host host) {
          this.host = host;
      }
      public void rent(){
          seeHouse();
          host.rent();
          signContract();
      }
      // 看房
      public void seeHouse(){
          System.out.println("中介带你看房！");
      }
      // 签合同
      public void signContract(){
          System.out.println("中介带你签合同！");
      }
  }
  

  • 客户端访问代理角色

  public class Clinet {
      public static void main(String[] args) {
          Host host = new Host();
          host.rent();
          // 代理，中介帮房东租房子，但是呢? 代理角色一般会有一些附属操作!
          Proxy proxy = new Proxy(host);
          proxy.rent();
      }
  }
  

  代理模式的好处:

  • 可以使真实角色的操作更加纯粹!不用去关注一些公共的业务
  • 公共也就交给代理角色!实现了业务的分工!
  • 公共业务发生扩展的时候，方便集中管理!

• 缺点:

  • 一个真实角色就会产生一个代理角色;代码量会翻倍~开发效率会变低.

• 栗子：

  // 常用接口
  public interface UserService {
      public void add();
      public void delete();
      public void update();
      public void query();
  }
  // 真实角色
  public class UserServiceImpl implements UserService {
      @Override
      public void add() {
          System.out.println("增加一个用户");
      }
  
      @Override
      public void delete() {
          System.out.println("删除一个用户");
      }
  
      @Override
      public void update() {
          System.out.println("更新一个用户");
      }
  
      @Override
      public void query() {
          System.out.println("查询用户");
      }
  }
  // 代理角色
  public class UserServicePtoxy implements UserService {
      private UserServiceImpl userService;
  
      public void setUserService(UserServiceImpl userService) {
          this.userService = userService;
      }
  
      @Override
      public void add() {
          log("增");
          userService.add();
      }
  
      @Override
      public void delete() {
          log("删");
          userService.delete();
      }
  
      @Override
      public void update() {
          userService.update();
      }
  
      @Override
      public void query() {
          userService.query();
      }
      public void log(String msg){
          System.out.println("输出日志文件："+msg);
      }
  }
  // 客户端
  package proxy.demo02;
  
  public class Client {
      public static void main(String[] args) {
          UserServiceImpl userService = new UserServiceImpl();
          UserServicePtoxy userServicePtoxy = new UserServicePtoxy();
          userServicePtoxy.setUserService(userService);
          userServicePtoxy.add();
      }
  }
  

• 动态代理模式

  • 动态代理和静态代理角色一样

  • 动态代理的代理类是动态生成的，不是我们直接写好的!

  • 动态代理分为两大类:基于接口的动态代理，基于类的动态代理

    • 基于接口—JDK动态代理【我们在这里使用】

    • 基于类: cglib

    • java字节码实现: javasist

  • 需要了解两个类︰Proxy:代理,InvocationHandler：调用处理程序

  // 租房接口
  public interface Rent {
      public void rent();
  }
  // 房东---真实角色
  public class Host implements Rent {
      @Override
      public void rent() {
          System.out.println("房东出租房子");
      }
  }
  /*
   * 自动生成代理类!
   */
  public class ProxyInvocationHandler implements InvocationHandler {
      // 被代理的接口
      private Rent rent;
  
      public void setRent(Rent rent) {
          this.rent = rent;
      }
      // 生成得到代理类
      public Object getProxy(){
          return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                  rent.getClass().getInterfaces(), this);
      }
      // 处理代理实例，并返回结果
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          // 动态代理的本质，就是使用反射机制交实现!
          seeHouse();
          Object invoke = method.invoke(rent, args);
          signContract();
          return invoke;
      }
      // 看房
      public void seeHouse(){
          System.out.println("中介带你看房！");
      }
      // 签合同
      public void signContract(){
          System.out.println("中介带你签合同！");
      }
  }
  public class Client {
      public static void main(String[] args) {
          // 真实角色
          Host host = new Host();
  
          // 代理角色： 创建
          ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
          // 通过调用程厅处理角色来处理我们要调用的接口对象!
          proxyInvocationHandler.setRent(host);
          //这里的proxy就是动态生成的,我们并没有写!
          Rent proxy =(Rent) proxyInvocationHandler.getProxy();
          proxy.rent();
  
      }
  }
  

  // 精简后代理类
  public class ProxyInvocationHandler implements InvocationHandler {
      // 被代理的接口
      private Object target;
      public void setTarget(Object target) {
          this.target = target;
      }
      // 生成得到代理类
      public Object getProxy(){
          return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                  target.getClass().getInterfaces(), this);
      }
      // 处理代理实例，并返回结果
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          // 动态代理的本质，就是使用反射机制交实现!
          log(method.getName());
          Object invoke = method.invoke(target, args);
          return invoke;
      }
      public void log(String msg){
          System.out.println("执行了："+msg+"方法");
      }
  }
  public class Client {
      public static void main(String[] args) {
          //真实角色
          UserServiceImpl userService = new UserServiceImpl();
          // 代理角色，不存在
          ProxyInvocationHandler invocationHandler = new ProxyInvocationHandler();
          // 设置要代理对象
          invocationHandler.setTarget(userService);
          // 动态生成代理类
          UserService proxy = (UserService) invocationHandler.getProxy();
          proxy.add();
          proxy.delete();
      }
  }