Cglib底层源码实现逻辑过程

于 2022-09-01 14:14:29 发布
阅读量389 收藏 2
点赞数 1
文章标签： java intellij-idea jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lost_gost/article/details/126633877
版权

文章目录

一、 环境搭建

火车站实体类

public class TrainStation  {
    public void sell() {
        System.out.println("卖票");
    }

动态代理工厂

public class ProxyFactory{
 private TrainStation trainStation = new TrainStation();
//        通过Cglib 获得代理对象
    public Sell getSell1() {
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\ideaPro\\cloud-demo\\gateway\\target\\classes\\cn\\itcast\\gateway");
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(trainStation.getClass());
        enhancer.setCallback(this);
        //是否开启缓存
     //   enhancer.setUseCache(false);
        Object o = enhancer.create();
        return (Sell) o;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("!!!!!!!!!!!");
        Object invoke = methodProxy.invokeSuper(o, objects);
        return invoke;
    }
    }

主函数

public class Client {
    public static void main(String[] args) {
        ProxyFactory proxyFactory = new ProxyFactory();
        Sell sell1 = proxyFactory.getSell1();
        sell1.sell();
    }
}

二、查看代理类的字节码文件

第一步

在这里插入图片描述

在这里插入图片描述

第二步: 在代理类工厂添加这句话

  System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, 
  "D:\\ideaPro\\cloud-demo\\gateway\\target\\classes\\cn\\itcast\\gateway");

最终显示样式

在这里插入图片描述

三、动态代理源码


//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package DEMO;

import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Factory;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class TrainStation$$EnhancerByCGLIB$$5e21b681 extends TrainStation implements Factory {
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static Object CGLIB$CALLBACK_FILTER;
    private static final Method CGLIB$sell$0$Method;
    private static final MethodProxy CGLIB$sell$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$equals$1$Method;
    private static final MethodProxy CGLIB$equals$1$Proxy;
    private static final Method CGLIB$toString$2$Method;
    private static final MethodProxy CGLIB$toString$2$Proxy;
    private static final Method CGLIB$hashCode$3$Method;
    private static final MethodProxy CGLIB$hashCode$3$Proxy;
    private static final Method CGLIB$clone$4$Method;
    private static final MethodProxy CGLIB$clone$4$Proxy;

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("DEMO.TrainStation$$EnhancerByCGLIB$$5e21b681");
        Class var1;
        CGLIB$sell$0$Method = ReflectUtils.findMethods(new String[]{"sell", "()V"}, (var1 = Class.forName("DEMO.TrainStation")).getDeclaredMethods())[0];
        CGLIB$sell$0$Proxy = MethodProxy.create(var1, var0, "()V", "sell", "CGLIB$sell$0");
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$equals$1$Method = var10000[0];
        CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");
        CGLIB$toString$2$Method = var10000[1];
        CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");
        CGLIB$hashCode$3$Method = var10000[2];
        CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3");
        CGLIB$clone$4$Method = var10000[3];
        CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");
    }

    final void CGLIB$sell$0() {
        super.sell();
    }

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

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$sell$0$Method, CGLIB$emptyArgs, CGLIB$sell$0$Proxy);
        } else {
            super.sell();
        }
    }

    final boolean CGLIB$equals$1(Object var1) {
        return super.equals(var1);
    }

    public final boolean equals(Object var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            Object var2 = var10000.intercept(this, CGLIB$equals$1$Method, new Object[]{var1}, CGLIB$equals$1$Proxy);
            return var2 == null ? false : (Boolean)var2;
        } else {
            return super.equals(var1);
        }
    }

    final String CGLIB$toString$2() {
        return super.toString();
    }

    public final String toString() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy) : super.toString();
    }

    final int CGLIB$hashCode$3() {
        return super.hashCode();
    }

    public final int hashCode() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            Object var1 = var10000.intercept(this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy);
            return var1 == null ? 0 : ((Number)var1).intValue();
        } else {
            return super.hashCode();
        }
    }

    final Object CGLIB$clone$4() throws CloneNotSupportedException {
        return super.clone();
    }

    protected final Object clone() throws CloneNotSupportedException {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? var10000.intercept(this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy) : super.clone();
    }

    public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
        String var10000 = var0.toString();
        switch(var10000.hashCode()) {
        case -508378822:
            if (var10000.equals("clone()Ljava/lang/Object;")) {
                return CGLIB$clone$4$Proxy;
            }
            break;
        case 1826985398:
            if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                return CGLIB$equals$1$Proxy;
            }
            break;
        case 1913648695:
            if (var10000.equals("toString()Ljava/lang/String;")) {
                return CGLIB$toString$2$Proxy;
            }
            break;
        case 1978249955:
            if (var10000.equals("sell()V")) {
                return CGLIB$sell$0$Proxy;
            }
            break;
        case 1984935277:
            if (var10000.equals("hashCode()I")) {
                return CGLIB$hashCode$3$Proxy;
            }
        }

        return null;
    }

    public TrainStation$$EnhancerByCGLIB$$5e21b681() {
        CGLIB$BIND_CALLBACKS(this);
    }

    public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
        CGLIB$THREAD_CALLBACKS.set(var0);
    }

    public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {
        CGLIB$STATIC_CALLBACKS = var0;
    }

    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        TrainStation$$EnhancerByCGLIB$$5e21b681 var1 = (TrainStation$$EnhancerByCGLIB$$5e21b681)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (var10000 == null) {
                    return;
                }
            }

            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
        }

    }

    public Object newInstance(Callback[] var1) {
        CGLIB$SET_THREAD_CALLBACKS(var1);
        TrainStation$$EnhancerByCGLIB$$5e21b681 var10000 = new TrainStation$$EnhancerByCGLIB$$5e21b681();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Callback var1) {
        CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1});
        TrainStation$$EnhancerByCGLIB$$5e21b681 var10000 = new TrainStation$$EnhancerByCGLIB$$5e21b681();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        TrainStation$$EnhancerByCGLIB$$5e21b681 var10000 = new TrainStation$$EnhancerByCGLIB$$5e21b681;
        switch(var1.length) {
        case 0:
            var10000.<init>();
            CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
            return var10000;
        default:
            throw new IllegalArgumentException("Constructor not found");
        }
    }

    public Callback getCallback(int var1) {
        CGLIB$BIND_CALLBACKS(this);
        MethodInterceptor var10000;
        switch(var1) {
        case 0:
            var10000 = this.CGLIB$CALLBACK_0;
            break;
        default:
            var10000 = null;
        }

        return var10000;
    }

    public void setCallback(int var1, Callback var2) {
        switch(var1) {
        case 0:
            this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
        default:
        }
    }

    public Callback[] getCallbacks() {
        CGLIB$BIND_CALLBACKS(this);
        return new Callback[]{this.CGLIB$CALLBACK_0};
    }

    public void setCallbacks(Callback[] var1) {
        this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
    }

    static {
        CGLIB$STATICHOOK1();
    }
}

