spring aop(一)：JDK动态代理和CGLIB动态代理

最新推荐文章于 2024-04-11 20:55:34 发布
最新推荐文章于 2024-04-11 20:55:34 发布
阅读量121 收藏
点赞数
分类专栏： spring aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asfa4111/article/details/114414285
版权

目录

1 动态代理和静态代理

1.1 代理模式

代理模式是面向对象编程中比较常见的设计模式，uml图如下：
在这里插入图片描述
需要注意的有下面几点：

  1. 用户只关心接口功能，而不在乎谁提供了功能。上图中接口是 Subject。
  2. 接口真正实现者是上图的 RealSubject，但是它不与用户直接接触，而是通过代理。
  3. 代理就是上图中的 Proxy，由于它实现了 Subject 接口，所以它能够直接与用户接触。
  4. 用户调用 Proxy 的时候，Proxy 内部调用了 RealSubject。所以，Proxy 是中介者，它可以增强 RealSubject 操作。

值得注意的是，代理可以分为静态代理和动态代理两种。先从静态代理讲起。

1.2 静态代理

静态代理的代理类时静态生成的，在编译前已经有了确定的目标对象

1.3 动态代理

动态代理的代理类实在程序运行过程中动态生成的。

2 JDK动态代理

2.1 demo

  1. 需要代理的两个接口类StudentService,TeacherService
public interface StudentService {
    void study(String course);
}

public interface TeacherService {
    void teach(String course);
}
  1. 代理的目标对象类PersonServiceImpl
public class PersonServiceImpl implements StudentService,TeacherService {

    @Override
    public void study(String course){
        System.out.println("学习："+course);
    }

    @Override
    public void teach(String course) {
        System.out.println("授课："+course);
    }
}
  1. 代理类JDKDynamicProxy
public class JDKDynamicProxy implements InvocationHandler {
    /**
     * 代理的目标类
     */
    private Object target;

    /**
     * 构造方法注入目标类
     */
    public JDKDynamicProxy(Object target) {
        this.target = target;
    }

    /**
     * 获取代理对象：这里面会进行一系列的操作，生产目标对象的代理对象。
     */
    public <T> T getProxy() {
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    /**
     * 最终通过代理对象执行方法，都会反射执行这个方法。
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        Object result = null;
        try {
            System.out.println(method.getName() + "：执行前");
            result = method.invoke(target, args);
            System.out.println(method.getName() + "：执行后");
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return result;
    }
}
  1. 启动测试类
public class ProxyTest {
    public static void main(String[] args) throws Exception {
        JDKDynamicProxy jdkDynamicProxy = new JDKDynamicProxy(new PersonServiceImpl());
        StudentService studentService = jdkDynamicProxy.getProxy();
        TeacherService teacherService = jdkDynamicProxy.getProxy();
        studentService.study("语文");
        studentService.toString();
        teacherService.teach("数学");
        //以下代码可将动态生成的类文件存储到本地
        byte[] bts = ProxyGenerator.generateProxyClass("PersonServiceImpl", UserServiceImpl.class.getInterfaces());
        FileOutputStream fos = new FileOutputStream(new File("D:/PersonServiceImpl.class"));
        fos.write(bts);
        fos.flush();
        fos.close();
    }
}
  1. 生成的代理类
public final class PersonServiceImpl extends Proxy implements UserService {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public PersonServiceImpl(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void addUser(String var1) throws  {
        try {
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("org.example.springstudy.service.UserService").getMethod("addUser", Class.forName("java.lang.String"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

2.2 jdk动态代理实现技术及源码

从上一节的demo中，我们可以看到，jdk实现动态代理的技术如下：

  1. 代理接口
  2. 目标对象
  3. JDKDynamicProxy类，实现InvocationHandler接口，持有代理对象
  4. Proxy.newProxyInstance（）会在内存中动态生成一个代理类的class文件，这个类继承了Proxy接口，实现了代理对象接口。
  5. 代理类中的方法，都是通过JDKDynamicProxy的invoke方法进行调用的（所以JDKDynamicProxy 需要实现InvocationHandler接口）。
  6. 以上最关键的过程动态的生产代理类class文件及相应的代理对象，这是通过Proxy.newProxyInstance（）方法实现的，具体如下。
public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);
 
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         */
         //查找或者生成一个代理的动态类（怎么生成的class文件就比较复杂了，在此不进行详述）
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }

            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            //通过反射创建一个代理类的对象
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

3.CGLIB动态代理

上面的jdk动态代理只能针对接口进行代理，那么如果接口没有实现任何接口，就不能用jdk自带的代理。这时候需要使用cglib代理。

3.1 demo

