spring,mybatis事务管理配置与@Transactional注解使用[转]

Spring事务管理中@Transactional的参数配置Spring作为低侵⼊的Java EE框架之⼀，能够很好地与其他框架进⾏整合，其中Spring与Hibernate的整合实现的事务管理是常⽤的⼀种功能。

所谓事务，就必须具备ACID特性，即原⼦性、⼀致性、隔离性和持久性，在Hibernate的实现中，需要我们编写代码来完成事务的控制⼯作。

未使⽤Spring的事务管理12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 public static void main(String[] args) {// Configuration cfg = new Configuration();// cfg.configure();// SessionFactory sf = cfg.buildSessionFactory();//因为在HibernateUtil类中已经有⼀部分封装⼯作，所以以上三⾏注释掉了。

Session s = null;Transaction tx = null;try{Class.forName("com.HibernateUtil");s = HibernateUtil.getSession();tx = s.beginTransaction(); //这⾥开启了事务//事务中所需的⼀系列数据库操作。

mit();} catch(HibernateException e) { //如果出现异常，且事务已经开启，则需要回滚。

if(tx != null)tx.rollback();throw e;} catch(ClassNotFoundException e) {e.printStackTrace();} finally{ //⽆论如何都需要关闭Session。

spring的@Transactional注解详细用法各位读友大家好！你有你的木棉，我有我的文章，为了你的木棉，应读我的文章！若为比翼双飞鸟，定是人间有情人！若读此篇优秀文，必成天上比翼鸟！spring的@Transactional注解详细用法Spring Framework对事务管理提供了一致的抽象，其特点如下：为不同的事务API 提供一致的编程模型，比如JTA(Java Transaction API), JDBC, Hibernate, JPA(Java Persistence API和JDO(Java Data Objects)支持声明式事务管理，特别是基于注解的声明式事务管理，简单易用提供比其他事务API如JTA更简单的编程式事务管理API与spring数据访问抽象的完美集成事务管理方式spring支持编程式事务管理和声明式事务管理两种方式。

编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。

对于编程式事务管理，spring推荐使用TransactionTemplate。

声明式事务管理建立在AOP之上的。

其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式)，便可以将事务规则应用到业务逻辑中。

显然声明式事务管理要优于编程式事务管理，这正是spring倡导的非侵入式的开发方式。

声明式事务管理使业务代码不受污染，一个普通的POJO对象，只要加上注解就可以获得完全的事务支持。

和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。

Spring 事务注解@Transactional 失效的⼋种场景分析⾸先说⼀下最近⾃⼰遇到的⼀个坑：123456789@Transactional service A （）{try{insert();serviceB.update();}catch(){throw new RunTimeException();}}123456789serviceB(){@Transactional update(){try{mapperB.update();}catch(){throw new RunTimeException();}}}1234567mapperB (){try{//doSomething....return true;}catch(){return false;}}上⾯的例⼦中我的异常出现再//doSomething…的⼀个sql 执⾏异常了，serviceA 中的insert 却⼀直不能回滚，根本原因在于异常处只返回了false,并没有抛出运⾏异常，没有往上⼀层抛，serviceB 中有抛出运⾏异常，却只拿到了⼀个false,故不会回滚。

下⾯总结下常见的事务不会回滚的集中情况：这⾥以 MySQL 为例，其 MyISAM 引擎是不⽀持事务操作的，InnoDB 才是⽀持事务的引擎，⼀般要⽀持事务都会使⽤InnoDB 。

如下⾯例⼦所⽰：12345678// @Servicepublic class OrderServiceImpl implements OrderService {@Transactional public void updateOrder(Order order) { // update order }}如果此时把 @Service 注解注释掉，这个类就不会被加载成⼀个 Bean ，那这个类就不会被 Spring 管理了，事务⾃然就失效了。

@Transactional 只能⽤于 public 的⽅法上，否则事务不会失效，如果要⽤在⾮ public ⽅法上，可以开启 AspectJ 代理模式。

spring-mvc+mybatis注解⽅式事务管理配置⽂件：<!-- dataSource --><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"><property name="url" value="${db.master.url}" /><property name="username" value="${er}" /><property name="password" value="${db.master.password}" /><!-- 配置监控统计拦截的filters --><property name="filters" value="mergeStat,wall,log4j2" /><property name="initialSize" value="5" /><property name="maxActive" value="100" /><property name="minIdle" value="10" /><property name="maxWait" value="60000" /><property name="validationQuery" value="SELECT 'x'" /><property name="testOnBorrow" value="true" /><property name="testOnReturn" value="true" /><property name="testWhileIdle" value="true" /><property name="timeBetweenEvictionRunsMillis" value="60000" /><property name="minEvictableIdleTimeMillis" value="300000" /><property name="removeAbandoned" value="true" /><property name="removeAbandonedTimeout" value="1800" /><property name="logAbandoned" value="true" /></bean><!-- Spring整合Mybatis --><bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean"><property name="dataSource" ref="dataSource"/><!-- ⾃动扫描Mapping.xml⽂件 --><property name="mapperLocations" value="classpath*:/sqlMapperXml/*.xml"></property><property name="configLocation" value="classpath:xml/mybatis-config.xml"></property><property name="typeAliasesPackage" value="com.mingwork.model"/><property name="globalConfig" ref="globalConfig"/><property name="plugins"><array><!-- 分页插件配置 --><bean id="paginationInterceptor" class="com.baomidou.mybatisplus.plugins.PaginationInterceptor"><property name="dialectType" value="mysql"/><property name="optimizeType" value="aliDruid" /></bean></array></property></bean><!-- MP 全局配置 --><bean id="globalConfig" class="com.baomidou.mybatisplus.entity.GlobalConfiguration"><property name="idType" value="0"/><property name="dbColumnUnderline" value="true"/></bean><!-- MyBatis 动态实现 --><bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer"><!-- 对Dao 接⼝动态实现，需要知道接⼝在哪 --><property name="basePackage" value="com.mingwork.mapper"/></bean><!-- 事务管理 --><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"></property></bean><!-- 事务注解 --><tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/><!-- 事务管理属性 --><tx:advice id="transactionAdvice" transaction-manager="transactionManager"><tx:attributes><tx:method name="select*" propagation="REQUIRED" read-only="true" /><tx:method name="delete*" propagation="REQUIRED" rollback-for="Exception" /><tx:method name="update*" propagation="REQUIRED" rollback-for="Exception" /><tx:method name="insert*" propagation="REQUIRED" rollback-for="Exception" /><tx:method name="*" propagation="REQUIRED" /></tx:attributes></tx:advice><!-- 配置切⾯ --><aop:config expose-proxy="true" proxy-target-class="true"><aop:advisor advice-ref="transactionAdvice" pointcut="execution(* com.mingwork.service..*.*(..))"/></aop:config>上⾯配置的意思就是配置⾯向切⾯，只要servcie中的⽅法抛出Exception，那么insert，update，delete的sql⽅法都会回滚。

spring实现事务配置的⽅式，事务7⼤传播属性的区别⼀、注解式事务1、注解式事务在平时的开发中使⽤的挺多，⼯作的两个公司中看到很多项⽬使⽤了这种⽅式，下⾯看看具体的配置demo。

2、事务配置实例（1）、spring+mybatis 事务配置<!-- 定义事务管理器 --><bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource" /></bean><!--使⽤注释事务 --><tx:annotation-driven transaction-manager="transactionManager" />（2）、spring+hibernate 事务配置<!-- 事务管理器配置,单数据源事务 --><bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean><!-- 使⽤annotation定义事务 --><tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />看到上⾯的这两段配置⽂件是不是很熟悉，对的这就是我们平时看到的事务的配置，在spring的配置中配置数据源即dataSource、事务管理器，事务管理器使⽤不同的orm框架事务管理器类就不同，⽐如这⾥使⽤的是mybatis 所以是org.springframework.jdbc.datasource.DataSourceTransactionManager如果使⽤hibernate 则事务管理器类为org.springframework.orm.hibernate3.HibernateTransactionManager这是使⽤注解⽅式时要配置的，代码中的具体的注解以及事务的传播性、隔离级别⼀般在service 层中配置下⾯看看3、@Transactional（1）、这⾥说明⼀下，有的把这个注解放在类名称上⾯了，这样你配置的这个@Transactional 对这个类中的所有public⽅法都起作⽤（2）、@Transactional ⽅法⽅法名上，只对这个⽅法有作⽤，同样必须是public的⽅法⽐如这⾥就对这个⽅法定义了⼀个事务同时设置了很多属性：@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class,timeout=1,isolation=Isolation.DEFAULT)public void saveUser(Map<String, String> map) throws Exception {System.out.println("⽅法开始");for (int i = 0; i < 500000; i++) {System.out.println("*");}System.out.println("进⼊保存");userDao.saveUser(map);System.out.println("退出保存");}4、事物配置中有哪些属性可以配置（1）、事务的传播性：@Transactional(propagation=Propagation.REQUIRED)如果有事务, 那么加⼊事务, 没有的话新建⼀个(默认情况下)（2）、事务的超时性：@Transactional(timeout=30) //默认是30秒注意这⾥说的是事务的超时性⽽不是Connection的超时性，这两个是有区别的（3）、事务的隔离级别：@Transactional(isolation = Isolation.READ_UNCOMMITTED) ，未提交读，就是⼀个事务可以读取另⼀个未提交事务的数据。

spring,mybatis事务管理配置与@Transactional注解使用[转]spring,mybatis事务管理配置与@Transactional注解使用概述事务管理对于企业应用来说是至关重要的，即使出现异常情况，它也可以保证数据的一致性。

Spring Framework对事务管理提供了一致的抽象，其特点如下：为不同的事务API提供一致的编程模型，比如JTA(Java Transaction API), JDBC, Hibernate, JPA(Java Persistence API和JDO(Java Data Objects)支持声明式事务管理，特别是基于注解的声明式事务管理，简单易用提供比其他事务API如JTA更简单的编程式事务管理API与spring数据访问抽象的完美集成事务管理方式spring支持编程式事务管理和声明式事务管理两种方式。

编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。

对于编程式事务管理，spring推荐使用TransactionTemplate。

声明式事务管理建立在AOP之上的。

其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式)，便可以将事务规则应用到业务逻辑中。

显然声明式事务管理要优于编程式事务管理，这正是spring 倡导的非侵入式的开发方式。

声明式事务管理使业务代码不受污染，一个普通的POJO对象，只要加上注解就可以获得完全的事务支持。

和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。

spring注解@Transactional
⼀、@Transactional所需要的jar包
1、aopalliance.jar 这个包是联盟的包，⾥⾯包含了针对⾯向切⾯的接⼝。

(通常Spring等其它具备动态织⼊功能的框架依赖此包)
2、aspectjrt.jar 处理事务和AOP所需的包
3、aspectjweaver.jar 处理事务和AOP所需的包
4、cglib-nodep.jar 中⾃动代理所需jar包
⼆、使⽤@Transactional
1、@Transactional可以在service类或⽅法前加上@Transactional，在service类上声明@Transactional，service所有⽅法需要事务管理。

每⼀个业务⽅法开始时都会打开⼀个事务。

本例:在⽅法上添加@Transactional,显⽰所有数据的⽅法且属性设为⼀个只读的事务(readOnly=true),当然它还有其他⾮常多的属性我就不⼀⼀介绍了，如果同时想使⽤多个属性，属性与属性之间⽤逗号隔开。

三、spring配置⽂件
1、在spring配置⽂件中添加如下代码
2、要注意hibernate的版本，本例使⽤的是hibernate5。

3、property属性中的名字要⼀⼀对应。

ssm框架期末考试试题# SSM框架期末考试试题## 一、选择题（每题2分，共20分）1. SSM框架中，S代表的是：A. SpringB. Spring MVCC. Spring BootD. Spring Cloud2. 在Spring MVC中，以下哪个组件负责处理用户请求？A. DispatcherServletB. ControllerC. ServiceD. Repository3. MyBatis框架中的映射文件通常使用哪种格式？A. XMLB. JSONC. YAMLD. Properties4. Spring框架的依赖注入（DI）主要用于：A. 数据库连接B. 配置文件解析C. 组件之间的耦合D. 日志记录5. 以下哪个不是Spring MVC的视图技术？A. JSPB. ThymeleafC. FreeMarkerD. Hibernate6. 在Spring框架中，@Transactional注解通常用于：A. 声明方法的事务性B. 声明方法的线程安全性C. 声明方法的同步性D. 声明方法的并发性7. MyBatis中，以下哪个不是内置的Executor类型？A. SIMPLEB. BATCHC. REUSED. PERSISTENT8. 在Spring MVC中，拦截器（Interceptor）主要用于：A. 处理HTTP请求B. 处理HTTP响应C. 日志记录和权限校验D. 数据库事务管理9. Spring框架的AOP（面向切面编程）主要用于：A. 数据持久化B. 事务管理C. 业务逻辑处理D. 视图渲染10. 在MyBatis中，以下哪个不是配置文件中的元素？A. `<settings>`B. `<typeAliases>`C. `<resultMaps>`D. `<datasource>`## 二、简答题（每题5分，共10分）1. 简述Spring框架中Bean的作用域有哪些，并给出一个例子说明其使用场景。

SpringBoot事务注解@TransactionalSpringBoot提供了⾮常⽅便的事务操作，通过注解就可以实现事务的回滚，⾮常⽅便快捷，下⾯我们就说⼀下如何进⾏事务操作。

1. 事务说明在Spring中，事务有两种实现⽅式，分别是编程式事务管理和声明式事务管理两种⽅式。

编程式事务管理：编程式事务管理使⽤TransactionTemplate或者直接使⽤底层的PlatformTransactionManager。

对于编程式事务管理，spring推荐使⽤TransactionTemplate。

声明式事务管理：建⽴在AOP之上的。

其本质是对⽅法前后进⾏拦截，然后在⽬标⽅法开始之前创建或者加⼊⼀个事务，在执⾏完⽬标⽅法之后根据执⾏情况提交或者回滚事务。

声明式事务管理不需要⼊侵代码，通过@Transactional就可以进⾏事务操作，更快捷⽽且简单。

推荐使⽤2. 如何使⽤在Mybatis中使⽤事务，⾮常简单，只需要在函数增加注解@Transactional，⽆需任何配置。

我们通过在controller层增加事务例⼦看下：@AutowiredOrderServiceorderService; //order操作的Service层@ApiOperation(value = "增加OrderCustomer")@RequestMapping(value = "", method = RequestMethod.POST)@ResponseBody@Transactionalpublic JsonBean<Order> insertOrder(@RequestParam(value = "order") String order) {try {//创建订单Order order = orderService.insert(user.getId(),is_company,fk_want_company_id);return new JsonBean(SUCCESS, orderCustomer);}catch (ErrorCodeException e){TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();return new JsonBean(e.getErrorCode());}}@Transactional可以作⽤于接⼝、接⼝⽅法、类以及类⽅法上。

在MyBatis中，@Transactional注解通常不是直接由MyBatis框架本身提供的，而是由底层的事务管理框架（例如Spring的@Transactional注解）提供支持。

因此，@Transactional注解的原理主要取决于使用的事务管理框架。

一般来说，如果你在Spring中使用@Transactional注解，那么事务的管理和处理将由Spring 的事务管理器来完成。

以下是一个简单的概述：声明式事务管理：@Transactional注解是一种声明式事务管理的方式。

通过在方法或类上使用这个注解，你告诉Spring在执行这些方法时要开启事务，并且当方法执行完成后，根据执行结果决定是提交事务还是回滚事务。

事务的传播行为：@Transactional注解允许你设置事务的传播行为，即在一个事务方法调用另一个事务方法时，应该如何处理事务。

一些常见的传播行为包括REQUIRED、REQUIRES_NEW、NESTED等。

事务的隔离级别：你还可以使用@Transactional注解设置事务的隔离级别，指定事务的一致性要求。

常见的隔离级别包括READ_COMMITTED、REPEATABLE_READ等。

事务的超时设置：通过timeout属性，你可以指定事务的超时时间，即事务允许执行的最长时间。

回滚规则：@Transactional注解还允许你定义在哪些异常发生时回滚事务。

通过rollbackFor 和noRollbackFor属性，你可以指定哪些异常会触发回滚，哪些异常不会触发回滚。

总的来说，@Transactional注解的原理涉及到事务的开启、提交、回滚等操作，这些操作由底层的事务管理器实现。

在使用MyBatis时，通常与Spring集成，通过Spring的事务管理功能来处理事务。

spring注解-@Transactional事务⼏点注意这⾥⾯有⼏点需要⼤家留意：A. ⼀个功能是否要事务，必须纳⼊设计、编码考虑。

不能仅仅完成了基本功能就ok。

B. 如果加了事务，必须做好开发环境测试（测试环境也尽量触发异常、测试回滚），确保事务⽣效。

C. 以下列了事务使⽤过程的注意事项，请⼤家留意。

1. 不要在接⼝上声明@Transactional ，⽽要在具体类的⽅法上使⽤ @Transactional 注解，否则注解可能⽆效。

2.不要图省事，将@Transactional放置在类级的声明中，放在类声明，会使得所有⽅法都有事务。

故@Transactional应该放在⽅法级别，不需要使⽤事务的⽅法，就不要放置事务，⽐如查询⽅法。

否则对性能是有影响的。

3.使⽤了@Transactional的⽅法，对同⼀个类⾥⾯的⽅法调⽤， @Transactional⽆效。

⽐如有⼀个类Test，它的⼀个⽅法A，A再调⽤Test 本类的⽅法B（不管B是否public还是private），但A没有声明注解事务，⽽B有。

则外部调⽤A之后，B的事务是不会起作⽤的。

（经常在这⾥出错）4.使⽤了@Transactional的⽅法，只能是public，@Transactional注解的⽅法都是被外部其他类调⽤才有效，故只能是public。

道理和上⾯的有关联。

故在 protected、private 或者 package-visible 的⽅法上使⽤ @Transactional 注解，它也不会报错，但事务⽆效。

5.经过在ICORE-CLAIM中测试，效果如下：A.抛出受查异常XXXException，事务会回滚。

B.抛出运⾏时异常NullPointerException，事务会回滚。

C.Quartz中，execute直接调⽤加了@Transactional⽅法，可以回滚；间接调⽤，不会回滚。

（即上⽂3点提到的）D.异步任务中，execute直接调⽤加了@Transactional⽅法，可以回滚；间接调⽤，不会回滚。

spring事务注解@Transactional的实现原理（转）出处：Transactional是spring中定义的事务注解，在⽅法或类上加该注解开启事务。

主要是通过反射获取bean的注解信息，利⽤AOP对编程式事务进⾏封装实现。

AOP对事务的封装可以看。

我们先写个demo，感受它的加载过程。

spring事务注解：1. ⾃定义⼀个注解/*** @Target 作⽤域(作⽤在⽅法上,类上,或是属性上)* @Retention 运⾏周期* @interface 定义注解*/@Target(value = ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface MyAnnotation {//⾃定义注解的属性int id() default 0;String name() default "默认名称";String[]arrays();String title() default "默认标题";}2. 测试import ng.reflect.Method;public class User {@MyAnnotation(name="吴磊",arrays = {"2","3"})public void aMethod () {}public void bMethod () {}public static void main(String[] args) throws ClassNotFoundException {//1. 反射获取到类信息Class<?> forName = Class.forName("er");//2. 获取到当前类（不包含继承）所有的⽅法Method[] declaredMethods = forName.getDeclaredMethods();//3. 遍历每个⽅法的信息for (Method method : declaredMethods) {System.out.println("⽅法名称:" + method.getName());//4. 获取⽅法上⾯的注解MyAnnotation annotation = method.getDeclaredAnnotation(MyAnnotation.class);if(annotation == null) {System.out.println("该⽅法上没有加注解....");}else {System.out.println("Id:" + annotation.id());System.out.println("Name:" + ());System.out.println("Arrays:" + annotation.arrays());System.out.println("Title:" + annotation.title());}System.out.println("--------------------------");}}}=============================【控制台输出】⽅法名称:main该⽅法上没有加注解....--------------------------⽅法名称:aMethodId:0Name:吴磊Arrays:[ng.String;@74a14482Title:默认标题--------------------------⽅法名称:bMethod该⽅法上没有加注解....--------------------------总结：通过上⾯这么⼀个⼩demo我们就能发现，反射获取到每⼀个⽅法的注解信息然后进⾏判断，如果这是@Transactional注解，spring就会开启事务。

spring学习7：纯注解整合mybatis和事务控制⽬录spring学习7: 纯注解整合mybatis和事务控制本⽂记录下如何利⽤纯注解的⽅式整合spring和mybatis⼀、引⼊依赖需要引⼊的依赖包括spring、mybatis、mybatis-spring、数据库驱动、连接池<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.1.5.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.1.5.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-tx</artifactId><version>5.1.5.RELEASE</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>1.3.2</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.4.5</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.46</version></dependency><!--连接池--><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.11</version></dependency>⼆、整合过程2.1 整合原理本⽂中sql语句是写在xml⽂件中的mybatis-spring提供了⼀个SqlSessionFactoryBean类，创建该类的对象添加到容器中,然后再⽤MapperScan注解指定要扫描的dao层接⼝的包路径。

mybatis 中的transaction 注解在MyBatis 中，事务（transaction）是用于管理数据库操作的机制，它确保一系列数据库操作的原子性、一致性、隔离性和持久性（ACID 属性）。

MyBatis 并没有特定的`@Transaction` 注解，而是通常与Spring 或其他事务管理框架一起使用，这些框架提供了事务管理的注解。

如果你是在Spring 中使用MyBatis，你可以使用Spring 的`@Transactional` 注解来标记一个方法或类，以指示该方法或类需要在事务管理下执行。

以下是一个简单的示例：```javaimport org.springframework.transaction.annotation.Transactional;@Servicepublic class MyService {@Autowiredprivate MyBatisMapper myBatisMapper;@Transactionalpublic void performDatabaseOperations() {// MyBatis 数据库操作myBatisMapper.insertData(...);myBatisMapper.updateData(...);// 其他业务逻辑}}```在上述示例中，`@Transactional` 注解被用于`performDatabaseOperations` 方法上，表示这个方法需要在事务管理下执行。

如果在执行方法期间发生了异常，事务将会回滚。

要在MyBatis 中使用事务，通常需要确保配置文件（例如`mybatis-config.xml`）中启用了事务管理器，并且MyBatis 映射器（Mapper）的方法遵循数据库事务。

在Spring 中，你还需要配置事务管理器，以便与Spring 的事务管理框架集成。

需要注意的是，如果你不使用Spring 或其他事务管理框架，而是直接使用MyBatis，你可以在Java 代码中使用`SqlSession` 和`Transaction` 对象手动管理事务。

spring@Transactional注解⽆效<!-- 配置事务管理器 --><bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"/></bean><!-- 配置基于注解的声明式事务 --><tx:annotation-driven transaction-manager="transactionManager"/><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd/schema/context /schema/context/spring-context-4.3.xsd/schema/aop /schema/aop/spring-aop-4.3.xsd/schema/tx /schema/tx/spring-tx-4.3.xsd"></beans>@Override@Transactionalpublic ResponseHelper insert(List<TranslateLexicon> models) {//do something here}1.确保<beans>节点包含xml的tx和aop命名空间。

对于spring中事务@Transactional注解的理解现在spring的配置都喜欢⽤注解，但是在这之前，还是有必要复习下然后咱们再来说看@Transactional⼀、如何开启@Transactional⽀持 要使⽤@Transactional，spring的配置⽂件applicationContext.xml中还是要写些东西的，那就看看最流⾏的两个ORM框架，如何配置，spring所有的事务管理策略类都继承⾃org.springframework.transaction.PlatformTransactionManager接⼝。

1.spring+mybatis 事务配置1 <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <!-- 定义事务管理器 -->2 <property name="dataSource" ref="dataSource" />3 </bean>4 <!--使⽤注释事务 -->5 <tx:annotation-driven transaction-manager="transactionManager" /> 2.spring+hibernate 事务配置1 <!-- 事务管理器配置,单数据源事务 -->2 <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">3 <property name="sessionFactory" ref="sessionFactory" />4 </bean>56 <!-- 使⽤annotation定义事务 -->7 <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />⼆、如何使⽤@Transactional 1.@Transactional⼀般作⽤于类上，像类似struts2的action类上，springmvc的controller类上，或者webservice的路径类上，等等涉及到数据库操作的类上，另外可以在该类的具体⽅法上在覆盖⼀个个性化的@Transactional。

Spring中的@Transactional事务注解⼀、事务特性@Transactional注解是⽤于事务控制的，需要知道事务的ACID特征：即原⼦性（Atomicity，或称不可分割性）、⼀致性（Consistency）、隔离性（Isolation，⼜称独⽴性）、持久性（Durability）。

事务是⽤来控制数据的ACID特性的，⽤于保证数据的正确性和完整性。

@Transactional注解有两种使⽤⽅式：（1）标注在类上⾯：当作⽤于类上时，该类的所有public⽅法将都具有该类型的事务属性，同时，我们也可以在⽅法级别使⽤该标注来覆盖类级别的定义。

（2）标注在⽅法上⾯：当作⽤于⽅法上时，只有当该⽅法发⽣了异常才会进⾏回滚，其他的⽅法不受影响。

在项⽬中使⽤，@Transactional(rollbackFor=Exception.class)，如果类加了这个注解，那么这个类⾥⾯的⽅法抛出异常，就会回滚，数据库⾥⾯的数据也会回滚。

在@Transactional注解中如果不配置rollbackFor属性，那么事物只会在遇到RuntimeException的时候才会回滚，加上rollbackFor=Exception.class，可以让事物在遇到⾮运⾏时异常时也回滚。

⼆、事务传播⾏为与隔离级别@Transactional(isolation = Isolation.DEFAULT, propagation = Propagation.REQUIRED, rollbackFor = Exception.class)（1）事物传播⾏为介绍:@Transactional(propagation=Propagation.REQUIRED) ：如果有事务, 那么加⼊事务, 没有的话新建⼀个(默认情况下)@Transactional(propagation=Propagation.NOT_SUPPORTED) ：容器不为这个⽅法开启事务@Transactional(propagation=Propagation.REQUIRES_NEW) ：不管是否存在事务，都创建⼀个新的事务，原来的挂起，新的执⾏完毕后继续执⾏⽼的事务@Transactional(propagation=Propagation.MANDATORY) ：必须在⼀个已有的事务中执⾏，否则抛出异常@Transactional(propagation=Propagation.NEVER) ：必须在⼀个没有的事务中执⾏，否则抛出异常(与Propagation.MANDATORY相反)@Transactional(propagation=Propagation.SUPPORTS) ：如果其他bean调⽤这个⽅法，在其他bean中声明事务那就⽤事务，如果其他bean没有声明事务，那就不⽤事务（2）事物超时设置：@Transactional(timeout=30) //默认是30秒（3）事务隔离级别：@Transactional(isolation = Isolation.READ_UNCOMMITTED)：读取未提交数据(会出现脏读, 不可重复读) 基本不使⽤@Transactional(isolation = Isolation.READ_COMMITTED)：读取已提交数据(会出现不可重复读和幻读)@Transactional(isolation = Isolation.REPEATABLE_READ)：可重复读(会出现幻读)@Transactional(isolation = Isolation.SERIALIZABLE)：串⾏化MYSQL: 默认为REPEATABLE_READ级别SQLSERVER: 默认为READ_COMMITTED 脏读 : ⼀个事务读取到另⼀事务未提交的更新数据。

SpringBoot使⽤@Transactional注解配置事务1、详细介绍事务管理是应⽤系统开发中必不可少的⼀部分。

Spring 为事务管理提供了丰富的功能⽀持。

Spring 事务管理分为编程式和声明式的两种⽅式。

编程式事务指的是通过编码⽅式实现事务；声明式事务基于 AOP,将具体业务逻辑与事务处理解耦。

声明式事务管理使业务代码逻辑不受污染, 因此在实际使⽤中声明式事务⽤的⽐较多。

声明式事务有两种⽅式，⼀种是在配置⽂件（xml）中做相关的事务规则声明，另⼀种是基于@Transactional注解的⽅式。

@Transactional可以作⽤于接⼝、接⼝⽅法、类以及类⽅法上。

当作⽤于类上时，该类的所有public⽅法将都具有该类型的事务属性，同时，我们也可以在⽅法级别使⽤该标注来覆盖类级别的定义。

虽然@Transactional注解可以作⽤于接⼝、接⼝⽅法、类以及类⽅法上，但是Spring建议不要在接⼝或者接⼝⽅法上使⽤该注解，因为这只有在使⽤基于接⼝的代理时它才会⽣效。

另外，@Transactional注解应该只被应⽤到public⽅法上，这是由Spring AOP的本质决定的。

如果你在protected、private或者默认可见性的⽅法上使⽤@Transactional注解，这将被忽略，也不会抛出任何异常。

默认情况下，只有来⾃外部的⽅法调⽤才会被AOP代理捕获，也就是，类内部⽅法调⽤本类内部的其他⽅法并不会引起事务⾏为，即使被调⽤⽅法使⽤@Transactional注解进⾏修饰。

2、使⽤⽅法注：SpringBoot项⽬会⾃动配置⼀个DataSourceTransactionManager，所以我们只需在⽅法（或者类）加上@Transactional注解，就⾃动纳⼊Spring的事务管理了。

如下在⽅法加上 @Transactional 注解：抛出异常之后，事务会⾃动回滚，数据不会插⼊到数据库。