四、代理类源码分析

通过代理工厂，生成代理类，代理类调用被增强的方法（ Sell() ）
我们从sell()方法入手开始分析源码
在这里插入图片描述

动态生成的代理类中sell方法源码

public class TrainStation$$EnhancerByCGLIB$$5e21b681 extends 
TrainStation implements Factory {
    public final void sell() {
   //通过查看源码发现 该方法拦截器并没有被赋值 ，所以为空
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
     			//进入改方法 拿到方法拦截器
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
        /*通过方法拦截器调用我们增强的方法
        参数说明：
        this：动态代理对象
        CGLIB$sell$0$Method： 就是 Sell的方法类  在这里被赋值
         CGLIB$sell$0$Method = ReflectUtils.findMethods(new String[]{"sell", "()V"}, (var1 = Class.forName("DEMO.TrainStation")).getDeclaredMethods())[0];
        CGLIB$emptyArgs：方法中的参数
        CGLIB$sell$0$Proxy： 代理方法类  在这里被创建 具体作用下面介绍
        CGLIB$sell$0$Proxy = MethodProxy.create(var1, var0, "()V", "sell", "CGLIB$sell$0");
       */
            var10000.intercept(this, CGLIB$sell$0$Method, CGLIB$emptyArgs, CGLIB$sell$0$Proxy);
        } else {
            super.sell();
        }
    }
    }

通过这段代码可以看的出来 ，只要能拿到这个CGLIB$CALLBACK_0方法拦截器就可以调用我们的增强方法 ，所以目前问题就是我们如何得到这个方法拦截器

CGLIB$BIND_CALLBACKS方法拦截器的具体源码

 private static final void CGLIB$BIND_CALLBACKS(Object var0) {
      //代理对象被强行转换
        TrainStation$$EnhancerByCGLIB$$5e21b681 var1 = (TrainStation$$EnhancerByCGLIB$$5e21b681)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            //  ThreadLocal CGLIB$THREAD_CALLBACKS;
            // 这个线程中得到
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (var10000 == null) {
                    return;
                }
            }
					//并且在这里被赋值得到方法拦截器
            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
        }

    }

