MyBatis学习之简单增删改查操作、MyBatis存储过程、MyBatis分页、MyBatis一对一、MyBatis一对多

一、用到的实体类如下：

Student.java

1. package com.company.entity;
2. import java.io.Serializable;
3. import java.util.Date;
4. public class Student implements Serializable{
5. private static final long serialVersionUID = 1L;
6. private int id;
7. private String name;
8. private Date birth;
9. private Group group;
10. public Group getGroup() {
11. return group;
12. }
13. public void setGroup(Group group) {
14. this.group = group;
15. }
16. public int getId() {
17. return id;
18. }
19. public void setId(int id) {
20. this.id = id;
21. }
22. public String getName() {
23. return name;
24. }
25. public void setName(String name) {
26. this.name = name;
27. }
28. public Date getBirth() {
29. return birth;
30. }
31. public void setBirth(Date birth) {
32. this.birth = birth;
33. }
34. @Override
35. public String toString() {
36. return "Student [birth=" + birth + ", group=" + group + ", id=" + id
37. + ", name=" + name + "]";
38. }
39. }

Group.java

1. package com.company.entity;
2. import java.util.List;
3. public class Group {
4. private int id;
5. private String name;
6. private String position;
7. private List<Student> students;
8. public List<Student> getStudents() {
9. return students;
10. }
11. public void setStudents(List<Student> students) {
12. this.students = students;
13. }
14. public int getId() {
15. return id;
16. }
17. public void setId(int id) {
18. this.id = id;
19. }
20. public String getName() {
21. return name;
22. }
23. public void setName(String name) {
24. this.name = name;
25. }
26. public String getPosition() {
27. return position;
28. }
29. public void setPosition(String position) {
30. this.position = position;
31. }
32. @Override
33. public String toString() {
34. return "Group [id=" + id + ", name=" + name + ", position=" + position
35. + "]";
36. }
37. }

二、实体对应的表结构

student表:

create table student(

id  int primary key,

name varchar2(20),

birth date,

group_id int references g_group(g_id));

g_group表:

create  table g_group(

g_id int primary key,

g_name varchar2(20),

g_position varchar2(30));

sequence:

create sequence student_id_sequence;

create sequence group_id_sequence;

三、Student和Group的映射文件如下，你可以在映射文件中找到，关于MyBatis的增删改查操作，MyBatis调用存储过程，MyBatis分页以及MyBatis对一对一、多对多的处理

xml文件中都标有注释，看的时候配合下面的具体实现看，虽然有点乱

student.xml

