死磕cglib系列之一 cglib简介与callback解析「建议收藏」

全栈程序员站长

发布于 2022-08-24 09:06:34

3190

发布于 2022-08-24 09:06:34

文章被收录于专栏：全栈程序员必看

大家好，又见面了，我是你们的朋友全栈君。

简介

cglib是一套java动态代理实现框架，cglib被应用到spring app,hibernate等高级业务框架，spring事务在业务实现类未实现接口的情况下也会使用该技术。

实际上，cglib基于继承实现，这也就意味着final,private相关的method无法被代理。基于asm框架对class字节码编辑改动，从而达到动态代理的目的，总之，被代理类没有实现接口的情况下cglib为首选

引用官网介绍的一段话：

Byte Code Generation Library is high level API to generate and transform JAVA byte code. It is used by AOP, testing, data access frameworks to generate dynamic proxy objects and intercept field access.

github地址：https://github.com/cglib/cglib

cglib作者博客：http://mydailyjava.blogspot.no/2013/11/cglib-missing-manual.html

以下案例在我的github中可以clone到，分支为howtocglib

github路径：https://github.com/zhang6622056/cglib

测试用例：cglib-sample/src/main/test/callback/Callbacktest

实现动态代理的几种方案

javasisit
jdk 动态代理
cglib
asm(cglib 内部也是用asm更改其字节码)

callbacks简介

这里的callback可以认为是cglib用于生成字节码的实现手段，cglib一共实现了6种callback，用于对代理类目标进行不同手段的代理，非常灵活，分别为：

FixedValue
InvocationHandler
LazyLoader
MethodInterceptor
Dispatcher
NoOp

编写实现案例

callbacks代码编写

Dispatcher

实现Dispatcher接口，要求实现loadObject方法，返回期望的代理类。值的一提的是，loadobject方法在每次调用被拦截方法的时候都会被调用一次

/**** * 与lazy不同的是，每一次调用代理方法的时候，都会调用一次Dispatcher的loadObject获取对象 * 而lazy则会缓存下来。 */
public class DispatcherCallBack implements Dispatcher { 
   
    public Object loadObject() throws Exception { 
   
        CallbackBean callbackBean = new CallbackBean();
        return callbackBean;
    }
}

FixedValue

实现FixedValue接口，该callback同样要求实现一个loadobject方法，只不过需要注意的是该loadobject方法相同与重写了被代理类的相应方法，因为在被代理之后，FixedValue callback只会调用loadobject，而不会再调用代理目标类的相应方法！

/***** * 该callback相当于重写了相应的函数实现。并不会调用原函数 */
public class FixValueCallback implements FixedValue { 
   


    /***** * 被代理方法的指定函数将会无条件的返回改object，动态的变更返回值 * @return * @throws Exception */
    public Object loadObject() throws Exception { 
   
        System.out.println("this is fixvalue callback ..... overwrite the code....");
        return true;
    }
}

InvocationHandler

需要实现InvocationHandler接口，实现invoke对象，该拦截传入了proxy对象，用于自定义实现，与MethodInterceptor相似，慎用method的invoke方法。切忌不要造成循环调用

public class InvocationHandlerCallback implements InvocationHandler { 
   
    /***** * invocationHandler的invoke方法传入的method和proxy都是代理本身对象 * 切忌重复调用，会循环调用 * @param proxy 代理类本身 * @param method 代理类内部的方法 * @param args 参数 * @return * @throws Throwable */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
   
        System.out.println("invocationHandlerCallback Before....");
        method.invoke(proxy.getClass().getSuperclass().newInstance(),args);
        //会无限循环
        //method.invoke(proxy,args);
        System.out.println("invocationHandlerCallback after....");
        return null;
    }
}

LazyLoader

实现LazyLoader的loadObject方法，返回对象实例，该实例只有第一次调用的时候进行初始化，之后不再重新调用，proxy类初始化时进行了成员的赋值，之后使用该成员进行调用父类方法

/**** * * 延迟加载初始化 * 类似于spring prototype的singleton ，在第一次调用的时候进行初始化，并且将此实例存储起来，之后都将返回改实例 * 可参考资料： * https://shensy.iteye.com/blog/1881277 */
public class LazyLoaderCallback implements LazyLoader { 
   
    public Object loadObject() throws Exception { 
   
        CallbackBean callbackBean = new CallbackBean();
        return callbackBean;
    }
}

MethodInterceptor

实现MethodInterceptor的intercept，实现被代理对象的逻辑植入。也是最常用的callback

/**** * 生成代理类字节码。对方法进行拦截调用 */
public class MethodInterceptorCallback implements MethodInterceptor { 
   
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { 
   
        System.out.println("before invoke........");
        proxy.invokeSuper(obj,args);
        System.out.println("after invoke.........");
        return null;
    }
}

NoOp

通过接口声明了一个单例对象，该代理不对被代理类执行任何操作

