大型Java进阶专题(六) 设计模式之代理模式

代理模式

前言

又开始我的专题了，又停滞了一段时间了，加油继续吧。都知道 SpringAOP 是用代理模式实现，到底是怎么实现的？我们来一探究竟，并且自己仿真手写还原部分细节。

代理模式的应用

在生活中，我们经常见到这样的场景，如：租房中介、售票黄牛、婚介、经纪人、快递、 事务代理、非侵入式日志监听等，这些都是代理模式的实际体现。代理模式（Proxy Pattern）的定义也非常简单，是指为其他对象提供一种代理，以控制对这个对象的访问。 代理对象在客服端和目标对象之间起到中介作用，代理模式属于结构型设计模式。使用 代理模式主要有两个目的：一保护目标对象，二增强目标象。下面我们来看一下代理 模式的类结构图：

Subject 是顶层接口，RealSubject 是真实对象（被代理对象），Proxy 是代理对象，代 理对象持有被代理对象的引用，客户端调用代理对象方法，同时也调用被代理对象的方 法，但是在代理对象前后增加一些处理。在代码中，我们想到代理，就会理解为是代码 增强，其实就是在原本逻辑前后增加一些逻辑，而调用者无感知。代理模式属于结构型 模式，有静态代理和动态代理。

静态代理

举个例子：人到了适婚年龄，父母总是迫不及待希望早点抱孙子。而现在社会的人在各 种压力之下，都选择晚婚晚育。于是着急的父母就开始到处为自己的子女相亲，比子女 自己还着急。这个相亲的过程，就是一种我们人人都有份的代理。来看代码实现： 

/**
 * 人很多行为，要谈恋爱
 */
public interface Person {
    void findLove();
}


/**
 * 儿子需要找对象
 */
public class Son implements Person {

    @Override
    public void findLove() {
        System.out.println("工作没时间！");
    }
}

/**
 * 父亲代理儿子 先帮物色对象
 */
public class Father{

    private Son son;

    //代理对象持有 被代理对象的应用 但没办法扩展
    private Father(Son son) {
        this.son = son;
    }

    private void findLove() {
        //before
        System.out.println("父母帮物色对象");
        son.findLove();
        //after
        System.out.println("双方同意交往！");
    }

    //测试代码
    public static void main(String[] args) {
        Son son = new Son();
        Father father = new Father(son);
        father.findLove();
    }
}

动态代理

动态代理和静态对比基本思路是一致的，只不过动态代理功能更加强大，随着业务的扩 展适应性更强。如果还以找对象为例，使用动态代理相当于是能够适应复杂的业务场景。 不仅仅只是父亲给儿子找对象，如果找对象这项业务发展成了一个产业，进而出现了媒 婆、婚介所等这样的形式。那么，此时用静态代理成本就更大了，需要一个更加通用的 解决方案，要满足任何单身人士找对象的需求。我们升级一下代码，先来看 JDK 实现方式：

JDK 实现方式

创建媒婆（婚介）JDKMeipo 类：

package com.study;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


public class JdkMeipo implements InvocationHandler {
  	//持有被代理对象的引用
    Object target;

    public Object getInstance(Object target){
        this.target =target;
        Class<?> aClass = target.getClass();
        return Proxy.newProxyInstance(aClass.getClassLoader(),aClass.getInterfaces(),this);
    }
  
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object object = method.invoke(this.target,args);
        after();
        return object;
    }

    private void before() {
        System.out.println("我是婚介，帮你物色对象");
    }

    private void after() {
        System.out.println("已找到，如果合适就开始");
    }
}

创建单身客户

package com.study;

public class Customer implements Person{

    @Override
    public void findLove() {
        System.out.println("我要找白富美");
    }
}

测试代码

package com.study;

public class DemoTest {
    public static void main(String[] args) {
        Person person = (Person) new JdkMeipo().getInstance(new Customer());
        person.findLove();
    }
}

执行效果

Jdk代理的原理

不仅知其然，还得知其所以然。既然 JDK Proxy 功能如此强大，那么它是如何实现的呢？ 我们现在来探究一下原理。 我们都知道 JDK Proxy 采用字节重组，重新生的对象来替代原始的对象以达到动态代理 的目的。JDK Proxy 生成对象的步骤如下：

1.拿到代理对象的应用，并获取它的所有接口，反射获取。

2.通过JDK proxy 类重新生成一个新的类，同时新的类要实现被代理类所有实现的接口。

3.动态生成Java代码，把新加的业务逻辑方法由一定的逻辑代码去调用（在代码中体现）。

4.编译重新生成Java代码.class

5.再重新加载的JVM中
以上这个过程就叫字节重组。

CGLib实现方式

简单看一下 CGLib 代理的使用,还是以媒婆为例，创建 CglibMeipo 类：

package com.study;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CGlibMeipo implements MethodInterceptor {
    Object target;
    public Object getInstance(Class<?> aClass){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(aClass);
        enhancer.setCallback(this);
        return enhancer.create();
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object invokeSuper = methodProxy.invokeSuper(o, objects);
        after();
        return invokeSuper;
    }

    private void after() {
        System.out.println("已找到，如果合适就开始");
    }

    private void before() {
        System.out.println("我是婚介，帮你物色对象");
    }
}

测试调用

package com.study;

public class DemoTest {
    public static void main(String[] args) {
        //Person person = (Person) new JdkMeipo().getInstance(new Customer());
        Person person = (Person) new CGlibMeipo().getInstance(Customer.class);
        person.findLove();
    }
}

执行结果：（CGLib代理的对象是不需要实现任何接口的，他是通过动态继承目标对象实现的动态代理。）

CGLib 动态代理执行代理方法效率之所以比 JDK 的高是因为 Cglib 采用了 FastClass 机 制，它的原理简单来说就是：为代理类和被代理类各生成一个 Class，这个 Class 会为代 理类或被代理类的方法分配一个 index(int 类型)。这个 index 当做一个入参，FastClass 就可以直接定位要调用的方法直接进行调用，这样省去了反射调用，所以调用效率比 JDK 动态代理通过反射调用高。

CGLib 和 JDK 动态代理对比

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

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

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