MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

• 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
• 损耗小：启动即会自动注入基本 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 操作智能分析阻断，也可自定义拦截规则，预防误操作

任何能使用 MyBatis 进行 CRUD, 并且支持标准 SQL 的数据库，具体支持情况如下，如果不在下列表查看分页部分教程 PR 您的支持。

• MySQL，Oracle，DB2，H2，HSQL，SQLite，PostgreSQL，SQLServer，Phoenix，Gauss ，ClickHouse，Sybase，OceanBase，Firebird，Cubrid，Goldilocks，csiidb，informix，TDengine，redshift
• 达梦数据库，虚谷数据库，人大金仓数据库，南大通用(华库)数据库，南大通用数据库，神通数据库，瀚高数据库，优炫数据库

配置类编写

@Configuration
public class MybatisPlusConfig {
    /**
     * 分页配置
     * @return 3.3.1及以下版本使用下面这个分页插件
     */
    @Bean 
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
	
	/**
     * 分页配置
     * @return 3.3.1以上版本使用下面这个分页插件
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL)); //插件分页拦截器，我的是mysql
        return mybatisPlusInterceptor;
    }
}

代码实战

	/**
     *
     * @param currPageNo 当前页码
     * @param pageSize 每页条数
     * @return
     */
    @PostMapping("/page")
    Map<String,Object> page(Integer currPageNo,Integer pageSize) {
        HashMap<String,Object> map = new HashMap<>();
        Page<TestDemo> page = new Page<>(currPageNo, pageSize);
        Page<TestDemo> page1 = testDemoService.page(page);
        Integer total = Math.toIntExact(page1.getTotal());
        Integer current = Math.toIntExact(page1.getCurrent());
        map.put("total",total); // 总条数
        map.put("current",current); // 当前页码
        map.put("content",page1.getRecords()); // 查询出来的数据
        map.put("code",200);
        map.put("message","查看分页数据成功");
        return map;
    }

乐观锁： 顾名思义十分乐观，它总是认为不会出现问题，无论干什么都不去上锁！如果出现了问题，再更新值测试。
悲观锁： 顾名思义十分悲观，它总是认为会出现问题，无论干什么都会上锁，然后再去操作！

插件功能： MyBatis-Plus 乐观锁插件是 MyBatis-Plus 提供的一种并发控制手段，用于解决在多线程或分布式场景下数据库并发更新所带来的数据不一致性问题。乐观锁的原理是在数据版本号的基础上进行并发控制，每次更新时判断数据版本号是否匹配，如果不匹配则认为数据已经被其他线程更新过，这时更新操作就会失败，返回更新失败的结果。

实现方式： 乐观锁实现方式如下

取出记录时，获取当前version
更新时，带上这个version
执行更新时， set version = newVersion where version = oldVersion
如果version不对，就更新失败

乐观锁： 1、先查询，获得版本号 version=1
--A
update test_demo set username ="user1" ,version =version+1
where id =1 and version=1

--B 如果线程抢先完成，这个时候version=2，会导致A修改失败
update test_demo set username ="user1" ,version =version+1
where id =1 and version=1

1、数据库添加字段：

ALTER TABLE `test_demo` ADD COLUMN `version` INT(11) DEFAULT '1' COMMENT '版本号'; 

2、实体类添加字段：

在TestDemo类下面添加如下字段：

@Version
private Integer version;

注意事项：

支持的数据类型只有:int,Integer,long,Long,Date,Timestamp,LocalDateTime
整数类型下 newVersion = oldVersion + 1
newVersion 会回写到 entity 中
仅支持 updateById(id) 与 update(entity, wrapper) 方法
在 update(entity, wrapper) 方法下， wrapper 不能复用

3、添加插件：

@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL)); //插件分页拦截器，我的是mysql
        mybatisPlusInterceptor.addInnerInterceptor(new BlockAttackInnerInterceptor()); // 添加执行分析插件
        mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor()); // 添加乐观锁插件
        return mybatisPlusInterceptor;
    }
}

4、代码实战：

单线程执行：

@SpringBootTest(classes = TestDemoApplication.class)
class TestDemoApplicationTests {
    @Resource
    private TestDemoService testDemoService;
    @Test
    void update() {
        TestDemo testDemo = testDemoService.getById(1);
        testDemo.setUsername("testDemo1");
        testDemo.setPassword("test1");
        testDemoService.updateById(testDemo);
    }
}

