mybatis-plus快速上手

Wmenghu

已于 2022-08-13 17:18:24 修改

阅读量1.2k

点赞数

文章标签： java 后端

于 2022-04-08 10:47:53 首次发布

本文链接：https://blog.csdn.net/w13966597931/article/details/124035740

版权

特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 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.数据库创建张表

创建表

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.导入架包

<!--        数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.32</version>
        </dependency>
<!--        lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
<!--        mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>

所有架包包括代码生成器

<!--        数据库驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.32</version>
</dependency>
<!-- lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>
<!-- mybatis-plus -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.0.5</version>
</dependency>
<!--模板引擎 依赖:mybatis-plus代码生成的时候报异常-->
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.0</version>
</dependency>
<!--配置ApiModel在实体类中不生效-->
<dependency>
    <groupId>com.spring4all</groupId>
    <artifactId>spring-boot-starter-swagger</artifactId>
    <version>1.5.1.RELEASE</version>
</dependency>
<!--freemarker-->
<dependency>
    <groupId>org.freemarker</groupId>
    <artifactId>freemarker</artifactId>
    <version>2.3.30</version>
</dependency>
<!--beetl-->
<dependency>
    <groupId>com.ibeetl</groupId>
    <artifactId>beetl</artifactId>
    <version>3.3.2.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.7</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>
        </dependency>

不能同时导入 mybatis-plus 和 mybatis 的架包

3.连接数据库，和mybatis相同

# mysql5驱动不同 com.mysql.jdbc.Driver
# useSSL=false&useUnicode=true&characterEncoding=utf-8使用安全连接，等编码格式
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useSSL=false&useUnicode=true&characterEncoding=utf-8
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

# mysql8驱动不同com.mysql.cj.jdbc.Driver，还需要增加时区配置 如东八区  serverTimezone=GMT%2B8
# 具体配置如下
# spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?
# useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8

pojo

@Data
@AllArgsConstructor //所有构造方法
@NoArgsConstructor  //w
public class User {
    
    private Long id;
    private String name;
    private Integer age;
    private String email;
    
}

mapper接口

package com.menghu.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.menghu.pojo.User;
import org.springframework.stereotype.Repository;

//在对应的Mapper上面继承基本类 BaseMapper 泛型为查询时的条件
@Repository     //代表持久层
public interface UserMapper extends BaseMapper<User>{


}

在SpringbootWebApplication中添加Mapper的扫描

@MapperScan("com.menghu.mapper")
@SpringBootApplication
public class SpringbootWebApplication {

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

}

测试

//继承了BaseMapper，所有的方法都来自自己的父类。我们也可以编写自己的扩展方法
@Autowired(required=false)
private UserMapper userMapper;

@Test
void contextLoads() {
    //参数时一个Wapper，条件构造器，不用是传null
    List<User> list = userMapper.selectList(null);
    list.forEach(System.out::println);
}

配置日志

# 配置日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

CRUD扩展

Insert

@Test
public void testInsert(){
    User user=new User();
    user.setName("李四呀");
    user.setAge(13);
    user.setEmail("633136@qq.com");

    int result = userMapper.insert(user);  //帮助我们自动生成id
    System.out.println(result);        //返回受影响的行数
    System.out.println(user);           //id自动回填
}

主键生成策略

分布式系统唯一ID生成方案汇总： https://www.cnblogs.com/haoxinyue/p/5208136.html

默认方案：@TableId(type = IdType.ID_WORKER)

雪花算法：snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数
，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。

主键自增

1、实体类主键字段上 @TableId(type = IdType.AUTO)

2、数据库字段一定要是自增

其余源码解释

public enum IdType {
    AUTO(0), 		// 数据库自增id
    NONE(1),		// 未设置主键
    INPUT(2),		// 手动输入
    ID_WORKER(3),   // 全局默认唯一id 
    UUID(4),		// 全局默认唯一id uuid
    ID_WORKER_STR(5);// ID_WORKER 字符串的表示法

    private int key;

    private IdType(int key) {
        this.key = key;
    }

    public int getKey() {
        return this.key;
    }
}

Update

@Test
public void testUpdate(){
    User user=new User();
    //通过条件自动拼接动态sql
    user.setId(1468589713891598338L);
    user.setName("李四999");
    user.setAge(19);
    user.setEmail("6666@qq.com");

    //注意：updateById 需要传入一个对象
    userMapper.updateById(user);
}

自动填充

阿里巴巴开发手册：所有数据库表都应该配备创建时间（gmt_create）修改时间（gmt_modified）需要自动化，不希望手动进行更新

数据库级别更新（工作中不允许修改）

1、表中添加两个字段 create_time update_time

2、将实体类同步

    private Date create_time;
    private Date update_time;

代码级别更新

1、刪除数据库中的默认值和更新操作

