Java设计模式之——代理设计模式

1.什么是代理设计模式

所谓代理模式是指客户端并不直接调用实际的对象，而是通过调用代理，来间接的调用实际的对象。

这里举一个栗子：就拿我们平时租房子来举例子，好比租客和房主之间的关系，我们租房子往往不会挨个去找房东，而是通过中间的代理者，也就是中介完成，租客来间接的和房主接触，这个时候租客（Tenant）相当于用户、中介（AgencyProxy）相当于代理者、房主（Homeowner）相当于被代理者。

在代理模式中还分为两种模式：静态代理和动态代理，下面我们通过代码来演示以下两种代理方式。

2、静态代理

首先我们先创建一个房主的接口（Houseowner），接口中只有一个租房子的方法。

 /**
  * @author wzy
  * @version 1.0
  * @date 2019/5/9 15:31
  */
 public interface Homeowner {
     public void letHouse();
 }

之后我们定义一个类去实现这个接口

 /**
  * @author wzy
  * @version 1.0
  * @date 2019/5/9 15:22
  */
 public class HomeownerImpl implements Homeowner {

     public void letHouse() {
         System.out.println("房东：出租了一套房子");
     }
 }

房主出租房子一般都会交给中介代理，创建一个AgencyProxy类，我们可以看到下面的类，这个类实现了被Homeowner接口，将房主的实现类作为类的成员变量，并且在自己的letHouse方法中调用目标类的方法，并且可以在调用目标类的前后做一些操作。

 public class AgencyProxy implements Homeowner{
     //被代理的对象
     private HomeownerImpl target;

     public AgencyProxy(HomeownerImpl target) {
         this.target = target;
     }

     public void letHouse() {
         System.out.println("中介带租客看房子");
         target.letHouse();
         System.out.println("成交后中介收取服务费");
     }

 }

接下来，创建一个租客类Tenant进行测试

 public class Tenant {
     public static void main(String[] args) {
         //租房子
         HomeownerImpl homeowners = new HomeownerImpl();
         AgencyProxy agencyProxy = new AgencyProxy(homeowners);
         agencyProxy.letHouse();

     }
 }

输出结果：

我们可以看到输出的结果，在调用被代理类的方法前后，代理类都可以做一些操作，这样就可以达到解耦的目的，也可以保护被代理的对象的目的，现在我们思考一下，如果被代理类的方法很多，那么我们每次都要在代理类中将所有方法重写一遍吗？并且如果被代理类中的方法名称发生变化，我们就需要去修改代理类的代码，这显然是不科学的，然而，动态代理就解决了这一问题。

3.动态代理

动态代理分为两种：JDK动态代理和cglib动态代理，动态代理的底层原理是，在程序运行时，通过反射机制动态生成代理类，那么如何实现动态代理呢？我们通过创建一个实现InvocationHandler的类，实现其中的invoke方法，在invoke方法对目标类中的方法进行调用。之后通过Proxy.newProxyInstance()创建一个动态代理的对象。

保持其他代码不动，修改AgencyProxy类的代码：

 public class AgencyProxy implements InvocationHandler{
     //被代理的对象,目标类
     private Homeowner target;
     //通过构造函数传入被代理目标类
     public AgencyProxy(Homeowner target) {
         this.target = target;
     }

     public Homeowner getProxy() {
         //目标类的类加载
         ClassLoader loader = target.getClass().getClassLoader();
         //返回代理类的接口列表
         Class [] classes = target.getClass().getInterfaces();
         //最后一个参数返回的实现了InvocationHandler的代理类
         Homeowner homeowner = (Homeowner) Proxy.newProxyInstance(loader, classes, this);
         //返回代理类对象
         return  homeowner;
     }

     @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         System.out.println("中介在租房前操作。。。。");
         //动态执行代理目标类中的方法
         Object result = method.invoke(target);
         System.out.println("中介在租房后的操作。。。");
         return result;
     }
 }

修改租客类Tenant测试动态代理：

 public class Tenant {
     public static void main(String[] args) {
         //创建被代理类：房主类
         Homeowner homeowners = new HomeownerImpl();
         //创建代理类，并传入被代理对象
         AgencyProxy agencyProxy = new AgencyProxy(homeowners);
         //返回生成的对象
         Homeowner homeownerProxy = agencyProxy.getProxy();
         //调用方法
         homeownerProxy.letHouse();
     }
 }

输出结果：我们可以看到通过动态代理我们实现了同样的效果。

4.总结

动态代理是一种十分常用的设计模式，在各种开源框架中都得到了非常广泛的应用，例如Spring的AOP底层就是使用的动态代理，MyBatis底层去代理Mapper使用的也是动态代理，还有就是在日志输出上也会用到这种设计模式，它的优势是实现无侵入式的代码扩展，也就是方法的增强；让你可以在不用修改源码的情况下，增强一些方法；在方法的前后你可以做你任何想做的事情（甚至不去执行这个方法都可以）。