lg

1 Mybatis-Plus概念

1.1 Mybatis-Plus介绍

官网: https://mybatis.plus/ 或 https://mp.baomidou.com/

Mybatis-Plus介绍

MyBatis-Plus(简称 MP)是一个 MyBatis 的增强工具,在 MyBatis 的基础上只做增强不做改变,为简化开发、提高效率而生。

愿景

我们的愿景是成为 MyBatis 最好的搭档,就像 魂斗罗 中的 1P、2P,基友搭配,效率翻倍。

1.2 特性

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

1.3 架构

1.4 作者

Mybatis-Plus是由baomidou(苞米豆)组织开发并且开源的,目前该组织大概有30人左右。

码云地址:https://gitee.com/organizations/baomidou

2 Mybatis-Plus快速入门

2.1 安装

全新的 MyBatis-Plus 3.0 版本基于 JDK8,提供了 lambda 形式的调用,所以安装集成 MP3.0 要求如下:

• JDK 8+
• Maven or Gradle

Spring Boot

Maven:

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

Spring MVC

Maven:

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

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

Boot+Mybatis+MP。

2.2 创建数据库以及表

创建User表,其表结构如下:

--
创建测试表
DROP TABLE IF EXISTS tb_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');

2.3 创建工程

导入依赖:

<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>
       <!--连接池-->
       <dependency>
           <groupId>com.alibaba</groupId>
         <artifactId>druid</artifactId>
           <version>1.0.11</version>
       </dependency>
       <!--简化bean代码的工具包-->
       <dependency>
           <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
           <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>

2.4 Mybatis与Mybatis-Plus整合

下面演示,通过纯Mybatis与Mybatis-Plus整合。

创建子Module

<?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>lagou-mybatis-plus</artifactId>
       <groupId>com.lagou.mp</groupId>
       <version>1.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
   <artifactId>lagou-mybatis-plus-simple</artifactId>
</project>

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

Mybatis实现查询User

第一步,编写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>
   <properties resource="jdbc.properties"></properties>
   <!--environments: 运行环境-->
   <environments default="development">
       <environment id="development">
               <!--当前的事务事务管理器是JDBC-->
           <transactionManager type="JDBC"></transactionManager>
               <!--数据源信息 POOLED:使用mybatis的连接池-->
           <dataSource type="POOLED">
               <property name="driver" value="${jdbc.driver}"/>
               <property name="url" value="${jdbc.url}"/>
               <property name="username" value="${jdbc.username}"/>
               <property name="password" value="${jdbc.password}"/>
           </dataSource>
       </environment>
   </environments>
   <!--引入映射配置文件-->
   <mappers>
       <mapper resource="mapper/UserMapper.xml"></mapper>
   </mappers>
</configuration>

第二步,编写User实体对象:(这里使用lombok进行了进化bean操作

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

第三步,编写UserMapper接口:

public interface UserMapper {
   
 List<User> findAll();
}

第四步,编写UserMapper.xml文件:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
       PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
       "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lagou.mapper.UserMapper">
   <!-- 查询所有 -->
   <select id="findAll" resultType="com.lagou.pojo.User">
     
select * from user
   </select>
</mapper>

第五步,编写TestMybatis测试用例:

public class MPTest {
   @Test
   public void test1() throws IOException {
       InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
       SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
       SqlSession sqlSession = sqlSessionFactory.openSession();
       UserMapper mapper = sqlSession.getMapper(UserMapper.class);
       List<User> all = mapper.findAll();
       for (User user : all) {
           System.out.println(user);
     }
  }
}

测试结果:

User(id=1, name=Jone, age=18, email=test1@baomidou.com)
User(id=2, name=Jack, age=20, email=test2@baomidou.com)
User(id=3, name=Tom, age=28, email=test3@baomidou.com)
User(id=4, name=Sandy, age=21, email=test4@baomidou.com)
User(id=5, name=Billie, age=24, email=test5@baomidou.com)

注:如果实体类名称和表名称不一致,可以在实体类上添加注解@TableName("指定数据库表名")

Mybatis+MP实现查询User

第一步,将UserMapper继承BaseMapper,将拥有了BaseMapper中的所有方法:

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.lagou.pojo.User;
  public interface UserMapper extends BaseMapper<User> {
}

第二步,使用MP中的MybatisSqlSessionFactoryBuilder进程构建:

@Test
public void test2() throws IOException {
   InputStream resourceAsStream =
= Resources.getResourceAsStream("sqlMapConfig.xml");
   //这里使用的是MP中的MybatisSqlSessionFactoryBuilder
   SqlSessionFactory sqlSessionFactory = new MybatisSqlSessionFactoryBuilder().build(resourceAsStream);
   SqlSession sqlSession = sqlSessionFactory.openSession();
   UserMapper mapper = sqlSession.getMapper(UserMapper.class);
   // 可以调用BaseMapper中定义的方法
   List<User> all = mapper.selectList(null);
   for (User user : all) {
       System.out.println(user);
 
  }
}

测试:

User(id=1, name=Jone, age=18, email=test1@baomidou.com)
User(id=2, name=Jack, age=20, email=test2@baomidou.com)
User(id=3, name=Tom, age=28, email=test3@baomidou.com)
User(id=4, name=Sandy, age=21, email=test4@baomidou.com)
User(id=5, name=Billie, age=24, email=test5@baomidou.com)

注:如果实体类名称和表名称不一致,可以在实体类上添加注解@TableName("指定数据库表名")

简单说明:

• 由于使用了 MybatisSqlSessionFactoryBuilder进行了构建,继承的BaseMapper中的方法就载入到了SqlSession中,所以就可以直接使用相关的方法;
• 如图

2.5 Spring + Mybatis + Mybatis-Plus

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

创建子Module

<?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>lagou-mybatis-plus</artifactId>
       <groupId>com.lagou.mp</groupId>
       <version>1.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
   <artifactId>lagou-mybatis-plus-spring</artifactId>

实现查询User

第一步,编写jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/mp?serverTimezone=GMT%2B8&useSSL=false
jdbc.username=root
jdbc.password=root

第二步,编写applicationContext.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">
   <!--引入properties-->
   <context:property-placeholder location="classpath:jdbc.properties"/>
   <!--dataSource-->
   <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
       <property name="driverClassName" value="${jdbc.driver}"/>
       <property name="url" value="${jdbc.url}"/>
       <property name="username" value="${jdbc.username}"/>
       <property name="password" value="${jdbc.password}"/>
   </bean>
   <!--这里使用MP提供的sqlSessionFactory,完成spring与mp的整合-->
   <bean id="sqlSessionFactory"
class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
       <property name="dataSource" ref="dataSource"/>
   </bean>
   <!--扫描mapper接口,使用的依然是mybatis原生的扫描器-->
   <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
       <property name="basePackage" value="com.lagou.mapper"/>
   </bean>
</beans>

第三步,编写User对象以及UserMapper接口:

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

public interface UserMapper extends BaseMapper<User> {
       List<User> findAll();
}

第四步,编写测试用例:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class TestSpringMP {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void test2() throws IOException {
       List<User> users = this.userMapper.selectList(null);
       for (User user : users) {
           System.out.println(user);
    
    }
}

2.6 SpringBoot + Mybatis + Mybatis-Plus

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

创建工程

导入依赖

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

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

编写application.properties

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

编写pojo

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

编写mapper

public interface UserMapper extends BaseMapper<User> {
}

编写启动类

package com.lagou.mp;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
@MapperScan("com.lagou.mp.mapper") //设置mapper接口的扫描包
@SpringBootApplication
public class MyApplication {
   public static void main(String[] args) {
       SpringApplication.run(MyApplication.class, args);
  }
}

编写测试用例

package com.lagou.mp;
import com.lagou.mp.mapper.UserMapper;
import com.lagou.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;
import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testSelect() {
       List<User> userList = userMapper.selectList(null);
       for (User user : userList) {
           System.out.println(user);
      }
  }
}

测试:

User(id=1, name=Jone, age=18, email=test1@baomidou.com)
User(id=2, name=Jack, age=20, email=test2@baomidou.com)
User(id=3, name=Tom, age=28, email=test3@baomidou.com)
User(id=4, name=Sandy, age=21, email=test4@baomidou.com)
User(id=5, name=Billie, age=24, email=test5@baomidou.com)

3 通用CRUD

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

3.1 插入操作

方法定义

   /**
    * 插入一条记录
    *
    * @param entity 实体对象.
    */
   int insert(T entity);

测试用例

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testInsert(){
       User user = new User();
       user.setAge(18);
       user.setEmail("test@lagou.cn");
       user.setName("子慕");
       //返回的result是受影响的行数,并不是自增后的id
       int result = userMapper.insert(user);
       System.out.println(result);
       System.out.println(user.getId());
  }
}

