cglib代理

简介：

　　github地址：https://github.com/cglib/cglib，可以访问这个地址查看cglib源码和相关文档。

　　简单的摘录了wiki上关于cglib的描述：

　　cglib is a powerful, high performance and quality Code Generation Library,It is used to extend JAVA classes and implements interfaces at runtime.

　　重点是后面这句话：它用于在【运行时】扩展JAVA类并实现接口。这也就是动态代理的精髓吧。

　　我们都知道，动态代理可以通过jdk动态代理，那和cglib有什么区别呢。第一，jdk动态代理的对象必须实现了某个接口，所代理的对象是实现了某个接口的所有类。

　　而cglib并没有这个要求。第二，cglib的效率比jdk要高许多。

下面介绍一个梨子：

首先定义一个目标类

package demo.cglib;

public class Target {
    
    public void first() {
        System.out.println("first");
    }
    
    public void second() {
        System.out.println("second");
    }
    
    public void third() {
        System.out.println("third");
    }
    
    public String toString() {
        return "target class";
    }
}

然后我们需要为目标类写一个方法拦截类。这个类需要实现MethodInterceptor接口，先看一下这个接口：

package net.sf.cglib.proxy;

/**
 * General-purpose {@link Enhancer} callback which provides for "around advice".
 * @author Juozas Baliuka <a href="mailto:baliuka@mwm.lt">baliuka@mwm.lt</a>
 * @version $Id: MethodInterceptor.java,v 1.8 2004/06/24 21:15:20 herbyderby Exp $
 */
public interface MethodInterceptor
extends Callback
{
    /**
     * All generated proxied methods call this method instead of the original method.
     * The original method may either be invoked by normal reflection using the Method object,
     * or by using the MethodProxy (faster).
     * @param obj "this", the enhanced object
     * @param method intercepted Method
     * @param args argument array; primitive types are wrapped
     * @param proxy used to invoke super (non-intercepted method); may be called
     * as many times as needed
     * @throws Throwable any exception may be thrown; if so, super method will not be invoked
     * @return any value compatible with the signature of the proxied method. Method returning void will ignore this value.
     * @see MethodProxy
     */    
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
                               MethodProxy proxy) throws Throwable;

}

这个接口只有一个方法，我们的具体代理增强逻辑就是在这个方法中实现的。

这里还有一个点，可以看到MethodInterceptor继承了Callback接口，那么我们来看看Callback接口的内容：

package net.sf.cglib.proxy;

/**
 * All callback interfaces used by {@link Enhancer} extend this interface.
 * @see MethodInterceptor
 * @see NoOp
 * @see LazyLoader
 * @see Dispatcher
 * @see InvocationHandler
 * @see FixedValue
 */
public interface Callback
{
}

嗯，它是个空接口，起到标志的作用，下面具体实现增强类的时候会看到它

那么，了解了这些，开始写我们的拦截类把

package demo.cglib;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class TargetInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("method:"+method.getName()+" ---begain---");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("method:"+method.getName()+" ---end---");
        return result;
    }

}

这里只是写了简单的方法执行前后的简单操作，下面测试一下

package demo.cglib;

import net.sf.cglib.proxy.Enhancer;

public class DemoTest {
    public static void main(String[] args) {
        TargetInterceptor interceptor = new TargetInterceptor();
        Enhancer eh = new Enhancer();
        eh.setSuperclass(Target.class);
        eh.setCallback(interceptor);
        Target target = (Target)eh.create();
        
        target.first();
        target.second();
        target.third();
    }
}    

输出结果：

method:first ---begain---
first
method:first ---end---
method:second ---begain---
second
method:second ---end---
method:third ---begain---
third
method:third ---end---

到这里，似乎很完美了。我们代理只要实现MethodInterceptor接口的intercept方法，在里面实现我们的逻辑就好了。

但是，现在我有一个需求：当调用first()方法时，我不希望被代理。调用时second()执行我们的拦截类实现的代理逻辑，而当调用third()方法时，会有一个

默认的返回值。

这里你可能说，我直接在intercept方法里判断啊，当方法名是first时，当方法是second时....

这样做可以，但是不够优雅，而且像不被代理和返回默认值这样的方法。我们完全有理由在调用之初就被过滤掉，而不需要进入到intercept()这一层再去进行一个判断。

下面讲一下过滤的实现方式。首先介绍两个实现了Callback接口的接口：

package net.sf.cglib.proxy;

/**
 * Methods using this {@link Enhancer} callback will delegate directly to the
 * default (super) implementation in the base class.
 */
