九、代理模式

目录：静态代理、动态代理
AOP的底层机制就是动态代理。
代理模式分为静态代理和动态代理。
接触aop之前，首先要了解一下代理模式。

代理模式示意图

1.静态代理

1）静态代理角色分析
①抽象角色：一般使用接口或者抽象类来实现。
②真实角色：被代理的角色。
③代理角色：代理真实角色。代理真实角色后 , 一般会做一些附属的操作。
④客户：使用代理角色来进行一些操作。
2）代码实现
以租房服务为例
Rent.java即抽象角色。

//抽象角色：租房 
public interface Rent { 
  public void rent(); 
}

Host.java 即真实角色。

//真实角色: 房东，房东要出租房子 
public class Host implements Rent { 
  public void rent() { 
    System.out.println("房屋出租"); 
  } 
}

Proxy.java即代理角色。

//代理角色：中介 
public class Proxy implements Rent { 
  private Host host; 
  public Proxy() { } 
  public Proxy(Host host) { 
    this.host = host; 
  }
  //租房 
  public void rent(){ 
    seeHouse(); 
    host.rent(); 
    fare(); 
  }
  //看房 
  public void seeHouse(){ 
    System.out.println("带房客看房");
  }
  //收中介费 
  public void fare(){ 
    System.out.println("收中介费"); 
  } 
}

Client.java即客户。

//客户类，一般客户都会去找代理
public class Client { 
  public static void main(String[] args) { 
    //房东要租房 
    Host host = new Host(); 
    //中介帮助房东 
    Proxy proxy = new Proxy(host); 
    //去找中介租房
    proxy.rent(); 
  } 
}

分析：租客直接接触的是中介，虽然接触不到房东，但是依旧组东了房东通过中介代理的房子，这就是以租房为例，所谓的代理模式。
3）静态代理的优势及劣势
优势：Ⅰ可以使得真实角色更加纯粹，不再去关注一些公共的事情。
Ⅱ公共的业务由代理来完成，实现了业务的分工。
Ⅲ公共业务发生扩展时变得更加集中和方便。
劣势：多了代理类，工作量变大，开发效率降低。
4）巩固练习
①创建一个抽象角色，主要业务就是增删改查。

//抽象角色：增删改查业务
public interface UserService {
  void add();
  void delete();
  void update();
  void query(); 
}

②创建一个真实对象来完成增删改查的操作。

//真实对象，完成增删改查操作 
public class UserServiceImpl implements UserService { 
  public void add() { 
    System.out.println("增加了一个用户"); 
  }
  public void delete() { 
    System.out.println("删除了一个用户"); 
  }
  public void update() { 
    System.out.println("更新了一个用户"); 
  }
  public void query() { 
    System.out.println("查询了一个用户"); 
  } 
}

③添加一个日志功能。
思路：Ⅰ在实现类上增加代码。
Ⅱ通过代理，在能够不改变原来的业务情况下实现此功能。
④ 设置一个代理类来处理日志。

