MyBatisPlus 介绍 和 简单使用

MyBatisPlus

MyBatisPlus概述

需要的基础 ：MyBatis ，Spring ，SpringMVC

我们为什么要学习MyBatisPlus呢？

MyBatisPlus可以方便我们的开发 减少大量的工作时间，所有的CRUD代码都可以自动化完成，

市面上用的最多的 简化代码的 工具 JPA ，tk-mapper, MyBatisPlus

简介

MyBatisPlus 是什么？ 为了简化MyBatis 的！

官网 ：https://mp.baomidou.com/

特性

• 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
• 损耗小：启动即会自动注入基本 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 操作智能分析阻断，也可自定义拦截规则，预防误操作

快速入门

地址：https://mp.baomidou.com/guide/quickstart.html#%E5%88%9D%E5%A7%8B%E5%8C%96%E5%B7%A5%E7%A8%8B

1、导入对应的依赖

2、研究依赖如何配置

3、代码如何编写

4、提高扩展技术能力

步骤

1、创建数据库

mybatis_plus

2、创建user表

DROP TABLE IF EXISTS user;

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, '[email protected]'),
(2, 'Jack', 20, '[email protected]'),
(3, 'Tom', 28, '[email protected]'),
(4, 'Sandy', 21, '[email protected]'),
(5, 'Billie', 24, '[email protected]');

-- 真实开发中，version(乐观锁)、deleted(逻辑删除)、gmt_create(创建时间)、gmt_modified(修改时间)
           

3、编写项目 使用 springboot

4、导入依赖

<!--数据库驱动-->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.44</version>
</dependency>
<!--lombok-->
<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <version>1.18.12</version>
</dependency>
<!--mybatis-plus 新版本有新的特性 我这里用的 3.0.5 -->
<dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>mybatis-plus-boot-starter</artifactId>
  <version>3.0.5</version>
</dependency>
           

5、数据库连接

#mysql 5  驱动不同 com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=321
spring.datasource.url=spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

#mysql 8  驱动不同 com.mysql.cj.jdbc.Driver  需要增加时区的配置 serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=321
spring.datasource.url=spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC&serverTimezone=GMT%2B8
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

           

6

6.1、实体类

@Data
@AllArgsConstructor//生成全参数构造函数
@NoArgsConstructor//生成无参构造函数
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}
           

6.2、持久层

//在对应的Mapper 上面继承基本的接口 BaseMapper<Object>
@Repository
public interface UserMapper extends BaseMapper<User> {
    //所有简单的CRUD操作已经编写完成了
    //不需要像以前的配置一大堆文件了
}
           

//扫描我们的Mapper 文件夹
@MapperScan("com.kang.mybaitsplusboot.mapper")
@SpringBootApplication
public class MybaitsplusbootApplication {

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

}
           

6.3、测试

@SpringBootTest
class MybaitsplusbootApplicationTests {

    @Autowired
    private UserMapper userMapper;

    @Test
    void contextLoads() {
        List<User> users = userMapper.selectList(null);
        users.forEach(s -> System.out.println(s));
    }
}
           

配置日志

我们所有的sql现在是不可见的，我们希望知道它是怎么执行的，所以我们必须要看日志!

#在application.properties 配置
#配置日志   org.apache.ibatis.logging.stdout.StdOutImpl  默认控制台输出
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
           

CRUD拓展

主键生成策略

默认 ID_WORKER全局唯—id

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-32z2zbs7-1632464296120)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210908014517795.png)]

分布式系统唯—id生成: https://www.cnblogs.com/haoxinyue/p/5208136.html

对应数据库中的主键(uuid、自增id、雪花算法、redis、 zookeeper ! )

1、数据库自增：

最常见的方式。利用数据库，全数据库唯一。

优点：

1）简单，代码方便，性能可以接受。

2）数字ID天然排序，对分页或者需要排序的结果很有帮助。

缺点：

1）不同数据库语法和实现不同，数据库迁移的时候或多数据库版本支持的时候需要处理。

2）在单个数据库或读写分离或一主多从的情况下，只有一个主库可以生成。有单点故障的风险。

3）在性能达不到要求的情况下，比较难于扩展。（不适用于海量高并发）

4）如果遇见多个系统需要合并或者涉及到数据迁移会相当痛苦。

5）分表分库的时候会有麻烦。

6）并非一定连续，类似MySQL，当生成新ID的事务回滚，那么后续的事务也不会再用这个ID了。这个在性能和连续性的折中。如果为了保证连续，必须要在事务结束后才能生成ID，那性能就会出现问题。

