java设计模式之代理模式

定义：

代理模式指为其他对象提供一种代理，以控制对这个对象的访问，属于结构型设计模式

在某些情况下，一个对象不适合或者不能直接引用另外一个对象，而代理对象可以在客户端与目标对象之间起到中介作用

应用场景：

生活中的租房中介，婚姻介绍，经纪人，快递，事务代理，日志监听等，都是代理模式的实际体现

当无法或者不想直接引用某个对象或者访问某个对象存在困难是，可以通过代理对象来间接访问。使用代理模式主要有两个目的：一是保护目标对象，二是，增强目标对象

代理模式的UML类图：

右上图可见，代理模式包括三个角色：

1. 抽象主题角色（ISubject）：抽象主题类的主要职责是声明真实主题与代理的共同接口方法，该类可以是接口，也可以是抽象类

2. 真是主题角色（RealSubject）：该类也被称为被代理类，该类定义了代理所表示的真实对象，是负责执行系统的真正的逻辑业务对象

3. 代理主题角色（Proxy）：也被称为代理类，其内部持有的RealSubject的引用，因此具备完全的对RealSubject的代理权，客户端调用代理对象方法，也调用被代理对象的方法，但是会在代理对象前后增加一些处理代码。在代码中，一般代理会被理解为代码增强，实际上就是在原代码逻辑前后增加一些代码逻辑，而使调用者无感知，代理模式分为静态代理和动态代理

通用写法：

public class Client{
  public static void main(String[] args){
    Proxy proxy = new Proxy(new RealSubject);
    proxy.request();
  }
}
​
//抽象主题角色
public interface ISubject{
  void request();
}
//代理主题角色
public class Proxy implements ISubject{
  private ISubject iSubject;
  public Proxy(ISubject iSubject){
    this.iSubject=iSubject;
  }
  public void request(){
    before();
    iSubject.request();
    after();
  }
  public void before(){
    System.out.println("called before request().");
  }
  public void after(){
    System.out.println("called after request().");
  }
}
//真实主题角色
public class RealSubject implements ISubject{
 
  public void request(){
    System.out.println("real service is called");
  }
}

举例：（静态代理）

举个例子，有些人到了适婚年龄，会被父母催婚。着急的父母为子女到处相亲。下面来看代码实现；

创建顶层接口IPerson代码如下：

package com.design.pattern.proxy;
​
public interface IPerson {
    void findLove();
}

儿子张三要找对象：

package com.design.pattern.proxy;
​
public class ZhangSan implements IPerson{
    @Override
    public void findLove() {
        System.out.println("儿子张三提出理想对象要求");
    }
}

父亲张老三帮忙相亲：

package com.design.pattern.proxy;
​
public class ZhangLaoSan implements IPerson{
​
    private IPerson iPerson;
​
    public ZhangLaoSan(IPerson iPerson) {
        this.iPerson = iPerson;
    }
    @Override
    public void findLove() {
        before();
        iPerson.findLove();
        after();
    }
    public void before(){
        System.out.println("张老三开始物色");
    }
    public void after(){
        System.out.println("开始交往");
    }
}

客户端代码：

package com.design.pattern.proxy;
​
public class Client {
    public static void main(String[] args) {
        ZhangLaoSan zhangLaoSan = new ZhangLaoSan(new ZhangSan());
        zhangLaoSan.findLove();
    }
}

结果：

张老三开始物色
儿子张三提出理想对象要求
开始交往

分析：

上面有个弊端，就是自己父母只能帮自己子女相亲，别人家孩子不会管的。如果在使用静态代理代理其他人相亲成本就比较大。因此就出现了动态代理。

JDK动态代理：

对于上个例子来说：首先创建媒婆婚介所JdkMeiPo:

package com.design.pattern.proxy;
​
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
​
public class JDKMeiPo implements InvocationHandler {
    private IPerson target;
​
    public IPerson getInstance(IPerson target){
        this.target = target;
        Class<? extends IPerson> clazz = target.getClass();
        return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(this.target, args);
        after();
        return result;
    }
    private void before(){
        System.out.println("我是媒婆，已经收集到你的需求，开始物色！");
    }
    private void after(){
        System.out.println("双方同意，开始交往！");
    }
}

