MyBatisPlus——入门介绍

1.MyBatis介绍
- 1.1.MyBatisPlus概述
- 1.2.MyBatisPlus特性
- 1.3.MyBatisPlus架构
2.快速开始
- 2.1.创建数据库以及表
- 2.2.创建工程
- - 2.2.1.在IDEA中创建一个Maven工程
  - 2.2.2.在pom.xml中导入相关依赖
- 2.3.Mybatis+MP
- - 2.3.1.创建子Module
  - 2.3.2.Mybatis实现查询User
  - 2.3.3.Mybatis+MP实现查询User
- 2.4.Spring + Mybatis + MP
- - 2.4.1.创建子Module
  - 2.4.2.实现查询User
- 2.5.SpringBoot + Mybatis + MP
- - 2.5.1.创建工程
  - 2.5.2.编写相关的配置文件
3.通用CRUD
- 3.1.插入操作——insert
- - 3.1.1.方法定义
  - 3.1.2.编写测试方法进行测试
  - 3.1.4.@TableField注解
- 3.2.更新操作
- - 3.2.1.根据id更新——updateById
  - 3.2.2.根据条件更新——update
- 3.3.删除操作
- - 3.3.1.根据id删除——deleteById
  - 3.3.2.根据条件删除——deleteByMap
  - 3.3.3.根据条件删除——delete
  - 3.3.3.批量删除——deleteBatchIds
- 3.4.查询操作
- - 3.4.1.根据id查询——selectById
  - 3.4.2.批量查询——selectBatchIds
  - 3.4.3.查询单条数据——selectOne
  - 3.4.4.查询数据条数——selectCount
  - 3.4.5.查询数据列表——selectList
  - 3.4.6.分页查询数据——selectPage
4.配置
- 4.1.基本配置
- - 4.1.1.configLocation
  - 4.1.2.mapperLocations
  - 4.1.3.typeAliasesPackage
- 4.2.进阶配置
- - 4.2.1.mapUnderscoreToCamelCase
  - 4.2.2.cacheEnabled
- 4.3.DB 策略配置
- - 4.3.1.idType
  - 4.3.2.tablePrefix
5.条件构造器
- 5.1.allEq
- 5.2.基本比较操作
- 5.3.模糊查询
- 5.4.排序
- 5.5.逻辑查询
- 5.6.select
6.ActiveRecord
- 6.1.ActiveRecord介绍
- 6.2.AR快速入门
7.插件
- 7.1.MyBatis的插件机制
- 7.2.SQL执行分析插件
- - 7.2.1.配置SQL分析插件
  - 7.2.2.编写测试代码
- 7.3.SQL性能分析插件
- - 7.3.1.配置SQL性能分析插件
  - 7.3.2.编写测试代码
- 7.4.乐观锁插件
- - 7.4.1.乐观锁介绍
  - 7.4.2.插件配置方式
  - 7.4.3.注解实体字段
  - 7.4.4.编写测试代码
  - 7.4.5.特别说明
8.Sql 注入器
- 8.1.编写MybaseMapper
- 8.2.编写MySqlInjector
- 8.3.编写FindAll
- 8.4.注册到Spring容器中
- 8.5.编写测试方法
9.自动填充功能
- 9.1.添加@TableField注解
- 9.2.编写MymetaObjectHandler
- 9.3.编写测试用例
10.逻辑删除
- 10.1.修改表结构
- 10.2.在application.properties中进行配置
- 10.3.编写测试方法
11.通用枚举
- 11.1.修改表结构
- 11.2.定义枚举
- 11.3.在application.properties中进行配置
- 11.4.修改实体类User
- 11.5.编写测试方法
12.代码生成器
- 12.1.创建工程
- 12.2.在pom.xml中导入相关依赖
- 12.3.生成器代码
13.MybatisX——快速开发插件
- 13.1.安装方法
- 13.2.功能

本文章笔记整理来自黑马视频https://www.bilibili.com/video/BV1rE41197jR，相关资料可以在视频评论取领取。

1.MyBatis介绍 1.1.MyBatisPlus概述

（1）MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
（2）官方地址：https://mybatis.plus/ 或者https://mp.baomidou.com/。
（3）文档地址：https://mybatis.plus/guide/或者https://mp.baomidou.com/guide/。
（4）源码地址：https://github.com/baomidou/mybatis-plus。
（5）Mybatis-Plus是由baomidou（苞米豆）组织开发并且开源的，码云地址为：https://gitee.com/organizations/baomidou

1.2.MyBatisPlus特性

