Mybatis-Plus- CRUD接口-主键策略-自动填充和乐观锁-分页-逻辑删除-条件构造器和常用接口-阿里云开发者社区

一、插入操作

添加测试类，进行功能测试：

@SpringBootTest
public class CRUDTests {  

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testInsert(){

        User user = new User();
        user.setName("Helen");
        user.setAge(18);
        user.setEmail("1941310246@qq.com");

        int result = userMapper.insert(user);
        System.out.println("影响的行数：" + result); //影响的行数
        System.out.println("id：" + user); //id自动回填
    }

}

运行添加成功

注意：数据库插入id值默认为：全局唯一id

二、数据库分库分表策略

背景

随着业务规模的不断扩大，需要选择合适的方案去应对数据规模的增长，以应对逐渐增长的访问压力和数据量。
数据库的扩展方式主要包括：

1. 业务分库
2. 主从复制
3. 数据库分表。

1、业务分库

业务分库指的是按照业务模块将数据分散到不同的数据库服务器。

例如，一个简单的电商网站，包括用户、商品、订单三个业务模块，我们可以将用户数据、商品数据、订单数据分开放到三台不同的数据库服务器上，而不是将所有数据都放在一台数据库服务器上。这样的就变成了3个数据库同时承担压力，系统的吞吐量自然就提高了。

虽然业务分库能够分散存储和访问压力，但同时也带来了新的问题，接下来我进行详细分析。

join 操作问题

业务分库后，原本在同一个数据库中的表分散到不同数据库中，导致无法使用 SQL 的 join 查询。

事务问题

原本在同一个数据库中不同的表可以在同一个事务中修改，业务分库后，表分散到不同的数据库中，无法通过事务统一修改。

成本问题

业务分库同时也带来了成本的代价，本来 1 台服务器搞定的事情，现在要 3 台，如果考虑备份，那就是 2 台变成了 6 台。

2、主从复制和读写分离

读写分离的基本原理是将数据库读写操作分散到不同的节点上。读写分离的基本实现是：

数据库服务器搭建主从集群，一主一从、一主多从都可以。
数据库主机负责读写操作，从机只负责读操作。

数据库主机通过复制将数据同步到从机，每台数据库服务器都存储了所有的业务数据。
业务服务器将写操作发给数据库主机，将读操作发给数据库从机。

3、数据库分表

将不同业务数据分散存储到不同的数据库服务器，能够支撑百万甚至千万用户规模的业务，但如果业务继续发展，同一业务的单表数据也会达到单台数据库服务器的处理瓶颈。

例如，淘宝的几亿用户数据，如果全部存放在一台数据库服务器的一张表中，肯定是无法满足性能要求的，此时就需要对单表数据进行拆分。

单表数据拆分有两种方式：垂直分表和水平分表。示意图如下：

垂直分表：将表中某些不常用占用空间的列拆分出去
水平分表：水平分表适合表行数特别大的表

4.雪花算法：分布式ID生成器

雪花算法：

主键生成算法，它能够保证不同表的主键的不重复性，以及相同表的主键的有序性。
整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞，并且效率较高。

三、MP的主键策略

1、ASSIGN_ID

MyBatis-Plus默认的主键策略是：ASSIGN_ID （使用了雪花算法）

在实体字段中配置

2、AUTO 自增策略

1.需要在创建数据表的时候设置主键自增

2.实体字段中配置 @TableId(type = IdType.AUTO)

要想影响所有实体的配置，可以设置全局主键配置

在properties文件中添加

#全局设置主键生成策略
#mybatis-plus.global-config.db-config.id-type=auto

四、更新操作

注意：update时生成的sql自动是动态sql：

UPDATE user SET age=? WHERE id=?

在CRUDTests测试类中添加testUpdateById方法

@Test
public void testUpdateById(){  

    User user = new User();
    user.setId(1427258609506459650L);//要更改的id
        user.setAge(28);
        user.setName("Annie");
    int result = userMapper.updateById(user);
    System.out.println("影响的行数：" + result);
}

运行测试成功

一、自动填充

需求描述：

项目中经常会遇到一些数据，每次都使用相同的方式填充，例如记录的

创建时间，更新时间等。

我们可以使用MyBatis Plus的自动填充功能，完成这些字段的赋值工作

1、数据库修改

在User表中添加datetime类型的新的字段 create_time、update_time

2、实体类修改

实体上增加字段并添加自动填充注解

@Data
public class User {
    ......
        
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;

    //@TableField(fill = FieldFill.UPDATE)
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;
}

3、实现元对象处理器接口

注意：不要忘记添加 @Component 注解

package com.atguigu.mybatisplus.handler;

@Slf4j
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill ....");
        this.setFieldValByName("createTime", new Date(), metaObject);
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }

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

4、测试

