Spring AOP动态代理(JDK与CGLib)及类内部方法事务不生效原因解析

最新推荐文章于 2024-06-01 15:47:03 发布
最新推荐文章于 2024-06-01 15:47:03 发布
阅读量1.3k 收藏 1
点赞数 1
分类专栏： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guandongsheng110/article/details/103065704
版权
java 同时被 2 个专栏收录
58 篇文章 0 订阅
订阅专栏
spring
18 篇文章 1 订阅
订阅专栏

Spring AOP通过动态代理实现的, 分为JDK代理和CGLib代理. 目标对象在被代理后, 可以为目标对象执行前后进行增强, AOP事务的原理就是这样, 在方法执行前开启事务, 在执行后提交或回滚事务

1.创建接口

public interface UserService {
	// 模拟操作
    boolean getById(String id);
}

2.创建实现类

public class UserServiceImpl implements UserService {
	// 实现接口方法, 并返回结果
    public boolean getById(String id) {
        System.out.println("用户" + id + "被查询了");
        return true;
    }

}

3.生成JDK代理对象

public class JdkProxyTest {

    public static void main(String[] args) throws FileNotFoundException {
    	// 创建目标对象
        UserService target = new UserServiceImpl();
        // 利用Proxy类工具创建代理对象
        UserService service = (UserService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(), // 代理谁就用谁的类加载器
                target.getClass().getInterfaces(), // 目标类实现的接口
                new MyInvocationHandler(target)); // 目标对象
        // 此处执行的是代理对象的方法, 并打印结果
        System.out.println(service.getById("1"));
    }
}

// 实现InvocationHandler接口, 在invoke方法前后对目标对象方法进行增强
class MyInvocationHandler implements InvocationHandler {
	// 被代理对象, 也叫目标对象
    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

	/**
     * @param proxy 代理对象
     * @param method 目标对象的方法
     * @param args 方法参数
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始执行方法"); // 在方法执行前增强
        // 利用反射调用目标对象方法, 此处必须用目标对象, 如果使用代理对象会出现死循环
        Object obj = method.invoke(target, args); 
        System.out.println("方法执行结束"); // 方法执行后增强
        return obj; // 返回结果
    }
}

4.生成JDK代理字节码

public class JdkProxyTest {
    public static void main(String[] args) throws FileNotFoundException {
        // 生成动态代理class文件, UserServiceProxy:类名, UserService:实现的接口
        byte[] bytes = ProxyGenerator.generateProxyClass("UserServiceProxy", new Class[]{UserService.class});
        // 将字节数组输出到磁盘文件中
        try (FileOutputStream os = new FileOutputStream("D://UserServiceProxy.class")) {
            os.write(bytes);
            os.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5.查看JDK代理字节码

可将生成的UserServiceProxy.class文件放入idea项目中的target目录下, 直接打开, idea自行反编译

import com.springstudy.proxy.UserService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

// 此处继承了Proxy, 实现了目标类的接口
// 类和方法使用final修饰, 类不可继承, 方法不可重写
// 由于此处使用的继承, 所以java动态代理只能实现目标对象类接口方式代理(Java单继承)
public final class UserServiceProxy extends Proxy implements UserService {
	// 定义一组方法, 后边会赋值
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

	// 构造方法
    public UserServiceProxy(InvocationHandler var1) throws  {
    	// 向父类Proxy中的h参数赋值
        super(var1);
    }
	
    public final boolean equals(Object var1) throws  {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } 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 boolean getById(String var1) throws  {
        try {
        	// 调用父类中的h对象的invoke方法, 即生成代理对象时的MyInvocationHandler类invoke方法
            return ((Boolean)super.h.invoke(this, m3, new Object[]{var1})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

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

    static {
        try {
        	// 反射获取方法对象
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("com.springstudy.proxy.UserService").getMethod("getById", new Class[]{Class.forName("java.lang.String")});
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

6.引入CGLib包

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

7.创建CGLib代理对象

public class CGLibProxyTest {

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        // 代理对象的父类, 为目标对象
        enhancer.setSuperclass(UserServiceImpl.class);
        // 设置回调对象
        enhancer.setCallback(new MyMethodInterceptor());
        // 创建代理对象
        UserService service = (UserService) enhancer.create();
        System.out.println(service.getById("1"));
    }

    // 可使用此命令将对应PID使用的类生成字节码文件
    // java -classpath "D:\Program Files\Java\jdk1.8.0_101\lib\sa-jdi.jar" sun.jvm.hotspot.HSDB
}

class MyMethodInterceptor implements MethodInterceptor {
    /**
     * @param obj 代理对象
     * @param method 目标类方法
     * @param args 方法参数
     * @param proxy 代理类方法
     */
    public Object intercept(
            Object obj,
            Method method,
            Object[] args,
            MethodProxy proxy) throws Throwable {
        System.out.println("方法开始执行");
        Object res = proxy.invokeSuper(obj, args);
        System.out.println("方法执行完成");
        return res;
    }
}

