MyBatis-Plus

2021-04-08

MyBatis-Plus

简介

　　MyBatis-Plus 是一个 Mybatis 增强版工具，在 MyBatis 上扩充了其他功能没有改变其基本功能，为了简化开发提交效率而存在。

官网文档地址：
　　https://mp.baomidou.com/guide/

MyBatis-Plus 特性：
　　https://mp.baomidou.com/guide/#%E7%89%B9%E6%80%A7

Demo：使用 SpringBoot 快速使用 MyBatis-Plus

（1）准备工作
　　需要 Java 开发环境（JDK）以及相应的开发工具（IDE）。
　　需要 maven（用来下载相关依赖的 jar 包）。
　　需要 SpringBoot。
　　可以使用 IDEA 安装一个 mybatis-plus 插件。

（2）创建一个 SpringBoot 项目。
　　方式一：去官网 https://start.spring.io/ 初始化一个，然后导入 IDE 工具即可。
　　方式二：直接使用 IDE 工具创建一个。 Spring Initializer。

（3）添加 MyBatis-Plus 依赖（mybatis-plus-boot-starter）

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.3.1.tmp</version>
</dependency>

（4）为了测试开发，此处使用 mysql 8，需要引入 mysql 相关依赖。
　　为了简化代码，引入 lombok 依赖（减少 getter、setter 等方法）。

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.18</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.10</version>
</dependency>

（5）完整依赖文件（pom.xml）

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.lyh.test</groupId>
    <artifactId>test-mybatis-plus</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>test-mybatis-plus</name>
    <description>测试 -- 测试 MyBatis-Plus 功能</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.1.tmp</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.18</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

（6）使用一个表进行测试。

　　仅供参考，可以定义创建时间、修改时间等字段。

DROP DATABASE IF EXISTS testMyBatisPlus;

CREATE DATABASE testMyBatisPlus;

USE testMyBatisPlus;

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)
);

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');

（7）在 application.yml 文件中配置 mysql 数据源信息。

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/testMyBatisPlus?useUnicode=true&characterEncoding=utf8

（8）编写表对应的实体类。

package entity;

import lombok.Data;

@Data
public class User {
    private Long id;
    private String name;
    private int age;
    private String email;
}

（9）编写操作实体类的 Mapper 类。
　　直接继承 BaseMapper，这是 mybatis-plus 封装好的类。

package mapper;

import bean.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface UserMapper extends BaseMapper<User> {
}

（10）实体类、Mapper 类都写好了，就可以使用了。
　　Step1：先得在启动类里扫描 Mapper 类，即添加 @MapperScan 注解

package com.lyh.test.testmybatisplus;

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

@MapperScan("mapper")
@SpringBootApplication
public class TestMybatisPlusApplication {

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

}

　　Step2：写一个测试类测试一下。

package com.lyh.test.testmybatisplus;

import bean.User;
import 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
class TestMybatisPlusApplicationTests {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelect() {
        System.out.println(("----- selectAll method test ------"));
        List<User> userList = userMapper.selectList(null);
        for(User user:userList) {
            System.out.println(user);
        }
    }
}

（11）总结：
　　通过以上简单操作，就能对 user 表进行 CRUD 操作，不需要去编写 xml 文件。
注：
　　若遇到 @Autowired 标记的变量出现红色下划线，但是不影响正常运行。

　　可以进入 Settings，找到 Inspection，并选择其中的 Spring Core -> Code -> Autowiring for Bean Class,将 Error 改为 Warning，即可。

创建数据库表

创建user表

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)
);
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');

注意：真实开发中往往都会有这四个字段，version（乐观锁）、deleted（逻辑删除）、gmt_create（创建时间）、gmt_modified（修改时间）

导入依赖

<!-- 数据库驱动 -->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
</dependency>
<!-- lombok -->
<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
</dependency>
<!-- mybatis-plus 是个人团队开发，并非官方的！-->
<dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>mybatis-plus-boot-starter</artifactId>
  <version>3.0.5</version>
</dependency>

注意：尽量不要同时导入 mybatis 和 mybatis-plus！避免版本的差异造成无法预知的问题。

连接数据库

创建application.yml

spring:
  profiles:
    active: dev
  datasource:
	# 驱动不同 mysql 5  com.mysql.jdbc.Driver
	# mysql 8  com.mysql.cj.jdbc.Driver、需要增加时区的配置serverTimezone=GMT%2B8
	#mysql的驱动包在6.0以上就需要加cj
    url: jdbc:mysql://localhost:3306/mybatis_plus?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root

业务代码

实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
  private Long id;
  private String name;
  private Integer age;
  private String email;
}

mapper接口

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.kuang.pojo.User;
import org.springframework.stereotype.Repository;

// 在对应的Mapper上面继承基本的类 BaseMapper
@Repository // 代表持久层
public interface UserMapper extends BaseMapper<User> {
  // 所有的CRUD操作都已经编写完成了
}

注意：我们需要在主启动类Application上去扫描我们的mapper包下的所有接口 @MapperScan(“com.kwhua.mapper”)

测试

@SpringBootTest
class MybatisPlusApplicationTests {
    
  // 继承了BaseMapper，所有的方法都来自父类
  // 我们也可以编写自己的扩展方法！
  @Autowired
  private UserMapper userMapper;
    
  @Test
  void contextLoads() {
    // 参数是一个 Wrapper ，条件构造器，这里我们先设置条件为空，查询所有。
    List<User> users = userMapper.selectList(null);
    users.forEach(System.out::println);
 }
    
}

所有数据输出

配置日志

我们所有的sql现在是不可见的，我们希望知道它是怎么执行的，所有我们要配置日志的输出 application.yml文件添加日志配置

#配置日志
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl  //这种配置仅在控制台打印出所有：查询语句，参数，结果类型，结果，总影响行数
    log-impl: org.apache.ibatis.logging.slf4j.Slf4jImpl   //这种配置可以存到文件中，只会打印：查询语句，参数，总影响行数
    //使用logback日志配置后，slf4j类下（除了上述2个）其他貌似都不能成功

查看执行sql的日志信息

Mybatis-plus的mapper层CRUD

service层：需继承 IService<实体类>

mapper层：需继承BaseMapper<实体类>

model层：需继承Model<实体类>，且对应mapper层需继承BaseMapper<实体类>，然后就可以让model层调用CRUD方法。 CRUD方法与mapper层方法一样

插入操作

// 测试插入
    @Test
    public void testInsert(){
        User user = new User();
        user.setName("kwhua_mybatis-plus_insertTest");
        user.setAge(15);
        user.setEmail("310697723@qq.com");
        int result = userMapper.insert(user); // 帮我们自动生成id
        System.out.println(result); // 受影响的行数
        System.out.println(user); // 看到id会自动填充。
	}

看到id会自动填充。数据库插入的id的默认值为：全局的唯一id

主键生成策略

1）主键自增

1、实体类字段上 @TableId(type = IdType.AUTO)

2、数据库id字段设置为自增！

3、再次测试（可以看到id值比上次插入的大1）id的生成策略源码解释

public enum IdType {
  AUTO(0), // 数据库id自增
  NONE(1), // 未设置主键
  INPUT(2), // 手动输入
  ID_WORKER(3), // 默认的方式,全局唯一id
  UUID(4), // 全局唯一id uuid
  ID_WORKER_STR(5); //ID_WORKER 字符串表示法
}

更新操作

@Test
public void testUpdate(){
        User user = new User();
        // 通过条件自动拼接动态sql
        user.setId(1302223874217295874L);
        user.setName("kwhua_mybatis-plus_updateTest");
        user.setAge(20);
        // 注意：updateById 但是参数是一个对象！
        int i = userMapper.updateById(user);
        System.out.println(i);
    }

自动填充

创建时间、修改时间！这两个字段操作都是自动化完成的，我们不希望手动更新！

阿里巴巴开发手册：所有的数据库表都要配置上gmt_create、gmt_modified！而且需要自动化！

方式一：数据库级别（工作中一般不用）

1、在表中新增字段 gmt_create, gmt_modified

2、把实体类同步

1 2	private Date gmtCreate; private Date gmtModified;

3、再次查看

方式二：代码级别

1、删除数据库的默认值、更新操作！

2、实体类字段属性上需要增加注解

// 字段添加填充内容
@TableField(fill = FieldFill.INSERT)
private Date gmt_create;

@TableField(fill = FieldFill.INSERT_UPDATE)
private Date gmt_modified;

3、编写处理器来处理这个注解即可！

@Slf4j
@Component // 一定不要忘记把处理器加到IOC容器中！
public class MyMetaObjectHandler implements MetaObjectHandler {
    // 插入时的填充策略
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill.....");
        // setFieldValByName(String fieldName, Object fieldVal, MetaObject metaObject
        this.setFieldValByName("gmt_create",new Date(),metaObject);
        this.setFieldValByName("gmt_modified",new Date(),metaObject);
    }

    // 更新时的填充策略
    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("start update fill.....");
        this.setFieldValByName("gmt_modified",new Date(),metaObject);
    }
}

4、测试插入和更新，检查时间变化。

乐观锁

乐观锁 : 顾名思义，十分乐观，它总是认为不会出现问题，无论干什么不去上锁！如果出现了问题，再次更新值测试

悲观锁：顾名思义，十分悲观，它总是认为总是出现问题，无论干什么都会上锁！再去操作！

乐观锁实现方式：

取出记录时，获取当前version 。更新时，带上这个version 执行更新时， set version = newVersion where version = oldVersion 如果version不对，就更新失败

乐观锁：

1、先查询，获得版本号 version = 1

-- A
update user set name = "kwhua", version = version + 1
where id = 2 and version = 1
-- B 线程抢先完成，这个时候 version = 2，会导致 A 修改失败！
update user set name = "kwhua", version = version + 1
where id = 2 and version = 1

乐观锁测试

1、给数据库中增加version字段！

2、实体类加对应的字段

1 2	@Version //乐观锁Version注解 private Integer version;

3、注册组件

// 扫描我们的 mapper 文件夹
@MapperScan("com.kwhua.mapper")
@EnableTransactionManagement
@Configuration // 配置类
public class MyBatisPlusConfig {
    // 注册乐观锁插件
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
}

4、测试

// 测试乐观锁成功！
@Test
public void testOptimisticLocker(){
        // 1、查询用户信息
        User user = userMapper.selectById(1L);
        // 2、修改用户信息
        user.setName("kwhua");
        user.setEmail("123456@qq.com");
        // 3、执行更新操作
        userMapper.updateById(user);
    }

version字段已经由1变成了2

// 测试乐观锁失败！多线程下
    @Test
    public void testOptimisticLocker2(){

        // 线程 1
        User user = userMapper.selectById(1L);
        user.setName("kwhua111");
        user.setEmail("123456@qq.com");

        // 模拟另外一个线程执行了插队操作
        User user2 = userMapper.selectById(1L);
        user2.setName("kwhua222");
        user2.setEmail("123456@qq.com");
        userMapper.updateById(user2);

        // 自旋锁来多次尝试提交！
        userMapper.updateById(user); // 如果没有乐观锁就会覆盖插队线程的值！
    }

可以看到线程1执行更新失败