测试

1
1318744682116739074

可以看到,数据已经写入到了数据库,但是,id的值不正确,我们期望的是数据库自增长,实际是MP

生成了id的值写入到了数据库。

如何设置id的生成策略呢?

MP支持的id策略:

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对象:

package com.lagou.mp.pojo;
import com.baomidou.mybatisplus.annotation.IdType;
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) //指定id类型为自增长
   private Long id;
   private String userName;
   private String password;
   private String name;
   private Integer age;
   private String email;
}

数据插入成功:

@TableField

在MP中通过@TableField注解可以指定字段的一些属性,常常解决的问题有2个:

1、对象中的属性名和字段名不一致的问题(非驼峰)

2、对象中的属性字段在表中不存在的问题

使用:

其他用法,如大字段不加入查询字段:

效果:

3.2 更新操作

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

根据id更新

方法定义:

   /**
    * 根据 ID 修改
    *
    * @param entity 实体对象
    */
   int updateById(@Param(Constants.ENTITY) T entity);

测试:

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testUpdateById() {
       User user = new User();
       user.setId(6L); //主键
       user.setAge(21); //更新的字段
       //根据id更新,更新不为null的字段
       this.userMapper.updateById(user);
 
  }
}

结果:

根据条件更新

方法定义:

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

测试用例:

package com.lagou.mp;
import com.lagou.mp.mapper.UserMapper;
import com.lagou.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import net.minidev.json.writer.UpdaterMapper;
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;
import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testUpdate() {
       User user = new User();
       user.setAge(22); //更新的字段
       //更新的条件
       QueryWrapper<User> wrapper = new QueryWrapper<>();
       wrapper.eq("id", 6);
       //执行更新操作
       int result = this.userMapper.update(user, wrapper);
       System.out.println("result = " + result);
 
  }
}

或者,通过UpdateWrapper进行更新:

 @Test
   public void testUpdate() {
       //更新的条件以及字段
       UpdateWrapper<User> wrapper = new UpdateWrapper<>();
       wrapper.eq("id", 6).set("age", 23);
       //执行更新操作
       int result = this.userMapper.update(null, wrapper);
       System.out.println("result = " + result);
 
}

测试结果:

[main] [com.lagou.mp.mapper.UserMapper.update]-[DEBUG] ==>  Preparing: UPDATE tb_user SET age=? WHERE id = ?
[main] [com.lagou.mp.mapper.UserMapper.update]-[DEBUG] ==> Parameters: 23(Integer), 6(Integer)
[main] [com.lagou.mp.mapper.UserMapper.update]-[DEBUG] <==    Updates: 1

均可达到更新的效果。

关于wrapper更多的用法后面会详细讲解。

3.3 删除操作

deleteById

方法定义:

/**
* 根据 ID 删除
*
* @param id 主键ID
*/
int deleteById(Serializable id);

测试用例:

package com.lagou.mp;


import com.lagou.mp.mapper.UserMapper;
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 UserMapperTest {


   @Autowired
   private UserMapper userMapper;


   @Test
   public void testDeleteById() {
       //执行删除操作
       int result = this.userMapper.deleteById(6L);
       System.out.println("result = " + result);
  }
}

结果:

[main] [com.lagou.mp.mapper.UserMapper.deleteById]-[DEBUG] ==>  Preparing: DELETE FROM tb_user WHERE id=?
[main] [com.lagou.mp.mapper.UserMapper.deleteById]-[DEBUG] ==> Parameters: 6(Long)
[main] [com.lagou.mp.mapper.UserMapper.deleteById]-[DEBUG] <==    Updates: 1