2、在对应字段添加注解

@TableField(fill = FieldFill.INSERT)
private Date create_time;

@TableField(fill = FieldFill.INSERT_UPDATE)
private Date update_time;

3、编写处理器来处理注解

package com.menghu.handler;

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

import java.util.Date;

@Slf4j
@Component    //将处理器加入到IOC容器中
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill......");
        this.setFieldValByName("create_time",new Date(),metaObject);
        this.setFieldValByName("update_time",new Date(),metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("start update fill......");
        this.setFieldValByName("update_time",new Date(),metaObject);
    }
}

乐观锁

乐观锁：十分乐观，他总是认为不会出问题，无论干什么不去上锁！如果出现问题，再次更新值测试

悲观锁：十分悲观，他总是认为总是会出现问题，无论干什么都会上锁！再去操作！

乐观锁实现方式

取出记录时，获取当前version
更新时，带上这个version
执行更新时， set version = newVersion where version = oldVersion

如果version不对，就更新失败

乐观锁：1、先查询，获得版本号 version = 1
--A
update user set name="menghu" , version = version +1
where id = 2 and version =1

--B 线程抢先完成，这时候 version =2,导致 A 更新失败！
update user set name="wang" , version = version +1
where id = 2 and version =1

测试Mybatis_plusl乐观锁插件

1、数据库中增加version字段

2、实体类加对应的字段

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

3、注册组件

    //扫描mapper文件夹
    @MapperScan("com.menghu.mapper")
    @EnableTransactionManagement     //自动事务管理注解
    @Configuration     //配置类
    public class MybatisPlusConfig {

        //注册乐观锁插件
        @Bean
        public OptimisticLockerInterceptor optimisticLockerInterceptor() {
            return new OptimisticLockerInterceptor();
        }

    }

4、测试

//测试乐观锁成功
@Test
public void testOptimisticLocker(){
    //1.查询用户信息
    User user = userMapper.selectById(1468589713891598354L);
    //2.修改用户信息
    user.setName("menghu");
    user.setEmail("99999@qq.com");
    //3.执行更新操作
    userMapper.updateById(user);
}

//测试乐观锁失败
@Test
public void testFild(){
    //1.查询用户信息
    User user = userMapper.selectById(1468589713891598354L);
    //2.修改用户信息
    user.setName("111111");

    User user2 = userMapper.selectById(1468589713891598354L);
    user2.setName("222222");
    userMapper.updateById(user2);

    //3.执行更新操作
    userMapper.updateById(user);
}

Select

//单个查询测试
@Test
public void testSelectById(){
    User user = userMapper.selectById(1L);
    System.out.println(user);
}

//多个查询测试
@Test
public void testSelectByBatchId(){
    List<User> list = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
    list.forEach(System.out::println);
}

//按条件查询之一 Map
@Test
public void testSelectByMap(){
    HashMap<String, Object> hashMap = new HashMap<>();
    //自定义查询条件
    hashMap.put("name","menghu");
    userMapper.selectByMap(hashMap);

}

分页Select

1、配置分页插件的拦截器

@Bean
public PaginationInterceptor paginationInterceptor() {
    return new PaginationInterceptor();
}

2、直接使用Page对象即可

@Test
public void testPage(){
    // 参数一：当前页     参数二：页面条数
    Page<User> page = new Page<>();
    userMapper.selectPage(page, null);

    page.getRecords().forEach(System.out::println);
}

Delete

1、根据各种条件删除记录

@Test
public void testDeleteById(){
    userMapper.deleteById(1468589713891598357L);
}

2、逻辑删除

数据库中添加字段

实体类中添加字段和注解

@TableLogic   //逻辑删除注解
private Integer deleted;

配置Bean

// 逻辑删除组件！
    @Bean
    public ISqlInjector sqlInjector() {
        return new LogicSqlInjector();
    }

配置yml

# 逻辑删除配置
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

性能分析插件

性能分析拦截器，用于输出每条SQL语句执行时间和格式化SQL

1、配置环境为测试环境，或者开发环境

# 设置开发环境
spring.profiles.active=dev

2、导入插件

 	 /**
     * SQL执行效率插件
     */
    @Bean
    @Profile({"dev","test"})// 设置 dev test 环境开启，保证我们的效率
    public PerformanceInterceptor performanceInterceptor() {
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        performanceInterceptor.setMaxTime(100); //ms 设置sql执行的最大时间，如果超过了则不执行
        performanceInterceptor.setFormat(true); //是否格式化代码
        return performanceInterceptor;
    }

条件构造器

Wrapper

测试一

@Test
void contextLoads() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper
            .isNotNull("name")      //name不为空
            .isNotNull("email")		//Email不为空
            .ge("age",17);			//age大于17
    userMapper.selectList(wrapper).forEach(System.out::println);
}

