MybatisPlus---从入门到深化

目录

MyBatisPlus入门

MyBatisPlus介绍

编辑Spring集成MyBatisPlus 

SpringBoot集成MyBatisPlus

MyBatisPlus_CRUD

添加

 CRUD_相关注解

修改

删除

查询

 条件构造器

全局配置

ActiveRecord_概念

 ActiveRecord_增删改查

MyBatisPlus插件_插件概述

 MyBatisPlus插件_分页插件

MyBatisPlus插件_防止全表更新与删除插件

MyBatisPlus插件_乐观锁插件

MyBatisPlus逻辑删除_概念

 MyBatisPlus逻辑删除_使用

 MyBaitsPlus扩展_自动填充

MyBatisPlus扩展_SQL注入器

MyBatisPlus扩展_代码生成器

MyBatisPlus扩展_MybatisX快速开发插件

---

MyBatisPlus入门

MyBatisPlus介绍

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

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

Spring集成MyBatisPlus 

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

 在Mysql中准备数据：

DROP DATABASE IF EXISTS `school`;
CREATE DATABASE `school`;
USE `school`;
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `email` varchar(255) DEFAULT NULL,
 `gender` varchar(255) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
INSERT INTO `student` VALUES ('1','小童','[e-mail]', 'm', '22');
INSERT INTO `student` VALUES ('2','小纯', '[e-mail]', 'f', '25');
INSERT INTO `student` VALUES ('3','小张','[e-mail]', 'm', '30');
INSERT INTO `student` VALUES ('4','小王','[e-mail]', 'f', '35');
INSERT INTO `student` VALUES ('5','小李','[e-mail]', 'm', '32');
INSERT INTO `student` VALUES ('6','小赵','[e-mail]', 'm', '32');

 创建Maven项目，引入依赖

<!-- MyBatisPlus -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>3.4.2</version>
</dependency>
<!-- mysql驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connectorjava</artifactId>
    <version>8.0.26</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>springcontext</artifactId>
    <version>5.3.9</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>5.3.9</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.3.9</version>
</dependency>
<!-- lombok   -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.22</version>
</dependency>

创建实体类

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

创建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/sche
ma/beans"
      
xmlns:context="http://www.springframework.
org/schema/context"
      
xmlns:xsi="http://www.w3.org/2001/XMLSchem
a-instance"
      
xmlns:p="http://www.springframework.org/sc
hema/p"
       xsi:schemaLocation="
                  
http://www.springframework.org/schema/context
                  
http://www.springframework.org/schema/context/spring-context.xsd
                  
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" destroymethod="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql:///school"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>
    <!-- MyBatisPlus提供的session工厂对象-->
    <bean id="sqlSessionFactory"
        
class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 自动扫描所有mapper ,将mapper接口生成代理注入到Spring-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"
        
p:basePackage="com.itbaizhan.mapper"
p:sqlSessionFactoryBeanName="sqlSessionFactory"/>
</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);
   }
}

SpringBoot集成MyBatisPlus

接下来我们在SpringBoot项目中使用MyBatisPlus

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

<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>8.0.26</version>
</dependency>

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

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

# 数据源
spring:
 datasource:
   driver-class-name:
com.mysql.cj.jdbc.Driver
   url: jdbc:mysql:///school?serverTimezone=UTC
   username: root
   password: 123456

编写实体类

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

编写Mapper接口，继承BaseMapper

public interface StudentMapper extends BaseMapper<Student> {
}

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

@SpringBootApplication
@MapperScan("com.itbaizhan.mpdemo2.mapper")
public class SpringbootMpApplication {
    public static void main(String[] args)
       {
      
            SpringApplication.run(SpringbootMpApplication.class, args);
       }
}

测试Mapper方法

@SpringBootTest
public class StudentMapperTest {
    @Autowired
    private StudentMapper studentMapper;
    @Test
    public void testFindById(){
        Student student = studentMapper.selectById(1);
        System.out.println(student);
   }
}

MyBatisPlus_CRUD

添加

 配置文件开启SQL日志打印

# 开启SQL日志
mybatis-plus:
 configuration:
   log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

测试添加方法：

@Test
public void testAdd(){
    Student student = new Student(null,"baizhan","[e-mail]","m",20);
    studentMapper.insert(student);
    // MyBatisPlus插入成功后，可直接直接获取主键的值
    System.out.println(student.getId());
}

 CRUD_相关注解

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

 @TableName

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

位置：类上方

@TableId

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

位置：属性上方

属性：

      value：主键字段名

      type:     主键策略

 @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 email;
    private String gender;
    private Integer age;
}

修改

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

删除

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

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

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

查询

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

// 根据id批量查询
@Test
public void testFindBatch() {
    //创建主键集合
    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 testFindMap() {
    Map<String,Object> map = new HashMap<>();
    map.put("sname","baizhan");
    map.put("gender","m");
    //查询name为baizhan,gender为m的数据
    List<Student> students = studentMapper.selectByMap(map);
    students.forEach(System.out::println);
}

 条件构造器

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

 

 用法如下：

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


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


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

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

 分页查询

 

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

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

测试分页查询

// 分页查询
@Test
public void testFindPage() {
    //创建分页条件，从第0条数据开始，获取两条数据
    Page page = new Page(2,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());
}

全局配置

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

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

ActiveRecord_概念

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

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

public interface StudentMapper extends BaseMapper<Student> {
}

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

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student extends Model<Student> {
    @TableId(type = IdType.AUTO)
    private Integer id;
    @TableField("sname")
    private String name;
    private String email;
    private String gender;
    private Integer age;
}

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

 ActiveRecord_增删改查

// AR新增
@Test
public void testAdd(){
    Student student = new Student(10,"baizhan", "[e-mail]", "m", 20);
    student.insert();
}

// AR修改
@Test
public void testUpDate(){
    // 创建实体类对象
    Student student = new Student();
    // 设置需要更新的属性
    student.setName("百战程序员");
    // 设置需要修改的id
    student.setId(10);
    // 根据主键进行更新，没有设置的值忽略
    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());
}