无侵入	只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小	启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作	内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用	通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
支持主键自动生成	支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
支持 XML 热加载	Mapper 对应的 XML 支持热加载，对于简单的 CRUD 操作，甚至可以无 XML 启动
支持 ActiveRecord 模式	支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作	支持全局通用方法注入（ Write once, use anywhere ）
支持关键词自动转义	支持数据库关键词（order、key…）自动转义，还可自定义关键词
内置代码生成器	采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件	基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List查询
内置性能分析插件	可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
内置全局拦截插件	提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作
内置 Sql 注入剥离器	支持 Sql 注入剥离，有效预防 Sql 注入攻击

1.3.MyBatisPlus架构

2.快速开始

对于Mybatis整合MP有常常有三种用法，分别是Mybatis+MP、Spring+Mybatis+MP、Spring Boot+Mybatis+MP。

2.1.创建数据库以及表

（1）创建名为mp的数据库，且字符集选择utf8。

（2）在mp数据库中创建一张名为tb_user的表，并且插入一些测试数据，对应的SQL语句如下：

-- 创建测试表
CREATE TABLE `tb_user` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`user_name` varchar(20) NOT NULL COMMENT '用户名',
`password` varchar(20) NOT NULL COMMENT '密码',
`name` varchar(30) DEFAULT NULL COMMENT '姓名',
`age` int(11) DEFAULT NULL COMMENT '年龄',
`email` varchar(50) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