7）在分布式数据库中，如果采用了自增主键的话，有可能会带来尾部热点。分布式数据库常常使用range的分区方式，在大量新增记录的时候，IO会集中在一个分区上，造成热点数据。

2、雪花算法︰

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

snowflake算法可以根据自身项目的需要进行一定的修改。比如估算未来的数据中心个数，每个数据中心的机器数以及统一毫秒可以能的并发数来调整在算法中所需要的bit数。

优点：

1）不依赖于数据库，灵活方便，且性能优于数据库。

2）ID按照时间在单机上是递增的。

缺点：

1）在单机上是递增的，但是由于涉及到分布式环境，每台机器上的时钟不可能完全同步，在算法上要解决时间回拨的问题。

3、UUID：

常见的方式。可以利用数据库也可以利用程序生成，一般来说全球唯一。UUID是由32个的16进制数字组成，所以每个UUID的长度是128位（16^32 = 2^128）。UUID作为一种广泛使用标准，有多个实现版本，影响它的因素包括时间、网卡MAC地址、自定义Namesapce等等。

优点：

1）简单，代码方便。

2）生成ID性能非常好，基本不会有性能问题。

3）全球唯一，在遇见数据迁移，系统数据合并，或者数据库变更等情况下，可以从容应对。

缺点：

1）没有排序，无法保证趋势递增。

2）UUID往往是使用字符串存储，查询的效率比较低。

3）存储空间比较大，如果是海量数据库，就需要考虑存储量的问题。

4）传输数据量大

5）不可读。

4、zookeeper生成唯一ID

zookeeper主要通过其znode数据版本来生成序列号，可以生成32位和64位的数据版本号，客户端可以使用这个版本号来作为唯一的序列号。

很少会使用zrolce eper来生成唯一。主要是由于需要依赖rokerepers并且是多步调用&I如果在旁争较大的侑况下·需要考虑使用分布式锁。因此﹐性能在高并发的分布式环情下，也不甚理想。

5、Redis生成ID

当使用数据库来生成ID性能不够要求的时候，我们可以尝试使用Redis来生成ID。这主要依赖于Redis是单线程的，所以也可以用生成全局唯一的ID。可以用Redis的原子操作 INCR和INCRBY来实现。

可以使用Redis集群来获取更高的吞吐量。假如一个集群中有5台Redis。可以初始化每台Redis的值分别是1,2,3,4,5，然后步长都是5。各个Redis生成的ID为：

A：1,6,11,16,21

B：2,7,12,17,22

C：3,8,13,18,23

D：4,9,14,19,24

E：5,10,15,20,25

这个，随便负载到哪个机确定好，未来很难做修改。但是3-5台服务器基本能够满足器上，都可以获得不同的ID。但是步长和初始值一定需要事先需要了。使用Redis集群也可以方式单点故障的问题。

另外，比较适合使用Redis来生成每天从0开始的流水号。比如订单号=日期+当日自增长号。可以每天在Redis中生成一个Key，使用INCR进行累加。

优点：

1）不依赖于数据库，灵活方便，且性能优于数据库。

2）数字ID天然排序，对分页或者需要排序的结果很有帮助。

缺点：

1）如果系统中没有Redis，还需要引入新的组件，增加系统复杂度。

2）需要编码和配置的工作量比较大。

主键自增

我们需要配置主键自增∶

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字符串表示法
}
           

自动填充

创建时间、修改时间!这些个操作一遍都是自动化完成的，我们不希望手动更新!

阿里巴巴开发手册︰所有的数据库表∶gmt_create、gmt_modified几乎所有的表都要配置上!而且需要自动化!

方式一：数据库级别

1、在表中新增字段create_time, update_time

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GnT0x2Ib-1632464296124)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210909004740907.png)]

2、对应的实体类 添加字段

private Date createTime;
    private Date updateTime;
           

3、测试

方式二：代码级别

1、删除数据库的默认值、更新操作!

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZcYTYMmX-1632464296128)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210909010224333.png)]

2.实体类字段属性上需要增加注解

@TableField(fill = FieldFill.INSERT)
private Date createTime;
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;
           

2.1、注解

public enum FieldFill {//填充
    DEFAULT,//不填充
    INSERT,//增加时填充
    UPDATE,//修改时填充
    INSERT_UPDATE;//增加和修改时填充
    }
           

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

