Mybatis入门与使用CRUD

一: 创建并初始化数据库

1: 创建数据库:

create database mybatis_plus charset utf8; //创建数据库指定字符集
use mybatis_plus; 						   //并选择该数据库

2: 创建User 用户表:

• 其中表结构如下:

id	name姓名	age年龄	email邮箱
1	Jone	18	test1@baomidou.com
2	Jack	20	test2@baomidou.com
3	Tom	28	test3@baomidou.com
4	Sandy	21	test4@baomidou.com
5	Billie	24	test5@baomidou.com

• 其对应的用户表数据库脚本如下:

DROP TABLE IF EXISTS user;

CREATE TABLE user (
    id BIGINT(20) NOT NULL COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
    age INT(11) NULL DEFAULT NULL COMMENT '年龄',
    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (id)
);

• 其对应相应的数据表Data 如下:

DELETE FROM user;

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');

二: 初始化项目

• 使用Idea开发工具 点击Spring Initializr 快捷初始化一个 SpringBoot 工程:

• 创建项目相应的版本: 版本：2.2.1.RELEASE

三: 添加依赖

• 添加：mybatis-plus-boot-starter、
• MySQL、
• lombok、需要安装 lombok 插件 settings 下载安装
• 在项目中使用Lombok可以减少很多重复代码的书写。比如说getter/setter/toString等方法的

 		<!--mybatis-plus为简化开发而生只需简单配置，即可快速进行单表 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>

        <!--mysql连接 Java 驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!--lombok用来简化实体类-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

• 注意：引入 MyBatis-Plus 之后请不要再次引入 MyBatis 以及 MyBatis-Spring，以避免因版本差异导致的问题。

四: 配置文件

• 在 application.properties 配置文件中添加 MySQL 数据库的相关配置：mysql5.4版本

# Mysql数据库连接
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus
spring.datasource.username=root
spring.datasource.password=

• 在 application.properties 配置文件中添加 MySQL 数据库的相关配置：mysql8.0 以上版本(SpringBoot2.1)
  注意：driver和url的变化

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=

• 注意：
  1、这里的 url 使用了 ?serverTimezone=GMT%2B8 后缀，因为Spring Boot 2.1 集成了 8.0版本的jdbc驱动，这个版本的 jdbc 驱动需要添加这个后缀，否则运行测试用例报告如下错误：

• 2、这里的 driver-class-name 使用了 com.mysql.cj.jdbc.Driver ，在 jdbc 8 中 建议使用这个驱动，之前的 com.mysql.jdbc.Driver 已经被废弃，否则运行测试用例的时候会有 WARN 信息

五: 编写代码

1:程序的主入口类

• 在 Spring Boot 启动类中添加 @MapperScan 注解，扫描 Mapper 文件夹
  注意：扫描的包名根据实际情况修改

package com.atguigu;

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

@SpringBootApplication
@MapperScan("com.atguigu.mapper") //组件扫描数据库CRUD 操作
public class Mpdemo1010Application {

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

}

2:实体类:

• 创建包 entity 编写实体类 User.java（此处使用了== Lombok== 简化代码）

import lombok.Data;
/**
 * 实体类
 * 对应数据库的表把属性编写出来
 */
@Data //注解在 类 上；提供类所有属性的 get 和 set 方法，此外还提供了equals、canEqual、hashCode、toString 方法。
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

3: Mapper 接口

• 创建包 mapper 编写Mapper 接口： UserMapper.java

/**
 * Mapper 继承该接口后，无需编写 mapper.xml 文件，即可获得CRUD功能
 * 操作数据库层接口使用继承 Mybatis_plus而它封装之前的 xml 增删改查的操作
 * 这样就可以调用里面的增删改查的操作
 * <>User</>指定要操作实体类
 */
@Repository //注解把该有的对象交由 SpringBean 容器管理
public interface UserMapper extends BaseMapper<User> {

}

六: Test 测试

select 查询操作

• select是生成的动态的 SQL 语句是

SELECT id,name,age,email FROM user;

• 添加测试类，进行功能测试

package com.atguigu;