控制台分析：

可以看到这里的修改条件变成了id加version了，而version的值也变成2了 WHERE id=? AND version=?

结果：

可以看到版本号变成2了，说明单线程进行更新操作没有任何问题的，都会执行更新操作，那我们再来试试多线程操作，这里我们简单模拟多线程操作

多线程执行：

    @Test
    void update() {
        // 模拟多线程操作
        // 模拟线程1
        TestDemo testDemo = testDemoService.getById(1);
        testDemo.setUsername("testDemo2");
        testDemo.setPassword("test2");

        // 模拟线程2插队
        TestDemo testDemo1 = testDemoService.getById(1);
        testDemo1.setUsername("testDemo3");
        testDemo1.setPassword("test3");
        testDemoService.updateById(testDemo1); // 线程2抢先提交，这时他的版本发生了变化
        testDemoService.updateById(testDemo); // 线程1失败，乐观锁在这种情况下防止了脏数据存在，没有乐观锁就会有覆盖掉线程2的操作
    }

控制台分析：

可以看到这里的修改条件变成了id加version了，而version的值也变成3了 WHERE id=? AND version=?

线程2执行结果：

线程1执行结果：

线程1查询的版本号还是2，但其实版本号为2在线程2执行时就更新了变成了 version=3，所以这里查询不到，更新失败

结果：

MyBatis-Plus 提供了 SQL 注入器来能够自定义 MySQL 的 SQL，可以灵活的进行条件组装，从而实现动态SQL查询的目的。

1、定义接口方法，在mapper接口添加接口方法
在 package com.example.demo.mapper; 包下的 TestDemoMapper 接口添加 deleteAll() 方法

public interface TestDemoMapper extends BaseMapper<TestDemo> {
    public void deleteAll();
}

注意：我们不需要编写xml映射，因为我们会采用sql注入的形式，在 MybatisPlus 启动的时候就注入。

注：添加自定义SQL配置类和 注册自定义方法都在这个包下面 package com.example.demo.util.mp;

2、添加自定义SQL配置类
在 package com.example.demo.util.mp; 包下创建 MyMappedStatement 类，并继承 AbstractMethod，实现自定义SQL注入代码

public class MyMappedStatement extends AbstractMethod {
    @Override
    public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
        // 接口中的方法名
        String method = "deleteAll";
        // 该方法执行语句
        String sql = "delete from " + tableInfo.getTableName();
        // 创建SqlSource
        SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
        // 构造一个删除的MappedStatement并返回
        return this.addDeleteMappedStatement(mapperClass, method, sqlSource);
    }
}

3、注册自定义方法
在 package com.example.demo.util.mp; 包下创建 MySqlInjector类，并继承 DefaultSqlInjector，实现注册SQL自定义方法

public class MySqlInjector extends DefaultSqlInjector {
    /**
     * 如果只需增加方法，保留MP自带方法
     * 可以super.getMethodList() 再add
     * @return
     */
    @Override
    public List<AbstractMethod> getMethodList(Class<?> mapperClass, TableInfo tableInfo) {
        List<AbstractMethod> methodList = super.getMethodList(mapperClass,tableInfo);
        methodList.add(new MyMappedStatement());
        return methodList;
    }
}

4、添加自定义SQL注入对象

注释“执行分析插件”：会影响代码执行，它会阻止全表删除操作，所以先注释掉，反正我们已经学会了
在 package com.example.demo.config; 包下的 MybatisPlusConfig类，并注册相关 Bean，实现SQL自动注入功能

@Configuration
public class MybatisPlusConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL)); //插件分页拦截器，我的是mysql
//        mybatisPlusInterceptor.addInnerInterceptor(new BlockAttackInnerInterceptor()); // 添加执行分析插件
        mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor()); // 添加乐观锁插件
        return mybatisPlusInterceptor;
    }
    
    @Bean
    public MySqlInjector mySqlInjector() {
        return new MySqlInjector();
    }
}

5、测试
在 package com.example.testdemo; 包下的 TestDemoApplicationTests 类编写测试代码，并进行测试

@SpringBootTest(classes = TestDemoApplication.class)
class TestDemoApplicationTests {
    @Autowired
    private TestDemoMapper testDemoMapper;

