Mybatis一对多、多对一、批量插入

在项目开发中，我们有遇到的对象关系通常是复杂的，每个对象并不是单独的。比如学生和老师之间关系，一个老师有多个学生，每个学生会对应一个老师（这里的老师主要是班主任），这种关系其实就是一对多的关系。Mybatis在处理这种关系的时候，也是有自己的办法的。接下来就讲述一下在Mybatis中处理一对多关系的映射。

1、先捋清楚学生和老师的ER模型以及数据库表

数据库表中主要是在学生端的表中有一个外键引用老师的id，所以两张表结构如下：

[sql] view plain copy

print ?

1. -- ----------------------------  
2. -- Table structure for teacher  
3. -- ----------------------------  
4. DROP TABLE IF EXISTS `teacher`;  
5. CREATE TABLE `teacher` (  
6.   `id` bigint(20) NOT NULL AUTO_INCREMENT,  
7.   `name` varchar(100) DEFAULT NULL,  
8.   `course` varchar(100) DEFAULT NULL,  
9.   PRIMARY KEY (`id`)  
10. ) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;  
11. -- ----------------------------  
12. -- Table structure for student  
13. -- ----------------------------  
14. DROP TABLE IF EXISTS `student`;  
15. CREATE TABLE `student` (  
16.   `id` bigint(20) NOT NULL AUTO_INCREMENT,  
17.   `name` varchar(100) DEFAULT NULL,  
18.   `sex` tinyint(1) DEFAULT NULL,  
19.   `teacherId` bigint(20) DEFAULT NULL, --这个字段表示学生对应的老师  
20.   PRIMARY KEY (`id`)  
21. ) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8;  

-- ----------------------------
-- Table structure for teacher
-- ----------------------------
DROP TABLE IF EXISTS `teacher`;
CREATE TABLE `teacher` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(100) DEFAULT NULL,
  `course` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for student
-- ----------------------------
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(100) DEFAULT NULL,
  `sex` tinyint(1) DEFAULT NULL,
  `teacherId` bigint(20) DEFAULT NULL, --这个字段表示学生对应的老师
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8;

2、创建对应的实体java对象

[java] view plain copy

print ?

1. //Teacher.java，老师是一方  
2. public class Teacher {  
3.  private Long id;//主键  
4.  private String name;  
5.  private String course;  
6.  private List<Student> students;//老师端定义一个学生列表集合  
7. //setter，getter  
8. }  
9. //Student.java，学生是多方  
10. public class Student {  
11.  private Long id;  
12.  private String name;  
13.  private Boolean sex;  
14.  private Long teacherId;// 学生对应的老师的id  
15.  private Teacher teacher;//学生端定义一个所属老师的对象  
16. //setter，getter  
17. }  

//Teacher.java，老师是一方
public class Teacher {
 private Long id;//主键
 private String name;
 private String course;
 private List<Student> students;//老师端定义一个学生列表集合
//setter，getter
}
//Student.java，学生是多方
public class Student {
 private Long id;
 private String name;
 private Boolean sex;
 private Long teacherId;// 学生对应的老师的id
 private Teacher teacher;//学生端定义一个所属老师的对象
//setter，getter
}

3、为每个对象配置映射文件

Teacher.xml

[html] view plain copy