数据被删除。

deleteByMap

方法定义:

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

测试用例:

package com.lagou.mp;
import com.lagou.mp.mapper.UserMapper;
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;
import java.util.HashMap;
import java.util.Map;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testDeleteByMap() {
       Map<String, Object> columnMap = new HashMap<>();
       columnMap.put("age",21);
       columnMap.put("name","子慕");
       //将columnMap中的元素设置为删除的条件,多个之间为and关系
       int result = this.userMapper.deleteByMap(columnMap);
       System.out.println("result = " + result);
 
  }
}

结果:

[main] [com.lagou.mp.mapper.UserMapper.deleteByMap]-[DEBUG] ==> Preparing: DELETE FROM tb_user WHERE name = ? AND age = ?
[main] [com.lagou.mp.mapper.UserMapper.deleteByMap]-[DEBUG] ==> Parameters: 子慕 (String), 21(Integer)
[main] [com.lagou.mp.mapper.UserMapper.deleteByMap]-[DEBUG] <==    Updates: 0

delete

方法定义:

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

测试用例:

package com.lagou.mp;
import com.lagou.mp.mapper.UserMapper;
import com.lagou.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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;
import java.util.HashMap;
import java.util.Map;


@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;


   @Test
   public void testDeleteByMap() {
       User user = new User();
       user.setAge(20);
       user.setName("子慕");
       //将实体对象进行包装,包装为操作条件
       QueryWrapper<User> wrapper = new QueryWrapper<>(user);
       int result = this.userMapper.delete(wrapper);
       System.out.println("result = " + result);
 
  }
}

结果:

[main] [com.lagou.mp.mapper.UserMapper.delete]-[DEBUG] ==> Preparing: DELETE FROM tb_user WHERE name=? AND age=?
[main] [com.lagou.mp.mapper.UserMapper.delete]-[DEBUG] ==> Parameters: 子慕 (String), 20(Integer)
[main] [com.lagou.mp.mapper.UserMapper.delete]-[DEBUG] <==    Updates: 0

deleteBatchIds

方法定义:

 /**
    * 删除(根据ID 批量删除)
    *
    * @param idList 主键ID列表(不能为 null 以及 empty)
    */
   int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

测试用例:

package com.lagou.mp;
import com.lagou.mp.mapper.UserMapper;
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;
import java.util.Arrays;


@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;


   @Test
   public void testDeleteByMap() {
       //根据id集合批量删除
       int result = this.userMapper.deleteBatchIds(Arrays.asList(1L,10L,20L));
       System.out.println("result = " + result);
 
  }
}

结果:

[main] [com.lagou.mp.mapper.UserMapper.deleteBatchIds]-[DEBUG] ==>  Preparing: DELETE FROM tb_user WHERE id IN ( ? , ? , ? )
[main] [com.lagou.mp.mapper.UserMapper.deleteBatchIds]-[DEBUG] ==> Parameters: 1(Long), 10(Long), 20(Long)
[main] [com.lagou.mp.mapper.UserMapper.deleteBatchIds]-[DEBUG] <==    Updates: 1

3.4 查询操作

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

3.4.1、selectById

方法定义:

   /**
    * 根据 ID 查询
    *
    * @param id 主键ID
    */
   T selectById(Serializable id);

测试用例:

package com.lagou.mp;
import com.lagou.mp.mapper.UserMapper;
import com.lagou.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 UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testSelectById() {
       //根据id查询数据
       User user = this.userMapper.selectById(2L);
       System.out.println("result = " + user);
 
  }
}

结果:

result = User(id=2, name=Jack, age=20, email=test2@baomidou.com)

3.4.2、selectBatchIds

方法定义:

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

测试用例:

package com.lagou.mp;


import com.lagou.mp.mapper.UserMapper;
import com.lagou.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;
import java.util.Arrays;
import java.util.List;


@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;


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

结果:

User(id=2, name=Jack, age=20, email=test2@baomidou.com)
User(id=3, name=Tom, age=28, email=test3@baomidou.com)

3.4.3、selectOne

方法定义:

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

测试用例:

package com.lagou.mp;


import com.lagou.mp.mapper.UserMapper;
import com.lagou.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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 UserMapperTest {
   @Autowired
   private UserMapper userMapper;


     @Test
   public void testSelectOne() {
       QueryWrapper<User> wrapper = new QueryWrapper<User>();
       wrapper.eq("name", "jack");
       //根据条件查询一条数据,如果结果超过一条会报错
       User user = this.userMapper.selectOne(wrapper);
       System.out.println(user);
 
  }
}

结果:

User(id=2, name=Jack, age=20, email=test2@baomidou.com)

3.4.4、selectCount

方法定义:

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

测试用例:

package com.lagou.mp;


import com.lagou.mp.mapper.UserMapper;
import com.lagou.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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 UserMapperTest {
   @Autowired
   private UserMapper userMapper;


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

结果:

count = 2

3.4.5、selectList

方法定义:

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

测试用例:

package com.lagou.mp;


import com.lagou.mp.mapper.UserMapper;
import com.lagou.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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;
import java.util.List;


@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;


   @Test
   public void testSelectList() {
       QueryWrapper<User> wrapper = new QueryWrapper<User>();
       wrapper.gt("age", 23); //年龄大于23岁
       //根据条件查询数据
       List<User> users = this.userMapper.selectList(wrapper);
       for (User user : users) {
           System.out.println("user = " + user);
      }
    }
}

结果:

user = User(id=3, name=Tom, age=28, email=test3@baomidou.com)
user = User(id=5, name=Billie, age=24, email=test5@baomidou.com)

3.4.6、selectPage

方法定义:

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

配置分页插件:

package com.lagou.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
@MapperScan("com.lagou.mp.mapper") //设置mapper接口的扫描包
public class MybatisPlusConfig {
   /**
    * 分页插件
    */
   @Bean
   public PaginationInterceptor paginationInterceptor() {
       return new PaginationInterceptor();
 
  }
}

测试用例:

