cglib 入门前篇

cglib 是一个功能强大、高性能、高质量的字节码操作库，主要用于在运行时扩展 Java 类或者根据接口生成对象。

cglib 在一些开源框架中使用很广泛，比如 Spring，数据库开源库 Hibernate，以及测试框架 mockito。正是因为 cglib 把脏活累活都干了，这些框架使用才很方便。

这是一个开源的库，cglib 本身的实现基于 asm 库。相比于 asm 库，cglib 的接口更友好，使用起来更简单。

下面介绍 cglib 的主要接口和类以及基于 cglib 的动态代理实现。

💡本文基于 OpenJDK11

1. Enhancer

首先要说到的就是 Enhancer 这个类，这个是 cglib 中使用的最多的类。之前 JDK 中使用反射来实现动态代理时，必须要基于接口来生成动态代理类，而 Enhancer 可以直接基于类来代理类。

Enhancer 可以生成被代理类的子类，并且拦截所有方法的调用，也就是通常所说的增强。

需要注意，Enhancer 不能增强构造函数，也不能增强被 final 修饰的类，或者被 static 和 final 修饰的方法。

如果不想直接生成一个对象，cglib 也可以生成一个 Class 对象，用这个 Class 对象生成对象或者其他操作。

Enhancer 的使用分为两步，传入目标类型，设置回调。支持不同类型回调是 cglib 最强大的地方。

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(HelloImpl.class);
//enhancer.setInterfaces(HelloImpl.class.getInterfaces()); // 也可以使用接口
enhancer.setCallback(...); // 设置回调

在 Enhancer 创建一个代理类之后所实现的行为要通过这些回调来实现。

常见的的回调类型如下：

FixedValue：返回一个固定的值
InvocationHandler：增强方法，添加额外的功能
MethodInterceptor：与 InvocationHandler 功能类似，但是控制的权限更多
LazyLoader：可以延迟加载被代理的对象，而且每个对象只会被创建一次
Dispatcher：与 LazyLoader 功能基本相同，但是在获取对象时，每次都会创建不同的对象
ProxyRefDispatcher：与 Dispatcher 功能类似，但是会多一个被代理对象的参数
NoOp：什么也不做

FixedValue

对于 FixedValue 类型的回调，调用所有的方法都会返回这个固定的值，如果类型不匹配，就会报错。

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(HelloImpl.class);
enhancer.setCallback(new FixedValue() {
    @Override
    public Object loadObject() throws Exception {
        System.out.println("Hello cglib");
        return "Hello cglib";
    }
});

HelloImpl proxy = (HelloImpl) enhancer.create();
proxy.sayHello("ray"); // 会打印 Hello cglib

除了 static 和 final 类型的方法，其他所有的方法都会执行上面的代码，打印 Hello cglib。但是需要注意的是，如果某个方法返回的类型和上面的代理行为不一致就会报错，java.lang.Object 中的方法也是一样。

proxy.hashCode(); // java.lang.ClassCastException

InvocationHandler

看到这个是不是很熟悉，这个与 JDK 反射自带的 InvocationHandler 基本一致。

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(HelloImpl.class);
enhancer.setCallback(new InvocationHandler() {
    @Override
    public Object invoke(Object proxy, Method method, Object[] objects) throws Throwable {
        if (method.getReturnType() == String.class) {
            System.out.println("Hello cglib");
            return "Hello cglib";
        } else {
            System.out.println("Invoke other method");
            return method.invoke(proxy, objects); // 这里可能会出现无限循环
        }
    }
});

HelloImpl proxy = (HelloImpl) enhancer.create();
proxy.sayHello("ray");

只想改变其中部分方法的行为，其他的方法还的行为不变，最简单的思路就是如果不是目标方法就会调用本来的实现，假设要调用 hashcode() 方法：

proxy.hashCode();

这个代码并不会正常返回结果，而是进入无限循环，这是因为这个代理对象的每一个可以被代理的方法都被代理了，在调用被代理了的方法时，会重复进入到 InvocationHandler#invoke 这个方法中，然后进入死循环。

解决办法如下。

MethodInterceptor

在 MethodInterceptor 中，有一个 MethodProxy 参数，这个就可以用来执行父类方法。

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(HelloImpl.class);
enhancer.setCallback(new MethodInterceptor() {
    @Override
    public Object intercept(Object o, Method method, Object[] params, MethodProxy methodProxy) throws Throwable {
        if (method.getReturnType() == String.class) {
            System.out.println("Hello cglib");
            return "Hello cglib";
        } else {
            return methodProxy.invokeSuper(o, params); // 对上面无限问题的改善
        }
    }
});