    @Test
    void testDeleteAll() {
        testDemoMapper.deleteAll();
    }
}

测试前数据：

控制台输出：

==>  Preparing: delete from test_demo
==> Parameters: 
<==    Updates: 5

测试后数据:

逻辑删除： 逻辑删除指将数据标记为“已删除”，而非真正删除。可以在表中增加一个 deleted 标志位字段，并在查询时过滤掉已被标记删除的数据。可以使用 ORM 框架的软删除插件来简化实现。

注意：在操作之前进行记得先添加数据，已进行逻辑删除的数据，使用id查询的时候默认加上了 deleted=0 的条件

1、添加application.yml配置

如果有以下配置，请忽略此步骤

com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig

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)

2、实体类字段上加上@TableLogic注解

在TestDemo类下面添加如下字段：

@TableLogic
private Integer deleted;

3、数据库添加字段

ALTER TABLE `test_demo` ADD COLUMN `deleted` INT(11) DEFAULT '0' COMMENT '是否删除（0:未删除、1:已删除）'; 

4、测试

@SpringBootTest(classes = TestDemoApplication.class)
class TestDemoApplicationTests {
    @Resource
    private TestDemoMapper testDemoMapper;

    @Test
    void testDeleteAll() {
        testDemoMapper.deleteById(14);
    }
}

控制台输出： 可以看到我们的deleteById 的SQL变成了更新语句，并且将 deleted 字段修改成逻辑已删除值

==>  Preparing: UPDATE test_demo SET deleted=1 WHERE id=? AND deleted=0
==> Parameters: 14(Integer)
<==    Updates: 1

最终结果：

实现自定义枚举有两种方式，一种是使用注解而另一种是使用实现接口IEnum的方式，在接下来的案例中，我们会分别使用这两种进行讲解，这样可以让大家学的更全面一些。

注意：3.3.0之前的版本可能还需要额外的配置

1、数据库添加字段

ALTER TABLE `test_demo` ADD COLUMN (`age` INT(11),`grade` INT(11)); 

2、声明枚举

在这个目录下面 添加枚举：package com.example.demo.enums;

方式一： 使用 @EnumValue 注解枚举属性 完整示例

public enum GradeEnum {

    PRIMARY(1, "小学"),  SECONDORY(2, "中学"),  HIGH(3, "高中");

    private final String descp;

    GradeEnum(int code, String descp) {
        this.code = code;
        this.descp = descp;
    }

    @EnumValue // 标记数据库存的值是code
    private final int code;
    
}

方式二： 枚举属性，实现 IEnum 接口如下

public enum AgeEnum implements IEnum<Integer> {
    ONE(1, "一岁"),
    TWO(2, "二岁"),
    THREE(3, "三岁");

    private int value;
    private String desc;

    AgeEnum(int value, String desc) {
        this.value = value;
        this.desc = desc;
    }

    @Override
    public Integer getValue() {
        return this.value;
    }
}

3、在实体类下面添加字段

在TestDemo类下面添加如下字段：

    /**
     * 年龄，IEnum接口的枚举处理
     * 数据库字段：age INT(3)
     */
    private AgeEnum age;


    /**
     * 年级，原生枚举（带{@link com.baomidou.mybatisplus.annotation.EnumValue}):
     * 数据库字段：grade INT(2)
     */
    private GradeEnum grade;

4、测试

@SpringBootTest(classes = TestDemoApplication.class)
class TestDemoApplicationTests {
    @Resource
    private TestDemoService testDemoService;
    @Test
    void insert() {
        TestDemo testDemo = new TestDemo();
        testDemo.setUsername("testDemo1");
        testDemo.setPassword("test1");
        testDemo.setEmail("test1@qq.com");
        testDemo.setMobile("12345698756");
        testDemo.setCreateTime(LocalDateTime.now());
        testDemo.setAge(AgeEnum.ONE);
        testDemo.setGrade(GradeEnum.HIGH);
        testDemoService.save(testDemo);
    }
}

控制台输出：

==>  Preparing: INSERT INTO test_demo ( username, password, email, create_time, mobile, age, grade ) VALUES ( ?, ?, ?, ?, ?, ?, ? )
==> Parameters: testDemo1(String), test1(String), test1@qq.com(String), 2023-06-02T10:30:26.042(LocalDateTime), 12345698756(String), 1(Integer), 3(Integer)
<==    Updates: 1

