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

一、用到的实体类如下：

Student.java

[html] view plaincopy

  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

[java] view plaincopy

  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

[html] view plaincopy

  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

[html] view plaincopy

  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

[java] view plaincopy

  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如下：

[java] view plaincopy

  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代码如下：

[java] view plaincopy

  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如下 ：

[java] view plaincopy

  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

时间： 2024-10-05 17:25:21

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

Mybatis实现单表增删改查操作

mybatis是对持久层进行了封装.mybatis文档地址:https://mybatis.org/mybatis-3/zh/index.html 下面实现单表的增删改查操作. 1.新建maven项目命名为mybatis.并在pom.xml中引入相关依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"

Asp.net Core 2.1使用 EF Core 简单增删改查操作数据库

Asp.net Core 2.1使用 EF Core 简单增删改查操作数据库 大概步骤如下5步: 1.创建项目(Asp.net Core 2.1项目) 2.项目使用EF Core 3.建立实体 4.生成迁移文件(生成数据库) 5.使用VS工具生成视图.控制器代码 示例代码下载  https://github.com/ZhMartincheng/NetCoreDemo.git 1.创建项目(Asp.net Core 2.1项目) 选择.net core 版本2.1 基础项目创建成功 2.项目使用E

idea+spring4+springmvc+mybatis+maven实现简单增删改查CRUD

在学习spring4+springmvc+mybatis的ssm框架,idea整合简单实现增删改查功能,在这里记录一下. 原文在这里:https://my.oschina.net/finchxu/blog/3007984 工作环境: Windows 10 jdk8(1.8) IntelliJ IDEA spring 4 和 springMVC MySQL 5.7 maven 3.3 mybatis 3.4 DBCP Tomcat 8.5 项目上传到了Github方便查看:https://gith

mybatis学习之普通增删改查

mybatis下载地址:https://github.com/mybatis/mybatis-3/releases 选择你要下载的版本,这里我下载的3.4.2版 项目结构: 将mybatis中的所有jar包导入还要导入链接mysql数据库的jar包. 其中db.properties,mybatis-config.xml,log4j.properties是在src下. 在mysql中新建mybatis数据库,在数据库中新建表t_customer,表结构如下: 随后向其中随便插入几条数据. Cust

elasticsearch的简单增删改查操作

1.首先弄明白四个概念 elasticsearch 关系型数据库 index 数据库 type 表 document 行 field 字段 如果刚一开始理解比较困难,那你就在心中默念100遍,10遍也可以... 如果你做过面向对象开发,我觉得elasticsearch的这四个概念还是很好理解的. 需要重点说明的是document就是一个json格式的字符串,里面包括N个字段.我们可以想象将面向对象语言里面的一个对象序列化成json字符串. 关系型数据库需要先建库,再建表.elasticsearc

MyBatis对数据库的增删改查操作，简单示例

之前一直实用Hibernate进行开发,最近公司在使用Mybatis,根据网上的示例,做了一个简单的Demo,以便日后复习 总体结构如下图 首先是创建一个工程,然后导入两个jar包,然后编写mybatis的jdbc配置文件Configuration.xml Configuration.xml <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-/

mybatis学习之二 增删改查

1.配置映射文件grilsMapper.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="mappe

MyBatis之二：简单增删改查

这一篇在上一篇的基础上简单讲解如何进行增删改查操作. 一.在mybatis的配置文件conf.xml中注册xml与注解映射 <!-- 注册映射文件 --> <mappers> <!-- 通过xml方式映射 --> <mapper resource="com/mybatis/crud/userMapper.xml" /> <!-- 通过注解方式映射 --> <mapper class="com.mybatis.c

Mybatis实现简单的数据库增删改查操作

Mybatis实现简单的数据库增删改查操作 框架:mybatis(3.5.2) 数据库:mysql 工具:idea 1.新建一个maven项目,在pom文件中添加mybatis依赖及MySQL依赖 <!-- mybatis核心依赖 --> <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --> <dependency> <groupId>org.mybatis</groupId&g