1. <?xml version="1.0" encoding="UTF-8" ?>
2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
3. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
4. <mapper namespace="com.company.dao.IStudentDAO">
5. <!-- mybatis缓存 -->
6. <cache eviction="LRU" flushInterval="600000" size="1024" readOnly="false" />
7. <!-- sql标签用来定义一些可以被重用的sql语句或字段或片段等 -->
8. <sql id="studentColumns">select id,name,birth from student</sql>
9. <!-- 此处获得多对一的关系 ,但就单条记录而言却是一对一的关系，所以一对一的写法跟此相同-->
10. <resultMap type="Student" id="getStudentAndGroup" >
11. <id column="id" property="id"/>
12. <result column="name" property="name"/>
13. <result column="birth" property="birth"/>
14. <association property="group" column="group_id" javaType="Group">
15. <id column="g_id" property="id"/>
16. <result column="g_name" property="name"/>
17. <result column="g_position" property="position"/>
18. </association>
19. </resultMap>
20. <select id="many2one" resultMap="getStudentAndGroup" parameterType="int" >
21. select s.id,s.name,s.birth,s.group_id,g.g_id,g.g_name,g.g_position
22. from student s
23. left join g_group g on s.group_id = g.g_id
24. where s.id = #{id}
25. </select>
26. <!-- 意图是获得一个学生，并且获得该学生所属的组，跟上面的意思差不多 ,用association的select属性-->
27. <!-- 于上面的相比个人感觉上面的效率要高些，因为上面只有一条sql语句 -->
28. <resultMap type="Student" id="getStudentAndGroupUseSelectMap">
29. <id column="id" property="id"/>
30. <result column="name" property="name"/>
31. <result column="birth" property="birth"/>
32. <association property="group" column="group_id" javaType="Group" select="selectGroup" />
33. </resultMap>
34. <select id="getStudentAndGroupUseSelect" resultMap="getStudentAndGroupUseSelectMap" parameterType="int">
35. select *
36. from student
37. where id = #{id}
38. </select>
39. <select id="selectGroup" resultType="Group" parameterType="int" flushCache="false" useCache="true"><!-- 此处实用缓存 -->
40. select g_id as id, g_name as name, g_position as position
41. from g_group
42. where g_id = #{id}
43. </select>
44. <!-- 动态sql语句 的测试dynamic sql-->
45. <select id="getStudentBySomeCondition" parameterType="Student" resultType="Student">
46. select *
47. from student
48. <where>
49. <if test="id != null">
50. id>2
51. </if>
52. <if test="name != null">
53. and name like '%g%'
54. </if>
55. </where>
56. </select>
57. <!-- MyBatis调用存储过程 -->
58. <resultMap type="Student" id="studentMap">
59. <id column="id" property="id"/>
60. <result column="name" property="name"/>
61. <result column="birth" property="birth"/>
62. </resultMap>
63. <select id="getAllUser" statementType="CALLABLE" >
64. {call get_all_student(#{students ,mode=OUT, jdbcType=CURSOR, javaType=ResultSet, resultMap=studentMap} )}
65. </select>
66. <!-- MyBatis向student表中插入一条数据 -->
67. <insert id="add" parameterType="Student" keyColumn="id">
68. <selectKey keyProperty="id" order="BEFORE" resultType="int">
69. select stu_id_sequence.nextval from dual
70. </selectKey>
71. insert into student(id,name,birth) values(#{id},#{name},#{birth})
72. </insert>
73. <!-- 根据id获得学生的信息 -->
74. <select id="getById" parameterType="int" resultType="Student">
75. <include refid="studentColumns"/> where id=#{id}
76. </select>
77. <!-- 此处的实现方法是一个分页的原型,请查看IStudentDAOImpl.java中的调用方法 -->
78. <select id="getAllStudent" resultMap="studentMap">
79. <include refid="studentColumns"/> order by id<!--此处是引用了上面预定义好的sql语句-->
80. </select>
81. </mapper>

group.xml

1. <?xml version="1.0" encoding="UTF-8" ?>
2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
3. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
4. <mapper namespace="com.company.dao.IGroupDAO">
5. <resultMap type="Group" id="groupResultMap" >
6. <id column="g_id" property="id"/>
7. <result column="g_name" property="name"/>
8. <result column="g_position" property="position"/>
9. </resultMap>
10. <sql id="getALl">select * from</sql>
11. <!-- 意图想通过获得组和组中的所有student,此处相当于one2many -->
12. <resultMap type="Group" id="getGroupAndStudents">
13. <id column="g_id" property="id"/>
14. <result column="g_name" property="name"/>
15. <result column="g_position" property="position"/>
16. <collection property="students" ofType="Student" column="group_id"><!-- 注意此处的group_id是student表的外键 -->
17. <id column="id" property="id"/>
18. <result column="name" property="name"/>
19. <result column="birth" property="birth"/>
20. </collection>
21. </resultMap>
22. <select id="getById" parameterType="int" resultMap="getGroupAndStudents">
23. select g.g_id,g.g_name,g.g_position,s.id,s.name,s.birth ,s.group_id
24. from g_group g
25. left join student s on g.g_id = s.group_id
26. where g.g_id = #{id}
27. </select>
28. <!--
29. <select id="getById" parameterType="int" resultType="Group">
30. select g_id as id, g_name as name, g_position as position from g_group where g_id=#{id}
31. </select>
32. -->
33. <select id="getByIdResultMap" parameterType="_int" resultMap="groupResultMap">
34. select g_id ,g_name, g_position  from g_group where g_id=#{id}
35. </select>
36. <delete id="deleteById" parameterType="_int" timeout="1000">
37. delete from g_group where g_id=#{id}
38. </delete>
39. <insert id="add" parameterType="Group">
40. insert into g_group(g_id, g_name, g_position)
41. values(#{id}, #{name}, #{position})
42. </insert>
43. </mapper>

四、接口IStudentDAO.java和IGroupDAO.java中定义了IStudentDAOImpl.java和IGroupDAOImpl.java中需要实现的方法

IStudentDAO.java

1. package com.company.dao;
2. import java.util.List;
3. import com.company.entity.Student;
4. public interface IStudentDAO {
5. /**
6. * 增加一个学生
7. * @param student
8. */
9. public void add(Student student);
10. /**
11. * 根据学生的Id删除学生
12. * @param id
13. */
14. public void deleteById(int id);
15. /**
16. * 通过学生的id获得学生的信息
17. * @param id
18. * @return
19. */
20. public Student getById(int id);
21. /**
22. * 更新学生信息
23. * @param student
24. */
25. public void update(Student student);
26. /**
27. * 此处是MyBatis的分页查询
28. * @return
29. */
30. public List<Student> getAllStudent();
31. /**
32. * 多对一
33. * @param id
34. * @return
35. */
36. public Student many2one(int id);
37. /**
38. * 获得学生的信息，并且获得该学生所属的组的信息
39. * @param id
40. * @return
41. */
42. public Student getStudentAndGroupUseSelect(int id);
43. /**
44. * 动态sql
45. * @param student
46. * @return
47. */
48. public List<Student> getStudentBySomeCondition(Student student);
49. /**
50. * 获得所有的学生信息，此处是调用在数据库中存储过程
51. * @return
52. */
53. public List<Student> getAllUser();
54. }

对应的实现类IStudentDAOImpl.java如下：

1. package com.company.dao.impl;
2. import java.util.ArrayList;
3. import java.util.HashMap;
4. import java.util.List;
5. import java.util.Map;
6. import org.apache.ibatis.session.RowBounds;
7. import org.apache.ibatis.session.SqlSession;
8. import org.apache.ibatis.session.SqlSessionFactory;
9. import com.company.dao.IStudentDAO;
10. import com.company.entity.Student;
11. import com.company.util.DBUtil;
12. public class IStudentDAOImpl implements IStudentDAO {
13. public void add(Student student) {
14. SqlSessionFactory sqlSessionFactory = DBUtil.getSqlSessionFactory();
15. SqlSession session = sqlSessionFactory.openSession();
16. try{
17. IStudentDAO dao = session.getMapper(IStudentDAO.class);
18. dao.add(student);
19. session.commit();
20. }catch(Exception e){
21. e.printStackTrace();
22. }finally{
23. session.close();
24. }
25. }
26. public void deleteById(int id) {
27. }
28. public Student getById(int id) {
29. SqlSessionFactory sqlSessionFactory = DBUtil.getSqlSessionFactory();
30. SqlSession session = sqlSessionFactory.openSession();
31. Student student = null;
32. try{
33. IStudentDAO dao = session.getMapper(IStudentDAO.class);
34. student = dao.getById(id);
35. }catch(Exception e){
36. e.printStackTrace();
37. }finally{
38. session.close();
39. }
40. return student;
41. }
42. public void update(Student student) {
43. }
44. public List<Student> getStudentsByGroupId(int groupId) {
45. return null;
46. }
47. /**
48. * 测试selectList，分页的原型
49. * @author king
50. * @return students
51. * @serialData 2011-7-29
52. */
53. public List<Student> getAllStudent() {
54. SqlSessionFactory sqlSessionFactory = DBUtil.getSqlSessionFactory();
55. SqlSession session = sqlSessionFactory.openSession();
56. List<Student> students = new ArrayList<Student>();
57. try{
58. RowBounds rb = new RowBounds(1,6);//RowBounds的下标是从0开始，表示第一条记录，此表示从第二条记录开始，取6条记录
59. students = session.selectList("com.company.dao.IStudentDAO.getAllStudent", null, rb);
60. }catch(Exception e){
61. e.printStackTrace();
62. }finally{
63. session.close();
64. }
65. return students;
66. }
67. public Student many2one(int id) {
68. SqlSessionFactory sqlSessionFactory = DBUtil.getSqlSessionFactory();
69. SqlSession session = sqlSessionFactory.openSession();
70. Student student = null;
71. try{
72. IStudentDAO dao = session.getMapper(IStudentDAO.class);
73. student = dao.many2one(id);
74. }catch(Exception e){
75. e.printStackTrace();
76. }finally{
77. session.close();
78. }
79. return student;
80. }
81. public Student getStudentAndGroupUseSelect(int id){
82. SqlSessionFactory sqlSessionFactory = DBUtil.getSqlSessionFactory();
83. SqlSession session = sqlSessionFactory.openSession();
84. Student student = null;
85. try{
86. IStudentDAO dao = session.getMapper(IStudentDAO.class);
87. student = dao.getStudentAndGroupUseSelect(id);
88. }catch(Exception e){
89. e.printStackTrace();
90. }finally{
91. session.close();
92. }
93. return student;
94. }
95. public List<Student> getStudentBySomeCondition(Student student){
96. SqlSessionFactory sqlSessionFactory = DBUtil.getSqlSessionFactory();
97. SqlSession session = sqlSessionFactory.openSession();
98. List<Student> students = new ArrayList<Student>();
99. try{
100. IStudentDAO dao = session.getMapper(IStudentDAO.class);
101. students = dao.getStudentBySomeCondition(student);
102. }catch(Exception e){
103. e.printStackTrace();
104. }finally{
105. session.close();
106. }
107. return students;
108. }
109. public List<Student> getAllUser(){
110. SqlSessionFactory sqlSessionFactory = DBUtil.getSqlSessionFactory();
111. SqlSession session = sqlSessionFactory.openSession();
112. List<Student> students = new ArrayList<Student>();
113. try{
114. Map<String,List<Student>> map = new HashMap<String,List<Student>>();
115. session.selectOne("com.company.dao.IStudentDAO.getAllUser", map);
116. students =  (List<Student>) map.get("students");
117. }catch(Exception e){
118. e.printStackTrace();
119. }finally{
120. session.close();
121. }
122. return students;
123. }
124. public static void main(String[] args) {
125. Student student = new Student();
126. IStudentDAOImpl impl = new IStudentDAOImpl();
127. List<Student> students = impl.getAllStudent();
128. for(Student s : students) {
129. System.out.println(s);
130. }
131. }
132. }

IGroupDAO.java代码如下：

1. package com.company.dao;
2. import com.company.entity.Group;
3. public interface IGroupDAO {
4. /**
5. * 增加一个组
6. * @param group
7. */
8. public void add(Group group);
9. /**
10. * 根据id删除组
11. * @param id
12. */
13. public void deleteById(int id);
14. /**
15. * 此方法是通过id获得一个组的信息，并且获得该组下面的所有的学生信息
16. * @param id
17. * @return
18. */
19. public Group getById(int id);
20. /**
21. * 此方法是测试如何设定ResultMap的方式来从数据库中获得Group
22. * @param id
23. * @return
24. */
25. public Group getByIdResultMap(int id);
26. public void update(Group group);
27. }

IGroupDAO.java对应的实现类IGroupDAOImpl.java如下 ：

1. package com.company.dao.impl;
2. import org.apache.ibatis.session.SqlSession;
3. import org.apache.ibatis.session.SqlSessionFactory;
4. import com.company.dao.IGroupDAO;
5. import com.company.entity.Group;
6. import com.company.entity.Student;
7. import com.company.util.DBUtil;
8. public class IGroupDAOImpl implements IGroupDAO{
9. public void add(Group group) {
10. SqlSession session = DBUtil.getSqlSessionFactory().openSession();
11. try{
12. IGroupDAO dao = session.getMapper(IGroupDAO.class);
13. dao.add(group);
14. session.commit();
15. }catch(Exception e){
16. e.printStackTrace();
17. }finally{
18. session.close();
19. }
20. }
21. public void deleteById(int id) {
22. SqlSession session = DBUtil.getSqlSessionFactory().openSession();
23. try{
24. IGroupDAO dao = session.getMapper(IGroupDAO.class);
25. dao.deleteById(id);
26. session.commit();
27. }catch(Exception e){
28. e.printStackTrace();
29. }finally{
30. session.close();
31. }
32. }
33. public Group getById(int id) {
34. SqlSessionFactory sqlSessionFactory = DBUtil.getSqlSessionFactory();
35. SqlSession session = sqlSessionFactory.openSession();
36. Group group = null;
37. try{
38. IGroupDAO dao = session.getMapper(IGroupDAO.class);
39. group = dao.getById(id);
40. }catch(Exception e){
41. e.printStackTrace();
42. }finally{
43. session.close();
44. }
45. return group;
46. }
47. public Group getByIdResultMap(int id) {
48. SqlSessionFactory sqlSessionFactory = DBUtil.getSqlSessionFactory();
49. SqlSession session = sqlSessionFactory.openSession();
50. Group group = null;
51. try{
52. IGroupDAO dao = session.getMapper(IGroupDAO.class);
53. group = dao.getByIdResultMap(id);
54. }catch(Exception e){
55. e.printStackTrace();
56. }finally{
57. session.close();
58. }
59. return group;
60. }
61. public void update(Group group) {
62. // TODO Auto-generated method stub
63. }
64. public static void main(String[] args) {
65. //System.out.println(new IGroupDAOImpl().getByIdResultMap(1));
66. /*Group group = new Group();
67. group.setId(3);
68. group.setName("南京农业2");
69. group.setPosition("南京信新街口2");
70. new IGroupDAOImpl().add(group);*/
71. Group group = new IGroupDAOImpl().getById(1);
72. for(Student s:group.getStudents()){
73. System.out.println(s.getId()+" , " + s.getName());
74. }
75. }
76. }

至此，对于一个初学者来说，需要了解的知识，上面的内容都有所概括，关键是灵活的应用。看的时候注意结合，如Student.xml       ，然后IStudentDAO.java， 最后看实现IStudentDAOImpl.java