HelloImpl proxy = (HelloImpl) enhancer.create();
proxy.sayHello("ray");
proxy.hashCode(); // 这个时候，调用 hashcode 方法就可以正常工作了

LazyLoader

用来延迟加载对象。

在下面这个例子中，使用 LazyLoader 来延迟加载一个 ArrayList 对象。

public class HelloImpl implements Hello {

    private ArrayList<String> data;

    public ArrayList<String> getData() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(ArrayList.class);
        enhancer.setCallback(new LazyLoader() {
            @Override
            public Object loadObject() throws Exception {
                System.out.println("Begin invoke lazyloader");
                ArrayList<String> data = new ArrayList<>();
                data.add("hello");
                data.add("cglib");
                System.out.println("End invoke lazyloader");
                return data;
            }
        });

        return (ArrayList<String>) enhancer.create();
    }
}

HelloImpl helloImpl = new HelloImpl();
ArrayList<String> data = helloImpl.getData(); // 在调用这个方法的时候，ArrayList 不会被创建
System.out.println(data.get(0));
System.out.println(data.get(1)); // 每次调用都使用同一个对象，不会重复创建对象

上面代码的执行结果如下:

Begin invoke lazyloader
End invoke lazyloader
hello
cglib

在执行 data.get(0) 的时候，ArrayList 才会被创建，也就是说只有在被使用的，才会去创建对象，而且每个对象只会被创建一次。

Dispatcher

Dispatcher 与 LazyLoader 的不同之处在于，每次去获取对象的时候都会创建一个新的对象，而不是复用同一个对象。

public class HelloImpl implements Hello {

    private ArrayList<String> data;

    public ArrayList<String> getDataDispatcher() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(ArrayList.class);
        enhancer.setCallback(new Dispatcher() {
            @Override
            public Object loadObject() throws Exception {
                System.out.println("Begin invoke dispatcher");
                ArrayList<String> data = new ArrayList<>();
                data.add("hello");
                data.add("cglib");
                System.out.println("End invoke Dispatcher");
                return data;
            }
        });
        return (ArrayList<String>) enhancer.create();
    }
}

HelloImpl helloimpl = new HelloImpl();
ArrayList<String> data = helloimpl.getDataDispatcher();
System.out.println(data.get(0));
System.out.println(data.get(1));// 每次调用都会获取不同送的对象

上面代理的执行结果如下，每次使用对象都会创建一个新的对象。

Begin invoke dispatcher
End invoke Dispatcher
hello
Begin invoke dispatcher
End invoke Dispatcher
cglib

ProxyRefDispatcher

ProxyRefDispatcher 与 Dispatcher 功能类似，但是多了一个参数，使用这个回调同样要注意无限循环的问题。

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(HelloImpl.class);
enhancer.setCallback(new ProxyRefDispatcher() {
    @Override
    public Object loadObject(Object proxy) throws Exception {
        System.out.println("Invoke");
        return proxy.hashCode(); // 同样可能会导致无限循环
    }
});

HelloImpl proxy = (HelloImpl) enhancer.create();
proxy.hashCode(); // 这样调用会无限循环

NoOp

这个回调什么也不做，会完全继承被代理类的功能，所以 NoOp 不能使用接口来创建代理，只能使用类。

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(HelloImpl.class);
//enhancer.setInterfaces(HelloImpl.class.getInterfaces()); //不能使用接口，只能使用类
enhancer.setCallback(new NoOp() {
});

Hello proxy = (Hello) enhancer.create();
proxy.sayHello("Ray");

这个回调在一些特定的情况下还是挺有用的，看下面的例子。

CallbackFilter

在上面的例子中，都是给 Enhancer 设置了单个回调，其实每个 Enhancer 可以设置多个回调，这里就需要用到 CallbackFilter。

比如现在就需要对 sayHello 方法进行处理，其他的方法保持父类的行为就可以，按照这个要求，实现的 CallbackFilter 如下：

public class CallbackHelperImpl extends CallbackHelper {
    public CallbackHelperImpl(Class superclass, Class[] interfaces) {
        super(superclass, interfaces);
    }

