前言
前一篇文章《MyBatis5：MyBatis整合Spring事物管理（上篇）》複習了MyBatis的基本使用以及使用Spring管理MyBatis的事物的做法，本文的目的是在這個的基礎上稍微做一點點的進階：多資料的事物處理。文章內容主要包含兩方面：
1、單表多資料的事物處理
2、多庫/多表多資料的事物處理
這兩種都是企業級開發中常見的需求，有一定的類似，在處理的方法與技巧上又各有不同，在進入文章前，先做一些準備工作，因為後面會用到多表的插入事物管理，前面的文章建立了一個Student相關表及類，這裡再建立一個Teacher相關的表及類。第一步是建立一張Teacher表：
create table teacher ( teacher_id int auto_increment, teacher_name varchar(20) not null, primary key(teacher_id) )
建立teacher_mapper.xml：
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > <mapper namespace="TeacherMapper"> <resultMap type="Teacher" id="TeacherMap"> <id column="teacher_id" property="teacherId" jdbcType="INTEGER" /> <result column="teacher_name" property="teacherName" jdbcType="VARCHAR" /> </resultMap> <select id="selectAllTeachers" resultMap="TeacherMap"> select teacher_id, teacher_name from teacher; </select> <insert id="insertTeacher" useGeneratedKeys="true" keyProperty="teacher_id" parameterType="Teacher"> insert into teacher(teacher_id, teacher_name) values(null, #{teacherName, jdbcType=VARCHAR}); </insert> </mapper>
建立Teacher.java：
public class Teacher { private int teacherId; private String teacherName; public int getTeacherId() { return teacherId; } public void setTeacherId(int teacherId) { this.teacherId = teacherId; } public String getTeacherName() { return teacherName; } public void setTeacherName(String teacherName) { this.teacherName = teacherName; } public String toString() { return "Teacher{teacherId:" + teacherId + "], [teacherName:" + teacherName + "}"; } }
還是再次提醒一下，推薦重寫toString()方法，列印關鍵屬性。不要忘了在config.xml裡面給Teacher.java宣告一個別名：
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <typeAliases> <typeAlias alias="Student" type="org.xrq.domain.Student" /> <typeAlias alias="Teacher" type="org.xrq.domain.Teacher" /> </typeAliases> </configuration>
接著是TeacherDao.java介面：
public interface TeacherDao { public List<Teacher> selectAllTeachers(); public int insertTeacher(Teacher teacher); }
其實現類TeacherDaoImpl.java：
@Repository public class TeacherDaoImpl extends SqlSessionDaoSupport implements TeacherDao { private static final String NAMESPACE = "TeacherMapper."; @Resource public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) { super.setSqlSessionFactory(sqlSessionFactory); } public List<Teacher> selectAllTeachers() { return getSqlSession().selectList(NAMESPACE + "selectAllTeachers"); } public int insertTeacher(Teacher teacher) { return getSqlSession().insert(NAMESPACE + "insertTeacher", teacher); } }
OK，這樣準備工作就全部做完了，有需要的朋友可以實際去把TeacherDao中的方法正確性先驗證一下，下面進入文章的內容。
單表事物管理
有一個很常見的需求，在同一張表裡面，我想批量插入100條資料，但是由於這100條資料之間存在一定的相關性，只要其中任何一條事物的插入失敗，之前插入成功的資料就全部回滾，這應當如何實現？這裡有兩種解決方案：
1、使用MyBatis的批量插入功能
2、使用Spring管理事物，任何一條資料插入失敗
由於我們限定的前提是單表，因此比較推薦的是第一種做法。
第二種做法儘管也可以實現我們的目標，但是每插入一條資料就要發起一次資料庫連線，即使使用了資料庫連線池，但在效能上依然有一定程度的損失。而使用MyBatis的批量插入功能，只需要發起一次資料庫的連線，這100次的插入操作在MyBatis看來是一個整體，其中任何一個插入的失敗都將導致整體插入操作的失敗，即：要麼全部成功，要麼全部失敗。
下面來看一下實現，首先在student_mapper.xml中新增一個批量新增的方法<insert>：
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > <mapper namespace="StudentMapper"> <resultMap type="Student" id="StudentMap"> <id column="student_id" property="studentId" jdbcType="INTEGER" /> <result column="student_name" property="studentName" jdbcType="VARCHAR" /> </resultMap> ... <insert id="batchInsert" useGeneratedKeys="true" parameterType="java.util.List"> <selectKey resultType="int" keyProperty="studentId" order="AFTER"> SELECT LAST_INSERT_ID() </selectKey> insert into student(student_id, student_name) values <foreach collection="list" item="item" index="index" separator=","> (#{item.studentId, jdbcType=INTEGER}, #{item.studentName, jdbcType=VARCHAR}) </foreach> </insert> </mapper>
這裡主要是利用MyBatis提供的foreach，對傳入的List做了一次遍歷，並取得其中的屬性進行插入。
然後在StudentDao.java中新增一個批量新增的方法batchInsert：
public interface StudentDao { public List<Student> selectAllStudents(); public int insertStudent(Student student); public int batchInsertStudents(List<Student> studentList); }
StudentDaoImpl.java實現它：
@Repository public class StudentDaoImpl extends SqlSessionDaoSupport implements StudentDao { private static final String NAMESPACE = "StudentMapper."; @Resource public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) { super.setSqlSessionFactory(sqlSessionFactory); }
... public int batchInsertStudents(List<Student> studentList) { return getSqlSession().insert(NAMESPACE + "batchInsert", studentList); } }
接著驗證一下，首先drop一下student這張表並重新建一下，然後寫一段測試程式：
public class StudentTest { @SuppressWarnings("resource") public static void main(String[] args) { ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml"); StudentDao studentDao = (StudentDao)ac.getBean("studentDaoImpl"); List<Student> studentList = null; Student student0 = new Student(); student0.setStudentName("Smith"); Student student1 = new Student(); student1.setStudentName("ArmStrong"); studentList = new ArrayList<>(); studentList.add(student0); studentList.add(student1); studentDao.batchInsertStudents(studentList); System.out.println("-----Display students------"); studentList = studentDao.selectAllStudents(); for (int i = 0, length = studentList.size(); i < length; i++) System.out.println(studentList.get(i)); } }
執行結果為：
-----Display students------ Student{[studentId:1], [studentName:Smith]} Student{[studentId:2], [studentName:ArmStrong]}
看到批量插入成功。
從另外一個角度來看，假如我們這麼建立這個studentList：
Student student0 = new Student(); student0.setStudentName("Smith"); Student student1 = new Student(); student1.setStudentName(null); studentList = new ArrayList<>(); studentList.add(student0); studentList.add(student1); studentDao.batchInsertStudents(studentList);
故意製造第一條插入OK，第二條插入報錯的場景，此時再執行一下程式，程式會丟擲異常，即使第一條資料是OK的，依然不會插入。
最後，這裡是批量插入，批量修改、批量刪除也是一樣的做法，可以自己試驗一下。
多庫/多表事物管理
上面的場景是對於單表的事物管理做法的推薦：實際上這並沒有用到事物管理，而是使用MyBatis批量運算元據的做法，目的是為了減少和資料庫的互動次數。
現在有另外一種場景，我要對單庫/多庫的兩張表（Student表、Teacher表）同時插入一條資料，要麼全部成功，要麼全部失敗，該如何處理？此時明顯就不可以使用MyBatis批量操作的方法了，要實現這個功能，可以使用Spring的事物管理。
前面文章有講，Dao層中的方法更多的是一種對資料庫的增刪改查的原子性操作，而Service層中的方法相當於對這些原子性的操作做一個組合，這裡要同時操作TeacherDao、StudentDao中的insert方法，因此建立一個SchoolService介面：
public interface SchoolService { public void insertTeacherAndStudent(Teacher teacher, Student student); }
寫一下這個介面的實現類：
@Service public class SchoolServiceImpl implements SchoolService { @Resource private StudentDao studentDao; @Resource private TeacherDao teacherDao; @Transactional public void insertTeacherAndStudent(Teacher teacher, Student student) { studentDao.insertStudent(student); teacherDao.insertTeacher(teacher); } }
這裡用到了兩個註解，解釋一下。
（1）@Service註解
嚴格地說這裡使用@Service註解不是特別好，因為Service作為服務層，更多的是應該對同一個Dao中的多個方法進行組合，如果要用到多個Dao中的方法，建議應該是放到Controller層中，引入兩個Service，這裡為了簡單，就簡單在一個Service中注入了StudentDao和TeacherDao兩個了。
（2）@Transactional註解
這個註解用於開啟事物管理，注意@Transactional註解的使用前提是該方法所在的類是一個Spring Bean，因此（1）中的@Service註解是必須的。換句話說，假如你給方法加了@Transactional註解卻沒有給類加@Service、@Repository、@Controller、@Component四個註解其中之一將類宣告為一個Spring的Bean，那麼對方法的事物管理，是不會起作用的。關於@Transactional註解，會在下面進一步解讀。
接著寫一個測試類測試一下：
public class SchoolTest { @SuppressWarnings("resource") public static void main(String[] args) { ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml"); SchoolService schoolService = (SchoolService)ac.getBean("schoolServiceImpl"); Student student = new Student(); student.setStudentName("Billy"); Teacher teacher = new Teacher(); teacher.setTeacherName("Luna"); schoolService.insertTeacherAndStudent(teacher, student); } }
可以看一下資料庫，Student表和Teacher表會同時多一條記錄。接著繼續從另外一個角度講，我這麼建立Student和Teacher：
Student student = new Student(); student.setStudentName("White"); Teacher teacher = new Teacher(); teacher.setTeacherName(null);
故意製造Teacher報錯的場景，此時儘管Student沒有問題，但是由於Teacher插入報錯，因此Student的插入進行回滾，檢視Student表，是不會有student_name為"White"這條記錄的。
@Transactional註解
@Transactional這個註解絕對是Java程式設計師的一個福音，如果沒有@Transactional註解，我們使用配置檔案的做法進行宣告式事務管理，我網上隨便找一段配置檔案：
<!-- 事物切面配置 --> <tx:advice id="advice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="update*" propagation="REQUIRED" read-only="false" rollback-for="java.lang.Exception"/> <tx:method name="insert" propagation="REQUIRED" read-only="false"/> </tx:attributes> </tx:advice> <aop:config> <aop:pointcut id="testService" expression="execution (* com.baobao.service.MyBatisService.*(..))"/> <aop:advisor advice-ref="advice" pointcut-ref="testService"/> </aop:config>
這種宣告式的做法不得不說非常不好控制以及進行除錯，尤其在要進行事物管理的內容不斷增多之後，尤其體現出它的不方便。
使用@Transactional註解就不一樣了，它可以精細到具體的類甚至具體的方法上（區別是同一個類，對方法的事物管理配置會覆蓋對類的事務管理配置），另外，宣告式事物中的一些屬性，在@Transaction註解中都可以進行配置，下面總結一下常用的一些屬性。
（1） @Transactional(propagation = Propagation.REQUIRED)
最重要的先說，propagation屬性表示的是事物的傳播特性，一共有以下幾種：
| 事物傳播特性 | 作 用 |
| Propagation.REQUIRED | 方法執行時如果已經處在一個事物中，那麼就加入到這個事物中，否則自己新建一個事物，REQUIRED是預設的事物傳播特性 |
| Propagation.NOT_SUPPORTED | 如果方法沒有關聯到一個事物，容器不會為它開啟一個事物，如果方法在一個事物中被呼叫，該事物會被掛起直到方法呼叫結束再繼續執行 |
| Propagation.REQUIRES_NEW | 不管是否存在事物，該方法總會為自己發起一個新的事物，如果方法已經執行在一個事物中，則原有事物掛起，新的事物被建立 |
| Propagation.MANDATORY | 該方法只能在一個已經存在的事物中執行，業務方法不能發起自己的事物，如果在沒有事物的環境下被呼叫，容器丟擲異常 |
| Propagation.SUPPORTS | 該方法在某個事物範圍內被呼叫，則方法成為該事物的一部分，如果方法在該事物範圍內被呼叫，該方法就在沒有事物的環境下執行 |
| Propagation.NEVER | 該方法絕對不能在事物範圍內執行，如果在就丟擲異常，只有該方法沒有關聯到任何事物，才正常執行 |
| Propagation.NESTED | 如果一個活動的事物存在，則執行在一個巢狀的事物中。如果沒有活動事物，則按REQUIRED屬性執行，它只對DataSourceTransactionManager事物管理器有效 |
因此我們可以來簡單分析一下上面的insertTeacherAndStudent方法：
- 由於沒有指定propagation屬性，因此事物傳播特性為預設的REQUIRED
- StudentDao的insertStudent方法先執行，此時沒有事物，因此新建一個事物
- TeacherDao的insertTeacher方法接著執行，此時由於StudentDao的insertStudent方法已經開啟了一個事物，insertTeacher方法加入到這個事物中
- StudentDao的insertStudent方法和TeacherDao的insertTeacher方法組成了一個事物，兩個方法要麼同時執行成功，要麼同時執行失敗
（2）@Transactional(isolation = Isolation.DEFAULT)
事物隔離級別，這個不細說了，可以參看事物及事物隔離級別一文。
（3）@Transactional(readOnly = true)
該事物是否為一個只讀事物，配置這個屬性可以提高方法執行效率。
（4）@Transactional(rollbackFor = {ArrayIndexOutOfBoundsException.class, NullPointerException.class})
遇到方法丟擲ArrayIndexOutOfBoundsException、NullPointerException兩種異常會回滾資料，僅支援RuntimeException的子類。
（5）@Transactional(noRollbackFor = {ArrayIndexOutOfBoundsException.class, NullPointerException.class})
這個和上面的相反，遇到ArrayIndexOutOfBoundsException、NullPointerException兩種異常不會回滾資料，同樣也是僅支援RuntimeException的子類。對（4）、（5）不是很理解的朋友，我給一個例子：
@Transactional(rollbackForClassName = {"NullPointerException"})
public void insertTeacherAndStudent(Teacher teacher, Student student)
{
studentDao.insertStudent(student);
teacherDao.insertTeacher(teacher);
String s = null;
s.length();
}
構造Student、Teacher的資料執行一下，然後檢視下庫裡面有沒有對應的記錄就好了，然後再把rollbackForClassName改為noRollbackForClassName，對比觀察一下。
（6）@Transactional(rollbackForClassName = {"NullPointerException"})、@Transactional(noRollbackForClassName = {"NullPointerException"})
這兩個放在一起說了，和上面的（4）、（5）差不多，無非是（4）、（5）是通過.class來指定要回滾和不要回滾的異常，這裡是通過字串形式的名字來制定要回滾和不要回滾的異常。
（7）@Transactional(timeout = 30)
事物超時時間，單位為秒。
（8）@Transactional(value = "tran_1")
value這個屬性主要就是給某個事物一個名字而已，這樣在別的地方就可以使用這個事物的配置。