手把手教你学设计模式-动态代理（JDK和CGLIB）

---

前言

在上一章讲解了 静态代理，通过一个例子，我们理解了为什么要用静态代理，又或者是何时使用静态代理。但是他的劣势也比较明显的，我们在开发态对代理方法进行编码增强，当我们的接口A发生变动时（增减方法），被代理类B和代理类P也需要进行变动（强制实现方法），如果我们忘记维护它们，那么就会产生编译时错误，甚至可能会引发一系列线上问题的出现。

---

应用场景

假设我们有一个UserService接口包含save和delete方法，有一个UserServiceImpl的实现类。现在有一个需求，要求UserService被调用前后要增加日志记录。

当时，我们可以使用静态代理，通过持有一个UserServiceImpl的实例，代理类去实现UserService接口并实现接口方法，在每个方法中前后加上日志，在调用被代理类的方法，从而实现这个功能。可以看到，目前我们只有save和delete方法，所以感觉没什么不合理的，也很容易实现。但是如果我们后期增加了update方法，这时候我们需要在代理类中再去实现update方法，每当我们增减方法，都需要改动代理类，这就是静态代理的劣势，静态就是所谓在编译器要将被代理和被代理方法确定，而我们使用动态代理便不会出现这种情况。

使用静态方法实现

//接口
public interface UserService {

    void save();

    void delete();

}
//实现类
public class UserServiceImpl implements UserService{
    @Override
    public void save() {
        System.out.println("增加一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除一个用户");
    }

}

//代理类
public class UserServiceProxy implements UserService{

    private UserService userService;

    public UserServiceProxy(UserService userService){
        this.userService = userService;
    }

    @Override
    public void save() {
        System.out.println("=====log start=====");
        userService.save();
        System.out.println("=====log end=====");
    }

    @Override
    public void delete() {
        System.out.println("=====log start=====");
        userService.delete();
        System.out.println("=====log end=====");
    }
}

//调用方
public static void main(String[] args) {
        UserServiceProxy userServiceProxy = new UserServiceProxy(new UserServiceImpl());
        userServiceProxy.save();
        userServiceProxy.delete();
    }

//输出
=====log start=====
增加一个用户
=====log end=====
=====log start=====
删除一个用户
=====log end=====

具体案例

JDK动态代理

//处理器实现
public class UserServiceHandler implements InvocationHandler {

    private UserService userService;

    public UserServiceHandler(UserService userService){
        this.userService = userService;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("=====log start=====");
        method.invoke(userService,args);
        System.out.println("=====log end=====");
        return null;
    }
}

使用JDK动态代理，需要去实现 InvocationHandler 接口，重写 invoke方法在其中进行增强。你可以把它理解为是一个方法拦截器，当你通过代理去调用方法时，会去拦截它，然后调用 invoke，到invoke后就交给你处理了,相当于是拦截被代理类的所有方法。

到这里我们就使用JDK动态代理去实现了功能，如果我们的 UserService 增加了方法，我们也不必去进行重写，如果有特殊需求可以在 invoke中去实现。

//调用方
public static void main(String[] args) {
        UserServiceHandler handler = new UserServiceHandler(new UserServiceImpl());
        //使用JDK动态代理去创建代理类
        UserService service = (UserService)Proxy.newProxyInstance(UserServiceHandler.class.getClassLoader(), new Class[]{UserService.class}, handler);
        service.save();
        service.delete();
    }

在这里简单说一下，我们使用 Proxy.newInstance()去创建代理类时，实际上是使用 反射创建一个匿名接口实现类 ，之后使用我们传入的 ClassLoader将代理类加载到JVM，最终创建实例对象。

在生成的代理类中，会在每个方法中都去调用我们实现的 Handler中的 invoke方法。
通过大概的讲述，我们也就知道为什么JDK的动态代理只支持 接口级别的了吧，因为JDK是通过反射生成的匿名代理类实现目标接口的，所以如果被代理没没有实现接口的话，JDK动态代理是无法使用的，当然这只是JDK动态的实现。在CGLIB中是支持 类级别的，是采用ASM动态字节码技术去实现的。

如果大家想了解更多原理，后续我会专门出一期去讲解 JDK 和 CGLIB 动态代理的源码以及原理。

//输出
=====log start=====
增加一个用户
=====log end=====
=====log start=====
删除一个用户
=====log end=====

CGLIB动态代理

首先，CGLIB不是jdk提供的，所以需要引入CGLIB依赖，maven坐标如下:

<dependency>
   <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.9<</version>
</dependency>

接下来看一下如何简单使用，跟JDK动态代理类似，也是需要创建一个方法拦截器，之后使用增强器创建代理对象，从而实现方法的增强。

//方法拦截器
public class UserServiceMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("=====log start=====");
        methodProxy.invokeSuper(o,objects);
        System.out.println("=====log end=====");
        return null;
    }
}

//调用方
public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        //设置被代理类 通过继承方式实现，所以无需实现接口
        enhancer.setSuperclass(UserServiceImpl.class);
        //设置方法拦截器
        enhancer.setCallback(new UserServiceMethodInterceptor());
        //生成代理类
        UserServiceImpl proxy = (UserServiceImpl)enhancer.create();
        proxy.save();
        proxy.delete();
}

这是一个简单的使用，可以看到和JDK动态代理的使用方式差别不大，总归说来都是思路都是使用动态字节码技术生成代理类，通过代理类去拦截被代理类的方法，从而完成方法增强。
后续也会出一期专门讲解CGLIB原理和源码，有兴趣可以关注后续。

//输出
=====log start=====
增加一个用户
=====log end=====
=====log start=====
删除一个用户
=====log end=====

---

总结

总体来说，使用方法都是差不多的，大家要做的是去学习这种思想，对于动态代理的话就是一种思想，并不是一种固定的写法，所以大家应该去合理的学习。就像JDK动态代理和CGLIB动态代理，他只是对于 动态代理这种设计模式的实现，
我们要学的应该是 设计模式的灵魂，使用很简单，难的是学会这种思想，并合理运用，从而达到简化代码、提高代码可读性。

接下来简单看一下这两种实现的区别吧

\	JDK动态代理	CGLIB动态代理
底层实现	JDK Proxy(反射)	ASM
需实现接口	是	否

我认为CGLIB是比JDK要更加灵活，因为CGLIB底层使用ASM框架去实现的，可操作性更高一些，可以做一些定制化的。而jdk使用的是反射，相比之下就会有一些限制。对于性能方便，个人认为CGLIB要比JDK更加好一些，因为我们都知道反射会非常消耗性能，很多规范手册也会表明尽量少用反射，但是总是会优化进步的，这不能一棒子打死。我说的并不一定是对的，如果各位对文章货观点有疑问非常欢迎各位指教。
注：个人观点，不喜勿喷