CGLib动态代理

最新推荐文章于 2024-04-11 20:55:34 发布
最新推荐文章于 2024-04-11 20:55:34 发布
阅读量555 收藏 5
点赞数 4
分类专栏： 设计模式 文章标签： java 反射 proxy 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43955361/article/details/113834503
版权
本文详细介绍了CGLib动态代理的原理和使用，包括如何创建代理对象、设置拦截器和回调方法，以及在懒加载和接口生成等方面的应用。通过示例代码展示了CGLib如何实现代理类的生成和方法拦截，强调了其无需接口、方法级别拦截和不使用反射执行等特点。
摘要由CSDN通过智能技术生成

CGLib动态代理

1.概述

  1. CGLib动态代理不要求委托方法需要实现接口。
  2. CGLib动态代理能够实现基于方法级别的拦截处理。
  3. CGLib动态代理执行方法，不是使用反射执行Method.invoke()。
  4. CGLib不能对声明为final的方法进行代理。

2.使用

1.Callback
public class TargetObject {
    public String method1(String paramName) {
        return paramName;
    }

    public int method2(int count) {
        return count;
    }

    public int method3(int count) {
        return count;
    }

    @Override
    public String toString() {
        return "TargetObject []"+ getClass();
    }
}

public class TargetInterceptor implements MethodInterceptor {
    /**
     * 重写方法拦截在方法前和方法后加入业务
     * Object obj为目标对象
     * Method method为目标方法
     * Object[] params 为参数，
     * MethodProxy proxy CGlib方法代理对象
     */
    public Object intercept(Object obj, Method method, Object[] params,
                            MethodProxy proxy) throws Throwable {
        System.out.println("调用前");
        Object result = proxy.invokeSuper(obj, params);
        System.out.println(" 调用后"+result);
        return result;
    }
}

public class TargetResultFixed implements FixedValue {

    /**
     * 该类实现FixedValue接口，同时锁定回调值为999
     * (整型，CallbackFilter中定义的使用FixedValue型回调的方法为getConcreteMethodFixedValue，该方法返回值为整型)。
     */

    public Object loadObject() throws Exception {
        System.out.println("锁定结果");
        Object obj = 999;
        return obj;
    }

}

public class TargetMethodCallbackFilter implements CallbackFilter {

    /**
     * 过滤方法
     * 返回的值为数字，代表了Callback数组中的索引位置，要到用的Callback
     */
    public int accept(Method method) {
        if(method.getName().equals("method1")){
            System.out.println("filter method1 ==0");
            return 0;
        }
        if(method.getName().equals("method2")){
            System.out.println("filter method2 ==1");
            return 1;
        }
        if(method.getName().equals("method3")){
            System.out.println("filter method3 ==2");
            return 2;
        }
        return 0;
    }

}

public class TestCglib {
    public static void main(String args[]) throws Exception{
        Enhancer enhancer =new Enhancer();
        enhancer.setSuperclass(TargetObject.class);
        CallbackFilter callbackFilter = new TargetMethodCallbackFilter();

        /**
         * (1)callback1：方法拦截器
         (2)NoOp.INSTANCE：这个NoOp表示no operator，即什么操作也不做，代理类直接调用被代理的方法不进行拦截。
         (3)FixedValue：表示锁定方法返回值，无论被代理类的方法返回什么值，回调方法都返回固定值。
         */
        Callback noopCb= NoOp.INSTANCE;
        Callback callback1=new TargetInterceptor();
        Callback fixedValue=new TargetResultFixed();
        Callback[] cbarray=new Callback[]{callback1,noopCb,fixedValue};
        //enhancer.setCallback(new TargetInterceptor());
        enhancer.setCallbacks(cbarray);
        enhancer.setCallbackFilter(callbackFilter);
        TargetObject targetObject2=(TargetObject)enhancer.create();
        System.out.println(targetObject2);
        System.out.println(targetObject2.method1("mmm1"));
        System.out.println(targetObject2.method2(100));
        System.out.println(targetObject2.method3(100));
        System.out.println(targetObject2.method3(200));
        //下述方法将生成的代理类字节码输出到class文件中，然后反编译查看。
        byte[] b = new DefaultGeneratorStrategy().generate(enhancer);
        File file = new File("MyProxyClass.class");
        FileOutputStream fos = new FileOutputStream(file);
        fos.write(b);
        fos.flush();
        fos.close();
    }
}