查询操作

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

    // 测试批量查询！
    @Test
    public void testSelectByBatchId(){
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
        users.forEach(System.out::println);
    }

    // 按条件查询之一使用map操作
    @Test
    public void testSelectByBatchIds(){
        HashMap<String, Object> map = new HashMap<>();
        // 自定义要查询
        map.put("name","kwhua");
        map.put("age",15);

        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

分页查询

官方文档说明：https://mp.baomidou.com/guide/page.html

mybatis的一级缓存和二级缓存

一级缓存不跨sqlsession，不同的sqlsession中的一级缓存不同，每次查询的时候先去一级缓存中查，若没有再到数据库查询，然后存入一级缓存，若执行了commit操作，一级缓存则被清空，设计成会清空是为了防止脏读，一级缓存不需要在.xml中进行设置，默认开启

正式开发时，事务由spring管理，发生在service中，一个service中包括很多mapper方法的调用，当事务开启时，创建一个sqlsession，事务结束时，关闭sqlsession，所有一个service可以使用1级缓存

二级缓存，默认不开启，每一个namespace有一个二级缓存区域，如果两个mapper的namespace相同，它们的二级缓存区域是同一个。执行commit也会清空对应的二级缓存

二级缓存的开启，在sqlMapConfig.xml和对应的mapper.xml中都需要进行配置

yml文件配置

1
2
3

mybatis-plus:
	configuration:
		cache-enabled: true

在mapper.xml中的配置，写一个标签就可以了，标签里的参数需要时再配置

禁用/开启二级缓存

二级缓存的存储介质不固定，可以是内存也可以是硬盘，或者是远程服务器，所以要求pojo实现序列化接口

session不关闭，数据写不到二级缓存区域

项目里分页实现的代码：

1.先配置文件

//创建一个自定义的配置类 MybatisPlusConfig
@Configuration
public class MybatisPlusConfig {

    /**
     * 旧版的分页插件,一缓和二缓遵循mybatis的规则,需要设置 MybatisConfiguration#useDeprecatedExecutor = false 避免缓存出现问题
     */
    @Bean
    public PaginationInterceptor mybatisPlusInterceptor() {
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
		//paginationInterceptor.setOverflow(false);
        // 设置最大单页限制数量，默认 500 条，-1 不受限制 设置20条
        //paginationInterceptor.setLimit(20);
        // 开启 count 的 join 优化,只针对部分 left join
        paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true));
        return paginationInterceptor;
    }

//    @Bean
//    public ConfigurationCustomizer configurationCustomizer() {
//        return configuration -> configuration.setUseDeprecatedExecutor(false);
//    }
    
    /**
     *新版分页
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
        return interceptor;
    }
    
}

2.再直接使用 controller层

1
2
3

public R getRechargeRecord(@RequestParam Integer page) throws UserNotExistException {
        return accountService.getRechargeRecord(page);
}

3.service层

public R getRechargeRecord(Integer currentPage) throws UserNotExistException {
        UserDTO userDTO = userUtil.getCurrentUser();
    
  // 参数一：当前页
  // 参数二：页面大小
  //Page<User> page = new Page<>(2,5);
  //userMapper.selectPage(page,null);
  //page.getRecords().forEach(System.out::println);
  //System.out.println(page.getTotal());

    
        IPage<TransactionDTO> page = new Page<TransactionDTO>(currentPage, 10) {
            private Integer companyId = userDTO.getCompanyId();
        };
        List<TransactionDTO> transactionDTOList = productTransactionMapper.listAccountTransactionByCompanyId(page);
    
        OrderListVO orderListVO = new OrderListVO();
        orderListVO.setTransactionDTOList(transactionDTOList);
        orderListVO.setTotal(page.getTotal());
        log.info("充值记录是：{}", orderListVO);
        return R.restResult(orderListVO, ResApiSuccessCode.SUCCESS);
    }

4.定义的vo

@Data
public class OrderListVO {

    @ApiModelProperty(value = "总记录数")
    Long total;

    @ApiModelProperty(value = "TransactionDTO集合")
    List<TransactionDTO> transactionDTOList;

}

5.定义的mapper和xml代码

List<TransactionDTO> listAccountTransactionByCompanyId(IPage<TransactionDTO> page);

    <select id="listAccountTransactionByCompanyId" resultType="com.swx.business.dto.TransactionDTO">
        SELECT t.order_sn,
               t.payment_status,
               t.create_time,
               t.completion_time,
               t.amount,
               t.payment_type,
               u.name
        FROM product_transaction t
                 LEFT JOIN user u ON t.user_id = u.id
        WHERE t.company_id = #{companyId}
          AND t.addr_id IS NULL
        ORDER BY t.create_time DESC
    </select>

删除操作

物理删除

// 测试删除
    @Test
    public void testDeleteById(){
        userMapper.deleteById(1L);
    }

    // 通过id批量删除
    @Test
    public void testDeleteBatchId(){
        userMapper.deleteBatchIds(Arrays.asList(2L,3L));
    }

    // 通过map删除
    @Test
    public void testDeleteMap(){
        HashMap<String, Object> map = new HashMap<>();
        map.put("name","kwhua");
        userMapper.deleteByMap(map);
    }

逻辑删除

物理删除：从数据库中直接移除

逻辑删除：在数据库中没有被移除，而是通过一个变量来让它失效！deleted = 0 => deleted = 1 管理员可以查看被删除的记录！防止数据的丢失，类似于回收站！

说明:

只对自动注入的sql起效:

插入: 不作限制
查找: 追加where条件过滤掉已删除数据,且使用 wrapper.entity 生成的where条件会忽略该字段
更新: 追加where条件防止更新到已删除数据,且使用 wrapper.entity 生成的where条件会忽略该字段
删除: 转变为更新

例如:

删除: update user set deleted=1 where id = 1 and deleted=0
查找: select id,name,deleted from user where deleted=0

字段类型支持说明:

支持所有数据类型(推荐使用 Integer,Boolean,LocalDateTime)
如果数据库字段使用datetime,逻辑未删除值和已删除值支持配置为字符串null,另一个值支持配置为函数来获取值如now()

附录:

逻辑删除是为了方便数据恢复和保护数据本身价值等等的一种方案，但实际就是删除。
如果你需要频繁查出来看就不应使用逻辑删除，而是以一个状态去表示。

使用方法：

步骤1: 在数据表中增加一个 deleted 字段

步骤2: 实体类中加上@TableLogic注解

1 2	@TableLogic //逻辑删除 private Integer deleted;

步骤3：mapper.xml加一个属性（可选）

步骤4：配置删除组件

// 逻辑删除组件
    @Bean
    public ISqlInjector sqlInjector() {
        return new LogicSqlInjector();
    }

配置com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig

例: application.yml

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: flag  # 全局逻辑删除的实体字段名(since 3.3.0,配置后可以忽略不配置步骤2)
      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

步骤5：测试删除

删除后测试查询：字段值从0修改成了1

常见问题:

如何 insert ?

字段在数据库定义默认值(推荐)

insert 前自己 set 值

使用自动填充功能

删除接口自动填充功能失效

使用 update 方法并: UpdateWrapper.set(column, value)(推荐)

使用 update 方法并: UpdateWrapper.setSql("column=value")

使用Sql注入器注入com.baomidou.mybatisplus.extension.injector.methods.LogicDeleteByIdWithFill并使用(推荐)

截断表

清空某个记录表的数据时，可以用到截断：truncate 这样会使id从1开始增长，但是会使数据全部丢失，binlog日志也没有记录

网上查到的利用mybatis-plus的方法：（自己的项目一直报错）

1.mapper接口里

public interface userInfoMapper extends BaseMapper<UserInfo> {
//清空指定表
    @Update("truncate table tb_user")
    void deleteUserTemp();
}

2.mapper的xml文件里

public interface userInfoMapper extends BaseMapper<UserInfo> {
//清空指定表
    void truncateTable();
}


<update id="truncateTable">
    truncate table tableName
</update>

3.直接使用自带的remove接口，同时使用QueryWrapper参数

1	userInfoTempService.remove(new QueryWrapper<>())

自己的项目里成功的方法：可以调用 helmetOnOffMapper.deleteTable(“helmet_on_off”); 更改表名删除对应表

public interface HelmetOnOffMapper extends BaseMapper<HelmetOnOff> {

    @Update("truncate table ${tableName}")
    void deleteTable(String tableName) ;
}

性能分析插件

作用：性能分析拦截器，用于输出每条 SQL 语句及其执行时间

MP也提供性能分析插件，如果超过这个时间就停止运行！

1、导入插件

/**
   * SQL执行效率插件
   */
  @Bean
  @Profile({"dev","test"})// 设置 dev test 环境开启，保证我们的效率
  public PerformanceInterceptor performanceInterceptor() {
      PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
      performanceInterceptor.setMaxTime(100); //ms 设置sql执行的最大时间，如果超过了则不执行
      performanceInterceptor.setFormat(true);
      return performanceInterceptor;
  }

条件构造器(Wrapper)

isNotNull ：非空

ge：大于等于 le：小于等于

gt：大于 lt：小于

eq：等于（用的最多）

例子：

@Test
void contextLoads() {
        // 查询name不为空的用户，并且邮箱不为空的用户，年龄大于等于12
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        		wrappe.isNotNull("name") //不为空
                .isNotNull("email")
                .ge("age",18);
        userMapper.selectList(wrapper).forEach(System.out::println); 
}

@Test
void test2(){
        // 查询名字kwhua
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("name","kwhua");
        User user = userMapper.selectOne(wrapper); // 查询一个数据用selectOne，查询多个结果使用List 或者 Map
        System.out.println(user);
}

代码自动生成器

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

1.添加依赖

MyBatisPlus 在3.0.3版本之前使用代码生成器因为存在默认依赖，所以不需要手动添加其他的依赖

项目中使用的是3.4.0的版本，所以需要手动添加依赖

<!-- mybatis-plus begain =================================== -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>${mybatis-plus-boot-starter.version}</version>
</dependency>
<!-- mybatis-plus end -->

<!-- mybatis-plus 代码构造器的依赖 -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.3.1.tmp</version>
</dependency>
<!-- 添加 模板引擎 依赖 -->
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.2</version>
</dependency>

MP默认将Velocity作为模板引擎，同时也支持Freemarker、Beetl

