mybatis-plus使用(含代码生成器)

依赖

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

@TableId(type = IdType.AUTO)主键自增策略

//    插入时修改内容
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
//    插入和更新都修改内容
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;

package com.hzy.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import lombok.extern.java.Log;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component  //将处理器加入到IOC容器中
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        this.setFieldValByName("createTime",new Date(),metaObject);
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
}

乐观锁和悲观锁

给数据库增加version字段

@Version //乐观锁注解 private Integer version;

在配置类中注册乐观锁组件

package com.hzy.config;

import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@EnableTransactionManagement
@MapperScan("com.hzy.mapper")
@Configuration  //配置类，启动加载
public class MyBatisPlusConfig {
//    注册乐观锁插件
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor(){
        return new OptimisticLockerInterceptor();
    }
}

测试乐观锁成功和失败

//    测试乐观锁成功
    @Test
    public void testOptimisticLocker(){
        User user=userMapper.selectById(1L);
        user.setName("giao");
        user.setEmail("4396");
        userMapper.updateById(user);
    }
//    测试乐观锁失败(多线程下)模拟线程插队
    @Test
    public void testOptimisticLocker2(){
        User user=userMapper.selectById(1L);
        user.setName("qian");
        user.setEmail("123");

        User user2=userMapper.selectById(1L);
        user2.setName("fen");
        user2.setEmail("abc");
        userMapper.updateById(user2);
        //        使用了乐观锁，进行更新时会携带version字段，如果在更新之前version字段已被更改，那么更新操作不会成功
        userMapper.updateById(user);//如果没有乐观锁，就会覆盖线程插队的值
    }

悲观锁就是synchronized

分页查询

//    在配置类注册分页插件
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return  new PaginationInterceptor();
    }

进行测试

//    分页查询
    @Test
    public void testPage(){
//        第一页，每页五条数据
        Page<User> page=new Page<>(1,5);
        Page<User> users = userMapper.selectPage(page, null);               
        System.out.println(users.getRecords().toString());
        System.out.println("--------------");
        page.getRecords().forEach(System.out::println);
        System.out.println("--------------");
        System.out.println(page.getTotal());
        System.out.println("--------------");
    }

逻辑删除

数据库增加字段，pojo新增属性，添加注解

@TableLogic private Integer deleted;
注册 Bean(3.1.1开始不再需要这一步)

 @Bean
    public ISqlInjector sqlInjector() {
        return new LogicSqlInjector();
    }

编写配置文件

#    配置逻辑删除
mybatis-plus:
  global-config:
    db-config:
      logic-delete-value: 1 #逻辑删除后
      logic-not-delete-value: 0  #原先

进行测试删除(配置之后，删除不是真正的删除)

@Test
    public void testDeleteId(){
        //int count = userMapper.deleteById(1240959130307493892L);
        //int count=userMapper.deleteBatchIds(Arrays.asList(1240959130307493891L,1240959130307493890L));
        Map map=new HashMap<>();
        map.put("name","fen");
        map.put("age",18);
        int count=userMapper.deleteByMap(map);
        System.out.println(count);
    }

并且查询的时候后自动过滤被逻辑删除的

性能分析插件

性能分析拦截器，用于输出每条 SQL 语句及其执行时间
该插件 3.2.0 以上版本移除推荐使用第三方扩展 执行SQL分析打印 功能

/**
     * SQL执行效率插件
     */
    @Bean
    @Profile({"dev","test"})// 设置 dev test 环境开启
    public PerformanceInterceptor performanceInterceptor() {
        PerformanceInterceptor performanceInterceptor=new PerformanceInterceptor();
        //在工作中常用
        performanceInterceptor.setMaxTime(1);//设置sql语句执行的最大时间，如果超过了就不执行，报出异常
        performanceInterceptor.setFormat(true);
        return performanceInterceptor;
    }

配置环境

spring:
  profiles:
    active: dev

条件构造器

Wrapper的小练习

package com.hzy;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.hzy.mapper.UserMapper;
import com.hzy.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

@SpringBootTest
public class WrapperTest {
    @Autowired(required = false)
    private UserMapper userMapper;
    @Test
    void contextLoads() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper
                .isNotNull("name")
                .isNotNull("email")
                .ge("age",12);//大于等于12岁
        userMapper.selectList(wrapper).forEach(System.out::println);

    }
    @Test
    void test2() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age",20,30);//查询20-30岁之间的
        System.out.println(userMapper.selectCount(wrapper));//查询数量
    }
    @Test
    void test3() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("name","abc");
        System.out.println(userMapper.selectOne(wrapper));//查询一条数据
    }
//    模糊查询
    @Test
    void test4() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
//        likeRight和likeLeft表示%在哪边
        wrapper
                .notLike("name","e")//名字中不包含e的
                .likeRight("email","t")
        ;
        userMapper.selectMaps(wrapper).forEach(System.out::println);
    }
    @Test
    void test5() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
//        id在子查询中查询出来
        wrapper.inSql("id","select id from user where id>3");
        userMapper.selectObjs(wrapper).forEach(System.out::println);
    }
    @Test
    void test6() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
//        排序
        wrapper.orderByDesc("id");
        userMapper.selectList(wrapper).forEach(System.out::println);
    }
}

代码生成器

添加依赖
所需要的maven配置文件

 
    <dependencies>
        <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.30</version>
        </dependency>

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

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>
        <!-- 模板引擎 -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

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

使用代码生成器

package com.hzy;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
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.po.TableFill;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

import java.util.ArrayList;

//代码生成器
public class HzyCode {
    public static void main(String[] args) {
        //        构建一个代码生成器对象
        AutoGenerator mpg = new AutoGenerator();
        //        配置策略
        //        1.全局配置
        GlobalConfig gc=new GlobalConfig();
        //        当前的项目路径
        String propertyPath = System.getProperty("user.dir");
        gc.setOutputDir(propertyPath+"/src/main/java");
        gc.setAuthor("hzy");//作者名
        gc.setOpen(false);//是否打开资源管理器
        gc.setFileOverride(false);//是否覆盖原先的文件
        gc.setServiceName("%sService");//去Service的i前缀
        gc.setIdType(IdType.AUTO);
        gc.setDateType(DateType.ONLY_DATE);
        gc.setSwagger2(true);
        mpg.setGlobalConfig(gc);
        //        设置数据源
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/demo?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);

        //        包的配置
        PackageConfig pc = new PackageConfig();
/**
 * 配置模块名
 * */
        pc.setModuleName("demo");
        pc.setParent("com.hzy");
        pc.setEntity("entity");
        pc.setService("service");
        pc.setController("controller");
        mpg.setPackageInfo(pc);

        //        策略配置
        StrategyConfig strategy = new StrategyConfig();
/**
 * 配置表名，可以填写多个一次生成...
 * */
        strategy.setInclude("user","log");//设置要映射的表名(可以填写多个)
        //        下划线转驼峰
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setEntityLombokModel(true);//自动lombok
        strategy.setLogicDeleteFieldName("deleted");//逻辑删除的字段
        //        自动填充
        TableFill createTime = new TableFill("create_time", FieldFill.INSERT);
        TableFill updateTime = new TableFill("update_time", FieldFill.INSERT_UPDATE);
        ArrayList<TableFill> tableFills = new ArrayList<>();
        tableFills.add(createTime);
        tableFills.add(updateTime);
        //        乐观锁
        strategy.setVersionFieldName("version");
        strategy.setRestControllerStyle(true);
        strategy.setControllerMappingHyphenStyle(true);
        mpg.setStrategy(strategy);

        mpg.execute();//执行
    }
}