print ?

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE mapper  
3.     PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
4.     "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
5.   
6. <mapper namespace="com.gusi.demo.idao.ITeacher">  
7.   
8. <!--该结果集映射只映射老师的基本属性，没有映射老师所对应的学生集合 -->  
9. <resultMap type="TeacherAlias" id="TeacherResult">  
10. <id column="id" jdbcType="BIGINT" property="id" />  
11. <result column="name" jdbcType="VARCHAR" property="name" />  
12. <result column="course" jdbcType="VARCHAR" property="course" />  
13. </resultMap>  
14.   
15. <!--该结果集映射了老师的基本信息以及老师所有学生的信息 -->  
16. <resultMap type="TeacherAlias" id="TeacherWithShtudentResult">  
17. <id column="id" jdbcType="BIGINT" property="id" />  
18. <result column="name" jdbcType="VARCHAR" property="name" />  
19. <result column="course" jdbcType="VARCHAR" property="course" />  
20. <!--一对多关系的时候，一方使用collection标签映射多方，属性就是Teacher对象中的集合属性名称。因为是集合类型，所以不能再直接使用column属性，需要使用另一个映射对象结果集合，该结果集合也是通过namespace.id指定。当然也可以不引用其他结果集合，在标签内部可以自己在定义临时的resultMap标签对象，比如id,result标签 -->  
21. <collection property="students"  
22. resultMap="com.gusi.demo.idao.IStudent.StudentResult"></collection>  
23. </resultMap>  
24.   
25. <!--查询老师，但是不涉及到老师的所有学生 -->  
26. <select id="queryOneTeacher" parameterType="long" resultMap="TeacherResult">  
27. SELECT a.id,a.name,a.course  
28. FROM teacher a  
29. WHERE a.id = #{id:BIGINT}  
30. </select>  
31.   
32. <!--这里查询结果中就包含老师所有的学生集合，使用到了多表连接查询 -->  
33. <select id="queryOneTeacherWithStudent" parameterType="long"  
34. <!-- 对于相同的属性名称s.id和t.id以及s.name和t.name，一定要注意起别名，不然会冲突 -->  
35. resultMap="TeacherWithShtudentResult">  
36. SELECT a.id,a.name,a.course,b.id sid,b.name  
37. sname,b.sex,b.teacherId  
38. FROM teacher a left join student b on  
39. a.id=b.teacherId  
40. WHERE a.id = #{id:BIGINT}  
41. </select>  
42.   
43. <!-- userGeneratedKeys和keyProperty属性可以让插入后对象获得本身自己的id -->  
44. <insert id="insertOneTeacher" parameterType="TeacherAlias"  
45. useGeneratedKeys="true" keyProperty="id">  
46. insert into teacher  
47. (name,course)  
48. values(#{name},#{course})  
49. </insert>  
50.   
51. </mapper>  

<?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="com.gusi.demo.idao.ITeacher">

<!--该结果集映射只映射老师的基本属性，没有映射老师所对应的学生集合 -->
<resultMap type="TeacherAlias" id="TeacherResult">
<id column="id" jdbcType="BIGINT" property="id" />
<result column="name" jdbcType="VARCHAR" property="name" />
<result column="course" jdbcType="VARCHAR" property="course" />
</resultMap>

<!--该结果集映射了老师的基本信息以及老师所有学生的信息 -->
<resultMap type="TeacherAlias" id="TeacherWithShtudentResult">
<id column="id" jdbcType="BIGINT" property="id" />
<result column="name" jdbcType="VARCHAR" property="name" />
<result column="course" jdbcType="VARCHAR" property="course" />
<!--一对多关系的时候，一方使用collection标签映射多方，属性就是Teacher对象中的集合属性名称。因为是集合类型，所以不能再直接使用column属性，需要使用另一个映射对象结果集合，该结果集合也是通过namespace.id指定。当然也可以不引用其他结果集合，在标签内部可以自己在定义临时的resultMap标签对象，比如id,result标签 -->
<collection property="students"
resultMap="com.gusi.demo.idao.IStudent.StudentResult"></collection>
</resultMap>

<!--查询老师，但是不涉及到老师的所有学生 -->
<select id="queryOneTeacher" parameterType="long" resultMap="TeacherResult">
SELECT a.id,a.name,a.course
FROM teacher a
WHERE a.id = #{id:BIGINT}
</select>

<!--这里查询结果中就包含老师所有的学生集合，使用到了多表连接查询 -->
<select id="queryOneTeacherWithStudent" parameterType="long"
<!-- 对于相同的属性名称s.id和t.id以及s.name和t.name，一定要注意起别名，不然会冲突 -->
resultMap="TeacherWithShtudentResult">
SELECT a.id,a.name,a.course,b.id sid,b.name
sname,b.sex,b.teacherId
FROM teacher a left join student b on
a.id=b.teacherId
WHERE a.id = #{id:BIGINT}
</select>

<!-- userGeneratedKeys和keyProperty属性可以让插入后对象获得本身自己的id -->
<insert id="insertOneTeacher" parameterType="TeacherAlias"
useGeneratedKeys="true" keyProperty="id">
insert into teacher
(name,course)
values(#{name},#{course})
</insert>

</mapper>

Student.xml

[html] view plain copy

print ?

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE mapper  
3.     PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
4.     "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
5.   
6. <mapper namespace="com.gusi.demo.idao.IStudent">  
7. <!-- 学生结果集合映射， -->  
8. <resultMap type="StudentAlias" id="StudentResult">  
9. <id column="sid" jdbcType="BIGINT" property="id" />  
10. <result column="sname" jdbcType="VARCHAR" property="name" />  
11. <result column="sex" jdbcType="TINYINT" property="sex" />  
12. <result column="teacherId" jdbcType="BIGINT" property="teacherId" />  
13. <!-- 多对一关系的时候，多方使用association标签映射一方，属性就是Student对象中定义的Teacher属性的名称。因为是对象类型，所以不能再直接使用column属性，需要使用另一个映射对象结果集合，该结果集合也是通过namespace.id指定。当然也可以不引用其他结果集合，在标签内部可以自己在定义临时的resultMap标签对象,比如id标签，result标签 -->  
14. <association property="teacher"  
15. resultMap="com.gusi.demo.idao.ITeacher.TeacherResult"></association>  
16. </resultMap>  
17.   
18. <!-- 查询学生基本信息，并且返回包含老师对象的信息 -->  
19. <select id="queryOneStudent" parameterType="long" resultMap="StudentResult">  
20. <!--在连接表查询的时候， 一定要注意这里的别名，不然会冲突 -->  
21. SELECT a.id sid,a.name sname,a.sex,a.teacherId,b.id,b.name,b.course  
22. FROM student a join teacher b on a.teacherId = b.id  
23. WHERE a.id =  
24. #{id:BIGINT}  
25. </select>  
26.   
27. <insert id="insertOneStudent" parameterType="com.gusi.demo.pojo.Student">  
28. Insert into student  
29. (name,sex,teacherId) values(#{name},#{sex},#{teacherId})  
30. </insert>  
31.   
32. <!-- 批量新增的时候，注意接收的对象是一个列表，需要在动态拼接sql的时候遍历参数集合对象 -->  
33. <insert id="insertBatchStudent" parameterType="java.util.List">  
34. Insert into student (name,sex,teacherId) values  
35. <!-- 注意foreach的语法,集合直接写list字符串，用item表示当前遍历的对象，结果集合通过使用逗号分隔使用separator属性 -->  
36. <foreach collection="list" item="item" separator=",">  
37. (#{item.name},#{item.sex},#{item.teacherId})  
38. </foreach>  
39. </insert>  
40.   
41. </mapper>  

<?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="com.gusi.demo.idao.IStudent">
<!-- 学生结果集合映射， -->
<resultMap type="StudentAlias" id="StudentResult">
<id column="sid" jdbcType="BIGINT" property="id" />
<result column="sname" jdbcType="VARCHAR" property="name" />
<result column="sex" jdbcType="TINYINT" property="sex" />
<result column="teacherId" jdbcType="BIGINT" property="teacherId" />
<!-- 多对一关系的时候，多方使用association标签映射一方，属性就是Student对象中定义的Teacher属性的名称。因为是对象类型，所以不能再直接使用column属性，需要使用另一个映射对象结果集合，该结果集合也是通过namespace.id指定。当然也可以不引用其他结果集合，在标签内部可以自己在定义临时的resultMap标签对象,比如id标签，result标签 -->
<association property="teacher"
resultMap="com.gusi.demo.idao.ITeacher.TeacherResult"></association>
</resultMap>

<!-- 查询学生基本信息，并且返回包含老师对象的信息 -->
<select id="queryOneStudent" parameterType="long" resultMap="StudentResult">
<!--在连接表查询的时候， 一定要注意这里的别名，不然会冲突 -->
SELECT a.id sid,a.name sname,a.sex,a.teacherId,b.id,b.name,b.course
FROM student a join teacher b on a.teacherId = b.id
WHERE a.id =
#{id:BIGINT}
</select>

<insert id="insertOneStudent" parameterType="com.gusi.demo.pojo.Student">
Insert into student
(name,sex,teacherId) values(#{name},#{sex},#{teacherId})
</insert>

<!-- 批量新增的时候，注意接收的对象是一个列表，需要在动态拼接sql的时候遍历参数集合对象 -->
<insert id="insertBatchStudent" parameterType="java.util.List">
Insert into student (name,sex,teacherId) values
<!-- 注意foreach的语法,集合直接写list字符串，用item表示当前遍历的对象，结果集合通过使用逗号分隔使用separator属性 -->
<foreach collection="list" item="item" separator=",">
(#{item.name},#{item.sex},#{item.teacherId})
</foreach>
</insert>

</mapper>

先只关注上面的select语句，insert语句是之后为了说明批量插入而写的。暂时先不需要关注insert语句

4、Mybatis全局配置文件中配置 数据库连接信息以及引入映射文件

[html] view plain copy

print ?

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE configuration  
3.     PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
4.     "http://mybatis.org/dtd/mybatis-3-config.dtd">  
5.   
6. <configuration>  
7. <typeAliases>  
8. <typeAlias alias="StudentAlias" type="com.gusi.demo.pojo.Student" />  
9. <typeAlias alias="TeacherAlias" type="com.gusi.demo.pojo.Teacher" />  
10. </typeAliases>  
11.   
12. <environments default="development">  
13. <environment id="development">  
14. <transactionManager type="JDBC">  
15. <property name="" value="" />  
16. </transactionManager>  
17. <dataSource type="UNPOOLED">  
18. <property name="driver" value="com.mysql.jdbc.Driver" />  
19. <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis" />  
20. <property name="username" value="root" />  
21. <property name="password" value="root" />  
22. </dataSource>  
23. </environment>  
24. </environments>  
25.   
26. <mappers>  
27. <mapper resource="com/gusi/demo/pojo/Student.xml" />  
28. <mapper resource="com/gusi/demo/pojo/Teacher.xml" />  
29. </mappers>  
30.   
31. </configuration>  

<?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="StudentAlias" type="com.gusi.demo.pojo.Student" />
<typeAlias alias="TeacherAlias" type="com.gusi.demo.pojo.Teacher" />
</typeAliases>

<environments default="development">
<environment id="development">
<transactionManager type="JDBC">
<property name="" value="" />
</transactionManager>
<dataSource type="UNPOOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis" />
<property name="username" value="root" />
<property name="password" value="root" />
</dataSource>
</environment>
</environments>

<mappers>
<mapper resource="com/gusi/demo/pojo/Student.xml" />
<mapper resource="com/gusi/demo/pojo/Teacher.xml" />
</mappers>

</configuration>

5、写接口查询

完成上面的配置以后，基本也就完成了一对多和多对一的所有配置，现在就是通过接口查询看是否符合我们预期。

[java] view plain copy

print ?

1. //通过Id查询学生，会包含老师的对象信息  
2. public Student queryOneStudent(Long id) {  
3.  Student student = null;  
4.  try {  
5.   sqlSession = mybatisUtils.getSqlSession();  
6.   IStudent iStudent = sqlSession.getMapper(IStudent.class);  
7. //面向接口编程，调运queryOneStudent语句  
8.   student = iStudent.queryOneStudent(id);  
9.  } catch (IOException e) {  
10.   e.printStackTrace();  
11.  } finally {  
12.   if (sqlSession != null) {  
13.    sqlSession.close();  
14.   }  
15.  }  
16.  return student;  
17. }  
18. //通过Id查询老师，不会包含老师的所有学生集合信息，只有老师的个人基本信息  
19. public Teacher queryOneTeacher(Long id) {  
20.  Teacher teacher = null;  
21.  try {  
22.   sqlSession = mybatisUtils.getSqlSession();  
23.   ITeacher iTeacher = sqlSession.getMapper(ITeacher.class);  
24. //面向接口编程，调运queryOneTeacher语句  
25.   teacher = iTeacher.queryOneTeacher(id);  
26.  } catch (IOException e) {  
27.   e.printStackTrace();  
28.  } finally {  
29.   sqlSession.close();  
30.  }  
31.  return teacher;  
32. }  
33. //通过Id查询老师，会包含老师的所有学生集合信息  
34. public Teacher queryOneTeacherWithStudent(Long id) {  
35.  Teacher teacher = null;  
36.  try {  
37.   sqlSession = mybatisUtils.getSqlSession();  
38.   ITeacher iTeacher = sqlSession.getMapper(ITeacher.class);  
39. //面向接口编程，调运queryOneTeacherWithStudent语句  
40.   teacher = iTeacher.queryOneTeacherWithStudent(id);  
41.  } catch (IOException e) {  
42.   e.printStackTrace();  
43.  } finally {  
44.   sqlSession.close();  
45.  }  
46.  return teacher;  
47. }  

//通过Id查询学生，会包含老师的对象信息
public Student queryOneStudent(Long id) {
 Student student = null;
 try {
  sqlSession = mybatisUtils.getSqlSession();
  IStudent iStudent = sqlSession.getMapper(IStudent.class);
//面向接口编程，调运queryOneStudent语句
  student = iStudent.queryOneStudent(id);
 } catch (IOException e) {
  e.printStackTrace();
 } finally {
  if (sqlSession != null) {
   sqlSession.close();
  }
 }
 return student;
}
//通过Id查询老师，不会包含老师的所有学生集合信息，只有老师的个人基本信息
public Teacher queryOneTeacher(Long id) {
 Teacher teacher = null;
 try {
  sqlSession = mybatisUtils.getSqlSession();
  ITeacher iTeacher = sqlSession.getMapper(ITeacher.class);
//面向接口编程，调运queryOneTeacher语句
  teacher = iTeacher.queryOneTeacher(id);
 } catch (IOException e) {
  e.printStackTrace();
 } finally {
  sqlSession.close();
 }
 return teacher;
}
//通过Id查询老师，会包含老师的所有学生集合信息
public Teacher queryOneTeacherWithStudent(Long id) {
 Teacher teacher = null;
 try {
  sqlSession = mybatisUtils.getSqlSession();
  ITeacher iTeacher = sqlSession.getMapper(ITeacher.class);
//面向接口编程，调运queryOneTeacherWithStudent语句
  teacher = iTeacher.queryOneTeacherWithStudent(id);
 } catch (IOException e) {
  e.printStackTrace();
 } finally {
  sqlSession.close();
 }
 return teacher;
}

6、测试查询

在测试之前，需要先向数据库中插入合适的数据，假设我的初始化数据如下：

[sql] view plain copy

print ?

1. INSERT INTO `mybatis`.`teacher` (`id`, `name`, `course`) VALUES ('1', 'ltt', 'english');   
2. INSERT INTO `mybatis`.`teacher` (`id`, `name`, `course`) VALUES ('2', 'dyy', 'computer');  
3. INSERT INTO `mybatis`.`student` (`id`, `name`, `sex`, `teacherId`) VALUES ('1', 'a', '0', '1');  
4. INSERT INTO `mybatis`.`student` (`id`, `name`, `sex`, `teacherId`) VALUES ('2', 'b', '1', '2');  
5. INSERT INTO `mybatis`.`student` (`id`, `name`, `sex`, `teacherId`) VALUES ('3', 'c', '1', '2');  
6. INSERT INTO `mybatis`.`student` (`id`, `name`, `sex`, `teacherId`) VALUES ('4', 'd', '1', '1');  

INSERT INTO `mybatis`.`teacher` (`id`, `name`, `course`) VALUES ('1', 'ltt', 'english'); 
INSERT INTO `mybatis`.`teacher` (`id`, `name`, `course`) VALUES ('2', 'dyy', 'computer');
INSERT INTO `mybatis`.`student` (`id`, `name`, `sex`, `teacherId`) VALUES ('1', 'a', '0', '1');
INSERT INTO `mybatis`.`student` (`id`, `name`, `sex`, `teacherId`) VALUES ('2', 'b', '1', '2');
INSERT INTO `mybatis`.`student` (`id`, `name`, `sex`, `teacherId`) VALUES ('3', 'c', '1', '2');
INSERT INTO `mybatis`.`student` (`id`, `name`, `sex`, `teacherId`) VALUES ('4', 'd', '1', '1');

[java] view plain copy

print ?

1. @Test  
2. public void testQueryOneStudent() {  
3.  StudentDao dao = new StudentDao();  
4.  Student student = dao.queryOneStudent(1L);  
5.  System.out.println(student);  
6. }  
7. @Test  
8. public void testQueryOneTeacher() {  
9.  TeacherDao dao = new TeacherDao();  
10.  Teacher teacher = dao.queryOneTeacher(1L);  
11.  System.out.println(teacher);  
12. }  
13. @Test   
14. public void testQueryTeacherWithStudent() {  
15.  TeacherDao dao = new TeacherDao();  
16.  Teacher teacher = dao.queryOneTeacherWithStudent(1L);  
17.  System.out.println(teacher);  
18. }  

@Test
public void testQueryOneStudent() {
 StudentDao dao = new StudentDao();
 Student student = dao.queryOneStudent(1L);
 System.out.println(student);
}
@Test
public void testQueryOneTeacher() {
 TeacherDao dao = new TeacherDao();
 Teacher teacher = dao.queryOneTeacher(1L);
 System.out.println(teacher);
}
@Test 
public void testQueryTeacherWithStudent() {
 TeacherDao dao = new TeacherDao();
 Teacher teacher = dao.queryOneTeacherWithStudent(1L);
 System.out.println(teacher);
}

完成上面的查询操作以后，我们还有需求是添加老师的时候，同事批量添加老师所有的学生，简单除暴的放方法当然是先把老师信息添加到teacher表中，然后再遍历老师的所有的学生，同事查询刚刚老师的id然后循环调运添加学生的方法，一个一个的添加学生对象。但是这样肯定是不优雅的，效率方面会有很大的影响，所以我们可以使用sql批量添加的语法来用一句sql批量添加所有学生。

7、批量添加

[java] view plain copy

print ?

1. //添加老师，  
2. public int insertOneTeacher(Teacher teacher) {  
3.  int count = 0;  
4.  try {  
5.   sqlSession = mybatisUtils.getSqlSession();  
6.   ITeacher iTeacher = sqlSession.getMapper(ITeacher.class);  
7.   count = iTeacher.insertOneTeacher(teacher);  
8.   sqlSession.commit();  
9.  } catch (IOException e) {  
10.   e.printStackTrace();  
11.  } catch (Exception e) {  
12.   e.printStackTrace();  
13.  } finally {  
14.   sqlSession.close();  
15.  }  
16.  return count;  
17. }  
18. //批量添加学生  
19. public void insertBatchStudent(List<Student> students) {  
20.  try {  
21.   sqlSession = mybatisUtils.getSqlSession();  
22.   IStudent iStudent = sqlSession.getMapper(IStudent.class);  
23.   iStudent.insertBatchStudent(students);  
24.   sqlSession.commit();  
25.  } catch (IOException e) {  
26.   e.printStackTrace();  
27.  } finally {  
28.   if (sqlSession != null) {  
29.    sqlSession.close();  
30.   }  
31.  }  
32. }  

//添加老师，
public int insertOneTeacher(Teacher teacher) {
 int count = 0;
 try {
  sqlSession = mybatisUtils.getSqlSession();
  ITeacher iTeacher = sqlSession.getMapper(ITeacher.class);
  count = iTeacher.insertOneTeacher(teacher);
  sqlSession.commit();
 } catch (IOException e) {
  e.printStackTrace();
 } catch (Exception e) {
  e.printStackTrace();
 } finally {
  sqlSession.close();
 }
 return count;
}
//批量添加学生
public void insertBatchStudent(List<Student> students) {
 try {
  sqlSession = mybatisUtils.getSqlSession();
  IStudent iStudent = sqlSession.getMapper(IStudent.class);
  iStudent.insertBatchStudent(students);
  sqlSession.commit();
 } catch (IOException e) {
  e.printStackTrace();
 } finally {
  if (sqlSession != null) {
   sqlSession.close();
  }
 }
}

8、测试批量插入

[java] view plain copy

print ?

1. @Test   
2. public void testInsertTeacherWithStudent() {  
3.  TeacherDao daoT = new TeacherDao();  
4.  StudentDao daoS = new StudentDao();  
5.  Teacher t = new Teacher();  
6.  t.setName("teacher1");  
7.  t.setCourse("ep");  
8.  daoT.insertOneTeacher(t);  
9. //注意在Teacher.xml映射文件中的insertOneTeacher语句中加入两属性userGeneratedKeys和keyProperty，目的是让在添加对象后，自动将新加对象的Id给设置到上面的t（Teacher）对象中，方便在添加下面的Student对象的时候设置teacherId属性的值  
10.  Student s1 = new Student();  
11.  s1.setName("s1");  
12.  s1.setSex(false);  
13.  s1.setTeacherId(t.getId());  
14.  Student s2 = new Student();  
15.  s2.setName("s2");  
16.  s2.setSex(false);  
17.  s2.setTeacherId(t.getId());  
18.  daoS.insertBatchStudent(Arrays.asList(s1, s2));  
19. //注意在批量添加Student对象的时候，出入的参数是集合类型的Student，同时Student对象已经把teacherId属性给赋值。  
20. }  

@Test 
public void testInsertTeacherWithStudent() {
 TeacherDao daoT = new TeacherDao();
 StudentDao daoS = new StudentDao();
 Teacher t = new Teacher();
 t.setName("teacher1");
 t.setCourse("ep");
 daoT.insertOneTeacher(t);
//注意在Teacher.xml映射文件中的insertOneTeacher语句中加入两属性userGeneratedKeys和keyProperty，目的是让在添加对象后，自动将新加对象的Id给设置到上面的t（Teacher）对象中，方便在添加下面的Student对象的时候设置teacherId属性的值
 Student s1 = new Student();
 s1.setName("s1");
 s1.setSex(false);
 s1.setTeacherId(t.getId());
 Student s2 = new Student();
 s2.setName("s2");
 s2.setSex(false);
 s2.setTeacherId(t.getId());
 daoS.insertBatchStudent(Arrays.asList(s1, s2));
//注意在批量添加Student对象的时候，出入的参数是集合类型的Student，同时Student对象已经把teacherId属性给赋值。
}

项目源码： https://github.com/yoting/demoMybatis