package com.lagou.mp;
import com.lagou.mp.mapper.UserMapper;
import com.lagou.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
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;
import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testSelectPage() {
       QueryWrapper<User> wrapper = new QueryWrapper<User>();
       wrapper.gt("age", 20); //年龄大于20岁
       Page<User> page = new Page<>(1,1);
       //根据条件查询数据
       IPage<User> iPage = this.userMapper.selectPage(page, wrapper);
       System.out.println("数据总条数:" + iPage.getTotal());
       System.out.println("总页数:" + iPage.getPages());
       List<User> users = iPage.getRecords();
       for (User user : users) {
           System.out.println("user = " + user);
     
 
      }
  }
}

结果:

数据总条数:4
总页数:4
user = User(id=3, name=Tom, age=28, email=test3@baomidou.com)

3.5 SQL注入的原理

前面我们已经知道,MP在启动后会将BaseMapper中的一系列的方法注册到meppedStatements中,那么究竟是如何注入的呢?流程又是怎么样的?下面我们将一起来分析下。

在MP中,ISqlInjector负责SQL的注入工作,它是一个接口,AbstractSqlInjector是它的实现类,实现

关系如下:

在AbstractSqlInjector中,主要是由inspectInject()方法进行注入的,如下:

@Override
public void inspectInject(MapperBuilderAssistant builderAssistant, Class<?> mapperClass) {
   Class<?> modelClass = extractModelClass(mapperClass);
   if (modelClass != null) {
       String className = mapperClass.toString();
       Set<String> mapperRegistryCache = GlobalConfigUtils.getMapperRegistryCache(builderAssistant.getConfiguration());
       if (!mapperRegistryCache.contains(className)) {
           List<AbstractMethod> methodList = this.getMethodList();
           if (CollectionUtils.isNotEmpty(methodList)) {
               TableInfo tableInfo = TableInfoHelper.initTableInfo(builderAssistant, modelClass);
               // 循环注入自定义方法
               methodList.forEach(m -> m.inject(builderAssistant, mapperClass, modelClass, tableInfo));
         
            } else {
               logger.debug(mapperClass.toString() + ", No effective injection method was found.");
         
}
           mapperRegistryCache.add(className);
     
 
          }
      }
}

在实现方法中, methodList.forEach(m -> m.inject(builderAssistant, mapperClass,

modelClass, tableInfo)); 是关键,循环遍历方法,进行注入。

最终调用抽象方法injectMappedStatement进行真正的注入:

 /**
    * 注入自定义 MappedStatement
    *
    * @param mapperClass mapper 接口
    * @param modelClass mapper 泛型
    * @param tableInfo   数据库表反射信息
    * @return MappedStatement
    */
   public abstract MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo);

查看该方法的实现:

以SelectById为例查看:

public class SelectById extends AbstractMethod {
   @Override
   public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
       SqlMethod sqlMethod = SqlMethod.LOGIC_SELECT_BY_ID;
       SqlSource sqlSource = new RawSqlSource(configuration, String.format(sqlMethod.getSql(),
           sqlSelectColumns(tableInfo, false),
           tableInfo.getTableName(), tableInfo.getKeyColumn(), tableInfo.getKeyProperty(),
           tableInfo.getLogicDeleteSql(true, false)), Object.class);
       return this.addSelectMappedStatement(mapperClass, sqlMethod.getMethod(), sqlSource, modelClass, tableInfo);
 
  }
}

可以看到,生成了SqlSource对象,再将SQL通过addSelectMappedStatement方法添加到

meppedStatements中。

4 配置

在MP中有大量的配置,其中有一部分是Mybatis原生的配置,另一部分是MP的配置,详情:https://m

ybatis.plus/config/

下面我们对常用的配置做讲解。

4.1、基本配置

4.1.1、configLocation

MyBatis 配置文件位置,如果有单独的 MyBatis 配置,请将其路径配置到 configLocation 中。

MyBatis Configuration 的具体内容请参考MyBatis 官方文档

Spring Boot:

mybatis-plus.config-location = classpath:mybatis-config.xml

Spring MVC:

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

4.1.2、mapperLocations

MyBatis Mapper 所对应的 XML 文件位置,如果您在 Mapper 中有自定义方法(XML 中有自定义实

现),需要进行该配置,告诉 Mapper 所对应的 XML 文件位置。

Spring Boot:

