MyBatis-Plus快速入门及CRUD扩展的使用
一、MyBatisPlus概述
1.1 什么是MyBatisPlus？
MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
1.2 MyBatisPlus的特性？
- 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
- 损耗小：启动即会自动注入基本 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.3 MyBatisPlus的框架结构
二、MyBatisPlus快速入门
2.1 创建数据库
创建数据库mybatisplus和表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)
);
2.2 搭建项目
1、创建项目MyBatisPlus（SpringBoot项目）
2、导入相关依赖
<dependencies>
<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>
<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>
<version>5.1.49</version>
</dependency>
<!-- lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.0</version>
</dependency>
</dependencies>
3、配置文件application.yml
# 配置数据库的相关链接
spring:
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/mybatisplus?useUnicode=true&characterEncoding=utf-8
username: root
password: root
# 配置开发环境
profiles:
active: dev
4、创建实体类
package cn.qhj.pojo;
import com.baomidou.mybatisplus.annotation.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* @author QHJ
* @date 2021/11/1 15:22
* @description: User实体类
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private Long id;
private String name;
private Integer age;
private String email;
}
5、创建mapper接口
package cn.qhj.mapper;
import cn.qhj.pojo.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.springframework.stereotype.Repository;
/**
* @author QHJ
* @date 2021/11/1 15:24
* @description: 基本接口(在对应的mapper上面继承基本的类 BaseMapper)
*/
@Repository // 代表持久层
public interface UserMapper extends BaseMapper<User> {
// 所有的CRUD操作都已经完成了，而不需要写一堆代码了
}
6、测试
@SpringBootTest
@SuppressWarnings(value = "all")
class MybatisplusApplicationTests {
// 继承了BaseMapper，所有的方法都来自于父类。当然也可以编写自己的扩展方法
@Autowired
private UserMapper userMapper;
@Test
void contextLoads() {
List<User> users = userMapper.selectList(null);
users.forEach(System.out::println);
}
}
我们没有编写任何SQL语句就可以实现查询，说明MyBatisPlus内部已经帮我们写好了这些SQL语句和相关的方法，由此可见MyBatisPlus的强大了！
三、MyBatisPlus配置日志
3.1 为什么要配置日志？
我们所有的SQL都是不可见的，要想知道它是怎么执行的，就需要通过日志来查看其执行过程。
3.2 配置日志
# 配置日志
mybatis-plus:
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 默认方式
四、CRUD扩展
4.1 插入操作
/**
* 测试插入
*/
@Test
public void testInsert(){
User user = new User();
user.setId((long) 10);
user.setAge(34);
user.setName("沉默的麻雀4");
user.setEmail("11111111@163.com");
System.out.println(userMapper.insert(user) == 1 ? "插入成功!" : "插入失败...");
}
4.2 主键生成策略
主键生成策略参考：https://www.cnblogs.com/haoxinyue/p/5208136.html
这里我们只配置主键自增（分为两步）：
1、在实体类字段上添加注解@TableId(type = IdType.AUTO)
2、将数据库字段设置为自增
注意：上述两个步骤缺一不可！！！
测试：
/**
* 测试插入
*/
@Test
public void testInsert(){
User user = new User();
// user.setId((long) 10);
user.setAge(34);
user.setName("沉默的麻雀5");
user.setEmail("11111111@163.com");
System.out.println(userMapper.insert(user) == 1 ? "插入成功!" : "插入失败...");
}
4.3 更新操作
/**
* 测试更新
*/
@Test
public void testUpdate(){
User user = new User();
user.setId((long) 7);
user.setAge(24);
user.setName("沉默的麻雀1");
user.setEmail("11111111@163.com");
System.out.println(userMapper.updateById(user) == 1 ? "更新成功!" : "更新失败...");
}
4.4 自动填充
当记录创建时间和修改时间时，我们并不希望手动更新，只需要配置自动填充就可以自动化完成了。这个填充有两个层面：
1、数据库层面
①在数据库表中新增字段create_time, update_time
②同步实体类
// 字段添加填充内容
private Date createTime;
private Date updateTime;
2、代码层面
① 删除数据的默认值和更新操作
② 在实体类字段属性上添加注解
// 字段添加填充内容
@TableField(fill = FieldFill.INSERT)
private Date createTime;
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;
③ 编写处理器来处理这个注解
package cn.qhj.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;
/**
* @author QHJ
* @date 2021/11/1 16:33
* @description:
*/
@Slf4j
@Component // 一定要将处理器加到IOC容器中
public class MyMetaObjectHandler implements MetaObjectHandler {
/**
* 插入时的填充策略
* @param metaObject
*/
@Override
public void insertFill(MetaObject metaObject) {
log.info("start insert fill...");
this.setFieldValByName("createTime",new Date(),metaObject);
this.setFieldValByName("updateTime",new Date(),metaObject);
}
/**
* 更新时的填充策略
* @param metaObject
*/
@Override
public void updateFill(MetaObject metaObject) {
log.info("start update fill...");
this.setFieldValByName("updateTime",new Date(),metaObject);
}
}
④ 测试
上面的代码中已经有显示这个时间了，没注意就往上巴拉巴拉哦！
4.5 乐观锁
乐观锁实现方式：
- 取出记录时，获取当前 version
- 更新时，带上这个version
- 执行更新时， set version = newVersion where version = oldVersion
- 如果version不对，就更新失败
1、给数据库增加version字段
2、给实体类增加对应字段
// 乐观锁Version注解
@Version
private Integer version;
3、注册组件
/**
* @author QHJ
* @date 2021/11/1 17:00
* @description: mybatisplus配置类
*/
@MapperScan("cn.qhj.mapper")
@EnableTransactionManagement
@Configuration // 配置类
public class MyBatisPlusConfig {
// 注册乐观锁插件
@Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor() {
return new OptimisticLockerInterceptor();
}
}
4、测试
/**
* 测试乐观锁成功-单线程下
*/
@Test
public void testOptimisticLocker(){
// 1.查询用户信息
User user = userMapper.selectById(1L);
// 2.修改用户信息
user.setName("qhj");
user.setEmail("222222@163.com");
// 3.执行更新操作
userMapper.updateById(user);
}
/**
* 测试乐观锁失败-多线程下
*/
@Test
public void testOptimisticLocker2(){
// 线程1
User user = userMapper.selectById(1L);
user.setName("Jone");
user.setEmail("Jone@163.com");
// 模拟另外一个线程执行了插队操作
User user2 = userMapper.selectById(1L);
user2.setName("Amay");
user2.setEmail("Amay@qq.com");
userMapper.updateById(user2);
// 如果没有乐观锁就会覆盖插队线程的值，也就是说两次都会执行成功。
// 很明显此操作没有执行，线程2插队成功。
// 可以使用自旋锁来多次尝试提交。
userMapper.updateById(user);
}
4.6 查询操作
/**
* 测试查询
*/
@Test
public void testSelectById(){
User user = userMapper.selectById(1L);
System.out.println(user);
}
/**
* 测试批量查询
*/
@Test
public void testSelectByVatchId(){
List<User> users = userMapper.selectBatchIds(Arrays.asList(1,2,3));
users.forEach(System.out::println);
}
/**
* 按条件查询之一--使用map操作
*/
@Test
public void testSelectByBatchIds(){
HashMap<String,Object> map = new HashMap<>();
// 自定义要查询的条件
map.put("name","Amay");
List<User> users = userMapper.selectByMap(map);
users.forEach(System.out::println);
}
4.7 分页查询
常见的分页查询：
- 原始的 limit 进行分页
- pageHelper 第三方插件
- MP内置的分页插件
1、配置拦截器组件
// 分页插件-拦截器组件
@Bean
public PaginationInterceptor paginationInterceptor() {
return new PaginationInterceptor();
}
2、使用Page对象实现分页
/**
* 测试分页查询
*/
@Test
public void testPage(){
// 参数一：当前页
// 参数二：页面大小
// 使用了分页插件之后，所有的分页操作也会变得简单
Page<User> page = new Page<>(3,3);
userMapper.selectPage(page,null);
page.getRecords().forEach(System.out::println);
System.out.println(page.getTotal());
}
4.8 删除操作
/**
* 测试删除
*/
@Test
public void testDeleteById(){
userMapper.deleteById(1L);
}
/**
* 通过id批量删除
*/
@Test
public void testDeleteBatchId(){
userMapper.deleteBatchIds(Arrays.asList(1,2,3));
}
/**
* 通过map删除
*/
@Test
public void testDeleteMap(){
HashMap<String, Object> map = new HashMap<>();
map.put("name","Amay");
userMapper.deleteByMap(map);
}
4.9 逻辑删除
物理删除 ：从数据库中直接移除
逻辑删除 ：在数据库中没有被移除，而是通过一个变量来让他失效！ deleted = 0 => deleted = 1
1、在数据库表中增加字段deleted
2、在实体类中增加属性
// 逻辑删除
@TableLogic
private Integer deleted;
3、配置文件application.yml
mybatis-plus:
global-config:
db-config:
logic-delete-value: 1 # 删除值
logic-not-delete-value: 0 # 不删除值
4、配置组件
// 逻辑删除组件
@Bean public ISqlInjector sqlInjector() {
return new LogicSqlInjector();
}
5、测试
/**
* 测试删除
*/
@Test
public void testDeleteById(){
userMapper.deleteById(1L);
}
4.10 性能分析插件
作用：性能分析拦截器，用于输出每条 SQL 语句及其执行时间
MP也提供性能分析插件，如果超过这个时间就停止运行！
1、配置插件
/**
* SQL执行效率插件
* @return
*/
@Bean
@Profile({"dev","test"}) // 设置dev test环境开启，保证效率
public PerformanceInterceptor performanceInterceptor(){
PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
// ms设置sql执行的最大时间，如果超过了这个时间就不执行
performanceInterceptor.setMaxTime(100);
// 是否格式化代码
performanceInterceptor.setFormat(true);
return performanceInterceptor;
}
spring:
# 配置开发环境
profiles:
active: dev
注意：要在SpringBoot中配置环境为dev或者 test 环境！
2、测试
@Test
void contextLoads() {
List<User> users = userMapper.selectList(null);
users.forEach(System.out::println);
}
4.11 条件构造器
wapper介绍 ：
- Wrapper ： 条件构造抽象类，最顶端父类，抽象类中提供4个方法西面贴源码展示
- AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件
- AbstractLambdaWrapper ： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。
- LambdaQueryWrapper ：看名称也能明白就是用于Lambda语法使用的查询Wrapper
- LambdaUpdateWrapper ： Lambda 更新封装Wrapper
- QueryWrapper ： Entity 对象封装操作类，不是用lambda语法
- UpdateWrapper ： Update 条件封装，用于Entity对象更新操作
详情查看：mybatis Plus 的Wapper条件构造器使用
/**
* 测试条件构造器1
*/
@Test
public void testConstrustor1(){
// 查询name不为空的用户，并且邮箱不为空的用户，年龄大于等于
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.isNotNull("name").isNotNull("email").ge("age",12);
userMapper.selectList(wrapper).forEach(System.out::println);
}
/**
* 测试条件构造器2
*/
@Test
public void testConstrustor2(){
// 查询名字Amay
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("name","Amay");
User user = userMapper.selectOne(wrapper);
// 查询一个数据，出现多个结果使用List 或者 Map
System.out.println(user);
}
/**
* 测试条件构造器3
*/
@Test
public void testConstrustor3(){
// 查询年龄在 20 ~ 30 岁之间的用户
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.between("age",20,30);
// 区间
Integer count = userMapper.selectCount(wrapper);
// 查询结果数
System.out.println(count);
}
/**
* 测试条件构造器4--模糊查询1
*/
@Test
public void testConstrustor4(){
// 查询年龄在 20 ~ 30 岁之间的用户
QueryWrapper<User> wrapper = new QueryWrapper<>();
// 左和右 t%
wrapper.notLike("name","e").likeRight("email","t");
List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
maps.forEach(System.out::println);
}
/**
* 测试条件构造器5--模糊查询2
*/
@Test
public void testConstrustor5(){
QueryWrapper<User> wrapper = new QueryWrapper<>();
// id 在子查询中查出来
wrapper.inSql("id","select id from user where id<3");
List<Object> objects = userMapper.selectObjs(wrapper);
objects.forEach(System.out::println);
}
/**
* 测试条件构造器6--模糊查询3
*/
@Test
public void testConstrustor6(){
QueryWrapper<User> wrapper = new QueryWrapper<>();
// 通过id进行排序
wrapper.orderByAsc("id");
List<User> users = userMapper.selectList(wrapper);
users.forEach(System.out::println);
}
4.12 代码自动生成
package cn.qhj.config;
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;
/**
* @author QHJ
* @date 2021/11/2 10:09
* @description:
*/
public class AutoCode {
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("qhj");
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/mybatisplus?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.qhj");
pc.setEntity("entity");
pc.setMapper("mapper");
pc.setService("service");
pc.setController("controller");
mpg.setPackageInfo(pc);
//4、策略配置
StrategyConfig strategy = new StrategyConfig();
strategy.setInclude("blog_tags","course","links","sys_settings","user_record"," user_say");
// 设置要映射的表名
strategy.setNaming(NamingStrategy.underline_to_camel);
strategy.setColumnNaming(NamingStrategy.underline_to_camel);
strategy.setEntityLombokModel(true); // 自动lombok；
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);
// localhost:8080/hello_id_2
mpg.setStrategy(strategy); mpg.execute(); //执行
}
}
772
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