8.查看CGLib字节码

package com.springstudy.proxy;

import com.springstudy.proxy.UserServiceImpl;
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;

// 继承目标类, 并且实现了指定接口
// 通过asm技术, 基于父类操作字节码生成
// 目标类不能是final修饰, 因为代理类需要继承它
public class UserServiceImpl$$EnhancerByCGLIB$$22516a7d extends UserServiceImpl 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$getById$0$Method;
    private static final MethodProxy CGLIB$getById$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;


    public UserServiceImpl$$EnhancerByCGLIB$$22516a7d() {
        CGLIB$BIND_CALLBACKS(this);
    }

    static {
        CGLIB$STATICHOOK1();
    }

    public final boolean equals(Object var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if(this.CGLIB$CALLBACK_0 == 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).booleanValue();
        } else {
            return super.equals(var1);
        }
    }

    public final String toString() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if(this.CGLIB$CALLBACK_0 == 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();
    }

    public final int hashCode() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if(this.CGLIB$CALLBACK_0 == 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();
        }
    }

    protected final Object clone() throws CloneNotSupportedException {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if(this.CGLIB$CALLBACK_0 == 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 Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        UserServiceImpl$$EnhancerByCGLIB$$22516a7d var10000 = new UserServiceImpl$$EnhancerByCGLIB$$22516a7d;
        switch(var1.length) {
            case 0:
                var10000.<init>();
                CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
                return var10000;
            default:
                throw new IllegalArgumentException("Constructor not found");
        }
    }

	// 创建代理对象
    public Object newInstance(Callback var1) {
        CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1});
        UserServiceImpl$$EnhancerByCGLIB$$22516a7d var10000 = new UserServiceImpl$$EnhancerByCGLIB$$22516a7d();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

	// 将MyMethodInterceptor对象放入到代理对象中
    public Object newInstance(Callback[] var1) {
        CGLIB$SET_THREAD_CALLBACKS(var1);
        UserServiceImpl$$EnhancerByCGLIB$$22516a7d var10000 = new UserServiceImpl$$EnhancerByCGLIB$$22516a7d();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public void setCallback(int var1, Callback var2) {
        switch(var1) {
            case 0:
                this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
            default:
        }
    }

	// 代理类对应的查询方法, final修饰
    public final boolean getById(String var1) {
    	// MyMethodInterceptor的对象
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if(this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if(var10000 != null) {
        	// 执行MyMethodInterceptor的intercept方法, 并将结果返回
            Object var2 = var10000.intercept(this, CGLIB$getById$0$Method, new Object[]{var1}, CGLIB$getById$0$Proxy);
            return var2 == null?false:((Boolean)var2).booleanValue();
        } else {
            return super.getById(var1);
        }
    }

    public void setCallbacks(Callback[] var1) {
        this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
    }

    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 Callback[] getCallbacks() {
        CGLIB$BIND_CALLBACKS(this);
        return new Callback[]{this.CGLIB$CALLBACK_0};
    }

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

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

    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 -403379525:
                if(var10000.equals("getById(Ljava/lang/String;)Z")) {
                    return CGLIB$getById$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;
    }

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("com.springstudy.proxy.UserServiceImpl$$EnhancerByCGLIB$$22516a7d");
        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$getById$0$Method = ReflectUtils.findMethods(new String[]{"getById", "(Ljava/lang/String;)Z"}, (var1 = Class.forName("com.springstudy.proxy.UserServiceImpl")).getDeclaredMethods())[0];
        CGLIB$getById$0$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)Z", "getById", "CGLIB$getById$0");
    }

    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        UserServiceImpl$$EnhancerByCGLIB$$22516a7d var1 = (UserServiceImpl$$EnhancerByCGLIB$$22516a7d)var0;
        if(!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if(var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if(CGLIB$STATIC_CALLBACKS == null) {
                    return;
                }
            }

            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
        }

    }

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

    final boolean CGLIB$equals$1(Object var1) {
        return super.equals(var1);
    }

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

    final boolean CGLIB$getById$0(String var1) {
        return super.getById(var1);
    }

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

总结

