07-MyBatisPlus

一 MyBatisPlus入门

1 MyBatisPlus介绍

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

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

官方网址：https://baomidou.com/

2 Spring集成MyBatisPlus

MyBatisPlus官方推荐在SpringBoot工程中使用，Spring工程也可以使用MyBatisPlus，首先我们在Spring中使用MyBatisPlus。

• 在Mysql中准备数据：
• 创建Maven项目，引入依赖

   <dependencies>
        <!-- MyBatisPlus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
            <version>3.4.2</version>
        </dependency>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.48</version>
        </dependency>
        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.6</version>
        </dependency>
        <!-- spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.3.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.13</version>
        </dependency>
        <!-- lombok   -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
        </dependency>

    </dependencies>

• 创建实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
    private Integer id;
    private String name;
    private String sex;
    private String address;
}

• 创建Mapper接口。

使用MyBatis时，在编写Mapper接口后，需要手动编写CRUD方 法，并需要在Mapper映射文件中手动编写每个方法对应的SQL 语句。而在MyBatisPlus中，只需要创建Mapper接口并继承 BaseMapper，此时该接口获得常用增删改查功能，不需要自己 手动编写Mapper配置文件

public interface StudentMapper extends BaseMapper<Student> {
}

• 创建Spring配置文件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"
        xsi:schemaLocation="
                  http://www.springframework.org/schema/beans
                  http://www.springframework.org/schema/beans/spring-beans.xsd">


    <!-- 配置数据源 -->
    <bean id="dataSource"
          class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/student?characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <!-- MyBatisPlus提供的session工厂对象-->
    <bean id="sqlSessionFactoryBean"
          class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 自动扫描所有mapper ,将mapper接口生成代理注入到Spring-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.lxx.mapper"/>
    </bean>


</beans>

• 测试Mapper方法

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class StudentMapperTest {
    @Autowired
    private StudentMapper studentMapper;

    @Test
    public void testFindById() {
        Student student = studentMapper.selectById(1);
        System.out.println(student);
    }
}

3 SpringBoot集成MyBatisPlus

• 创建SpringBoot项目，添加MyBatisPlus起步依赖

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

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

        <!-- MyBatisPlus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.0</version>
        </dependency>

        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.48</version>
        </dependency>

        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

    </dependencies>

• 在SpringBoot配置文件中配置数据源

# 数据源
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/student?characterEncoding=utf-8
    username: root
    password: 123456

• 编写实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
    private Integer id;
    private String name;
    private String sex;
    private String address;
}

• 编写Mapper接口，继承BaseMapper

public interface StudentMapper extends BaseMapper<Student> {
}

• 在 SpringBoot启动类中添加 @MapperScan 注解，扫描Mapper文件夹

@SpringBootApplication
@MapperScan("com.lxx.mapper")
public class Mpdemo2Application {

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

}

• 测试Mapper方法

@SpringBootTest
public class StudenrMapperTest {
    @Autowired
    private StudentMapper studentMapper;

    @Test
    public void testFindById() {
        Student student = studentMapper.selectById(1);
        System.out.println(student);
    }
}

二 MyBatisPlusCRUD

1 添加

• 配置文件开启SQL日志打印

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

• 测试添加方法：

    @Test
    public void testInsert() {
        Student student = new Student(null, "lxx", "男", "昆明");
        studentMapper.insert(student);
        // MyBatisPlus插入成功后，可直接直接获取主键的值(即：自动主键回填)
        System.out.println(student.getId());
    }

2 相关注解

我们将表名改为tb_student，id字段名改为sid，name字段名改为 sname，此时由于名字不同无法完成映射，我们可以通过相关注解为实体类对象指定表名和列名。

@TableName

作用：指定类为哪个表的实体类

位置：类上方

@TableId

作用：指定实体类的属性为主键

位置：属性上方

属性：

• value：主键字段名
• type：主键策略

值	描述
NONE	无状态,不设置主键类型
AUTO	自增主键
INPUT	插入前自行设置主键值
ASSIGN_ID	默认策略，使用雪花算法自动生成主键ID，主键类型为整形或字符串。 （雪花算法：微博开源的分布式ID生成算法，使用一个64位的Long类型数 字作为全局唯一ID。在分布式系统中的应用十分广泛，且ID引入了时间 戳，基本上保持自增）
ASSIGN_UUID	自动生成排除中划线的UUID作为主键，主键类型为字符串。