2.新建一个java类，在类中写方法

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;

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

        // Step2：全局配置
        GlobalConfig gc = new GlobalConfig();
        // 填写代码生成的目录(需要修改)
        String projectPath = "C:\\Users\\swx\\Desktop\\yxtl";
        // 拼接出代码最终输出的目录
        gc.setOutputDir(projectPath + "/src/main/java");
        // 配置开发者信息（可选）（需要修改）
        gc.setAuthor("swx");
        // 配置是否打开目录，false 为不打开（可选） false/true好像都没有影响
        gc.setOpen(false);
        // 实体属性 Swagger2 注解，添加 Swagger 依赖，开启 Swagger2 模式（可选）
        gc.setSwagger2(true);
        // 重新生成文件时是否覆盖，false 表示不覆盖（可选） false/true好像都没有影响
        gc.setFileOverride(false);
        // 不需要ActiveRecord(实体类继承Model)特性的请改为false
        gc.setActiveRecord(false);
        // XML 二级缓存
        gc.setEnableCache(false);
        // XML ResultMap   没有这个的话mapper.xml里没有表结构
        gc.setBaseResultMap(true);
        // XML ColumnList 
        //gc.setBaseColumnList(true);  多一个查询配置语句
        // 配置主键生成策略（可选） 
        gc.setIdType(IdType.AUTO);
        // 配置日期类型（可选）
        gc.setDateType(DateType.ONLY_DATE);
        // 自定义文件命名，注意 %s 会自动填充表实体属性！
        // 默认service接口名IXXXService 自定义指定之后就不会用I开头了
        gc.setControllerName("%sController");
        gc.setServiceName("%sService");
    	gc.setServiceImplName("%sServiceImpl");
        gc.setMapperName("%sMapper");
        gc.setXmlName("%sMapper");
        mpg.setGlobalConfig(gc);

		// Step3：数据源配置（需要修改）
        DataSourceConfig dsc = new DataSourceConfig();
        /* //需要自定义将表字段类型转换时可选填（比如将tinyint转Integer，将Data转LocalDateTime）
			dsc.setTypeConvert(new MySqlTypeConvert() {
            @Override
            public DbColumnType processTypeConvert(GlobalConfig globalConfig, String fieldType) {
                System.out.println("转换类型：" + fieldType);
                //tinyint转换成Integer
                if (fieldType.toLowerCase().contains("tinyint")) {
                    return DbColumnType.INTEGER;
                }
                //将数据库中datetime转换成LocalDateTime
                if (fieldType.toLowerCase().contains("datetime")) {
                    return DbColumnType.LOCAL_DATE_TIME;
                }
                return (DbColumnType) super.processTypeConvert(globalConfig, fieldType);
            }
        });*/ 
        // 配置数据库 url 地址
        dsc.setUrl("jdbc:mysql://xx.xxx.xxx.xx:3306/数据库名?useUnicode=yes&characterEncoding=UTF-8&useSSL=true&serverTimezone=GMT%2B8");
        // 可以直接在 url 中指定数据库名   上面的url中其实已经指定了数据库名
        // dsc.setSchemaName("testMyBatisPlus"); 
        // 配置数据库驱动  高版本用这个带cj的   mysql5.6以下的驱动用com.mysql.jdbc.Driver
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        // 配置数据库连接用户名
        dsc.setUsername("root");
        // 配置数据库连接密码
        dsc.setPassword("root");
        //数据库类型为mysql   加不加没啥区别，url中都有mysql了
        //dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);

        // Step:4：包的属性配置
        PackageConfig pc = new PackageConfig();
        // 配置父包名（需要修改）
        pc.setParent("com.yxtl.business");
        // 配置模块名（需要修改）  生成的文件的上级文件夹
        pc.setModuleName("api");
        // 配置 entity 包名
        pc.setEntity("entity");
        // 配置 mapper 包名
        pc.setMapper("mapper");
		//配置 service 包名
   		pc.setService("service");
        //配置controller包名
   		pc.setController("controller");
        mpg.setPackageInfo(pc);

        // Step5：策略配置（数据库表配置）
        StrategyConfig strategy = new StrategyConfig();
        // 指定表名（可以同时操作多个表，使用 , 隔开）（需要修改）  参数可以为string字符串。也可以为string的字符串数组
        String str1 = "admin,company,product,user,vip";
        String[] s = str1.split(",");
        strategy.setInclude(s);
        // 排除生成的表
        //strategy.setExclude(new String[]{"test"}); 
        // 配置数据表与实体类名之间映射的策略   下划线转驼峰
        strategy.setNaming(NamingStrategy.underline_to_camel);
        // 配置数据表的字段与实体类的属性名之间映射的策略
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        // 配置 lombok 模式
        strategy.setEntityLombokModel(true);
        // 配置驼峰转连字符   controller层的url带连字符
        strategy.setControllerMappingHyphenStyle(true);
         //自动转下划线，比如localhost:8080/hello_id_2
    	//strategy.setControllerMappingHyphenStyle(true); 
        // 配置 rest 风格的控制器（@RestController）
        strategy.setRestControllerStyle(true);

		// 配置表前缀，生成实体时去除表前缀
		// 假如表名为 test_mybatis_plus_user，模块名为 test_mybatis_plus，去除前缀后剩下为 user。
		//strategy.setTablePrefix(pc.getModuleName() + "_"); 
        //strategy.setTablePrefix(new String[] { "tlog_", "tsys_" });// 此处可以修改为您的表前缀  
        //根据你的表名来建对应的类名，如果你的表名没有下划线，比如test，那么你就可以取消这一步
    	//strategy.setTablePrefix("t_");
                          
      // strategy.setCapitalMode(true);// 全局大写命名 ORACLE 注意    
      // 自定义实体父类  
      // strategy.setSuperEntityClass("com.baomidou.demo.TestEntity");  
      // 自定义实体，公共字段  
      // strategy.setSuperEntityColumns(new String[] { "test_id", "age" });  
      // 自定义 mapper 父类  
      // strategy.setSuperMapperClass("com.baomidou.demo.TestMapper");  
      // 自定义 service 父类  
      // strategy.setSuperServiceClass("com.baomidou.demo.TestService");  
      // 自定义 service 实现类父类  
      // strategy.setSuperServiceImplClass("com.baomidou.demo.TestServiceImpl");  
      // 自定义 controller 父类  
      // strategy.setSuperControllerClass("com.baomidou.demo.TestController");  
      // 【实体】是否生成字段常量（默认 false）  
      // public static final String ID = "test_id";  
      // strategy.setEntityColumnConstant(true);  
      // 【实体】是否为构建者模型（默认 false）  
      // public User setName(String name) {this.name = name; return this;}  
      // strategy.setEntityBuilderModel(true);   
                           
        
      //strategy.setLogicDeleteFieldName("deleted");
    // 自动填充配置
    //TableFill gmtCreate = new TableFill("gmt_create", FieldFill.INSERT);
    //TableFill gmtModified = new TableFill("gmt_modified",FieldFill.INSERT_UPDATE);
    //ArrayList<TableFill> tableFills = new ArrayList<>();
    //tableFills.add(gmtCreate);
    //tableFills.add(gmtModified);
    //strategy.setTableFillList(tableFills);
    // 乐观锁
    //strategy.setVersionFieldName("version");
                       
        mpg.setStrategy(strategy);

        // Step6：执行代码生成操作
        mpg.execute();
    }
}                           
                           
    //上述代码即可自动生成成功  下面是一些额外的配置  未测试                     
      // 注入自定义配置，可以在 VM 中使用 cfg.abc 【可无】  
      InjectionConfig cfg = new InjectionConfig() {  
          @Override  
          public void initMap() {  
              Map<String, Object> map = new HashMap<String, Object>();  
              map.put("abc", this.getConfig().getGlobalConfig().getAuthor() + "-mp");  
              this.setMap(map);  
          }  
      };  

      // 自定义 xxList.jsp 生成  
      List<FileOutConfig> focList = new ArrayList<FileOutConfig>();  
      focList.add(new FileOutConfig("/template/list.jsp.vm") {  
          @Override  
          public String outputFile(TableInfo tableInfo) {  
              // 自定义输入文件名称  
              return "D://my_" + tableInfo.getEntityName() + ".jsp";  
          }  
      });  
      cfg.setFileOutConfigList(focList);  
      mpg.setCfg(cfg);  

   	  // 调整 xml 生成目录演示  
      focList.add(new FileOutConfig("/templates/mapper.xml.vm") {  
           @Override  
           public String outputFile(TableInfo tableInfo) {  
               return "/develop/code/xml/" + tableInfo.getEntityName() + ".xml";  
           }  
       });  
       cfg.setFileOutConfigList(focList);  
       mpg.setCfg(cfg);  

       // 关闭默认 xml 生成，调整生成 至 根目录  
       TemplateConfig tc = new TemplateConfig();  
       tc.setXml(null);  
       mpg.setTemplate(tc);  
       
       // 自定义模板配置，可以 copy 源码 mybatis-plus/src/main/resources/templates 下面内容修改，  
       // 放置自己项目的 src/main/resources/templates 目录下, 默认名称一下可以不配置，也可以自定义模板名称  
       // TemplateConfig tc = new TemplateConfig();  
       // tc.setController("...");  
       // tc.setEntity("...");  
       // tc.setMapper("...");  
       // tc.setXml("...");  
       // tc.setService("...");  
       // tc.setServiceImpl("...");  

   // 如上任何一个模块如果设置 空 OR Null 将不生成该模块。  
       // mpg.setTemplate(tc);  

       // 执行生成  
       mpg.execute();  
       
       // 打印注入设置【可无】  
       System.err.println(mpg.getCfg().getMap().get("abc"));     


**放在配置策略前，可以设置生成的文件**
     // 自定义配置
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
            }
        };

        // 模板引擎是 freemarker
        // 自定义controller的代码模板
        // 如果模板引擎是 velocity
        // String templatePath = "/templates/mapper.xml.vm";
        String templatePath = "/templates/mapper.xml.ftl";
        // 自定义输出配置
        List<FileOutConfig> focList = new ArrayList<>();

        // 自定义配置会被优先输出,配置mapper.xml
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
               /* return projectPath + "/src/main/resources/mappers/" + pc.getModuleName()
                        + "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;*/
                //根据自己的位置修改
                return projectPath + "/boot-dao/src/main/resources/mappers/" +tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
            }
        });

        //控制层
        templatePath = "/templates/controller.java.ftl";
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 + pc.getModuleName()
                String expand = projectPath + "/boot-web/src/main/java/com/example/" + "controller";
                String entityFile = String.format((expand + File.separator + "%s" + ".java"), tableInfo.getControllerName());
                return entityFile;
            }
        });

        //业务层
        templatePath = "/templates/service.java.ftl";
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 + pc.getModuleName()
                String expand = projectPath + "/boot-service/src/main/java/com/example/" + "service";
                String entityFile = String.format((expand + File.separator + "%s" + ".java"), tableInfo.getServiceName());
                return entityFile;
            }
        });
        templatePath = "/templates/serviceImpl.java.ftl";
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 + pc.getModuleName()
                String expand = projectPath + "/boot-service/src/main/java/com/example/" + "service/impl";
                String entityFile = String.format((expand + File.separator + "%s" + ".java"), tableInfo.getServiceImplName());
                return entityFile;
            }
        });

        //数据层
        templatePath = "/templates/mapper.java.ftl";
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 + pc.getModuleName()
                String expand = projectPath + "/boot-dao/src/main/java/com/example/"+"mapper";
                String entityFile = String.format((expand + File.separator + "%s" + ".java"), tableInfo.getMapperName());
                return entityFile;
            }
        });

        //数据层
        templatePath = "/templates/entity.java.ftl";
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 + pc.getModuleName()
                String expand = projectPath + "/boot-dao/src/main/java/com/example/"+"entity";
                String entityFile = String.format((expand + File.separator + "%s" + ".java"), tableInfo.getEntityName());
                return entityFile;
            }
        });

        /*
        cfg.setFileCreate(new IFileCreate() {
            @Override
            public boolean isCreate(ConfigBuilder configBuilder, FileType fileType, String filePath) {
                // 判断自定义文件夹是否需要创建
                checkDir("调用默认方法创建的目录");
                return false;
            }
        });
        */
        mpg.setPackageInfo(pc);
        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);

        // 配置模板
        TemplateConfig templateConfig = new TemplateConfig();

        // 配置自定义输出模板
        //指定自定义模板路径，注意不要带上.ftl/.vm, 会根据使用的模板引擎自动识别
//        templateConfig.setEntity("templates/1.java");
        // templateConfig.setService();
         templateConfig.setController(null);
        //此处设置为null，就不会再java下创建xml的文件夹了
        templateConfig.setXml(null);
        mpg.setTemplate(templateConfig);

3.执行主方法即可生成对应代码

注：

1.上述方法自动生成的mapper类里没有mapper注入，需要在application的入口方法所在的类上加 @MapperScan("mapper所在的包")

2.上述方法也会将数据库内的视图表生成，注意不用时可以删除

扩展：这种全局性的注解一般都加在Application类的上面。

3.在使用mybatis-generator时发现数据库类型为tinyint(1)时，映射生成的字段为Boolean类型，是由于tinyint(1)时默认为Boolean型，所以便将tinyint类型设置为tinyint(4)。但是情况是映射过来后的数据类型为byte型。

所以需要进行手动配置相关的类型转换组件，使用 Integer 作为tinyint的Java类型

tinyint(1) 转换成数字类型而不是布尔类型
tinyint(n) n>1 转换成 Integer 而非 Byte

生成的实体类的注解的备注：

注解说明	值	描述
表名注解 @TableName com.baomidou.mybatisplus.annotations.TableName	value resultMap	表名（默认空） xml 字段映射 resultMap ID
主键注解 @TableId com.baomidou.mybatisplus.annotations.TableId	value type	字段值（驼峰命名方式，该值可无）主键 ID 策略类型（默认 INPUT ，全局开启的是 ID_WORKER ）暂不支持组合主键
字段注解 @TableField com.baomidou.mybatisplus.annotations.TableField	value el exist strategy	字段值（驼峰命名方式，该值可无）详看注释说明是否为数据库表字段（默认 true 存在，false 不存在）字段验证（默认非 null 判断，查看 com.baomidou.mybatisplus.enums.FieldStrategy ）
序列主键策略注解 @KeySequence com.baomidou.mybatisplus.annotations.KeySequence	value clazz	序列名 id的类型
乐观锁标记注解 @Version com.baomidou.mybatisplus.annotations.Version

主键填充策略 TableId

IdType.AUTO ———-数据库ID自增
IdType.INPUT ———-用户输入ID
IdType.ID_WORKER———- 全局唯一ID，内容为空自动填充（默认配置）这是MP在Sequence的基础上进行部分优化，用于产生全局唯一ID
IdType.UUID ———-全局唯一ID，内容为空自动填充

字段填充策略 FieldFill
DEFAULT ———-默认不处理
INSERT ———-插入填充字段
UPDATE ———-更新填充字段
INSERT_UPDATE ———-插入和更新填充字段

