23种设计模式之：动态代理模式

说到动态代理模式，大家一定会想到spring的AOP概念，今天我们来说一下java的动态代理模式

概念：为另一个对象提供一个替身患者占位符以控制对这个对象的访问。

代理模式有好多种变种，常见的分别为：远程代理、虚拟代理、保护代理、缓存代理。

简单介绍一下这三种代理的使用场景：

1.远程代理：最典型的例子就是Java的RMI，客户端通过代理想要调用远程服务端的方法实现。此时代理要做的就是将客户端想要调用的方法通过代理使用网络传输将数据序列化、反序列化调用另一台服务器的服务方法。

2.虚拟代理：直到我们真正需要对象的时候才创建它，当对象再创建前创建中时，由虚拟代理来扮演。对象的替身，对象创建后代理会将请求直接委托给对象。

3.保护代理：被代理类控制哪些方法可以被访问，哪些不能被访问。

4.缓存代理：为开销大的运算结果提供暂时存储，它允许多个客户共享结果，以减少计算或网络延迟。

代理模式代理模式能帮助我们完成什么？

举个生活中常见的例子：在我们需要租房时，通常都要去房屋中介登记、看房，此时带我们去看房的精神小伙就是房主的委托人，房主告诉他想要租2000块一个月，他接受了委派并且自己想要拿到一些额外的佣金，在原本出租价格的基础上加了200块。此时，我们租房要花2200，我们不知道房东是谁，也不知道房东要租多少钱，我们只能跟这个精神小伙打交道，他就是房主的代理，价钱合适就让房主来签合同。

有动态代理模式的概念，自然有静态代理模式，我们先看一下静态代理的实现代码：

import java.math.BigDecimal;
/**
 * @Author:zhangyanan
 * @Description: 房屋出租Service
 * @Date:Crated in 17:29 2020/3/12
 * @Modified By:
 */
public interface HouseOwnerService {

    /**
     * 出租房屋的价格
     */
    BigDecimal rentalHousePrice();
}

上图为提供服务的接口

import java.math.BigDecimal;

/**
 * @Author:zhangyanan
 * @Description: 服务实现
 * @Date:Crated in 17:29 2020/3/12
 * @Modified By:
 */
public class HouseOwnerServiceImpl implements HouseOwnerService {

    /**
     * 出租房屋的价格
     */
    @Override
    public BigDecimal rentalHousePrice() {
        return new BigDecimal("2000");
    }
}

上图为服务的接口实现

import java.math.BigDecimal;

/**
 * @Author:zhangyanan
 * @Description: 房屋中介代理类
 * @Date:Crated in 19:31 2020/3/12
 * @Modified By:
 */
public class LettingAgent {

    private leaseService leaseService;

    public LettingAgent(leaseService leaseService) {
        this.leaseService = leaseService;
    }

    /**
     * 告诉租户的房屋出租价格
     */
    public void printRentalHosuse() {
        System.out.println("房主想租的价格是：" + leaseService.rentalHousePrice().toString());
        //精神小伙又自己加了200块钱
        System.out.println("精神小伙想出租的价格是：" + leaseService.rentalHousePrice().add(new BigDecimal("200")).toString());
    }
}

上图为精神小伙代理类，额外增加了自己的佣金

/**
 * @Author:zhangyanan
 * @Description:
 * @Date:Crated in 10:25 2019/9/23
 * @Modified By:
 */
public class Test {

    public static void main(String[] args) {

        leaseService service = new leaseServiceImpl();
        LettingAgent lettingAgent = new LettingAgent(service);
        lettingAgent.printRentalHosuse();
    }
}

调用代理类，打印结果：
房主想租的价格是：2000
精神小伙想出租的价格是：2200

是不是看着有点像行为模式，他们之间看似结构相同，但实际目的不同。装饰模式是为对象加上一些行为，而代理模式则是控制访问。

静态代理模式的缺点：每当需要一个代理类就要新创建一个代理类，将被代理类放进构造方法。强耦合，代码依赖写死，必须显示的创建代理对象，会造成设计的类不断增加。

动态代理模式如何实现？
JDK为我们提供了内部实现动态代理的方式，有几个两个重要的类：

1.Proxy：代理类，调用Proxy.newInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)工厂方法创建实例。

2.InvocationHandler：代理辅助类，代理调用任何方法都会执行InvocationHandler.invoke()。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.math.BigDecimal;

/**
 * @Author:zhangyanan
 * @Description:
 * @Date:Crated in 19:45 2020/3/12
 * @Modified By:
 */
public class Hander implements InvocationHandler {

    private leaseService service;

    public Hander(leaseService service) {
        this.service = service;
    }

    /**
     * Proxy动态代理类调用所有的方法都会经过invoke方法
     *
     * @param proxy  调用的代理对象
     * @param method 被调用的方法
     * @param args   方法参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("**********进入handler.invoke()方法**********");
        if ("rentalHousePrice".equals(method.getName())) {
            System.out.println("我是精神小伙，这次我想加500作为我的佣金");
            BigDecimal price = ((BigDecimal) method.invoke(service, args)).add(new BigDecimal("500"));
            System.out.println("此小区的租房的价格是：" + price);
        }
        return null;
    }
}

上图为代理对象的处理类实现

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

/**
 * @Author:zhangyanan
 * @Description:
 * @Date:Crated in 10:25 2019/9/23
 * @Modified By:
 */
public class Test {

    public static void main(String[] args) {

        leaseService service = new leaseServiceImpl();
        InvocationHandler handler = new Hander(service);
        //利用工厂创建动态代理实例
        leaseService proxyService = (leaseService) Proxy.newProxyInstance(service.getClass().getClassLoader(), service.getClass().getInterfaces(), handler);
        //调用代理方法
        proxyService.rentalHousePrice();
    }
}

测试结果：
**********进入handler.invoke()方法**********
我是精神小伙，这次我想加500作为我的佣金
此小区的租房的价格是：2500

动态代理模式的优点：低耦合，在运行时创建对象，有兴趣的小伙伴们可以看一下创建动态代理的源码：

image.png

简单来说一下动态代理的创建过程：
1.获得真实服务实现类的所有接口和类加载器，获得所有的接口就能获得接口所有的方法。
2.得到动态代理类的Class。
3.获得动态对象的构造方法。
4.将handler处理类放入动态代理类的有参构造器。
5.创建代理对象。