-- 插入测试数据
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
('1', 'zhangsan', '123456', '张三', '18', 'test1@itcast.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
('2', 'lisi', '123456', '李四', '20', 'test2@itcast.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
('3', 'wangwu', '123456', '王五', '28', 'test3@itcast.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
('4', 'zhaoliu', '123456', '赵六', '21', 'test4@itcast.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
('5', 'sunqi', '123456', '孙七', '24', 'test5@itcast.cn');

2.2.创建工程 2.2.1.在IDEA中创建一个Maven工程

2.2.2.在pom.xml中导入相关依赖



    4.0.0

    cn.itcast.mp
    itcast-mybatis-plus
    1.0-SNAPSHOT

    
        
        
            com.baomidou
            mybatis-plus
            3.1.1
        
        
        
            mysql
            mysql-connector-java
            5.1.47
        
        
        
            com.alibaba
            druid
            1.0.11
        
        
        
            org.projectlombok
            lombok
            true
            1.18.4
        
        
        
            junit
            junit
            4.12
        
        
        
            org.slf4j
            slf4j-log4j12
            1.6.4
        
    

    
        
            
            
                org.apache.maven.plugins
                maven-compiler-plugin
                
                    1.8
                    1.8

2.3.Mybatis+MP 2.3.1.创建子Module

在resources目录下创建日志配置文件log4j.properties

log4j.rootLogger=DEBUG,A1

log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n

2.3.2.Mybatis实现查询User

（1）创建MyBatis全局配置文件mybatis-config.xml

（2）创建User实体类以及UserMapper接口、UserMapper.xml文件

package cn.itcast.mp.simple.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {

    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
}

package cn.itcast.mp.simple.mapper;

import cn.itcast.mp.simple.pojo.User;
import com.baomidou.mybatisplus.core.mapper.baseMapper;

import java.util.List;

public interface UserMapper{

    List findAll();
}

（3）编写TestMybatis测试用例

package cn.itcast.mp.simple;

import cn.itcast.mp.simple.mapper.UserMapper;
import cn.itcast.mp.simple.pojo.User;
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 org.junit.Test;

import java.io.InputStream;
import java.util.List;

public class TestMybatis {

    @Test
    public void testFindAll() throws Exception{

        String config = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(config);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //测试查询
        List users = userMapper.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }
}

结果如下：

2.3.3.Mybatis+MP实现查询User

（1）将UserMapper继承baseMapper，这样将拥有baseMapper中的所有方法

package cn.itcast.mp.simple.mapper;

import cn.itcast.mp.simple.pojo.User;
import com.baomidou.mybatisplus.core.mapper.baseMapper;

import java.util.List;

public interface UserMapper extends baseMapper {

    List findAll();
}

（2）在User类上添加注解@TableName(“tb_user”)，指定该实体类所对应的数据库表名（如果不添加该注解，则会出现Table ‘mp.user’ dosen’t exist的错误提示）

（3）使用MP中的MybatisSqlSessionFactoryBuilder进行构建

package cn.itcast.mp.simple;

import cn.itcast.mp.simple.mapper.UserMapper;
import cn.itcast.mp.simple.pojo.User;
import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
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 org.junit.Test;

import java.io.InputStream;
import java.util.List;

public class TestMybatisPlus {

    @Test
    public void testFindAll() throws Exception{

        String config = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(config);
        //这里使用的是MP中的MybatisSqlSessionFactoryBuilder
        SqlSessionFactory sqlSessionFactory = new MybatisSqlSessionFactoryBuilder().build(inputStream);

        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    
        //测试查询
//        List users = userMapper.findAll();
        List users = userMapper.selectList(null);
        for (User user : users) {
            System.out.println(user);
        }
    }
}

结果如下：

2.4.Spring + Mybatis + MP

引入了Spring框架后，数据源、构建等工作就交给了Spring管理。

2.4.1.创建子Module

与上面一样，创建一个名为itcast-mybatis-plus-spring的子Module，并在pom.xml中导入Spring的相关依赖



    
        itcast-mybatis-plus
        cn.itcast.mp
        1.0-SNAPSHOT
    
    4.0.0

    itcast-mybatis-plus-spring

    
        5.1.6.RELEASE
    

    
        
            org.springframework
            spring-webmvc
            ${spring.version}
        
        
            org.springframework
            spring-jdbc
            ${spring.version}
        
        
            org.springframework
            spring-test
            ${spring.version}

2.4.2.实现查询User

（1）编写数据库配置文件jdbc.properties以及日志配置文件log4j.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mp?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false
jdbc.username=root
jdbc.password=123456

log4j.rootLogger=DEBUG,A1

log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n

（2）编写Spring配置文件applicationContext.xml以及MyBatis配置文件mybatis-config.xml

（3）创建User实体类以及UserMapper接口（与上面的基本一样，可以直接复制）
（4）编写测试用例

package cn.itcast.mp.simple;

import cn.itcast.mp.simple.mapper.UserMapper;
import cn.itcast.mp.simple.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class TestMybatisSpring {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectList(){
        //不带条件查询用户，即查询所有使用户
        List users = this.userMapper.selectList(null);
        for (User user : users) {
            System.out.println(user);
        }
    }
}

结果如下：

2.5.SpringBoot + Mybatis + MP

使用SpringBoot将进一步的简化MP的整合，需要注意的是，由于使用SpringBoot需要继承parent，所以需要重新创建工程，并不是创建子Module。

2.5.1.创建工程

（1）创建一个名为itcast-mp-springboot的工程

（2）在pom.xml中导入相关依赖



    4.0.0

    
        org.springframework.boot
        spring-boot-starter-parent
        2.1.4.RELEASE
    

    cn.itcast.mp
    itcast-mp-springboot
    1.0-SNAPSHOT

    
        
            org.springframework.boot
            spring-boot-starter
            
                
                    org.springframework.boot
                    spring-boot-starter-logging
                
            
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        

        
        
            org.projectlombok
            lombok
            true
        
        
        
            com.baomidou
            mybatis-plus-boot-starter
            3.1.1
        
        
        
            mysql
            mysql-connector-java
            5.1.47
        
        
            org.slf4j
            slf4j-log4j12
        

    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin

2.5.2.编写相关的配置文件

（1）日志配置文件log4j.properties

log4j.rootLogger=DEBUG,A1

log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n

（2）SpringBoot全局配置文件application.properties

spring.application.name = itcast-mp-springboot

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mp?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456

（3）创建User实体类以及UserMapper接口（与上面的基本一样，可以直接复制）
（4）编写SpringBoot启动类

package cn.itcast.mp;

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

@MapperScan("cn.itcast.mp.mapper")  //设置mapper接口的扫描包
@SpringBootApplication
public class MyApplication {

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

（4）编写测试用例

package cn.itcast.mp;

import cn.itcast.mp.mapper.UserMapper;
import cn.itcast.mp.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class TestMybatisSpringBoot {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectList(){
        List users = this.userMapper.selectList(null);
        for (User user : users) {
            System.out.println(user);
        }
    }
}

结果如下：

3.通用CRUD

通过前面的学习，我们已经了解到通过继承baseMapper就可以获取到下面各种各样的单表操作方法，接下来我们将详细讲解这些操作。

3.1.插入操作——insert 3.1.1.方法定义

int insert(T entity);

3.1.2.编写测试方法进行测试

package cn.itcast.mp;

import cn.itcast.mp.mapper.UserMapper;
import cn.itcast.mp.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestUserMapper {
    
    @Autowired
    private UserMapper userMapper;
    
    @Test
    public void testInsert() {
        User user = new User();
        user.setUserName("xiaowang");
        user.setPassword("123456");
        user.setName("小王");
        user.setAge(21);
        user.setEmail("xiaowang@163.com");
        
        //result:数据库受影响的行数
        int result = this.userMapper.insert(user);
        System.out.println("result => " + result);
        
        //获取自增长后的id值, 自增长后的id值会回填到user对象中
        System.out.println("id => " + user.getId());
    }
}

测试结果如下：

可以看到，数据已经写入到了数据库，但是，id的值不正确，我们期望的是数据库自增长，而实际是MP自动生成的id值写入到了数据库之中。所以应该设置id的生成策略，MP支持的id策略如下：

package com.baomidou.mybatisplus.annotation;

import lombok.Getter;


@Getter
public enum IdType {
    
    AUTO(0),
    
    NONE(1),
    
    INPUT(2),

    
    
    ID_WORKER(3),
    
    UUID(4),
    
    ID_WORKER_STR(5);

    private final int key;

    IdType(int key) {
        this.key = key;
    }
}

所以应该在User类中指定id的类型：

此外，还需要在数据库中修改tb_user表中id字段的下一个自增值。
最后，再次进行测试

3.1.4.@TableField注解

在MP中通过@TableField注解可以指定字段的一些属性，常常解决的问题有以下两个：
（1）对象中的属性名和字段名不一致的问题（非驼峰命名）；
（2）对象中的属性字段在表中不存在的问题；

package cn.itcast.mp.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
//@TableName("tb_user")
public class User {

    @TableId(type = IdType.AUTO)
    private Long id;
    private String userName;

    @TableField(select = false) //查询时不返回该字段的值
    private String password;
    private String name;
    private Integer age;

    @TableField(value = "email") //指定数据表中字段名
    private String mail;

    @TableField(exist = false)  //在数据库表中是不存在的
    private String address; 
}

3.2.更新操作

在MP中，更新操作有两种，一种是根据id更新，另一种是根据条件更新。

3.2.1.根据id更新——updateById

（1）方法定义

    int updateById(@Param(Constants.ENTITY) T entity);

（2）编写测试代码

@Test
public void testUpdateById(){
    User user = new User();
    user.setId(1L);
    user.setPassword("111111");
    user.setEmail("111@163.com");
    //将id为1的用户的密码改为111111、邮箱改为111@163.com
    int result = this.userMapper.updateById(user);
    System.out.println("result => " + result);
}

3.2.2.根据条件更新——update

（1）方法定义

    int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper updateWrapper);

（2）编写测试代码
① 通过QueryWrapper进行更新：

@Test
public void testUpdate1(){
    User user = new User();
    user.setPassword("888888");
    user.setAge(29);

    QueryWrapper wrapper = new QueryWrapper<>();
    //匹配user_name = zhangsan 的用户数据
    wrapper.eq("user_name", "zhangsan");
    
    int result = this.userMapper.update(user,wrapper);
    System.out.println("result => " + result);
}

② 通过UpdateWrapper进行更新：

@Test
public void testUpdate2() {
    UpdateWrapper wrapper = new UpdateWrapper<>();
    wrapper.set("age", 29).set("password", "888888") //更新的字段
            .eq("user_name", "zhangsan"); //更新的条件
    int result = this.userMapper.update(null, wrapper);
    System.out.println("result => " + result);
}

3.3.删除操作 3.3.1.根据id删除——deleteById

（1）方法定义

int deleteById(Serializable id);

（2）编写测试代码

@Test
public void testDeleteById(){
    // 根据id删除数据
    int result = this.userMapper.deleteById(6L);
    System.out.println("result => " + result);
}

3.3.2.根据条件删除——deleteByMap

（1）方法定义

int deleteByMap(@Param(Constants.COLUMN_MAP) Map columnMap);

（2）编写测试代码

@Test
public void testDeleteByMap(){
    Map map = new HashMap<>();
    map.put("user_name", "xiaowang");
    map.put("password", "123456");
    
    //根据map删除数据，多条件之间是and关系
    int result = this.userMapper.deleteByMap(map);
    System.out.println("result => " + result);
}

3.3.3.根据条件删除——delete

（1）方法定义

int delete(@Param(Constants.WRAPPER) Wrapper wrapper);

（2）编写测试代码
① 方式一

@Test
public void testDelete1(){
    QueryWrapper wrapper = new QueryWrapper<>();
    wrapper.eq("user_name", "caocao1")
            .eq("password", "123456");     //删除的条件
    int result = this.userMapper.delete(wrapper);
    System.out.println("result => " + result);
}

② 方式二（推荐使用）

@Test
public void testDelete2(){
    User user = new User();
    user.setPassword("123456");
    user.setUserName("xiaowang");
    QueryWrapper wrapper = new QueryWrapper<>(user);
    // 根据包装条件做删除
    int result = this.userMapper.delete(wrapper);
    System.out.println("result => " + result);
}

3.3.3.批量删除——deleteBatchIds

（1）方法定义

int deleteBatchIds(@Param(Constants.COLLECTION) Collection idList);

（2）编写测试代码

@Test
public void  testDeleteBatchIds(){
    // 根据id批量删除数据
    int result = this.userMapper.deleteBatchIds(Arrays.asList(8L, 9L));
    System.out.println("result => " + result);
}

3.4.查询操作

MP提供了多种查询操作，包括根据id查询、批量查询、查询单条数据、查询列表、分页查询等操作。

3.4.1.根据id查询——selectById

（1）方法定义

T selectById(Serializable id);

（2）编写测试代码

@Test
public void testSelectById() {
    //根据id查询数据
    User user = this.userMapper.selectById(2L);
    System.out.println("result = " + user);
}

3.4.2.批量查询——selectBatchIds

（1）方法定义

List selectBatchIds(@Param(Constants.COLLECTION) Collection idList);

（2）编写测试代码

@Test
public void testSelectBatchIds(){
    // 根据id批量查询数据
    List users = this.userMapper.selectBatchIds(Arrays.asList(2L, 3L, 4L, 100L));
    for (User user : users) {
        System.out.println(user);
    }
}

3.4.3.查询单条数据——selectOne

（1）方法定义

T selectOne(@Param(Constants.WRAPPER) Wrapper queryWrapper);

（2）编写测试代码

@Test
public void testSelectOne(){
    QueryWrapper wrapper = new QueryWrapper<>();
    //查询条件
    wrapper.eq("password", "111111");
    User user = this.userMapper.selectOne(wrapper);
    System.out.println(user);
}

注：当查询的数据超过一条时（例如有4条数据），会抛出如下异常：

org.mybatis.spring.MyBatisSystemException: 
nested exception is org.apache.ibatis.exceptions.TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 4

3.4.4.查询数据条数——selectCount

（1）方法定义

Integer selectCount(@Param(Constants.WRAPPER) Wrapper queryWrapper);

（2）编写测试代码

@Test
public void testSelectCount(){
    QueryWrapper wrapper = new QueryWrapper<>();
    wrapper.gt("age", 24); // 条件：年龄大于20岁的用户
    //根据条件查询数据条数
    Integer count = this.userMapper.selectCount(wrapper);
    System.out.println("count => " + count);
}

3.4.5.查询数据列表——selectList

（1）方法定义

List selectList(@Param(Constants.WRAPPER) Wrapper queryWrapper);

（2）编写测试代码

@Test
public void testSelectList(){
    QueryWrapper wrapper = new QueryWrapper<>();
    //设置查询条件
    wrapper.like("email", "itcast");
    List users = this.userMapper.selectList(wrapper);
    for (User user : users) {
        System.out.println(user);
    }
}

3.4.6.分页查询数据——selectPage

（1）方法定义

IPage selectPage(IPage page, @Param(Constants.WRAPPER) Wrapper queryWrapper);

package com.baomidou.mybatisplus.extension.plugins.pagination;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;

import java.util.Collections;
import java.util.List;


public class Page implements IPage {

    private static final long serialVersionUID = 8545996863226528798L;

    
    private List records = Collections.emptyList();
    
    private long total = 0;
    
    private long size = 10;
    
    private long current = 1;
    
    private String[] ascs;
    
    private String[] descs;
    
    private boolean optimizeCountSql = true;
    
    private boolean isSearchCount = true;

    public Page() {
        // to do nothing
    }

    
    public Page(long current, long size) {
        this(current, size, 0);
    }

    public Page(long current, long size, long total) {
        this(current, size, total, true);
    }

    public Page(long current, long size, boolean isSearchCount) {
        this(current, size, 0, isSearchCount);
    }

    public Page(long current, long size, long total, boolean isSearchCount) {
        if (current > 1) {
            this.current = current;
        }
        this.size = size;
        this.total = total;
        this.isSearchCount = isSearchCount;
    }

    
    public boolean hasPrevious() {
        return this.current > 1;
    }

    
    public boolean hasNext() {
        return this.current < this.getPages();
    }

    @Override
    public List getRecords() {
        return this.records;
    }

    @Override
    public Page setRecords(List records) {
        this.records = records;
        return this;
    }

    @Override
    public long getTotal() {
        return this.total;
    }

    @Override
    public Page setTotal(long total) {
        this.total = total;
        return this;
    }

    @Override
    public long getSize() {
        return this.size;
    }

    @Override
    public Page setSize(long size) {
        this.size = size;
        return this;
    }

    @Override
    public long getCurrent() {
        return this.current;
    }

    @Override
    public Page setCurrent(long current) {
        this.current = current;
        return this;
    }

    @Override
    public String[] ascs() {
        return ascs;
    }

    public Page setAscs(List ascs) {
        if (CollectionUtils.isNotEmpty(ascs)) {
            this.ascs = ascs.toArray(new String[0]);
        }
        return this;
    }


    
    public Page setAsc(String... ascs) {
        this.ascs = ascs;
        return this;
    }

    @Override
    public String[] descs() {
        return descs;
    }

    public Page setDescs(List descs) {
        if (CollectionUtils.isNotEmpty(descs)) {
            this.descs = descs.toArray(new String[0]);
        }
        return this;
    }

    
    public Page setDesc(String... descs) {
        this.descs = descs;
        return this;
    }

    @Override
    public boolean optimizeCountSql() {
        return optimizeCountSql;
    }

    @Override
    public boolean isSearchCount() {
        if (total < 0) {
            return false;
        }
        return isSearchCount;
    }

    public Page setSearchCount(boolean isSearchCount) {
        this.isSearchCount = isSearchCount;
        return this;
    }

    public Page setOptimizeCountSql(boolean optimizeCountSql) {
        this.optimizeCountSql = optimizeCountSql;
        return this;
    }
}

（2）配置分页插件

package cn.itcast.mp;

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

//@Configuration:标注这是一个配置类
@Configuration
@MapperScan("cn.itcast.mp.mapper") //设置mapper接口的扫描包，也可以标注在SpringBoot启动类上
public class MybatisPlusConfig {
    
    //配置分页插件
    @Bean
    public PaginationInterceptor paginationInterceptor(){
        return new PaginationInterceptor();
    }
}

以上是在SpringBoot中的配置类中进行分页插件的配置，其实也可以在MyBatis的全局配置文件中进行配置。

（3）编写测试代码

@Test
public void testSelectPage(){
    //查询第三页，查询2条数据
    Page page = new Page<>(3,2);
    
    QueryWrapper wrapper = new QueryWrapper<>();
    //设置查询条件
    wrapper.like("email", "itcast");
    
    IPage iPage = this.userMapper.selectPage(page, wrapper);
    System.out.println("数据总条数： " + iPage.getTotal());
    System.out.println("数据总页数： " + iPage.getPages());
    System.out.println("当前页数： " + iPage.getCurrent());
    
    //当前页数的所有记录
    List records = iPage.getRecords();
    for (User record : records) {
        System.out.println(record);
    }
}

数据库中的数据如下：

查询结果如下：

4.配置

在MP中有大量的配置，其中有一部分是Mybatis原生的配置，另一部分是MP的配置，详情请见官方文档https://mp.baomidou.com/config/。

4.1.基本配置 4.1.1.configLocation

configLocation即MyBatis 全局配置文件位置，如果有单独的 MyBatis 配置，请将其路径配置到 configLocation 中。 MyBatis Configuration 的具体内容请参考MyBatis 官方文档。
（1）SpringBoot

# 指定MyBatis全局的配置文件
mybatis-plus.config-location = classpath:mybatis-config.xml

（2）SpringMVC

4.1.2.mapperLocations

mapperLocations，即MyBatis Mapper 所对应的 XML 文件位置，如果在 Mapper 中有自定义方法（XML 中有自定义实现），需要进行该配置，告诉 Mapper 所对应的 XML 文件位置。
（1）SpringBoot

# 指定Mapper.xml文件的路径
mybatis-plus.mapper-locations = classpath*:mybatis
@Bean
public MySqlInjector mySqlInjector(){
    return new MySqlInjector();
}

8.5.编写测试方法

如果继续使用userMapper来进行测试，那么要将其继承的接口改为自定义的MybaseMapper。

package cn.itcast.mp.mapper;

import cn.itcast.mp.pojo.User;

public interface UserMapper extends MybaseMapper {

}

具体的测试方法如下：

@Test
public void testFindAll(){
    List users = this.userMapper.findAll();
    for (User user : users) {
        System.out.println(user);
    }
}

结果如下：

9.自动填充功能

有些时候我们可能会有这样的需求，插入或者更新数据时，希望有些字段可以自动填充数据,比如密码、version等。在MP中提供了这样的功能，可以实现自动填充。

9.1.添加@TableField注解

例如，为User类中的password添加自动填充功能，在新增数据时有效。

//插入数据时进行填充
@TableField(fill = FieldFill.INSERT)
private String password;

此外，FieldFill提供了以下多种模式选择：

package com.baomidou.mybatisplus.annotation;


public enum FieldFill {
    
    DEFAULT,
    
    INSERT,
    
    UPDATE,
    
    INSERT_UPDATE
}

9.2.编写MymetaObjectHandler

package cn.itcast.mp.handler;

import com.baomidou.mybatisplus.core.handlers.metaObjectHandler;
import org.apache.ibatis.reflection.metaObject;
import org.springframework.stereotype.Component;

@Component
public class MymetaObjectHandler implements metaObjectHandler {
    
    @Override
    public void insertFill(metaObject metaObject) {
        // 先获取到password的值，再进行判断，如果为空，就进行填充，如果不为空，就不做处理
        Object password = getFieldValByName("password", metaObject);
        if(null == password){
           setFieldValByName("password", "888888", metaObject);
        }
    }

    
    @Override
    public void updateFill(metaObject metaObject) {

    }
}

9.3.编写测试用例

@Test
public void testInsert() {
    User user = new User();
    user.setUserName("xiaoli");
    //不设置密码
    user.setName("小李");
    user.setAge(21);
    user.setEmail("xiaoli@itcast.com");
    
    //result:数据库受影响的行数
    int result = this.userMapper.insert(user);
    System.out.println("result => " + result);
    
    //获取自增长后的id值, 自增长后的id值会回填到user对象中
    System.out.println("id => " + user.getId());
}

10.逻辑删除

开发系统时，有时候在实现功能时，删除操作需要实现逻辑删除，所谓逻辑删除就是将数据标记为删除，而并非真正的物理删除（非DELETE操作），查询时需要携带状态条件，确保被标记的数据不被查询到。这样做的目的就是避免数据被真正的删除。MP就提供了这样的功能，下面将展开介绍。

10.1.修改表结构

为tb_user表增加deleted字段，用于表示数据是否被删除，1代表删除，0代表未删除。

ALTER TABLE `tb_user`
ADD COLUMN `deleted` int(1) NULL DEFAULT 0 COMMENT '1代表删除，0代表未删除' 
AFTER `version`;

同时，也修改User实体，增加deleted属性并且添加@TableLogic注解

@TableLogic
private Integer deleted;

10.2.在application.properties中进行配置

# 删除状态的值为：1
mybatis-plus.global-config.db-config.logic-delete-value=1
# 未删除状态的值为：0
mybatis-plus.global-config.db-config.logic-not-delete-value=0

10.3.编写测试方法

@Test
public void testDeleteById(){
    // 根据id删除数据（逻辑删除）
    int result = this.userMapper.deleteById(2L);
    System.out.println("result => " + result);
}

当id为2的用户被进行了逻辑删除后，再次查找该用户时则找不到

@Test
public void testSelectById() {
    //根据id查询数据
    User user = this.userMapper.selectById(2L);
    System.out.println("result = " + user);
}

11.通用枚举

解决了繁琐的配置，让MyBatis更加方便地使用枚举属性！

11.1.修改表结构

为tb_user表增加sex字段，用于表示用户地性别，1代表男，0代表女。

ALTER TABLE `tb_user`
ADD COLUMN `sex` int(1) NULL DEFAULT 1 COMMENT '1-男，2-女' 
AFTER `deleted`;

11.2.定义枚举

package cn.itcast.mp.enums;

import com.baomidou.mybatisplus.core.enums.IEnum;

public enum SexEnum implements IEnum {

    MAN(1,"男"),
    WOMAN(2,"女");

    private int value;
    private String desc;

    SexEnum(int value, String desc) {
        this.value = value;
        this.desc = desc;
    }

    @Override
    public Integer getValue() {
        return this.value;
    }

    @Override
    public String toString() {
        return this.desc;
    }
}

11.3.在application.properties中进行配置

# 枚举包扫描
mybatis-plus.type-enums-package=cn.itcast.mp.enums

11.4.修改实体类User

在User实体类中添加SexEnum字段

//性别，枚举类型
private SexEnum sex;

11.5.编写测试方法

（1）添加测试

@Test
public void testEnum(){
    User user = new User();
    user.setUserName("xiaofang");
    user.setPassword("123456");
    user.setAge(20);
    user.setName("小芳");
    user.setEmail("xiaofang@itcast.cn");
    user.setVersion(1);
    user.setSex(SexEnum.WOMAN); //使用的是枚举
    
    // 调用AR的insert方法进行插入数据
    boolean insert = user.insert();
    System.out.println("result => " + insert);
}

（2）条件查询测试

@Test
public void testSelectBySex(){
    QueryWrapper wrapper = new QueryWrapper<>();
    wrapper.ge("sex", SexEnum.WOMAN)
            .or()
            .eq("age", 21)
            .select("id","name","age"); //指定查询的字段
    List users = this.userMapper.selectList(wrapper);
    for (User user : users) {
        System.out.println(user);
    }
}

12.代码生成器

AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper、XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。

12.1.创建工程

创建一个名为itcast-mp-generator的Maven工程

12.2.在pom.xml中导入相关依赖



    4.0.0

    
        org.springframework.boot
        spring-boot-starter-parent
        2.1.4.RELEASE
    

    cn.itcast.mp
    itcast-mp-generator
    1.0-SNAPSHOT

    
        
            org.springframework.boot
            spring-boot-starter-test
            test
        

        
        
            com.baomidou
            mybatis-plus-boot-starter
            3.1.1
        
        
            com.baomidou
            mybatis-plus-generator
            3.1.1
        
        
            org.springframework.boot
            spring-boot-starter-freemarker
        
        
        
            mysql
            mysql-connector-java
            5.1.47
        
        
            org.slf4j
            slf4j-log4j12
        
		
            org.projectlombok
            lombok
            true
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin

12.3.生成器代码

package cn.itcast.mp.generator;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.FileOutConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.TemplateConfig;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;


public class MysqlGenerator {

    
    public static String scanner(String tip) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder help = new StringBuilder();
        help.append("请输入" + tip + "：");
        System.out.println(help.toString());
        if (scanner.hasNext()) {
            String ipt = scanner.next();
            if (StringUtils.isNotEmpty(ipt)) {
                return ipt;
            }
        }
        throw new MybatisPlusException("请输入正确的" + tip + "！");
    }

    
    public static void main(String[] args) {
        // 代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        gc.setOutputDir(projectPath + "/src/main/java");
        gc.setAuthor("itcast");
        gc.setOpen(false);
        mpg.setGlobalConfig(gc);

        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://127.0.0.1:3306/mp?useUnicode=true&useSSL=false&characterEncoding=utf8");
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("123456");
        mpg.setDataSource(dsc);

        // 包配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName(scanner("模块名"));
        pc.setParent("cn.itcast.mp.generator");
        mpg.setPackageInfo(pc);

        // 自定义配置
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
                // to do nothing
            }
        };
        List focList = new ArrayList<>();
        focList.add(new FileOutConfig("/templates/mapper.xml.ftl") {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输入文件名称
                return projectPath + "/itcast-mp-generator/src/main/resources/mapper/" + pc.getModuleName()
                        + "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
            }
        });
        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);
        mpg.setTemplate(new TemplateConfig().setXml(null));

        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
//        strategy.setSuperEntityClass("com.baomidou.mybatisplus.samples.generator.common.baseEntity");
        strategy.setEntityLombokModel(true);
//        strategy.setSuperControllerClass("com.baomidou.mybatisplus.samples.generator.common.baseController");
        strategy.setInclude(scanner("表名"));
        strategy.setSuperEntityColumns("id");
        strategy.setControllerMappingHyphenStyle(true);
        strategy.setTablePrefix(pc.getModuleName() + "_");
        mpg.setStrategy(strategy);
        // 选择 freemarker 引擎需要指定如下加，注意 pom 依赖必须有！
        mpg.setTemplateEngine(new FreemarkerTemplateEngine());
        mpg.execute();
    }
}

运行上述的main方法即可自动生成代码。

13.MybatisX——快速开发插件

MybatisX 是一款基于 IDEA 的快速开发插件，其目的在于提高开发效率。

13.1.安装方法

打开 IDEA，进入 File -> Settings -> Plugins -> Browse Repositories，输入mybatisx 搜索并安装，安装之后重启IDEA即可使用该插件。

13.2.功能

（1）Java 与 XML 调回跳转；

（2）Mapper 方法自动生成 XML；

MyBatisPlus——入门介绍

Java相关栏目本月热门文章