cglib动态代理

最新推荐文章于 2024-04-17 17:28:09 发布
最新推荐文章于 2024-04-17 17:28:09 发布
阅读量338 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wz_ling1991/article/details/120519457
版权

cglib实现动态代理：本质是继承被代理类，通过MethodInterceptor作为切入点，织入一些逻辑，同时//通过代理类调用父类中的方法，以实现被代理类调用目标方法。

cglid动态代理核心接口，实现该接口，重写intercept方法，即可织入代理前后的逻辑。

package wz_ling.learning.proxy;

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * cglid动态代理，方法切入实现类：实现MethodInterceptor类，重写intercept方法
 */
public class MethodInterceptorImpl implements MethodInterceptor {

    /**
     * @param o           代理对象
     * @param method      
     * @param objects     方法参数
     * @param methodProxy 代理方法
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before proxy");
        //通过代理类调用父类中的方法，这里有没有其他的调用方式呢？
        Object invoke = methodProxy.invokeSuper(o, objects);
        System.out.println("after proxy");
        return invoke;
    }
}

ProxyDemo类

package wz_ling.learning.proxy;

import org.springframework.cglib.core.DebuggingClassWriter;
import org.springframework.cglib.proxy.Enhancer;

public class ProxyDemo {
    public static void main(String[] args) {
    	//设置字节码生成的位置
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, ".\\proxy");
        Enhancer enhancer = new Enhancer();
        // 设置enhancer对象的父类
        enhancer.setSuperclass(RealObject.class);
        enhancer.setCallback(new MethodInterceptorImpl());

        RealObject proxy = (RealObject) enhancer.create();
        proxy.sayGoodBye();
        proxy.playGame("真~三国无双");
    }
}

生成代理类的字节码

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

package wz_ling.learning.proxy;

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

public class RealObject$$EnhancerByCGLIB$$52f43606 extends RealObject 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$sayGoodBye$0$Method;
    private static final MethodProxy CGLIB$sayGoodBye$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$playGame$1$Method;
    private static final MethodProxy CGLIB$playGame$1$Proxy;
    private static final Method CGLIB$equals$2$Method;
    private static final MethodProxy CGLIB$equals$2$Proxy;
    private static final Method CGLIB$toString$3$Method;
    private static final MethodProxy CGLIB$toString$3$Proxy;
    private static final Method CGLIB$hashCode$4$Method;
    private static final MethodProxy CGLIB$hashCode$4$Proxy;
    private static final Method CGLIB$clone$5$Method;
    private static final MethodProxy CGLIB$clone$5$Proxy;

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("wz_ling.learning.proxy.RealObject$$EnhancerByCGLIB$$52f43606");
        Class var1;
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"sayGoodBye", "()Ljava/lang/String;", "playGame", "(Ljava/lang/String;)V"}, (var1 = Class.forName("wz_ling.learning.proxy.RealObject")).getDeclaredMethods());
        CGLIB$sayGoodBye$0$Method = var10000[0];
        CGLIB$sayGoodBye$0$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "sayGoodBye", "CGLIB$sayGoodBye$0");
        CGLIB$playGame$1$Method = var10000[1];
        CGLIB$playGame$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)V", "playGame", "CGLIB$playGame$1");
        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$2$Method = var10000[0];
        CGLIB$equals$2$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$2");
        CGLIB$toString$3$Method = var10000[1];
        CGLIB$toString$3$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$3");
        CGLIB$hashCode$4$Method = var10000[2];
        CGLIB$hashCode$4$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$4");
        CGLIB$clone$5$Method = var10000[3];
        CGLIB$clone$5$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
    }

    final String CGLIB$sayGoodBye$0() {
        return super.sayGoodBye();
    }

    public final String sayGoodBye() {
        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$sayGoodBye$0$Method, CGLIB$emptyArgs, CGLIB$sayGoodBye$0$Proxy) : super.sayGoodBye();
    }

    final void CGLIB$playGame$1(String var1) {
        super.playGame(var1);
    }

    public final void playGame(String var1) {
        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$playGame$1$Method, new Object[]{var1}, CGLIB$playGame$1$Proxy);
        } else {
            super.playGame(var1);
        }
    }

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

    final String CGLIB$toString$3() {
        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$3$Method, CGLIB$emptyArgs, CGLIB$toString$3$Proxy) : super.toString();
    }

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

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

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

        return null;
    }

    public RealObject$$EnhancerByCGLIB$$52f43606() {
        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) {
        RealObject$$EnhancerByCGLIB$$52f43606 var1 = (RealObject$$EnhancerByCGLIB$$52f43606)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);
        RealObject$$EnhancerByCGLIB$$52f43606 var10000 = new RealObject$$EnhancerByCGLIB$$52f43606();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Callback var1) {
        CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1});
        RealObject$$EnhancerByCGLIB$$52f43606 var10000 = new RealObject$$EnhancerByCGLIB$$52f43606();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        RealObject$$EnhancerByCGLIB$$52f43606 var10000 = new RealObject$$EnhancerByCGLIB$$52f43606;
        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();
    }
}

可以看到，生成的代理类，继承了被代理类，同时被代理类中设置了callbacks。可以看到代理类中有和被代理类的签名一样的方法，关键代码

if (var10000 != null) {
	//关键代码，这里最终会实际调用被代理对象的方法
	var10000.intercept(this, CGLIB$playGame$1$Method, new Object[]{var1},CGLIB$playGame$1$Proxy);
} else {
    super.playGame(var1);
}

由此：cglib代理也是有限制的，不能代理final类（无法继承），final方法（无法重写）

wz_ling1991
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
你必须会的 JDK 动态代理和 CGLIB 动态代理
12-21
CGLIB代理适用于不依赖接口的目标类。 总结来说，静态代理简单直观，但灵活性差；JDK动态代理基于接口，适用于接口众多的情况，但不支持非接口类；CGLIB则弥补了JDK动态代理的这一不足，适用于没有接口或接口较少的...
【动态代理】CGLIB 动态代理的使用及原理
sco5282的博客
12-11 9434
JDK 的中动态代理类位于 java.lang.reflect 包下，一般主要涉及到以下两个类：
CGLIB动态代理的使用
qq_61267719的博客
06-14 470
CGLIB动态代理是通过继承被代理类来实现代理的，所以被代理类不用实现接口。使用动态代理能够把代理的方法都集成在一个方法invoke中，即使新增方法，也不用修改代理类，扩展性好。在很多地方都用到了代理，比如spring的aop就是通过代理实现的。鉴权也是通过代理。关于CJLib的具体解释可查看这篇文章CGLIB动态代理之intercept函数刨析_cglib intercept_一个默默努力的人的博客-CSDN博客。
动态代理（JDK+CGLIB ）
weixin_45134135的博客
04-17 872
动态代理是一种在运行时生成代理类的技术，它允许在不知道具体接口或类的情况下创建代理对象，并在代理对象的方法执行前后插入额外的逻辑。在 Java 中，通常有两种动态代理的实现方式：基于 JDK 的动态代理和基于 CGLIB 的动态代理。
JDK动态代理和CGLIB动态代理
努力努力再努力的小笼包
05-30 8060
在SpringAOP中基于动态代理实现功能的增强，也就是动态的生成代理类，在代理类中织入增强的逻辑然后调用目标对象的方法。动态代理中用的比较多的两种：JDK动态代理、CGLIB动态代理。 JDK动态代理 使用JDK的java.lang.reflect.Proxy类的newProxyInstance方法实现的代理。 用一个测试接口看下具体实现： public interface JdkProxyDemoService { void queryTrs(); } @Service public
【深度思考】聊聊CGLIB动态代理原理
2301_76429513的博客
08-15 737
CGLIB的全称是：Code Generation Library。CGLIB是一个强大的、高性能、高质量的代码生成类库，它可以在运行期扩展Java类与实现Java接口，底层使用的是字节码处理框架ASM。。
CGLIB动态代理详解分析
weixin_43397326的博客
07-06 5771
CGLIB是强大的、高性能的代码生成库，被广泛应用于AOP框架，它底层使用ASM来操作字节码生成新的类，为对象引入间接级别，以控制对象的访问。CGLIB相比于JDK动态代理更加强大，JDK动态代理只能对接口进行代理，而CGLIB既可以代理普通类，也能够代理接口。
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动态代理 | 如何生成代理类、代理类内容解析
devops
06-24 4552
CgLib（Code Generation Library）是一个针对java，且开源的代码生成类库，封装了ASM，ASM可以直接产生二进制class文件。
JDK和CGLIB动态代理原理
m0_38033199的博客
07-27 1310
JDK和CGLIB动态代理原理解析
动态代理模式之cglib和JDK动态代理
搬运工007
11-22 750
一文讲清楚动态代理模式
CGLIB 动态代理机制
weixin_66123436的博客
02-24 218
例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理。很多知名的开源框架都使用到了。类来动态获取被代理类，当代理类调用方法的时候，实际调用的是。用于拦截增强被代理类的方法。
class org.springframework.cglib.core.DebuggingClassWriter has interface org.springframework.asm.Clas
叶落无痕，枫过有情……
05-04 2381
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'signInDao' defined in ServletContext resource [/WEB-INF/applicationContext.xml]: Initialization of bean failed;
通俗易懂 快速理解 JDK动态代理 和 cglib动态代理
热门推荐
weixin_43935152的博客
05-05 1万+
动态代理有两种： ① jdk动态代理，要求必须有接口，最终生成的代理类和目标类实现相同的接口，在com.sun.proxy包下，类名为$proxy+数字 （例如：$proxy6） ② cglib动态代理，最终生成的代理类会继承目标类，并且和目标类在相同的包下
Cglib动态代理实现及原理
汉南最後の読書人
01-04 812
通过字节码技术创建这个类的子类，实现动态代理/*** 被代理类*/System.out.println("被代理的方法执行了");}}该类实现了创建子类的方法与代理的方法。//设置父类方法通过入参即父类的字节码，扩展父类的class来创建代理对象。intercept()方法拦截所有目标类方法的调用，obj表示目标类的实例，method为目标类方法的反射对象，args为方法的动态入参，methodProxy为代理类实例。通过代理类调用父类中的方法。
cglib动态代理intercept
04-18
CGLIB动态代理是CGLIB库的一个重要特性，它通过生成目标类的子类来实现代理。 在CGLIB动态代理中，我们可以使用`MethodInterceptor`接口来定义代理逻辑。`MethodInterceptor`接口有一个`intercept`方法，该方法在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值