原来这个方法拦截器是通过一个线程中得到的，那么我们的问题又变成了 这个线程类CGLIB$THREAD_CALLBACKS是什么时候被赋值的

这个线程其实是在我们创建动态代理类后创建动态代理对象前被赋值的 具体我们继续看源码

在我们的方法中 最后一步就是生成代理类对象 我们源码也是从这里开始分析
在这里插入图片描述

create方法 源码

 public Object create() {
        classOnly = false;
        argumentTypes = null;
        //这里 我们继续跟进
        return createHelper();
    }

createHelper()方法 源码

 private Object createHelper() {
        preValidate();
        Object key = KEY_FACTORY.newInstance((superclass != null) ? superclass.getName() : null,
                ReflectUtils.getNames(interfaces),
                filter == ALL_ZERO ? null : new WeakCacheKey<CallbackFilter>(filter),
                callbackTypes,
                useFactory,
                interceptDuringConstruction,
                serialVersionUID);
        this.currentKey = key;
        //这里返回的是我们的动态代理对象 我们继续跟进  key是我们真实主题类
        Object result = super.create(key);
        return result;
    }

create(key)方法 源码

protected Object create(Object key) {
        try {
            ClassLoader loader = getClassLoader();
            Map<ClassLoader, ClassLoaderData> cache = CACHE;
            ClassLoaderData data = cache.get(loader);
            if (data == null) {
                synchronized (AbstractClassGenerator.class) {
                    cache = CACHE;
                    data = cache.get(loader);
                    if (data == null) {
                        Map<ClassLoader, ClassLoaderData> newCache = new WeakHashMap<ClassLoader, ClassLoaderData>(cache);
                        data = new ClassLoaderData(loader);
                        newCache.put(loader, data);
                        CACHE = newCache;
                    }
                }
            }
            this.key = key;
            //这里会进行缓存  如果将enhancer.useCache 设置为false  每次创建代理对象都会是新的代理对象
            Object obj = data.get(this, getUseCache());
            if (obj instanceof Class) {
            // 在第一次创建代理对象的时候会调用这个方法
                return firstInstance((Class) obj);
            }
            //否则就会进入这个方法
            return nextInstance(obj);
        } catch (RuntimeException e) {
            throw e;
        } catch (Error e) {
            throw e;
        } catch (Exception e) {
            throw new CodeGenerationException(e);
        }
    }

我们就以第一次创建 为例子继续跟进源码

firstInstance方法 源码

  protected Object firstInstance(Class type) throws Exception {
        if (classOnly) {
            return type;
        } else {
        //这里会执行这个方法 继续跟进
            return createUsingReflection(type);
        }
    }

createUsingReflection方法 源码

private Object createUsingReflection(Class type) {
			//到了这里我们终于看到了关于线程的方法
        setThreadCallbacks(type, callbacks);
        try{
        
        if (argumentTypes != null) {
        			//到这里 通过这个方法就创建了新的代理对象
             return ReflectUtils.newInstance(type, argumentTypes, arguments);
             
        } else {
        	
            return ReflectUtils.newInstance(type);
            
        }
        }finally{
         // clear thread callbacks to allow them to be gc'd
         setThreadCallbacks(type, null);
        }
    }

通过查看源码 可以发现之前我们提到的线程类 是在 创建代理类之后，创建代理对象之前 进行设置的
（关于怎么生成代理对象的我们这里就不讲了）
那么这个 值是如何被赋进去的呢 我们接着跟进 setThreadCallbacks(type, callbacks); 查看

setThreadCallbacks方法 源码

 private static void setThreadCallbacks(Class type, Callback[] callbacks) {
        setCallbacksHelper(type, callbacks, SET_THREAD_CALLBACKS_NAME);
    }

SET_THREAD_CALLBACKS_NAME 是什么呢 我看跟进可以发现是一个
名为“CGLIB$SET_THREAD_CALLBACKS ”的字符串
这个字符串的作用是是什么呢 我们继续跟进源码

setCallbacksHelper方法 源码

 private static void setCallbacksHelper(Class type, Callback[] callbacks, String methodName) {
        // TODO: optimize
        try {
        //这里原来是根据类型和方法这个名称进行得到了具体方法
            Method setter = getCallbacksSetter(type, methodName);
            //通过方法名称进行反射将 callbacks赋值进去
            setter.invoke(null, new Object[]{ callbacks });
        } catch (NoSuchMethodException e) {
            throw new IllegalArgumentException(type + " is not an enhanced class");
        } catch (IllegalAccessException e) {
            throw new CodeGenerationException(e);
        } catch (InvocationTargetException e) {
            throw new CodeGenerationException(e);
        }
    }