import com.atguigu.entity.User;
import com.atguigu.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class Mpdemo1010ApplicationTests {

    @Autowired//自动装配
    //userMapper 会报错可忽悠 可处理没有把该自动装配的对象交由容器管理
    private UserMapper userMapper;


    //1: 查询 user 表所有数据
    @Test
    public void findAll() {
        //UserMapper 中的 selectList() 方法的参数为 MP 内置的条件封装器 Wrapper
        //所以不填写就是无任何条件
        List<User> users = userMapper.selectList(null);
        System.out.println(users);
    }

    //2: 查询所有的数据
    @Test
    public void testSelectList() {
        System.out.println(("----- selectAll method test ------"));
        //UserMapper 中的 selectList() 方法的参数为 MP 内置的条件封装器 Wrapper
        //所以不填写就是无任何条件
        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }
}

1、根据id查询记录

@Test
public void testSelectById(){
    User user = userMapper.selectById(1L);
    System.out.println(user);
}

2、多个 id批量查询

 //多个 id批量查询
    @Test
    public void testSelectdemo1(){
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1L, 2L, 3L));
        System.out.println(users);
    }

3、简单的条件查询基本用不上

@Test
public void testSelectByMap(){
    HashMap<String, Object> map = new HashMap<>();
    map.put("name", "Helen");
    map.put("age", 18);
    List<User> users = userMapper.selectByMap(map);
    users.forEach(System.out::println);
}

• 注意：map中的key对应的是数据库中的列名。例如数据库user_id，实体类是userId，这时map的key需要填写user_id

insert 插入操作

• insert 是生成的动态的 sql 语句是

INSERT INTO user ( id, name, age, email ) VALUES ( 1304501745350623233, 'Heart', 30, '2667275115@qq.com' );

  //3: 添加的操作
    @Test
    public void addUser(){
        //创建 user 对象
        User user = new User();
        //添加数据
        user.setName("Heart");
        user.setAge(30);
        user.setEmail("2667275115@qq.com");
        //调用 user 方法
        int insert = userMapper.insert(user);
        //打印输出
        System.out.println("insert:"+insert);
    }

update 修改操作

• 注意：update时生成的sql自动是动态sql：UPDATE user SET age=? WHERE id=?

UPDATE user SET name='Spring', age=120, email='qq2667275115@iCloud.com' WHERE id=2;

   //修改操作
    @Test
    public void updateUser(){
    	//创建要修改的对象 User
        User user = new User();
        //根据 id 最大值修改
        user.setId(2L);
        //修改 name
        user.setName("Spring");
        //修改年龄
        user.setAge(120);
        //修改邮箱
        user.setEmail("qq2667275115@iCloud.com");
		//调用修改的方法
        int row = userMapper.updateById(user);
        //打印输出
        System.out.println("row:"+row);
    }

分页查询项目中用得最多的查询方式

• MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能
  

( 1 ): 创建配置类:

• 此时可以删除主类中的@ MapperScan 组件扫描

	/**
     * 分页插件
     */
    @Bean //存放在 Bean 容器进行管理
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }

( 2 ): 测试testPage分页查询:

• 测试：最终通过page对象获取相关数据

//分页查询
    @Test
    public void testPage(){
        //创建 Page 对象
        //传入两个参数.当前页.和每页显示记录数
        Page<User> page = new Page<>(1,3);
        //调用Mapper.实现分页查询
        //调用Mapper.分页查询过程中.底层封装.把分页所有的数据封装到Page 对象里面
        userMapper.selectPage(page,null);

        //通过 Page 对象获取分页的数据
        System.out.println("获取当前" + page.getCurrent());//获取当前
        System.out.println("获取记录" + page.getRecords());//获取记录数
        System.out.println("得到大小" + page.getSize());//得到的大小
        System.out.println("总计" + page.getTotal());//总记录数
        System.out.println("获取页面" + page.getPages());//获取的页面

        System.out.println("下一页" + page.hasNext()); //是否有下一页 则为 true 没有则为 false
        System.out.println("上一页" + page.hasPrevious());//是否有上一页  则为 true 没有则为 false

    }

• 控制台sql语句打印：

SELECT id,name,age,email,create_time,update_time,version FROM user LIMIT 0,3;

delete

1、根据id删除记录

//删除操作 物理删除
    @Test
    public void testDeleteById(){
        int result = userMapper.deleteById(1);
        System.out.println("根据 id 删除成功!:" + result);
    }
    
	   //动态 sql 语句:
       DELETE FROM user WHERE id=1;