然后创建一个LiSi类：

package com.design.pattern.proxy;
​
public class LiSi implements IPerson{
    @Override
    public void findLove() {
        System.out.println("符合预期！！");
    }
}

客户端代码：

package com.design.pattern.proxy;
​
public class Client1 {
    public static void main(String[] args) {
        JDKMeiPo jdkMeiPo = new JDKMeiPo();
        IPerson LiSi = jdkMeiPo.getInstance(new LiSi());
        LiSi.findLove();
    }
}

结果：

我是媒婆，已经收集到你的需求，开始物色！
符合预期！！
双方同意，开始交往！

CGLib动态代理：

还是以媒婆为例，创建CglibMeiPo

package com.design.pattern.proxy;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
​
import java.lang.reflect.Method;
​
public class CglibMeiPo implements MethodInterceptor{
​
    public Object getInstance(Class<?> clazz){
        //相当于jdk中的proxy类，是完成代理的工具类
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object obj = methodProxy.invokeSuper(o, objects);
        after();
        return obj;
    }
​
    private void after() {
        System.out.println("双方同意，准备婚事");
    }
​
    private void before() {
        System.out.println("我是媒婆，确认你的需求，");
        System.out.println("开始给你找对象");
    }
}

创建客户类：

package com.design.pattern.proxy;
​
public class Customer {
    public void findLove(){
        System.out.println("看对眼！");
    }
}

客户端测试：

package com.design.pattern.proxy;
​
public class Clinet2 {
    public static void main(String[] args) {
        //JDK采用读取接口的信息
        //CGLib覆盖父类的方法
        //目的都是生成一个新的类，去实现增强代码的逻辑
        //JDK Proxy对于用户而言，必须要有一个接口实现，目标类相对来说复杂
        //CGLib可以代理任何一个普通类，没有任何要求
        //CGLib生成代理的逻辑更加复杂，调用率更高，生成一个包含了所有逻辑的FastClass。不再需要反射调用
        //JDK Proxy生成代理的逻辑简单，执行效率相对要低，每次都要反射动态调用
        //CGLib又一个缺点，不能代理final方法
        Customer obj = (Customer) new CglibMeiPo().getInstance(Customer.class);
        //System.out.println(obj);
        obj.findLove();
    }
}

结果：

我是媒婆，确认你的需求，
开始给你找对象
看对眼！
双方同意，准备婚事

CGLib和JDK动态代理对比：

1. JDK动态代理实现了被代理对象的接口，CGLib动态代理继承了被代理对象

2. JDK动态代理和CGLib动态代理都在运行期生成字节码，JDK动态代理直接写Class字节码，CGLib使用ASM框架写Class字节码，CGLib动态代理实现更复杂，生成代理类比JDK动态代理效率低

3. JDK动态代理调用代理方法是通过反射机制调用的，CGLib动态代理是通过FastClass机制直接调用方法，CGLib动态代理执行效率更高

静态代理与动态代理的区别：

1. 静态代理只能通过手动完成代理操作，如果被代理类增加了新的方法，则代理类需要同步增加，违背了开闭原则。

2. 动态代理采用在运行时动态生成代码的方式，取消了对被代理的扩展限制，遵循开闭原则

3. 若动态代理要对目标类的增加逻辑进行扩展，结合策略模式，只需要新增策略类便可以完成，无需修改代理类的代码

代理模式优点：

1. 代理模式能将代理对象与真实被调用目标对象分离

2. 在一定程度上降低了系统的耦合性，扩展性更好

3. 可以起到保护目标对象的作用

4. 可以增强目标对象的功能

代理模式的缺点：

1. 代理模式会造成系统设计中类的数量的增加

2. 在客户端和目标对象中增加一个代理对象，会导致处理请求的速度变慢

3. 增加了系统的复杂度