mybatis-plus.mapper-locations = classpath*:mybatis/*.xml

Spring MVC:

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

Maven 多模块项目的扫描路径需以 classpath*: 开头 (即加载多个 jar 包下的 XML 文件)

测试:

UserMapper.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
       PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
       "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lagou.mp.mapper.UserMapper">
   <select id="findById" resultType="com.lagou.mp.pojo.User">
   
select * from tb_user where id = #{id}
   </select>
</mapper>

package com.lagou.mp.mapper;
import com.lagou.mp.pojo.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
public interface UserMapper extends BaseMapper<User> {
   User findById(Long id);
}

测试用例:

package com.lagou.mp;
import com.lagou.mp.mapper.UserMapper;
import com.lagou.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 UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testSelectPage() {
       User user = this.userMapper.findById(2L);
       System.out.println(user);
 
  }
}

运行结果:

4.1.3、typeAliasesPackage

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

Spring Boot:

mybatis-plus.type-aliases-package = com.lagou.mp.pojo

Spring MVC:

<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

• 类型: boolean
• 默认值: true

是否开启自动驼峰命名规则(camel case)映射,即从经典数据库列名 A_COLUMN(下划线命名) 到

经典 Java 属性名 aColumn(驼峰命名) 的类似映射。

注意:

此属性在 MyBatis 中原默认值为 false,在 MyBatis-Plus 中,此属性也将用于生成最终的 SQL 的select body

如果您的数据库命名符合规则无需使用 @TableField 注解指定数据库字段名

示例(SpringBoot):

#关闭自动驼峰映射,该参数不能和mybatis-plus.config-location同时存在
mybatis-plus.configuration.map-underscore-to-camel-case=false

4.2.2、cacheEnabled

• 类型: boolean
• 默认值: true

全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存,默认为 true。

示例:

mybatis-plus.configuration.cache-enabled=false

4.3、DB 策略配置

4.3.1、idType

• 类型: com.baomidou.mybatisplus.annotation.IdType
• 默认值: ID_WORKER

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

示例:

SpringBoot:

mybatis-plus.global-config.db-config.id-type=auto

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

• 类型: String
• 默认值: null

表名前缀,全局配置后可省略@TableName()配置。

SpringBoot:

mybatis-plus.global-config.db-config.table-prefix=tb_

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以及其子类。

说明:

QueryWrapper(LambdaQueryWrapper) 和 UpdateWrapper(LambdaUpdateWrapper) 的父类用于生成 sql 的 where 条件, entity 属性也用于生成 sql 的 where 条件

注意: entity 生成的 where 条件与 使用各个 api 生成的 where 条件没有任何关联行为

官网文档地址:https://mybatis.plus/guide/wrapper.html

5.1、allEq

5.1.1、说明

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

• 全部eq (opens new window)(或个别isNull (opens new window))

个别参数说明:

params : key 为数据库字段名, value 为字段值

null2IsNull : 为 true 则在 map 的 value 为 null 时调用 isNull (opens new window) 方法,为 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 = '老王'

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)

个别参数说明:

filter : 过滤函数,是否允许字段传入比对条件中

params 与 null2IsNull : 同上

例1: allEq((k,v) -> k.indexOf("a") > 0, {id:1,name:"老王",age:null}) ---> name = '老王' and age is null


例2: allEq((k,v) -> k.indexOf("a") > 0, {id:1,name:"老王",age:null}, false) ---> name = '老王'

5.1.2、测试用例

package com.lagou.mp;
import com.lagou.mp.mapper.UserMapper;
import com.lagou.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testWrapper() {
       QueryWrapper<User> wrapper = new QueryWrapper<>();
       //设置条件
       Map<String,Object> params = new HashMap<>();
       params.put("name", "jack");
       params.put("age", "20");
//      
wrapper.allEq(params);//SELECT * FROM tb_user WHERE password IS NULL
AND name = ? AND age = ?
//      wrapper.allEq(params,false); //SELECT * FROM tb_user WHERE name = ? AND age = ?
//      wrapper.allEq((k, v) -> (k.equals("name") || k.equals("age")) ,params);
//SELECT * FROM tb_user WHERE name = ? AND age = ?
       List<User> users = this.userMapper.selectList(wrapper);
       for (User user : users) {
           System.out.println(user);
     
 
       }
    }
}

5.2、基本比较操作

• eq

• • 等于 =

• ne

• • 不等于 <>

• gt

• • 大于 >

• ge

• • 大于等于 >=

• lt

• • 小于 <

• le

• • 小于等于 <=

• between

• • BETWEEN 值1 AND 值2

• notBetween

• • NOT BETWEEN 值1 AND 值2

• in

• • `字段 IN (value.get(0), value.get(1), ...)

• notIn

• 1字段 NOT IN (v0, v1, ...)

测试用例:

package com.lagou.mp;


import com.lagou.mp.mapper.UserMapper;
import com.lagou.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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;
import java.util.List;


@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
    QueryWrapper<User> wrapper = new QueryWrapper<>();
       //SELECT id,name,age,email FROM tb_user WHERE password = ? AND age >= ? AND name IN (?,?,?)
       wrapper.eq("email", "test2@baomidou.com")
              .ge("age", 20)
              .in("name", "jack", "jone", "tom");
       List<User> users = this.userMapper.selectList(wrapper);
       for (User user : users) {
           System.out.println(user);
     
 
        }
    }
}

5.3、模糊查询

• like

• • LIKE '%值%'
  • 例: like("name", "王") ---> name like '%王%'

• notLike

• • NOT LIKE '%值%'
  • 例: notLike("name", "王") ---> name not like '%王%'

• likeLeft

• • LIKE '%值'
  • 例: likeLeft("name", "王") ---> name like '%王'

• likeRight

• • LIKE '值%'
  • 例: likeRight("name", "王") ---> name like '王%'

测试用例:

package com.lagou.mp;
import com.lagou.mp.mapper.UserMapper;
import com.lagou.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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;
import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testWrapper() {
         QueryWrapper<User> wrapper = new QueryWrapper<>();
       //SELECT id,user_name,password,name,age,email FROM tb_user WHERE name
LIKE ?
       //Parameters: %子%(String)
       wrapper.like("name", "子");
       List<User> users = this.userMapper.selectList(wrapper);
       for (User user : users) {
           System.out.println(user);
     
 
      }
    }
}

5.4、排序

• orderBy

• • 排序:ORDER BY 字段, ...
  • 例: orderBy(true, true, "id", "name") ---> order by id ASC,name ASC

• orderByAsc

• • 1排序:ORDER BY 字段, ... ASC
  • 例: orderByAsc("id", "name") ---> order by id ASC,name ASC

• orderByDesc

• • 排序:ORDER BY 字段, ... DESC
  • 例: orderByDesc("id", "name") ---> order by id DESC,name DESC

测试用例:

package com.lagou.mp;


import com.lagou.mp.mapper.UserMapper;
import com.lagou.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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;


import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testWrapper() {
       QueryWrapper<User> wrapper = new QueryWrapper<>();
       //SELECT id,user_name,password,name,age,email FROM tb_user ORDER BY age DESC
       wrapper.orderByDesc("age");
       List<User> users = this.userMapper.selectList(wrapper);
       for (User user : users) {
           System.out.println(user);
     
 
      }
  }
}

5.5、逻辑查询

• or

• • 拼接 OR
  • q主动调用 or 表示紧接着下一个方法不是用 and 连接!(不调用 or 则默认为使用 and 连接)

• and

• • AND 嵌套
  • 例: and(i -> i.eq("name", "李白").ne("status", "活着")) ---> and (name = '李白' and status <> '活着')

测试用例:

package com.lagou.mp;
import com.lagou.mp.mapper.UserMapper;
import com.lagou.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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;
import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testWrapper() {
       QueryWrapper<User> wrapper = new QueryWrapper<>();
       //SELECT id,user_name,password,name,age,email FROM tb_user WHERE name = ? OR age = ?
       wrapper.eq("name","jack").or().eq("age", 24);
       List<User> users = this.userMapper.selectList(wrapper);
       for (User user : users) {
           System.out.println(user);
     
 
        }
    }
}

5.6、select

在MP查询中,默认查询所有的字段,如果有需要也可以通过select方法进行指定字段。

package com.lagou.mp;
import com.lagou.mp.mapper.UserMapper;
import com.lagou.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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;
import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testWrapper() {
       QueryWrapper<User> wrapper = new QueryWrapper<>();
       //SELECT id,name,age FROM tb_user WHERE name = ? OR age = ?
       wrapper.eq("name", "jack")
              .or()
              .eq("age", 24)
              .select("id", "name", "age");
       List<User> users = this.userMapper.selectList(wrapper);
       for (User user : users) {
           System.out.println(user);
   
 
        }
    }
}

6 ActiveRecord

ActiveRecord(简称AR)一直广受动态语言( PHP 、 Ruby 等)的喜爱,而 Java 作为准静态语言,对

于 ActiveRecord 往往只能感叹其优雅,所以我们也在 AR 道路上进行了一定的探索,喜欢大家能够喜欢。

什么是ActiveRecord?

ActiveRecord也属于ORM(对象关系映射)层,由Rails最早提出,遵循标准的ORM模型:表映

射到记录,记录映射到对象,字段映射到对象属性。配合遵循的命名和配置惯例,能够很大程度

的快速实现模型的操作,而且简洁易懂。

ActiveRecord的主要思想是:

• 每一个数据库表对应创建一个类,类的每一个对象实例对应于数据库中表的一行记录;通常

表的每个字段在类中都有相应的Field;

• ActiveRecord同时负责把自己持久化,在ActiveRecord中封装了对数据库的访问,即

CURD;;

• ActiveRecord是一种领域模型(Domain Model),封装了部分业务逻辑;

6.1、开启AR之旅

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

package com.lagou.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 com.baomidou.mybatisplus.extension.activerecord.Model;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User extends Model<User> {
   private Long id;
   private String userName;
   private String password;
   private String name;
   private Integer age;
   private String email;
}

6.2、根据主键查询

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testAR() {
       User user = new User();
       user.setId(2L);
       User user2 = user.selectById();
       System.out.println(user2);
 
  }
}

6.3、新增数据

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testARInsert() {
       User user = new User();
       user.setName("应颠");
       user.setAge(30);
       user.setEmail("liubei@lagou.cn");
       boolean insert = user.insert();
       System.out.println(insert);
 
  }
}

结果:

[main] [com.lagou.mp.mapper.UserMapper.insert]-[DEBUG] ==> Preparing: INSERT INTO tb_user ( name, age, email ) VALUES ( ?, ?, ?, ?, ? )
[main] [com.lagou.mp.mapper.UserMapper.insert]-[DEBUG] ==> Parameters: 刘备 (String), 30(Integer), liubei@lagou.cn(String)
[main] [com.lagou.mp.mapper.UserMapper.insert]-[DEBUG] <==    Updates: 1

6.4、更新操作

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testAR() {
       User user = new User();
       user.setId(8L);
       user.setAge(35);
       boolean update = user.updateById();
       System.out.println(update);
 
   }
}

结果:

[main] [com.lagou.mp.mapper.UserMapper.updateById]-[DEBUG] ==>  Preparing: UPDATE tb_user SET age=? WHERE id=?
[main] [com.lagou.mp.mapper.UserMapper.updateById]-[DEBUG] ==> Parameters: 35(Integer), 8(Long)
[main] [com.lagou.mp.mapper.UserMapper.updateById]-[DEBUG] <==    Updates: 1

6.5、删除操作

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testAR() {
       User user = new User();
       user.setId(7L);
       boolean delete = user.deleteById();
       System.out.println(delete);
 
  }
}

结果:

[main] [com.lagou.mp.mapper.UserMapper.deleteById]-[DEBUG] ==>  Preparing: DELETE FROM tb_user WHERE id=?
[main] [com.lagou.mp.mapper.UserMapper.deleteById]-[DEBUG] ==> Parameters: 7(Long)
[main] [com.lagou.mp.mapper.UserMapper.deleteById]-[DEBUG] <==    Updates: 1

6.6、根据条件查询

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
   @Autowired
   private UserMapper userMapper;
   @Test
   public void testARFindById() {
       User user = new User();
       QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
       userQueryWrapper.le("age","20");
       List<User> users = user.selectList(userQueryWrapper);
       for (User user1 : users) {
           System.out.println(user1);
     
 
      }
  }
}

结果:

User(id=1, name=Jone, age=18, email=test1@baomidou.com)
User(id=2, name=Jack, age=20, email=test2@baomidou.com)
User(id=7, name=子慕, age=18, email=test@lagou.cn)

7 插件

7.1、mybatis的插件机制

MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下,MyBatis 允许使用插件来拦截的方法调用包括:

1. Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
2. ParameterHandler (getParameterObject, setParameters)
3. ResultSetHandler (handleResultSets, handleOutputParameters)
4. StatementHandler (prepare, parameterize, batch, update, query)

我们看到了可以拦截Executor接口的部分方法,比如update,query,commit,rollback等方法,还有

其他接口的一些方法等。

总体概括为:

1. 拦截执行器的方法
2. 拦截参数的处理
3. 拦截结果集的处理
4. 拦截Sql语法构建的处理

拦截器示例:

package com.lagou.mp.plugins;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.*;
import java.util.Properties;
@Intercepts({@Signature(
       type= Executor.class,
       method = "update",
       args = {MappedStatement.class,Object.class})})
public class MyInterceptor implements Interceptor {
   @Override
   public Object intercept(Invocation invocation) throws Throwable {
       //拦截方法,具体业务逻辑编写的位置
       return invocation.proceed();
 
  }
   @Override
   public Object plugin(Object target) {
       //创建target对象的代理对象,目的是将当前拦截器加入到该对象中
       return Plugin.wrap(target, this);
 
  }
   @Override
   public void setProperties(Properties properties) {
       //属性设置
   }
}

注入到Spring容器:

   /**
    * 自定义拦截器
    */
   @Bean
   public MyInterceptor myInterceptor(){
       return new MyInterceptor();
 
}

