系列学习 SpringBoot 整合 Mybatis 之第 2 篇 —— 实现对数据库的 CRUD（增删改查）

 

本篇博客接着上一篇：https://blog.csdn.net/BiandanLoveyou/article/details/116528151

CRUD（增删改查，create、read、update、delete的缩写）操作，接下来，我们对表 t_student 做简单的增删改查功能，以打通数据从“前端——》后台——》数据库——》后台——》前端” 这条闭环之路。

项目结构图：

 

1、首先我们修改一下 Mybatis 自动生成的 mapper 文件：StudentEntityMapper.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="com.study.dao.StudentEntityMapper">

  <resultMap id="BaseResultMap" type="com.study.entity.StudentEntity">
    <id column="id" jdbcType="INTEGER" property="id" />
    <result column="student_no" jdbcType="VARCHAR" property="studentNo" />
    <result column="student_name" jdbcType="VARCHAR" property="studentName" />
    <result column="introduce" jdbcType="VARCHAR" property="introduce" />
  </resultMap>

  <!-- 根据主键ID删除数据 -->
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
    delete from t_student
    where id = #{id,jdbcType=INTEGER}
  </delete>

  <!-- 新增数据 -->
  <insert id="insert" parameterType="com.study.entity.StudentEntity">
    insert into t_student (id, student_no, student_name,
      introduce)
    values (null, #{studentNo,jdbcType=VARCHAR}, #{studentName,jdbcType=VARCHAR},
      #{introduce,jdbcType=VARCHAR})
  </insert>

  <!-- 根据主键ID更新数据 -->
  <update id="updateByPrimaryKey" parameterType="com.study.entity.StudentEntity">
    update t_student
    set student_no = #{studentNo,jdbcType=VARCHAR},
      student_name = #{studentName,jdbcType=VARCHAR},
      introduce = #{introduce,jdbcType=VARCHAR}
    where id = #{id,jdbcType=INTEGER}
  </update>

  <!-- 根据主键ID查询数据 -->
  <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
    select id, student_no, student_name, introduce
    from t_student
    where id = #{id,jdbcType=INTEGER}
  </select>

  <!-- 查询所有数据 -->
  <select id="selectAll" resultMap="BaseResultMap">
    select id, student_no, student_name, introduce
    from t_student
  </select>

</mapper>

说明：

①namespace：<mapper namespace="com.study.dao.StudentEntityMapper">  这里对应我们 dao 层的 mapper 接口全路径。可以鼠标右键找到 Copy Reference

 

②resultMap：就是前面说到的映射标签，即对象与数据库的 ORM 字段关系映射。

下面给出标签映射的类型大全图（即 jdbcType 的类型）： 

③insert、delete、update、select：是 mybatis 的标签，对应的是增删改查。但并没有强制的对应关系，比如你可以在 <delete> 标签上执行 update 语句。

④id：表示处理的方法名称，对应 dao 层的接口名，不允许重载。即 id 对应的名称是不能重复的，否则 mybatis 会抛出异常。

parameterType：表示请求参数的类型，比如：parameterType="java.lang.Integer"。

resultMap：表示返回的结果集类型。比如：resultMap="BaseResultMap"。注意这里的 BaseResultMap 就是对应上面定义的结果集。

resultType：表示返回的类型，比如：resultType="java.lang.String"

<select>元素的常用属性如下表：

属性名称	描 述
id	它和 Mapper 的命名空间组合起来使用，是唯一标识符，供 MyBatis 调用
parameterType	表示传入 SQL 语句的参数类型的全限定名或别名。它是一个可选属性，MyBatis 能推断出具体传入语句的参数
resultType	SQL 语句执行后返回的类型（全限定名或者别名）。如果是集合类型，返回的是集合元素的类型，返回时可以使用 resultType 或 resultMap 之一
resultMap	它是映射集的引用，与 <resultMap> 元素一起使用，返回时可以使用 resultType 或 resultMap 之一
flushCache	用于设置在调用 SQL 语句后是否要求 MyBatis 清空之前查询的本地缓存和二级缓存，默认值为 false，如果设置为 true，则任何时候只要 SQL 语句被调用都将清空本地缓存和二级缓存
useCache	启动二级缓存的开关，默认值为 true，表示将査询结果存入二级缓存中
timeout	用于设置超时参数，单位是秒（s），超时将抛出异常
fetchSize	获取记录的总条数设定
statementType	告诉 MyBatis 使用哪个 JDBC 的 Statement 工作，取值为 STATEMENT（Statement）、 PREPARED（PreparedStatement）、CALLABLE（CallableStatement）
resultSetType	这是针对 JDBC 的 ResultSet 接口而言，其值可设置为 FORWARD_ONLY（只允许向前访问）、SCROLL_SENSITIVE（双向滚动，但不及时更新）、SCROLLJNSENSITIVE（双向滚动，及时更新）

2、dao 层的 StudentEntityMapper 接口如下：

package com.study.dao;

import com.study.entity.StudentEntity;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper //如果不在 dao 层增加 @Mapper 注解，就在启动类增加扫描 dao 层的包
public interface StudentEntityMapper {

    /**
     * 根据主键ID删除
     * @param id
     * @return
     */
    int deleteByPrimaryKey(Integer id);

    /**
     * 新增数据
     * @param record
     * @return
     */
    int insert(StudentEntity record);

    /**
     * 根据主键ID查询
     * @param id
     * @return
     */
    StudentEntity selectByPrimaryKey(Integer id);

    /**
     * 查询所有数据
     * @return
     */
    List<StudentEntity> selectAll();

    /**
     * 根据主键更新
     * @param record
     * @return
     */
    int updateByPrimaryKey(StudentEntity record);
}

说明：注意接口名要与 xml 配置的 id 一致。如果不在 dao 层的接口里增加 @Mapper 注解，则可以在启动类里增加扫描 dao 层的包：@MapperScan("com.study.dao")

 

3、实体类：StudentEntity

package com.study.entity;

public class StudentEntity {
    //主键ID
    private Integer id;

    //学号
    private String studentNo;

    //姓名
    private String studentName;

    //自我介绍
    private String introduce;

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getStudentNo() {
        return studentNo;
    }
    public void setStudentNo(String studentNo) {
        this.studentNo = studentNo;
    }
    public String getStudentName() {
        return studentName;
    }
    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }
    public String getIntroduce() {
        return introduce;
    }
    public void setIntroduce(String introduce) {
        this.introduce = introduce;
    }
}