@TableField

作用：在属性和列名不同的情况下，指定映射关系

位置：非主键属性上方

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_student")
public class Student {
    @TableId(value = "sid", type = IdType.AUTO)
    private Integer id;
    @TableField("sname")
    private String name;
    private String sex;
    private String address;
}

3 修改

    @Test
    public void testUpdate() {
        //创建实体类对象
        Student student = new Student();
        //设置需要更新的属性
        student.setName("李秀祥");
        //设置需要修改的数据id
        student.setId(1);
        //根据主键进行更新，没有设置的值则忽略
        studentMapper.updateById(student);
    }

4 删除

   //根据id删除
    @Test
    public void testDeleteById() {
        studentMapper.deleteById(7);
    }

    // 批量删除
    @Test
    public void testDeleteBatch() {
        ArrayList<Integer> ids = new ArrayList();
        ids.add(3);
        ids.add(4);
        studentMapper.deleteBatchIds(ids);
    }

    // 根据字段条件删除
    @Test
    public void testDeleteMap() {
        HashMap<String, Object> map = new HashMap<>();
        // 键为数据库列名，而不是对象属性名
        map.put("sname", "张三");
        map.put("sex", "女");
        // 删除sname为张三且sex为女的数据
        studentMapper.deleteByMap(map);
    }

5 查询

// 根据id查询
@Test
public void testSelectById() {
    Student student = studentMapper.selectById(1);
    System.out.println(student);
}

// 根据id批量查询
@Test
public void testSelectBatch() {
    //创建主键集合
    List<Integer> ids = new ArrayList<>();
    ids.add(1);
    ids.add(2);
    ids.add(3);
    List<Student> students = studentMapper.selectBatchIds(ids);
    students.forEach(System.out::println);
}

// 根据字段条件查询
@Test
public void testSelectMap() {
    Map<String, Object> map = new HashMap<>();
    map.put("sname", "科比");
    map.put("sex", "男");
    //查询sname为科比,sex为男的数据
    List<Student> students = studentMapper.selectByMap(map);
    students.forEach(System.out::println);
}

6 条件构造器

Mybatis-Plus通过QueryWrapper对象让用户自由的构建SQL条 件，简单便捷，没有额外的负担，能够有效提高开发效率。

条件参数说明:

查询方式	说明
or	或条件语句
and	且条件语句
like	模糊查询 like
notLike	模糊查询 not Like
exists	exists 条件语句
notExists	not Exists 条件语句
isNull	null 值查询
isNotNull	is Not Null 查询
in	in 查询
notIn	not in 查询
groupBy	分组查询
orderBy	排序查询
having	分组后筛选
eq	等于 =
ne	不等于 <>
between	between 条件语句
gt	大于>
ge	大于等于>=
lt	小于<
le	小于等于<=

用法如下：

    // 条件构造器1
    @Test
    public void testFindWrapper1() {
        // 查询id小于3或id大于13的人
        QueryWrapper<Student> queryWrapper = new QueryWrapper<>();
        queryWrapper.lt("sid", 3).or().gt("sid", 13);
        List<Student> students = studentMapper.selectList(queryWrapper);
        students.forEach(System.out::println);
    }

    // 条件构造器2
    @Test
    public void testFindWrapper2() {
        // 查询性别为女，且id小于等于30的数据
        QueryWrapper<Student> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("sex", "女").le("sid", 30);
        List<Student> students = studentMapper.selectList(queryWrapper);
        students.forEach(System.out::println);
    }

    // 条件构造器3
    @Test
    public void testFindWrapper3() {
        // 查询名字包含"x"的学生，按照id升序排序
        QueryWrapper<Student> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("sname", "x").orderByAsc("id");
        List<Student> students = studentMapper.selectList(queryWrapper);
        students.forEach(System.out::println);
    }

注：构造时使用的是数据库字段，不是Java属性

7 分页查询

• 在配置类或启动类配置分页插件

@Configuration
public class MPConfig {