运行之前的testInsert、testUpdateById添加和修改方法

结果：

创建时间与修改时间自动填充

五、乐观锁

1.场景

并发：当前用户和其他用户一起操作

没有做好并发控制，就可能导致脏读、幻读和不可重复读等问题。

实现并发控制的主要手段分为乐观并发控制和悲观并发控制两种。

2.乐观锁与悲观锁

乐观锁：
-在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果冲突，则返回给用户异常信息，让用户决定如何去做。乐观锁适用于读多写少的场景，这样可以提高程序的吞吐量。
悲观锁:

-对该数据进行加锁以防止并发
-改数据之前先锁定，再修改的方式被称之为悲观并发控制

3、模拟修改冲突

（1）数据库中增加商品表

CREATE TABLE product
(
  id BIGINT(20) NOT NULL COMMENT '主键ID',
  name VARCHAR(30) NULL DEFAULT NULL COMMENT '商品名称',
  price INT(11) DEFAULT 0 COMMENT '价格',
  version INT(11) DEFAULT 0 COMMENT '乐观锁版本号',
    PRIMARY KEY (id)
);

（2）添加数据

INSERT INTO product (id, NAME, price) VALUES (1, '冰箱', 100);

（3）创建实体类

package com.atguigu.mybatis_plus.entity;
@Data
public class Product {
    private Long id;
    private String name;
    private Integer price;
    private Integer version;
}

（4）Mapper

package com.atguigu.mybatis_plus.mapper;
@Repository
public interface ProductMapper extends BaseMapper<Product> {
    
}

（5）测试

@Autowired
private ProductMapper productMapper;

@Test
public void testConcurrentUpdate() {

    //1、小李
    Product p1 = productMapper.selectById(1L);
    System.out.println("小李取出的价格：" + p1.getPrice());

    //2、小王
    Product p2 = productMapper.selectById(1L);
    System.out.println("小王取出的价格：" + p2.getPrice());

    //3、小李将价格加了50元，存入了数据库
    p1.setPrice(p1.getPrice() + 50);
    productMapper.updateById(p1);

    //4、小王将商品减了30元，存入了数据库
    p2.setPrice(p2.getPrice() - 30);
    int result = productMapper.updateById(p2);
    if(result == 0){//更新失败，重试
        //重新获取数据
        p2 = productMapper.selectById(1L);
        //更新
        p2.setPrice(p2.getPrice() - 30);
        productMapper.updateById(p2);
    }

    //最后的结果
    Product p3 = productMapper.selectById(1L);
    System.out.println("最后的结果：" + p3.getPrice());
}

原价100 同时取到值100元小李加入50元这时数据库数据为150 小王减去30元失败

重新获取数据为150元这时在减去30元为120元

两人同时对数据操作导致数据出现错误

4、解决方案

数据库中添加version字段
取出记录时，获取当前version

SELECT id,`name`,price,`version` FROM product WHERE id=1

更新时，version + 1，如果where语句中的version版本不对，则更新失败

UPDATE product SET price=price+50, `version`=`version` + 1 WHERE id=1 AND `version`=1

接下来介绍如何在Mybatis-Plus项目中，使用乐观锁：

5、乐观锁实现流程

（1）修改实体类

在实体类添加 @Version 注解

     @Version
     private Integer version;

（2）创建配置文件

创建包config，创建文件MybatisPlusConfig.java

此时可以删除主类MybatisPlusApplication中的 @MapperScan 扫描注解

  
@EnableTransactionManagement//事务处理
@Configuration
@MapperScan("com.atguigu.mybatis_plus.mapper")
public class MybatisPlusConfig {
    
}

（3）注册乐观锁插件

在 MybatisPlusConfig 中注册 Bean

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

（4）测试

更改数据两次 version+2

六、查询

1、通过多个id批量查询

完成了动态sql的foreach的功能

@Test
public void testSelectBatchIds(){

    List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
    users.forEach(System.out::println);
}

查询结果:

2、简单的条件查询

通过map封装查询条件

注意：

map中的key对应数据库中的列名。如：数据库user_id，实体类是userId，这时map的key需要填写user_id

@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);
}

运行结果：

七、分页

1、分页插件

MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能

（1）添加分页插件

之前写的MyBatisPlusConfig配置类中添加@Bean配置

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

（2）测试selectPage分页

测试：最终通过page对象获取相关数据

@Test
public void testSelectPage() {

    Page<User> page = new Page<>(1,5);
    Page<User> pageParam = userMapper.selectPage(page, null);

    pageParam.getRecords().forEach(System.out::println);
    System.out.println(pageParam.getCurrent());
    System.out.println(pageParam.getPages());
    System.out.println(pageParam.getSize());
    System.out.println(pageParam.getTotal());
    System.out.println(pageParam.hasNext());
    System.out.println(pageParam.hasPrevious());
}