结果：

在这里插入图片描述

对字节码进行反编译分析：

//该类继承自目标类(被代理类)
public class TargetObject$$EnhancerByCGLIB$$413697a3 extends TargetObject implements Factory {
    private boolean CGLIB$BOUND;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private NoOp CGLIB$CALLBACK_1;
    private FixedValue CGLIB$CALLBACK_2;
    private static final Method CGLIB$toString$0$Method;
    private static final MethodProxy CGLIB$toString$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$method1$2$Method;
    private static final MethodProxy CGLIB$method1$2$Proxy;
    private static final Method CGLIB$finalize$4$Method;
    private static final MethodProxy CGLIB$finalize$4$Proxy;
    private static final Method CGLIB$equals$5$Method;
    private static final MethodProxy CGLIB$equals$5$Proxy;
    private static final Method CGLIB$hashCode$6$Method;
    private static final MethodProxy CGLIB$hashCode$6$Proxy;
    private static final Method CGLIB$clone$7$Method;
    private static final MethodProxy CGLIB$clone$7$Proxy;

    //在该类加载时，调用，为上面的静态属性赋值。
    static void CGLIB$STATICHOOK2() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("Designpattern.CGlibProxy.scholl.TargetObject$$EnhancerByCGLIB$$413697a3");
        Class var1;
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"toString", "()Ljava/lang/String;", "method1", "(Ljava/lang/String;)Ljava/lang/String;"}, (var1 = Class.forName("Designpattern.CGlibProxy.scholl.TargetObject")).getDeclaredMethods());
        CGLIB$toString$0$Method = var10000[0];
        CGLIB$toString$0$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$0");
        CGLIB$method1$2$Method = var10000[1];
        CGLIB$method1$2$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)Ljava/lang/String;", "method1", "CGLIB$method1$2");
        var10000 = ReflectUtils.findMethods(new String[]{"finalize", "()V", "equals", "(Ljava/lang/Object;)Z", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$finalize$4$Method = var10000[0];
        CGLIB$finalize$4$Proxy = MethodProxy.create(var1, var0, "()V", "finalize", "CGLIB$finalize$4");
        CGLIB$equals$5$Method = var10000[1];
        CGLIB$equals$5$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$5");
        CGLIB$hashCode$6$Method = var10000[2];
        CGLIB$hashCode$6$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$6");
        CGLIB$clone$7$Method = var10000[3];
        CGLIB$clone$7$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$7");
    }
	//带有CGLIB$xxx的方法，最终会调用父类方法。
    final String CGLIB$toString$0() {
        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$0$Method, CGLIB$emptyArgs, CGLIB$toString$0$Proxy) : super.toString();
    }

    final String CGLIB$method1$2(String var1) {
        return super.method1(var1);
    }
	//目标类的method1方法。
    public final String method1(String var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }
		//调用MethodInterceptor.intercept()
        return var10000 != null ? (String)var10000.intercept(this, CGLIB$method1$2$Method, new Object[]{var1}, CGLIB$method1$2$Proxy) : super.method1(var1);
    }

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

    protected final void finalize() throws Throwable {
        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$finalize$4$Method, CGLIB$emptyArgs, CGLIB$finalize$4$Proxy);
        } else {
            super.finalize();
        }
    }

    final boolean CGLIB$equals$5(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$5$Method, new Object[]{var1}, CGLIB$equals$5$Proxy);
            return var2 == null ? false : (Boolean)var2;
        } else {
            return super.equals(var1);
        }
    }

    final int CGLIB$hashCode$6() {
        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$6$Method, CGLIB$emptyArgs, CGLIB$hashCode$6$Proxy);
            return var1 == null ? 0 : ((Number)var1).intValue();
        } else {
            return super.hashCode();
        }
    }

    final Object CGLIB$clone$7() 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$7$Method, CGLIB$emptyArgs, CGLIB$clone$7$Proxy) : super.clone();
    }

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

        return null;
    }
	//method3
    public final int method3(int var1) {
        FixedValue var10000 = this.CGLIB$CALLBACK_2;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_2;
        }
		//直接调用FixedValue.loadObject()
        Object var2 = var10000.loadObject();
        return var2 == null ? 0 : ((Number)var2).intValue();
    }
	//代理类的构造方法
    public TargetObject$$EnhancerByCGLIB$$413697a3() {
        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) {
        TargetObject$$EnhancerByCGLIB$$413697a3 var1 = (TargetObject$$EnhancerByCGLIB$$413697a3)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;
                }
            }

            Callback[] var10001 = (Callback[])var10000;
            var1.CGLIB$CALLBACK_2 = (FixedValue)((Callback[])var10000)[2];
            var1.CGLIB$CALLBACK_1 = (NoOp)var10001[1];
            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)var10001[0];
        }

    }
	//返回一个新的该代理类
    public Object newInstance(Callback[] var1) {
        CGLIB$SET_THREAD_CALLBACKS(var1);
        TargetObject$$EnhancerByCGLIB$$413697a3 var10000 = new TargetObject$$EnhancerByCGLIB$$413697a3();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Callback var1) {
        throw new IllegalStateException("More than one callback object required");
    }

    public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        TargetObject$$EnhancerByCGLIB$$413697a3 var10000 = new TargetObject$$EnhancerByCGLIB$$413697a3;
        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);
        Object var10000;
        switch(var1) {
        case 0:
            var10000 = this.CGLIB$CALLBACK_0;
            break;
        case 1:
            var10000 = this.CGLIB$CALLBACK_1;
            break;
        case 2:
            var10000 = this.CGLIB$CALLBACK_2;
            break;
        default:
            var10000 = null;
        }

        return (Callback)var10000;
    }

    public void setCallback(int var1, Callback var2) {
        switch(var1) {
        case 0:
            this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
            break;
        case 1:
            this.CGLIB$CALLBACK_1 = (NoOp)var2;
            break;
        case 2:
            this.CGLIB$CALLBACK_2 = (FixedValue)var2;
        }

    }

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

    public void setCallbacks(Callback[] var1) {
        this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
        this.CGLIB$CALLBACK_1 = (NoOp)var1[1];
        this.CGLIB$CALLBACK_2 = (FixedValue)var1[2];
    }
	//调用最开始的那个静态方法。
    static {
        CGLIB$STATICHOOK2();
    }
}
//可以看到没有method2方法，因为method2方法使用NoOp.INSTANCE拦截，因此可以直接调用代理类父类的method2方法.
2.懒加载
public class TargetObject {
    public String method1(String paramName) {
        return paramName;
    }