根据代码我们发现了 反射，那就意味着在代理类对象中应该有一种方法可以进行设置我们之前说的线程类

CGLIB$SET_THREAD_CALLBACKS 方法 源码

 public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
        CGLIB$THREAD_CALLBACKS.set(var0);
    }

这和我们之前看的那个 字符串的名字是一样的 所以可以通过反射得到这个方法并且进行赋值

至此我们知道Cglib内部是如何实现动态代理的逻辑了。

那么在intercept方法中MethodProxy参数到底是作用有哪些呢？ 方法中invokeSuper和invoke方法有什么不同呢。

四、MethodProxy

   CGLIB$sell$0$Proxy = MethodProxy.create(var1, var0, "()V", "sell", "CGLIB$sell$0");

注意到 create方法有两个参数 分别是sell和CGLIB$sell$0 正好对应我们代理对象中的两个方法，（"()v"是返回值为空的意思）
在这里插入图片描述我们继续追踪create方法查看源码

create方法 源码

  public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) {
  		//构造一个代理方法
        MethodProxy proxy = new MethodProxy();
        //将这两个方法 分别封装到两个签名类中
        proxy.sig1 = new Signature(name1, desc);
        proxy.sig2 = new Signature(name2, desc);
        //将真实主题类和代理类进行封装
        proxy.createInfo = new CreateInfo(c1, c2);
        return proxy;
    }

我们拿到这个代理方法就可进行调用 invokeSuper和invoke方法
在这里插入图片描述在这里插入图片描述那么他们的差别是什么呢？

invoke和invokeSuper

invoke方法 源码

 public Object invoke(Object obj, Object[] args) throws Throwable {
        try {
            init();
            FastClassInfo fci = fastClassInfo;
            return fci.f1.invoke(fci.i1, obj, args);
        } catch (InvocationTargetException e) {
            throw e.getTargetException();
        } catch (IllegalArgumentException e) {
            if (fastClassInfo.i1 < 0)
                throw new IllegalArgumentException("Protected method: " + sig1);
            throw e;
        }
    }

源码很容易看懂就是 讲fastClassInfo 赋值给fci并且调用fci.f1的方法 ，那么 fastClassInfo 的值从何而来，那就要继续查看 Init()方法了，看一下他里面做了哪些操作。

   private void init()
    {  
      if (fastClassInfo == null)
        {
            synchronized (initLock)
            {
                if (fastClassInfo == null)
                {
                //根据之前源码分析 得知 这一步将 真是主题类和代理类的信息传递给ci
                    CreateInfo ci = createInfo;

                    FastClassInfo fci = new FastClassInfo();
                    //将 真实主题类 也就是火车站类 传递给了f1
                    fci.f1 = helper(ci, ci.c1);
                     //将 代理类类，传递给了f2
                    fci.f2 = helper(ci, ci.c2);
                    //通过签名得到具体方法 sig1 是sell（）方法
                    fci.i1 = fci.f1.getIndex(sig1);
                    //sig2 是CGLIB$sell$0()方法
                    fci.i2 = fci.f2.getIndex(sig2);
                    fastClassInfo = fci;
                    createInfo = null;
                }
            }
        }
    }

现在我们再回过头来看 Invoke方法
在这里插入图片描述

不难发现 invoke调用的是 真实主题类中sell()方法

同理我们查看 InvokeSuper方法
在这里插入图片描述

很容易就得知 invokeSuper调用的是 代理类中CGLIB$sell$0方法

这个时候就有一个疑问了 那我可不可以用 invoke方法调用 代理类中sell()方法，或者我用InvokeSuper方法调用 真实主题类中的CGLIB$sell$0()方法呢？

于是我进行了尝试

用 invoke方法调用 代理类中sell()方法

在这里插入图片描述很显然，它报错了。为啥呢 ？

因为造成了递归死循环调用 想一下 ，代理类的sell方法 最终会去调用 Intercept增强方法 而增强方法又回去调用代理类的sell方法 这不就成了死循环了吗。

InvokeSuper方法调用 真实主题类中的CGLIB$sell$0()方法

在这里插入图片描述当然也不行的，为啥呢？

从逻辑上来说 因为 真实主题类也就是 火车站类根本就没有CGLIB$sell$0()这个方法