  1. 代理的目标类Person1ServiceImpl
public class Person1ServiceImpl{

    public void study(String course){
        System.out.println("学习："+course);
    }
    //注意：这里特意声明为final方法
    public final void teach(String course) {
        System.out.println("授课："+course);
    }
}
  1. 创建代理的类 CglibDynamicProxy
public class CglibDynamicProxy implements MethodInterceptor {
    public <T> T getProxyInstance(Class c){
        //输出class文件
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\code");
        //新建一个cglib的增强类
        Enhancer enhancer = new Enhancer();
        //设置父类，也就是被代理的类
        enhancer.setSuperclass(c);
        //设置回调，主要是最后是执行MethodInterceptor接口的intercept方法
        enhancer.setCallback(this);
        //在内存中创建代理类的Class文件，并通过反射创建代理对象
        return (T) enhancer.create();
    }
    @Override
    public Object intercept(Object sub, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("方法执行前");
        Object invoke = methodProxy.invokeSuper(sub, objects);
        System.out.println("方法执行后");
        return invoke;
    }
}
  1. 启动类
public class ProxyTest {
    public static void main(String[] args){
       CglibDynamicProxy cglibDynamicProxy = new CglibDynamicProxy();
        Person1ServiceImpl proxyInstance = cglibDynamicProxy.getProxyInstance(Person1ServiceImpl.class);
        proxyInstance.study("111");
        proxyInstance.teach("222");

    }
}
  1. 执行结果
方法执行前
学习：111
方法执行后
授课：222
  1. 动态生产的代理类
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.lihui.study.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 Person1ServiceImpl$$EnhancerByCGLIB$$64a03981 extends Person1ServiceImpl 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$study$0$Method;
    //代理方法
    private static final MethodProxy CGLIB$study$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("com.lihui.study.proxy.Person1ServiceImpl$$EnhancerByCGLIB$$64a03981");
        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$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");
        CGLIB$study$0$Method = ReflectUtils.findMethods(new String[]{"study", "(Ljava/lang/String;)V"}, (var1 = Class.forName("com.lihui.study.proxy.Person1ServiceImpl")).getDeclaredMethods())[0];
        CGLIB$study$0$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)V", "study", "CGLIB$study$0");
    }

    final void CGLIB$study$0(String var1) {
        super.study(var1);
    }

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

    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 581061590:
            if (var10000.equals("study(Ljava/lang/String;)V")) {
                return CGLIB$study$0$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 1984935277:
            if (var10000.equals("hashCode()I")) {
                return CGLIB$hashCode$3$Proxy;
            }
        }

        return null;
    }

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

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

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

3.2 技术讲解

从上面的demo可以看到，生成的代理类没有对final修复的teach方法进行代理，因为生成的代理类Person1ServiceImpl$$EnhancerByCGLIB$$64a03981继承了需要代理的类Person1ServiceImpl（final方法是不能被继承的），实现了Factory接口。
整个流程如下：

  1. 新建一个cglib的增强类：Enhancer enhancer = new Enhancer()
  2. 设置代理类和回调：enhancer.setSuperclass(c)；enhancer.setCallback(this);
  3. 动态生成代理类的class文件及相应的代理对象： enhancer.create()
  4. 通过代理类调用相应方法，比如调用study()方法；
 public final void study(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$study$0$Method, new Object[]{var1}, CGLIB$study$0$Proxy);
        } else {
            super.study(var1);
        }
    }
  1. 如上，实际会调用之前设置的回调对象的回调方法，参数解释如下：
   /**
   * sub : 传入的子类对象，也就是被代理的对象
   * method ：被代理的方法
   * objects：方法入参
   * methodProxy：代理对象的代理方法
   **/
  public Object intercept(Object sub, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("方法执行前");
        Object invoke = methodProxy.invokeSuper(sub, objects);
        System.out.println("方法执行后");
        return invoke;
    }
  1. 执行代理对象的方法：methodProxy.invokeSuper(sub, objects)
