首页
学习
活动
专区
工具
TVP
发布
精选内容/技术社群/优惠产品,尽在小程序
立即前往

Spring @Transactional + AspectJ编译时织入不起作用

Spring @Transactional是Spring框架中用于管理事务的注解,它可以应用在方法或类级别上。当应用在方法上时,@Transactional注解会将该方法标记为一个事务性方法,Spring会在方法执行前开启一个事务,在方法执行后根据方法的执行结果决定是提交事务还是回滚事务。

AspectJ是一个面向切面编程(AOP)的框架,它可以在编译时或运行时将切面织入到目标对象中。编译时织入是指在编译阶段将切面代码织入到目标对象的字节码中,这样在运行时就不需要再进行织入操作了。

然而,Spring的@Transactional注解与AspectJ的编译时织入并不兼容。因为@Transactional注解是在运行时通过Spring的代理机制实现的,而AspectJ的编译时织入是在编译阶段完成的,两者的织入时机不同。

如果想要在Spring中使用AspectJ的编译时织入,可以通过以下步骤实现:

  1. 引入AspectJ的相关依赖:
代码语言:txt
复制
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
</dependency>
  1. 在Spring Boot的配置类上添加@EnableAspectJAutoProxy注解,启用AspectJ的自动代理功能:
代码语言:txt
复制
@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    // 配置其他Bean
}
  1. 创建一个切面类,使用@Aspect注解标记,并在该类中定义切点和通知:
代码语言:txt
复制
@Aspect
@Component
public class TransactionalAspect {
    @Pointcut("@annotation(org.springframework.transaction.annotation.Transactional)")
    public void transactionalPointcut() {
    }

    @Around("transactionalPointcut()")
    public Object aroundTransactional(ProceedingJoinPoint joinPoint) throws Throwable {
        // 在方法执行前后进行事务管理
        // ...
        return joinPoint.proceed();
    }
}
  1. 在切面类所在的包或子包下创建一个aspectj.xml文件,配置编译时织入的规则:
代码语言:txt
复制
<aspectj>
    <aspects>
        <aspect name="com.example.TransactionalAspect"/>
    </aspects>
    <weaver options="-verbose">
        <include within="com.example..*"/>
    </weaver>
</aspectj>
  1. 在项目的pom.xml文件中添加AspectJ的编译插件:
代码语言:txt
复制
<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>aspectj-maven-plugin</artifactId>
            <version>1.12.6</version>
            <configuration>
                <complianceLevel>1.8</complianceLevel>
                <source>1.8</source>
                <target>1.8</target>
                <aspectLibraries>
                    <aspectLibrary>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-aspects</artifactId>
                    </aspectLibrary>
                </aspectLibraries>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

通过以上步骤,就可以在Spring中实现AspectJ的编译时织入,使得@Transactional注解与AspectJ的切面代码能够一起生效。

推荐的腾讯云相关产品:腾讯云Serverless云函数(SCF),它是一种无服务器计算服务,可以帮助开发者更轻松地构建和管理应用程序。腾讯云SCF支持Java语言,可以用于编写和部署Spring Boot应用程序。您可以通过以下链接了解更多信息:腾讯云Serverless云函数

页面内容是否对你有帮助?
有帮助
没帮助

相关·内容

Spring-AOP @AspectJ进阶之增强织入的顺序

文章目录 概述 示例 概述 一个连接点可以同时匹配多个切点,切点对应的增强在连接点上的织入顺序到底是如何安排呢?...这个问题需要分三种情况讨论: 如果增强在同一个切面类中声明,则依照增强在切面类中定义的顺序进行织入; 如果增强位于不同的切面类中,且这些切面类都实现了org.springframework.core.Ordered...接口,则由接口方法的顺序号决定(顺序号小的先织入); 如果增强位于不同的切面类中,且这些切面类没有实现org.springframework.core.Ordered接口,织入的顺序是不确定的。...我们可以通过下图描述这种织入的规则: ?...切面类A和B都实现为Ordered接口,A切面类对应序号为1,B切面类对应序号为2,A切面类按顺序定义了3个增强,B切面类按顺序定义两个增强,这5个增强对应的切点都匹配某个目标类的连接点,则增强织入的顺序为图中虚线所示

