结构型模式--代理模式【Proxy Pattern】

代理模式

• 给某一个对象提供一个代理，并由代理对象控制对原对象的引用。
• 为其他对象提供一种代理以控制对这个对象的访问。

分类

• 远程代理：为不同地理的对象提供局域网代表对象（例子：通过远程代理可以监控各个店铺，使之可以直观的了解店里的情况）

• 虚拟代理：根据需要将资源消耗很大的对象进行延迟，真正需要的时候进行创建 (类似于新闻网站加载时，图片加载不出来先用一张空的图片代替)

• 保护代理：控制用户的访问权限

• 智能引用代理：提供对目标对象提供额外的服务（火车票代售处）

代理模式的实现方式

• 静态代理
• 动态代理

代理模式应用场合

系统启动时的延迟加载
远程调用的网络代理
考虑安全因素的安全代理
Spring AOP
C3P0数据库连接池

类图

• Subject接口的实现

public interface Subject {
  public void visit();
}

• 实现了Subject接口的两个类：

public class RealSubject implements Subject {

    private String name = "tianming";
    
    @Override
    public void visit() {
        System.out.println(name);
    }
}

public class ProxySubject implements Subject{

    private Subject subject;

    public ProxySubject(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void visit() {
        subject.visit();
    }
}

• 具体的调用如下

public class TestProxyPattern {

    public static void main(String[] args) {
        ProxySubject subject = new ProxySubject(new RealSubject());
        subject.visit();
    }
}

动态代理

Spring AOP的底层使用了两种代理机制

• JDK 的动态代理：针对实现了接口的类产生代理。
• CGlib 的动态代理：针对没有实现接口的类产生代理，应用的是底层的字节码增强的技术 生成当前类的子类对象

动态代理有别于静态代理，是根据代理的对象，动态创建代理类。这样，就可以避免静态代理中代理类接口过多的问题。动态代理的实现方式，是通过反射来实现的，借助Java自带的java.lang.reflect.Proxy,通过固定的规则生成【基于JDK的动态代理】。

其步骤如下：

1. 编写一个委托类的接口，即静态代理的（Subject接口）
2. 实现一个真正的委托类，即静态代理的（RealSubject类）
3. 创建一个动态代理类，实现java.lang.reflect.InvocationHandler接口，并重写该invoke方法
4. 在测试类中，生成动态代理的对象。

第一二步骤，和静态代理一样，不过说了。第三步，代码如下：

public class DynamicProxy implements InvocationHandler {
    private Object object;
    public DynamicProxy(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(">>>>before invoking");
        Object result = method.invoke(this.object, args);
        System.out.println(">>>>after invoking");
        return result;
    }
    
    // 返回一个被修改过的对象
    public static Object agent(Class interfaceClazz, Object proxy) {
        return Proxy.newProxyInstance(interfaceClazz.getClassLoader(), new Class[]{interfaceClazz},
                new DynamicProxy(proxy));
    }
}

第四步，创建动态代理的对象

//注意一定要返回接口，不能返回实现类否则会报错
Subject subject = (Subject) DynamicProxy.agent(Subject.class, new RealSubject());
subject.visit();

创建动态代理的对象，需要借助Proxy.newProxyInstance。该方法的三个参数分别是：

1. ClassLoader loader表示当前使用到的classloader。
2. Class<?>[] interfaces表示目标对象实现的一组接口。
3. InvocationHandler h表示当前的InvocationHandler实现实例对象。

可以看到对于不同的实现类来说，可以用同一个动态代理类来进行代理，实现了“一次编写到处代理”的效果。但是这种方法有个缺点，就是被代理的类一定要是实现了某个接口的，这很大程度限制了本方法的使用场景。

框架应用

• MyBatis之MapperMethod

---

参考文档：

1. https://www.cnblogs.com/qifengshi/p/6566752.html
2. https://www.cnblogs.com/puyangsky/p/6218925.html