Cglib动态代理源码例子解析

最新推荐文章于 2024-02-28 10:26:20 发布
最新推荐文章于 2024-02-28 10:26:20 发布
阅读量1.6k 收藏 1
点赞数 2
CC 4.0 BY-SA版权
分类专栏： # 动态代理系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/gaohaicheng123/article/details/77113042
本文深入探讨Cglib库的原理与应用，包括其实现动态代理的方式、底层字节码处理技术及与JDK动态代理的区别。通过实例演示Cglib如何在运行时生成新的类。

什么是Cglib

Cglib是一个强大的，高性能，高质量的代码生成类库。它可以在运行期扩展JAVA类与实现JAVA接口。其底层实现是通过ASM字节码处理框架来转换字节码并生成新的类。大部分功能实际上是ASM所提供的，Cglib只是封装了ASM，简化了ASM操作，实现了运行期生成新的class。

运行时动态的生成一个被代理类的子类（通过ASM字节码处理框架实现），子类重写了被代理类中所有非final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势植入横切逻辑。

Cglib优缺点

优点：
JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要CGLib了。CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。
JDK动态代理要求被代理的类必须实现接口，当需要代理的类没有实现接口时Cglib代理是一个很好的选择。另一个优点是Cglib动态代理比使用java反射的JDK动态代理要快（Cglib的FastClass机制，解析参考http://www.cnblogs.com/cruze/category/593899.html）

缺点：
对于被代理类中的final方法，无法进行代理，因为子类中无法重写final函数
CGLib创建的动态代理对象性能比JDK创建的动态代理对象的性能高不少，但是CGLib在创建代理对象时所花费的时间却比JDK多得多，所以对于单例的对象，因为无需频繁创建对象，用CGLib合适，反之，使用JDK方式要更为合适一些。同时，由于CGLib由于是采用动态创建子类的方法，对于final方法，无法进行代理

Cglib类库

net.sf.cglib.core:底层字节码处理类，他们大部分与ASM有关系。

net.sf.cglib.transform:编译期或运行期类和类文件的转换

net.sf.cglib.proxy:实现创建代理和方法拦截器的类

net.sf.cglib.reflect:实现快速反射和C#风格代理的类

net.sf.cglib.util:集合排序等工具类

net.sf.cglib.beans:JavaBean相关的工具类

package com.cglib;

import java.lang.reflect.Method;

import net.sf.cglib.beans.BeanGenerator;
import net.sf.cglib.core.DebuggingClassWriter;
import net.sf.cglib.core.DefaultGeneratorStrategy;
import net.sf.cglib.core.GeneratorStrategy;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
/**
 * MyMethodInterceptor  用来实现提供给代理对象调用的方法。
 * @author gaohaicheng
 *
 */
public class MyMethodInterceptor implements MethodInterceptor {

    /**
     * 从源码可以看出，这个接口只有一个方法——intercept，这个方法有4个参数，分别是增强的对象，即实               现这个接口类的一个对象；  
     * method表示要被拦截的方法; args要被拦截方法的参数；proxy表示要触发父类的方法对象；
     */
    public Object intercept(Object obj, Method method, Object[] arg, MethodProxy proxy) throws Throwable {
        System.out.println("准备开始   :" + method);  
        Object object = proxy.invokeSuper(obj, arg);
        System.out.println("已经结束了  :" + method); 
        return object;
    }



    public static void main(String[] args) throws Exception {
        //Enhancer是Cglib代理的核心类
        Enhancer enhancer = new Enhancer();  
        enhancer.setSuperclass(Programer.class);  
        enhancer.setCallback(new MyMethodInterceptor());  
        Programer programer = (Programer)enhancer.create();
        //开始调用
        programer.eat("代码级大餐");
        System.out.println("------------------------------------------------------------------");
        programer.wear();












    }


}



//**************************************被代理类*************************************
/**
 * person
 * @author gfw2306
 *
 */
class Programer {


    public void wear(){
        System.out.println("穿衣服");
    }

    public void eat(String food) {
        // TODO Auto-generated method stub
        System.out.println("程序猿大餐开吃，妈的");
    }
}

想看一下cglib生成的class文件是什么样的就要用到一个工具：HSDB
借HSDB来探索HotSpot VM的运行时数据.

1、在cmd中执行，当然先跳到jdk的bin目录下执行。
H:\Program Files\Java\jdk1.7.0_79\bin>Java -classpath “%JAVA_HOME%/lib/sa-jdi.jar” sun.jvm.hotspot.HSDB