4、业务逻辑接口：StudentService

package com.study.service;

import com.study.entity.StudentEntity;

import java.util.List;
import java.util.Map;

/**
 * @author biandan
 * @description 业务逻辑处理类
 * @signature 让天下没有难写的代码
 * @create 2021-05-09 下午 2:19
 */
public interface StudentService {

    //新增用户信息。
    boolean add(StudentEntity entity);

    //删除用户信息
    boolean delete(Integer id);

    //更新用户信息
    boolean update(StudentEntity entity);

    //根据主键 id 查询用户信息
    StudentEntity selectById(Integer id);

    //查询所有
    List<StudentEntity> selectAll();

}

 

5、业务逻辑实现类：StudentServiceImpl。需要增加注解：@Service，加入到 Spring 容器中，方便识别是业务层。

package com.study.service.impl;

import com.study.dao.StudentEntityMapper;
import com.study.entity.StudentEntity;
import com.study.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author biandan
 * @description
 * @signature 让天下没有难写的代码
 * @create 2021-05-09 下午 2:45
 */
@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentEntityMapper studentEntityMapper;

    //新增
    @Override
    public boolean add(StudentEntity entity) {
        int count = studentEntityMapper.insert(entity);
        if(count > 0){
            return true;
        }
        return false;
    }

    //删除
    @Override
    public boolean delete(Integer id) {
        int count = studentEntityMapper.deleteByPrimaryKey(id);
        if(count > 0){
            return true;
        }
        return false;
    }

    //更新
    @Override
    public boolean update(StudentEntity entity) {
        int count = studentEntityMapper.updateByPrimaryKey(entity);
        if(count > 0){
            return true;
        }
        return false;
    }

    //根据主键ID查询
    @Override
    public StudentEntity selectById(Integer id) {
        StudentEntity studentEntity = studentEntityMapper.selectByPrimaryKey(id);
        return studentEntity;
    }

    //查询所有
    @Override
    public List<StudentEntity> selectAll() {
        List<StudentEntity> list = studentEntityMapper.selectAll();
        return list;
    }
}

6、请求 Controller 层：StudentController

package com.study.controller;

import com.study.entity.StudentEntity;
import com.study.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author biandan
 * @description
 * @signature 让天下没有难写的代码
 * @create 2021-05-09 下午 2:27
 */
@RestController
@RequestMapping(value = "/student")
public class StudentController {

    @Autowired
    private StudentService studentService;