MyBatisPlus插件_插件概述

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

 MyBatisPlus插件_分页插件

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

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

MyBatisPlus插件_防止全表更新与删除插件

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

注意：

     该插件只支持 MySQL5.6.3 以上版本

     该插件只建议在开发环境中使用，不建议在生产环境使用

 插件使用： 1 在配置类或启动类配置防止全表更新与删除插件

// 注册插件
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
    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());
}

MyBatisPlus插件_乐观锁插件

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

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

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

 

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

 

MyBatisPlus乐观锁插件实现方式：
 1 取出记录时，获取当前version

 2 更新时，带上这个version

 3 执行更新时， set version = newVersion where version = oldVersion

 4 如果version不对，就更新失败

 使用MyBatisPlus乐观锁插件：

       注册乐观锁插件

// 注册插件
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
    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 email;
    private String gender;
    private Integer age;
    @Version
    private Integer version;
}

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

测试修改功能

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

MyBatisPlus逻辑删除_概念

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

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

 MyBatisPlus逻辑删除_使用

 在配置文件配置逻辑删除

# 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
public class Student extends Model<Student> {
@TableId(value = "sid")
    private Integer id;
    @TableField("sname")
    private String name;
    private String email;
    private String gender;
    private Integer age;
    @Version
    private Integer version;
    @TableLogic
    private Integer deleted;
}

修改数据库表，添加一列整型deleted字段并设置默认值为0

测试删除和查询方法，会看到删除时将deleted字段变为1，查询 时添加条件deleted=0

 MyBaitsPlus扩展_自动填充

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

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

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

 填充策略：

 自定义填充类实现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 testAdd2(){
    Student student = new Student();
    student.insert();
}

MyBatisPlus扩展_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 mybatisPlusInterceptor() {
    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();
}

MyBatisPlus扩展_代码生成器

 如果不想手动编写实体类等文件，MyBaitsPlus提供了代码生成器， 它可以读取数据库的表信息，生成MyBaitsPlus代码供我们使用，之 前我们学过MyBatis的代码生成器MyBatis Generator，这二者的区 别是：

 MBG基于xml文件配置的，MyBaitsPlus代码生成器是基于Java代码配置的。

MBG可生成实体类、Mapper接口、Mapper映射文件；MyBaitsPlus代码生成器可生成实体类、 Mapper接口、Mapper映射文件、Service类、Controller类

 使用： 1 添加代码生成器所需的依赖

<!-- MyBatisPlus代码生成器 -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plusgenerator</artifactId>
    <version>3.5.1</version>
</dependency>

<!-- MyBatisPlus代码生成器需要的模板引擎 -->
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-enginecore</artifactId>
    <version>2.2</version>
</dependency>

 编写代码生成器

public class MyGenerator {
    public static void main(String[] args)
       {
      
         FastAutoGenerator.create("jdbc:mysql:///school", "root", "root")
            // 全局配置
           .globalConfig(builder -> {
              
                       builder.author("itbaizhan") // 设置作者
                              .commentDate("MM-dd")// 注释日期格式 
                   
                              .outputDir(System.getProperty("user.dir")
                              + "/springboot_mybatisplus/src/main/java") // 指定输出目录
                              .fileOverride(); //覆盖文件
                           })
                        // 包配置
            .packageConfig(builder -> {
               
                      builder.parent("com.itbaizhan.springboot_mp") // 包名前缀
                             .entity("domain") //实体类包名
                             .mapper("mapper")
                              //mapper接口包名
                             .service("service") //service包名                   
                             .controller("controller") //controller包名
                             .xml("mapper"); //映射文件包名
                            })
                         // 策略配置
             .strategyConfig(builder -> {
              
                    builder.addInclude("tb_student") // 设置需要生成的表名,可以有多个
                            .addTablePrefix("tb_") // 设置表名前缀
                            .entityBuilder() // 开始实体类配置
                            .enableLombok() // 开启lombok模型
                            .naming(NamingStrategy.underline_to_camel) //表名下划线转驼峰                   
                            .columnNaming(NamingStrategy.underline_to_camel);
                            //列名下划线转驼峰
                          })
                    .execute();
   }
}

运行代码生成器即可生成代码

MyBatisPlus扩展_MybatisX快速开发插件

 MybatisX是一款基于IDEA的快速开发插件，为效率而生。 安装方法：打开 IDEA，进入 File -> Settings -> Plugins -> Marketplace，输入 mybatisx 搜索并安装。

 生成代码 MybatisX也可以生成Mybatis代码

    1 在IDEA中连接数据库

    2 如下操作可以根据数据库表生成Mybaits代码

 

 

 

 生成映射配置

 在Mapper接口中编写方法

public interface StudentMapper extends BaseMapper<Student> {
    List<Student> selectAllBySname(String sname);
}

如下操作即可在映射文件中自动生成映射配置

 

 代码跳转

点击Mapper接口或映射文件前的小鸟图案，即可快速在Mapper接 口与映射文件间跳转