    public int method2(int count) {
        return count;
    }

    public int method3(int count) {
        return count;
    }

    @Override
    public String toString() {
        return "TargetObject []"+ getClass();
    }

public class PropertyBean {
    private String key;
    private Object value;
    public String getKey() {
        return key;
    }
    public void setKey(String key) {
        this.key = key;
    }
    public Object getValue() {
        return value;
    }
    public void setValue(Object value) {
        this.value = value;
    }
    @Override
    public String toString() {
        return "PropertyBean [key=" + key + ", value=" + value + "]" +getClass();
    }

}

public class ConcreteClassLazyLoader implements LazyLoader {
    /**
     * 对需要延迟加载的对象添加代理，在获取该对象属性时先通过代理类回调方法进行对象初始化。
     * 在不需要加载该对象时，只要不去获取该对象内属性，该对象就不会被初始化了（在CGLib的实现中只要去访问该对象内属性的getter方法，
     * 就会自动触发代理类回调）。
     */

    public Object loadObject() throws Exception {
        System.out.println("before lazyLoader...");
        PropertyBean propertyBean = new PropertyBean();
        propertyBean.setKey("zghw");
        propertyBean.setValue(new TargetObject());
        System.out.println("after lazyLoader...");
        return propertyBean;
    }

}

public class ConcreteClassDispatcher implements Dispatcher{