    @Override
    protected Object getCallback(Method method) {
        if (method.getName() == "sayHello") { // 对这个方法就行增强，其他的方法不改变
            return new FixedValue() {
                @Override
                public Object loadObject() throws Exception {
                    System.out.println("Hello cglib");
                    return "Hello cglib";
                }
            };
        } else { // NoOp 就可以在这种情况下使用
            return new NoOp() {
            };
        }
    }
}

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(HelloImpl.class);
CallbackHelper callbackHelper = new CallbackHelperImpl(HelloImpl.class, null);
enhancer.setCallbackFilter(callbackHelper);
enhancer.setCallbackTypes(callbackHelper.getCallbackTypes());
enhancer.setCallbacks(callbackHelper.getCallbacks());

HelloImpl proxy = (HelloImpl) enhancer.create();

proxy.sayHello("Ray"); 
proxy.hashCode(); // 其他方法的调用不受影响

调用结果如下，只有 sayHello 方法会被拦截，其他的方法不会有变动。

Hello cglib
1647766367

2. 实现动态代理

上面介绍了 Enhancer 之后，实现动态代理应该就不难了。

InvocationHandler 和 MethodInterceptor 都可以用来实现动态代理，下面是两种实现。

InvocationHandler 实现

public class CGlibHelloProxyInvocationHandler implements InvocationHandler {

    private Object target;

    public Object bind(Object obj) {
        Enhancer enhancer = new Enhancer();
        enhancer.setInterfaces(obj.getClass().getInterfaces());
        //enhancer.setSuperclass(obj.getClass().getSuperclass());
        this.target = obj;
        enhancer.setCallback(this);
        return enhancer.create(); // 生成代理类
    }

    @Override
    public Object invoke(Object o, Method method, Object[] params) throws Throwable {
        long begin = System.currentTimeMillis();
        Object result = method.invoke(target, params);
        System.out.printf("Invoke time " + (System.currentTimeMillis() - begin) + " ms");
        return result;
    }
}

使用上面的实现来创建代理并调用方法：

HelloImpl helloImpl = new HelloImpl();

CGlibHelloProxyInvocationHandler helloProxyInvocationHandler = new CGlibHelloProxyInvocationHandler();
Hello proxy = (Hello) helloProxyInvocationHandler.bind(helloImpl);

proxy.sayHello("ray");

这里需要注意，如果使用接口创建代理对象，第一行代码使用 Hello helloImpl = new HelloImpl() 或者 HelloImpl helloImpl = new HelloImpl() 创建对象传入都可以，如果使用是父类创建代理对象，那么只能使用第二种。

MethodInceptor 实现

public class CGlibHelloProxyMethodInterceptor implements MethodInterceptor {

    private Object target;

    public Object bind(Object obj) {
        Enhancer enhancer = new Enhancer();
        enhancer.setInterfaces(obj.getClass().getInterfaces());
        //enhancer.setSuperclass(obj.getClass());
        this.target = obj;
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] params, MethodProxy methodProxy) throws Throwable {
        long begin = System.currentTimeMillis();
        Object result = method.invoke(target, params);
        System.out.printf("Invoke time " + (System.currentTimeMillis() - begin) + " ms");
        return result;
    }
}

然后创建代理对象并调用：

HelloImpl hello = new HelloImpl();

CGlibHelloProxyMethodInterceptor cGlibHelloProxy = new CGlibHelloProxyMethodInterceptor();
HelloImpl proxyObject = (HelloImpl) cGlibHelloProxy.bind(hello);

proxyObject.sayHello("ray");

通常来说，使用 MethodInceptor 方式来实现更好，因为可以避免出现上面说到的无限循环的问题。

cglib 相比于 Java 反射实现动态代理的优势就是不受类的限制，可以自由的选择根据接口或者类来生成新的代理对象。

cglib 中的 Proxy

在 JDK 中，动态代理主要由 java.lang.reflect.Proxy 来实现，在 cglib 中，同样也实现了 Proxy，功能于 JDK 中的功能基本一致，其中用到的 InvocationHandler 就是前面介绍的回调。

这样做是为了 JDK1.3 以前的版本也能使用动态代理的功能。

3. 总结

这篇文章主要介绍了 cglib 的如果通过 Enhancer 去生成代理类，可以同时支持接口和子类的两种方式**。**同时也介绍了通过 Enhancer 来实现动态代理。

cglib 的能力远不止这些，下篇文章将介绍 cglib 的其他功能。

REF

[1] dzone.com/articles/cg…

文 / Rayjun