springboot整合Mybatis-Plus框架，步骤详细 适合小白
一、看官方文档不要偷懒
导入依赖：
依赖的配置
研究代码
二、创建一个数据库
create database mybatis_plus;
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)
);
--真实开发中，version（乐观锁）、deleted（逻辑删除）、gmt_create、gmt_modified
DELETE FROM user;
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]');
三、初始化项目
构建一个springboot项目 ，添加一个mysql驱动依赖。
四、导入batisplus依赖
从官网复制
<dependency>
<groupId>com.baomidougroupId>
<artifactId>mybatis-plus-starterartifactId>
<version>3.0.5version>
dependency>
添加lombok依赖
五、依赖的配置文件
# mysql 5 驱动不同 com.mysql.jdbc.Driver
# mysql 8 驱动不同com.mysql.cj.jdbc.Driver、需要增加时区的配置 serverTimezone=GMT%2B8
#spring.datasource.driver-class-name 是配置驱动的
# 应用名称
spring.application.name=mybaits_plus
# 应用服务 WEB 访问端口
server.port=8080
# spring 静态资源扫描路径
spring.resources.static_locations=classpath:/static/
spring.datasource.username=root
spring.datasource.password=root
#jdbc:mysql://端口号/数据库名称?是否使用安全连接=否&指定字符编码&时区 这是8版本的
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useSSL=FALSE&useUnicode=true&charcterEncoding=utf-8&serverTimezone=GMT%2B8
#mysql驱动
# mysql 5 驱动不同 com.mysql.jdbc.Driver # mysql
# 8 驱动不同com.mysql.cj.jdbc.Driver、需要增加时区的配置 serverTimezone=GMT%2B8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
六、mapper层创建
在mybatis中创建还需要配置xml文件，
但是在plus中只需要在对应的mapper层上继承一个基本的类BaseMapper并约定需要操作的数据库对应的类的泛型即可。
//操作数据库对应的User 类
@Mapper
public interface UserMapper extends BaseMapper<User> {
// 所有的CRUD操作都已经编写完成了
// 你不需要像以前的配置一大堆文件了！
}
七、在启动类里加上扫描路径
@MapperScan(“com.liql.mapper”) 里面是mapper包的路径
加这个注解可以扫描我们的mapper文件夹。
@SpringBootApplication
@MapperScan("com.liql.mapper")
public class MybaitsPlusApplication {
public static void main(String[] args) {
SpringApplication.run(MybaitsPlusApplication.class, args);
}
}
八、测试
在test的测试类里class MybaitsPlusApplicationTests （创建好项目就自动生成的类）编写测试代码
package com.liql;
import com.liql.mapper.UserMapper;
import com.liql.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.sql.SQLOutput;
import java.util.List;
@SpringBootTest
class MybaitsPlusApplicationTests {
@Autowired
private UserMapper userMapper;
@Test
void contextLoads() {
//查询全部用户
//queryWrapper条件是一个 条件构造器 ，这里先不用
List<User> list=userMapper.selectList(null);
//遍历list
list.forEach(System.out::println);
}
}
八、配置日志
使用默认的控制台输入日志，不需要导依赖。
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
九、测试插入
@Test
void insert(){
User user=new User();
user.setAge(10);
user.setName("liql");
user.setEmail("[email protected]");
//引入插入成功会返回一个int类型
int result=userMapper.insert(user); //我们没写id 但是plus帮我们自动生成了id
System.out.println("result:"+result);
System.out.println(user);//id会自动回填到user对象中
}
十、主键生成策略
默认 ID_WORKER 全局唯一id
众多主键生成策略请百度。
雪花算法：
snowflflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为 毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味
着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。可以保证几乎全球唯 一！
十一、配置主键自增
在字段类上添加注解 @TableId(type = IdType.AUTO)
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
@TableId(type = IdType.AUTO)//主键自增 前提是表里已经设置自增
//Ctrl 点击IdType 可以查看主键策略
private Long id;
private String name;
private Integer age;
private String email;
}
// 给已经有主键的表添加自增的sql
// alter table 表名 modify id int auto_increment;
IdType源码
public enum IdType {
AUTO(0), // 数据库id自增
NONE(1), // 未设置主键
INPUT(2), // 手动输入 就需要自己写id
ID_WORKER(3), // 默认的全局唯一id
UUID(4), // 全局唯一id uuid
ID_WORKER_STR(5); //ID_WORKER 字符串表示法
}
十二、更新操作
```java
```java`在这里插入代码片
//测试更新
@Test
void update(){
User user =new User();
user.setId(4L);
user.setEmail("猜猜我是谁@qq.com");
user.setName("猪猪侠");
user.setAge(18);
int result=userMapper.updateById(user);
System.out.println(result);
}
十三、时间自动填充
方式1、数据库级别操作，
但是工作中一般不允许操作数据库
给已有的表增加时间字段
alter table 表名 add column 时间字段名 datetime default now();
alter table user add column create_time datetime default now();
alter table user add column update_time datetime default now();
实体类同步
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
Ctrl 点击IdType 可以查看主键策略
@TableId(type = IdType.AUTO)
alter table 表名 modify id int auto_increment;
private Long id;
private String name;
private Integer age;
private String email;
private Date create_time;
private Date update_time;
}
方式2、代码级别
1、删除数据库的默认值、更新操作！
2、在实体类相关字段添加注解
@TableField(fill= FieldFill.INSERT)//插入的时候自动填充
private Date create_time;
@TableField(fill=FieldFill.INSERT_UPDATE)//更新的时候自动填充
private Date update_time;
3、编写处理器来处理这个注解即可！
定义一个 MyMetaObjectHandler 实现类 实现 MetaObjectHandler 接口 并重写里面的方法。
添加componet注解 把这个类纳入到spring容器中
Batistaplus官网也有自动填充。
package com.liql.pojo;
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 updata fill...");
this.setFieldValByName("update_time",new Date(),metaObject);
}
}
4、观察插入，更新的时间变化。
十四、乐观锁插件
乐观锁 : 故名思意分乐观，它总是认为不会出现问题，无论干什么不去上锁！如果出现了问题，
再次更新值测试
悲观锁：故名思意十分悲观，它总是认为总是出现问题，无论干什么都会上锁！再去操作！
我们这里主要讲解 乐观锁机制！
乐观锁实现方式：
取出记录时，获取当前 version
更新时，带上这个version
执行更新时， set version =newVersion where version =oldVersion
如果version不对，就更新失败
乐观锁：
1、先查询，获得版本号 version = 1
-- A
update user set name = "liql",
version = version + 1 where id = 2 and version = 1
-- B 线程抢先完成，这个时候 version = 2，会导致 A 修改失败！
update user set name = "liql", version = version + 1 where id = 2 and version = 1
2、测试MP的乐观锁插件
2.1给数据库的user表增加一个version字段
alter table user add column version int default 1;
2.2 在user类中的version字段加一个MP的乐观锁注解@Version
@Version //这是MP的一个乐观锁的注解
private Integer version;
2.3注册组件
插件一个config包，用来放配置类
插件 MybatisPlusConfig 类，且要在类上加 一个 @Configuration 注解
再加一个事务类注解@EnableTransactionManagement
这个时候 就可以把主启动类的扫描注解@ScanMapper 注解写在配置类上 ，看个人习惯。
package com.liql.config;
import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@Configuration //配置类注解
@EnableTransactionManagement //开启事务类注解 用来管理事务
public class MybatisPlusConfig {
//从MP官网上直接拿过来的组件代码 Interceptor是个拦截器
@Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor() {
return new OptimisticLockerInterceptor();
}
}
到此，组件配置完成 下面进行测试。
2.4测试乐观锁
//测试乐观锁成功的案例
@Test
public void testOptimisticLocker(){
// 1、查询用户信息
User user = userMapper.selectById(1L);
// 2、修改用户信息
user.setName("kuangshen");
user.setEmail("[email protected]");
// 3、执行更新操作
userMapper.updateById(user);
}
// 测试乐观锁失败！多线程下
@Test
public void testOptimisticLocker2(){
// 线程 1
User user = userMapper.selectById(1L);
user.setName("kuangshen111");
user.setEmail("[email protected]");
// 模拟另外一个线程执行了插队操作
User user2 = userMapper.selectById(1L);
user2.setName("kuangshen222");
user2.setEmail("[email protected]");
userMapper.updateById(user2);
// 自旋锁来多次尝试提交！ 因为这个先查的 version=1 ，但是上面的已经修改
//了version ，变成了2 所以这个更新被user2插队了
userMapper.updateById(user);//如果没有乐观锁就会覆盖插队线程的值！
}
}
十五、查询操作 非构造器方式
//测试查询单个
@Test
public void testselectbyid(){
User user=userMapper.selectById(1l);
System.out.println(user);
}
//测试查询多个
@Test
public void testseletbybatchid(){
List<User> list=userMapper.selectBatchIds(Arrays.asList(1,2,3));
list.forEach(System.out::println);
}
//条件查询1 map
@Test
public void testmap(){
HashMap<String ,Object> map=new HashMap<>();
map.put("name", "liql");
map.put("age", 18);
List<User> list =userMapper.selectByMap(map);
list.forEach(System.out::println);
}
十六、分页插件
1、原始的 limit 进行分页
2、pageHelper 第三方插件
3、MP 其实也内置了分页插件！
4、配置MP自带的分页插件，在配置类（拦截器）中配置，官网中有代码 直接用
//MP分页插件
@Bean
public PaginationInterceptor paginationInterceptor() {
PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
// 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求 默认false
// paginationInterceptor.setOverflow(false);
// 设置最大单页限制数量，默认 500 条，-1 不受限制
// paginationInterceptor.setLimit(500);
// 开启 count 的 join 优化,只针对部分 left join
paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true));
return paginationInterceptor;
}
配置完成后在实例类直接使用内置的page对象
//测试分页查询
@Test
public void testpage(){
// 参数一：当前页 1 ,和前端联动是直接让前端传一个参数给参数一
// 参数二：页面大小 5
// 使用了分页插件之后，所有的分页操作也变得简单的！
Page<User> page = new Page<>(1,5);
userMapper.selectPage(page,null);
page.getRecords().forEach(System.out::println);
System.out.println(page.getTotal());
}
十七、删除操作
1、根据id删除
@Test
public void testDeleteById(){
userMapper.deleteById(1240620674645544965L);
}
// 通过id批量删除
@Test public void testDeleteBatchId(){ userMapper.deleteBatchIds(Arrays.asList(1240620674645544961L,124062067464554496 2L));
}
// 通过map删除
@Test public void testDeleteMap(){
HashMap<String, Object> map = new HashMap<>(); map.put("name","狂神说Java"); userMapper.deleteByMap(map);
}
十八、逻辑删除
物理删除 ：从数据库中直接移除
逻辑删除 ：再数据库中没有被移除，而是通过一个变量来让他失效！ deleted = 0 => deleted = 1
管理员可以查看被逻辑删除的记录！防止数据的丢失，类似于回收站！
在数据库中增加一个逻辑删除字段 deleted 并配上逻辑删除注解Tablelogic
@TableLogic //逻辑删除
private Integer deleted;
1、配置类中配置逻辑删除 官网拷贝
//配置逻辑删除组件 新版本不用配置
/* @Bean public ISqlInjector sqlInjector() {
return new LogicSqlInjector();
}*/
2、再在yml文件中配置逻辑删除 ,官网最新不是这个
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0
3、测试逻辑删除
原先的删除操作 都变成了逻辑删除、走的是更新操作，并不是删除，记录依旧在数据库，但值已经变化了。
查询的时候回自动过滤杯逻辑删除的数据。
二十、条件构造器
构造器种类繁多 可参考官网学习
步骤： 先new一个 queerywrapper， 然后给wrapper设置条件 ，可以和map类比一下
springboot自定义测试类的时候需要在雷伤加 @SpringBootTest 注解
package com.liql;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
/* 这个类专门用来测试条件构造器*/
@SpringBootTest
public class WrapperTest {
@Autowired
private UserMapper userMapper;
@Test
void contextLoads(){
}
}
@Test
void contextLoads() {
// 查询name不为空的用户，并且邮箱不为空的用户，年龄大于等于12 QueryWrapper wrapper = new QueryWrapper<>(); wrapper.isNotNull("name") .isNotNull("email") .ge("age",12); userMapper.selectList(wrapper).forEach(System.out::println);
// map对比一下
}
@Test
void test2(){
// 查询名字狂神说
QueryWrapper<User> wrapper = new QueryWrapper<>(); wrapper.eq("name","狂神说");
User user = userMapper.selectOne(wrapper);
// 查询一个数据，出现多个结果使用List 或者 Map System.out.println(user);
}
@Test
void test3(){
// 查询年龄在 20 ~ 30 岁之间的用户
QueryWrapper<User> wrapper = new QueryWrapper<>(); wrapper.between("age",20,30); // 区间
Integer count =userMapper.selectCount(wrapper);
// 查询结果数
System.out.println(count);}
// 模糊查询
@Test
void test4(){ // 查询年龄在 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);
}
// 子查询
@Test void test5(){
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); }
//测试六 排序
@Test
void test6(){
QueryWrapper<User> wrapper = new Qu
eryWrapper<>();
// 通过id进行排序
wrapper.orderByAsc("id"); List<User> users = userMapper.selectList(wrapper); users.forEach(System.out::println);
}