或者通过xml配置,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>
   <plugins>
       <plugin interceptor="com.lagou.mp.plugins.MyInterceptor"></plugin>
   </plugins>
</configuration>

7.2、执行分析插件

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

SpringBoot配置:

@Bean
public SqlExplainInterceptor sqlExplainInterceptor(){
   SqlExplainInterceptor sqlExplainInterceptor = new SqlExplainInterceptor();
   List<ISqlParser> sqlParserList = new ArrayList<>();
   // 攻击 SQL 阻断解析器、加入解析链
   sqlParserList.add(new BlockAttackSqlParser());
   sqlExplainInterceptor.setSqlParserList(sqlParserList);
   return sqlExplainInterceptor;
}

测试:

@Test
public void testUpdate(){
   User user = new User();
   user.setAge(20);
   int result = this.userMapper.update(user, null);
   System.out.println("result = " + result);
}

结果:

可以看到,当执行全表更新时,会抛出异常,这样有效防止了一些误操作。

7.3、性能分析插件

性能分析拦截器,用于输出每条 SQL 语句及其执行时间,可以设置最大执行时间,超过时间会抛出异常。

该插件只用于开发环境,不建议生产环境使用。

配置:

javaconfig方式

@Bean
public PerformanceInterceptor performanceInterceptor(){
   PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
   performanceInterceptor.setMaxTime(100);
   performanceInterceptor.setFormat(true);
   return performanceInterceptor;
}

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