//代理角色，在这里增加日志的实现
public class UserServiceProxy implements UserService {
  private UserServiceImpl userService;
  public void setUserService(UserServiceImpl userService) {
    this.userService = userService;
  }
  public void add() {
    log("add");
    userService.add();
  }
  public void delete() {
    log("delete");
    userService.delete();
  }
  public void update() {
    log("update");
  userService.update();
}

⑤测试访问类。

public class Client { 
  public static void main(String[] args) { 
    //真实业务 
    UserServiceImpl userService = new UserServiceImpl(); 
    //代理类 
    UserServiceProxy proxy = new UserServiceProxy(); 
    //使用代理类实现日志功能
    proxy.setUserService(userService); 
    proxy.add(); 
  } 
}

在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想。
AOP：纵向开发，横向开发

AOP的纵向开发与横向开发

2.动态代理

1）简介
动态代理的角色和静态代理的一样。但是动态代理的代理类是动态生成的，而静态代理的代理类是提前写好的。
动态代理分为两类，一类是基于接口动态代理，一类是基于类的动态代理。

• 基于接口的动态代理——JDK动态代理
• 基于类的动态代理——cglib
• javassist生成动态代理（现在使用的比较多） 百度一下javassist

JDK的动态代理需要了解两个类：InvocationHandler和Proxy，查看JDK帮助文档。
①InvocationHandler：调用处理程序
public interface InvocationHandler
InvocationHandler是由代理实例的调用处理程序实现的接口。
每个代理实例都有一个关联的调用处理程序。当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。

Object invoke(Object proxy, 方法 method, Object[] args);
//参数 
//proxy - 调用该方法的代理实例 
//method - 所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。 
//args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean。

②Proxy：代理
public class Proxy
extends Object
implements Serializable
Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。
动态代理类（以下简称为代理类）是一个实现在类创建时在运行时指定的接口列表的类，具有如下所述行为。代理接口是由代理类实现的接口。代理实例是代理类的一个实例。每个代理实例都有一个关联的调用处理程序对象，它实现了接口InvocationHandler。通过其代理接口之java.lang.reflect.Method对象以及包含参数的类型Object Object的数组。调用处理程序适当地处理编码方法调用，并且返回的结果将作为方法在实例上调用的结果返回。
查看方法newProxyInstance
参数：
Ⅰloader：类加载器来定义代理类。
Ⅱinterfaces：代理类实现的接口列表。
Ⅲh：调度方法调用的调用处理函数。

//生成代理类 
public Object getProxy(){ 
  return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(),this); 
}

2）代码实现
抽象角色和真实角色与静态代理时的保持一致。
Rent.java即抽象角色。

//抽象角色：租房 
public interface Rent { 
  public void rent(); 
}

Host.java 即真实角色。

//真实角色: 房东，房东要出租房子 
public class Host implements Rent { 
  public void rent() { 
    System.out.println("房屋出租"); 
  } 
}

ProxyInvocationHandler. java即代理角色。

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); 
  }
  // proxy：代理类 method：代理类的调用处理程序的方法对象
  // 处理代理实例上的方法调用并返回结果 
  @Override 
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    seeHouse(); 
    //核心：本质利用反射实现 
    Object result = method.invoke(rent, args); 
    fare(); 
    return result; 
  }
  //看房 
  public void seeHouse() { 
    System.out.println("带房客看房"); 
  }
  //收中介费 
  public void fare() { 
    System.out.println("收中介费"); 
  } 
}

Client.java即客户。

//租客 
public class Client { 
  public static void main(String[] args) { 
    //真实角色 
    Host host = new Host(); 
    //代理实例的调用处理程序 
    ProxyInvocationHandler pih = new ProxyInvocationHandler(); pih.setRent(host); 
    //将真实角色放置进去
    Rent proxy = (Rent)pih.getProxy();
    //动态生成对应的代理类
    proxy.rent(); 
  } 
}

核心：一个动态代理，一般代理某一类业务，一个动态代理可以代理多个类，代理的是接口。
3）深化理解
编写一个通用的动态代理实现的类，所有的代理对象设置为Object即可。先来实现我们前面写的UserService。

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); 
  }
  // proxy:代理类 method：代理类的调用处理程序的方法对象
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    log(method.getName()); 
    Object result = method.invoke(target, args); 
    return result; 
  }
  public void log(String methodName) { 
    System.out.println("执行了"+methodName+"方法"); 
  } 
}

测试：

public class Test { 
  public static void main(String[] args) { 
    //真实对象 
    UserServiceImpl userService = new UserServiceImpl(); 
    //代理对象的调用处理程序 
    ProxyInvocationHandler pih = new ProxyInvocationHandler(); pih.setTarget(userService); 
    //设置要代理的对象 
    UserService proxy = (UserService)pih.getProxy(); 
    //动态生成代理类
    proxy.add(); 
  } 
}

4）动态代理的优势
①可以使得真实角色更加纯粹，不再去关注一些公共的事情。
②公共的业务由代理来完成，实现了业务的分工。
③公共业务发生扩展时变得更加集中和方便。
④一个动态代理，一般代理某一类业务。
⑤一个动态代理可以代理多个类，代理的是接口。