但是它报的错误 不是说没找到该方法而是这个错误呢 因为 在FastClass类中会进行强制类型转换 ，由于 不能强制类型转换 就会报错。（代理类可以转换为真实主题类，但是真实主题类不能转换成代理类，因为子类继承自父类的原因，这也就是为啥 invoke是代理类时没有报类型转换错误的原因）
在这里插入图片描述
至于啥是 FastClass 可以结尾查看相应视频了解

至此 关于Cglib的相关基础逻辑全部搞明白了。

总结

感谢 b站 Java程序员周瑜的讲解
视频链接：
https://www.bilibili.com/video/BV1fF411q7QQ?p=4&vd_source=36f798afd4325366d4bae2a4aa1bdccd

桦苒
关注
cglib底层源码分析（⼀）
tulingxueyuanXM的博客
04-10 546
cglib是⼀种动态代理技术，可以针对类来⽣成⼀个代理对象。 ⽐如，我们现有⼀个UserService类： 现在利⽤cglib对UserService类中的test()⽅法进⾏增强： 在分析底层源码实现之前，我们先来试试，cglib能否代理接⼝，定义⼀个UserInterface接⼝ 然后利⽤cglib来代理⼀个接⼝： 也是可以正常运⾏的，那么⽤cglib代理⼀个类和代理⼀个接⼝的底层有什么区别呢？我们继续分析。 我们知道，既然要⽣成⼀个代理对象，那么就肯定需要⼀个代理...
cglib底层源码分析（⼆）
tulingxueyuanXM的博客
04-12 445
其实我们如果看到了cglib所⽣成的代理类之后，其实就不难猜测，cglib是如何去⽣成代理类了，我们看 ⼀个完整的代理类： 我们发现，UserService代理类既继承了UserService类，也实现了Factory接⼝，从⽽代理中就需要去 实现Factory接⼝中的⼏个⽅法： 我们可以发现newInstance()⽅法会重新⽣成⼀个代理对象，setCallbacks()和getCallbacks()可以⽤来 设置或获取增强逻辑。 我们还发现，不仅只...
jdk与cglib动态代理与底层实现
12-21
代理模式详解-jdk与cglib动态代理与底层实现，spring中常用的设计模式，本案例是从源码到代理模式的实现。
cglib.jar源码
08-25
spring AOP中的cglib代理所依赖的jar包cglib.jar源码 net.sf.cglib.proxy
精讲23种设计模式-002：CGLIB底层实现的原理
枫火的博客
09-24 437
002：CGLIB底层实现的原理1 CGLIB动态代理课程内容安排2 CGLIB与JDK动态代理之间的区别3 使用CGLIB实现动态代理4 CGLIB代理生成的代理类源码分析5 Jdk与Cglib动态代理的区别6 模拟手写调用FastClass类7 FastClass机制底层源码解读 1 CGLIB动态代理课程内容安排 课程内容 如何基于CGLIB实现动态代理 CGLIB底层实现原理源码解读 为什么CGLIB效率会比Jdk动态代理效率高 CGLIB的FastClass机制实现的原理 2 CGLIB与JD
cglib-3.1源码
04-22
通过阅读源码，可以深入理解Java字节码的生成过程，以及AOP的实现原理。 总的来说，CGLIB 3.1源码不仅为我们提供了实现动态代理的工具，也是一份深入了解Java字节码、代理机制和AOP的宝贵教材。通过对源码的深入...
动态代理cglibjar包和源码
05-21
动态代理在Java编程中是一种非常重要的技术，它允许我们在不修改原有对象代码的情况下，为对象增加额外的功能。CGLIB（Code Generation ...通过深入研究CGLIB的源码，可以更好地理解Java字节码和动态代理的底层机制。
CGLib字节码增强实现代理原理(附源码下载)
04-16
CGLib的工作原理基于ASM库，ASM是一个底层的Java字节码操控和分析框架，可以用来动态生成类或者增强已有类的功能。CGLib通过ASM在内存中动态生成字节码，然后通过Java的ClassLoader将字节码转换为Class对象。这个...
Cglib源码解析
厚积薄发
02-27 2853
      Cglib(Code Generator Library)是一个 java字节码生成工具，提供了一系列的类生成器，可以在运行期间，生成现有java类的子类（cglib不能扩展final类）。本系列文章分析cglib的源码实现。一、基本框架ClassGenerator是Cglib的核心接口，其中核心方法generateClass方法用于产生目标类；public interface Cla...