执行结果:

Time:11 ms - ID:com.lagou.mp.mapper.UserMapper.selectById Execute SQL:
SELECT id,
        user_name,
        password,
        name,
        age,
        email
FROM tb_user
WHERE
id=7

可以看到,执行时间为11ms。如果将maxTime设置为1,那么,该操作会抛出异常。

Caused by: com.baomidou.mybatisplus.core.exceptions.MybatisPlusException:  The
SQL execution time is too large, please optimize !
    at
com.baomidou.mybatisplus.core.toolkit.ExceptionUtils.mpe(ExceptionUtils.java:49)
    at com.baomidou.mybatisplus.core.toolkit.Assert.isTrue(Assert.java:38)
    ................

7.4、乐观锁插件

7.4.1、主要适用场景

意图:

当要更新一条记录的时候,希望这条记录没有被别人更新

乐观锁实现方式:

取出记录时,获取当前version

更新时,带上这个version

执行更新时, set version = newVersion where version = oldVersion

如果version不对,就更新失败

7.4.2、插件配置

spring xml:

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

spring boot:

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

7.4.3、注解实体字段

需要为实体字段添加@Version注解。

第一步,为表添加version字段,并且设置初始值为1:

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


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

第二步,为User实体对象添加version字段,并且添加@Version注解:

@Version
private Integer version;

7.4.4、测试

测试用例:

@Test
public void testUpdate(){
   User user = new User();
   user.setAge(30);
   user.setId(2L);
   user.setVersion(1); //获取到version为1
   int result = this.userMapper.updateById(user);
   System.out.println("result = " + result);
}

执行日志:

可以看到,更新的条件中有version条件,并且更新的version为2。

如果再次执行,更新则不成功。这样就避免了多人同时更新时导致数据的不一致。

7.4.5、特别说明

• 支持的数据类型只有:int,Integer,long,Long,Date,Timestamp,LocalDateTime
• 整数类型下 newVersion = oldVersion + 1
• newVersion 会回写到 entity 中
• 仅支持 updateById(id) 与 update(entity, wrapper) 方法
• 在 update(entity, wrapper) 方法下, wrapper 不能复用!!!

8 Sql 注入器

我们已经知道,在MP中,通过AbstractSqlInjector将BaseMapper中的方法注入到了Mybatis容器,这样这些方法才可以正常执行。

那么,如果我们需要扩充BaseMapper中的方法,又该如何实现呢?

下面我们以扩展findAll方法为例进行学习。

8.1、编写MyBaseMapper

package com.lagou.mp.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import java.util.List;
public interface MyBaseMapper<T> extends BaseMapper<T> {
   List<T>  findAll();
}

其他的Mapper都可以继承该Mapper,这样实现了统一的扩展。

如:

package com.lagou.mp.mapper;
import com.lagou.mp.pojo.User;
public interface UserMapper extends MyBaseMapper<User> {
   User findById(Long id);
}

8.2、编写MySqlInjector

如果直接继承AbstractSqlInjector的话,原有的BaseMapper中的方法将失效,所以我们选择继承

DefaultSqlInjector进行扩展。

package com.lagou.mp.sqlInjector;
import com.baomidou.mybatisplus.core.injector.AbstractMethod;
import com.baomidou.mybatisplus.core.injector.DefaultSqlInjector;
import java.util.List;
public class MySqlInjector extends DefaultSqlInjector {
   @Override
   public List<AbstractMethod> getMethodList() {
       List<AbstractMethod> methodList = super.getMethodList();
       methodList.add(new FindAll());
       
       // 再扩充自定义的方法
       list.add(new FindAll());
       return methodList;
 
  }
}

8.3、编写FindAll

package com.lagou.mp.sqlInjector;
import com.baomidou.mybatisplus.core.enums.SqlMethod;
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 sqlMethod = "findAll";
       String sql = "select * from " + tableInfo.getTableName();
     SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
       return this.addSelectMappedStatement(mapperClass, sqlMethod, sqlSource, modelClass, tableInfo);
 
  }
}

8.4、注册到Spring容器

/**
* 自定义SQL注入器
*/
@Bean
public MySqlInjector mySqlInjector(){
   return new MySqlInjector();
}

8.5、测试

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

输出的SQL:

[main] [com.lagou.mp.mapper.UserMapper.findAll]-[DEBUG] ==>  Preparing: select * from tb_user
[main] [com.lagou.mp.mapper.UserMapper.findAll]-[DEBUG] ==> Parameters:
[main] [com.lagou.mp.mapper.UserMapper.findAll]-[DEBUG] <==      Total: 10

至此,我们实现了全局扩展SQL注入器。

9 自动填充功能

有些时候我们可能会有这样的需求,插入或者更新数据时,希望有些字段可以自动填充数据,比如密

码、version等。在MP中提供了这样的功能,可以实现自动填充。

9.1、添加@TableField注解

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

为email添加自动填充功能,在新增数据时有效。

FieldFill提供了多种模式选择:

