[Java知识库]MyBatisPlus——入门介绍

本文章笔记整理来自黑马视频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特性

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中导入相关依赖

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.itcast.mp</groupId>
    <artifactId>itcast-mybatis-plus</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- mybatis-plus插件依赖 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
            <version>3.1.1</version>
        </dependency>
        <!-- MySql连接依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!-- druid连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.11</version>
        </dependency>
        <!--简化bean代码的工具包——lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
            <version>1.18.4</version>
        </dependency>
        <!--单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!--日志-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.4</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!--编译项目代码-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

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

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

	<settings>
        <!--开启驼峰命名-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/mp?useUnicode=true&amp;characterEncoding=utf8&amp;autoReconnect=true&amp;allowMultiQueries=true&amp;useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!--注册SQL映射文件-->
    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

（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<User> 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<User> 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<User> {

    List<User> 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<User> users = userMapper.findAll();
        List<User> 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的相关依赖

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>itcast-mybatis-plus</artifactId>
        <groupId>cn.itcast.mp</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>itcast-mybatis-plus-spring</artifactId>

    <properties>
        <spring.version>5.1.6.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>
</project>

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

<?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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 定义数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="maxActive" value="10"/>
        <property name="minIdle" value="5"/>
    </bean>

    <!--这里使用MP提供的sqlSessionFactory，完成了Spring与MP的整合-->
    <bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="globalConfig">
            <bean class="com.baomidou.mybatisplus.core.config.GlobalConfig">
                <property name="dbConfig">
                    <bean class="com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig">
                        <property name="idType" value="AUTO"/>
                    </bean>
                </property>
            </bean>
        </property>
    </bean>

    <!--扫描mapper接口，使用的依然是Mybatis原生的扫描器-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="cn.itcast.mp.simple.mapper"/>
    </bean>
</beans>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
	<settings>
        <!--开启驼峰命名-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
</configuration>

（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<User> 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中导入相关依赖

<?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 http://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.1.4.RELEASE</version>
    </parent>

    <groupId>cn.itcast.mp</groupId>
    <artifactId>itcast-mp-springboot</artifactId>
    <version>1.0-SNAPSHOT</version>

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

        <!--简化代码的工具包-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!--mybatis-plus的springboot支持-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.1</version>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </dependency>

    </dependencies>

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

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<User> users = this.userMapper.selectList(null);
        for (User user : users) {
            System.out.println(user);
        }
    }
}

结果如下：

3.通用CRUD

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

3.1.插入操作——insert

3.1.1.方法定义

/**
 * 插入一条记录
 *
 * @param entity 实体对象
 */
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策略如下：

/*
 * Copyright (c) 2011-2020, baomidou (jobob@qq.com).
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * <p>
 * https://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.baomidou.mybatisplus.annotation;

import lombok.Getter;

/**
 * 生成ID类型枚举类
 *
 * @author hubin
 * @since 2015-11-10
 */
@Getter
public enum IdType {
    /**
     * 数据库ID自增
     */
    AUTO(0),
    /**
     * 该类型为未设置主键类型
     */
    NONE(1),
    /**
     * 用户输入ID
     * <p>该类型可以通过自己注册自动填充插件进行填充</p>
     */
    INPUT(2),

    /* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
    /**
     * 全局唯一ID (idWorker)
     */
    ID_WORKER(3),
    /**
     * 全局唯一ID (UUID)
     */
    UUID(4),
    /**
     * 字符串全局唯一ID (idWorker 的字符串表示)
     */
    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）方法定义

/**
     * 根据 ID 修改
     *
     * @param entity 实体对象
     */
    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）方法定义

/**
     * 根据 whereEntity 条件，更新记录
     *
     * @param entity        实体对象 (set 条件值,可以为 null)
     * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     */
    int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);

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

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

    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //匹配user_name = zhangsan 的用户数据
    wrapper.eq("user_name", "zhangsan");
    /*
        上面的操作相当于SQL语句:
        update tb_user set password = '888888' , age = 29 where user_name = 'zhangsan'
    */
    int result = this.userMapper.update(user,wrapper);
    System.out.println("result => " + result);
}

② 通过UpdateWrapper进行更新：

