【设计模式】深入理解静态代理和动态代理

1、UML

2、静态代理

2.1 例子

背景：模仿租户租房子。
（1）抽象接口

/**
 * 抽象接口
 */
public interface Rent {
    public void rent();
}

（2）Host类（房东要出租房子）

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

(3) Proxy 代理类

public class Proxy implements Rent{

    Host host;
    // 选择set注入是模仿IOC机制，不要在类中提前new对象
    public void setHost(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        System.out.println("出租之前的合同准备");
        host.rent();
    }
}

(4) 调用

public class Client {
    public static void main(String[] args) {

        Host host=new Host();
        Proxy proxy=new Proxy();
        // 创建host对象的主动权交给了调用者
        proxy.setHost(host);
        proxy.rent();
    }
}

2.1 静态代理的优缺点

优点

可以使得我们的真实角色更加纯粹 .
如：host（房东）就只管出租房租，

公共的业务由代理来完成 . 实现了业务的分工
如：具体的其他的操作（如每个租客合同）由代理就行管理

公共业务发生扩展时变得更加集中和方便 .
如：在开发完成成，我可以根据需求添加日志，不用在去修改相关的类

缺点

多了代理类，工作量变大，效率降低，所以除了动态代理。

3、动态代理

动态代理分为两类，一个是基于接口的动态代理（JDK动态代理），一个是基于类的动态代理（cglib）

这里用原生的JDK代码实现动态代理：

3.1 代码实现：

（1）抽象接口：

/**
 * 抽象接口
 */
public interface Rent {
    public void rent();
}

（2） Host（房东）

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

（3）动态代理

public class ProxyInvocationHandler implements InvocationHandler {
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }


    //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
    public Object getProxy() {
        // 测试接口的返回值
        for (Class<?> aClass : target.getClass().getInterfaces()) {
            System.out.println(aClass);
        }
        /**
         * ClassLoader: 一个classloader对象，定义了由哪个classloader对象对生成的代理类进行加载
         * interfaces: 一个interface对象数组，表示我们将要给我们的代理对象提供一组什么样的接口，如果我们提供了这样一个接口对象数组，
         *             那么也就是声明了代理类实现了这些接口，代理类就可以调用接口中声明的所有方法。
         * h: 一个InvocationHandler对象，表示的是当动态代理对象调用方法的时候会关联到哪一个InvocationHandler对象上，并最终由其调用。
         * 就是执行invoke方法
         */
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }

    // proxy : 代理类，
    // method : 代理类的调用处理程序的方法对象.
    // 处理代理实例上的方法调用并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        System.out.println(method.getName());
        //核心：本质利用反射实现！
        Object result = method.invoke(target, args);
        fare();
        return result;
    }

    //看房
    public void seeHouse() {
        System.out.println("带房客看房");
    }

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

（4）client

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

（5）结果

3.2 理论分析

• 这里有一个被代理的类Host，接口Rent，但是没有用一个专门的代理类来实现接口Rent
• 它是通过实现了InvocationHandler 的类ProxyInvocationHandler 实现的动态性，这里面有两点最重要：

public Object getProxy() {
   return Proxy.newProxyInstance(target.getClass().getClassLoader(),
           target.getClass().getInterfaces(), this);
}

• （1）getProxy方法为了获取动态获取代理类
  第一个参数 target.getClass().getClassLoader()，我们都知道有三个类加载处理器，这里肯定是系统类加载器（因为是我们自己定义的类），通过这个类加载器来定义代理类
  第二个参数 target.getClass().getInterfaces()，获得的是被代理类实现的接口，目的获得接口中的方法，如上面截图中的： interface com.guang.spring.ioc.test1.test2.Rent
  第三个参数this，实际上是InvocationHandler

• 解释InvocationHandler
  InvocationHandler 是一个接口，官方文档解释说，每个代理的实例都有一个与之关联的 InvocationHandler 实现类，如果代理的方法被调用，那么代理便会通知和转发给内部的 InvocationHandler 实现类，由它决定处理。

public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

InvocationHandler 内部只是一个 invoke() 方法，正是这个方法决定了怎么样处理代理传递过来的方法调用。

proxy 代理对象
method 代理对象调用的方法
args 调用的方法中的参数

因为，Proxy 动态产生的代理会调用 InvocationHandler 实现类，所以 InvocationHandler 是实际执行者。实际上执行的是invoke方法

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        System.out.println(method.getName());
        //核心：本质利用反射实现！
        Object result = method.invoke(target, args);
        fare();
        return result;
    }

• method.invoke(target, args); 这个是关键，利用了反射，这里简单说明反射在这里的实用：反射就是把Java类中的各个部分，映射成一个个的Java对象，拿到这些对象后可以做一些事情。 就好像是方法rent()执行，其中里面有了参数host和args

3.3 动态代理的优点：

一个动态代理 , 一般代理某一类业务 , 一个动态代理可以代理多个类，代理的是接口！

4、总结

代理类让真是角色更加专注做一件事情
代理实现了业务分工，在不改变原有类的基础上，对功能进行了扩展

参考：

轻松学，Java 中的代理模式及动态代理
狂神说Spring06：静态/动态代理模式
用最直接的大白话来聊一聊Java中的反射机制