在MP中，我们建议数据库表名采用下划线命名方式，而表字段名采用驼峰命名方式。

这么做的原因是为了避免在对应实体类时产生的性能损耗，这样字段不用做映射就能直接和实体类对应。当然如果项目里不用考虑这点性能损耗，那么你采用下滑线也是没问题的，只需要在生成代码时配置dbColumnUnderline属性就可以。

统一返回结果集

com.baomidou.mybatisplus.extension.api

统一返回结果集:R

二、Mybatis-Plus 常用操作

1、配置日志

1 2	【参考地址（两种方式配置日志）】 https://blog.csdn.net/dfBeautifulLive/article/details/100700365

　　想要查看执行的 sql 语句，可以在 yml 文件中添加配置信息，如下。

1
2
3

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

　　如下图所示：执行时会打印出 sql 语句。

2、简单认识一下常用注解

【@TableName 】
    @TableName               用于定义表名
注：
    常用属性：
        value                用于定义表名

【@TableId】
    @TableId                 用于定义表的主键
注：
    常用属性：
        value           用于定义主键字段名
        type            用于定义主键类型（主键策略 IdType）

   主键策略：
      IdType.AUTO          主键自增，系统分配，不需要手动输入
      IdType.NONE          未设置主键
      IdType.INPUT         需要自己输入 主键值。
      IdType.ASSIGN_ID     系统分配 ID，用于数值型数据（Long，对应 mysql 中 BIGINT 类型）。
      IdType.ASSIGN_UUID   系统分配 UUID，用于字符串型数据（String，对应 mysql 中 varchar(32) 类型）。

【@TableField】  
    @TableField            用于定义表的非主键字段。
注：
    常用属性：
        value                用于定义非主键字段名
        exist                用于指明是否为数据表的字段， true 表示是，false 为不是。
        fill                 用于指定字段填充策略（FieldFill）。
        
    字段填充策略：（一般用于填充 创建时间、修改时间等字段）
        FieldFill.DEFAULT         默认不填充
        FieldFill.INSERT          插入时填充
        FieldFill.UPDATE          更新时填充
        FieldFill.INSERT_UPDATE   插入、更新时填充。

【@TableLogic】
    @TableLogic           用于定义表的字段进行逻辑删除（非物理删除）
注：
    常用属性：
        value            用于定义未删除时字段的值
        delval           用于定义删除时字段的值
        
【@Version】
    @Version             用于字段实现乐观锁

4、自动填充数据功能

（1）简介
　　添加、修改数据时，每次都会使用相同的方式进行填充。比如数据的创建时间、修改时间等。
　　Mybatis-plus 支持自动填充这些字段的数据。

　　给之前的数据表新增两个字段：创建时间、修改时间。

CREATE TABLE test_mybatis_plus_user
(
    id BIGINT 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 '邮箱',
    create_time timestamp NULL DEFAULT NULL COMMENT '创建时间',
    update_time timestamp NULL DEFAULT NULL COMMENT '最后修改时间', 
    PRIMARY KEY (id)
);

并使用代码生成器生成代码。

（2）未使用自动填充时
　　未使用自动填充时，每次添加、修改数据都可以手动对其进行添加。

@SpringBootTest
class TestMybatisPlusApplicationTests {

    @Autowired
    private UserService userService;

    @Test
    public void testUpdate() {
        User user = new User();
        user.setName("tom").setAge(20).setEmail("tom@163.com");
        // 手动添加数据
        user.setCreateTime(new Date()).setUpdateTime(new Date());
        if (userService.save(user)) {
            userService.list().forEach(System.out::println);
        } else {
            System.out.println("添加数据失败");
        }
    }
}

（3）使用自动填充功能。
Step1：
　　使用 @TableField 注解，标注需要进行填充的字段。

/**
 * 创建时间
 */
@TableField(fill = FieldFill.INSERT)
private Date createTime;

/**
 * 最后修改时间
 */
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;

Step2：
　　自定义一个类，实现 MetaObjectHandler 接口，并重写方法。
　　添加 @Component 注解，交给 Spring 去管理。

package com.lyh.test.test_mybatis_plus.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "createTime", Date.class, new Date());
        this.strictInsertFill(metaObject, "updateTime", Date.class, new Date());
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        this.strictUpdateFill(metaObject, "updateTime", Date.class, new Date());
    }
}

Step3：
　　简单测试一下。

@Test
public void testAutoFill() {
    User user = new User();
    user.setName("tom").setAge(20).setEmail("tom@163.com");
    if (userService.save(user)) {
        userService.list().forEach(System.out::println);
    } else {
        System.out.println("添加数据失败");
    }
}

5、逻辑删除

（1）简介
　　删除数据，可以通过物理删除，也可以通过逻辑删除。
　　物理删除指的是直接将数据从数据库中删除，不保留。
　　逻辑删除指的是修改数据的某个字段，使其表示为已删除状态，而非删除数据，保留该数据在数据库中，但是查询时不显示该数据（查询时过滤掉该数据）。

　　给数据表增加一个字段：delete_flag，用于表示该数据是否被逻辑删除。

CREATE TABLE test_mybatis_plus_user
(
    id BIGINT 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 '邮箱',
    create_time timestamp NULL DEFAULT NULL COMMENT '创建时间',
    update_time timestamp NULL DEFAULT NULL COMMENT '最后修改时间', 
    delete_flag tinyint(1) NULL DEFAULT NULL COMMENT '逻辑删除（0 未删除、1 删除）',
    PRIMARY KEY (id)
);

（2）使用逻辑删除。
　　可以定义一个自动填充规则，初始值为 0。0 表示未删除， 1 表示删除。

/**
 * 逻辑删除（0 未删除、1 删除）
 */
@TableLogic(value = "0", delval = "1")
@TableField(fill = FieldFill.INSERT)
private Integer deleteFlag;


@Override
public void insertFill(MetaObject metaObject) {
    this.strictInsertFill(metaObject, "deleteFlag", Integer.class, 0);
}

（3）简单测试
　　使用 mybatis-plus 封装好的方法时，会自动添加逻辑删除的功能。
　　若是自定义的 sql 语句，需要手动添加逻辑。

@Test
public void testDelete() {
    if (userService.removeById(1258924257048547329L)) {
        System.out.println("删除数据成功");
        userService.list().forEach(System.out::println);
    } else {
        System.out.println("删除数据失败");
    }
}

现有数据

执行 testDelete 进行逻辑删除。

若去除 TableLogic 注解，再执行 testDelete 时进行物理删除，直接删除这条数据。

6、分页插件的使用

（1）简介
　　与 mybatis 的插件 pagehelper 用法类似。
　　通过简单的配置即可使用。

（2）使用
Step1：
　　配置分页插件。
　　编写一个配置类，内部使用 @Bean 注解将 PaginationInterceptor 交给 Spring 容器管理。

package com.lyh.test.test_mybatis_plus.config;

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;

/**
 * 自定义一个配置类，mapper 扫描也可在此写上
 */
@Configuration
@MapperScan("com.lyh.test.test_mybatis_plus.mapper")
public class Myconfig {
    /**
     * 分页插件
     * @return 分页插件的实例
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

Step2：
　　编写分页代码。
　　直接 new 一个 Page 对象，对象需要传递两个参数（当前页，每页显示的条数）。
　　调用 mybatis-plus 提供的分页查询方法，其会将分页查询的数据封装到 Page 对象中。

@Test
public void testPage() {
    // Step1：创建一个 Page 对象
    Page<User> page = new Page<>();
    // Page<User> page = new Page<>(2, 5);
    // Step2：调用 mybatis-plus 提供的分页查询方法
    userService.page(page, null);
    // Step3：获取分页数据
    System.out.println(page.getCurrent()); // 获取当前页
    System.out.println(page.getTotal()); // 获取总记录数
    System.out.println(page.getSize()); // 获取每页的条数
    System.out.println(page.getRecords()); // 获取每页数据的集合
    System.out.println(page.getPages()); // 获取总页数
    System.out.println(page.hasNext()); // 是否存在下一页
    System.out.println(page.hasPrevious()); // 是否存在上一页
}

7、乐观锁的实现

（1）首先认识一下读问题、写问题？
　　操作数据库数据时，遇到的最基本问题就是读问题与写问题。
　　读问题指的是从数据库中读取数据时遇到的问题，比如：脏读、幻读、不可重复读。

1 2	【脏读、幻读、不可重复读参考地址：】 https://www.cnblogs.com/l-y-h/p/12458777.html#_label0_3

　　写问题指的是数据写入数据库时遇到的问题，比如：丢失更新（多个线程同时对某条数据更新，无论执行顺序如何，都会丢失其他线程更新的数据）

（2）如何解决写问题？
　　乐观锁、悲观锁就是为了解决写问题而存在的。
　　　　乐观锁：总是假设最好的情况，每次读取数据时认为数据不会被修改（即不加锁），当进行更新操作时，会判断这条数据是否被修改，未被修改，则进行更新操作。若被修改，则数据更新失败，可以对数据进行重试（重新尝试修改数据）。
　　　　悲观锁：总是假设最坏的情况，每次读取数据时认为数据会被修改（即加锁），当进行更新操作时，直接更新数据，结束操作后释放锁（此处才可以被其他线程读取）。

（3）乐观锁、悲观锁使用场景？
　　乐观锁一般用于读比较多的场合，尽量减少加锁的开销。
　　悲观锁一般用于写比较多的场合，尽量减少类似乐观锁重试更新引起的性能开销。

（4）乐观锁两种实现方式
方式一：通过版本号机制实现。
　　在数据表中增加一个 version 字段。
　　取数据时，获取该字段，更新时以该字段为条件进行处理（即set version = newVersion where version = oldVersion），若 version 相同，则更新成功（给新 version 赋一个值，一般加 1）。若 version 不同，则更新失败，可以重新尝试更新操作。

方式二：通过 CAS 算法实现。
　　CAS 为 Compare And Swap 的缩写，即比较交换，是一种无锁算法（即在不加锁的情况实现多线程之间的变量同步）。
　　CAS 操作包含三个操作数 —— 内存值（V）、预期原值（A）和新值(B)。如果内存地址里面的值 V 和 A 的值是一样的，那么就将内存里面的值更新成B。若 V 与 A 不一致，则不执行任何操作（可以通过自旋操作，不断尝试修改数据直至成功修改）。即 V == A ？ V = B ： V = V。
　　CAS 可能导致 ABA 问题（两次读取数据时值相同，但不确定值是否被修改过），比如两个线程操作同一个变量，线程 A、线程B 初始读取数据均为 A，后来线程B 将数据修改为 B，然后又修改为 A，此时线程 A 再次读取到的数据依旧是 A，虽然值相同但是中间被修改过，这就是 ABA 问题。可以加一个额外的标志位 C，用于表示数据是否被修改。当标志位 C 与预期标志位相同、且 V == A 时，则更新值 B。

（5）mybatis-plus 实现乐观锁（通过 version 机制）
实现思路：
　　Step1：取出记录时，获取当前version
　　Step2：更新时，带上这个version
　　Step3：执行更新时， set version = newVersion where version = oldVersion
　　Step4：如果version不对，就更新失败

（6）mybatis-plus 代码实现乐观锁
Step1：
　　配置乐观锁插件。
　　编写一个配置类（可以与上例的分页插件共用一个配置类），将 OptimisticLockerInterceptor 通过 @Bean 交给 Spring 管理。

/**
 * 乐观锁插件
 * @return 乐观锁插件的实例
 */
@Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor() {
    return new OptimisticLockerInterceptor();
}

Step2：
　　定义一个数据库字段 version。

CREATE TABLE test_mybatis_plus_user
(
    id BIGINT 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 '邮箱',
    create_time timestamp NULL DEFAULT NULL COMMENT '创建时间',
    update_time timestamp NULL DEFAULT NULL COMMENT '最后修改时间', 
    delete_flag tinyint(1) NULL DEFAULT NULL COMMENT '逻辑删除（0 未删除、1 删除）',
    version int NULL DEFAULT NULL COMMENT '版本号（用于乐观锁， 默认为 1）',
    PRIMARY KEY (id)
);

Step3：
　　使用 @Version 注解标注对应的实体类。
　　可以通过 @TableField 进行数据自动填充。

/**
 * 版本号（用于乐观锁， 默认为 1）
 */
@Version
@TableField(fill = FieldFill.INSERT)
private Integer version;


@Override
public void insertFill(MetaObject metaObject) {
    this.strictInsertFill(metaObject, "version", Integer.class, 1);
}

Step4：
　　简单测试一下，可以看一下控制台打印的 sql 语句。

@Test
public void testVersion() {
    User user = new User();
    user.setName("tom").setAge(20).setEmail("tom@163.com");
    userService.save(user);
    userService.list().forEach(System.out::println);
    user.setName("jarry");
    userService.update(user, null);
    userService.list().forEach(System.out::println);
}

回到顶部

三、Mybatis-Plus CRUD 操作简单了解一下

1、Mapper 接口方法（CRUD）简单了解一下

（1）简介
　　使用代码生成器生成的 mapper 接口中，其继承了 BaseMapper 接口。
　　而 BaseMapper 接口中封装了一系列 CRUD 常用操作，可以直接使用，而不用自定义 xml 与 sql 语句进行 CRUD 操作（当然根据实际开发需要，自定义 sql 还是有必要的）。

此处简单介绍一下 BaseMapper 接口中的常用方法。

（2）方法介绍
　　混个眼熟，用多了就记得了。

【添加数据：（增）】
    int insert(T entity);              // 插入一条记录
注：
    T         表示任意实体类型
    entity    表示实体对象

【删除数据：（删）】
    int deleteById(Serializable id);    // 根据主键 ID 删除
    int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);  // 根据 map 定义字段的条件删除
    int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper); // 根据实体类定义的 条件删除对象
    int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList); // 进行批量删除