@Component
public class MymetaObjectHandler implements MetaObjectHandler {
  //插入时的填充策略
    @Override
    public void insertFill(MetaObject metaObject) {
        //setFieldValByName(String 字段名, Object 字段值, 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);

    }
}
           

4、测试

乐观锁

在面试过程中，我们经常会被问道乐观锁，悲观锁!这个其实非常简单!

乐观锁∶故名思意十分乐观，它总是认为不会出现问题，无论干什么不去上锁!如果出现了问题，再次更新值测试

悲观锁:故名思意十分悲观，它总是认为总是出现问题，无论干什么都会上锁! |

version、new version

乐观锁实现方式：

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

1、数据库添加字段

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lKh3zK5s-1632464296132)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210909154502782.png)]

2、实体类添加字段

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

3、注册乐观锁插件

@MapperScan("com.kang.mybaitsplusboot.mapper")
@EnableTransactionManagement //自动管理事务
@Configuration //配置类
public class MybatisplusConfig {

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

}
           

4、测试

//测试乐观锁成功
@Test
public void versionTest(){
    User user = userMapper.selectById(1l);
    user.setName("苏笙");
    user.setEmail("12321321");
    userMapper.updateById(user);
}

//测试乐观锁失败
@Test
public void versionTest2(){
    User user = userMapper.selectById(1l);
    user.setName("苏笙");
    user.setEmail("12321321");

    User user2 = userMapper.selectById(1l);
    user2.setName("苏笙");
    user2.setEmail("12321321");
    userMapper.updateById(user2);

    userMapper.updateById(user);
}
           

查询

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

//查询多个Id测试
@Test
public void selectByBatchId(){
    List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
    users.forEach(System.out::println);
}
//条件测试
@Test
public void selectByBatchIds(){
    Map<String,Object> map=new HashMap();
    map.put("name","康康");
    List<User> users = userMapper.selectByMap(map);
    users.forEach(System.out::println);
}
           

分页

1、原始的limit进行分页

2.第三方插件

3、MbatisPlus其实也内置了分页插件!

1、配置拦截器组件即可

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

2、测试

//分页测试
    @Test
    public void pageSelect(){
        //参数一:当前页
        // 参数二:页面大小
        Page<User> page = new Page<>(1,5);
        userMapper.selectPage(page,null);
        //getRecords 分页记录
        page.getRecords().forEach(System.out::println);
    }
           

性能分析插件

性能分析插件 我们在平时的开发中，会遇到一些慢sql。测试！ druid,,,,, 

作用：性能分析拦截器，用于输出每条 SQL 语句及其执行时间 

MP也提供性能分析插件，如果超过这个时间就停止运行！ 
           

导入插件在配置类

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

#设置开发环境 application.yml文件
spring:
  profiles:
        active: dev
           

逻辑删除

1、在数据库添加字段 deleted

2、在实体类添加字段

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

3、配置文件（application.properties） 和配置类 配置逻辑删除

#逻辑删除
#删除时
mybatis-plus.global-config.db-config.logic-delete-value=1
#没有删除时
mybatis-plus.global-config.db-config.logic-not-delete-value=0
           

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

4、测试

条件构造器 Wrapper

我们写一些复杂的sql就可以使用它来替代！

1、测试

eq 等于 =

//测试eq
@Test
void contextLoads() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq("name","康康");//查询姓名是康康的用户
    
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}
           

ne 不等于 <>

//测试ne
@Test
void testNe() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.ne("name","康康");//查询姓名不等于 康康 的用户
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}
           

gt 大于 >

//测试gt
@Test
void testGt() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.gt("age",18);//查询大于18的用户
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}
           

ge 大于等于 >=

//测试ge
@Test
void testGe() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.ge("age",18);//查询大于等于18的用户
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}
           

lt 小于 <

//测试lt
@Test
void testLt() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.lt("age",18);//查询小于18的用户
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}
           

le 小于等于 <=

//测试le
@Test
void testLe() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.le("age",18);//查询小于等于18的用户
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}
           

between 之间

//测试between
@Test
void testBetween() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.between("age",12,18);//查询年龄在12 到 18 之间的
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}
           

notBetween 不在 这之间

//测试notbetween
@Test
void testNotBetween() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.notBetween("age",12,18);//查询不年龄在12 到 18 之间的
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}
           

like 模糊查询

//测试like
@Test
void testLike() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.like("name","康");
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}
           

notLike查询不包含的关键字

//测试notlike
@Test
void testNotLike() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.notLike("name","康");
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}
           

isNull 是空的

//测试isnull
@Test
void testIsNull() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.isNull("name");//查询name 是null的
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}
           

