springboot之mybatis-plus

首先我们需要先导入基本pom依赖，若有其他需要后续自己可添加。

//springboot类启动依赖
         <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--mybatis-plus 持久层-->
//mybatis-plus依赖
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>
//数据库连接依赖
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
            <version>8.0.13</version>
        </dependency>
//limbok依赖，用来简化数据
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
//springboot测试类依赖
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

其次：我们编写最基本的application.yaml文件：

说明：如果你的springboot的版本是2.x.x的话driver驱动类用我这个，注意修改自己的数据库名，和数据的的连接名，密码。

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

接下来，我们创建一个实体类Teacher类，先关注字段名即可，详细的注解后续再介绍。

package com.yuan.edu.entity;

import com.baomidou.mybatisplus.annotation.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import net.sf.jsqlparser.expression.DateTimeLiteralExpression;

import java.util.Date;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Teacher {
    @TableId(type = IdType.ID_WORKER)//ID_WORKER是mp自带的策略，需要id的值为long类型。
    private long id;

    private String name;

    private String tel;

    private String email;
    @TableField(fill = FieldFill.INSERT)//mp自带的自动填充的注解
    private Date createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;

    @TableField(fill = FieldFill.INSERT)
    @Version
    private int version;

    @TableLogic
    @TableField(fill = FieldFill.INSERT)
    private int deleted;

}

实现自动填充功能：

package com.yuan.edu.handler;

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

import java.util.Date;

@Component
public class MyMateObjectHandler implements MetaObjectHandler {
    //使用mp实现添加操作就会执行
    @Override
    public void insertFill(MetaObject metaObject) {
        this.setFieldValByName("createTime",new Date(),metaObject);
        this.setFieldValByName("updateTime",new Date(),metaObject);
        this.setFieldValByName("version",1,metaObject);
    }
    //使用mp实现修改操作就会执行
    @Override
    public void updateFill(MetaObject metaObject) {
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
}

然后我们创建一个配置文件：mybatisplusConfig

此配置文件存放了一些mybatis的一些插件：

乐观锁插件：为了防止两个用户修改一个数据，造成数据的丢失。

分页插件：为列表数据实现分页

逻辑删除插件：deleted字段若为0，则没有删除，若字段为1则删除

性能分析插件：可以查看sql语句的运行时间，

package com.yuan.edu.config;

import com.baomidou.mybatisplus.core.injector.ISqlInjector;
import com.baomidou.mybatisplus.extension.injector.LogicSqlInjector;
import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.baomidou.mybatisplus.extension.plugins.PerformanceInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;

@Configuration
@MapperScan("com.yuan.edu.mapper")
public class mybatisConfig {

    //乐观锁插件，乐观锁是通过自动改变版本号，从而进行防治冲突更改
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor(){
        return new OptimisticLockerInterceptor();
    }

    //分页插件
    @Bean
    public PaginationInterceptor paginationInterceptor(){
        return new PaginationInterceptor();
    }
    //逻辑删除插件
    @Bean
    public ISqlInjector iSqlInjector(){
       return new LogicSqlInjector();
    }

    //性能分析插件
    //开发环境使用，线上不用
    @Bean
    @Profile({"dev","test"})//设置dev,test 环境开启
    public PerformanceInterceptor performanceInterceptor(){
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        performanceInterceptor.setMaxTime(500);//ms,超过此设置时间的sql不执行
        performanceInterceptor.setFormat(true);
        return performanceInterceptor;
    }
}

数据的测试类：

package com.yuan.edu;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yuan.edu.entity.Teacher;
import com.yuan.edu.mapper.TeacherMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.sql.Wrapper;
import java.time.temporal.TemporalAccessor;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@SpringBootTest
class EduApplicationTests {
    @Autowired
    private TeacherMapper teacherMapper;
    @Test
     public void findAll() {

        List<Teacher> teachers = teacherMapper.selectList(null);
        System.out.println(teachers);
    }

    @Test
    public void update(){
        Teacher teacher  = new Teacher();
        teacher.setId(1L);
        teacher.setName("九天狐");
        int update = teacherMapper.updateById(teacher);
        System.out.println(update);

    }

    @Test
    public void insert(){
        Teacher teacher =  new Teacher();
        teacher.setName("灰3");
        teacher.setTel("1234");
        teacher.setEmail("998908");
        int insert = teacherMapper.insert(teacher);
        System.out.println(insert);
    }

    @Test//测试乐观锁
    public void testoptimisticLocker(){
        //先查询
        Teacher teacher = teacherMapper.selectById(6L);
        //再修改
        teacher.setName("小李");
        int i = teacherMapper.updateById(teacher);
        System.out.println(i);
    }

    @Test//多个id批量查询
    public void testSelectDemo1(){
        List<Teacher> teachers = teacherMapper.selectBatchIds(Arrays.asList(1l, 2l, 3l));
        System.out.println(teachers);
    }
    @Test//条件查询
    public void testSelectByMap(){
        HashMap<String, Object> map = new HashMap<>();
        map.put("name","啊乐");
        map.put("tel","1234");
        List<Teacher> teachers = teacherMapper.selectByMap(map);
        System.out.println(teachers);
    }

    @Test
    public void testPage(){
        Page<Teacher> page = new Page<>(1, 3);

        IPage<Teacher> teacherIPage = teacherMapper.selectPage(page, null);

        System.out.println(page.getTotal());//获取总数
        System.out.println(page.getSize());//每页最大记录数
        System.out.println(page.getPages());//获取多少页
        System.out.println(page.getCurrent());//当前页
        System.out.println(page.getRecords());//获取当前记录数

        System.out.println(page.hasNext());//是否有下页
        System.out.println(page.hasPrevious());//是否有上页
    }

    @Test//单条删除
    public void testDelet(){
        int i = teacherMapper.deleteById(7L);
        System.out.println(i);
    }

    @Test//批量删除
    public void testmoreDelet(){
        int i = teacherMapper.deleteBatchIds(Arrays.asList(2, 3));
        System.out.println(i);
    }

    @Test
    public void TestSelectWrapper(){
        //创建一个QueryWrapper对象
        QueryWrapper<Teacher> wrapper = new QueryWrapper<>();
        //通过QueryWrapper对象设置条件
        //ge,gt,le,lt
        //ge >= ,gt >,le <=,lt <;
//        wrapper.ge("id", 3);
//        wrapper.eq("name","哈哈");
        wrapper.like("name","灰");
        //复杂条件查询
        List<Map<String, Object>> lists = teacherMapper.selectMaps(wrapper);
        System.out.println(lists);


    }


}