52130

AspectJ一文说明白

可获取方法名等 Object getTarget():返回被织入增强处理的目标对象 Object getThis():返回AOP框架为目标对象生成的代理对象 使用@Around处理时,需要将第一个JoinPoint...在“进入”连接点时,最高优先级的增强处理将先被织入(eg. 给定的两个不同切面类Before增强处理中,优先级高的那个会先执行); 在“退出”连接点时,最高优先级的增强处理会最后被织入(eg....包含了@Before,优先级为2的切面类Bean2包含了@Around,虽然@Around优先级高于@Before,但由于Bean1的优先级高于Bean2的优先级,因此Bean1中的@Before先被织入...,优先级越高 直接使用@Order注解来修饰一个切面类:使用这个注解时可以配置一个int类型的value属性,该属性值越小,优先级越高 同一个切面类里的两个相同类型的增强处理在同一个连接点被织入时,Spring...AOP将以随机的顺序来织入这两个增强处理,没有办法指定它们的织入顺序。

77420
  • 动力节点Spring框架学习笔记-王鹤(四)Spring事务

    B、Spring 的回滚方式(理解) Spring事务的默认回滚方式是: 发生运行时异常和 error 时回滚,发生受 查(编译)异常时提交。不过,对于受查异常,程序员也可以手工设置其回滚方式。...受查异常,也叫编译时异常,即在代码编写时要求必须捕获或抛出的异 常,若不处理,则无法通过编译。...4.4 使用 Spring 的事务注解管理事务(掌握) 通过@Transactional 注解方式, 可将事务织入到相应 public 方法中,实 现事务管理。...对于其他非 public 方法,如果加上了注解@Transactional,虽然 Spring不会报错,但不会将指定事务织入到该方法中。...因为 Spring 会忽略掉所有非public 方法上的@Transaction 注解。 若@Transaction 注解在类上,则表示该类上所有的方法均将在执行时织入 事务。

    1.5K20

    再学习之Spring(面向切面编程).

    这个点可以是调用方法时、抛出异常时、甚至修改一个字段时。 ? 织入(Weaving):织入是把切面应用到目标对象并创建新的代理对象的过程。...织入有三种方式可以实现,Spring采用的是第三种,在运行期织入的: 编译期:切面在目标类编译时被织入。这种方式需要特殊的编译器。AspectJ的织入编译器就是以这种方式织入切面的。...类加载期:切面在目标类加载到JVM时被织入。这种方式需要特殊的类加载器(ClassLoader),它可以在目标类被引入应用之前增强该目标类的字节码。...AspectJ 5的加载时织入(load-time weaving,LTW)就支持以这种方式织入切面。 运行期:切面在应用运行的某个时刻被织入。...一般情况下,在织入切面时,AOP容器会为目标对象动态地创建一个代理对象。代理类封装了目标类,并拦截被通知方法的调用,再把调用转发给真正的目标bean。SpringAOP就是以这种方式织入切面的。 ?

    76150

    Spring 事务用法示例与实现原理

    , user.getName(), user.getAge()); } } 在进行事务支持时,Spring只需要使用者在需要事务支持的bean上使用@Transactional注解即可...这里Pointcut用于判断目标bean是否需要织入当前切面逻辑;Advice则封装了需要织入的切面逻辑。如下是这三个部分的简要关系图: ?...这里可想而知,其判断的基本逻辑就是判断其方法或类声明上有没有使用@Transactional注解,如果使用了就是需要织入事务逻辑的bean; TransactionInterceptor:这个bean本质上是一个...Advice,其封装了当前需要织入目标bean的切面逻辑,也就是Spring事务是如果借助于数据库事务来实现对目标方法的环绕的。...Spring Aop实现将事务逻辑织入目标bean的。

    37720

    Spring事务你可能不知道的事儿

    , user.getName(), user.getAge()); } } 在进行事务支持时,Spring只需要使用者在需要事务支持的bean上使用@Transactional注解即可...这里Pointcut用于判断目标bean是否需要织入当前切面逻辑;Advice则封装了需要织入的切面逻辑。如下是这三个部分的简要关系图: ?...这里可想而知,其判断的基本逻辑就是判断其方法或类声明上有没有使用@Transactional注解,如果使用了就是需要织入事务逻辑的bean; TransactionInterceptor:这个bean本质上是一个...Advice,其封装了当前需要织入目标bean的切面逻辑,也就是Spring事务是如果借助于数据库事务来实现对目标方法的环绕的。...Spring Aop实现将事务逻辑织入目标bean的。

    40170

    比较Spring AOP与AspectJ

    AspectJ使用了三种不同类型的织入: 编译时织入:AspectJ编译器同时加载我们切面的源代码和我们的应用程序,并生成一个织入后的类文件作为输出。 编译后织入:这就是所熟悉的二进制织入。...AspectJ使用的是编译期和类加载时进行织入,Spring AOP利用的是运行时织入。 运行时织入,在使用目标对象的代理执行应用程序时,编译这些切面(使用JDK动态代理或者CGLIB代理)。 ?...Simplicity Spring AOP显然更加简单,因为它没有引入任何额外的编译期或在编译期织入。它使用了运行期织入的方式,因此是无缝集成我们通常的构建过程。...尽管看起来很简单,Spring AOP只作用于Spring管理的beans 。 然而,使用AspectJ,我们需要引入AJC编译器,重新打包所有库(除非我们切换到编译后或加载时织入)。...Performance 考虑到性能问题,编译时织入比运行时织入快很多。Spring AOP是基于代理的框架,因此应用运行时会有目标类的代理对象生成。

    1.6K80

    Spring系列八:Spring AOP 和 AspectJ AOP 区别

    ,由于 Spring AOP 是基于动态代理来实现的,在容器启动时需要生成代理实例,在方法调用上也会增加栈的深度,使得 Spring AOP 的性能不如 AspectJ 的那么好。...AspectJ AspectJ 是一个易用的功能强大的 AOP 框架,属于编译时增强, 可以单独使用,也可以整合到其它框架中,是 AOP 编程的完全解决方案。...AspectJ 属于静态织入,通过修改代码来实现,在实际运行之前就完成了织入,所以说它生成的类是没有额外运行时开销的,一般有如下几个织入的时机: 编译期织入(Compile-time weaving)...:如类 A 使用 AspectJ 添加了一个属性,类 B 引用了它,这个场景就需要编译期的时候就进行织入,否则没法编译类 B。...类加载后织入(Load-time weaving):指的是在加载类的时候进行织入,要实现这个时期的织入,有几种常见的方法 整体对比如下: ​ 编辑 Spring AOP和AspectJ对比 本期分享到此结束

    1.3K10

    面渣逆袭:Spring三十五问,四万字+五十图详解

    编译期织入:切面在目标类编译时被织入 类加载期织入:切面在目标类加载到JVM时被织入。需要特殊的类加载器,它可以在目标类被引入应用之前增强该目标类的字节码。...运行期织入:切面在应用运行的某个时刻被织入。一般情况下,在织入切面时,AOP容器会为目标对象动态地创建一个代理对象。SpringAOP就是以这种方式织入切面。...Spring采用运行期织入,而AspectJ采用编译期织入和类加载器织入。...AspectJ 属于静态织入,通过修改代码来实现,在实际运行之前就完成了织入,所以说它生成的类是没有额外运行时开销的,一般有如下几个织入的时机: 编译期织入(Compile-time weaving)...:如类 A 使用 AspectJ 添加了一个属性,类 B 引用了它,这个场景就需要编译期的时候就进行织入,否则没法编译类 B。

    78820

    【小家Spring】Spring AOP的多种使用方式以及神一样的AspectJ-AOP使用介绍

    在Spring中,AOP代理可以是JDK动态代理或者CGLIB代理。 织入(Weaving): 组装方面来创建一个被通知对象。这可以在编译时完成(例如使用AspectJ编译器),也可以在运行时完成。...(Weaving) :把切面应用到目标对象来创建新的代理对象的过程,织入一般发生在如下几个时机: ---- (1)编译时:当一个类文件被编译时进行织入,这需要特殊的编译器才可以做的到,例如AspectJ...的织入编译器 ---- (2)类加载时:使用特殊的ClassLoader在目标类被加载到程序之前增强类的字节代码 ----(3)运行时:切面在运行的某个时刻被织入,SpringAOP就是以这种方式织入切面的...ApectJ主要采用的是编译期织入,在这个期间使用AspectJ的acj编译器(类似javac)把aspect类编译成class字节码后,在java目标类编译时织入,即先编译aspect类再编译目标类。...Spring AOP的内部机制(动态织入),这是与AspectJ(静态织入)最根本的区别。

    2.6K20

    Spring AOP 最热门面试题及答案「建议收藏」

    织入是将切面与外部的应用类型或者类连接起来以创建通知对象(adviced object)的过程。这可以在编译时(比如使用 AspectJ 编译器)、加载时或者运行时完成。...Spring AOP 跟其他纯 Java AOP 框架一样,只在运行时执行织入。在协议上,AspectJ 框架支持编译时和加载时织入。...AspectJ 编译时织入是通过一个叫做 ajc 特殊的 AspectJ 编译器完成的。它可以将切面织入到你的 Java 源码文件中,然后输出织入后的二进制 class 文件。...在 Spring IoC 容器中声明你的类之前,你可以为它们运行编译时和后编译时织入。Spring 完全没有被包含到织入的过程中。更多关于编译时和后编译时织入的信息,请查阅 AspectJ 文档。...AspectJ 和 Spring 都提供了加载时织入器以为类加载添加加载时织入的能力。你只需要简单的配置就可以打开这个加载时织入器。

    2.5K20

    原生AspectJ用法分析以及Spring-AOP原理分析

    上面的说明其实也就指出了aspectJ的几种标准的使用方法(参考文档): 编译时织入,利用ajc编译器替代javac编译器,直接将源文件(java或者aspect文件)编译成class文件并将切面织入进代码...接下来我们就来尝试下三种不同的编译方式。 编译时织入 编译时织入其实就是使用ajc来进行编译,暂时不使用自动化构建工具,我们先在项目根目录下手动写一个编译脚本compile.sh: #!...加载时织入(LTW) 前两种织入方法都依赖于ajc的编译工具,LTW却通过java agent机制在内存中操作类文件,可以不需要ajc的支持做到动态织入。...强行织入? 当然,如果我们想,我们也可以强行采用织入的方式,不过我们就不能将切面类注册为spring的bean,只能采用ajc插件编译或者java agent在类加载时织入。...参考资料 比较分析 Spring AOP 和 AspectJ 之间的差别 AOP之@AspectJ技术原理详解 AspectJ 编译时织入(Compile Time Weaving, CTW) Mojohaus

    2.5K20

    昨天面了一位,见识到了Spring的天花板~

    编译期织入:切面在目标类编译时被织入 类加载期织入:切面在目标类加载到JVM时被织入。需要特殊的类加载器,它可以在目标类被引入应用之前增强该目标类的字节码。...Spring采用运行期织入,而AspectJ采用编译期织入和类加载器织入。...AspectJ 属于静态织入,通过修改代码来实现,在实际运行之前就完成了织入,所以说它生成的类是没有额外运行时开销的,一般有如下几个织入的时机: 编译期织入(Compile-time weaving)...:如类 A 使用 AspectJ 添加了一个属性,类 B 引用了它,这个场景就需要编译期的时候就进行织入,否则没法编译类 B。...类加载后织入(Load-time weaving):指的是在加载类的时候进行织入,要实现这个时期的织入,有几种常见的方法 整体对比如下: Spring AOP和AspectJ对比 事务 Spring

    66520

    Java 中反射、注解、动态代理、AOP 之间的联系

    AspectJ 就是编译期生成,可以由开发人员手动执行命令,也可以放在 maven 等自动执行。 Spring AOP 则是使用 JDK 或 CGLib 动态代理,在运行时动态生成的。...AspectJ 和 Spring AOP 都是什么关系 AspectJ 是 eclipse 下的项目,是一个 AOP 的实现框架,是一种对 Java 语言的扩展语言,在编译器将原来的 Java 代码中织入增强代码...AspectJ 分为 编译时织入:通过 ajc 用编译生成 class 文件 编译后织入:已经 javac 生成 class 文件后,通过处理 class 文件得到新的织入后的 class 文件 加载时织入...下面是编译时织入的例子 // 定义被增强类 public class App { public void say() { System.out.println("App say...虽然 spring 中使用了这些 AspectJ 的注解定义 AOP,但实际织入则用的是动态代理,是运行时动态执行的,而没用使用 AspectJ 在编译器织入。

    37911

    系统学习SpringFramework:Spring AOP

    织入(Weaving):是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入,而AspectJ采用编译期织入和类装载期织入。...AspectJ 则属于编译时增强,主要有3种方式: 编译时织入:指的是增强的代码和源代码我们都有,直接使用 AspectJ 编译器编译就行了,编译之后生成一个新的类,他也会作为一个正常的 Java 类装载到...JVM; 编译后织入:指的是代码已经被编译成 class 文件或者已经打成 jar 包,这时候要增强的话,就是编译后织入,比如你依赖了第三方的类库,又想对他增强的话,就可以通过这种方式; 加载时织入:...指的是在 JVM 加载类的时候进行织入。...总结下来的话,就是 Spring AOP 只能在运行时织入,不需要单独编译,性能相比 AspectJ 编译织入的方式慢,而 AspectJ 只支持编译前后和类加载时织入,性能更好,功能更加强大。

    25820

    Java岗大厂面试百日冲刺 - 日积月累,每日三题【Day16】—— Spring框架2

    的那么好 AspectJ AspectJ属于静态代理(织入),通过修改代码来实现,有如下几个织入的时机: 编译期织入(Compile-time weaving): 如类 A 使用 AspectJ...添加了一个属性,类 B 引用了它,这个场景就需要编译期的时候就进行织入,否则没法编译类 B。...编译后织入(Post-compile weaving): 也就是已经生成了 .class 文件,或已经打成 jar 包了,这种情况我们需要增强处理的话,就要用到编译后织入。...是否需要编译 不需要单独的编译过程 除非设置 LTW,否则需要 AspectJ 编译器 (ajc) 织入方式 只能使用运行时织入 运行时织入不可用。...支持编译时、编译后和加载时织入 织入能力 功能不强-仅支持方法级编织 更强大 – 可以编织字段、方法、构造函数、静态初始值设定项、最终类/方法等……。

    61320

    Spring基础知识之基于注解的AOP

    切面在指定的连接点被织入到目标对象中,在目标对象的生命周期里有多个点可以进行织入:         编译期:切面在目标类编译时织入。这种方式需要特殊的编译器。...AspectJ的织入编译器就是以这种方式织入切面的。         类加载期:切面在目标类被加载到JVM时织入。这种方式需要特殊的类加载器,他可以在目标类被引入应用之前增加该目标类的字节码。...AspectJ5的加载时织入,就支持以这种方式织入。         运行期:切面在应用运行的某个时刻被织入。...一般情况下,在切面被织入时,AOP容器会为目标对象动态创建代理对象,SpringAOP就是以这种方式进行织入的。   ...Spring在运行时通知对象       Spring运行时才会创建代理对象,所以我们不需要特殊的编译器来织入SpringAOP的切面。

    1.1K100

    【面试】Spring事务面试考点吐血整理(建议珍藏)

    事务注解在接口/类上 @Transactional注解可以用在接口上,也可以在类上。在接口上时,必须使用基于接口的代理才行,即JDK动态代理。...事实是Java的注解不能从接口继承,如果你使用基于类的代理,即CGLIB,或基于织入方面,即AspectJ,事务设置不会被代理和织入基础设施认出来,目标对象不会被包装到一个事务代理中。...Spring团队建议注解标注在类上而非接口上。 只在public方法上生效? 当采用代理来实现事务时,(注意是代理),@Transactional注解只能应用在public方法上。...如果想在非public方法上生效,考虑使用AspectJ(织入方式)。 目标类里的自我调用没有事务?...相反,目标类被织入(即它的字节码被修改)来把@Transactional加入到运行时行为,在任何种类的方法上都可以。

    60330
    领券