测试二

@Test
void test2(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq("name","menghu");
    //查询一个用selectOne(wrapper)   出现多个结果用List  或者Map
    userMapper.selectList(wrapper).forEach(System.out::println);
}

测试三

@Test
void test3(){
    //查询年龄在 10~20 岁之间的用户  age between 10 and 20
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.between("age",10,20);  //区间
    Integer count = userMapper.selectCount(wrapper);  //查询结果条数
    System.out.println(count);
}

测试四

@Test
void test4(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    // 左模糊 %王    右模糊 王%
    wrapper
            .notLike("name","李")
            .likeRight("name","m");
    List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
    maps.forEach(System.out::println);
}

测试五

 void test5(){
/*SELECT
        id,
        NAME,
        age,
        email,
        VERSION,
        deleted,
        create_time,
        update_time 
    FROM
        USER 
    WHERE
        deleted=0 
        AND id IN (
            SELECT
                id 
            FROM
                USER 
            WHERE
                id<5
        )*/
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        // id 在子查询中查出来
        wrapper.inSql("id","select id from user where id<5");
        List<Object> list = userMapper.selectObjs(wrapper);
        list.forEach(System.out::println);
    }

测试六

@Test
void test6(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    // 通过id进行排序
    wrapper.orderByDesc("id");
    List<User> list = userMapper.selectList(wrapper);
    list.forEach(System.out::println);
}

代码生成器

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

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

<!--模板引擎 依赖:mybatis-plus代码生成的时候报异常-->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.0</version>
        </dependency>
        <!--配置ApiModel在实体类中不生效-->
        <dependency>
            <groupId>com.spring4all</groupId>
            <artifactId>spring-boot-starter-swagger</artifactId>
            <version>1.5.1.RELEASE</version>
        </dependency>
        <!--freemarker-->
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.30</version>
        </dependency>
        <!--beetl-->
        <dependency>
            <groupId>com.ibeetl</groupId>
            <artifactId>beetl</artifactId>
            <version>3.3.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.7</version>
        </dependency>

package com.menghu;

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 CreateCode {public static void main(String[] args) {

    // 需要构建一个 代码自动生成器 对象

    AutoGenerator mpg = new AutoGenerator();

    // 配置策略

    // 1、全局配置

    GlobalConfig gc = new GlobalConfig();

    String projectPath = System.getProperty("user.dir");
    gc.setOutputDir(projectPath+"/src/main/java");
    gc.setAuthor("添加注释");

    gc.setOpen(false);   //是否打开文件管理器

    gc.setFileOverride(false); // 是否覆盖

    gc.setServiceName("%sService"); // 去Service的I前缀

    gc.setIdType(IdType.ID_WORKER);  //主键策略

    gc.setDateType(DateType.ONLY_DATE);  //日期格式

    gc.setSwagger2(true);

    mpg.setGlobalConfig(gc);


//2、设置数据源

    DataSourceConfig dsc = new DataSourceConfig();
    dsc.setUrl("jdbc:mysql://localhost:3306/mybatis_plus?useSSL=false&useUnicode=true&characterEncoding=utf-8");
    dsc.setDriverName("com.mysql.jdbc.Driver");
    dsc.setUsername("root");
    dsc.setPassword("root");
    dsc.setDbType(DbType.MYSQL);
    mpg.setDataSource(dsc);

//3、包的配置

    PackageConfig pc = new PackageConfig();
    pc.setModuleName("blog");
    pc.setParent("com.menghu");
    pc.setEntity("entity");
    pc.setMapper("mapper");
    pc.setService("service");
    pc.setController("controller");
    mpg.setPackageInfo(pc);

//4、策略配置

    StrategyConfig strategy = new StrategyConfig();

    strategy.setInclude("user"); // 设置要映射的表名

    strategy.setNaming(NamingStrategy.underline_to_camel);  //命名规则，_转驼峰
    strategy.setColumnNaming(NamingStrategy.underline_to_camel);

    strategy.setEntityLombokModel(true); // 自动lombok；

    strategy.setLogicDeleteFieldName("deleted"); 

    // 自动填充配置

    TableFill gmtCreate = new TableFill("create_time", FieldFill.INSERT);

    TableFill gmtModified = new TableFill("update_time", FieldFill.INSERT_UPDATE);

    ArrayList<TableFill> tableFills = new ArrayList<>();

    tableFills.add(gmtCreate);

    tableFills.add(gmtModified);

    strategy.setTableFillList(tableFills);

    // 乐观锁

    strategy.setVersionFieldName("version");strategy.setRestControllerStyle(true);

    strategy.setControllerMappingHyphenStyle(true); //localhost:8080/hello_id_2

    mpg.setStrategy(strategy);

    mpg.execute(); //执行

}

}