    @Bean
    public MybatisPlusInterceptor getMybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

• 测试分页查询

    // 分页查询
    @Test
    public void testFindPage() {
        //创建分页条件，第1页，数据量为2
        Page page = new Page(1, 2);
        // 分页查询
        IPage<Student> iPage = studentMapper.selectPage(page, null);
        // 打印分页数据
        System.out.println("结果集：" + iPage.getRecords());
        System.out.println("总页数：" + iPage.getPages());
        System.out.println("总条数：" + iPage.getTotal());
        System.out.println("当前页：" + iPage.getCurrent());
        System.out.println("每页条数：" + iPage.getSize());

    }

8 全局配置

假如数据库的所有表都以 tb_ 开头，主键都是自增的。如果针对每一个实体类都要添加相关注解比较麻烦，可以在SpringBoot配置文件 中进行全局配置，该配置在所有的实体类中都生效。

mybatis-plus:
  # 全局配置
 global-config:
   db-config:
      #主键类型
     id-type: AUTO
      # 设置表名前缀
     table-prefix: tb_
      # 是否使用驼峰转下划线命名，默认开启
     table-underline: true

三 ActiveRecord

1 概念

Active Record(活动记录)，是一种领域模型模式，特点是一个模型类对应关系型数据库中的一个表，而模型类的一个实例对应表中的 一行记录。 在MyBatisPlus中，AR模式即在实体类中封装了对数据库的访问， 而不通过mapper类。

用法：

• 虽然操作数据库不通过mapper类，但需要编写mapper类并继承BaseMapper

public interface StudentMapper extends BaseMapper<Student> {
}

• 实体类继承Model类，开启AR模式

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_student")
public class Student extends Model<Student> {
    @TableId(value = "sid", type = IdType.AUTO)
    private Integer id;
    @TableField("sname")
    private String name;
    private String sex;
    private String address;
}

• 接下来可以使用实体类进行增删改查

2 增删改查

@SpringBootTest
public class StudentARTest {
    // AR新增
    @Test
    public void testAdd() {
        Student student = new Student(100, "LBJ", "男", "鞍山市");
        student.insert();
    }

    // AR修改
    @Test
    public void testUpDate() {
        // 创建实体类对象
        Student student = new Student();
        // 设置需要更新的属性
        student.setName("勒布朗");
        // 设置需要修改的id
        student.setId(100);
        // 根据主键进行更新，没有设置的值忽略
        student.updateById();
    }

    // AR根据id查询
    @Test
    public void testFindById() {
        Student student = new Student();
        student.setId(10);
        Student student1 = student.selectById();
        System.out.println(student1);
    }

    // AR删除
    @Test
    public void testDeleteById() {
        Student student = new Student();
        student.setId(10);
        student.deleteById();
    }

    // AR查询所有
    @Test
    public void testFindAll() {
        Student student = new Student();
        List<Student> students = student.selectAll();
        students.forEach(System.out::println);
    }

    // AR分页查询
    @Test
    public void testFindPage() {
        // 创建分页条件
        Page page = new Page(0, 2);
        // 查询构造器
        QueryWrapper<Student> queryWrapper = new QueryWrapper<>();
        // 查询名字包含"小"的学生，按照年龄升序排序
        queryWrapper.like("sname", "小").orderByAsc("age");

        Student student = new Student();
        // 分页查询
        IPage iPage = student.selectPage(page, queryWrapper);
        // 打印分页数据
        System.out.println("结果集：" + iPage.getRecords());
        System.out.println("总页数：" + iPage.getPages());
        System.out.println("总条数：" + iPage.getTotal());
        System.out.println("当前页：" + iPage.getCurrent());
        System.out.println(" 每页条数：" + iPage.getSize());
    }


}

四 MyBatis插件

1 插件概述

MyBatis插件机制

MyBatis插件就是对Executor、StatementHandler、 ParameterHandler、ResultSetHandler这四个接口上的方法进行 拦截，利用JDK动态代理机制，为这些接口的实现类创建代理对象， 在执行方法时，先去执行代理对象的方法，从而执行自己编写的拦截逻辑。

• Executor： MyBatis的内部执行器，它负责调用StatementHandler操作数 据库，并把结果集通过 ResultSetHandler进行自动映射。
• StatementHandler： MyBatis直接让数据库执行sql脚本的对象。
• ParameterHandler： MyBatis实现Sql入参设置的对象。
• ResultSetHandler： MyBatis把ResultSet集合映射成POJO的接口对象。

MyBatisPlus常用插件

MyBatisPlus依据MyBatis插件机制，为我们提供了一些开发中常用 的插件，我们在开发中使用即可。

常用插件：

• 自动分页: PaginationInnerInterceptor
• 防止全表更新与删除: BlockAttackInnerInterceptor
• 乐观锁: OptimisticLockerInnerInterceptor

这些插件都实现了InnerInterceptor接口

2 分页插件

在配置类或启动类配置分页插件：

