SpringBoot: Mybatis配置事务管理

        <!-- mysql 连接 -->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>${mybatis-spring-boot-starter.version}</version>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql-connector-java.version}</version>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid-spring-boot-starter</artifactId>
			<version>${com.alibaba.druid.version}</version>
		</dependency>
		<!-- 分页控件 -->
		<dependency>
			<groupId>com.github.pagehelper</groupId>
			<artifactId>pagehelper</artifactId>
			<version>4.1.6</version>
		</dependency>

搭建SpringBoot + MyBatist +Druid + PageHelper 依赖核心jar 包文件。

今天重点讲解：MyBatis 事务配置管理

第一步：程序入口添加@EnableTransactionManagement ,启动事务管理器

package com.zzg.batch;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@SpringBootApplication
@EnableTransactionManagement
@MapperScan("com.zzg.batch.mapper")
public class Application extends SpringBootServletInitializer{

	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
		System.out.println("============= SpringBoot gcxt-system-provider Service Start Success =============");

	}

	@Override
	protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
		// 注意这里要指向原先用main方法执行的Application启动类
		return builder.sources(Application.class);
	}
}

原因：mybatis-spring-boot-starter jar文件包含事务处理的jar包：spring-tx.jar。

第二步：在业务逻辑的实现类添加@Transactional，注意：（如果整个类的所有方法都需要事务管理则在类上添加，如果仅某个方法需要事务管理则在方法上添加）

package com.zzg.batch.service.impl;

import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.zzg.batch.domain.AuthUser;
import com.zzg.batch.mapper.AuthUserMapper;
import com.zzg.batch.service.AuthUserService;
import com.zzg.jreport.common.convert.SimpleTypeConverterUtil;
import com.zzg.jreport.common.page.PageData;
import com.zzg.jreport.common.page.PageParam;

@Service
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT,timeout=36000,rollbackFor=Exception.class)
public class AuthUserServiceImpl implements AuthUserService {
	@Autowired
	private AuthUserMapper mapper;

	@Override
	public Long insert(AuthUser entity) {
		// TODO Auto-generated method stub
		Integer num = mapper.insertSelective(entity);
		return Long.valueOf(num);
	}

	@Override
	public void updateByPrimaryKeySelective(AuthUser entity) {
		// TODO Auto-generated method stub
		mapper.updateByPrimaryKeySelective(entity);
	}

	@Override
	public AuthUser selectByPrimaryKey(String sid) {
		// TODO Auto-generated method stub
		return mapper.selectByPrimaryKey(SimpleTypeConverterUtil.convertIfNecessary(sid, int.class));
	}

	@Override
	public void deleteByPrimaryKey(String sid) {
		// TODO Auto-generated method stub
		mapper.deleteByPrimaryKey(SimpleTypeConverterUtil.convertIfNecessary(sid, int.class));
	}

	@Override
	public List<AuthUser> selectAll(Map<String, Object> paramter) {
		// TODO Auto-generated method stub
		return mapper.selectAll(paramter);
	}

	@Override
	public PageData<AuthUser> selectAllPage(Map<String, Object> parame, PageParam rb) {
		// TODO Auto-generated method stub
		PageData<AuthUser> pageData = new PageData<AuthUser>();

		PageHelper.startPage(rb.getPageNo(), rb.getLimit());
		List<AuthUser> rs = mapper.selectAll(parame);

		PageInfo<AuthUser> pageInfo = new PageInfo<AuthUser>(rs);
		pageData.setData(pageInfo.getList());
		pageData.setPageNum(pageInfo.getPageNum());
		pageData.setPageSize(pageInfo.getPageSize());
		pageData.setTotalCount(pageInfo.getTotal());
		return pageData;
	}

	@Override
	public void transaction() {
		// TODO Auto-generated method stub
		AuthUser admin = new AuthUser();
		admin.setId(1);
		admin.setUsername("admin");
		mapper.updateByPrimaryKeySelective(admin);
		
		int a = 1 / 0;
		
		AuthUser superMan = new AuthUser();
		superMan.setId(2);
		superMan.setUsername("superMan");
		mapper.updateByPrimaryKeySelective(superMan);
		
		
	}

}

@Transactional 注解标签属性详解：

propagation --事务传播行为：

PROPAGATION_REQUIRED	如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认值。
PROPAGATION_REQUIRES_NEW	创建一个新的事务，如果当前存在事务，则把当前事务挂起。
PROPAGATION_NOT_SUPPORTED	以非事务方式运行，如果当前存在事务，则把当前事务挂起。
PROPAGATION_NEVER	以非事务方式运行，如果当前存在事务，则抛出异常。
PROPAGATION_MANDATORY	如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
PROPAGATION_NESTED	如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。

isolation -- 事务隔离级别

ISOLATION_DEFAULT	这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是
ISOLATION_READ_UNCOMMITTED	该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读，不可重复读和幻读，因此很少使用该隔离级别。比如PostgreSQL实际上并没有此级别。
ISOLATION_READ_COMMITTED	该隔离级别表示一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读，这也是大多数情况下的推荐值。
ISOLATION_REPEATABLE_READ	该隔离级别表示一个事务在整个过程中可以多次重复执行某个查询，并且每次返回的记录都相同。该级别可以防止脏读和不可重复读。
ISOLATION_SERIALIZABLE	所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。

timeout--事务超时

readOnly--读写或只读事务

rollbackFor--指定特定异常实例，遇到时数据回滚

rollbackForClassname--指定特定异常名，遇到时数据回滚

norollbackFor --指定特定异常实例，遇到时数据不会回滚

norollbackForClassname--指定特定异常名，遇到时数据不会回滚