设计模式之动态代理-蒲公英云

1 背景回顾

设计模式是一种思维方式，前人总结的最佳实践，也是一种态度，一种进步。
软件过程里面设计模式一共有23种，一般分为3类。即创建型，结构性型，行为型。其中：
****创建型5种： **** 解决了创建对象的烦恼
单例模式，工厂模式，抽象工厂模式，建造者模式，原型模式

结构性型7种： 解决了如何让类组合起来完成复杂的功能
适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式，

行为型11种： 解决了类之间的控制关系。
模版方法模式，命令模式，迭代器模式，观察者模式，中介者模式，备忘录模式，状态模式，策略模式，职责链模式，访问者模式，解释器模式。

如果想要学习并掌握这些设计模式，最好是编码和画图理解

设计模式是一种思维方式，前人总结的最佳实践，也是一种态度，一种进步。
软件过程里面设计模式一共有23种，一般分为3类。即创建型，结构性型，行为型。其中：
**创建型5种： ** 解决了创建对象的烦恼
单例模式，工厂模式，抽象工厂模式，建造者模式，原型模式

结构性型7种： 解决了如何让类组合起来完成复杂的功能
适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式，

如果想要学习并掌握这些设计模式，最好是编码和画图理解。

在学习动态代理之前，最好先学习静态代理，可以看笔者另外一篇基础文章：设计模式之静态代理

2 动态代理

因为静态代理对每个要被代理的类，都要创建一个对应的类，比较麻烦。由此，提出了动态代理，即一个代理可以代理多个真实的类。
需要用到3个类，InvokerHanlder接口，Proxy，前者要使用invoke方法，后者完成生成对应真实类的代理。

2.1 要代理的接口
租房

package demo03;
public interface Rent { 
    void rent();
}

2.2 真实的角色：房东

package demo03;
public class Host implements Rent { 
    public void rent() { 
        System.out.println("房东要租房");
    }
}

2.3实现InokerHanlder接口

第一步：定义被代理的接口
第二步：生成得到代理，通过Proxy.newProxyInstance（ClassLoader，Interfaces，InvokerHanlder），参数分别分类加载器，接口对象，InvokerHanlder
第三步：处理代理实例，并返回结果

package demo03;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//代理 调用处理器
public class ProxyInvocationHandler implements InvocationHandler { 
    // 1 定义被代理的接口
    private Rent rent;
    public void setRent(Rent rent) { 
        this.rent = rent;
    }
//2 生成得到代理
  public Object  getProxy(){ 
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
    }
    //3 处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
        Object result = method.invoke(rent, args);//类似于，rent.method(args)
        return result;
    }
}

2.4 客户端找代理

package demo03;
public class Client { 
    public static void main(String[] args) { 
        //需要先生成一个真实代理的类
        Rent host = new Host();
        //代理角色， 现在没有
        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
        //通过调用处理角色来处理我们要调用的接口对象
        proxyInvocationHandler.setRent(host);
        // 动态生成代理
        Rent proxy = (Rent) proxyInvocationHandler.getProxy();
        proxy.rent();
    }
}

执行结果：
在这里插入图片描述

3 动态代理进阶

对与第3个角色生成，可以写成一个通用工具类，以后使用时直接用就好了，即达到可以代理很多对象的初衷。

即把Rent接口变为Object就可以了。这个工具类可以代理很多类型对象。

package demo04;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//代理 调用处理器
public class ProxyInvocationHandler implements InvocationHandler { 
    // 1 定义被代理的接口
    private Object target;
    public void setRent(Object target) { 
        this.target = target;
    }
//2 生成得到代理
  public Object  getProxy(){ 
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
    //3 处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
       // 方法执行前
        Object result = method.invoke(target, args);//类似于，rent.method(args)
          // 方法执行后
        return result;
    }
}

同时，在方法执行前后还能加一些方法：

// 方法执行前
        Object result = method.invoke(target, args);//类似于，rent.method(args)
          // 方法执行后

具体如下：

package demo04;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//代理 调用处理器
public class ProxyInvocationHandler implements InvocationHandler { 
    // 1 定义被代理的接口
    private Object target;
    public void setRent(Object target) { 
        this.target = target;
    }
//2 生成得到代理
  public Object  getProxy(){ 
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
    //3 处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
        before();
        Object result = method.invoke(target, args);//类似于，rent.method(args)
        after();
        return result;
    }
    public  void before(){ 
        System.out.println("==========invoke方法执行前======");
    }
    public  void after(){ 
        System.out.println("=====invoke方法执行后=====");
    }
}