结果：这里只输出了第一页的数据

2、返回指定的列

当指定了特定的查询列时，希望分页结果列表只返回被查询的列，而不是很多null值

测试selectMapsPage分页：结果集是Map

@Test
public void testSelectMapsPage() {

    //返回很多null列
    //Page<User> page = new Page<>(1, 5);
    //QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //queryWrapper.select("name", "age");
    //Page<User> pageParam = userMapper.selectPage(page, queryWrapper);
    //
    //pageParam.getRecords().forEach(System.out::println);


    //Page不需要泛型
    Page<Map<String, Object>> page = new Page<>(1, 5);
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.select("name", "age");
    Page<Map<String, Object>> pageParam = userMapper.selectMapsPage(page, queryWrapper);

    List<Map<String, Object>> records = pageParam.getRecords();
    records.forEach(System.out::println);
    System.out.println(pageParam.getCurrent());
    System.out.println(pageParam.getPages());
    System.out.println(pageParam.getSize());
    System.out.println(pageParam.getTotal());
    System.out.println(pageParam.hasNext());
    System.out.println(pageParam.hasPrevious());
}

运行结果：输出特定查询列

七、删除

1、根据id删除记录

@Test
public void testDeleteById(){

    int result = userMapper.deleteById(1427270191766597638L);
    System.out.println(result);
}

2、批量删除

@Test
public void testDeleteBatchIds() {

    int result = userMapper.deleteBatchIds(Arrays.asList(8, 9, 10));
    System.out.println(result);
}

3、简单条件删除

@Test
public void testDeleteByMap() {

    HashMap<String, Object> map = new HashMap<>();
    map.put("name", "Annie");
    map.put("age", 28);

    int result = userMapper.deleteByMap(map);
    System.out.println(result);
}

八、逻辑删除

1、物理删除和逻辑删除

物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除数据
逻辑删除：假删除，将对应数据中代表是否被删除字段状态修改为“被删除状态”，之后在数据库中仍旧能看到此条数据记录

逻辑删除的使用场景：

可以进行数据恢复
有关联数据，不便删除

2、逻辑删除实现流程

（1）数据库修改

添加 deleted字段

ALTER TABLE `user` ADD COLUMN `deleted` boolean DEFAULT false

（2）实体类修改

添加deleted 字段，并加上 @TableLogic 注解

@TableLogic
private Integer deleted;

（3）配置（可选）

application.properties 加入以下配置，此为默认值，如果你的默认值和mp默认的一样,该配置可无

mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

application.yml

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: flag  # 全局逻辑删除的实体字段名(since 3.3.0,配置后可以忽略不配置步骤2)
      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

（4）测试

测试后发现，数据并没有被删除，deleted字段的值由0变成了1
测试后分析打印的sql语句，是一条update
注意：被删除前，数据的deleted 字段的值必须是 0，才能被选取出来执行逻辑删除的操作

@Test
public void testLogicDelete() {

    int result = userMapper.deleteById(1L);
    System.out.println(result);
}

（5）测试逻辑删除后的查询

MyBatis Plus中查询操作也会自动添加逻辑删除字段的判断

@Test
public void testLogicDeleteSelect() {
    
    List<User> users = userMapper.selectList(null);
    users.forEach(System.out::println);
}

sql：SELECT id,name,age,email,create_time,update_time,deleted FROM user WHERE deleted=0

这里查询deleted为0的也就是未删除的数据为1的数据为逻辑删除的数据不查询

Wapper

Wrapper即条件构造器，用来写一些复杂的sql语句。

1.eq 等于 = 、 ne不等于<> 、gt大于 > 、 ge大于等于 >= 、 lt 小于 < 、le小于等于 <=

eq 等于 =

例: eq(“name”, “老王”)—>name = ‘老王’

ne 不等于 <>

例: ne(“name”, “老王”)—>name <> ‘老王’

gt大于等于 >=

例: gt(“age”, 18)—>age > 18

ge 大于等于 >=

例: ge(“age”, 18)—>age >= 18

lt 小于 <

例: lt(“age”, 18)—>age < 18

le小于等于 <=

例: le(“age”, 18)—>age <= 18

@Test
public void testSelectOne() {

    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("name", "Tom");

    User user = userMapper.selectOne(queryWrapper);//只能返回一条记录，多余一条则抛出异常
    System.out.println(user);
}

2. between 、 notBetween、 like、 notLike、 likeLeft 、likeRight

BETWEEN 值1 AND 值2

例: between(“age”, 18, 30)—>age between 18 and 30

NOT BETWEEN 值1 AND 值2

例: notBetween(“age”, 18, 30)—>age not between 18 and 30

LIKE ‘%值%’

例: like(“name”, “王”)—>name like ‘%王%’

