【Java】基于【Mybatis】框架学习系列——Mybatis增删改查（CURD）

文章目录

前言
一、准备数据和实体类
二、创建映射与注册映射
- 1.创建映射
- 2.注册映射
三、增删改查操作（CURD）
总结

前言

在前面数据库连接成功和配置良好的情况下，今天使用Mybatis对数据库进行CURD操作。

一、准备数据和实体类

1.创建数据表

在连接的数据库下创建学生表，为其添加id，name，address字段信息，具体的我是在Navicat数据库可视化工具中进行字段数据的添加，当然也可以使用SQL语句进行操作。
在这里插入图片描述

2.创建实体类

在实体类包下创建实体类Student类，对学生类进行属性的封装，并提供访问的方法以及构建实体类构造器。这里的实例类属性要与数据库的字段保持一致。后面会有一个数据库字段带下划线的属性，使用别的别的方法解决，尽量保持字段名一致。

public class Student {
    private Integer id;
    private String name;
    private String address;

    public Student() {
    }

    public Student(Integer id, String name, String address) {
        this.id = id;
        this.name = name;
        this.address = address;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

3.创建工具类

这里创建自己的包装类，用于保证SqlSeesionFactory的全局唯一性，功能层次更加清晰，封装工具方法，分工明确。基本步骤为：创建全局唯一的SqlSessionFactory对象、创建SqlSession、使用SqlSession、关闭SqlSession。

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.InputStream;
public class MybatisUtil {
    //1、创建全局唯一的SqlSessionFactory对象
    private static SqlSessionFactory sqlSessionFactory=null;
    //使用静态代码块
    static{
        try {
            //加载配置文件
            String resource = "mybatis-config.xml";
            //转换成输入流
            InputStream inputStream = Resources.getResourceAsStream(resource);
            //拿到sqlSessionFactory
             sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        }catch (Exception e) {
            throw  new ExceptionInInitializerError(e);
        }
    }
    //创建SqlSession
    public static SqlSession createSqlSession(){
        return sqlSessionFactory.openSession();
    }
    //关闭SqlSession
    public static void closeSqlSession(SqlSession sqlSession){
        if (null!=sqlSession){
            sqlSession.close();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

4.对工具类进行测试

对工具类进行测试，这里与连接数据测试基本一样，可以直接仿照连接数据库的部分来写。

 @Test
    public void testUtil(){
        SqlSession sqlSession=null;
        try {
            sqlSession=MybatisUtil.createSqlSession();
            System.out.println(sqlSession.getConnection());
        }catch (Exception e){
            e.printStackTrace();
        }finally {
         MybatisUtil.closeSqlSession(sqlSession);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12

当运行测试后，在控制台得到下面的信息，表示工具类成功连接到数据库。保证后续对数据库内的数据进行操作。
在这里插入图片描述

二、创建映射与注册映射

1.创建映射

对实体类对象创建映射，为避免有多个实体类，影响项目结构，这里在resource包下专门创建一个映射的mappers包，然后在mappers包下创建不同实例对应的映射文件，后续所有的SQL操作都在映射文件中来编写。需要注意的是mapper的URL地址最后是mybatis-3-mapper.dtd这里与Mybatis的映射文件很像，注意细微区别是它以mapper.dtd结尾的。

<?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.dao.StudentDao">
</mapper>
1
2
3
4
5
6

2.注册映射

很多初学者在创建完映射文件后，就觉得可以直接去写SQL语句，对数据库中的数据进行操作了，其实这时候你去写CURD必然使IDEA报缺失mapeer的错误，相当于就是你没有把数据请求操作交给Mybatis来处理。所以应该在Mybatis.xml文件中进行映射文件注册。

<!--    注册映射文件-->
    <mappers>
        <mapper resource="mappers/StudentDao.xml"/>
    </mappers>
1
2
3
4

三、增删改查操作（CURD）

完成上面的所有准备工作后，就是万事具备，只欠代码了，下面就对数据库的数据进行具体操作了，特别需要注意查询操作，对单条数据的查询和多条数据的查询是有区别的。

1.单条数据的查询

在映射文件中，写查询的SQL语句，由于是进行单条数据的查询，所以这里id的名字可以随便给，都可以绑定到参数，但是一般还是做到见名知意。

    <select id="selectById" resultType="com.entity.Student">
        select * from Student where id = #{id}
    </select>
1
2
3

然后在测试类中写测试就可以了对数据进行查询，调用selectOne()方法，该方法第一个参数为String类型，来定位映射文件的路径。第二个参数为绑定的id参数。

 @Test
    public void testSelectById(){
        SqlSession sqlSession=null;
        try {
            sqlSession=MybatisUtil.createSqlSession();
            System.out.println(sqlSession.getConnection());
            Student student = sqlSession.selectOne("com.dao.StudentDao.selectById", 1);
            System.out.println(student);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            MybatisUtil.closeSqlSession(sqlSession);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行测试代码，在控制台得到的查询数据为下图，与数据库中的信息一致，说明查询单条数据操作完成。
在这里插入图片描述

2.多条数据的查询

在进行多条数据查询时，写查询的SQL一般的参数绑定会是一个范围，不像单条数据一样可以随便进行绑定，下面对数据库中id为min到max的数据进行查询。

    <select id="selectByRange" resultType="com.entity.Student">
        select * from Student where id between #{min} and #{max}
    </select>
1
2
3

接着创建StudentDao接口，由于是多条数据，所以返回的应该是一个集合，创建接口实方便其他的多数据的查询。@Param("min")和@Param("max")使用注解是为了与多数据匹配对应参数绑定。

  List<Student> selectByRange(@Param("min") Integer min, @Param("max") Integer max);
1

然后在测试类中写测试就可以了对数据进行查询，调用selectList()方法，创建Map集合对min和max进行绑定，这里与单条数据有本质上的区别。这里也可以使用JDK的动态代理模式，进行多数据查询。

 @Test
    public void testSelectByRange(){
        SqlSession sqlSession=null;
        try {
            sqlSession=MybatisUtil.createSqlSession();
            System.out.println(sqlSession.getConnection());
            HashMap<String, Object> params = new HashMap<>();
            params.put("min",1);
            params.put("max",2);
            List<Student> student = sqlSession.selectList("com.dao.StudentDao.selectByRange",params);
            for (Student student1 : student) {
                System.out.println(student1);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            MybatisUtil.closeSqlSession(sqlSession);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

运行测试代码，在控制台得到的查询数据为下图，与数据库中的信息一致，说明查询多条数据操作完成。
在这里插入图片描述

3.数据的增加

在映射文件中，写插入的SQL语句，与单数据查询大同小异。字段的属性值要与数据库保持一致 values(#{id},#{name},#{address})

 <insert id="insertStudent" parameterType="com.entity.Student">
        insert into student values(#{id},#{name},#{address})
    </insert>
1
2
3

然后在测试类中写测试就可以了对数据进行添加，调用insert()方法，在数据进行插入之后，一定要记得使用sqlSession.commit();对数据进行提交操作，不然控制台提示你插入了数据，但是数据进行了rollback回滚操作，数据库信息不会更新。如果出现异常我们应当在catch语块中利用sqlSession.rollback();进行事务的回滚操作，防止脏数据的产生。

 //新增测试
    @Test
    public void testInsertStudent(){
        SqlSession sqlSession=null;
        try {
            sqlSession=MybatisUtil.createSqlSession();
            Student student = new Student();
            student.setId(3);
            student.setName("阿水");
            student.setAddress("安徽阜阳");
            int insertNum = sqlSession.insert("com.dao.StudentDao.insertStudent", student);
            sqlSession.commit();
            System.out.println("新增了"+insertNum+"条数据");
        }catch (Exception e){
            e.printStackTrace();
            sqlSession.rollback();
        }finally {
            MybatisUtil.closeSqlSession(sqlSession);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行测试代码，在控制台得到的新增数据为下图，并查看数据中的信息，发现与数据库中的信息一致，说明添加数据操作完成。
在这里插入图片描述
添加后的数据库中表的数据：

4.数据的更新

在映射文件中，写更新的SQL语句，与数据插入大同小异。字段的属性值要与数据库保持一致name=#{name},address=#{address}并使用id来做限定。

 <update id="updateStudent" parameterType="com..entity.Student">
        update student set name=#{name},address=#{address} where id=#{id}
    </update>
1
2
3

然后在测试类中写测试就可以了对数据进行更新，调用update()方法，同样需要对数据进行提交操作。

//更新测试
    @Test
    public void testUpdateStudent(){
        SqlSession sqlSession=null;
        try {
            sqlSession=MybatisUtil.createSqlSession();
            Student student = new Student();
            student.setId(1);
            student.setName("武哥NB");
            student.setAddress("湖北荆州");
            int updateNum = sqlSession.update("com.dao.StudentDao.updateStudent", student);
            sqlSession.commit();
            System.out.println("更新了"+updateNum+"条数据");
        }catch (Exception e){
            e.printStackTrace();
            sqlSession.rollback();
        }finally {
            MybatisUtil.closeSqlSession(sqlSession);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行测试代码，在控制台得到的更新数据为下图，并查看数据中的信息，发现数据库中的信息一致，说明更新数据操作完成。
在这里插入图片描述
更新后的数据库中表的数据：

5.数据的删除

在映射文件中，写删除的SQL语句，与前面的数据添加和更新是一样的。由于是进行删除操作，所以直接将id作为参数，直接将对象信息删除。

<delete id="deleteStudent" parameterType="com.softeem.entity.Student">
        delete from student where id=#{id}
    </delete>
1
2
3

然后在测试类中写测试就可以了对数据进行删除，调用delete()方法，同样需要对数据进行提交操作。

 @Test
    public void testDeleteStudent(){
        SqlSession sqlSession=null;
        try {
            sqlSession=MybatisUtil.createSqlSession();
            Student student = new Student();
            student.setId(3);
            int deleteNum = sqlSession.delete("com.dao.StudentDao.deleteStudent", student);
            sqlSession.commit();
            System.out.println("删除了"+deleteNum+"条数据");
        }catch (Exception e){
            e.printStackTrace();
            sqlSession.rollback();
        }finally {
            MybatisUtil.closeSqlSession(sqlSession);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

运行测试代码，在控制台得到的删除数据为下图，并查看数据中的信息，发现数据库中的信息一致，说明删除数据操作完成。
在这里插入图片描述
删除后的数据库中表的数据：

总结

以上就是今天要讲的内容，本文完整的介绍了Mybatis的具体的增删改查（CURD）操作。使用ORM框架，更快的完成数据的一系列操作。

相关阅读:
node.js知识系列（2）-每天了解一点
 记 350亿数据从 es 迁移到 ClickHouse 遇到的问题
 反转链表的升级版——链表内指定区间反转
 nodejs+wasm+rust debug及性能分析
 JWT在spring boot中的应用
 git gitlab撤回已经提交的代码,回滚到某一个版本/节点
 C++中queue的用法（超详细，入门必看）
AWS CloudFormation
50.Python-web框架-Django中引入静态的bootstrap样式
 Java进阶03 IO基础
原文地址：https://blog.csdn.net/dxcn01/article/details/125493492