注：
    id        表示 主键 ID
    columnMap 表示表字段的 map 对象
    wrapper   表示实体对象封装操作类，可以为 null。
    idList    表示 主键 ID 集合（列表、数组），不能为 null 或 empty

【修改数据：（改）】
    int updateById(@Param(Constants.ENTITY) T entity); // 根据 ID 修改实体对象。
    int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper); // 根据 updateWrapper 条件修改实体对象
注：
    update 中的 entity 为 set 条件，可以为 null。
    updateWrapper 表示实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）

【查询数据：（查）】
    T selectById(Serializable id); // 根据 主键 ID 查询数据
    List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList); // 进行批量查询
    List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap); // 根据表字段条件查询
    T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 根据实体类封装对象 查询一条记录
    Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询记录的总条数
    List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 entity 集合）
    List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 map 集合）
    List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（但只保存第一个字段的值）
    <E extends IPage<T>> E selectPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 entity 集合），分页
    <E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 map 集合），分页
注：
    queryWrapper 表示实体对象封装操作类（可以为 null）
    page 表示分页查询条件

1.selectById的问题

表的主键列名不是id时：查询不到数据，因为Mybatisplus自动生成的sql语句where后面拼接的是where null = ？

这就表示表的主键列名的名字不是id，而Mybatisplus默认的是使用id为主键名的

解决方法：

	@Id
    @TableId("commodity_id")//设置mybatisplus自动根据id查询时，表的实际id不是默认的id时，找不到id的情况
    @Column("commodity_id")
    @ApiModelProperty(name = "commodityId", value = "商品的id")
    private String commodityId;
在对应映射的实体类里，主键字段的头上加上@TableId("commodity_id")，就表示告诉mybatisplus你的主键列名为commodity_id

selectById和selectOne的区别：
System.out.println(userMapper.selectById(new QueryWrapper<User>().lambda().eq(User::getId,1)));
可以运行，但是运行到这要出错，因为selectById相当于是where id = ？ 这里的？不能是实体类，只能是id对应的数据类型
System.out.println(userMapper.selectOne(new QueryWrapper<User>().lambda().eq(User::getId,1)));
可以正常运行，因为selectOne相当于是where（？）   这里的？就可以是id = 1

2.insert的问题

设置了@TableId(“specifications_id”)以后，并且数据库的主键列是自增的类型而不是我们手段插入的数据，那么使用Mybaitsplus自带的insert方法时，就会导致数据存不进数据库

	@Id
    @TableId(value = "specifications_id",type = IdType.AUTO)
    @Column("specifications_id")
    @ApiModelProperty(name = "specificationsId", value = "商品的规格id")
    private Integer specificationsId;
要标明当前主键是自增的列，设置type = IdType.AUTO

2、Service 接口方法（CRUD）简单了解一下

（1）简介
　　使用代码生成器生成的 service 接口中，其继承了 IService 接口。
　　IService 内部进一步封装了 BaseMapper 接口的方法（当然也提供了更详细的方法）。
　　使用时，可以通过生成的 mapper 类进行 CRUD 操作，也可以通过生成的 service 的实现类进行 CRUD 操作。（当然，自定义代码执行也可）
此处简单介绍一下 IService 中封装的常用方法。

（2）方法介绍
　　混个眼熟，用多了就记得了。
　　内部封装了 BaseMapper 的方法，也提供了新的方法。
比如：
　　添加了批量更新方法、更新或修改方法等。
　　对查询方法做了细化，使用 get 命名的方法查询一条数据，使用 list 命名的方法查询多条数据等。
　　增加了链式调用的方法。

【添加数据：（增）】
    default boolean save(T entity); // 调用 BaseMapper 的 insert 方法，用于添加一条数据。
    boolean saveBatch(Collection<T> entityList, int batchSize); // 批量插入数据
注：
    entityList 表示实体对象集合 
    batchSize 表示一次批量插入的数据量，默认为 1000

【添加或修改数据：（增或改）】
    boolean saveOrUpdate(T entity); // id 若存在，则修改， id 不存在则新增数据
   default boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper); // 先根据条件尝试更新，然后再执行 saveOrUpdate 操作
   boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize); // 批量插入并修改数据 