NOT LIKE ‘%值%’

例: notLike(“name”, “王”)—>name not like ‘%王%’

likeLeft LIKE ‘%值’

例: likeLeft(“name”, “王”)—>name like ‘%王’

likeRight LIKE ‘值%’

例: likeRight(“name”, “王”)—>name like ‘王%’

3.isNull isNotNull in notIn inSql notInSql groupBy orderByAsc

字段 IS NULL

例: isNull(“name”)—>name is null

字段 IS NOT NULL

例: isNotNull(“name”)—>name is not null

字段 IN (value.get(0), value.get(1), …)

例: in(“age”,{1,2,3})—>age in (1,2,3)

字段 NOT IN (value.get(0), value.get(1), …)

例: notIn(“age”,{1,2,3})—>age not in (1,2,3)

字段 NOT IN (v0, v1, …)

例: notIn(“age”, 1, 2, 3)—>age not in (1,2,3)

字段 IN ( sql语句 )

例: 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)

字段 NOT IN ( sql语句 )

例: notInSql(“age”, “1,2,3,4,5,6”)—>age not in (1,2,3,4,5,6) 例:

notInSql(“id”, “select id from table where id < 3”)—>id not in

(select id from table where id < 3)

分组：GROUP BY 字段, …

例: groupBy(“id”, “name”)—>group by id,name

排序：ORDER BY 字段, … ASC

例: orderByAsc(“id”, “name”)—>order by id ASC,name ASC

排序：ORDER BY 字段, … DESC

例: orderByDesc(“id”, “name”)—>order by id DESC,name DESC

排序：ORDER BY 字段, …

例: orderBy(true, true, “id”, “name”)—>order by id ASC,name ASC

HAVING ( sql语句 )

例: having(“sum(age) > 10”)—>having sum(age) > 10 例:
having(“sum(age) > {0}”, 11)—>having sum(age) > 11

拼接 OR

注意事项:

主动调用or表示紧接着下一个方法不是用and连接!(不调用or则默认为使用and连接)

例: eq(“id”,1).or().eq(“name”,“老王”)—>id = 1 or name = ‘老王’

AND 嵌套

例: and(i -> i.eq(“name”, “李白”).ne(“status”, “活着”))—>and (name =
‘李白’ and status <> ‘活着’)

链式调用 lambda 式

// 区分:
// 链式调用 普通
UpdateChainWrapper<T> update();
// 链式调用 lambda 式。注意：不支持 Kotlin 
LambdaUpdateChainWrapper<T> lambdaUpdate();

// 等价示例：
query().eq("id", value).one();
lambdaQuery().eq(Entity::getId, value).one();

// 等价示例：
update().eq("id", value).remove();
lambdaUpdate().eq(Entity::getId, value).remove();

总结

之前看的尚硅谷的在线教育项目学习视频记录顺便复习

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Mybatis-Plus- CRUD接口-主键策略-自动填充和乐观锁-分页-逻辑删除-条件构造器和常用接口

一、插入操作

二、数据库分库分表策略

背景

1、业务分库

2、主从复制和读写分离

3、数据库分表

4.雪花算法：分布式ID生成器

三、MP的主键策略

1、ASSIGN_ID

2、AUTO 自增策略

四、更新操作

一、自动填充

1、数据库修改

2、实体类修改

3、实现元对象处理器接口

4、测试

五、乐观锁

1.场景

2.乐观锁与悲观锁

3、模拟修改冲突

（1）数据库中增加商品表

（2）添加数据

（3）创建实体类

（4）Mapper

（5）测试

4、解决方案

5、乐观锁实现流程

（1）修改实体类

（2）创建配置文件

（3）注册乐观锁插件

（4）测试

六、查询

1、通过多个id批量查询

2、简单的条件查询

七、分页

1、分页插件

（1）添加分页插件

（2）测试selectPage分页

2、返回指定的列

七、删除

1、根据id删除记录

2、批量删除

3、简单条件删除

八、逻辑删除

1、物理删除和逻辑删除

2、逻辑删除实现流程

（1）数据库修改

（3）配置（可选）

（4）测试

（5）测试逻辑删除后的查询

Wapper

1.eq 等于 = 、 ne不等于<> 、gt大于 > 、 ge大于等于 >= 、 lt 小于 < 、le小于等于 <=

eq 等于 =

ne 不等于 <>

gt大于等于 >=

ge 大于等于 >=

lt 小于 <

le小于等于 <=

2. between 、 notBetween、 like、 notLike、 likeLeft 、likeRight

BETWEEN 值1 AND 值2

NOT BETWEEN 值1 AND 值2

LIKE ‘%值%’

NOT LIKE ‘%值%’

likeLeft LIKE ‘%值’

likeRight LIKE ‘值%’