    public Object loadObject() throws Exception {
        System.out.println("before Dispatcher...");
        PropertyBean propertyBean = new PropertyBean();
        propertyBean.setKey("xxx");
        propertyBean.setValue(new TargetObject());
        System.out.println("after Dispatcher...");
        return propertyBean;
    }

}

public class LazyBean {
    private String name;
    private int age;
    private PropertyBean propertyBean;
    private PropertyBean propertyBeanDispatcher;

    public LazyBean(String name, int age) {
        System.out.println("lazy bean init");
        this.name = name;
        this.age = age;
        this.propertyBean = createPropertyBean();
        this.propertyBeanDispatcher = createPropertyBeanDispatcher();
    }



    /**
     * 只第一次懒加载
     * @return
     */
    private PropertyBean createPropertyBean() {
        /**
         * 使用cglib进行懒加载 对需要延迟加载的对象添加代理，在获取该对象属性时先通过代理类回调方法进行对象初始化。
         * 在不需要加载该对象时，只要不去获取该对象内属性，该对象就不会被初始化了（在CGLib的实现中只要去访问该对象内属性的getter方法，
         * 就会自动触发代理类回调）。
         */
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(PropertyBean.class);
        PropertyBean pb = (PropertyBean) enhancer.create(PropertyBean.class,
                new ConcreteClassLazyLoader());
        return pb;
    }
    /**
     * 每次都懒加载
     * @return
     */
    private PropertyBean createPropertyBeanDispatcher() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(PropertyBean.class);
        PropertyBean pb = (PropertyBean) enhancer.create(PropertyBean.class,
                new ConcreteClassDispatcher());
        return pb;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public PropertyBean getPropertyBean() {
        return propertyBean;
    }

    public void setPropertyBean(PropertyBean propertyBean) {
        this.propertyBean = propertyBean;
    }

    public PropertyBean getPropertyBeanDispatcher() {
        return propertyBeanDispatcher;
    }

    public void setPropertyBeanDispatcher(PropertyBean propertyBeanDispatcher) {
        this.propertyBeanDispatcher = propertyBeanDispatcher;
    }

    @Override
    public String toString() {
        return "LazyBean [name=" + name + ", age=" + age + ", propertyBean="
                + propertyBean + "]";
    }
}

测试：

public class Main {
    public static void main(String[] args) throws Exception{
        LazyBean lazyBean  = new LazyBean("涨",20);
        System.out.println("lazyBean---------实例化完成");
        lazyBean.getPropertyBean().getValue();
        lazyBean.getPropertyBean().getValue();
        System.out.println("----------------------------");
        lazyBean.getPropertyBeanDispatcher().getValue();
        lazyBean.getPropertyBeanDispatcher().getValue();

    }
}

结果：

在这里插入图片描述

3.根据目标类，新建接口
public class TargetObject {
    public String method1(String paramName) {
        return paramName;
    }

    public int method2(int count) {
        return count;
    }

    public int method3(int count) {
        return count;
    }

    @Override
    public String toString() {
        return "TargetObject []"+ getClass();
    }
}

public class TestInterfaceMaker {

    public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        InterfaceMaker interfaceMaker =new InterfaceMaker();
        //抽取某个类的方法生成接口方法
        interfaceMaker.add(TargetObject.class);
        Class<?> targetInterface=interfaceMaker.create();
        for(Method method : targetInterface.getMethods()){
            System.out.println(method.getName());
        }
        //接口代理并设置代理接口方法拦截
        Object object = Enhancer.create(Object.class, new Class[]{targetInterface}, new MethodInterceptor(){

            public Object intercept(Object obj, Method method, Object[] args,
                                    MethodProxy methodProxy) throws Throwable {
                if(method.getName().equals("method1")){
                    System.out.println("filter method1 ");
                    return "mmmmmmmmm";
                }
                if(method.getName().equals("method2")){
                    System.out.println("filter method2 ");
                    return 1111111;
                }
                if(method.getName().equals("method3")){
                    System.out.println("filter method3 ");
                    return 3333;
                }
                return "default";
            }});
        Method targetMethod1=object.getClass().getMethod("method3",new Class[]{int.class});
        int i=(Integer) targetMethod1.invoke(object, new Object[]{33});
        Method targetMethod=object.getClass().getMethod("method1",new Class[]{String.class});
        System.out.println(targetMethod.invoke(object, new Object[]{"sdfs"}));
    }
}