/** * 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() { 
    };
}

被代理类code

public class CallbackBean { 
   

    public void methodForDispatcher(){ 
   
        System.out.println("methodForDispatcher...");
    }

    public void methodForFixValue(){ 
   
        System.out.println("methodForFixValue...");
    }

    public void methodForInvocationHandler(){ 
   
        System.out.println("methodForInvocationHandler...");
    }

    public void methodForLazy(){ 
   
        System.out.println("methodForLazy...");
    }

    public void methodForInterceptor(){ 
   
        System.out.println("methodForInterceptor...");
    }

    public void methodForNoop(){ 
   
        System.out.println("methodForNoop...");
    }
}

编写Enhancer调用

import callbacks.*;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.CallbackFilter;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.NoOp;
import org.junit.Test;
import proxybean.CallbackBean;
import java.lang.reflect.Method;

public class CallbackTest { 
   

    @Test
    public void testCallback(){ 
   
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(CallbackBean.class);
        enhancer.setCallbacks(initCallBacks());
        enhancer.setCallbackFilter(initCallbackFilter());
        CallbackBean callbackBean = (CallbackBean) enhancer.create();

        callbackBean.methodForNoop();
        callbackBean.methodForInterceptor();
        callbackBean.methodForLazy();
        callbackBean.methodForDispatcher();
        callbackBean.methodForInvocationHandler();
        callbackBean.methodForFixValue();
    }





    /**** * 初始化callback拦截数组 * @return */
    private static final Callback[] initCallBacks(){ 
   
        MethodInterceptorCallback methodInterceptorCallback = new MethodInterceptorCallback();
        LazyLoaderCallback lazyLoaderCallback = new LazyLoaderCallback();
        InvocationHandlerCallback invocationHandlerCallback = new InvocationHandlerCallback();
        FixValueCallback fixValueCallback = new FixValueCallback();
        DispatcherCallBack dispatcherCallBack = new DispatcherCallBack();
        Callback[] callbacks = new Callback[]{ 
   NoOp.INSTANCE,methodInterceptorCallback,lazyLoaderCallback,dispatcherCallBack,invocationHandlerCallback,fixValueCallback};
        return callbacks;
    }



    private static final CallbackFilter initCallbackFilter(){ 
   
        return new CallbackFilter() { 
   
            public int accept(Method method) { 
   
                if (method.getName().equals("methodForNoop")){ 
   
                    return 0;
                }
                if (method.getName().equals("methodForInterceptor")){ 
   
                    return 1;
                }
                if (method.getName().equals("methodForLazy")){ 
   
                    return 2;
                }
                if (method.getName().equals("methodForDispatcher")){ 
   
                    return 3;
                }
                if (method.getName().equals("methodForInvocationHandler")){ 
   
                    return 4;
                }
                if (method.getName().equals("methodForFixValue")){ 
   
                    return 5;
                }
                return 0;
            }
        };

    }
}

proxy class反编译分析(请看关键注释)

Dispatcher

public final void methodForDispatcher() { 
   
    Dispatcher var10000 = this.CGLIB$CALLBACK_3;
    if (var10000 == null) { 
   
        CGLIB$BIND_CALLBACKS(this);
        var10000 = this.CGLIB$CALLBACK_3;
    }
	//每次都调用一次loadObject，获取对象，并调用对象的相应方法
    //这样的实现，相当于loadObject可以很灵活的返回相应的实现类或者子类
    ((CallbackBean)var10000.loadObject()).methodForDispatcher();
}

FixedValue

public final void methodForFixValue() { 
   
    FixedValue var10000 = this.CGLIB$CALLBACK_5;
    if (var10000 == null) { 
   
        CGLIB$BIND_CALLBACKS(this);
        var10000 = this.CGLIB$CALLBACK_5;
    }
	//直接调用了FixValue callback的loadObject，相当于重写逻辑
    var10000.loadObject();
}

InvocationHandler

public final void methodForInvocationHandler() { 
   
    try { 
   
        InvocationHandler var10000 = this.CGLIB$CALLBACK_4;
        if (var10000 == null) { 
   
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_4;
        }
		//调用InvocationHandler相应的invoke实现
        var10000.invoke(this, CGLIB$methodForInvocationHandler$4, new Object[0]);
    } catch (Error | RuntimeException var1) { 
   
        throw var1;
    } catch (Throwable var2) { 
   
        throw new UndeclaredThrowableException(var2);
    }
}

LazyLoader

public final void methodForLazy() { 
   
	//CGLIB$LOAD_PRIVATE_2在proxy初始化的时候初始化一次，并维护了该成员
	//与Dispatcher不同，每次调用都是运用proxy成员变量进行调用
    ((CallbackBean)this.CGLIB$LOAD_PRIVATE_2()).methodForLazy();
}

MethodInterceptor

public final void methodForInterceptor() { 
   
    MethodInterceptor var10000 = this.CGLIB$CALLBACK_1;
    if (var10000 == null) { 
   
        CGLIB$BIND_CALLBACKS(this);
        var10000 = this.CGLIB$CALLBACK_1;
    }

    if (var10000 != null) { 
   
        //调用callback的intercept方法，用于实现拦截
        var10000.intercept(this, CGLIB$methodForInterceptor$1$Method, CGLIB$emptyArgs, CGLIB$methodForInterceptor$1$Proxy);
    } else { 
   
        super.methodForInterceptor();
    }
}