cglib工作原理

最新推荐文章于 2020-11-03 11:01:42 发布
最新推荐文章于 2020-11-03 11:01:42 发布
阅读量138 收藏
点赞数
分类专栏： Java 文章标签： java proxy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/uciaqgjj/article/details/105156488
版权
准备测试环境
public class PersonService {
    public String sayHello(String name) {
        return "Hello " + name;
    }
 
    public Integer lengthOfName(String name) {
        return name.length();
    }
}

    @Test
    public void givenEnhancer_whenExecuteMethodOnProxy_thenInterceptOnlyStringReturnTypeMethod() throws Exception {

        // given
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(PersonService.class);
        enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> {
            if (method.getDeclaringClass() != Object.class && method.getReturnType() == String.class) {
                return "Hello Tom!";
            } else {
                return proxy.invokeSuper(obj, args);
            }
        });

        // when
        PersonService proxy = (PersonService) enhancer.create();

        // then
        assertEquals("Hello Tom!", proxy.sayHello(null));
        int lengthOfName = proxy.lengthOfName("Mary");
        assertEquals(4, lengthOfName);
    }
生成代码
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package me.uc.cglib;

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 PersonService$$EnhancerByCGLIB$$d4596647 extends PersonService 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$lengthOfName$0$Method;
    private static final MethodProxy CGLIB$lengthOfName$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$sayHello$1$Method;
    private static final MethodProxy CGLIB$sayHello$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("me.uc.cglib.PersonService$$EnhancerByCGLIB$$d4596647");
        Class var1;
        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$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");
        // 原始方法原型数组
        var10000 = ReflectUtils.findMethods(new String[]{"lengthOfName", "(Ljava/lang/String;)Ljava/lang/Integer;", "sayHello", "(Ljava/lang/String;)Ljava/lang/String;"}, (var1 = Class.forName("me.uc.cglib.PersonService")).getDeclaredMethods());
        // 原始方法原型　lengthOfName　拦截的第二个参数
        CGLIB$lengthOfName$0$Method = var10000[0];
        //代理方法　拦截的第四个参数 这个是关键
        CGLIB$lengthOfName$0$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)Ljava/lang/Integer;", "lengthOfName", "CGLIB$lengthOfName$0");
        // sayHello相关代码
        CGLIB$sayHello$1$Method = var10000[1];
        CGLIB$sayHello$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)Ljava/lang/String;", "sayHello", "CGLIB$sayHello$1");
    }

    final Integer CGLIB$lengthOfName$0(String var1) {
        return super.lengthOfName(var1);
    }

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

        return var10000 != null ? (Integer)var10000.intercept(this, CGLIB$lengthOfName$0$Method, new Object[]{var1}, CGLIB$lengthOfName$0$Proxy) : super.lengthOfName(var1);
    }

    final String CGLIB$sayHello$1(String var1) {
        return super.sayHello(var1);
    }

    public final String sayHello(String var1) {
        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$sayHello$1$Method, new Object[]{var1}, CGLIB$sayHello$1$Proxy) : super.sayHello(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 -1816210712:
            if (var10000.equals("sayHello(Ljava/lang/String;)Ljava/lang/String;")) {
                return CGLIB$sayHello$1$Proxy;
            }
            break;
        case -1146295586:
            if (var10000.equals("lengthOfName(Ljava/lang/String;)Ljava/lang/Integer;")) {
                return CGLIB$lengthOfName$0$Proxy;
            }
            break;
        case -508378822:
            if (var10000.equals("clone()Ljava/lang/Object;")) {
                return CGLIB$clone$5$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 PersonService$$EnhancerByCGLIB$$d4596647() {
        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) {
        PersonService$$EnhancerByCGLIB$$d4596647 var1 = (PersonService$$EnhancerByCGLIB$$d4596647)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);
        PersonService$$EnhancerByCGLIB$$d4596647 var10000 = new PersonService$$EnhancerByCGLIB$$d4596647();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

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

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

每个被代理的方法会生成两个相关静态相关对象，分别是方法原型的描述和代理对象
代理对象关键方法

    /**
     * Invoke the original method, on a different object of the same type.
     * @param obj the compatible object; recursion will result if you use the object passed as the first
     * argument to the MethodInterceptor (usually not what you want)
     * @param args the arguments passed to the intercepted method; you may substitute a different
     * argument array as long as the types are compatible
     * @see MethodInterceptor#intercept
     * @throws Throwable the bare exceptions thrown by the called method are passed through
     * without wrapping in an <code>InvocationTargetException</code>
     */
    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;
        }
    }

    /**
     * Invoke the original (super) method on the specified object.
     * @param obj the enhanced object, must be the object passed as the first
     * argument to the MethodInterceptor
     * @param args the arguments passed to the intercepted method; you may substitute a different
     * argument array as long as the types are compatible
     * @see MethodInterceptor#intercept
     * @throws Throwable the bare exceptions thrown by the called method are passed through
     * without wrapping in an <code>InvocationTargetException</code>
     */
    public Object invokeSuper(Object obj, Object[] args) throws Throwable {
        try {
            init();
            FastClassInfo fci = fastClassInfo;
            // 调用原始方法
            return fci.f2.invoke(fci.i2, obj, args);
        } catch (InvocationTargetException e) {
            throw e.getTargetException();
        }
    }