    // 注册插件
    @Bean
    public MybatisPlusInterceptor getMybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;

3 防止全表更新与删除插件

作用：分析删除/更新语句，防止小白或者恶意进行删除/更新全表 操作。

注意:

• 该插件只支持 MySQL5.6.3 以上版本
• 该插件只建议在开发环境中使用，不建议在生产环境使用

插件使用：

• 在配置类或启动类配置防止全表更新与删除插件

    // 注册插件
    @Bean
    public MybatisPlusInterceptor getMybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 分页插件
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        // 防止全表更新与删除插件
        interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());

        return interceptor;
    }

• 测试全表删除

    // AR删除所有
    @Test
    public void testDeleteAll() {
        Student student = new Student();
        student.delete(new QueryWrapper());
    }

报错：MybatisPlusException: Prohibition of full table deletion

4 乐观锁插件

修改数据库中的数据时，为了避免同时被其他人修改，最好的办 就是对该数据进行加锁以防止并发。

锁的设计分为悲观锁和乐观锁：

• 悲观锁：悲观锁对数据被外界修改持保守态度。即在整个数据处 理过程中，将数据处于锁定状态。悲观锁的实现往往依靠数据库提供的锁机制。

• 乐观锁：乐观锁在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果冲突，则返回给用户异常信息，让用户决定如何去做。

MyBatisPlus乐观锁插件实现方式：

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

使用MyBatisPlus乐观锁插件：

• 注册乐观锁插件

    // 注册插件
    @Bean
    public MybatisPlusInterceptor getMybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 分页插件
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        // 防止全表更新与删除插件
        interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
        // 乐观锁插件
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());

        return interceptor;
    }

• 修改实体类，添加version列并在该属性上面增加@Version

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_student")
public class Student extends Model<Student> {
    @TableId(value = "sid", type = IdType.AUTO)
    private Integer id;
    @TableField("sname")
    private String name;
    private String sex;
    private String address;
    @Version
    private Integer version;
}

• 修改数据库表，添加一列整型version字段并设置默认值为0
• 测试修改功能

    // 修改
    @Test
    public void testUpdate1() {
        Student student = new Student();
        student.setId(100);
        student.setName("科比");
        //如果版本号和数据库一致更新成功，版本号+1,
        //如果不一致更新失败
        student.setVersion(0);
        student.updateById();
    }

五 MyBatisPlus逻辑删除

1 概念

在实际开发中，由于数据十分重要，为了避免误删除数据导致数据 无法找回，我们往往不会使用物理删除，即从数据库中直接删除数 据。而是采用逻辑删除的方式，即不会真正在数据库删除数据，而是通过一个变量代表它被删除。

deleted属性代表该数据是否删除，0代表未删除，1代表已删除。此时增删改查的Sql语句发生变化：

• 插入: 不作限制
• 查找: 追加where条件过滤掉已删除数据。
• 更新: 追加where条件防止更新到已删除数据。
• 删除: 转变为更新

例如:

• 删除

update user set deleted=1 where id = 1 and deleted=0

• 查找

select id,name,deleted from user where deleted=0

2 使用

• 在配置文件配置逻辑删除

# mybatis-plus相关配置
mybatis-plus:
  # 全局配置
 global-config:
   db-config:
      # 全局逻辑删除的字段名
     logic-delete-field: deleted
      # 逻辑已删除值(默认为 1)
     logic-delete-value: 1
      # 逻辑未删除值(默认为 0)
     logic-not-delete-value: 0

