Java静态代理与动态代理

前言

最近在学习设计模式，个人觉得代理模式比较重要，就在网上找了很多代理模式相关的知识点，总结如下，希望可以帮到有需要的小伙伴 :)

一、代理模式

定义：代理模式，顾名思义就是提供一个代理类，可以访问原对象并且替原对象进行一些操作。
优点：使用代理模式可以在保证不修改原有类的同时（即满足对扩展开放，对修改关闭的原则），对原有类增加一些功能实现。

二、静态代理

定义：静态代理就是在编译时就确定了代理类与被代理类的关系。
实现思路：定义一个接口 Subject，定义一个目标类 RealSubject 和一个代理类 ProxySubject同时实现 Subject 这个接口，在代理类 ProxySubject中持有目标类RealSubject对象，并对目标类RealSubject对象的方法进行一些增强实现。代码如下：
Subject 接口

public interface Subject {
    public void doSomething();
}

目标类 RealSubject

/**
 * 目标类
 *
 * @Author Marshal
 * @Date 2019-05-20 23:09
 */
public class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("This is RealSubject~s method!");
    }
}

代理类 ProxySubject

/**
 *  代理类
 *
 * @Author Marshal
 * @Date 2019-05-20 23:09
 */
public class ProxySubject implements Subject {

    // 持有目标对象
    private RealSubject realSubject;

    public ProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void doSomething() {
        // 在被代理对象的方法前后增加业务
        before();
        realSubject.doSomething();
        after();
    }

    private void after() {
        System.out.println("after proxy");
    }

    private void before() {
        System.out.println("before proxy");
    }
}

测试类

public class ProxyTest {
    public static void main(String[] args) {
        Subject subject = new ProxySubject(new RealSubject());
        subject.doSomething();
    }
}

输出结果如下：

before proxy
This is RealSubject~s method!
after proxy

总结

优点：

代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用
代理对象可以扩展目标对象的功能
代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度

缺点：

因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护

PS: 静态代理的缺点，可以通过动态代理来解决。

三、动态代理

定义：代理类在程序运行时创建的代理方式被称为动态代理。也就是说，代理类并不需要在Java代码中定义，而是在运行时动态生成的。相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类的函数。
Java的动态代理主要有两种，即JDK代理和Cglib代理

3.1 JDK代理

使用JDK动态代理有一个很大的限制，就是它要求目标类必须实现了对应方法的接口，它只能为接口创建代理实例。
我们继续接着使用上面的类，JDK代理类需要实现InvocationHandler接口，通过实现该接口定义横切逻辑，并通过反射机制调用目标类的代码，动态的将横切逻辑和业务逻辑编织在一起。代码如下：

JDKProxyjdk代理类：

/**
 *  动态代理之JDK代理
 *
 * @Author Marshal
 * @Date 2019-05-20 23:15
 */
public class JDKProxy implements InvocationHandler {

    // 目标对象
    private Object object;

    public JDKProxy(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("-----------JDKProxy before------------");
        Object invoke = method.invoke(object, args);
        System.out.println("-----------JDKProxy after------------");
        return invoke;
    }
}

测试类：

/**
 * @Author Marshal
 * @Date 2019-05-21 21:39
 */
public class JDKProxyTest {

    public static void main(String[] args) {

        // 被代理的类
        RealSubject realSubject = new RealSubject();
        // 代理类
        JDKProxy jdkProxy = new JDKProxy(realSubject);
        // 生成代理对象
        Subject subject = (Subject) Proxy.newProxyInstance(RealSubject.class.getClassLoader(), new Class[]{Subject.class}, jdkProxy);

        subject.doSomething();
    }
}

测试

-----------JDKProxy before------------
This is RealSubject~s method!
-----------JDKProxy after------------

3.2 cglib代理

使用cglib实现动态代理，并不要求委托类必须实现接口，底层采用asm字节码生成框架生成代理类的字节码，我们需要导入 cglib-nodep-3.2.6.jar 包。实现步骤如下：

新建一个目标类CglibRealSubject

public class CglibRealSubject {

    public void doSomething() {
        System.out.println("This is CglibRealSubject~s method!");
    }
}

代理类CglibProxy实现MethodInterceptor接口并重写intercept方法

/**
 *  Cglib代理
 *  cglib-nodep-3.2.6.jar : https://github.com/cglib/cglib/releases/tag/RELEASE_3_2_6
 *
 * @Author Marshal
 * @Date 2019-05-22 21:23
 */
public class CglibProxy implements MethodInterceptor {


    public Object getProxyInstance(Class cla) {
        // 1. 工具类
        Enhancer en = new Enhancer();
        // 2. 设置父类
        en.setSuperclass(cla);
        // 3. 设置回调函数
        en.setCallback(this);
        // 4. 创建子类（代理对象）
        return en.create();
    }

    @Override
    public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy)
            throws Throwable {
        System.out.println("-------------Before CglibProxy-------------");
        // 目标方法调用
        Object invoke = methodProxy.invokeSuper(object, args);
        System.out.println("-------------After CglibProxy-------------");
        return invoke;
    }
}

测试

public class CglibProxyTest {
    public static void main(String[] args) {
        CglibProxy proxy = new CglibProxy();
        CglibRealSubject realSubject = (CglibRealSubject) proxy.getProxyInstance(CglibRealSubject.class);
        realSubject.doSomething();
    }
}

输出结果

-------------Before CglibProxy-------------
This is CglibRealSubject~s method!
-------------After CglibProxy-------------

3.3 动态代理的应用

动态代理主要运用于框架中，例如在Spring的AOP中:

如果加入容器的目标对象有实现接口,使用JDK代理
如果目标对象没有实现接口,则使用Cglib代理