cglib 在运行时会生成一个map, 给每个方法加一个数字索引，调用时通过索引拿到方法原型，具体实现在生成的FastClass中

参考
http://mydailyjava.blogspot.com/2013/11/cglib-missing-manual.html
https://dzone.com/articles/cglib-missing-manual
https://dzone.com/articles/dynamic-class-enhancement-with-cglib
https://objectcomputing.com/resources/publications/sett/november-2005-create-proxies-dynamically-using-cglib-library
https://javax0.wordpress.com/2016/01/27/creating-a-proxy-object-using-cglib/
https://www.baeldung.com/cglib

firstuc
关注
专栏目录
CGLIB动态代理的实现及原理
留下你的观点
02-08 472
CGLIB介绍与原理(部分节选自网络)一、什么是CGLIB?CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。通常可以使用Java的动态代理创建代理，但当要代理的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择。二、CGLIB原理CGLIB原理：动态生成一个要代理类的子类，子类重写要代理的类的所有不是final的方法。在子类中...
JDK和CGLIB动态代理原理
m0_38033199的博客
07-27 1359
JDK和CGLIB动态代理原理解析
Spring Aop之Cglib实现原理详解
weixin_34310127的博客
08-25 248
2019独角兽企业重金招聘Python工程师标准>>> ...
CGLib动态代理原理及实现
pingguonjb的专栏
11-09 613
JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要CGLib了。CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。    简单的实现举例： 这是一个需要被代理的类，也就是父类，通过字
CGLIB原理
qq_34831781的博客
04-10 532
先介绍一下简单实现 //需要实现MethodInterceptor接口 public class ProxyFactory implements MethodInterceptor { private Object target; public ProxyFactory(Object target){ this.target = target; } ...
基于MAVEN项目的CGLib动态代理原理及实现
01-15
3. CGLib工作原理 CGLib通过继承的方式创建代理对象。它会生成一个目标类的子类，并在这个子类中拦截方法调用，然后执行额外的操作。CGLib使用ASM库来生成和加载字节码。 4. 创建Enhancer对象 CGLib的核心是`...
CGLib字节码增强实现代理原理(附源码下载)
04-16
CGLib的工作原理基于ASM库，ASM是一个底层的Java字节码操控和分析框架，可以用来动态生成类或者增强已有类的功能。CGLib通过ASM在内存中动态生成字节码，然后通过Java的ClassLoader将字节码转换为Class对象。这个...
cglib 动态代理原理详解
u012094957的专栏
11-03 1103
cglib 动态代理详解 我们都知道jdk的动态代理内部调用切面无效的问题，而cglib则不会出现这种情况，这是为什么？cglib就一定不会出现内部调用切面无效的问题吗？cglib针对每一个类只创建了一个代理类吗？为什么cglib的效率要比jdk的动态代理低呢？ 首先我们看一下通常我们是如何使用cglib增强一个类的 public class Main { static class Test{ public void test(){ System.out.pr
Spring框架+Spring工作原理+AOP面向切面编程+JDK代理+Cglib代理
最新发布
03-13
### Spring框架概述与核心原理 #### 一、Spring框架简介 Spring框架是一个广泛使用的开源Java平台，用于构建高质量的企业级应用程序。它最初由Rod Johnson在2004年创建，旨在简化企业级Java应用程序的开发过程。...
cglib原理解析
03-29 2369
先放上示例代码： //Person.java public class Person { public void sayHello() { System.out.println("Hello!"); } } //Test.java import org.objectweb.asm.ClassWriter; import net.sf.cglib.proxy....
CGLIB介绍与原理
热门推荐
zghwaicsdn的专栏
03-22 6万+
CGLIB介绍与原理(部分节选自网络) 一、什么是CGLIB? CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。通常可以使用Java的动态代理创建代理，但当要代理的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择。 二、CGLIB原理 CGLIB原理：动态生成一个要代理类的子类，子类重写要代理的类的所有不是final
cglib工作原理详解
johnhuster的专栏
03-23 6702
cglib是一种动态代理方式，底层通过asm产生class字节码来完成动态代理，cglib与jdk动态代理相比，除了可以代理实现接口的类也可以代理非实现接口的类，通过fastclass类来避免了java反射的使用。对jdk7以前的版本来说，jdk动态代理执行效率明显要比cglib动态代理类效率差，jdk8即以后版本对jdk动态代理进行了相应的优化，这种差距就不那么明显了。但是要代理...
CGLIB原理及实现机制
weixin_40516305的博客
06-17 2040
CGLIB原理及实现机制 什么是CGLIB CGLIB（Code Generator Library）是一个强大的、高性能的代码生成库。其被广泛应用于AOP框架（Spring、dynaop）中，用以提供方法拦截操作。Hibernate作为一个比较受欢迎的ORM框架，同样使用CGLIB来代理单端（多对一和一对一）关联（延迟提取集合使用的另一种机制）。 为什么使用CGLIB CGLIB代理主要通过对字节码的操作，为对象引入间接级别，以控制对象的访问。我们知道Java中有一个动态代理也是做这个事情的，那我们为什么
Cglib实现动态代理原理
单向街的夏天
06-26 814
如今Apache Hadoop已成为大数据行业发展背后的驱动力。Hive和Pig等技术也经常被提到，但是他们都有什么功能，为什么会需要奇怪的名字（如Oozie，ZooKeeper、Flume）。 Hadoop带来了廉价的处理大数据（大数据的数据容量通常是10-100GB或更多，同时数据种类多种多样，包括结构化、非结构化等）的能力。但这与之前有什么不同？ 现今企业数据仓库和关系型数据库擅
cglib动态代理实现原理
yyang11的专栏
04-18 2441
cglib是一个字节码操纵库，底层是基于ASM的
CGLib原理学习
weixin_30835649的博客
07-03 223
一、使用示例： public class UserDaoImpl implements UserDao { @Override public void addUser(User user) { System.out.println("connect to mySQL dataBase......."); System.out.println("添加用户...
cglib和jdk动态代理原理
07-28
C知道：cglib和jdk动态代理都是实现Java动态代理的方式，它们的原理略有不同。 JDK动态代理是通过反射机制来实现的。当我们使用JDK动态代理时，需要定义一个接口，并且创建一个实现了InvocationHandler接口的代理类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值