【删除数据：（删）】
    default boolean removeById(Serializable id); // 调用 BaseMapper 的 deleteById 方法，根据 id 删除数据。
    default boolean removeByMap(Map<String, Object> columnMap); // 调用 BaseMapper 的 deleteByMap 方法，根据 map 定义字段的条件删除
    default boolean remove(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 delete 方法，根据实体类定义的 条件删除对象。
    default boolean removeByIds(Collection<? extends Serializable> idList); // 用 BaseMapper 的 deleteBatchIds 方法, 进行批量删除。
    
【修改数据：（改）】
    default boolean updateById(T entity); // 调用 BaseMapper 的 updateById 方法，根据 ID 选择修改。
    default boolean update(T entity, Wrapper<T> updateWrapper); // 调用 BaseMapper 的 update 方法，根据 updateWrapper 条件修改实体对象。
    boolean updateBatchById(Collection<T> entityList, int batchSize); // 批量更新数据

【查找数据：（查）】
    default T getById(Serializable id); // 调用 BaseMapper 的 selectById 方法，根据 主键 ID 返回数据。
    default List<T> listByIds(Collection<? extends Serializable> idList); // 调用 BaseMapper 的 selectBatchIds 方法，批量查询数据。
    default List<T> listByMap(Map<String, Object> columnMap); // 调用 BaseMapper 的 selectByMap 方法，根据表字段条件查询
    default T getOne(Wrapper<T> queryWrapper); // 返回一条记录（实体类保存）。
    Map<String, Object> getMap(Wrapper<T> queryWrapper); // 返回一条记录（map 保存）。
    default int count(Wrapper<T> queryWrapper); // 根据条件返回 记录数。
    default List<T> list(); // 返回所有数据。
    default List<T> list(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectList 方法，查询所有记录（返回 entity 集合）。
    default List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectMaps 方法，查询所有记录（返回 map 集合）。
    default List<Object> listObjs(); // 返回全部记录，但只返回第一个字段的值。
    default <E extends IPage<T>> E page(E page, Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectPage 方法，分页查询
    default <E extends IPage<Map<String, Object>>> E pageMaps(E page, Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectMapsPage 方法，分页查询
注：
    get 用于返回一条记录。
    list 用于返回多条记录。
    count 用于返回记录总数。
    page 用于分页查询。
    
【链式调用：】
    default QueryChainWrapper<T> query(); // 普通链式查询
    default LambdaQueryChainWrapper<T> lambdaQuery(); // 支持 Lambda 表达式的修改
    default UpdateChainWrapper<T> update(); // 普通链式修改
    default LambdaUpdateChainWrapper<T> lambdaUpdate(); // 支持 Lambda 表达式的修改
注：
    query 表示查询
    update 表示修改
    Lambda 表示内部支持 Lambda 写法。
形如：
    query().eq("column", value).one();
    lambdaQuery().eq(Entity::getId, value).list();
    update().eq("column", value).remove();
    lambdaUpdate().eq(Entity::getId, value).update(entity);

3、条件构造器（Wrapper，定义 where 条件）

（1）简介
　　上面介绍的接口方法的参数中，会出现各种 wrapper，比如 queryWrapper、updateWrapper 等。wrapper 的作用就是用于定义各种各样的查询条件（where）。

Wrapper  条件构造抽象类
    -- AbstractWrapper 查询条件封装，用于生成 sql 中的 where 语句。
        -- QueryWrapper Entity 对象封装操作类，用于查询。
        -- UpdateWrapper Update 条件封装操作类，用于更新。
    -- AbstractLambdaWrapper 使用 Lambda 表达式封装 wrapper
        -- LambdaQueryWrapper 使用 Lambda 语法封装条件，用于查询。
        -- LambdaUpdateWrapper 使用 Lambda 语法封装条件，用于更新。

（2）常用条件
　　参考源码以及官方文档总结的，还是一句话，混个眼熟，多用用就熟练了。

【通用条件：】
【比较大小： ( =, <>, >, >=, <, <= )】
    eq(R column, Object val); // 等价于 =，例: eq("name", "老王") ---> name = '老王'
    ne(R column, Object val); // 等价于 <>，例: ne("name", "老王") ---> name <> '老王'
    gt(R column, Object val); // 等价于 >，例: gt("name", "老王") ---> name > '老王'
    ge(R column, Object val); // 等价于 >=，例: ge("name", "老王") ---> name >= '老王'
    lt(R column, Object val); // 等价于 <，例: lt("name", "老王") ---> name < '老王'
    le(R column, Object val); // 等价于 <=，例: le("name", "老王") ---> name <= '老王'
    
【范围：（between、not between、in、not in）】
   between(R column, Object val1, Object val2); // 等价于 between a and b, 例： between("age", 18, 30) ---> age between 18 and 30
   notBetween(R column, Object val1, Object val2); // 等价于 not between a and b, 例： notBetween("age", 18, 30) ---> age not between 18 and 30
   in(R column, Object... values); // 等价于 字段 IN (v0, v1, ...),例: in("age",{1,2,3}) ---> age in (1,2,3)
   notIn(R column, Object... values); // 等价于 字段 NOT IN (v0, v1, ...), 例: notIn("age",{1,2,3}) ---> age not in (1,2,3)
   inSql(R column, Object... values); // 等价于 字段 IN (sql 语句), 例: inSql("id", "select id from table where id < 3") ---> id in (select id from table where id < 3)
   notInSql(R column, Object... values); // 等价于 字段 NOT IN (sql 语句)
   
【模糊匹配：（like）】
    like(R column, Object val); // 等价于 LIKE '%值%'，例: like("name", "王") ---> name like '%王%'
    notLike(R column, Object val); // 等价于 NOT LIKE '%值%'，例: notLike("name", "王") ---> name not like '%王%'
    likeLeft(R column, Object val); // 等价于 LIKE '%值'，例: likeLeft("name", "王") ---> name like '%王'
    likeRight(R column, Object val); // 等价于 LIKE '值%'，例: likeRight("name", "王") ---> name like '王%'
    
【空值比较：（isNull、isNotNull）】
    isNull(R column); // 等价于 IS NULL，例: isNull("name") ---> name is null
    isNotNull(R column); // 等价于 IS NOT NULL，例: isNotNull("name") ---> name is not null

【分组、排序：（group、having、order）】
    groupBy(R... columns); // 等价于 GROUP BY 字段, ...， 例: groupBy("id", "name") ---> group by id,name
    orderByAsc(R... columns); // 等价于 ORDER BY 字段, ... ASC， 例: orderByAsc("id", "name") ---> order by id ASC,name ASC
    orderByDesc(R... columns); // 等价于 ORDER BY 字段, ... DESC， 例: orderByDesc("id", "name") ---> order by id DESC,name DESC
    having(String sqlHaving, Object... params); // 等价于 HAVING ( sql语句 )， 例: having("sum(age) > {0}", 11) ---> having sum(age) > 11

【拼接、嵌套 sql：（or、and、nested、apply）】
   or(); // 等价于 a or b， 例：eq("id",1).or().eq("name","老王") ---> id = 1 or name = '老王'
   or(Consumer<Param> consumer); // 等价于 or(a or/and b)，or 嵌套。例: or(i -> i.eq("name", "李白").ne("status", "活着")) ---> or (name = '李白' and status <> '活着')
   and(Consumer<Param> consumer); // 等价于 and(a or/and b)，and 嵌套。例: and(i -> i.eq("name", "李白").ne("status", "活着")) ---> and (name = '李白' and status <> '活着')
   nested(Consumer<Param> consumer); // 等价于 (a or/and b)，普通嵌套。例: nested(i -> i.eq("name", "李白").ne("status", "活着")) ---> (name = '李白' and status <> '活着')
   apply(String applySql, Object... params); // 拼接sql（若不使用 params 参数，可能存在 sql 注入），例: apply("date_format(dateColumn,'%Y-%m-%d') = {0}", "2008-08-08") ---> date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")
   last(String lastSql); // 无视优化规则直接拼接到 sql 的最后，可能存若在 sql 注入。
   exists(String existsSql); // 拼接 exists 语句。例: exists("select id from table where age = 1") ---> exists (select id from table where age = 1)
   
【QueryWrapper 条件：】
    select(String... sqlSelect); // 用于定义需要返回的字段。例： select("id", "name", "age") ---> select id, name, age
    select(Predicate<TableFieldInfo> predicate); // Lambda 表达式，过滤需要的字段。
    lambda(); // 返回一个 LambdaQueryWrapper
    
【UpdateWrapper 条件：】
    set(String column, Object val); // 用于设置 set 字段值。例: set("name", null) ---> set name = null
    etSql(String sql); // 用于设置 set 字段值。例: setSql("name = '老李头'") ---> set name = '老李头'
    lambda(); // 返回一个 LambdaUpdateWrapper

（3）简单使用，测试一下 QueryWrapper

@Test
public void testQueryWrapper() {
    // Step1：创建一个 QueryWrapper 对象
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();

    // Step2： 构造查询条件
    queryWrapper
            .select("id", "name", "age")
            .eq("age", 20)
            .like("name", "j");

    // Step3：执行查询
    userService
            .list(queryWrapper)
            .forEach(System.out::println);
}

当前数据库数据如下：

执行测试方法输出如下：

lombok包

1、idea下安装lombok插件
[settings/plugins在插件库中搜索安装即可。]
(https://img-blog.csdnimg.cn/20190501112839630.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Jlbnh0MDUwOA==,size_16,color_FFFFFF,t_70)
2、重启idea
3、在maven库中添加依赖
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.10</version>
        </dependency>
4、在实体类上添加注解即可生效

@Data

1、@Data可以为类提供读写功能，从而不用写get、set方法。
2、他还会为类提供 equals()、hashCode()、toString() 方法。

@SneakyThrows（隐秘抛出）

是lombok包下的注解并且继承了Throwable作用是为了用try{}catch{}捕捉异常添加之后会在代码编译时自动捕获异常

二、spring整合mybatis-plus:

正如官方所说，mybatis-plus在mybatis的基础上只做增强不做改变，因此其与spring的整合亦非常简单。只需把mybatis的依赖换成mybatis-plus的依赖，再把sqlSessionFactory换成mybatis-plus的即可。接下来看具体操作：
1、pom.xml:
核心依赖如下：

<!-- spring -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.14.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>4.3.14.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>4.3.14.RELEASE</version>
    <scope>test</scope>
</dependency>
<!-- mp 依赖 -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>2.3</version>
</dependency>

注意：这些是核心依赖，本项目还用到了mysql驱动、c3p0、日志（slf4j-api，slf4j-log4j2）、lombok。集成mybatis-plus要把mybatis、mybatis-spring去掉，避免冲突；lombok是一个工具，添加了这个依赖，开发工具再安装Lombok插件，就可以使用它了，最常用的用法就是在实体类中使用它的@Data注解，这样实体类就不用写set、get、toString等方法了。关于Lombok的更多用法，请自行百度。

2、log4j.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd
HH:mm:ss,SSS} %m (%F:%L) \n" />
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug" />
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
    <root>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

3、jdbc.properties:

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///数据库名?useUnicode=true&characterEncoding=utf8
jdbc.username=#
jdbc.password=#

4、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>
</configuration>

注：因为是与spring整合，所有mybatis-plus的大部分都写在spring的配置文件中，这里定义一个空的mybatis-config.xml即可。

5、spring-dao.xml:

<?xml version="1.0" encoding="UTF-8"?>    
<beans xmlns="http://www.springframework.org/schema/beans"    
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
    xmlns:p="http://www.springframework.org/schema/p"  
    xmlns:aop="http://www.springframework.org/schema/aop"   
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:jee="http://www.springframework.org/schema/jee"  
    xmlns:tx="http://www.springframework.org/schema/tx"  
    xsi:schemaLocation="    
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd  
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd  
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">    
        
    <!-- 配置整合mybatis-plus过程 -->
    <!-- 1、配置数据库相关参数properties的属性：${url} -->
    <context:property-placeholder location="classpath:jdbc.properties" />
    <!-- 2、配置数据库连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!-- mybatis的sqlsessionFactorybean：org.mybatis.spring.SqlSessionFactoryBean-->
    <!-- 3、配置mybatis-plus的sqlSessionFactory -->
    <bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="typeAliasesPackage" value="com.zhu.mybatisplus.entity"/>
    </bean>
    <!-- 4、DAO接口所在包名，Spring会自动查找其下的类 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.zhu.mybatisplus.dao" />
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean> 
</beans>

6、entity:

@Data
@TableName(value = "tb_employee")//指定表名
public class Employee {
    //value与数据库主键列名一致，若实体类属性名与表主键列名一致可省略value
    @TableId(value = "id",type = IdType.AUTO)//指定自增策略
    private Integer id;
    //若没有开启驼峰命名，或者表中列名不符合驼峰规则，可通过该注解指定数据库表中的列名，exist标明数据表中有没有对应列
    @TableField(value = "last_name",exist = true)
    private String lastName;
    private String email;
    private Integer gender;
    private Integer age;
}

7、mapper:

1 2	public interface EmplopyeeDao extends BaseMapper<Employee> { }

这样就完成了mybatis-plus与spring的整合。首先是把mybatis和mybatis-spring依赖换成mybatis-plus的依赖，然后把sqlsessionfactory换成mybatis-plus的，然后实体类中添加@TableName、@TableId等注解，最后mapper继承BaseMapper即可。

8、测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:spring/spring-dao.xml"})
public class test {
    @Autowired
    private DataSource dataSource;
    @Test
    public void testDataSource() throws SQLException {
        System.out.println(dataSource.getConnection());
    }
}

运行该junit，可输出获取到的连接，说明整合没问题：

image.png

本文所有代码本人均亲自测试过，本文涉及代码又较多，为了不影响篇幅，故非必要处不再截图。接下来的所有操作都是基于此整合好的项目。

三、mp的通用crud:

需求：
存在一张 tb_employee 表，且已有对应的实体类 Employee，实现tb_employee 表的 CRUD 操作我们需要做什么呢？
基于 Mybatis：
需要编写 EmployeeMapper 接口，并在 EmployeeMapper.xml 映射文件中手动编写 CRUD 方法对应的sql语句。
基于 MP：
只需要创建 EmployeeMapper 接口, 并继承 BaseMapper 接口。
我们已经有了Employee、tb_employee了，并且EmployeeDao也继承了BaseMapper了，接下来就使用crud方法。

1、insert操作：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:spring/spring-dao.xml"})
public class test {
    @Autowired
    private EmplopyeeDao emplopyeeDao;
    @Test
    public void testInsert(){
        Employee employee = new Employee();
        employee.setLastName("东方不败");
        employee.setEmail("dfbb@163.com");
        employee.setGender(1);
        employee.setAge(20);
        emplopyeeDao.insert(employee);
        //mybatisplus会自动把当前插入对象在数据库中的id写回到该实体中
        System.out.println(employee.getId());
    }
}

执行添加操作，直接调用insert方法传入实体即可。

2、update操作：

@Test
public void testUpdate(){
        Employee employee = new Employee();
        employee.setId(1);
        employee.setLastName("更新测试");
        //emplopyeeDao.updateById(employee);//根据id进行更新，没有传值的属性就不会更新
        emplopyeeDao.updateAllColumnById(employee);//根据id进行更新，没传值的属性就更新为null
}

注：注意这两个update操作的区别，updateById方法，没有传值的字段不会进行更新，比如只传入了lastName，那么age、gender等属性就会保留原来的值；updateAllColumnById方法，顾名思义，会更新所有的列，没有传值的列会更新为null。

3、select操作：

(1)、根据id查询：

1	Employee employee = emplopyeeDao.selectById(1);

(2)、根据条件查询一条数据：

Employee employeeCondition = new Employee();
employeeCondition.setId(1);
employeeCondition.setLastName("更新测试");
//若是数据库中符合传入的条件的记录有多条，那就不能用这个方法，会报错
Employee employee = emplopyeeDao.selectOne(employeeCondition);

注：这个方法的sql语句就是where id = 1 and last_name = 更新测试，若是符合这个条件的记录不止一条，那么就会报错。

(3)、根据查询条件返回多条数据：
当符合指定条件的记录数有多条时，上面那个方法就会报错，就应该用这个方法。

Map<String,Object> columnMap = new HashMap<>();
columnMap.put("last_name","东方不败");//写表中的列名
columnMap.put("gender","1");
List<Employee> employees = emplopyeeDao.selectByMap(columnMap);
System.out.println(employees.size());

注：查询条件用map集合封装，columnMap，写的是数据表中的列名，而非实体类的属性名。比如属性名为lastName，数据表中字段为last_name，这里应该写的是last_name。selectByMap方法返回值用list集合接收。

(4)、通过id批量查询：

List<Integer> idList = new ArrayList<>();
idList.add(1);
idList.add(2);
idList.add(3);
List<Employee> employees = emplopyeeDao.selectBatchIds(idList);
System.out.println(employees);

注：把需要查询的id都add到list集合中，然后调用selectBatchIds方法，传入该list集合即可，该方法返回的是对应id的所有记录，所有返回值也是用list接收。

(5)、分页查询：

1 2	List<Employee> employees = emplopyeeDao.selectPage(new Page<>(1,2),null); System.out.println(employees);

注：selectPage方法就是分页查询，在page中传入分页信息，后者为null的分页条件，这里先让其为null，讲了条件构造器再说其用法。这个分页其实并不是物理分页，而是内存分页。也就是说，查询的时候并没有limit语句。等配置了分页插件后才可以实现真正的分页。

4、delete操作：

(1)、根据id删除：

1	emplopyeeDao.deleteById(1);

(2)、根据条件删除：

Map<String,Object> columnMap = new HashMap<>();
columnMap.put("gender",0);
columnMap.put("age",18);
emplopyeeDao.deleteByMap(columnMap);

注：该方法与selectByMap类似，将条件封装在columnMap中，然后调用deleteByMap方法，传入columnMap即可，返回值是Integer类型，表示影响的行数。

(3)、根据id批量删除：

List<Integer> idList = new ArrayList<>();
idList.add(1);
idList.add(2);
emplopyeeDao.deleteBatchIds(idList);

注：该方法和selectBatchIds类似，把需要删除的记录的id装进idList，然后调用deleteBatchIds，传入idList即可。

四、全局策略配置：

通过上面的小案例我们可以发现，实体类需要加@TableName注解指定数据库表名，通过@TableId注解指定id的增长策略。实体类少倒也无所谓，实体类一多的话也麻烦。所以可以在spring-dao.xml的文件中进行全局策略配置。

<!-- 5、mybatisplus的全局策略配置 -->
<bean id="globalConfiguration" class="com.baomidou.mybatisplus.entity.GlobalConfiguration">
        <!-- 2.3版本后，驼峰命名默认值就是true，所以可不配置 -->
        <!--<property name="dbColumnUnderline" value="true"/>-->
        <!-- 全局主键自增策略，0表示auto -->
        <property name="idType" value="0"/>
        <!-- 全局表前缀配置 -->
        <property name="tablePrefix" value="tb_"/>
</bean>

这里配置了还没用，还需要在sqlSessionFactory中注入配置才会生效。如下：

<!-- 3、配置mybatisplus的sqlSessionFactory -->
<bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="typeAliasesPackage" value="com.zhu.mybatisplus.entity"/>
        <!-- 注入全局配置 -->
        <property name="globalConfig" ref="globalConfiguration"/>
</bean>

如此一来，实体类中的@TableName注解和@TableId注解就可以去掉了。

五、条件构造器(EntityWrapper)：

以上基本的 CRUD 操作，我们仅仅需要继承一个 BaseMapper 即可实现大部分单表 CRUD 操作。BaseMapper 提供了多达 17 个方法供使用, 可以极其方便的实现单一、批量、分页等操作，极大的减少开发负担。但是mybatis-plus的强大不限于此，请看如下需求该如何处理：
需求：
我们需要分页查询 tb_employee 表中，年龄在 18~50 之间性别为男且姓名为 xx 的所有用户，这时候我们该如何实现上述需求呢？
使用MyBatis : 需要在 SQL 映射文件中编写带条件查询的 SQL,并用PageHelper 插件完成分页. 实现以上一个简单的需求，往往需要我们做很多重复单调的工作。
使用MP: 依旧不用编写 SQL 语句，MP 提供了功能强大的条件构造器 —— EntityWrapper。

接下来就直接看几个案例体会EntityWrapper的使用。

1、分页查询年龄在18 - 50且gender为0、姓名为tom的用户：

List<Employee> employees = emplopyeeDao.selectPage(new Page<Employee>(1,3),
     new EntityWrapper<Employee>()
        .between("age",18,50)
        .eq("gender",0)
        .eq("last_name","tom")
);

注：由此案例可知，分页查询和之前一样，new 一个page对象传入分页信息即可。至于分页条件，new 一个EntityWrapper对象，调用该对象的相关方法即可。between方法三个参数，分别是column、value1、value2，该方法表示column的值要在value1和value2之间；eq是equals的简写，该方法两个参数，column和value，表示column的值和value要相等。注意column是数据表对应的字段，而非实体类属性字段。

2、查询gender为0且名字中带有老师、或者邮箱中带有a的用户：

List<Employee> employees = emplopyeeDao.selectList(
                new EntityWrapper<Employee>()
               .eq("gender",0)
               .like("last_name","老师")
                //.or()//和or new 区别不大
               .orNew()
               .like("email","a")
);

注：未说分页查询，所以用selectList即可，用EntityWrapper的like方法进行模糊查询，like方法就是指column的值包含value值，此处like方法就是查询last_name中包含“老师”字样的记录；“或者”用or或者orNew方法表示，这两个方法区别不大，用哪个都可以，可以通过控制台的sql语句自行感受其区别。

3、查询gender为0，根据age排序，简单分页：

List<Employee> employees = emplopyeeDao.selectList(
                new EntityWrapper<Employee>()
                .eq("gender",0)
                .orderBy("age")//直接orderby 是升序，asc
                .last("desc limit 1,3")//在sql语句后面追加last里面的内容(改为降序，同时分页)
);

注：简单分页是指不用page对象进行分页。orderBy方法就是根据传入的column进行升序排序，若要降序，可以使用orderByDesc方法，也可以如案例中所示用last方法；last方法就是将last方法里面的value值追加到sql语句的后面，在该案例中，最后的sql语句就变为select ······ order by desc limit 1, 3，追加了desc limit 1,3所以可以进行降序排序和分页。

4、分页查询年龄在18 - 50且gender为0、姓名为tom的用户：
条件构造器除了EntityWrapper，还有Condition。用Condition来处理一下这个需求：

List<Employee> employees = emplopyeeDao.selectPage(
               new Page<Employee>(1,2),
               Condition.create()
                       .between("age",18,50)
                       .eq("gender","0")
);

注：Condition和EntityWrapper的区别就是，创建条件构造器时，EntityWrapper是new出来的，而Condition是调create方法创建出来。

5、根据条件更新：

@Test
public void testEntityWrapperUpdate(){
        Employee employee = new Employee();
        employee.setLastName("苍老师");
        employee.setEmail("cjk@sina.com");
        employee.setGender(0);
        emplopyeeDao.update(employee,
                new EntityWrapper<Employee>()
                .eq("last_name","tom")
                .eq("age",25)
        );
}

注：该案例表示把last_name为tom，age为25的所有用户的信息更新为employee中设置的信息。

6、根据条件删除：

emplopyeeDao.delete(
        new EntityWrapper<Employee>()
        .eq("last_name","tom")
        .eq("age",16)
);

注：该案例表示把last_name为tom、age为16的所有用户删除。

Mybatis-Plus和Mybatis的区别

在这里插入图片描述

区别一
如果Mybatis Plus是扳手，那Mybatis Generator就是生产扳手的工厂。
通俗来讲——
MyBatis：一种操作数据库的框架，提供一种Mapper类，支持让你用java代码进行增删改查的数据库操作，省去了每次都要手写sql语句的麻烦。但是！有一个前提，你得先在xml中写好sql语句，是不是很麻烦？于是有下面的↓
Mybatis Generator：自动为Mybatis生成简单的增删改查sql语句的工具，省去一大票时间，两者配合使用，开发速度快到飞起。至于标题说的↓
Mybatis Plus：国人团队苞米豆在Mybatis的基础上开发的框架，在Mybatis基础上扩展了许多功能，荣获了2018最受欢迎国产开源软件第5名，当然也有配套的↓
Mybatis Plus Generator：同样为苞米豆开发，比Mybatis Generator更加强大，支持功能更多，自动生成Entity、Mapper、Service、Controller等
总结：
数据库框架：Mybatis Plus > Mybatis
代码生成器：Mybatis Plus Generator > Mybatis Generator

区别二
Mybatis-Plus是一个Mybatis的增强工具，它在Mybatis的基础上做了增强，却不做改变。我们在使用Mybatis-Plus之后既可以使用Mybatis-Plus的特有功能，又能够正常使用Mybatis的原生功能。Mybatis-Plus(以下简称MP)是为简化开发、提高开发效率而生，但它也提供了一些很有意思的插件，比如SQL性能监控、乐观锁、执行分析等。

Mybatis虽然已经给我们提供了很大的方便，但它还是有不足之处，实际上没有什么东西是完美的，MP的存在就是为了稍稍弥补Mybatis的不足。在我们使用Mybatis时会发现，每当要写一个业务逻辑的时候都要在DAO层写一个方法，再对应一个SQL，即使是简单的条件查询、即使仅仅改变了一个条件都要在DAO层新增一个方法，针对这个问题，MP就提供了一个很好的解决方案，之后我会进行介绍。另外，MP的代码生成器也是一个很有意思的东西，它可以让我们避免许多重复性的工作，下面我将介绍如何在你的项目中集成MP。

mybatis-plus添加依赖

注意这里的依赖！springboot项目和spring项目的依赖不一样！

首先添加maven依赖：springboot项目用下面这个依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.2.0</version>
</dependency>

如果是spring项目则用下面的依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>3.2.0</version>
</dependency>

然后就可以使用BaseMapper <entity范型>

启动类上还需要加上 @MapperScan(“UserMapper接口所在的包”)

例如：@MapperScan(“top.yumbo.dao”) 这样启动的时候就不会因为注入的时候导致报错

一、集成步骤：(首先，你要有个spring项目)
集成依赖，pom中加入依赖即可，不多说：

<!-- mybatis mybatis-plus mybatis-spring mvc -->  
<dependency>  
    <groupId>com.baomidou</groupId>  
    <artifactId>mybatis-plus</artifactId>  
    <version>${mybatis-plus.version}</version>  
</dependency>  
<dependency>  
    <groupId>org.apache.velocity</groupId>  
    <artifactId>velocity-engine-core</artifactId>  
    <version>2.0</version>  
</dependency>

说明：笔者使用的版本为：mybatis-plus.version=2.1-gamma，上边的代码中有两个依赖，第一个是mybatis-plus核心依赖，第二个是使用代码生成器时需要的模板引擎依赖，若果你不打算使用代码生成器，此处可不引入。
注意：mybatis-plus的核心jar包中已集成了mybatis和mybatis-spring，所以为避免冲突，请勿再次引用这两个jar包。

二、在spring中配置MP：

<bean id="sqlSessionFactory"  
    class="com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean">  
    <!-- 配置数据源 -->  
    <property name="dataSource" ref="dataSource" />  
    <!-- 自动扫描 Xml 文件位置 -->  
    <property name="mapperLocations" value="classpath*:com/ds/orm/mapper/**/*.xml" />  
    <!-- 配置 Mybatis 配置文件（可无） -->  
    <property name="configLocation" value="classpath:mybatis-config.xml" />  
    <!-- 配置包别名，支持通配符 * 或者 ; 分割 -->  
    <property name="typeAliasesPackage" value="com.ds.orm.model" />  
    <!-- 枚举属性配置扫描，支持通配符 * 或者 ; 分割 -->  
    <!-- <property name="typeEnumsPackage" value="com.baomidou.springmvc.entity.*.enums" /> -->  
    <!-- 以上配置和传统 Mybatis 一致 -->  

<!-- MP 全局配置注入 -->  
<property name="globalConfig" ref="globalConfig" />  

</bean>

<bean id="globalConfig" class="com.baomidou.mybatisplus.entity.GlobalConfiguration">  
    <!-- 主键策略配置 -->  
    <!-- 可选参数 AUTO->`0`("数据库ID自增") INPUT->`1`(用户输入ID") ID_WORKER->`2`("全局唯一ID")   
        UUID->`3`("全局唯一ID") -->  
    <property name="idType" value="2" />  
    <!-- 数据库类型配置 -->  
    <!-- 可选参数（默认mysql） MYSQL->`mysql` ORACLE->`oracle` DB2->`db2` H2->`h2`   
        HSQL->`hsql` SQLITE->`sqlite` POSTGRE->`postgresql` SQLSERVER2005->`sqlserver2005`   
        SQLSERVER->`sqlserver` -->  
    <property name="dbType" value="mysql" />  
    <!-- 全局表为下划线命名设置 true -->  
    <property name="dbColumnUnderline" value="true" />  
    <property name="sqlInjector">  
        <bean class="com.baomidou.mybatisplus.mapper.AutoSqlInjector" />  
    </property>  
</bean>  
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">  
    <description>DAO接口所在包名，Spring会自动查找其下的类</description>  
    <property name="basePackage" value="com.ds.orm.mapper" />  
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />  
</bean>  
<!-- 乐观锁插件 -->  
<bean class="com.baomidou.mybatisplus.plugins.OptimisticLockerInterceptor" />  

<!-- xml mapper热加载 sqlSessionFactory:session工厂 mapperLocations:mapper匹配路径   
    enabled:是否开启动态加载 默认:false delaySeconds:项目启动延迟加载时间 单位：秒 默认:10s sleepSeconds:刷新时间间隔   
    单位：秒 默认:20s -->  
<bean class="com.baomidou.mybatisplus.spring.MybatisMapperRefresh">  
    <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory" />  
    <constructor-arg name="mapperLocations"  
        value="classpath*:com/ds/orm/mapper/*/*.xml" />  
    <constructor-arg name="delaySeconds" value="10" />  
    <constructor-arg name="sleepSeconds" value="20" />  
    <constructor-arg name="enabled" value="true" />  
</bean>  

<!-- 事务 -->  
<bean id="transactionManager"  
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
    <property name="dataSource" ref="dataSource" />  
</bean>  
<tx:annotation-driven transaction-manager="transactionManager"  
    proxy-target-class="true" />

注意：只要做如上配置就可以正常使用mybatis了，不要重复配置。MP的配置和mybatis一样，都是配置一个sqlSessionFactory，只是现在所配置的类在原本的SqlSessionFactoryBean基础上做了增强。插件等配置请按需取舍。
插件配置，按需求配置就可以，此处把可以配置的插件都列了出来，具体的请看代码注释：

<configuration>  
    <settings>  
        <setting name="logImpl" value="SLF4J" />  
        <!-- 字段为空时仍调用model的set方法或map的put方法 -->  
        <setting name="callSettersOnNulls" value="true" />  
    </settings>  
    <plugins>  
        <!-- | 分页插件配置 | 插件提供二种方言选择：1、默认方言 2、自定义方言实现类，两者均未配置则抛出异常！ | overflowCurrent   
            溢出总页数，设置第一页 默认false | optimizeType Count优化方式 （ 版本 2.0.9 改为使用 jsqlparser 不需要配置   
            ） | -->  
        <!-- 注意!! 如果要支持二级缓存分页使用类 CachePaginationInterceptor 默认、建议如下！！ -->  
        <plugin interceptor="com.baomidou.mybatisplus.plugins.PaginationInterceptor">  
            <property name="dialectType" value="mysql" />  
            <!--<property name="sqlParser" ref="自定义解析类、可以没有" />  
            <property name="localPage" value="默认 false 改为 true 开启了 pageHeper 支持、可以没有" />  
            <property name="dialectClazz" value="自定义方言类、可以没有" /> -->  
        </plugin>  

    <!-- SQL 执行性能分析，开发环境使用，线上不推荐。 maxTime 指的是 sql 最大执行时长 -->  
    <plugin interceptor="com.baomidou.mybatisplus.plugins.PerformanceInterceptor">  
        <property name="maxTime" value="2000" />  
        <!--SQL是否格式化 默认false -->  
        <property name="format" value="true" />  
    </plugin>  

    <!-- SQL 执行分析拦截器 stopProceed 发现全表执行 delete update 是否停止运行 该插件只用于开发环境，不建议生产环境使用。。。 -->  
    <plugin interceptor="com.baomidou.mybatisplus.plugins.SqlExplainInterceptor">  
        <property name="stopProceed" value="false" />  
    </plugin>  
</plugins>  

</configuration>

注意：执行分析拦截器和性能分析推荐只在开发时调试程序使用，为保证程序性能和稳定性，建议在生产环境中注释掉这两个插件。
数据源：(此处使用druid)

<!-- 配置数据源 -->  
<bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">  
    <!--     <property name="driverClassName" value="${jdbc.driverClassName}" /> -->  
    <property name="url" value="${jdbc.url}" />   
    <property name="username" value="${jdbc.username}" />   
    <property name="password" value="${jdbc.password}" />   
    <property name="initialSize" value="${jdbc.initialSize}" />   
    <property name="minIdle" value="${jdbc.minIdle}" />   
    <property name="maxActive" value="${jdbc.maxActive}" />   
    <property name="maxWait" value="${jdbc.maxWait}" />   
    <property name="timeBetweenEvictionRunsMillis" value="${jdbc.timeBetweenEvictionRunsMillis}" />   
    <property name="minEvictableIdleTimeMillis" value="${jdbc.minEvictableIdleTimeMillis}" />   
    <property name="validationQuery" value="${jdbc.validationQuery}" />   
    <property name="testWhileIdle" value="${jdbc.testWhileIdle}" />   
    <property name="testOnBorrow" value="${jdbc.testOnBorrow}" />   
    <property name="testOnReturn" value="${jdbc.testOnReturn}" />   
    <property name="removeAbandoned" value="${jdbc.removeAbandoned}" />   
    <property name="removeAbandonedTimeout" value="${jdbc.removeAbandonedTimeout}" />   
    <!--     <property name="logAbandoned" value="${jdbc.logAbandoned}" /> -->  
    <property name="filters" value="${jdbc.filters}" />  
    <!-- 关闭abanded连接时输出错误日志 -->  
    <property name="logAbandoned" value="true" />  
    <property name="proxyFilters">  
        <list>  
            <ref bean="log-filter"/>  
        </list>  
    </property>  

<!-- 监控数据库 -->  
<!-- <property name="filters" value="stat" /> -->  
<!--     <property name="filters" value="mergeStat" />-->  

</bean>

到此，MP已经集成进我们的项目中了，下面将介绍它是如何简化我们的开发的。

三、简单的CURD操作：

假设我们有一张user表，且已经建立好了一个与此表对应的实体类User，我们来介绍对user的简单增删改查操作。
建立DAO层接口。我们在使用普通的mybatis时会建立一个DAO层接口，并对应一个xml用来写SQL。在这里我们同样要建立一个DAO层接口，但是若无必要，我们甚至不需要建立xml，就可以进行资源的CURD操作了，我们只需要让我们建立的DAO继承MP提供的BaseMapper<?>即可：

public interface UserMapper extends BaseMapper { }
然后在我们需要做数据CURD时，像下边这样就好了：
Java代码 收藏代码
// 初始化 影响行数
int result = 0;
// 初始化 User 对象
User user = new User();

// 插入 User (插入成功会自动回写主键到实体类)
user.setName(“Tom”);
result = userMapper.insert(user);

// 更新 User
user.setAge(18);
result = userMapper.updateById(user);//user要设置id哦，具体的在下边我会详细介绍

// 查询 User
User exampleUser = userMapper.selectById(user.getId());

// 查询姓名为‘张三’的所有用户记录
List userList = userMapper.selectList(
new EntityWrapper().eq(“name”, “张三”)
);

// 删除 User
result = userMapper.deleteById(user.getId());

多条件分页查询：
// 分页查询 10 条姓名为‘张三’、性别为男，且年龄在18至50之间的用户记录

List<User> userList = userMapper.selectPage(  
        new Page<User>(1, 10),  
        new EntityWrapper<User>().eq("name", "张三")  
                .eq("sex", 0)  
                .between("age", "18", "50")  
);  

/**等价于SELECT *
*FROM sys_user
*WHERE (name=‘张三’ AND sex=0 AND age BETWEEN ‘18’ AND ‘50’)
*LIMIT 0,10
*/

下边这个，多条件构造器。其实对于条件过于复杂的查询，还是建议使用原生mybatis的方式实现，易于维护且逻辑清晰，如果所有的数据操作都强行使用MP，就失去了MP简化开发的意义了。所以在使用时请按实际情况取舍，在这里还是先介绍一下。

public Page<T> selectPage(Page<T> page, EntityWrapper<T> entityWrapper) {  
  if (null != entityWrapper) {  
      entityWrapper.orderBy(page.getOrderByField(), page.isAsc());//排序  
  }  
  page.setRecords(baseMapper.selectPage(page, entityWrapper));//将查询结果放入page中  
  return page;  
}

条件构造一(上边方法的entityWrapper参数)：

public void testTSQL11() {  
    /* 

   * 实体带查询使用方法  输出看结果 
     /  
         EntityWrapper<User> ew = new EntityWrapper<User>();  
         ew.setEntity(new User(1));  
         ew.where("user_name={0}", "'zhangsan'").and("id=1")  
     .orNew("user_status={0}", "0").or("status=1")  
     .notLike("user_nickname", "notvalue")  
     .andNew("new=xx").like("hhh", "ddd")  
     .andNew("pwd=11").isNotNull("n1,n2").isNull("n3")  
     .groupBy("x1").groupBy("x2,x3")  
     .having("x1=11").having("x3=433")  
     .orderBy("dd").orderBy("d1,d2");  
         System.out.println(ew.getSqlSegment());  
     }

条件构造二（同上）：

int buyCount = selectCount(Condition.create()
.setSqlSelect(“sum(quantity)”)
.isNull(“order_id”)
.eq(“user_id”, 1)
.eq(“type”, 1)
.in(“status”, new Integer[]{0, 1})
.eq(“product_id”, 1)
.between(“created_time”, startDate, currentDate)
.eq(“weal”, 1));

自定义条件使用entityWrapper：
List selectMyPage(RowBounds rowBounds, @Param(“ew”) Wrapper wrapper);

SELECT * FROM user ${ew.sqlSegment} *注意：此处不用担心SQL注入，MP已对ew做了字符串转义处理。 其实在使用MP做数据CURD时，还有另外一个方法，AR(ActiveRecord )，很简单，让我们的实体类继承MP提供Model<?>就好了，这和我们常用的方法可能会有些不同，下边简单说一下吧：

//实体类
@TableName(“sys_user”) // 注解指定表名
public class User extends Model {
… // fields

… // getter and setter

.
.

/ 指定主键 /*
@Override
protected Serializable pkVal() { //一定要指定主键哦
return this.id;
}
}

下边就是CURD操作了：

// 初始化 成功标识
boolean result = false;
// 初始化 User
User user = new User();

// 保存 User
user.setName(“Tom”);
result = user.insert();

// 更新 User
user.setAge(18);
result = user.updateById();

// 查询 User
User exampleUser = t1.selectById();

// 查询姓名为‘张三’的所有用户记录
List userList1 = user.selectList(
new EntityWrapper().eq(“name”, “张三”)
);

// 删除 User
result = t2.deleteById();

// 分页查询 10 条姓名为‘张三’、性别为男，且年龄在18至50之间的用户记录
List userList = user.selectPage(
new Page(1, 10),
new EntityWrapper().eq(“name”, “张三”)
.eq(“sex”, 0)
.between(“age”, “18”, “50”)
).getRecords();

就是这样了，可能你会说MP封装的有些过分了，这样做会分散数据逻辑到不同的层面中，难以管理，使代码难以理解。其实确实是这样，这就需要你在使用的时候注意一下了，在简化开发的同时也要保证你的代码层次清晰，做一个战略上的设计或者做一个取舍与平衡。

总结

MP的宗旨是简化开发，但是它在提供方便的同时却容易造成代码层次混乱，我们可能会把大量数据逻辑写到service层甚至contoller层中，使代码难以阅读。凡事过犹不及，在使用MP时一定要做分析，不要将所有数据操作都交给MP去实现。毕竟MP只是mybatis的增强工具，它并没有侵入mybatis的原生功能，在使用MP的增强功能的同时，原生mybatis的功能依然是可以正常使用的

一些疑问

mapper层可以完成的数据操作，为什么还需要设计services层也进行数据操作，造成分层结构不明确？

在后端开发过程中，用到mybatis-plus，发现在其内部存在着两种数据库操作接口，Iservice和BaseMapper，如果只是用增删改查会发现两者的功能是一致的，除了方法名称有所不同，其他的基本相似。
先演示一下基本开发中的继承关系，手动创建的Service继承于ServiceImpl，并加载自己创建的Mapper

@Service
public class AdminServiceImpl extends ServiceImpl<AdminMapper, Admin> implements AdminService {

}

public interface AdminService extends IService<Admin> {

}

@Mapper
public interface AdminMapper extends BaseMapper<Admin> {

}

如上，就是一般开发的基本模版代码，足以满足各种需求功能
先看一下继承结构

我们继承的ServiceImpl依旧实现了BaseMapper接口和Iservice接口，明明我们单独写了AdminMapper，并且继承了BaseMapper，现在ServiceImpl还是实现了BaseMapper，那我直接一个Service用下来不就行了，创建两套类，功能相似，还容易混乱，代码结构冗余。

对比一下两个接口的方法

Service简直是BaseMapper的大扩充，不但包含了所有基本方法，还加入了很多批处理功能

Service CRUD 接口
说明:

通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用：

get 查询单行 remove 删除 list 查询集合 page 分页前缀命名方式区分 Mapper 层避免混淆

泛型 T 为任意实体对象
建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
对象 Wrapper 为条件构造器

Mapper CRUD 接口
说明:

通用 CRUD 封装BaseMapper接口，为 Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器
泛型 T 为任意实体对象
参数 Serializable 为任意类型主键 Mybatis-Plus 不推荐使用复合主键约定每一张表都有自己的唯一 id 主键
对象 Wrapper 为条件构造器

Service虽然加入了数据库的操作，但还是以业务功能为主，而更加复杂的SQL查询，还是要靠Mapper对应的XML文件里去编写SQL语句