    //新增学生信息
    @ResponseBody
    @RequestMapping(value = "/add", method = RequestMethod.POST)
    public Map<String,Object> addUserInfo(HttpServletRequest request) {
        Map<String,Object> map = new HashMap<>();
        map.put("code",-1);
        map.put("message","新增学生信息失败！");
        try {
            //从 request 对象中获取学生信息
            String studentNo = request.getParameter("studentNo");
            String studentName = request.getParameter("studentName");
            String introduce = request.getParameter("introduce");
            //创建学生对象，并注入属性
            StudentEntity  entity = new StudentEntity ();
            entity.setStudentNo(studentNo);
            entity.setStudentName(studentName);
            entity.setIntroduce(introduce);
            //调用 studentService 接口的新增学生方法
            boolean flag = studentService.add(entity);
            if(flag){//成功
                map.put("code",0);
                map.put("message","新增学生信息成功！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }

    //根据 id 删除学生信息
    @ResponseBody
    @RequestMapping(value = "/delete", method = RequestMethod.POST)
    public Map<String,Object> deleteUserInfo(HttpServletRequest request) {
        Map<String,Object> map = new HashMap<>();
        map.put("code",-1);
        map.put("message","删除学生信息失败！");
        try {
            //从 request 对象中获取学生名主键 id
            int id = Integer.parseInt(request.getParameter("id"));
            //调用 studentService 接口删除方法
            boolean flag = studentService.delete(id);
            if(flag){//成功
                map.put("code",0);
                map.put("message","删除学生信息成功！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }

    //修改学生信息（不修改学号）
    @ResponseBody
    @RequestMapping(value = "/update", method = RequestMethod.POST)
    public Map<String,Object> updateUserInfo(HttpServletRequest request) {
        Map<String,Object> map = new HashMap<>();
        map.put("code",-1);
        map.put("message","修改学生信息失败！");
        try {
            //从 request 对象中获取学生信息，注意学号
            Integer id = Integer.parseInt(request.getParameter("id"));
            String studentName = request.getParameter("studentName");
            String introduce = request.getParameter("introduce");
            //创建学生对象，并注入属性
            StudentEntity entity = new StudentEntity();
            entity.setId(id);
            entity.setStudentName(studentName);
            entity.setIntroduce(introduce);
            //调用 studentService 接口的修改学生方法
            boolean flag = studentService.update(entity);
            if(flag){//成功
                map.put("code",0);
                map.put("message","修改学生信息成功！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }

    //根据主键 id 查询学生信息
    @ResponseBody
    @RequestMapping(value = "/selectById", method = RequestMethod.POST)
    public StudentEntity selectStudentInfo(HttpServletRequest request) {
        StudentEntity entity = null;
        try {
            //从 request 对象中获取学生名主键 id
            int id = Integer.parseInt(request.getParameter("id"));
            //调用 studentService 接口的查询学生方法
            entity = studentService.selectById(id);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return entity;
    }

    //查询所有信息
    @ResponseBody
    @RequestMapping(value = "/selectAll", method = RequestMethod.POST)
    public List<StudentEntity> selectAll() {
        List<StudentEntity> list = new ArrayList<>();
        try {
            list = studentService.selectAll();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }
}

7、启动类：MybatisStudyApplication

package com.study;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author biandan
 * @description
 * @signature 让天下没有难写的代码
 * @create 2021-05-09 下午 2:55
 */
@SpringBootApplication
@MapperScan("com.study.dao") //扫描 dao 层的包
public class MybatisStudyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MybatisStudyApplication.class,args);
    }
}

8、配置文件：application.yml

# 配置服务相关信息
server:
  # 端口号
  port: 80

# 服务名称和数据源配置
spring:
  application:
    name: mybatisStudy
  datasource:
    # 使用阿里巴巴的 druid 数据源
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/mybatis_study?characterEncoding=utf-8
      username: root
      password: root

# mybatis 配置
mybatis:
  # Mybatis扫描的mapper文件
  mapper-locations: classpath:mapper/*.xml
  # 扫描哪个包下的对象，如果在 xml 的文件里配置了全限定名（如：com.study.entity.StudentEntity），则不需要在这里配置。
  # type-aliases-package: com.study.entity
  # Mybatis配置文件
  config-location: classpath:mybatis-config.xml

说明：

我们在 pom.xml 配置里引入“org.mybatis.spring.boot”依赖，SpringBoot 在启动的时候，会自动检测现有的 DataSource 配置，然后创建并注册 SqlSessionFactory 实例，该实例使用 SqlSessionFactoryBean 将该 DataSource 作为输入进行传递，然后创建  SqlSessionTemplate 实例，自动扫描 mapper 文件，然后注入到 Spring 上下文中。

我们再使用 mybatis-spring-boot-starter ，只需要定义一个 DataSource 即可（可以在配置文件里完成），它会自动创建使用该 DataSource 的。

mybatis 的配置节点，配置了 config-location 属性，是 Mybatis 的配置文件，我们还需要增加这个配置文件。

9、在 resources 目录下增加 Mybatis 的配置文件：mybatis-config.xml

<?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>

    <!-- 全局配置参数 -->
    <settings>
        <!-- 使全局的映射器启用或禁用缓存。 -->
        <setting name="cacheEnabled" value="true"/>
        <!-- debug 模式打印 sql 语句 -->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

</configuration>

 

OK，代码编写完成，我们启动测试。

测试新增：

测试查询：

测试更新：

 

OK，测试通过。其它的功能可以自己测试。

本次实验代码：https://pan.baidu.com/s/1Ly7cH3Vq0tCb1cPS32-A_A  提取码：4ntj