isNotNull 不是null的

//测试isNotnull
@Test
void testIsNotNull() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.isNotNull("name");//查询name 不是null的
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}
           

in 查询某个范围内的数据

//测试in
@Test
void testIn() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.in("id", Arrays.asList(1435647182320463873L,1436279101462753282L,1436279297521303553L));//查询某个范围内的数据
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}
           

notIn 跟上面的相反

//测试notin
@Test
void testNotIn() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.notIn("id", Arrays.asList(1435647182320463873L,1436279101462753282L,1436279297521303553L));
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}
           

noSql 子查询

//测试inSql
@Test
void testInSql() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.inSql("id","select id from user where id = 1435647182320463873");
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}
           

notInSql 跟上面相反

//测试notinSql
@Test
void testNotInSql() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.notInSql("id","select id from user where id = 1435647182320463873");
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}
           

groupBy 分组

自己去玩

orderByAsc 升序

//测试orderByAsc
@Test
void testOrderByAscl() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.orderByAsc("age");
    userMapper.selectList(wrapper).forEach(System.out::println);
}
           

orderByDesc 倒序

//测试orderByDesc
@Test
void testorderByDesc() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.orderByDesc("age");
    userMapper.selectList(wrapper).forEach(System.out::println);
}
           

orderBy 排序

//测试orderBy
@Test
void testOrderBy() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.orderBy(true,false,"age");//第二个参数 是控制 倒序 升序的 true是升序 false是倒序
    userMapper.selectList(wrapper).forEach(System.out::println);
}
           

or 嵌套

//测试or
@Test
void testOr() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.lt("age",18)
            .or()//主动调用or表示紧接着下一个方法不是用and连接!(不调用or则默认为使用and连接)
            .eq("name","康");
    userMapper.selectList(wrapper).forEach(System.out::println);
}
           

and 嵌套

//测试and
@Test
void testAnd() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.and(true,qw->qw.eq("age", "18").eq("name","康康"));
    userMapper.selectList(wrapper).forEach(System.out::println);
}
           

apply 拼接sql

//测试apply
@Test
void testApply() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.apply("id = 1435647182320463873");
    userMapper.selectList(wrapper).forEach(System.out::println);
}
           

last 拼接sql

无视优化规则直接拼接到 sql 的最后

注意事项:

只能调用一次,多次调用以最后一次为准 有sql注入的风险,请谨慎使用

//测试last
@Test
void testLast() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.last("limit 0,5");
    userMapper.selectList(wrapper).forEach(System.out::println);
}
           

select 设置查询字段

//测试select 
@Test
void testSelect() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.select("name","age","email");
    userMapper.selectList(wrapper).forEach(System.out::println);
}
           

代码自动生成器

MyBatis-Plus 从

3.0.3

之后移除了代码生成器与模板引擎的默认依赖，需要手动添加相关依赖：

<!--代码生成器依赖-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.0.5</version>
</dependency>
<!--模板引擎依赖-->
<dependency>
    <groupId>org.freemarker</groupId>
    <artifactId>freemarker</artifactId>
    <version>latest-freemarker-version</version>
</dependency>

<dependency>
    <groupId>io.swagger</groupId>
    <artifactId>swagger-annotations</artifactId>
    <version>1.6.2</version>
</dependency>
           

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);
        // 去Service的I前缀
        gc.setServiceName("%sService");
        //id生成策略
        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/t259?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("321");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);
        //3、包的配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName("ssm");
        pc.setParent("org.kang");
        pc.setEntity("model");
        pc.setMapper("mapper");
        pc.setService("service");
        pc.setController("controller");
        mpg.setPackageInfo(pc);
        //4、策略配置
        StrategyConfig strategy = new StrategyConfig();
        // 设置要映射的表名
        strategy.setInclude("t_student");
        // 去除的表前缀
        strategy.setTablePrefix("t_");
        // 配置数据表与实体类名之间映射的策略
        strategy.setNaming(NamingStrategy.underline_to_camel);
        // 配置数据表的字段与实体类的属性名之间映射的策略
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        // 自动lombok；
        strategy.setEntityLombokModel(true);
        //逻辑删除配置
        strategy.setLogicDeleteFieldName("deleted");
        // 自动填充配置
        TableFill gmtCreate = new TableFill("gmt_create", FieldFill.INSERT);
        TableFill gmtModified = new TableFill("gmt_modified",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);
        mpg.setStrategy(strategy);
        mpg.execute(); //执行
    }