结果：

MyBatis-Plus提供了一种自动填充（AutoFill）功能，可以在执行插入或者更新操作时，自动填充指定的字段。这个功能通常用来填充一些公共字段，例如创建时间、更新时间、创建人、更新人等等，避免重复代码的编写，提高代码的可维护性。

1、添加注解

package com.example.demo.model;

将TestDemo实体类上面的更新时间和创建时间两个字段的注解修改成如下所示

    @TableField(fill = FieldFill.UPDATE)
    private LocalDateTime updateTime;
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime createTime;

2、创建自动填充功能处理器

在如下包中创建 MyMetaObjectHandler 类 package com.example.demo.util.mp;

public class MyMetaObjectHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
        setFieldValByName("createTime", LocalDateTime.now(), metaObject);
        setFieldValByName("updateTime", LocalDateTime.now(), metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        setFieldValByName("updateTime", LocalDateTime.now(), metaObject);
    }
}

3、注册自动填充功能处理器：

在 package com.example.demo.config; 包下面的 MybatisPlusConfig 配置类中注册自动填充功能处理器

    @Bean
    public MyMetaObjectHandler myMetaObjectHandler() {
        return new MyMetaObjectHandler();
    }

4、测试

package com.example.testdemo;

@SpringBootTest(classes = TestDemoApplication.class)
class TestDemoApplicationTests {
    @Resource
    private TestDemoService testDemoService;
    @Test
    void insert() { // 新增
        TestDemo testDemo = new TestDemo();
        testDemo.setUsername("testDemo1");
        testDemo.setPassword("test1");
        testDemo.setEmail("test1@qq.com");
        testDemo.setMobile("12345698756");
        testDemo.setAge(AgeEnum.ONE);
        testDemo.setGrade(GradeEnum.HIGH);
        testDemoService.save(testDemo);
    }

    @Test
    void update() { // 更新
        TestDemo testDemo = testDemoService.getById(18);
        testDemo.setUsername("testDemo2");
        testDemo.setPassword("test2");
        testDemo.setEmail("test2@qq.com");
        testDemo.setMobile("98745632102");
        testDemo.setAge(AgeEnum.TWO);
        testDemo.setGrade(GradeEnum.PRIMARY);
        testDemoService.updateById(testDemo);
    }
}

新增结果：

更新结果：

此版本至少在 3.2.0 开始才生效噢~

字段类型处理器，用于 JavaType 与 JdbcType 之间的转换，用于 PreparedStatement 设置参数值和从 ResultSet 或 CallableStatement 中取出一个值，本文讲解 mybaits-plus 内置常用类型处理器如何通过TableField注解快速注入到 mybatis 容器中。

• JSON 字段类型

@Data
@Accessors(chain = true)
@TableName(autoResultMap = true)
public class User {
    private Long id;
    ...

    /**
     * 注意！！ 必须开启映射注解
     *
     * @TableName(autoResultMap = true)
     *
     * 以下两种类型处理器，二选一 也可以同时存在
     *
     * 注意！！选择对应的 JSON 处理器也必须存在对应 JSON 解析依赖包
     */
    @TableField(typeHandler = JacksonTypeHandler.class)
    // @TableField(typeHandler = FastjsonTypeHandler.class)
    private OtherInfo otherInfo;

}

该注解对应了 XML 中写法为

<result column="other_info" jdbcType="VARCHAR" property="otherInfo" typeHandler="com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler" />

1、ID生成策略对比

2、导入数据

