在线教育项目_01Mybatis-plus
一、简介
官网：http://mp.baomidou.com/
MyBatis-Plus(简称MP)是MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
二、特性
- 无侵入性： 只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
- 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
- 支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件
- 支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer2005、SQLServer 等多种数据库
- 支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
- 支持 XML 热加载：Mapper 对应的 XML 支持热加载，对于简单的 CRUD 操作，甚至可以无 XML 启动
- 内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎
- 内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
- 内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
- 内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作
- 内置 Sql 注入剥离器：支持 Sql 注入剥离，有效预防 Sql 注入攻击
三、入门案例
3.1 创建并初始化数据库
- 用SQLyong可视化工具创建mybatis_plus数据库
3.2 创建User表
- 在该数据库中创建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)
);
- 向表中添加数据：
DELETE FROM USER;
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');
3.3 初始化工程
使用 Spring Initializr 快速初始化一个 Spring Boot 工程
Group：com.atguigu
Artifact：mpdemo1010
版本：2.2.1.RELEASE
3.4 添加依赖
1 引入依赖
spring-boot-starter、spring-boot-starter-test
添加：mybatis-plus-boot-starter、MySQL、lombok、
在项目中使用Lombok可以减少很多重复代码的书写。比如说getter/setter/toString等方法的编写 pom.xml文件中添加依赖
<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>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
<!--mybatis-plus-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.0.5</version>
</dependency>
<!--mysql-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!--lombok用来简化实体类-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
2、在idea中安装lombok插件
安装插件后，lombok才能起作用
3.5 配置
application.properties配置文件
mysql8.0以上要用带cj的驱动还有设置时区
#mysql数据库连接
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=abc123
3.6 编写代码
- 实体类User
package com.atguigu.entity;
import lombok.Data;
@Data
public class User {
private Long id;
private String name;
private Integer age;
private String email;
}
- mapper接口
package com.atguigu.mapper;
import com.atguigu.entity.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
//苞米斗mybayisplus提供的BaseMapper，里面有很多方法，我们只需要继承就能够调用增删改查方法
@Repository
public interface UserMapper extends BaseMapper<User> {
}
- 启动类加注解
package com.atguigu;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@MapperScan("com.atguigu.mapper")//去扫描mapper,找到接口然后进行实现类去实现
public class Mpdemo1010Application {
public static void main(String[] args) {
SpringApplication.run(Mpdemo1010Application.class, args);
}
}
3.7 开始使用
在测试模块测试
package com.atguigu;
import com.atguigu.entity.User;
import com.atguigu.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
@SpringBootTest
class Mpdemo1010ApplicationTests {
//将mapper注入到test里面来
@Autowired//报错解决------在userMapper加上给springIoc容器管理的注解，让自动注入能够找得到
private UserMapper userMapper;
//测试查询user表中的所有数据
@Test
void findAll() {
List<User> userList = userMapper.selectList(null);
System.out.println(userList);
}
}
3.8 配置日志
#mybatis日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
四. MyBatisPlus的CRUD 接口
4.1 insert
package com.atguigu;
import com.atguigu.entity.User;
import com.atguigu.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
@SpringBootTest
class Mpdemo1010ApplicationTests {
//将mapper注入到test里面来
@Autowired//报错解决------在userMapper加上给springIoc容器管理的注解，让自动注入能够找得到
private UserMapper userMapper;
//添加操作
@Test
public void addUser(){
User user = new User();
user.setName("lucy");
user.setAge(22);
user.setEmail("lucy@qq.com");
//ID自动回填，返回的是影响的行数
int insert = userMapper.insert(user);
System.out.println("添加用户" + insert);
}
}
注意：数据库插入id值默认为：全局唯一id
4.2 主键策略
- ID_WORKER
MyBatis-Plus默认的主键策略是：ID_WORKER全局唯一ID；snowflake算法
参考资料：分布式系统唯一ID生成方案汇总：https://www.cnblogs.com/haoxinyue/p/5208136.html - 自增策略
- 想要主键自增需要在创建数据表时设置主键自增
- 实体字段中配置@Tableld(type = IdType.AUTO)
UUID
缺点：无法排序
Redis生成ID
@TableId(type = IdType.ID_WORKER)//mp自带，生成19位值，字数类型使用这种策略，比如long
@TableId(type = IdType.ID_WORKER_STR)//mp自带，生成19位值字符串类型使用这种策略
想要影响所有实体的配置，可以设置全局主键配置
其他主键策略：分析IdType源码
@Getter
public enum IdType {
/**
* AUTO数据库ID自增MP自带
*/
AUTO(0),
/**
* NONE该类型为未设置主键类型
*/
NONE(1),
/**
* INPUT用户输入ID
* 该类型可以通过自己注册自动填充插件进行填充
*/
INPUT(2),
/*ID_WORKER 以下3种类型、只有当插入对象ID 为空，才自动填充。 */MP自带
/**
* 全局唯一ID (idWorker)
*/
ID_WORKER(3),
/**
* UUID全局唯一ID (UUID)
*/
UUID(4),
/**
* ID_WORKER_STR字符串全局唯一ID (idWorker 的字符串表示)MP自带
*/
ID_WORKER_STR(5);
private int key;
IdType(int key) {
this.key = key;
}
}
4.2 update
1、根据Id更新操作
**注意：**update时生成的sql自动是动态sql：UPDATE user SET age=? WHERE id=?
@Test
public void testUpdateById(){
User user = new User();
user.setId(1L);
user.setAge(28);
int result = userMapper.updateById(user);
System.out.println(result);
}
2、自动填充
什么是自动填充？
像创建时间，修改时间可以自动添加进入到数据库
- 在实体类添加自动添加的注解
@TableField(fill = FieldFill.INSERT)//当添加时，里边有值
private Date createTime;
@TableField(fill = FieldFill.INSERT_UPDATE)//添加或者修改时，都插入
private Date updateTime;
- 创建类，实现固定的接口
package com.atguigu.handler;
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;
import java.util.Date;
@Component//提交给spring容器进行管理
public class MyMetaObjectHandler implements MetaObjectHandler {
//使用mp实现添加操作，这个方法就会执行
@Override
public void insertFill(MetaObject metaObject) {
this.setFieldValByName("createTime",new Date(),metaObject);//metaObject,元素据对象
this.setFieldValByName("updateTime",new Date(),metaObject);//metaObject,元素据对象
}
// 修改操作，执行这个方法
@Override
public void updateFill(MetaObject metaObject) {
this.setFieldValByName("updateTime",new Date(),metaObject);//metaObject,元素据对象
}
}
3、乐观锁
什么时乐观锁？
针对特定问题的解决方案
主要解决丢失更新问题，数据库中写的问题，并发情况下会产生；
多个人同时修改一条记录，最后提交的会把之前提交的数据覆盖
解决方案：
1.悲观锁 一个人操作数据的时候其他人都不能够操作该数据-----串行，只能一个人操作
2.乐观锁：在表中添加字段version版本号；谁先修改数据后提交版本号+1，后来的再想修改版本号不一致后并不能再进行修改
例子：买票，只剩一张后，多人抢，一人抢到之后其他人不能再购买
实操
- 表中添加字段version
- 实体类添加对应属性,在对应实体类的属性上添加注解
@Version
@TableField(fill = FieldFill.INSERT)
private Integer version;
//给字段设置自动插入
this.setFieldValByName("version",1,metaObject);//metaObject,元素据对象
- 配置乐观锁插件
package com.atguigu.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;
@Configuration
@MapperScan("com.atguigu.mapper")//去扫描mapper,找到接口然后进行实现类去实现
public class MpConfig {
/**
* 乐观锁插件
*/
@Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor() {
return new OptimisticLockerInterceptor();
}
}
- 乐观锁测试成功，version会+1
//乐观锁测试
@Test
public void testOptimisticLocker(){
//先查再改
//查询，会查出来version为1，才在该版版本上往上加
User user = userMapper.selectById(1567349053740580866L);
//修改
user.setAge(200);
userMapper.updateById(user);
}
- 乐观锁测试失败
/**
* 测试乐观锁插件 失败
*/
@Test
public void testOptimisticLockerFail() {
//查询
User user = userMapper.selectById(1L);
//修改数据
user.setName("Helen Yao1");
user.setEmail("helen@qq.com1");
//模拟取出数据后，数据库中version实际数据比取出的值大，即已被其它线程修改并更新了version
user.setVersion(user.getVersion() - 1);
//执行更新
userMapper.updateById(user);
}
参考sql语句，它是根据version版本与id进行修改，所以一旦版本不一致就不会进行修改
UPDATE user SET name=?, age=?, email=?, create_time=?, update_time=?, version=? WHERE id=? AND version=?
4.3 select
根据id查询
@Test
public void testSelectById(){
User user = userMapper.selectById(1L);
System.out.println(user);
}
通过多个id批量查询
@Test
public void testSelectBatchIds(){
List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
users.forEach(System.out::println);
}
简单的条件查询
@Test
public void testSelectByMap(){
HashMap<String, Object> map = new HashMap<>();
map.put("name", "Helen");
map.put("age", 18);
List<User> users = userMapper.selectByMap(map);
users.forEach(System.out::println);
}
分页查询
Mp自带的分页插件
- 配置分页插件
/**
* 分页插件
*/
@Bean
public PaginationInterceptor paginationInterceptor() {
return new PaginationInterceptor();
}
- 编写分页代码
//分页插件
@Test
public void testPage(){
//1 创建page对象
//传入两个参数 ： 当前页 和 每页相显示记录数
Page<User> page = new Page<>(1,3);
//调用mp分页查询的方法
//调用mp分页查询过程中，底层封装
//把分页所有数据封装到page对象里面
userMapper.selectPage(page,null);
//通过page对象获取分页数据
System.out.println(page.getCurrent());//当前页
System.out.println(page.getPages());//总页数
System.out.println(page.getSize());//每页显示的记录数
System.out.println(page.getTotal());//总记录数
System.out.println(page.hasNext());//下一页是否存在，存在则true
System.out.println(page.hasPrevious());//上一页是否存在，否则false
}
4.4 delete
根据id删除（物理删除）
@Test
public void testDeleteById(){
int result = userMapper.deleteById(8L);
System.out.println(result);
}
批量删除
@Test
public void testDeleteBatchIds() {
int result = userMapper.deleteBatchIds(Arrays.asList(8, 9, 10));
System.out.println(result);
}
简单的条件删除
@Test
public void testDeleteByMap() {
HashMap<String, Object> map = new HashMap<>();
map.put("name", "Helen");
map.put("age", 18);
int result = userMapper.deleteByMap(map);
System.out.println(result);
}
逻辑删除
物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除数据逻辑删除：假删除，将对应数据中代表是否被删除字段状态修改为“被删除状态”，之后在数据库中仍旧能看到此条数据记录- 数据还存在，但是查询时查不出来，需要在数据库中添加一个字段作为标志位
实例
1.添加表字段作为标志位
2.在类中添加对应的属性与注解
@TableLogic
private Integer deleted;
3.向配置中添注册Bean
//逻辑删除插件
@Bean
public ISqlInjector sqlInjector() {
return new LogicSqlInjector();
}
4.5 性能分析
性能分析拦截器，用于输出每条 SQL 语句及其执行时间
SQL 性能执行分析,开发环境使用，超过指定时间，停止运行。有助于发现问题
- 参数说明
参数：maxTime： SQL 执行最大时长，超过自动停止运行，有助于发现问题。
参数：format： SQL是否格式化，默认false。 - 在配置类中添加配置
/**
* SQL 执行性能分析插件
* 开发环境使用，线上不推荐。 maxTime 指的是 sql 最大执行时长
* dev :开发环境
* test：测试环境
* prod ：生产环境 项目已经部署好，所有人都能够用
*/
@Bean
@Profile({"dev","test"})// 设置 dev test 环境开启 在什么环境下起作用？
public PerformanceInterceptor performanceInterceptor() {
PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
performanceInterceptor.setMaxTime(200);//ms，超过此处设置的ms则sql不执行
performanceInterceptor.setFormat(true);
return performanceInterceptor;
}
- 在springboot中添加环境
#环境设置：dev、test、prod
spring.profiles.active=dev
可以针对各环境新建不同的配置文件application-dev.properties、application-test.properties、application-prod.properties
五、MyBatisPlus条件构造器
5.1 Wapper介绍
Wrapper ： 条件构造抽象类，最顶端父类
AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件
QueryWrapper ： Entity 对象封装操作类，不是用lambda语法
UpdateWrapper ： Update 条件封装，用于Entity对象更新操作
AbstractLambdaWrapper ： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。
LambdaQueryWrapper ：看名称也能明白就是用于Lambda语法使用的查询Wrapper
LambdaUpdateWrapper ： Lambda 更新封装Wrapper
5.2 AbstractWrapper
注意：以下条件构造器的方法入参中的 column 均表示数据库字段
5.2.1 ge、gt、le、lt、isNull、isNotNull
@Test
public void testDelete() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper
.isNull("name")
.ge("age", 12)
.isNotNull("email");
int result = userMapper.delete(queryWrapper);
System.out.println("delete return count = " + result);
}
sql语句：
SQL：UPDATE user SET deleted=1 WHERE deleted=0 AND name IS NULL AND age >= ? AND email IS NOT NULL
5.2.2 eq、ne（等于、不等于）
注意：seletOne返回的是一条实体记录，当出现多条时会报错
@Test
public void testSelectOne() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "Tom");
User user = userMapper.selectOne(queryWrapper);
System.out.println(user);
}
SQL语句：SELECT id,name,age,email,create_time,update_time,deleted,version FROM user WHERE deleted=0 AND name = ?
5.2.3 between、notBetween (包含大小边界)
@Test
public void testSelectCount() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.between("age", 20, 30);
Integer count = userMapper.selectCount(queryWrapper);
System.out.println(count);
}
SQL语句：SELECT COUNT(1) FROM user WHERE deleted=0 AND age BETWEEN ? AND ?
5.2.4 allEq
@Test
public void testSelectList() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
Map<String, Object> map = new HashMap<>();
map.put("id", 2);
map.put("name", "Jack");
map.put("age", 20);
queryWrapper.allEq(map);
List<User> users = userMapper.selectList(queryWrapper);
users.forEach(System.out::println);
}
SQL语句：SELECT id,name,age,email,create_time,update_time,deleted,version
FROM user WHERE deleted=0 AND name = ? AND id = ? AND age = ?
5.2.5 like、notLike、likeLeft、likeRight
selectMaps返回Map集合列表
@Test
public void testSelectMaps() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper
.notLike("name", "e")
.likeRight("email", "t");
List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);//返回值是Map列表
maps.forEach(System.out::println);
}
SQL语句：SELECT id,name,age,email,create_time,update_time,deleted,version
FROM user WHERE deleted=0 AND name NOT LIKE ? AND email LIKE ?
5.2.6 in、notIn、inSql、notinSql、exists、notExists
in、notIn：
- notIn(“age”,{1,2,3})—>age not in (1,2,3)
- notIn(“age”, 1, 2, 3)—>age not in (1,2,3)
inSql、notinSql：可以实现子查询
- 例: inSql(“age”, “1,2,3,4,5,6”)—>age in (1,2,3,4,5,6)
- 例: inSql(“id”, “select id from table where id < 3”)—>id in (select id from table where id < 3)
@Test
public void testSelectObjs() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//queryWrapper.in("id", 1, 2, 3);
queryWrapper.inSql("id", "select id from user where id < 3");
List<Object> objects = userMapper.selectObjs(queryWrapper);//返回值是Object列表
objects.forEach(System.out::println);
}
SQL语句：SELECT id,name,age,email,create_time,update_time,deleted,version
FROM user WHERE deleted=0 AND id IN (select id from user where id < 3)
5.2.7 or、and
注意：这里使用的是 UpdateWrapper 不调用or则默认为使用 and 连
@Test
public void testUpdate1() {
//修改值
User user = new User();
user.setAge(99);
user.setName("Andy");
//修改条件
UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
userUpdateWrapper
.like("name", "h")
.or()
.between("age", 20, 30);
int result = userMapper.update(user, userUpdateWrapper);
System.out.println(result);
}
SQL语句：UPDATE user SET name=?, age=?, update_time=? WHERE deleted=0 AND name LIKE ? OR age BETWEEN ? AND ?
5.2.8 嵌套or、嵌套and
这里使用了lambda表达式，or中的表达式最后翻译成sql时会被加上圆括号
@Test
public void testUpdate2() {
//修改值
User user = new User();
user.setAge(99);
user.setName("Andy");
//修改条件
UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
userUpdateWrapper
.like("name", "h")
.or(i -> i.eq("name", "李白").ne("age", 20));
int result = userMapper.update(user, userUpdateWrapper);
System.out.println(result);
}
SQL语句：
UPDATE user SET name=?, age=?, update_time=?
WHERE deleted=0 AND name LIKE ?
OR ( name = ? AND age <> ? )
5.2.9 orderBy、orderByDesc、orderByAsc
@Test
public void testSelectListOrderBy() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByDesc("id");
List<User> users = userMapper.selectList(queryWrapper);
users.forEach(System.out::println);
}
SQL语句：SELECT id,name,age,email,create_time,update_time,deleted,version
FROM user WHERE deleted=0 ORDER BY id DESC
5.2.10 last
直接拼接到 sql 的最后
注意：只能调用一次,多次调用以最后一次为准 有sql注入的风险,请谨慎使用
@Test
public void testSelectListLast() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.last("limit 1");
List<User> users = userMapper.selectList(queryWrapper);
users.forEach(System.out::println);
}
SQL语句:SELECT id,name,age,email,create_time,update_time,deleted,version
FROM user WHERE deleted=0limit 1
5.2.11 指定要查询的列
@Test
public void testSelectListColumn() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("id", "name", "age");
List<User> users = userMapper.selectList(queryWrapper);
users.forEach(System.out::println);
}
SQL语句:SELECT id,name,age FROM user WHERE deleted=0
5.2.12 set、setSql
@Test
public void testUpdateSet() {
//修改值
User user = new User();
user.setAge(99);
//修改条件
UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
userUpdateWrapper
.like("name", "h")
.set("name", "老李头")//除了可以查询还可以使用set设置修改的字段
.setSql(" email = '123@qq.com'");//可以有子查询
int result = userMapper.update(user, userUpdateWrapper);
}
SQL语句：UPDATE user SET age=?, update_time=?, name=?, email = ‘123@qq.com’ WHERE deleted=0 AND name LIKE ?
433
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