• 修改实体类，添加逻辑删除属性

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_student")
public class Student extends Model<Student> {
    @TableId(value = "sid", type = IdType.AUTO)
    private Integer id;
    @TableField("sname")
    private String name;
    private String sex;
    private String address;
    @Version
    private Integer version;
    @TableLogic
    private Integer deleted;
}

• 修改数据库表，添加一列整型deleted字段并设置默认值为0
• 测试删除和查询方法，会看到删除时将deleted字段变为1，查询 时添加条件deleted=0

六 MyBatisPlus扩展

1 自动填充

由于有了逻辑删除字段，那么向数据库插入数据时候，都需要设置 deleted=0，而每次插入数据时都要设置该值十分繁琐，于是 MyBatisPlus提供了自动填充功能。

• 为实体类的自动填充字段添加 @TableField

@TableLogic
// 自动填充字段
@TableField(fill = FieldFill.INSERT)
private Integer deleted;

填充策略：

值	描述
DEFAULT	默认不处理
INSERT	插入操作填充字段
UPDATE	更新操作填充字段
INSERT_UPDATE	插入操作和更新操作均填充字段

• 自定义填充类实现MetaObjectHandler接口

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    /**
     * 插入时填充逻辑
     *
     * @param metaObject 元对象
     */
    @Override
    public void insertFill(MetaObject metaObject) {
        /**
         * 参数1：填充字段名
         * 参数2：参数值
         * 参数3：元对象
         */
        this.setFieldValByName("deleted", 0, metaObject);
    }

    /**
     * 更新时填充逻辑
     *
     * @param metaObject
     */
    @Override
    public void updateFill(MetaObject metaObject) {
    }
}

• 测试插入方法

@Test
public void testAdd(){
    Student student = new Student();
    student.insert();
}

2 SQL注入器

MyBatisPlus方法是有限的，我们可以使用SQL注入器自定义全局方法，注入到全局中，这样所有的Mapper类都能使用该方法，接下 来我们自定义一个deleteAll方法。

• 创建注入方法类，继承AbstractMethod

// 注入方法类
public class DeleteAll extends AbstractMethod {
    @Override
    public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
        //定义sql语句
        String sql = "delete from " + tableInfo.getTableName();
        //方法名
        String method = "deleteAll";
        //构建SqlSource,它负责将Sql传递到数据库
        SqlSource sqlSource = this.languageDriver.createSqlSource(this.configuration, sql, modelClass);
        //构建删除方法
        return this.addDeleteMappedStatement(mapperClass, method, sqlSource);
    }
}

• 创建SQL自动注入器，继承AbstractSqlInjector

@Component
public class MySqlInject extends AbstractSqlInjector {
    // 注入自定义方法集合
    @Override
    public List<AbstractMethod>
    getMethodList(Class<?> mapperClass, TableInfo tableInfo) {
        List<AbstractMethod> methods = new ArrayList<>();
        methods.add(new DeleteAll());
        return methods;
    }
}

• 注销防止全表更新与删除插件

    // 注册插件
    @Bean
    public MybatisPlusInterceptor getMybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 分页插件
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        // 防止全表更新与删除插件
		// interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
        // 乐观锁插件
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());

        return interceptor;
    }

• 在Mapper接口中定义deleteAll方法

public interface StudentMapper extends BaseMapper<Student> {
    void deleteAll();
}

• 测试deleteAll方法

@Test
public void testDeleteAll() {
    studentMapper.deleteAll();
}

3 代码生成器

待续

4 MyBatisX快速开发插件

待续

七 MyBatis-Plus 通用的IService接口

MyBatis-Plus 通用的IService接口：（假设实体类为User）

service层接口可以继承IService接口，IService的使用：

①mapper接口继承BaseMapper接口：

public interface UserMapper extends BaseMapper<User> {
}

②service接口继承Iservice：

public interface IUserService extends IService<User> {
}

③service接口的实现类继承ServiceImpl<继承baseMapper的mapper，实体类>，实现IUserService接口：

@Service
public class IUserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
}

④接下来就可以调用IService中的方法啦：参考
IService接口解释