CGLIB动态代理底层实现原理
wajueji的博客
03-28 685
一、前言 最近在探究Spring AOP的性能，发现最后是绕不开JDK动态代理和CGLIB动态代理这两个点。笔者心里大致有这么个概念：对于动态代理来说，CGLIB性能要好于JDK。也知道CGLIB是利用ASM技术基于继承子类实现动态代理，JDK是基于实现接口实现动态代理，但是对于底层实现还是比较模糊。今天就彻底整明白CGLIB动态代理的底层实现。二、前置准备(一)测试代码CGLIB核心的几个概念...
CGLib3.2.5依赖包及源码
09-25
cglib-3.2.5.jar、cglib-nodep-3.2.5.jar、cglib-RELEASE_3_2_5.tar.gz（源码）、cglib-RELEASE_3_2_5.zip（源码）
SpringAOP的CGLIB动态代理的底层原理实现
热门推荐
ywl470812087的博客
01-11 11万+
欢迎加入java学习讨论群：725562382 CGLIB动态代理: CGLIB(Code Generation Library)是一个开源项目！是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。 Hibernate支持它来实现PO(Persistent Object 持久化对象)字节码的动态生成 Hibernate生成持久化类的javassis...
CGLib实现和底层实现原理
qq_42358647的博客
06-12 1136
cglib动态代理底层则是借助asm来实现的。总的来说，反射机制在生成类的过程中比较高效，而asm在生成类之后的相关执行过程中比较高效（可以通过将asm生成的类进行缓存，这样解决asm生成类过程低效问题）。 CGLIb测试demo: public class SayHello { public void sayhello(){ System.out.println("hello 呀!!!"); } } public class CglibProxy i..
CGLIB源码分析
工作总结博客
07-20 270
前言 SpringAOP在Spring框架中占据了非常重要的位置，所提供的面向切面编程（AOP）是对面向对象编程（OOP）的一种补充。AOP采用横切的的方式，将核心业务与通用逻辑切分开来。可以更好的服用代码以及项目管理。 ...
Spring学习笔记_AOP的cglib动态代理底层实现方式
__盛某人的博客
07-05 205
单独使用cglib是需要到jar的。 当在spring中使用时cglib的部分随着spring-context.jar的导入已经引用了。 Target目标对象 package com.cvicse.ump.proxy.jdk.impl; import com.cvicse.ump.proxy.jdk.TargetInterface; /** * 目标对象 */ public class Target implements TargetInterface { /** * 目标方法
cglib 源代码分析（原创）
zhangyu84848245的博客
02-25 469
最近读了下cglib 的源代码,分析了cglib 通过字节码生成的代理类。就用cglib源代码包中的例子吧. 1.首先eclipse中开启debug模式,如图 例子的代码如下 public static void main(String args[]) { Bean bean = (Bean)newInstance(Bean.class); bean.addPr...
cglib proxy 源码学习
This is bill的专属博客
07-22 2882
背景 前段时间在写hank hsf 的工具（http://www.atatech.org/articles/23763） 时，发现cndcp 中，一个单例的bean，被jmonitor 做了代理， 动态生成了3个class, 其中 CndcpConsolidationTmsOrderServiceImpl EnhancerByCGLIBEnhancerByCGLIB 35f433a5
cglib动态代理的基本实现流程
lvhao6037的博客
07-08 258
①配置cglib的依赖 ②声明真实对象和真实方法 ③创建类并声明方法完成扩展代码的声明 ④使用Cglib提供的方法获取代理对象 ⑤使用代理对象完成功能处理
4.SpringAOP动态代理之JDK和CGlib实现过程与仿写简例
郑学炜的技术博客
04-18 436
Proxy InvocationHandlerAOP概述软件的编程语言最终的目的就是用更自然更灵活的方式模拟世界，从原始机器语言到过程语言再到面向对象的语言，我们看到编程语言在一步步用更自然、更强大的方式描述软件。AOP是软件开发思想的一个飞跃，AOP的引入将有效弥补OOP的不足，OOP和AOP分别从纵向和横向对软件进行抽象，有效地消除重复性的代码，使代码以更优雅的更有效的方式进行逻辑表达。AOP...
深入理解Spring AOP：动态代理与Cglib源码解析
课程内容涵盖AOP核心概念，CGLib动态代理的实现方式，以及Spring AOP源码解析，如BeanDefinitionParser的相关流程和AOP代理对象的生成过程。" 在Spring框架中，AOP是一种重要的设计模式，它允许程序员在不修改原有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值