结果：
在这里插入图片描述

hbvfhb
关注
专栏目录
你必须会的 JDK 动态代理和 CGLIB 动态代理
12-21
CGLIB代理适用于不依赖接口的目标类。 总结来说，静态代理简单直观，但灵活性差；JDK动态代理基于接口，适用于接口众多的情况，但不支持非接口类；CGLIB则弥补了JDK动态代理的这一不足，适用于没有接口或接口较少的...
CGLIB动态代理详解分析
weixin_43397326的博客
07-06 6158
CGLIB是强大的、高性能的代码生成库，被广泛应用于AOP框架，它底层使用ASM来操作字节码生成新的类，为对象引入间接级别，以控制对象的访问。CGLIB相比于JDK动态代理更加强大，JDK动态代理只能对接口进行代理，而CGLIB既可以代理普通类，也能够代理接口。
cglib动态代理
NCS123456的博客
06-13 1万+
CGLIB（Code Generation Library），是一个强大的，高性能，高质量的 Code 生成类库，它可以在运行期扩展 Java 类与实现 Java 接口。
动态代理模式 -- Cglib代理
weixin_43739348的博客
03-19 1719
静态代理和 JDK 代理模式都要求目标对象是实现一个接口,但是有时候目标对象只是一个 单独的对象,并没 有实现任何的接口,这个时候可使用目标对象子类来实现代理-这就是 Cglib 代理Cglib代理也叫作 子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能扩展, 有些书也将Cglib代理归属到动态代理。Cglib 是一个强大的高性能的代码生成包,它可以在运行期扩展 java 类与实现 java 接口.它广泛的被许多 AOP 的框架使用,例如 SpringAOP，实现方法拦截。
Spring高手之路17——动态代理的艺术与实践
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
04-11 1万+
本文深入分析了JDK和CGLIB两种动态代理技术在Spring框架中的应用。讨论了动态代理的基础概念，通过实例展示了如何实现和应用这两种方法，并比较了它们的性能差异及适用场景。进一步，探讨了在动态代理中实现熔断限流和日志监控的策略，以及如何利用动态代理优化Spring应用的设计和功能。
动态代理之 cglib 实现
冷血之心的博客
02-17 8669
（尊重劳动成果，转载请注明出处：https://blog.csdn.net/qq_25827845/article/details/87513102冷血之心的博客） 目录 前言： 正文： AOP（面向切面编程） JDK动态代理 cglib实现动态代理 cglib包结构： cglib动态代理相关的基础类： cglib动态代理Demo 总结： 前言：         这篇文...
cglib动态代理介绍
04-19
CGlib则是Java动态代理的一种实现方式，尤其是在不提供接口的情况下，它通过生成目标类的子类来实现动态代理。 在Java中，JDK自带的动态代理机制是基于接口的，如果被代理的类没有实现任何接口，那么就无法使用JDK...
基于MAVEN项目的CGLib动态代理原理及实现
01-15
本文将深入探讨如何在基于Maven的项目中利用CGLib库实现动态代理。CGLib（Code Generation Library）是Java中一个高性能的代码生成库，它在运行期通过字节码技术为类创建子类，以此实现动态代理。 1. Maven项目配置...
CGLIB动态代理+CGLIB动态代理完整代码
最新发布
05-13
我们最终是通过一个代理对象去调用方法的，那我们就要获取一个代理对象，cglib代理，是通过Enhancer这个类里面对应的一个create()方法，去生成一个代理对象的。 Enhancer创建一个被代理对象的子类并且拦截所有的方法...
JDK动态代理和Cglib动态代理实例源码
01-04
本篇将详细探讨JDK动态代理和Cglib动态代理，并通过源码实例来加深理解。 首先，JDK动态代理是Java内置的一种机制，它依赖于`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口。`Proxy`类...
【cglib实现动态代理】
edwer93的博客
11-29 1074
cglib是是第三方的工具库。其原理是继承，cglib通过继承目标类，创建他的子类，在子类当中重写父类的相关方法，实现功能的增强。
CGLIB 动态代理
m0_61609890的博客
03-11 7087
目录 CGLIB 动态代理 简单结构: 添加依赖 定义类 CGLIB 动态代理 JDK的动态代理机制只能代理实现了接口的类。而不能实现接口的类就不能使用JDK的动态代理，CGLIB是针对类来实现代理的，它的原理是对指定目标类生成一个子类，并覆盖其中的方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。 简单结构: 实现原理:继承思想 代理类继承目标类，重写目标类中的方法， CGLIB像是一个拦截器，在调用我们的代...
【好记性不如烂笔头】CGLIB动态代理简述与实现
记录并分享信息的载体
10-07 496
前文学习了jdk动态代理，这里记录一下cglib动态代理CGLIB是一个强大的高性能高质量的Code生成类库，它可以再运行期扩展Java类实现Java接口。也被广泛的应用于AOP的使用。cglib底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。基于ASM操作字节码实现的，相对JDK动态代理的代理范围要更完善，性能更高，不过需要注意的是，这些字节码文件也是会被放在JVM内存中的，要注意OOM异常。
【保姆级】手把手捋动态代理流程（JDK+Cglib超详细源码分析）
热门推荐
aqin1012的博客
02-23 23万+
动态代理，通俗点说就是：无需声明式的创建java代理类，而是在运行过程中生成"虚拟"的代理类，被ClassLoader加载。从而避免了静态代理那样需要声明大量的代理类。上面的简介中提到了两个关键的名词：“静态代理”和“动态代理”我们先来看来下两个问题：首先什么是代理呢？它可以看作是对最终调用目标的一个封装，可以通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合“静态代理”和“动态代理”又有什么区别呢？
Spring AOP 实现原理详解之 CGLIB 动态代理
流华追梦的专栏
02-23 1639
CGLIB 是一个强大的高性能的代码生成包。它广泛的被许多 AOP 的框架使用，例如 Spring AOP 和 dynaop，为他们提供方法的 interception（拦截）。CGLIB 包的底层是通过使用一个小而快的字节码处理框架 ASM，来转换字节码并生成新的类。除了 CGLIB 包，脚本语言例如 Groovy和 BeanShell，也是使用 ASM 来生成 Java 的字节码。当然不鼓励直接使用 ASM，因为它要求你必须对 JVM 内部结构包括 class 文件的格式和指令集都很熟悉。引入 CGLI
Java编程使用CGLIB动态代理介绍与实战演示
勤于笔记，成于点滴。
04-03 1344
以上就是一个完整的Java CGLIB动态代理实例。通过这个例子，可以看到我们成功地对ActionUserDataServiceImpl 类进行了代理，代理过程中插入了额外的前后置处理逻辑，而无需修改原有类的代码。在实际使用时，我们应根据项目需求和目标类特性选择合适的代理方案，不仅仅限制于CGLIB，如果有实现接口的类用JDK也可，这样才能达到事半功倍的效果。
动态代理之cglib代理
qq_37342720的博客
01-05 465
看了 上云 老师的视频，整理下。
深入解析JDK与Cglib动态代理实例源码
资源摘要信息:"JDK动态代理和Cglib动态代理是两种常见的动态代理实现方式。它们通常用于面向切面编程（AOP）中，使得开发者可以在不修改源代码的情况下增加额外的行为。以下将详细介绍这两种动态代理的实例源码，以...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值