# 这是一个用于删除名为 "goods" 的数据库表的 SQL 命令。它先检查该表是否存在，如果存在就删除它。通常用于重新创建一个表。
DROP TABLE IF EXISTS `goods`;
# 新建表
CREATE TABLE `goods` (
  `pid` bigint NOT NULL COMMENT '商品主键',
  `goods_name` varchar(255) DEFAULT NULL COMMENT '商品名称',
  PRIMARY KEY (`pid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='商品';

3、生成代码 运行NewAutoCodeGenerator

使用代码生成器生成相关的代码：https://blog.csdn.net/ITKidKid/article/details/126185295

请输入表名,用逗号隔开：
goods

温馨提示：自3.3.0开始，默认使用雪花算法+UUID(不含中划线)

4、重写方法

5、添加雪花算法工具类

在 package com.example.demo.util.mp; 包下添加 SnowflakeUtils 雪花算法工具类

/**
 * 雪花算法生成唯一的有序的序列号
 */
public class SnowFlakeUtil {

    private static SnowFlakeUtil snowFlakeUtil;
    static {
        snowFlakeUtil = new SnowFlakeUtil();
    }

    // 初始时间戳(纪年)，可用雪花算法服务上线时间戳的值
    // 1650789964886：2022-04-24 16:45:59
    private static final long INIT_EPOCH = 1650789964886L;

    // 时间位取&
    private static final long TIME_BIT = 0b1111111111111111111111111111111111111111110000000000000000000000L;

    // 记录最后使用的毫秒时间戳，主要用于判断是否同一毫秒，以及用于服务器时钟回拨判断
    private long lastTimeMillis = -1L;

    // dataCenterId占用的位数
    private static final long DATA_CENTER_ID_BITS = 5L;

    // dataCenterId占用5个比特位，最大值31
    // 0000000000000000000000000000000000000000000000000000000000011111
    private static final long MAX_DATA_CENTER_ID = ~(-1L << DATA_CENTER_ID_BITS);

    // dataCenterId
    private long dataCenterId;

    // workId占用的位数
    private static final long WORKER_ID_BITS = 5L;

    // workId占用5个比特位，最大值31
    // 0000000000000000000000000000000000000000000000000000000000011111
    private static final long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS);

    // workId
    private long workerId;

    // 最后12位，代表每毫秒内可产生最大序列号，即 2^12 - 1 = 4095
    private static final long SEQUENCE_BITS = 12L;

    // 掩码（最低12位为1，高位都为0），主要用于与自增后的序列号进行位与，如果值为0，则代表自增后的序列号超过了4095
    // 0000000000000000000000000000000000000000000000000000111111111111
    private static final long SEQUENCE_MASK = ~(-1L << SEQUENCE_BITS);

    // 同一毫秒内的最新序号，最大值可为 2^12 - 1 = 4095
    private long sequence;

    // workId位需要左移的位数 12
    private static final long WORK_ID_SHIFT = SEQUENCE_BITS;

    // dataCenterId位需要左移的位数 12+5
    private static final long DATA_CENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS;

    // 时间戳需要左移的位数 12+5+5
    private static final long TIMESTAMP_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATA_CENTER_ID_BITS;

    /**
     * 无参构造
     */
    public SnowFlakeUtil() {
        this(1, 1);
    }

    /**
     * 有参构造
     * @param dataCenterId
     * @param workerId
     */
    public SnowFlakeUtil(long dataCenterId, long workerId) {
        // 检查dataCenterId的合法值
        if (dataCenterId < 0 || dataCenterId > MAX_DATA_CENTER_ID) {
            throw new IllegalArgumentException(
                    String.format("dataCenterId 值必须大于 0 并且小于 %d", MAX_DATA_CENTER_ID));
        }
        // 检查workId的合法值
        if (workerId < 0 || workerId > MAX_WORKER_ID) {
            throw new IllegalArgumentException(String.format("workId 值必须大于 0 并且小于 %d", MAX_WORKER_ID));
        }
        this.workerId = workerId;
        this.dataCenterId = dataCenterId;
    }

    /**
     * 获取唯一ID
     * @return
     */
    public static Long getSnowFlakeId() {
        return snowFlakeUtil.nextId();
    }

    /**
     * 通过雪花算法生成下一个id，注意这里使用synchronized同步
     * @return 唯一id
     */
    public synchronized long nextId() {
        long currentTimeMillis = System.currentTimeMillis();
        System.out.println(currentTimeMillis);
        // 当前时间小于上一次生成id使用的时间，可能出现服务器时钟回拨问题
        if (currentTimeMillis < lastTimeMillis) {
            throw new RuntimeException(
                    String.format("可能出现服务器时钟回拨问题，请检查服务器时间。当前服务器时间戳：%d，上一次使用时间戳：%d", currentTimeMillis,
                            lastTimeMillis));
        }
        if (currentTimeMillis == lastTimeMillis) {
            // 还是在同一毫秒内，则将序列号递增1，序列号最大值为4095
            // 序列号的最大值是4095，使用掩码（最低12位为1，高位都为0）进行位与运行后如果值为0，则自增后的序列号超过了4095
            // 那么就使用新的时间戳
            sequence = (sequence + 1) & SEQUENCE_MASK;
            if (sequence == 0) {
                currentTimeMillis = getNextMillis(lastTimeMillis);
            }
        } else { // 不在同一毫秒内，则序列号重新从0开始，序列号最大值为4095
            sequence = 0;
        }
        // 记录最后一次使用的毫秒时间戳
        lastTimeMillis = currentTimeMillis;
        // 核心算法，将不同部分的数值移动到指定的位置，然后进行或运行
        // <<：左移运算符, 1 << 2 即将二进制的 1 扩大 2^2 倍
        // |：位或运算符, 是把某两个数中, 只要其中一个的某一位为1, 则结果的该位就为1
        // 优先级：<< > |
        return
                // 时间戳部分
                ((currentTimeMillis - INIT_EPOCH) << TIMESTAMP_SHIFT)
                        // 数据中心部分
                        | (dataCenterId << DATA_CENTER_ID_SHIFT)
                        // 机器表示部分
                        | (workerId << WORK_ID_SHIFT)
                        // 序列号部分
                        | sequence;
    }

    /**
     * 获取指定时间戳的接下来的时间戳，也可以说是下一毫秒
     * @param lastTimeMillis 指定毫秒时间戳
     * @return 时间戳
     */
    private long getNextMillis(long lastTimeMillis) {
        long currentTimeMillis = System.currentTimeMillis();
        while (currentTimeMillis <= lastTimeMillis) {
            currentTimeMillis = System.currentTimeMillis();
        }
        return currentTimeMillis;
    }

    /**
     * 获取随机字符串,length=13
     * @return
     */
    public static String getRandomStr() {
        return Long.toString(getSnowFlakeId(), Character.MAX_RADIX);
    }

    /**
     * 从ID中获取时间
     * @param id 由此类生成的ID
     * @return
     */
    public static Date getTimeBySnowFlakeId(long id) {
        return new Date(((TIME_BIT & id) >> 22) + INIT_EPOCH);
    }

//    public static void main(String[] args) {
//        SnowFlakeUtil snowFlakeUtil = new SnowFlakeUtil();
//        long id = snowFlakeUtil.nextId();
//        System.out.println(id);
//        Date date = SnowFlakeUtil.getTimeBySnowFlakeId(id);
//        System.out.println(date);
//        long time = date.getTime();
//        System.out.println(time);
//        System.out.println(getRandomStr());
//
//    }

}

6、创建自定义ID生成器实体类

在 package com.example.demo.util.mp; 包下面创建 CustomIdGenerator ID生成器实体类

public class CustomIdGenerator implements IdentifierGenerator {
    @Value("${server.worker-id:1}")
    private Integer workerId;

    @Value("${server.data-center-id:1}")
    private Integer dataCenterId;

    @Override
    public Long nextId(Object entity) {
        //可以将当前传入的class全类名来作为bizKey,或者提取参数来生成bizKey进行分布式Id调用生成.
        String bizKey = entity.getClass().getName();
        //根据bizKey调用分布式ID生成
        System.out.println("bizKey:" + bizKey);
        // 获取元对象
        MetaObject metaObject = SystemMetaObject.forObject(entity);
        // 获取商品名称
        String name = (String) metaObject.getValue("goodsName");
        //上面的雪花算法
        long id = new SnowFlakeUtil(workerId, dataCenterId).nextId();
        //返回生成的id值即可.
        System.out.println("为" + name + "生成主键值->:" + id);
        return id;
    }
}				

7、注册自定义ID生成器

在 package com.example.demo.config; 包下面的 MybatisPlusConfig 注册 Bean

@Bean
public IdentifierGenerator customIdGenerator(){
    return new CustomIdGenerator();
}

8、修改主键策略

修改 package com.example.demo.model; 包下面的 Goods 类中的主键策略

    /**
     * 商品主键
     */
    @TableId(value = "pid", type = IdType.ASSIGN_ID)
    private Long pid;

9、测试

@SpringBootTest(classes = TestDemoApplication.class)
class TestDemoApplicationTests {
    @Resource
    private GoodsService goodsService;
    @Test
    void testCustomIdGenerator() {
        Goods goods = new Goods();
        goods.setGoodsName("电脑");
        boolean save = goodsService.save(goods);
        System.out.println(save);
    }
}

结果：