Spring AOP默认使用JDK动态代理, 但是前提为目标类必须实现接口, 使用反射, 如果没有实现接口, 则会使用CGLib代理, 前提为目标类不能被final修饰, 也可以强制使用CGLib代理

这也同样描述了一个问题, 当我们在service层通过调用内部方法使用事务时, 为什么事务不会生效?

class Test implements TestService {
    public void a() {
        b();
    }

    @Transactional
    public void b() {

    }
}

因为使用了JDK代理, 因为没有通过接口, 无法通过AOP代理, 所以不能在方法前后增强
解决办法: 在Service中注入自己

但是如果使用CGLib代理, 为什么事务还是不行?

class Test {
    public void a() {
        b();
    }

    @Transactional
    public void b() {

    }
}

因为CGLib代理重写了父类的非私有方法, 然后直接调用父类对应方法, 但是由于没有修改父类的字节码, 所以, 在父类方法中, 仍然会调用父类自己的添加事务的方法

解决办法: 在方法a中获取当前代理对象p, 执行p.a()可使得事务生效

跟心爱的人浪迹天涯
关注
专栏目录
关于spring 类内部方法调用aop不生效原因，以及jdk，cglib 动态代理原理
FREEDOM
10-30 611
引入：spring的aop 我们知道，在spring 的一个A类bean中方法fa调用A中的方法fb，即使fb上有则@Transactional，或者fb 被aop拦截了，此时fb上的所有代理织入操作都不会生效。而如果在另一个类B中调用A中的fb,则代理织入是生效的。 但是经过下面实验发现，spring完全可以实现类内部方法调用 代理增强依然生效。但为何spring 不这样做呢？网上没有找到原因，以下为自己的理解原因：Spring aop应该是故意这样做的 内部调用是调用自己，不然就没办法通过代理b..
分析JDK代理与CGlib代理的区别，从而解读Spring AOP事务失效的问题的原因
qq_34244479的博客
12-02 571
动态代理和静态代理的区别？ 动态代理是在程序运行时才生成目标代理类的class文件，而静态代理是在编译时就生成了目标代理类的class文件 有哪些常用的框架技术用到了动态代理？ Spring的AOP功能，可以用来加事务，加权限和加日志。 Mybatis Mapper的映射，实际上是把获取数据库连接，封装结果集返回等操作放在了动态代理中。 RPC框架，远程过程调用，通俗点说就是“像调用本地服务一样调...
面试必备技能：JDK动态代理给Spring事务埋下的坑！
热门推荐
徐刘根的博客
01-10 1万+
一、场景分析 最近做项目遇到了一个很奇怪的问题，大致的业务场景是这样的：我们首先设定两个事务，事务parent和事务child，在Controller里边同时调用这两个方法，示例代码如下： 1、场景A： @RestController @RequestMapping(value = "/test") public class OrderController { @Autowir...
@Transactional 事务注解失效
最新发布
aaBen_的博客
06-01 1450
在使用Spring框架时，可以有两种使用事务的方式，一种是编程式的，一种是声明式的，注解就是声明式的。
Spring事务失效
zrlwoaini的专栏
07-22 4485
[问题]       Spring的声明式事务，我想就不用多介绍了吧，一句话“自从用了Spring AOP啊，事务管理真轻松啊，真轻松；事务管理代码没有了，脑不酸了，手不痛了，一口气全配上了事务；轻量级，测试起来也简单，嘿！”。不管从哪个角度看，轻量级声明式事务都是一件解放生产力
Spring事务三：cglib方式代理，this调用不生效本质
万物皆字节
12-13 1991
基于自己之前对Spring代理生成的认知，大致的认为采用cglib框架生成目标类的子类；在父类方法体内使用this应该也是调用代理类的实例，那么容器应该能感知方法上的注解进而执行拦截（比如事务拦截器），但是事与愿违用this调用的没有让事务拦截生效。 先来看我的定势思维想象：假设有父类F和子类S public class F { public void first() { this.second(); } public void second() { .
Spring事务失效——JDK动态代理给Spring事务埋下的坑
e891377的专栏
09-13 300
Spring事务失效 面试必备技能：JDK动态代理给Spring事务埋下的坑
关于AOP(cglib) 代理内部方法失效的问题
u014799309的博客
04-29 1980
环境：springboot 问题：使用springboot脚手架搭建spring项目，在使用aop编程时，对 MyObject 类的方法method() 使用aop切入, 当直接调用method()方法以及 使用this.method() 或者 使用new MyObject().method() 这几种调用method()的方式，AOP无法切入 原因：1.cglib代理的对象是类，是将代理类在执行期间动态生成一个子类，重写所有不是final的方法，它代理的不是方法，此处记住一点就是它在运行期间生...
Spring Boot 中的 AOP，到底是 JDK 动态代理还是 Cglib 动态代理？
m0_71777195的博客
09-02 385
大家都知道，AOP 底层是动态代理，而 Java 中的动态代理有两种实现方式：基于 JDK 的动态代理基于 Cglib 的动态代理这两者最大的区别在于基于 JDK 的动态代理需要被代理的对象有接口，而基于 Cglib 的动态代理并不需要被代理对象有接口。那么小伙伴们不禁要问，Spring 中的 AOP 是怎么实现的？是基于 JDK 的动态代理还是基于 Cglib 的动态代理？
Spring事务与JDK/CGLIB动态代理
liyifan687的博客
05-29 3707
近日面试问及AOP和动态代理，再之后的事务方面有所生疏，感谢面试官特意给我介绍了下，一个之前的知识盲区。 首先Spring事务在开发过程中是通过@Transactional注解来控制。 1. Transactional注解的原理 对于使用了Transactional注解的方法的类，Spring AOP代理会在运行时生成这个类的代理对象。 当这个对象运行这个注解方法时，会读取@Transa...
SpringBoot中的Aop优先使用的是JDK动态代理还是Cglib
桐花思雨
11-29 2770
目录`Spring` 中 `Aop` 的实现 Spring 中 Aop 的实现 如果代理对象有接口，就用 JDK 动态代理。JDK 动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法时，会先调用实现了 InvokeHandler 接口的 invoke() 方法，来实现业务增强 如果代理对象没有接口，那么就直接使用 Cglib 动态代理。Cglib 动态代理是利用 asm 开源包，对代理对象类的 class 文件加载进来，通过修改其字节码生成子类来处理 来看看这段来自 Spring 官方文
JDK动态代理为什么不能代理类
luoxn28的专栏
10-15 2679
戳蓝字「TopCoder」关注我们哦！关于JDK动态代理，想必小伙伴都知道，它只能代理接口！但是有的小伙伴可能会有疑问，为什么它只能代理接口，不能代理类呢？这里借助某位技...
SpringBoot CGLIB AOP解决Spring事务,对象调用自己方法事务失效.
10年职场两茫茫，35岁凄凉奈若何
10-29 261
SpringBoot CGLIB AOP解决Spring事务,对象调用自己方法事务失效.
动态代理之spring事务调用本类方法不生效问题
houjx3的博客
09-03 780
1.先看示例代码 @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class,args); } } @Controller @RequestMapping("acontroller") public class AController { @Autowired
Spring事务失效，同一个类中的内部方法调用事务失效
NoviceZ的博客
12-12 8664
声明式事务实现方式 所谓声明式事务，也就是通过配置的方式，比如通过配置文件xml或者注解的方式，来告诉Spring哪些方法需要Spring帮忙管理事务，然后开发者只需要关注业务代码，而事务的事情则由Spring自动帮我们控制。 配置文件的方式：即在spring.xml文件中进行统一配置，开发者基本不用关注事务的事情了，一切交给spring处理。 基于注解的方式：只需要在想要添加事务的方法上加上@Transaction注解就可以了。 实际工作中，基于配置文件的方式用的很少，我们工作中主要还是用注解的方
自定义切面注解没生效的原因
Jatham_C的博客
06-01 3317
博主的问题是 用this无法生效切面 public class ServiceImpl implements Service { @Override public T getAssetDetail() { xxxxxx; } @Override @TranslateRemoteField public T selectConcreteRecordDetail(Long id) { //正确写法 Service serviceT
为什么JDK动态代理只能代理接口，不能直接代理类？CGlib为什么可以代理类？
lx1315998513的博客
10-07 4008
在？撸个问题。一、JDK动态代理与CGlib动态代理二、为什么JDK动态代理只能代理接口，不能直接代理类？（一）简单的实现JDK动态代理三、CGlib为什么可以代理类？四、总结五、参考： 一、JDK动态代理与CGlib动态代理 众所周知，Spring会基于代理的类去动态的选择使用JDK创建代理对象还是CGLIB（当然也可以配置全都使用CGlib），这取决于被代理的对象是类还是接口。 java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。 CGli
动态代理模式和动态代理失效原因简介
user2025的博客
10-04 3773
Spring有两种动态代理实现方式 java动态代理：利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。 cglib动态代理：利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理 JDK动态代理和CGLIB字节码生成的区别： （1）JDK动态代理只能对实现了接口的类生成代理，而不能针对类 （2）CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法【】因为是继承，所以该类或方法最好不要声明成final 如果目
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值