执行完指令后
这里写图片描述

2、会出现HSDB窗口

HSDB

然后查找执行中生成的动态代理类：
这里写图片描述

点击生成：

这里写图片描述

最后会在jdk下生成和你包名相同的路径下的class类：

这里写图片描述

使用jad反编译工具编译出class文件：

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   <generated>

package com.cglib;

import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.*;

// Referenced classes of package com.cglib:
//            Programer

public class Programer$$EnhancerByCGLIB$$e950f55f extends Programer
    implements Factory
{

    protected final void finalize()
        throws Throwable
    {
        CGLIB$CALLBACK_0;
        if(CGLIB$CALLBACK_0 != null) goto _L2; else goto _L1
_L1:
        JVM INSTR pop ;
        CGLIB$BIND_CALLBACKS(this);
        CGLIB$CALLBACK_0;
_L2:
        JVM INSTR dup ;
        JVM INSTR ifnull 37;
           goto _L3 _L4
_L3:
        break MISSING_BLOCK_LABEL_21;
_L4:
        break MISSING_BLOCK_LABEL_37;
        this;
        CGLIB$finalize$2$Method;
        CGLIB$emptyArgs;
        CGLIB$finalize$2$Proxy;
        intercept();
        return;
        super.finalize();
        return;
    }

    public final boolean equals(Object obj)
    {
        CGLIB$CALLBACK_0;
        if(CGLIB$CALLBACK_0 != null) goto _L2; else goto _L1
_L1:
        JVM INSTR pop ;
        CGLIB$BIND_CALLBACKS(this);
        CGLIB$CALLBACK_0;
_L2:
        JVM INSTR dup ;
        JVM INSTR ifnull 57;
           goto _L3 _L4
_L3:
        this;
        CGLIB$equals$3$Method;
        new Object[] {
            obj
        };
        CGLIB$equals$3$Proxy;
        intercept();
        JVM INSTR dup ;
        JVM INSTR ifnonnull 50;
           goto _L5 _L6
_L5:
        JVM INSTR pop ;
        false;
          goto _L7
_L6:
        (Boolean);
        booleanValue();
_L7:
        return;
_L4:
        return super.equals(obj);
    }

    public final String toString()
    {
        CGLIB$CALLBACK_0;
        if(CGLIB$CALLBACK_0 != null) goto _L2; else goto _L1
_L1:
        JVM INSTR pop ;
        CGLIB$BIND_CALLBACKS(this);
        CGLIB$CALLBACK_0;
_L2:
        JVM INSTR dup ;
        JVM INSTR ifnull 40;
           goto _L3 _L4
_L3:
        this;
        CGLIB$toString$4$Method;
        CGLIB$emptyArgs;
        CGLIB$toString$4$Proxy;
        intercept();
        (String);
        return;
_L4:
        return super.toString();
    }

    public final int hashCode()
    {
        CGLIB$CALLBACK_0;
        if(CGLIB$CALLBACK_0 != null) goto _L2; else goto _L1
_L1:
        JVM INSTR pop ;
        CGLIB$BIND_CALLBACKS(this);
        CGLIB$CALLBACK_0;
_L2:
        JVM INSTR dup ;
        JVM INSTR ifnull 52;
           goto _L3 _L4
_L3:
        this;
        CGLIB$hashCode$5$Method;
        CGLIB$emptyArgs;
        CGLIB$hashCode$5$Proxy;
        intercept();
        JVM INSTR dup ;
        JVM INSTR ifnonnull 45;
           goto _L5 _L6
_L5:
        JVM INSTR pop ;
        0;
          goto _L7
_L6:
        (Number);
        intValue();
_L7:
        return;
_L4:
        return super.hashCode();
    }

    protected final Object clone()
        throws CloneNotSupportedException
    {
        CGLIB$CALLBACK_0;
        if(CGLIB$CALLBACK_0 != null) goto _L2; else goto _L1
_L1:
        JVM INSTR pop ;
        CGLIB$BIND_CALLBACKS(this);
        CGLIB$CALLBACK_0;
_L2:
        JVM INSTR dup ;
        JVM INSTR ifnull 37;
           goto _L3 _L4
_L3:
        this;
        CGLIB$clone$6$Method;
        CGLIB$emptyArgs;
        CGLIB$clone$6$Proxy;
        intercept();
        return;
_L4:
        return super.clone();
    }

    public Object newInstance(Class aclass[], Object aobj[], Callback acallback[])
    {
        CGLIB$SET_THREAD_CALLBACKS(acallback);
        JVM INSTR new #2   <Class Programer$$EnhancerByCGLIB$$e950f55f>;
        JVM INSTR dup ;
        aclass;
        aclass.length;
        JVM INSTR tableswitch 0 0: default 35
    //                   0 28;
           goto _L1 _L2
_L2:
        JVM INSTR pop ;
        Programer$$EnhancerByCGLIB$$e950f55f();
          goto _L3
_L1:
        JVM INSTR pop ;
        throw new IllegalArgumentException("Constructor not found");
_L3:
        CGLIB$SET_THREAD_CALLBACKS(null);
        return;
    }

    public Object newInstance(Callback acallback[])
    {
        CGLIB$SET_THREAD_CALLBACKS(acallback);
        CGLIB$SET_THREAD_CALLBACKS(null);
        return new Programer$$EnhancerByCGLIB$$e950f55f();
    }

    public Object newInstance(Callback callback)
    {
        CGLIB$SET_THREAD_CALLBACKS(new Callback[] {
            callback
        });
        CGLIB$SET_THREAD_CALLBACKS(null);
        return new Programer$$EnhancerByCGLIB$$e950f55f();
    }

    public void setCallback(int i, Callback callback)
    {
        switch(i)
        {
        case 0: // '\0'
            CGLIB$CALLBACK_0 = (MethodInterceptor)callback;
            break;
        }
    }

    public final void eat(String s)
    {
        CGLIB$CALLBACK_0;
        if(CGLIB$CALLBACK_0 != null) goto _L2; else goto _L1
_L1:
        JVM INSTR pop ;
        CGLIB$BIND_CALLBACKS(this);
        CGLIB$CALLBACK_0;
_L2:
        JVM INSTR dup ;
        JVM INSTR ifnull 42;
           goto _L3 _L4
_L3:
        break MISSING_BLOCK_LABEL_21;
_L4:
        break MISSING_BLOCK_LABEL_42;
        this;
        CGLIB$eat$0$Method;
        new Object[] {
            s
        };
        CGLIB$eat$0$Proxy;
        intercept();
        return;
        super.eat(s);
        return;
    }

    public final void wear()
    {
        CGLIB$CALLBACK_0;
        if(CGLIB$CALLBACK_0 != null) goto _L2; else goto _L1
_L1:
        JVM INSTR pop ;
        CGLIB$BIND_CALLBACKS(this);
        CGLIB$CALLBACK_0;
_L2:
        JVM INSTR dup ;
        JVM INSTR ifnull 37;
           goto _L3 _L4
_L3:
        break MISSING_BLOCK_LABEL_21;
_L4:
        break MISSING_BLOCK_LABEL_37;
        this;
        CGLIB$wear$1$Method;
        CGLIB$emptyArgs;
        CGLIB$wear$1$Proxy;
        intercept();
        return;
        super.wear();
        return;
    }

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

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

    public static MethodProxy CGLIB$findMethodProxy(Signature signature)
    {
        String s = signature.toString();
        s;
        s.hashCode();
        JVM INSTR lookupswitch 7: default 160
    //                   -1574182249: 76
    //                   -508378822: 88
    //                   685027751: 100
    //                   1223317398: 112
    //                   1826985398: 124
    //                   1913648695: 136
    //                   1984935277: 148;
           goto _L1 _L2 _L3 _L4 _L5 _L6 _L7 _L8
_L2:
        "finalize()V";
        equals();
        JVM INSTR ifeq 161;
           goto _L9 _L10
_L10:
        break MISSING_BLOCK_LABEL_161;
_L9:
        return CGLIB$finalize$2$Proxy;
_L3:
        "clone()Ljava/lang/Object;";
        equals();
        JVM INSTR ifeq 161;
           goto _L11 _L12
_L12:
        break MISSING_BLOCK_LABEL_161;
_L11:
        return CGLIB$clone$6$Proxy;
_L4:
        "eat(Ljava/lang/String;)V";
        equals();
        JVM INSTR ifeq 161;
           goto _L13 _L14
_L14:
        break MISSING_BLOCK_LABEL_161;
_L13:
        return CGLIB$eat$0$Proxy;
_L5:
        "wear()V";
        equals();
        JVM INSTR ifeq 161;
           goto _L15 _L16
_L16:
        break MISSING_BLOCK_LABEL_161;
_L15:
        return CGLIB$wear$1$Proxy;
_L6:
        "equals(Ljava/lang/Object;)Z";
        equals();
        JVM INSTR ifeq 161;
           goto _L17 _L18
_L18:
        break MISSING_BLOCK_LABEL_161;
_L17:
        return CGLIB$equals$3$Proxy;
_L7:
        "toString()Ljava/lang/String;";
        equals();
        JVM INSTR ifeq 161;
           goto _L19 _L20
_L20:
        break MISSING_BLOCK_LABEL_161;
_L19:
        return CGLIB$toString$4$Proxy;
_L8:
        "hashCode()I";
        equals();
        JVM INSTR ifeq 161;
           goto _L21 _L22
_L22:
        break MISSING_BLOCK_LABEL_161;
_L21:
        return CGLIB$hashCode$5$Proxy;
_L1:
        JVM INSTR pop ;
        return null;
    }

    public void setCallbacks(Callback acallback[])
    {
        this;
        acallback;
        JVM INSTR dup2 ;
        0;
        JVM INSTR aaload ;
        (MethodInterceptor);
        CGLIB$CALLBACK_0;
    }

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

    public Callback getCallback(int i)
    {
        CGLIB$BIND_CALLBACKS(this);
        this;
        i;
        JVM INSTR tableswitch 0 0: default 30
    //                   0 24;
           goto _L1 _L2
_L2:
        CGLIB$CALLBACK_0;
          goto _L3
_L1:
        JVM INSTR pop ;
        null;
_L3:
        return;
    }

    final void CGLIB$eat$0(String s)
    {
        super.eat(s);
    }

    final void CGLIB$wear$1()
    {
        super.wear();
    }

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

    final boolean CGLIB$equals$3(Object obj)
    {
        return super.equals(obj);
    }

    final void CGLIB$finalize$2()
        throws Throwable
    {
        super.finalize();
    }

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

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

    static void CGLIB$STATICHOOK1()
    {
        Method amethod[];
        Method amethod1[];
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class class1 = Class.forName("com.cglib.Programer$$EnhancerByCGLIB$$e950f55f");
        Class class2;
        amethod = ReflectUtils.findMethods(new String[] {
            "finalize", "()V", "equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"
        }, (class2 = Class.forName("java.lang.Object")).getDeclaredMethods());
        Method[] _tmp = amethod;
        CGLIB$finalize$2$Method = amethod[0];
        CGLIB$finalize$2$Proxy = MethodProxy.create(class2, class1, "()V", "finalize", "CGLIB$finalize$2");
        CGLIB$equals$3$Method = amethod[1];
        CGLIB$equals$3$Proxy = MethodProxy.create(class2, class1, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$3");
        CGLIB$toString$4$Method = amethod[2];
        CGLIB$toString$4$Proxy = MethodProxy.create(class2, class1, "()Ljava/lang/String;", "toString", "CGLIB$toString$4");
        CGLIB$hashCode$5$Method = amethod[3];
        CGLIB$hashCode$5$Proxy = MethodProxy.create(class2, class1, "()I", "hashCode", "CGLIB$hashCode$5");
        CGLIB$clone$6$Method = amethod[4];
        CGLIB$clone$6$Proxy = MethodProxy.create(class2, class1, "()Ljava/lang/Object;", "clone", "CGLIB$clone$6");
        amethod1 = ReflectUtils.findMethods(new String[] {
            "eat", "(Ljava/lang/String;)V", "wear", "()V"
        }, (class2 = Class.forName("com.cglib.Programer")).getDeclaredMethods());
        Method[] _tmp1 = amethod1;
        CGLIB$eat$0$Method = amethod1[0];
        CGLIB$eat$0$Proxy = MethodProxy.create(class2, class1, "(Ljava/lang/String;)V", "eat", "CGLIB$eat$0");
        CGLIB$wear$1$Method = amethod1[1];
        CGLIB$wear$1$Proxy = MethodProxy.create(class2, class1, "()V", "wear", "CGLIB$wear$1");
    }

    private static final void CGLIB$BIND_CALLBACKS(Object obj)
    {
        Programer$$EnhancerByCGLIB$$e950f55f programer$$enhancerbycglib$$e950f55f = (Programer$$EnhancerByCGLIB$$e950f55f)obj;
        if(programer$$enhancerbycglib$$e950f55f.CGLIB$BOUND) goto _L2; else goto _L1
_L1:
        Object obj1;
        programer$$enhancerbycglib$$e950f55f.CGLIB$BOUND = true;
        obj1 = CGLIB$THREAD_CALLBACKS.get();
        obj1;
        if(obj1 != null) goto _L4; else goto _L3
_L3:
        JVM INSTR pop ;
        CGLIB$STATIC_CALLBACKS;
        if(CGLIB$STATIC_CALLBACKS != null) goto _L4; else goto _L5
_L5:
        JVM INSTR pop ;
          goto _L2
_L4:
        (Callback[]);
        programer$$enhancerbycglib$$e950f55f;
        JVM INSTR swap ;
        0;
        JVM INSTR aaload ;
        (MethodInterceptor);
        CGLIB$CALLBACK_0;
_L2:
    }

    private boolean CGLIB$BOUND;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback CGLIB$STATIC_CALLBACKS[];
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static final Method CGLIB$eat$0$Method;
    private static final MethodProxy CGLIB$eat$0$Proxy;
    private static final Object CGLIB$emptyArgs[];
    private static final Method CGLIB$wear$1$Method;
    private static final MethodProxy CGLIB$wear$1$Proxy;
    private static final Method CGLIB$finalize$2$Method;
    private static final MethodProxy CGLIB$finalize$2$Proxy;
    private static final Method CGLIB$equals$3$Method;
    private static final MethodProxy CGLIB$equals$3$Proxy;
    private static final Method CGLIB$toString$4$Method;
    private static final MethodProxy CGLIB$toString$4$Proxy;
    private static final Method CGLIB$hashCode$5$Method;
    private static final MethodProxy CGLIB$hashCode$5$Proxy;
    private static final Method CGLIB$clone$6$Method;
    private static final MethodProxy CGLIB$clone$6$Proxy;

    static 
    {
        CGLIB$STATICHOOK1();
    }

    public Programer$$EnhancerByCGLIB$$e950f55f()
    {
        CGLIB$BIND_CALLBACKS(this);
    }
}

Cglib最新版本：

Cglib所有发布版本：

Cglib包实现动态代理
会玩代码的劫
05-24 1121
Cglib代理模式基本介绍： Cglib代理也叫子类代理，它是在内存中构建一个子类对象并对其目标方法进行拦截从而实现对目标对象功能扩展。使用Cglib代理需要引入Cglib jar包，Cglib包的底层是通过字节码处理框架ASM来转换字节码并生成新的类。 1）首先导入cglib jar包 2）注意，cglib代理的目标对象里要被增强的方法不能是static或者final的，如果是static或者final的则不会被拦截到，因为cglib是通过继承目标类实现方法增强，而static或者final的方法是不能
CGLIB动态代理之intercept函数刨析
qq_41854763的博客
12-12 3971
网上搜CGLIB动态代理，几乎所有的博文都只给了示例代码而缺少对代码的解释说明（特别是关键的intercept函数），看完实在是云里雾里。所以，这篇博文将带你从源码的角度来理解intercept函数。 前言 关于如何使用CGLIB创建动态代理，网上已经有很多资料，这里就不再赘述。本文将使用如下代码进行分析，如果你还看不懂下面的代码，请先自行搜索资料看懂后再继续后面的内容。 import net.sf.cglib.core.DebuggingClassWriter; import net.sf.cglib.
动态代理和cglib例子
12-25
动态代理和cglib例子，动态代理和cglib例子动态代理和cglib例子动态代理和cglib例子
cglib例子
10-11 183
import java.lang.reflect.Method; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; class Myclass { public void method() ...
CGLIB的代理例子
m0_37487653的博客
03-06 237
package com.itheima.factory; import com.itheima.service.IAccountService; import com.itheima.utils.TransactionManager; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; imp...
CGLib的一个简单的例子
晴空的专栏
02-20 1373
CGlib是一个强大的,高性能,高质量的Code生成类库。它常常被用来在运行期扩展Java类与实现Java接口。 它可以在不改变原代码的情况下对类的功能进行增强。 package cglib; import java.lang.reflect.Method; import net.sf.cglib.proxy.Callback; import net.sf.cglib.proxy.Call
SpringBoot整合Aop源码之Aop生成动态Cglib代理源码分析
m0_71749752的博客
02-12 1210
1.AOP先通过AnnotationAwareAspectJAutoProxyCreator的postProcessBeforeInstantiation创建一个增强器的集合，创建的逻辑主要是查找spring容器中标有@Aspectj注解的类，并且方法标有Pointcut、Around、Before、After、AfterReturning、AfterThrowing注解给他们封装为增强器对象。
【Cglib Nodep基础篇】：Cglib动态代理技术深度解析与实践
[【Cglib Nodep基础篇】：Cglib动态代理技术深度解析与实践](https://gmoon92.github.io/md/img/aop/jdk-dynamic-proxy-and-cglib/cglib1.png) # 1. Cglib动态代理技术概述 在现代软件开发中，动态代理是提高系统...
Spring源码分析总结(三)-JDK动态代理和CGLIB代理以及拦截器
记录进步-Jinken
04-28 899
   一、JDK动态代理和CGLIB代理方式:      1、如果目标对象实现了接口,默认会采用JDK代理实现AOP,也可以通过配置强制使用CGLIB实现       2、如果目标对象没有实现接口，必须采用CGLIB库，Spring会自动在JDK方式和CGLIB方式之前转换。    强制使用CGLIB实现：        1.添加CGLIB库,home目录下/cglib/*.jar   ...
cglib的简单案例
tangyongzhe的专栏
04-05 2786
本文的例子全部来自github上cglib的官方文档，有关cglib的教程少之又少，如果想学习觉得还是看看诸如Hibernate和Spring的源码来的实在。 package com.tang; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotSame; import j
CGLIB代理例子
04-28
CGLIB代理例子
CGlib的动态代理使用示例
ithome
10-13 234
1、cglib简述 Cglib是一个优秀的动态代理框架，它的底层使用ASM在内存中动态的生成被代理类的子类，使用CGLIB即使代理类没有实现任何接口也可以实现动态代理功能。CGLIB具有简单易用，它的运行速度要远远快于JDK的Proxy动态代理： 使用CGLIB需要导入以下两个jar文件： $1: asm.jar – CGLIB的底层实现 $2: cglib.ja...
CGLIB动态代理示例与源码解析
fenglllle的博客
09-18 1043
1. 原理，代理模式 代理模式的本质：调用方---&gt;代理方---&gt;实现方。 不细介绍，看我上一篇文章 JDK8动态代理示例与原码解析 1.1 动态代理模式步骤       生成代理类二进制字节码，可配置参数生成文件。       classloader load二进制字节码，生成Class对象( 可使用public static Class&lt;?&gt; forName(...
cglib的小例子
xuejianxinokok的专栏
05-21 1051
public class Dao { public Object select(int id){ System.out.println("DAO--->select"); return "select"; } public void insert(int id){ System.out.println("DAO--->insert---->"+id); } public void update(int id){ System.out.printl
cglib简单的小实例
追本溯源的专栏
06-06 4229
cglib和Jdk的动态代理相比，它的优点是目标类不用实现一个接口。 代码实现： 目标类 package cglib; public class ClassHasNoInterface { public void method(){ System.out.println("建立自己的知识体系还是很重要的，尽管觉得麻烦"); } public void fun
【设计模式】代理模式之CGLIB动态代理（案例详解）
辰兮要努力
10-25 1875
【辰兮要努力】：hello你好我是辰兮，很高兴你能来阅读，昵称是希望自己能不断精进，向着优秀程序员前行！ 博客来源于项目以及编程中遇到的问题总结，偶尔会有读书分享，我会陆续更新Java前端、后台、数据库、项目案例等相关知识点总结，感谢你的阅读和关注，希望我的博客能帮助到更多的人，分享获取新知，大家一起进步! 吾等采石之人，应怀大教堂之心，愿大家奔赴在各自的热爱里… 文章目录一、初识代理模式二、代码案例学习三、断点深入探究 一、初识代理模式 关于jdk的动态代理和cglib的动态代理，我会通过两篇文.
Cglib源码分析
最新发布
weixin_43900726的博客
02-28 934
超简单的Cglib超详细源码分析
cglib动态代理实例
u012061554的博客
09-01 779
这是一个service类 public class SayHelloService {     public void sayHello(){         System.out.println("Hello");     } }   这是一个代理类 import org.springframework.cglib.proxy.Enhancer; import org.springfra...
CGLIB源码易懂解析
m0_48333563的博客
08-08 1550
博主亲身实践，细嚼慢咽，提供了赌代码方式读代码，通俗易懂。如有指教，敬请提出！！！
深入解析Jdk动态代理：原理与源码分析
我们将通过一个模拟@Cacheable注解的例子来展示动态代理如何处理缓存，并深入源码来解答为何Jdk动态代理需要目标对象实现接口。" ### Jdk动态代理简介 Java的动态代理机制允许在运行时创建一个实现了特定接口的新类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值