2、批量删除

 //批量删除
    @Test
    public void testDeleteBatchIds(){
        int result = userMapper.deleteBatchIds(Arrays.asList(2, 3, 4));
        System.out.println("根据 id 进行批量删除成功!" + result);
    }
    //动态 sql 语句
    DELETE FROM user WHERE id IN ( 2 , 3 , 4 );

3、简单的条件查询删除不推荐

//简单的条件查询删除
    @Test
    public void deleteByMap(){
        HashMap<String, Object> map = new HashMap<>();

        map.put("name","岳不群");
        map.put("age","18");

        int result = userMapper.deleteByMap(map);
        System.out.println("根据条件查询删除:" + result);
    }

4、逻辑删除

• 物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除数据
• 逻辑删除：假删除，将对应数据中代表是否被删除字段状态修改为“被删除状态”，之后在数据库中仍旧能看到此条数据记录

( 1 ): 数据库中添加deleted字段.不使用自动递增.默认填充零

ALTER TABLE user ADD COLUMN deleted boolean

( 2 ): 实体类中添加deleted 属性更数据库表一一对应

• 并加上 @TableLogic 注解 和 @TableField(fill = FieldFill.INSERT) 注解

    @TableLogic //表字段逻辑处理注解（逻辑删除）
    private Integer deleted;

( 3 ): 在 MybatisPlusConfig 中注册 Bean交由容器管理 插件

    /**
     * 配置逻辑删除插件
     * @return
     */
    @Bean
    public ISqlInjector sqlInjector() {
        return new LogicSqlInjector();
    }

( 4 ): application.properties 加入配置默认填充

• 此为默认值，如果你的默认值和mp默认的一样,该配置可无

mybatis-plus.global-config.db-config.logic-delete-value=1 //默认删除为 1
#mybatis-plus.global-config.db-config.logic-not-delete-value=0 //默认不删除是 0

( 5 ): 测试逻辑删除

• 测试后发现，数据并没有被删除，deleted字段的值由0变成了1
• 测试后分析打印的sql语句，是一条update
• 注意：被删除数据的deleted 字段的值必须是 0，才能被选取出来执行逻辑删除的操作

	/**
     * 测试 逻辑删除
     */
    @Test
    public void testLoginDelete(){

        int result = userMapper.deleteById(1304813393089179649L);
        System.out.println("逻辑删除成功!" + result);
    }
    动态 sql 语句
UPDATE user SET deleted=1 WHERE id=1304813393089179649 AND deleted=0;

( 6 ): 测试逻辑删除后的查询

 	/**
     * 测试
     * 逻辑删除后的查询
     * 不包括被逻辑删除的记录
     */
    @Test
    public void testLoginDeleteSelect(){
        User user = new User();
        List<User> users = userMapper.selectList(null);
        System.out.println("总计:" + users);
    }
    动态sql 语句
 SELECT id,name,age,email,create_time,update_time,version,deleted 
 FROM
 	 user
 WHERE 
 	deleted=0;

1: 自动填充的两种方式 set 的和 mp 框架形式

• 项目中经常会遇到一些数据.每次都使用相同的方式填充.例如记录的创建时间.更新时间.等.我们会可以使用Mybatis_plusd的自动填充功能.完成这些字段的赋值工作.

( 1 ): 数据表中添加自动填充字段

• 在 User表中添加datatime 类型的新的字段create_time. update_time实体类添加注释

(2): 实体类添加注解

import java.util.Date;
	//手动填充
    //创建时间 create_time
    private Date createTime;

    //修改时间 update_time
    private Date updateTime;
     
     
    //Mybatis_plus 自动填充的框架
    @TableField(fill = FieldFill.INSERT)  //插入填充字段
    //创建时间 create_time
    private Date createTime;

    @TableField(fill = FieldFill.INSERT_UPDATE)  //插入和更新填充字段
    //修改时间 update_time
    private Date updateTime;

( 3 ): 测试 create_time 创建和 update_time 修改操作

//3: 添加的操作
    @Test
    public void addUser(){
        //创建 user 对象
        User user = new User();
        //添加数据
        user.setName("mary");
        user.setAge(30);
        user.setEmail("@qq.com");

        //添加时间
        user.setCreateTime(new Date()); //手动设置
        //修改时间
        user.setUpdateTime(new Date());//时间值

        //调用 user 方法
        int insert = userMapper.insert(user);
        //打印输出
        System.out.println("insert:"+insert);
    }

