MyBatisPlus 第二天

常用注解

1 @TableName:数据库表名和实体类名不同时,会出现以下报错

在实体类上添加 @TableName("t_user")

在开发的过程中，我们经常遇到以上的问题，即实体类所对应的表都有固定的前缀，例如t_或tbl_

此时，可以使用MyBatis-Plus提供的全局配置，为实体类所对应的表名设置默认的前缀，那么就 不需要在每个实体类上通过@TableName标识实体类对应的表

mybatis-plus:
    configuration:
# 配置MyBatis日志
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    global-config:
        db-config:
# 配置MyBatis-Plus操作表的默认前缀
            table-prefix: t_

2 @TableId:当你的数据库和表中表示主键的不是id 是其他字段名会出现报错

在你的主键上添加注解进行修改即可括号里面是数据库主键名

@TableId("t_id")
    private Long id;

雪花算法:

雪花算法是由Twitter公布的分布式主键生成算法，它能够保证不同表的主键的不重复性，以及相同表的主键的有序性。

①核心思想：

长度共64bit（一个long型）。

首先是一个符号位， 1bit标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0。

41bit时间截(毫秒级)，存储的是时间截的差值（当前时间截 - 开始时间截)，结果约等于69.73年。

10bit作为机器的ID（ 5个bit是数据中心， 5个bit的机器ID，可以部署在1024个节点）。

12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID）。

3 @TableField:实体类中的字段名和数据库中的字段名不一致

  @TableField("username")
    private String name;

4 @TableLogic :逻辑删除

物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除的数据

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

使用场景：可以进行数据恢复

需要在实体类中添加字段名 isdeleted(逻辑删除属性)

@TableName("t_user")
@Data //lombok注解  提供所有set get方法
@AllArgsConstructor  //有参构造器方法
@NoArgsConstructor  //无参构造器方法
public class User {

    @TableId("t_id")
    private Long id;
    @TableField("username")
    private String name;
    private Integer age;
    private String email;

    @TableLogic
    private Integer isdeleted;

}

此时你执行的删除操作实质上是修改

UPDATE t_user SET is_deleted=1 WHERE id=? AND is_deleted=0

此时的查询

SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0

如果你想要进行真正的删除，还有恢复信息都需要自己在mapper中实现

真实删除

  @Delete("DELETE FROM t_user WHERE isdeleted=1")
    void deleteUsersWithNullIsdeleted();

恢复信息

 @Update("update t_user set isdeleted=0 where t_id= #{t_id}")
    void updateisdeleted(Integer t_id);

分页方法

1）分页插件:Mybatis Plus自带分页插件

a 先添加配置类

@Configuration
@MapperScan("com.atguigu.mybatisplus.mapper")  //可以将主类中的注解移到此处
public class MybatisPlusConfig {

@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
interceptor.addInnerInterceptor(new
PaginationInnerInterceptor(DbType.MYSQL));
return interceptor;
}

}

b 测试

  @Test
    public void testPage(){
    //设置分页参数
        Page<User> page = new Page<>(1, 5);  //查询第一页 一页五个对象
        userMapper.selectPage(page, null);
    //获取分页数据
        List<User> list = page.getRecords();
        list.forEach(System.out::println);
        System.out.println("当前页："+page.getCurrent());
        System.out.println("每页显示的条数："+page.getSize());
        System.out.println("总记录数："+page.getTotal());
        System.out.println("总页数："+page.getPages());
        System.out.println("是否有上一页："+page.hasPrevious());
        System.out.println("是否有下一页："+page.hasNext());
    }

2）UserMapper中定义接口方法

UserMapper

Page<User> selectPageVo(@Param("page") Page<User> page, @Param("age") Integer age);

UserMapper.xml

<sql id="BaseColumns">t_id,username,age,email</sql>
        <!--IPage<User> selectPageVo(Page<User> page, Integer age);-->
<select id="selectPageVo" resultType="User">
SELECT <include refid="BaseColumns"></include> FROM t_user WHERE age > #{age}
</select>