public enum FieldFill {
   /**
    * 默认不处理
    */
   DEFAULT,
   /**
    * 插入时填充字段
    */
   INSERT,
   /**
    * 更新时填充字段
    */
   UPDATE,
   /**
    * 插入和更新时填充字段
    */
   INSERT_UPDATE
}

9.2、编写MyMetaObjectHandler

package com.lagou.mp.handler;
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
   @Override
   public void insertFill(MetaObject metaObject) {
       Object password = getFieldValByName("password", metaObject);
       if(null == password){
           //字段为空,可以进行填充
           setFieldValByName("password", "123456", metaObject);
     
 
        }
  }
   @Override
   public void updateFill(MetaObject metaObject) {
 
  }
}

9.3、测试

@Test
public void testInsert(){
   User user = new User();
       user.setName("冰冰");
       user.setAge(30);
       user.setVersion(1);
       int result = this.userMapper.insert(user);
       System.out.println("result = " + result);
}

结果:

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(){
   this.userMapper.deleteById(2L);
}

执行的SQL:

main] [com.lagou.mp.mapper.UserMapper.deleteById]-[DEBUG] ==>  Preparing: UPDATE tb_user SET deleted=1 WHERE id=? AND deleted=0
[main] [com.lagou.mp.mapper.UserMapper.deleteById]-[DEBUG] ==> Parameters: 2(Long)
[main] [com.lagou.mp.mapper.UserMapper.deleteById]-[DEBUG] <==    Updates: 1

测试查询:

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

执行的SQL:

[main] [com.lagou.mp.mapper.UserMapper.selectById]-[DEBUG] ==>  Preparing:
SELECT id,user_name,password,name,age,email,version,deleted FROM tb_user WHERE id=? AND deleted=0
[main] [com.lagou.mp.mapper.UserMapper.selectById]-[DEBUG] ==> Parameters: 2(Long)
[main] [com.lagou.mp.mapper.UserMapper.selectById]-[DEBUG] <==      Total: 0

可见,已经实现了逻辑删除。

11 代码生成器

AutoGenerator 是 MyBatis-Plus 的代码生成器,通过 AutoGenerator 可以快速生成 Entity、

Mapper、Mapper XML、Service、Controller 等各个模块的代码,极大的提升了开发效率。

11.1、创建工程

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.3.4.RELEASE</version>
       <relativePath/> <!-- lookup parent from repository -->
   </parent>
   <groupId>com.lagou</groupId>
   <artifactId>lagou-mp-generator</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>lagou-mp-generator</name>
   <description>Demo project for Spring Boot</description>
   <properties>
       <java.version>11</java.version>
   </properties>
   <dependencies>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-test</artifactId>
           <scope>test</scope>
       </dependency>
       <!--mybatis-plus的springboot支持-->
       <dependency>
           <groupId>com.baomidou</groupId>
           <artifactId>mybatis-plus-boot-starter</artifactId>
           <version>3.1.1</version>
       </dependency>
       <dependency>
           <groupId>com.baomidou</groupId>
           <artifactId>mybatis-plus-generator</artifactId>
           <version>3.1.1</version>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-freemarker</artifactId>
       </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>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
       <!--简化代码的工具包-->
       <dependency>
           <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
         <optional>true</optional>
       </dependency>
   </dependencies>
   <build>
       <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
           </plugin>
       </plugins>
   </build>
</project>

11.2、代码

package com.lagou.mp.generator;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.FileOutConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.TemplateConfig;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
/**
* <p>
* mysql 代码生成器演示例子
* </p>
*/
public class MysqlGenerator {
   /**
    * <p>
    * 读取控制台内容
    * </p>
    */
   public static String scanner(String tip) {
       Scanner scanner = new Scanner(System.in);
       StringBuilder help = new StringBuilder();
       help.append("请输入" + tip + ":");
       System.out.println(help.toString());
     if (scanner.hasNext()) {
           String ipt = scanner.next();
           if (StringUtils.isNotEmpty(ipt)) {
               return ipt;
         
     
}
}
       throw new MybatisPlusException("请输入正确的" + tip + "!");
 
}
   /**
    * RUN THIS
    */
   public static void main(String[] args) {
       // 代码生成器
       AutoGenerator mpg = new AutoGenerator();
       // 全局配置
       GlobalConfig gc = new GlobalConfig();
       String projectPath = System.getProperty("user.dir");
       gc.setOutputDir(projectPath + "/src/main/java");
       gc.setAuthor("lagou");
       gc.setOpen(false);
       mpg.setGlobalConfig(gc);
       // 数据源配置
       DataSourceConfig dsc = new DataSourceConfig();
       dsc.setUrl("jdbc:mysql://127.0.0.1:3306/mp?
useUnicode=true&useSSL=false&characterEncoding=utf8");
       // dsc.setSchemaName("public");
       dsc.setDriverName("com.mysql.jdbc.Driver");
       dsc.setUsername("root");
       dsc.setPassword("root");
       mpg.setDataSource(dsc);
       // 包配置
       PackageConfig pc = new PackageConfig();
       pc.setModuleName(scanner("模块名"));
       pc.setParent("com.lagou.mp.generator");
       mpg.setPackageInfo(pc);
       // 自定义配置
       InjectionConfig cfg = new InjectionConfig() {
           @Override
           public void initMap() {
               // to do nothing
         
     
}
};
       List<FileOutConfig> focList = new ArrayList<>();
       focList.add(new FileOutConfig("/templates/mapper.xml.ftl") {
           @Override
           public String outputFile(TableInfo tableInfo) {
               // 自定义输入文件名称
               return projectPath + "/lagou-mp-
generator/src/main/resources/mapper/" + pc.getModuleName()
                       + "/" + tableInfo.getEntityName() + "Mapper" +
StringPool.DOT_XML;
         
     
});
}

11.3、测试

代码已生成:

实体对象:

12 MybatisX 快速开发插件

MybatisX 是一款基于 IDEA 的快速开发插件,为效率而生。

安装方法:打开 IDEA,进入 File -> Settings -> Plugins -> Browse Repositories,输入 mybatisx 搜

索并安装。

功能:

• Java 与 XML 调回跳转
• Mapper 方法自动生成 XML