@Test
public void testUpdate2() {
    UpdateWrapper<User> 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）方法定义

/**
 * 根据 ID 删除
 *
 * @param id 主键ID
 */
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）方法定义

/**
 * 根据 columnMap 条件，删除记录
 *
 * @param columnMap 表字段 map 对象
 */
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

（2）编写测试代码

@Test
public void testDeleteByMap(){
    Map<String,Object> 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）方法定义

/**
 * 根据 entity 条件，删除记录
 *
 * @param wrapper 实体对象封装操作类（可以为 null）
 */
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);

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

@Test
public void testDelete1(){
    QueryWrapper<User> 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<User> wrapper = new QueryWrapper<>(user);
    // 根据包装条件做删除
    int result = this.userMapper.delete(wrapper);
    System.out.println("result => " + result);
}

3.3.3.批量删除——deleteBatchIds

（1）方法定义

/**
 * 删除（根据ID 批量删除）
 *
 * @param idList 主键ID列表(不能为 null 以及 empty)
 */
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> 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）方法定义

/**
* 根据 ID 查询
*
* @param id 主键ID
*/
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）方法定义

/**
 * 查询（根据ID 批量查询）
 *
 * @param idList 主键ID列表(不能为 null 以及 empty)
 */
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

（2）编写测试代码

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

3.4.3.查询单条数据——selectOne

（1）方法定义

/**
* 根据 entity 条件，查询一条记录
 *
 * @param queryWrapper 实体对象封装操作类（可以为 null）
 */
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

（2）编写测试代码

@Test
public void testSelectOne(){
    QueryWrapper<User> 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）方法定义

/**
 * 根据 Wrapper 条件，查询总记录数
 *
 * @param queryWrapper 实体对象封装操作类（可以为 null）
 */
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

（2）编写测试代码

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

3.4.5.查询数据列表——selectList

（1）方法定义

/**
* 根据 entity 条件，查询全部记录
 *
 * @param queryWrapper 实体对象封装操作类（可以为 null）
 */
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

（2）编写测试代码

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

3.4.6.分页查询数据——selectPage

（1）方法定义

/**
* 根据 entity 条件，查询全部记录（并翻页）
 *
 * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
 * @param queryWrapper 实体对象封装操作类（可以为 null）
 */
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

/*
 * Copyright (c) 2011-2020, baomidou (jobob@qq.com).
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * <p>
 * https://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
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;

/**
 * 简单分页模型
 *
 * @author hubin
 * @since 2018-06-09
 */
public class Page<T> implements IPage<T> {

    private static final long serialVersionUID = 8545996863226528798L;

    /**
     * 查询数据列表
     */
    private List<T> records = Collections.emptyList();
    /**
     * 总数
     */
    private long total = 0;
    /**
     * 每页显示条数，默认 10
     */
    private long size = 10;
    /**
     * 当前页
     */
    private long current = 1;
    /**
     * SQL 排序 ASC 数组
     */
    private String[] ascs;
    /**
     * SQL 排序 DESC 数组
     */
    private String[] descs;
    /**
     * 自动优化 COUNT SQL
     */
    private boolean optimizeCountSql = true;
    /**
     * 是否进行 count 查询
     */
    private boolean isSearchCount = true;

    public Page() {
        // to do nothing
    }

    /**
     * 分页构造函数
     *
     * @param current 当前页
     * @param size    每页显示条数
     */
    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;
    }

    /**
     * 是否存在上一页
     *
     * @return true / false
     */
    public boolean hasPrevious() {
        return this.current > 1;
    }

    /**
     * 是否存在下一页
     *
     * @return true / false
     */
    public boolean hasNext() {
        return this.current < this.getPages();
    }

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

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

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

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

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

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

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

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

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

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


    /**
     * 升序
     *
     * @param ascs 多个升序字段
     */
    public Page<T> setAsc(String... ascs) {
        this.ascs = ascs;
        return this;
    }

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

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

    /**
     * 降序
     *
     * @param descs 多个降序字段
     */
    public Page<T> 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<T> setSearchCount(boolean isSearchCount) {
        this.isSearchCount = isSearchCount;
        return this;
    }

    public Page<T> 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的全局配置文件中进行配置。

<plugins>
	<plugin interceptor="com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor"></plugin>
</plugins>

（3）编写测试代码

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

<bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
	<property name="configLocation" value="classpath:mybatis-config.xml"/>
</bean>

4.1.2.mapperLocations

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

# 指定Mapper.xml文件的路径
mybatis-plus.mapper-locations = classpath*:mybatis/*.xml

（2）SpringMVC

<bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
	<property name="mapperLocations" value="classpath*:mybatis/*.xml"/>
</bean>

4.1.3.typeAliasesPackage

typeAliasesPackage，即MyBaits 别名包扫描路径，通过该属性可以给包中的类注册别名，注册后在 Mapper 对应的 XML 文件中可以直接使用类名，而不用使用全限定的类名（即 XML 中调用的时候不用包含包名）。
（1）SpringBoot

mybatis-plus.type-aliases-package = cn.itcast.mp.pojo

（2）SpringMVC

<bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
	<property name="typeAliasesPackage" value="com.baomidou.mybatisplus.samples.quickstart.entity"/>
</bean>

4.2.进阶配置

本部分（Configuration）的配置大都为 MyBatis 原生支持的配置，这意味着您可以通过MyBatis XML 配置文件的形式进行配置。

4.2.1.mapUnderscoreToCamelCase

mapUnderscoreToCamelCase，即是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN（下划线命名） 到经典 Java 属性名 aColumn（驼峰命名） 的类似映射。类型为boolean，默认值为 true。
注意：此属性在 MyBatis 中原默认值为 false，在 MyBatis-Plus 中，此属性也将用于生成最终的 SQL 的 select body，如果数据库命名符合规则，则无需使用 @TableField 注解指定数据库字段名。
（1）SpringBoot

#开启自动驼峰映射，该参数不能和mybatis-plus.config-location同时存在
mybatis-plus.configuration.map-underscore-to-camel-case=true

（2）MyBatis

<settings>
    <!--开启驼峰命名-->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>

4.2.2.cacheEnabled

cacheEnabled，即全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存，类型为boolean，默认值为 true。
（1）SpringBoot

mybatis-plus.configuration.cache-enabled=false

（2）MyBatis

<settings>
    <!--关闭缓存-->
    <setting name="cacheEnabled" value="false"/>
</settings>

4.3.DB 策略配置

4.3.1.idType

idType，即全局默认主键类型，设置后，即可省略实体对象中的@TableId(type =IdType.AUTO)配置。
（1）SpringBoot

# 全局的id自增策略
mybatis-plus.global-config.db-config.id-type=auto

（2）SpringMVC

<!--这里使用MP提供的sqlSessionFactory，完成了Spring与MP的整合-->
<bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
	<property name="dataSource" ref="dataSource"/>
	<property name="globalConfig">
		<bean class="com.baomidou.mybatisplus.core.config.GlobalConfig">
			<property name="dbConfig">
				<bean class="com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig">
					<property name="idType" value="AUTO"/>
				</bean>
			</property>
		</bean>
	</property>
</bean>

4.3.2.tablePrefix

tablePrefix，即表名前缀，全局配置后可省略@TableName()配置。
（1）SpringBoot

# 全局的表名的前缀
mybatis-plus.global-config.db-config.table-prefix=tb_

（2）SpringMVC

<bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
	<property name="dataSource" ref="dataSource"/>
	<property name="globalConfig">
		<bean class="com.baomidou.mybatisplus.core.config.GlobalConfig">
			<property name="dbConfig">
				<bean class="com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig">
					<property name="idType" value="AUTO"/>
					<property name="tablePrefix" value="tb_"/>
				</bean>
			</property>
		</bean>
	</property>
</bean>

5.条件构造器

在MP中，Wrapper接口的实现类关系如下：

可以看到，AbstractWrapper和AbstractChainWrapper是重点实现，接下来重点学习AbstractWrapper以及其子类。条件构造器的官网文档地址为：https://mp.baomidou.com/guide/wrapper.html。
说明：QueryWrapper(LambdaQueryWrapper) 和UpdateWrapper(LambdaUpdateWrapper) 的父类用于生成sql的where条件，entity属性也用于生成sql的where条件。但entity生成的where条件与使用各个api生成的where条件没有任何关联行为

5.1.allEq

（1）说明

allEq(Map<R, V> params)
allEq(Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, Map<R, V> params, boolean null2IsNull)
allEq(BiPredicate<R, V> filter, Map<R, V> params)
allEq(BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)

部分参数说明：
params： key 为数据库字段名，value为字段值。
null2IsNull： 为 true时，则在map的value为null时调用isNull方法；为false时，则忽略 value为null时的条件。

例1: allEq({id:1,name:"老王",age:null}) ---> id = 1 and name = '老王' and age is null
例2: allEq({id:1,name:"老王",age:null}, false) ---> id = 1 and name = '老王'

filter： 过滤函数，是否允许字段传入比对条件中 params
（2）编写测试用例

@Test
public void testAlleq(){
    Map<String,Object> params = new HashMap<>();
    params.put("name", "李四");
    params.put("age", "20");
    params.put("password", null);
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //SELECT id,user_name,password,name,age,email FROM tb_user WHERE password IS NULL AND name = ? AND age = ?
    //wrapper.allEq(params);
    
    //SELECT id,user_name,password,name,age,email FROM tb_user WHERE name = ? AND age = ?
    //wrapper.allEq(params,false);
    
    //只有age字段比对成功
    //SELECT id,user_name,password,name,age,email FROM tb_user WHERE age = ?
    //wrapper.allEq((k,v)->(k.equals("age") || k.equals("id")),params);

	//age字段和name字段比对成功
    //Preparing: SELECT id,user_name,password,name,age,email FROM tb_user WHERE name = ? AND age = ?
    wrapper.allEq((k, v) -> (k.equals("age") || k.equals("id") || k.equals("name")) , params);
    
    List<User> users = this.userMapper.selectList(wrapper);
    for (User user : users) {
        System.out.println(user);
    }
}

5.2.基本比较操作

（1）说明

（2）编写测试用例

@Test
public void testEq() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //SELECT id,user_name,password,name,age,email FROM tb_user WHERE password = ? AND age >= ? AND name IN (?,?,?)
    wrapper.eq("password", "123456")
            .ge("age", 20)
            .in("name", "李四", "王五", "赵六");
    List<User> users = this.userMapper.selectList(wrapper);
    for (User user : users) {
        System.out.println(user);
    }
}

5.3.模糊查询

（1）说明

（2）编写测试用例

@Test
public void testLike(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    // SELECT id,user_name,name,age,email AS mail FROM tb_user WHERE name LIKE ?
    // 参数：%五(String)
    wrapper.likeLeft("name", "五");
    
    List<User> users = this.userMapper.selectList(wrapper);
    for (User user : users) {
        System.out.println(user);
    }
}

5.4.排序

（1）说明

（2）编写测试用例

@Test
public void testOrderByAgeDesc(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //按照年龄倒序排序
    wrapper.orderByDesc("age");
    List<User> users = this.userMapper.selectList(wrapper);
    for (User user : users) {
        System.out.println(user);
    }
}

5.5.逻辑查询

（1）说明

（2）编写测试用例

@Test
public void testOr(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    // SELECT id,user_name,name,age,email AS mail FROM tb_user WHERE name = ? OR age = ?
    wrapper.eq("name", "王五").or().eq("age", 21);
    List<User> users = this.userMapper.selectList(wrapper);
    for (User user : users) {
        System.out.println(user);
    }
}

5.6.select

（1）说明
在MP查询中，默认查询所有的字段，如果有需要也可以通过select方法进行指定字段。
（2）编写测试用例

@Test
public void testSelect(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //SELECT id,name,age FROM tb_user WHERE name = ? OR age = ?
    wrapper.eq("name", "王五")
            .or()
            .eq("age", 21)
            .select("id","name","age"); //指定查询的字段
    List<User> users = this.userMapper.selectList(wrapper);
    for (User user : users) {
        System.out.println(user);
    }
}

6.ActiveRecord

6.1.ActiveRecord介绍

（1）ActiveRecord属于ORM（对象关系映射）层，由Rails最早提出，遵循标准的ORM模型：表映射到记录，记录映射到对象，字段映射到对象属性。配合遵循的命名和配置惯例，能够很大程度的快速实现模型的操作，而且简洁易懂。
（2）ActiveRecord的主要思想是：
① 每一个数据库表对应创建一个类，类的每一个对象实例对应于数据库中表的一行记录；通常表的每个字段在类中都有相应的Field；
② ActiveRecord同时负责把自己持久化，在ActiveRecord中封装了对数据库的CURD；
③ ActiveRecord是一种领域模型(Domain Model)，封装了部分业务逻辑；
（3）ActiveRecord（简称AR）一直广受动态语言（ PHP 、 Ruby 等）的喜爱，而 Java 作为准静态语言，对于ActiveRecord 往往只能感叹其优雅，所以我们开发团队也在 AR 道路上进行了一定的探索。

6.2.AR快速入门

（1）在MP中，开启AR非常简单，只需要将实体对象继承Model即可。

package cn.itcast.mp.pojo;

import com.baomidou.mybatisplus.extension.activerecord.Model;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
//@TableName("tb_user")
public class User extends Model<User>{
    
    //@TableId(type = IdType.AUTO)
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
}

（2）编写测试代码

@Test
public void testSelectById(){
    User user = new User();
    user.setId(2L);
    //不需要显示地注入UserMapper
    User user1 = user.selectById();
    System.out.println(user1);
}

7.插件

7.1.MyBatis的插件机制

有关Mybatis中的插件机制方面的知识，作者已经在MyBatis3——入门介绍这篇文章的第10节进行了总结，有需要的读者可以前往查看你，所以此处不再赘述。

7.2.SQL执行分析插件

MP提供了对SQL执行的分析插件，可用作阻断全表更新、删除的操作（注意：该插件仅适用于开发环境，不适用于生产环境）

7.2.1.配置SQL分析插件

下面是在SpringBoot项目的配置类中进行的配置。

@Bean //SQL分析插件
public SqlExplainInterceptor sqlExplainInterceptor(){
    SqlExplainInterceptor sqlExplainInterceptor = new SqlExplainInterceptor();
    List<ISqlParser> list = new ArrayList<>();
    list.add(new BlockAttackSqlParser()); //全表更新、删除的阻断器
    sqlExplainInterceptor.setSqlParserList(list);
    return sqlExplainInterceptor;
}

7.2.2.编写测试代码

@Test
public void testUpdateAll(){
    User user = new User();
    user.setAge(31); // 更新的数据
    //全表更新，但是这对SQL执行分析插件来说是不可取的
    boolean result = user.update(null);
    System.out.println("result => " + result);
}

由于SQL执行分析插件的配置，上述测试代码中的全表更新操作是会被阻断的：

org.apache.ibatis.exceptions.PersistenceException: 
### Error updating database.  Cause: com.baomidou.mybatisplus.core.exceptions.MybatisPlusException: Prohibition of table update operation
### Cause: com.baomidou.mybatisplus.core.exceptions.MybatisPlusException: Prohibition of table update operation

7.3.SQL性能分析插件

SQL性能分析拦截器，用于输出每条 SQL 语句及其执行时间，可以设置最大执行时间，超过时间会抛出异常（该插件只用于开发环境，不建议生产环境使用）。

7.3.1.配置SQL性能分析插件

下面是在MyBatis的全局配置文件mybatis-config.xml中进行的配置。

<plugins>
    <!--配置SQL性能分析插件-->
    <plugin interceptor="com.baomidou.mybatisplus.extension.plugins.PerformanceInterceptor">
        <!--最大执行时间，单位为毫秒-->
        <property name="maxTime" value="100"/>
        <!--对输出的SQL做格式化，默认为false-->
        <property name="format" value="true"/>
    </plugin>
</plugins>

7.3.2.编写测试代码

@Test
public void testSelectById(){
    User user = new User();
    user.setId(2L);
    //不需要显示地注入UserMapper
    User user1 = user.selectById();
    System.out.println(user1);
}

通过上面的结果可以看到，执行时间为5ms。如果将maxTime设置为1，那么，该操作会抛出如下异常。

org.apache.ibatis.exceptions.PersistenceException: 
### Error querying database.  Cause: com.baomidou.mybatisplus.core.exceptions.MybatisPlusException:  The SQL execution time is too large, please optimize ! 
### The error may exist in cn/itcast/mp/mapper/UserMapper.java (best guess)
### The error may involve cn.itcast.mp.mapper.UserMapper.selectById
### The error occurred while handling results
### SQL: SELECT id,user_name,password,name,age,email FROM tb_user WHERE id=?
### Cause: com.baomidou.mybatisplus.core.exceptions.MybatisPlusException:  The SQL execution time is too large, please optimize ! 

7.4.乐观锁插件

7.4.1.乐观锁介绍

（1）乐观锁的目的在于当要更新一条记录的时候，希望这条记录没有被别人更新。
（2）乐观锁实现方式：
① 取出记录时，获取当前version
② 更新时，带上这个version
③ 执行更新时， set version = newVersion where version = oldVersion
④ 如果version不对，则更新失败

7.4.2.插件配置方式

在以下三种方式中任选其一进行配置即可。
（1）在SpringBoot项目的自定义配置类中进行配置

@Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor() {
	return new OptimisticLockerInterceptor();
}

（2）在Spring的配置文件中进行配置

<bean class="com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor"/>

（3）在Mybatis的全局配置文件mybatis-config.xml中进行配置

<plugins>
    <!--配置乐观锁插件-->
    <plugin interceptor="com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor"></plugin>
</plugins>

7.4.3.注解实体字段

（1）为tb_user表添加version字段，并且设置初始值为1

ALTER TABLE `tb_user` ADD COLUMN `version` int(10) NULL AFTER `email`;

UPDATE `tb_user` SET `version`='1';

（2）为User实体对象添加version字段，并且添加@Version注解

//乐观锁的版本字段
@Version
private Integer version;

7.4.4.编写测试代码

@Test
public void testUpdateVersion(){
    User user = new User();
    user.setId(2L);// 查询条件

    User userVersion = user.selectById();

    user.setAge(23); // 更新的数据
    user.setVersion(userVersion.getVersion()); // 当前的版本信息

    boolean result = user.updateById();
    System.out.println("result => " + result);
}

7.4.5.特别说明

（1）版本version支持的数据类型只有:int、Integer、long、Long、Date、Timestamp、LocalDateTime。
（2）整数类型下 newVersion = oldVersion + 1
（3）newVersion 会回写到 entity 中
（4）仅支持 updateById(id) 与 update(entity, wrapper) 方法
（5）在 update(entity, wrapper) 方法下, wrapper 不能复用！

8.Sql 注入器

在MP中，通过AbstractSqlInjector将BaseMapper中的方法注入到了Mybatis容器，这样这些方法才可以正常执行。那么，如果需要扩充BaseMapper中的方法，又应该如何实现呢？下面将以扩展findAll方法为例进行展开学习。

8.1.编写MyBaseMapper

package cn.itcast.mp.mapper;

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

import java.util.List;

public interface MyBaseMapper<T> extends BaseMapper<T> {
    
    //扩充的方法
    List<T> findAll();
}

8.2.编写MySqlInjector

如果直接继承AbstractSqlInjector的话，那么原有的BaseMapper中的方法将失效，所以这里选择继承DefaultSqlInjector进行扩展。

package cn.itcast.mp.injectors;

import com.baomidou.mybatisplus.core.injector.AbstractMethod;
import com.baomidou.mybatisplus.core.injector.DefaultSqlInjector;

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

public class MySqlInjector extends DefaultSqlInjector {
    
    @Override
    public List<AbstractMethod> getMethodList() {
        List<AbstractMethod> list = new ArrayList<>();
        
        // 获取父类中的集合
        list.addAll(super.getMethodList());
        
        // 再扩充自定义的方法
        list.add(new FindAll());
        
        return list;
    }
}

8.3.编写FindAll

package cn.itcast.mp.injectors;

import com.baomidou.mybatisplus.core.injector.AbstractMethod;
import com.baomidou.mybatisplus.core.metadata.TableInfo;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlSource;

public class FindAll extends AbstractMethod {
    @Override
    public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {     
        String sql = "select * from " + tableInfo.getTableName();
        SqlSource sqlSource = languageDriver.createSqlSource(configuration,sql, modelClass);        
        return this.addSelectMappedStatement(mapperClass, "findAll", sqlSource, modelClass, tableInfo);
    }
}

8.4.注册到Spring容器中

在SpringBoot的自定义的配置类中配置MySqlInjector（即将MySqlInjector注册到Spring容器中）

/**
 * 注入自定义的SQL注入器
 * @return
 */
@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<User> {

}

具体的测试方法如下：

@Test
public void testFindAll(){
    List<User> 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;

/**
 * 字段填充策略枚举类
 *
 * <p>
 * 判断注入的 insert 和 update 的 sql 脚本是否在对应情况下忽略掉字段的 if 标签生成
 * <if test="...">......</if>
 * 判断优先级比 {@link FieldStrategy} 高
 * </p>
 *
 * @author hubin
 * @since 2017-06-27
 */
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 {
    /**
        * 插入数据时填充
     * @param metaObject
     */
    @Override
    public void insertFill(MetaObject metaObject) {
        // 先获取到password的值，再进行判断，如果为空，就进行填充，如果不为空，就不做处理
        Object password = getFieldValByName("password", metaObject);
        if(null == password){
           setFieldValByName("password", "888888", metaObject);
        }
    }

    /**
     * 更新数据时填充
     * @param 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<Integer> {

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