测试

 @Test
    public void testSelectPageVo(){
    //设置分页参数
        Page<User> page = new Page<>(1, 5);
        userMapper.selectPageVo(page, 20);
    //获取分页数据
        List<User> list = page.getRecords();
        list.forEach(System.out::println);
        System.out.println("当前页："+page.getCurrent());
        System.out.println("每页显示的条数："+page.getSize());
        System.out.println("总记录数："+page.getTotal());
        System.out.println("总页数："+page.getPages());
        System.out.println("是否有上一页："+page.hasPrevious());
        System.out.println("是否有下一页："+page.hasNext());
    }

乐观锁与悲观锁:

乐观锁: 就是很乐观，每次去拿数据的时候都认为别人不会修改。所以不会上锁，但是如果想要更新数据，则会在更新前检查在读取至更新这段时间别人有没有修改过这个数据。如果修改过，则重新读取，再次尝试更新，循环上述步骤直到更新成功（当然也允许更新失败的线程放弃操作）,乐观锁适用于多读的应用类型，这样可以提高吞吐量

悲观锁: 悲观锁中的共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程

模拟冲突修改

故事背景:

一件商品，成本价是80元，售价是100元。老板先是通知小李，说你去把商品价格增加50元。小 李正在玩游戏，耽搁了一个小时。正好一个小时后，老板觉得商品价格增加到150元，价格太
高，可能会影响销量。又通知小王，你把商品价格降低30元。
此时，小李和小王同时操作商品后台系统。小李操作的时候，系统先取出商品价格100元；小王  也在操作，取出的商品价格也是100元。小李将价格加了50元，并将100+50=150元存入了数据  库；小王将商品减了30元，并将100-30=70元存入了数据库。是的，如果没有锁，小李的操作就 完全被小王的覆盖了。
现在商品价格是70元，比成本价低10元。几分钟后，这个商品很快出售了1千多件商品，老板亏1 万多。

建数据库

CREATE TABLE t_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)
);

INSERT INTO t_product (id, NAME, price) VALUES (1, '外星人笔记本 ', 100);

实体类

package com.atguigu.mybatisplus.entity;
import lombok.Data;

@Data
public class Product {
private Long id;
private String name;
private Integer price;
private Integer version;
}

Mapper层

public interface ProductMapper extends BaseMapper<Product> {
}

测试

@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());
        p1.setPrice(p1.getPrice() + 50);
        int result1 = productMapper.updateById(p1);
        System.out.println("小李修改结果：" + result1);

//4、小王将商品减了30元，存入了数据库
        p2.setPrice(p2.getPrice() - 30);
        int result2 = productMapper.updateById(p2);
        System.out.println("小王修改结果：" + result2);

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

使用乐观锁来解决这种冲突，要使用到数据库的version字段

select取出记录时

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

update更新时,如果version版本不对就更新失败

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

在原有基础上实体类中version上加入@Version

添加乐观锁插件

@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor(){
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
//添加分页插件
interceptor.addInnerInterceptor(new
PaginationInnerInterceptor(DbType.MYSQL));
//添加乐观锁插件
interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor()); return interceptor;
}

此时运行原先的测试类，就能够正确输出120

乐观锁测试项的优化版

@Test
public void testConcurrentVersionUpdate() {

//小李取数据
Product p1 = productMapper.selectById(1L);

//小王取数据
Product p2 = productMapper.selectById(1L);

//小李修改 + 50
p1.setPrice(p1.getPrice() + 50);
int result1 = productMapper.updateById(p1);
System.out.println("小李修改的结果：" + result1);

//小王修改 - 30
p2.setPrice(p2.getPrice() - 30);
int result2 = productMapper.updateById(p2);
System.out.println("小王修改的结果：" + result2);
if(result2 == 0){
//失败重试，重新获取version并更新
p2 = productMapper.selectById(1L);
p2.setPrice(p2.getPrice() - 30);
result2 = productMapper.updateById(p2);
}
System.out.println("小王修改重试的结果：" + result2);

//老板看价格
Product p3 = productMapper.selectById(1L);
System.out.println("老板看价格：" + p3.getPrice());
}