赐我梦境～还我清醒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈Spring中JDK动态代理和CGLIB动态代理
CharlesYooSky的博客
10-21 1700
浅谈Spring中JDK动态代理和CGLIB动态代理
Spring AOP底层实现- JDK动态代理和CGLIB动态代理
JavaLab
12-21 6759
Spring AOP是运行时织入的，那么运行时织入到底是怎么实现的呢?答案就是代理对象。 代理又可以分为静态代理和动态代理。 静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。 动态代理：在程序运行时，运用反射机制动态创建而成。 静态代理的每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且...
CGLIB动态代理详解分析
weixin_43397326的博客
07-06 5821
CGLIB是强大的、高性能的代码生成库，被广泛应用于AOP框架，它底层使用ASM来操作字节码生成新的类，为对象引入间接级别，以控制对象的访问。CGLIB相比于JDK动态代理更加强大，JDK动态代理只能对接口进行代理，而CGLIB既可以代理普通类，也能够代理接口。
cglib动态代理
NCS123456的博客
06-13 1万+
CGLIB（Code Generation Library），是一个强大的，高性能，高质量的 Code 生成类库，它可以在运行期扩展 Java 类与实现 Java 接口。
Spring高手之路17——动态代理的艺术与实践
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
04-11 1万+
本文深入分析了JDK和CGLIB两种动态代理技术在Spring框架中的应用。讨论了动态代理的基础概念，通过实例展示了如何实现和应用这两种方法，并比较了它们的性能差异及适用场景。进一步，探讨了在动态代理中实现熔断限流和日志监控的策略，以及如何利用动态代理优化Spring应用的设计和功能。
动态代理模式 -- Cglib代理
weixin_43739348的博客
03-19 1287
静态代理和 JDK 代理模式都要求目标对象是实现一个接口,但是有时候目标对象只是一个 单独的对象,并没 有实现任何的接口,这个时候可使用目标对象子类来实现代理-这就是 Cglib 代理Cglib代理也叫作 子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能扩展, 有些书也将Cglib代理归属到动态代理。Cglib 是一个强大的高性能的代码生成包,它可以在运行期扩展 java 类与实现 java 接口.它广泛的被许多 AOP 的框架使用,例如 SpringAOP，实现方法拦截。
动态代理之 cglib 实现
冷血之心的博客
02-17 8319
（尊重劳动成果，转载请注明出处：https://blog.csdn.net/qq_25827845/article/details/87513102冷血之心的博客） 目录 前言： 正文： AOP（面向切面编程） JDK动态代理 cglib实现动态代理 cglib包结构： cglib动态代理相关的基础类： cglib动态代理Demo 总结： 前言：         这篇文...
JAVA动态代理实现Demo（JDK动态代理和CGLIB动态代理）
12-19
Java提供了两种主要的动态代理实现方式：JDK动态代理和CGLIB动态代理。 **JDK动态代理**： JDK动态代理基于接口实现，也就是说，被代理的对象必须实现至少一个接口。代理机制的核心是`java.lang.reflect.Proxy`类和...
Spring框架中JDK动态代理和cglib动态代理
11-06
Spring 框架中 JDK 动态代理和 CGLIB 动态代理是 Spring AOP 中一个非常重要的知识点。Spring AOP 框架会根据实际情况选择使用 JDK 的动态代理还是 CGLIB 的动态代理。 JDK 动态代理是 Java 自带的动态代理机制，它...
Spring框架+SpringAOP动态代理
03-22
SpringAOP动态代理 Spring AOP 使用的动态代理主要有两种方式：JDK 动态代理和 CGLIB 代理。 JDK 动态代理：用于代理实现了接口的类。Spring 会使用 java.lang.reflect.Proxy 类来创建代理对象。 CGLIB 代理：用于...
关于Spring AOP，除了动态代理、CGLIB，你还知道什么？
12-20
- Spring AOP主要通过动态代理来实现，包括JDK动态代理和CGLIB。对于接口实现类，Spring使用JDK动态代理；对于没有接口的类，使用CGLIB生成子类来实现切面。 - **Pointcut**在Spring中通过`org.springframework....
Spring-AOP-JDK动态代理
05-12
在Java编程领域，Spring框架是应用最广泛的轻量级开源框架之一，它提供了一系列强大的功能，包括依赖注入、面向切面编程（AOP）...在实际项目中，熟练掌握Spring AOP和JDK动态代理，能够有效地提升开发效率和软件质量。
【cglib实现动态代理】
edwer93的博客
11-29 1042
cglib是是第三方的工具库。其原理是继承，cglib通过继承目标类，创建他的子类，在子类当中重写父类的相关方法，实现功能的增强。
JDK和CGLIB动态代理的区别
热门推荐
qq_59527118的博客
10-18 2万+
学习动态代理的区别
通俗易懂 快速理解 JDK动态代理 和 cglib动态代理
weixin_43935152的博客
05-05 1万+
动态代理有两种： ① jdk动态代理，要求必须有接口，最终生成的代理类和目标类实现相同的接口，在com.sun.proxy包下，类名为$proxy+数字 （例如：$proxy6） ② cglib动态代理，最终生成的代理类会继承目标类，并且和目标类在相同的包下
CGLIB 动态代理
m0_61609890的博客
03-11 6990
目录 CGLIB 动态代理 简单结构: 添加依赖 定义类 CGLIB 动态代理 JDK的动态代理机制只能代理实现了接口的类。而不能实现接口的类就不能使用JDK的动态代理，CGLIB是针对类来实现代理的，它的原理是对指定目标类生成一个子类，并覆盖其中的方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。 简单结构: 实现原理:继承思想 代理类继承目标类，重写目标类中的方法， CGLIB像是一个拦截器，在调用我们的代...
pillow-10.4.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl
最新发布
07-27
基本介绍 名称与起源：Pillow，原名为PIL（Python Imaging Library），但PIL只支持Python 2版本。随着Python 3的普及，Pillow作为PIL的一个分支出现，兼容Python 3并提供更多的功能和改进。 主要功能：Pillow支持多种图像格式的打开、保存、显示以及基本的图像操作和处理，如裁剪、缩放、旋转、翻转、滤镜应用等。 跨平台性：Pillow库可以在不同的操作系统上运行，包括Windows、Linux和MacOS等。 主要功能模块 Pillow库包含多个功能模块，每个模块都提供了特定的图像处理功能。以下是一些常用的模块： Image：用于处理图像文件，提供打开、保存、调整大小、旋转、裁剪、滤镜等功能。 ImageDraw：提供在图像上绘制各种形状（如线条、矩形、圆形）和文本的功能。 ImageFont：用于加载和使用TrueType字体文件，以便在图像上绘制文本时设置字体样式、大小和颜色。 ImageFilter：提供各种滤镜效果，如模糊、锐化、边缘增强等，用于图像增强、特效处理和图像识别等应用。 ImageEnhance：用于调整图像的亮度、对比度、颜色饱和度等参数，使图像更加清晰、明亮或具有特定的调色效果。 高级功能 除了基本的图像处理功能外，Pillow还支持一些高级功能，如色彩空间转换、直方图均衡化等。这些功能可以帮助用户进行更复杂的图像处理和分析。
Spring Aop中的JDK动态代理和CGLIB动态代理有什么区别
06-10
在 Spring AOP 中，JDK 动态代理和 CGLIB 动态代理都可以用来实现切面的功能，它们的主要区别在于： 1. JDK 动态代理只能代理实现了接口的类，而 CGLIB 动态代理可以代理没有实现接口的类。这是因为 JDK 动态代理是基于接口来实现的，而 CGLIB 动态代理则是通过生成被代理类的子类来实现的。 2. JDK 动态代理相对于 CGLIB 动态代理来说，生成代理对象的速度更快，执行效率也更高。这是因为 JDK 动态代理是使用 Java 自带的反射机制来实现的，而 CGLIB 动态代理则是使用 ASM 字节码操作框架来生成字节码的。 3. JDK 动态代理适用于对单个对象的代理，而 CGLIB 动态代理适用于对类的代理。这是因为 JDK 动态代理生成的代理对象是实现了接口的单个对象，而 CGLIB 动态代理生成的代理对象是被代理类的子类。 需要注意的是，当被代理的类没有实现接口时，Spring AOP 默认会使用 CGLIB 动态代理来生成代理对象，如果被代理的类实现了接口，则可以通过配置来选择使用 JDK 动态代理或 CGLIB 动态代理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值