(4) Mybatis_plus 框架实现自动填充实现元对象处理器接口

• 根据Mybatis_plus 文档实现该方法
  https://baomidou.com/guide/auto-fill-metainfo.html
  
• 实现元对象处理器接口
• 注意：不要忘记添加 @Component 注解

package com.atguigu.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;
import java.util.Date;

/**
 * 自定义实现类自动添加 Mybatis_plus接口
 */
@Slf4j //记录日志
@Component //注解把对象交由容器去管理
public class MyMetaObjectHandler implements MetaObjectHandler {

    //使用 Mybatis实现添加操作.这个方法就会执行
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("============添加成功!=============");
        this.setFieldValByName("createTime",new Date(),metaObject);
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }

    //使用 Mybatis 实现更新修改操作.这里面的方法就会执行
    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("============修改成功!=============");
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
}

测试结构

• 生成动态的 sql 语句

//添加的动态的 sql 语句
INSERT INTO user ( id, name, age, email, create_time, update_time )
VALUES ( 1304691122085347329, 'liSi', 21,
  '218291341@gemil.com', 
  '2020-09-12 15:59:38.152',
  '2020-09-12 15:59:38.152' );


//更新的生成动态的 sql 语句
UPDATE user SET name='Spring', age=11, email='qq2667275115@iCloud.com', update_time='2020-09-12 16:01:50.166'
WHERE id=1304691122085347329;

• 注意：
  1: IDEA在 userMapper 处报错，因为找不到注入的对象，因为类是动态创建的，但是程序可以正确的执行。
  为了避免报错，可以在 dao 层 的接口上添加 @Repository 注
  2: 通过以上几个简单的步骤，我们就实现了 User 表的 CRUD 功能，甚至连 XML 文件都不用编写！

乐观锁

• 根据 mp 文档配置
  https://baomidou.com/guide/optimistic-locker-plugin.html

• 主要适用场景：当要更新一条记录的时候，希望这条记录没有被别人更新，也就是说实现线程安全的数据更新
  
  乐观锁实现方式:
  

• 取记录时.获取当前 version 版号

• 更新时.带上这个版本号 version

• 执行更新时.set version = newVersion where version = oldVersion

• 如果version不对，就更新失败

(1): # 数据库中添加version字段

ALTER TABLE user ADD COLUMN version INT

(2): # 实体类添加version字段

    //乐观锁的版本号
    private Integer version;

(3): # 插件配置

• 第一种方法插件配置可以直接配置到我 SpringBoot 主启动类中直接读取

package com.atguigu;

import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
@MapperScan("com.atguigu.mapper") //组件扫描数据库CRUD 操作可以放到我们配置类中让它去扫描
public class Mpdemo1010Application {

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

    /**
     * 乐观锁插件配置到主启动类中
     * @return
     */
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
}

• 第二种方法为了更突出的我们的配置 单独可以建个config 专门来存放项目中所需要的配置

package com.atguigu.config;
/**
 * 类 描 述：TODD
 * 项目名称：mpdemo1010
 * 类 名 称：MpConfig
 * 创建时间：2020/9/12 5:33 PM
 * 创 建 人：huanghao
 * @version: V2.2
 */

import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 配置类 config
 */
@Configuration
@MapperScan("com.atguigu.mapper") //组件扫描数据库CRUD 操作
public class MpConfig {
    /**
     * 乐观锁插件配置到主启动类中
     * @return
     */
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
}

(4): #元对象处理器接口添加version的insert默认值

• 1: 去实体类添加自动填充的字段.数据库默认为 1

    //乐观锁的版本号
    @Version //注解添加 version 修改
    @TableField(fill = FieldFill.INSERT)  //插入填充字段1
    private Integer version;

• 2: 去 Handler接口中添加查询的方法

        //自动填充版本号 默认值为 1
        this.setFieldValByName("version",1,metaObject);

• 3: 测试乐观锁先查询所有 后修改默认加载的版本为 2

  //测试乐观锁
    @Test
    public void testOptimisticLocker(){
        //根据 id 查询数据
        User user = userMapper.selectById(1304717378008985602L);//id 值
        //进行修改
        user.setAge(22);//年龄
        userMapper.updateById(user);//调用更新的方法
        System.out.println("乐观锁查询成功!"+user);
    }

( 5 ): # 测试乐观锁可以修改成功