public interface NoOp extends Callback
{
    /**
     * A thread-safe singleton instance of the <code>NoOp</code> callback.
     */
    public static final NoOp INSTANCE = new NoOp() { };
}

这个类的意思就是No Operation，也就是不进行操作

 

package net.sf.cglib.proxy;

/**
 * {@link Enhancer} callback that simply returns the value to return
 * from the proxied method. No information about what method
 * is being called is available to the callback, and the type of
 * the returned object must be compatible with the return type of
 * the proxied method. This makes this callback primarily useful
 * for forcing a particular method (through the use of a {@link CallbackFilter}
 * to return a fixed value with little overhead.
 */
public interface FixedValue extends Callback {
    /**
     * Return the object which the original method invocation should
     * return. This method is called for <b>every</b> method invocation.
     * @return an object matching the type of the return value for every
     * method this callback is mapped to
     */
    Object loadObject() throws Exception;
}

这个接口需要实现loadObject，固定返回的类型

这里我们给它一个简单的实现，返回固定值 “dog” 字符串

package demo.cglib;

import net.sf.cglib.proxy.FixedValue;

public class TargetResultFixed implements FixedValue {

    @Override
    public Object loadObject() throws Exception {
        
        System.out.println("返回固定值");
        return "dog";
    }

}

 

还要实现一个过滤接口，先来看一下这个接口

package net.sf.cglib.proxy;

import java.lang.reflect.Method;

/**
 * Map methods of subclasses generated by {@link Enhancer} to a particular
 * callback. The type of the callbacks chosen for each method affects
 * the bytecode generated for that method in the subclass, and cannot
 * change for the life of the class.
 * <p>Note: {@link CallbackFilter} implementations are supposed to be
 * lightweight as cglib might keep {@link CallbackFilter} objects
 * alive to enable caching of generated classes. Prefer using {@code static}
 * classes for implementation of {@link CallbackFilter}.</p>
 */
public interface CallbackFilter {
    /**
     * Map a method to a callback.
     * @param method the intercepted method
     * @return the index into the array of callbacks (as specified by {@link Enhancer#setCallbacks}) to use for the method, 
     */
    int accept(Method method);

    /**
     * The <code>CallbackFilter</code> in use affects which cached class
     * the <code>Enhancer</code> will use, so this is a reminder that
     * you should correctly implement <code>equals</code> and
     * <code>hashCode</code> for custom <code>CallbackFilter</code>
     * implementations in order to improve performance.
    */
    boolean equals(Object o);
}

这里主要的实现逻辑在accept内，下面是实现类

package demo.cglib;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.CallbackFilter;

public class TargetMethodFilter implements CallbackFilter {

    @Override
    public int accept(Method method) {
        if(method.getName().equals("first")) {
            return 0;
        }
        if(method.getName().equals("second")) {
            return 1;
        }
        return 2;
    }

}

在这里说明一下，这里返回的数字代表着所调用的代理类的序号。之前我们已经看到过，代理增强需要设置Callback，就是上面的enhancer.setCallback()方法，但是上面

只用了一个拦截类。当有多个拦截类时，我们定义一个Callback数组，然后设置setCallbacks(),上面返回的数字，就代表所调用的对应数组中哪个拦截方式。

下面来测试一下

package demo.cglib;

import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.CallbackFilter;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.NoOp;

public class DemoTest {
    public static void main(String[] args) {
        TargetInterceptor interceptor = new TargetInterceptor();
        Callback resultFixed = new TargetResultFixed();
        Callback noOp = NoOp.INSTANCE;
        // 这里定义了拦截类数组
        Callback[] callbacks = {noOp,interceptor,resultFixed};
        //过滤逻辑类
        CallbackFilter filter = new TargetMethodFilter();
        Enhancer eh = new Enhancer();
        eh.setSuperclass(Target.class);
        // 设置拦截数组，过滤方法返回的整数将对应数组中的具体拦截类，然后被执行
        eh.setCallbacks(callbacks);
        eh.setCallbackFilter(filter);
        Target target = (Target)eh.create();
        
        target.first();
        target.second();
        target.third();
    }
}    

输出结果：

first
method:second ---begain---
second
method:second ---end---
返回固定值

当然上面介绍的知识cglib的一些简单的应用和原理，了解更过可以去github上参考项目源码和文档，当然更多的应该是

多去实践和测试。很多东西都是很简单的东西堆砌拼凑出伟大的东西，就像计算机不就是0和1么，但是无数的0和1各种不同的拼凑

就可以代表无穷的信息。从小到大，从简单到复杂，重要的是掌握原理和精髓。