23种设计模式—③代理模式

代理模式是SpringAOP的底层
分为静态代理和动态代理

静态代理

角色分析：

• 抽象角色：一般使用接口或抽象类来解决
• 真实角色：被代理的角色
• 代理角色：代理真实角色，代理真实角色后，一般会做一些附属操作
• 客户：访问代理对象的人

用租房子来举个例子，抽象角色为租房子，真实角色为房东，代理角色为中介，客户为想租房的人

首先时抽象角色，租房接口

public interface Rent {
    void rent();
}

然后房东实现了这个接口

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

代理角色中介， 同样实现了Rent()接口，中介除了代理房东外，也有自己的功能

public class Proxy implements Rent {
    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    @Override
    public void rent(){
        host.rent();
        lookHouse();
        contract();
        fee();
    }

    //看房
    public void lookHouse(){
        System.out.println("中介带你看房");
    }

    //签合同
    public void contract(){
        System.out.println("中介与你签合同");
    }

    //中介收取中介费
    public void fee(){
        System.out.println("中介收取中介费");
    }
}

想要租房子的客户

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

代理模式的好处：

• 可以使真实角色更加纯粹，不用去关注一些公共的事情
• 公共的业务由代理来完成，实现业务的分工
• 公共业务要扩展的话，方便集中管理

静态代理模式再理解

再举一个例子来理解代理模式的好处
有一个用户增删改查的服务，它的接口和实现类为：

public interface UserService {
    void add();

    void delete();

    void update();

    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 UserServiceProxy implements UserService{

    private UserServiceImpl userServiceImpl;

    public void setUserServiceImpl(UserServiceImpl userServiceImpl) {
        this.userServiceImpl = userServiceImpl;
    }

    @Override
    public void add() {
        log("add");
        userServiceImpl.add();
    }

    @Override
    public void delete() {
        log("delete");
        userServiceImpl.delete();
    }

    @Override
    public void update() {
        log("update");
        userServiceImpl.update();
    }

    @Override
    public void query() {
        log("query");
        userServiceImpl.query();
    }

    //日志方法
    public void log(String msg){
        System.out.println("[debug] 使用了"+msg+"方法");
    }

}

这样客户类想要使用的时候，调用它的代理类就可以

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userServiceImpl = new UserServiceImpl();

        UserServiceProxy userServiceProxy = new UserServiceProxy();
        userServiceProxy.setUserServiceImpl(userServiceImpl);
        
        userServiceProxy.add();
        userServiceProxy.delete();
        userServiceProxy.update();
        userServiceProxy.query();
    }
}

但是静态代理也有个明显的缺点，一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低，为了改善这个问题，引入了动态代理。

动态代理

• 动态代理和静态代理角色一样
• 动态代理的代理类是动态生成的，不是我们直接写好的
• 动态代理分为两大类：基于接口的动态代理和基于类的动态代理
  - 基于接口——JDK动态代理
  - 基于类——cglib
  - java字节码实现：javasist

我在这里使用基于接口的，需要了解两个类：Proxy：代理，InvocationHandler：调用处理程序

Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。
动态代理类 （以下简称为代理类 ）是一个实现在类创建时在运行时指定的接口列表的类，具有如下所述的行为。 代理接口是由代理类实现的接口。 代理实例是代理类的一个实例。 每个代理实例都有一个关联的调用处理程序对象，它实现了接口InvocationHandler 。 通过其代理接口之一的代理实例上的方法调用将被分派到实例调用处理程序的invoke方法，传递代理实例， java.lang.reflect.Method被调用方法的java.lang.reflect.Method对象以及包含参数的类型Object Object的数组。 调用处理程序适当地处理编码方法调用，并且返回的结果将作为方法在代理实例上调用的结果返回。
我们来看它的两个静态方法

getInvocationHandler(Object proxy) //返回指定代理实例的调用处理程序。 

返回值类型：InvocationHandler

newProxyInstance(ClassLoader loader, 类<?>[] interfaces, InvocationHandler h) 
//返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。 

返回值类型：Object
InvocationHandler :是代理实例的调用处理程序实现的接口。
  每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。
只有一个方法

invoke(Object proxy, Method method, Object[] args) //在代理实例上处理方法调用并返回结果。

参数：
proxy - 在其上调用方法的代理实例
method - 对应于在代理实例上调用的接口方法的 Method 实例。Method 对象的声明类将是在其中声明方法的接口，该接口可以是代理类赖以继承方法的代理接口的超接口。
args - 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null。基本类型的参数被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中。
返回：
从代理实例的方法调用返回的值。如果接口方法的声明返回类型是基本类型，则此方法返回的值一定是相应基本包装对象类的实例；否则，它一定是可分配到声明返回类型的类型。如果此方法返回的值为 null 并且接口方法的返回类型是基本类型，则代理实例上的方法调用将抛出 NullPointerException。否则，如果此方法返回的值与上述接口方法的声明返回类型不兼容，则代理实例上的方法调用将抛出 ClassCastException。

用代码演示一下怎样用Proxy类和InvocationHandler类实现动态代理
我们写出一个类，我们会用这个类，自动生成代理类，是适用于任何代理角色的万能代理类。

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{
        Object result = method.invoke(target, args);
        return result;
    }

}

写个Client类来测试一下，同时用这个代理类来代理两个角色

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();

        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService);
        UserService proxy = (UserService) pih.getProxy();
        proxy.add();
//==================================================================
        Host host = new Host();
        pih.setTarget(host);
        Rent proxy1 = (Rent) pih.getProxy();
        proxy1.rent();
    }
}

同样，我们也可以用代理角色给原角色增加功能，比如说现在要实现一个记录使用了什么方法的日志功能，在ProxyInvocationHandler类中增添方法，并放入invoke方法中即可

 @Override
    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 msg){
        System.out.println("调用了"+msg+"方法");
    }

再运行一下