• 测试后分析打印的sql语句，将version的数值进行了加1操作

/**
 * 测试 乐观锁插件
 */
@Test
public void testOptimisticLocker() {
    //查询
    User user = userMapper.selectById(1L);
    //修改数据
    user.setName("Helen Yao");
    user.setEmail("helen@qq.com");
    //执行更新
    userMapper.updateById(user);
}

( 6 ): # 测试乐观锁可以修改失败

/**
 * 测试乐观锁插件 失败
 */
@Test
public void testOptimisticLockerFail() {
    //查询
    User user = userMapper.selectById(1L);
    //修改数据
    user.setName("Helen Yao1");
    user.setEmail("helen@qq.com1");
    //模拟取出数据后，数据库中version实际数据比取出的值大，即已被其它线程修改并更新了version
    user.setVersion(user.getVersion() - 1);
    //执行更新
    userMapper.updateById(user);
}

八: 打印配置日志

• 查看sql输出日志

#mybatis日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

九: 主键的策略

• 1: Mybatis_plus的默认主键策略是: id_Worker全局的唯一 id 值

• 2: 使用 ID_Worfer工具测试 id 的生成.了解生成 id 的原理
  

• 添加测试类Worker

• 编写测试的用例

( 2 )自增策略

• 1: 要想主键自增需要配置如下主键策略
  2: 需要在创建数据表的时候设置主键策略
  3: 实体类字段中配置@TableId(type = IdType.AUTO)

     @TableId(type = IdType.AUTO) //表主键标识
//    @TableId(type = IdType.ID_WORKER) //mybatis_plus 自带策略.生成19 位值.数字类型使用这种策略.比如Long 类型
//    @TableId(type = IdType.ID_WORKER_STR) mybatis_plus 自带策略.生成19 位值.字符串类型使用这种策略.

• 4: 要想影响所有实体的配置，可以设置全局主键配置

#全局设置主键生成策略
mybatis-plus.global-config.db-config.id-type=auto

十: 性能分析

• 性能分析拦截器，用于输出每条 SQL 语句及其执行时间
• SQL 性能执行分析,开发环境使用，超过指定时间，停止运行。有助于发现问题

1: 配置插件:

( 1 ): 参数说明:

• 参数：maxTime： SQL 执行最大时长，超过自动停止运行，有助于发现问题。
• 参数：format： SQL是否格式化，默认false。

（2）在 MybatisPlusConfig 中配置

	 /**
     * SQL 执行性能分析插件
     * 开发环境使用，线上不推荐。 maxTime 指的是 sql 最大执行时长
     *
     * 三种环境
     * application-dev.properties：用于开发环境 server.port=8080
     * application-test.properties：用于测试环境 server.port=8090
     * application-prod.properties：用于生产环境 spring.profiles.active=dev
     */
    @Bean //容器管理
    @Profile({"dev","test"})// 设置 dev test 环境开启
    public PerformanceInterceptor performanceInterceptor() {
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        performanceInterceptor.setMaxTime(100);//ms，超过此处设置的ms则sql不执行
        performanceInterceptor.setFormat(true);
        return performanceInterceptor;
    }

（3）Spring Boot 中设置dev环境

#环境设置：dev、test、prod
spring.profiles.active=dev

• 可以针对各环境新建不同的配置文件application-dev.properties、application-test.properties、application-prod.properties
  也可以自定义环境名称：如test1、test2

2、测试:

(2): 常规测试

	/**
     * 测试 性能分析插件
     */
    @Test
    public void testPerformance(){
        User user = new User();
        user.setName("张飞");
        user.setAge(20);
        user.setEmail("qq.com");
        userMapper.insert(user);
    }
    动态添加 sql 语句
INSERT INTO user ( id, name, age, email, create_time, update_time, version ) 
VALUES 
( 1304829909046210562, '张飞', 20, 'qq.com', 
'2020-09-13 01:11:07.543',
'2020-09-13 01:11:07.543', 1 );

(3): 性能异常
正常通过
（4）将maxTime 改小之后再次进行测试

performanceInterceptor.setMaxTime(100);//ms，超过此处设置的ms则sql不执行

• 输出
  

十一: 异常报错

Java.sql.Exception: Access denied for user ‘root’ @’ localhost (using password: YES).

• 配置文件application.properties 密码错误 根据自己的mysql 来配置信息