<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>tech.aistar</groupId>
    <artifactId>mybatis-plus-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mybatis-plus-demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

DROP TABLE IF EXISTS user;  
   CREATE TABLE user (  
     id BIGINT(20) PRIMARY KEY NOT NULL COMMENT '主键',  
     name VARCHAR(30) DEFAULT NULL COMMENT '姓名',  
     age INT(11) DEFAULT NULL COMMENT '年龄',  
     email VARCHAR(50) DEFAULT NULL COMMENT '邮箱',  
     manager_id BIGINT(20) DEFAULT NULL COMMENT '直属上级id',  
     create_time DATETIME DEFAULT NULL COMMENT '创建时间',  
     CONSTRAINT manager_fk FOREIGN KEY(manager_id) REFERENCES user (id)  
   ) ENGINE=INNODB CHARSET=UTF8;  
   INSERT INTO user (id, name, age ,email, manager_id, create_time) VALUES  
   (1, '大BOSS', 40, 'boss1@baomidou.com', NULL, '2021-03-22 09:48:00'),  
   (2, '李三儿', 30, 'boss2@baomidou.com', 1, '2021-01-22 09:48:00'),  
   (3, '黄小三', 35, 'boss3@baomidou.com', 2, '2021-01-22 09:48:00'),  
   (4, '三德子', 25, 'boss4@baomidou.com', 2, '2021-02-22 09:48:00'),  
   (5, '小菜', 23, 'boss5@baomidou.com', 2, '2021-02-22 09:48:00'),
   (6, '黄主任',23,NULL,5, '2021-02-22 09:48:00');

package tech.aistar.pojo;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
    * 本类用来演示: 用户实体类
 *
    * @author: success
    * @date: 2021/5/31 9:51 上午
 */
@Data
public class User implements Serializable {
    private Long id;
    private String name;
    private Integer age;
    private String email;
    private Long managerId;
    private Date createTime;
}

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/dev?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

package tech.aistar;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@MapperScan("tech.aistar.mapper")
@SpringBootApplication
public class MybatisPlusDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(MybatisPlusDemoApplication.class, args);
    }
}

package tech.aistar.mapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
/**
    * 本类用来演示:
 *
    * @author: success
    * @date: 2021/5/31 11:14 上午
 */
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    /**
        * 测试 - 查询所有
     */
    @Test
    public void testFindAll(){
        userMapper.selectList(null).forEach(System.out::println);
    }
}

// 插入一条记录
int insert(T entity);

/**
  * 测试Insert方法
  */
@Test
public void testInsert(){
  User user = new User();
  user.setName("success");
  user.setAge(18);
  user.setEmail("849962874@qq.com");
  user.setCreateTime(new Date());
  user.setManagerId(2L);
  userMapper.insert(user);
}

// 根据 entity 条件，删除记录
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
// 删除（根据ID 批量删除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 ID 删除
int deleteById(Serializable id);
// 根据 columnMap 条件，删除记录
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

@Test
public void testDelete(){
  //根据 ID 删除
  //userMapper.deleteById(1399249825152729090L);
  //删除（根据ID 批量删除）
  //        List<Long> ids = new ArrayList<>();
  //        ids.add(5L);
  //        ids.add(3L);
  //        userMapper.deleteBatchIds(ids);
  // 根据 entity 条件，删除记录
  //DELETE FROM user WHERE (manager_id = ?)
  //        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
  //        queryWrapper.eq("manager_id",2L);
  //        userMapper.delete(queryWrapper);
  //根据 columnMap 条件，删除记录
  //DELETE FROM user WHERE name = ? 
  Map<String,Object> maps = new HashMap<>();
  maps.put("name","吴组长");
  userMapper.deleteByMap(maps);
}

// 根据 whereWrapper 条件，更新记录
int update(@Param(Constants.ENTITY) T updateEntity, @Param(Constants.WRAPPER) Wrapper<T> whereWrapper);
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

@Test
public void testUpdate(){
  //        User user = userMapper.selectById(1L);
  //        user.setName("success");
  //        userMapper.updateById(user);
  //第一种写法 - 使用set()方法单独更新某个列
  //        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
  //        updateWrapper.ge("age",40).set("age",100);
  //
  //        userMapper.update(null,updateWrapper);
  //第二种写法 - 使用对象
  UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
  updateWrapper.ge("age",23).le("age",30);
  User user = new User();
  user.setAge(18);
  userMapper.update(user,updateWrapper);
}

// 根据 ID 查询
T selectById(Serializable id);
// 根据 entity 条件，查询一条记录
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 entity 条件，查询全部记录
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据 columnMap 条件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
// 根据 Wrapper 条件，查询全部记录
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 entity 条件，查询全部记录（并翻页）
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录（并翻页）
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询总记录数
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

//SELECT id,name FROM user WHERE (name LIKE ?)
//==>  Preparing: SELECT id,name FROM user WHERE (name LIKE ?)
//==> Parameters: 黄%(String)
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("id","name");
queryWrapper.likeRight("name","黄");
List<Map<String,Object>> maps = userMapper.selectMaps(queryWrapper);
maps.forEach(System.out::println);

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("manager_id","avg(age)")
  .groupBy("manager_id")
  .having("avg(age)>={0}",59);
List<Map<String,Object>> maps = userMapper.selectMaps(queryWrapper);
maps.forEach(System.out::println);

QueryWrapper<User> wrapper = new QueryWrapper<>();  
wrapper.select("id", "name").like("name", "黄");  
List<Object> objects = userMapper.selectObjs(wrapper);  
objects.forEach(System.out::println);

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("age",18);
Integer size = userMapper.selectCount(queryWrapper);
System.out.println(size);

public interface UserService extends IService<User2> {
}

@Service
public class UserServiceImpl extends ServiceImpl<User2Mapper, User2> implements UserService{
}

// 插入一条记录（选择字段，策略插入）
boolean save(T entity);
// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）- batchSize - 表示一次批量插入的数据量，默认为 1000
boolean saveBatch(Collection<T> entityList, int batchSize);

@Test
public void testSave(){
  List<User2> list = new ArrayList<>();
  for (int i = 0; i < 5; i++) {
    User2 user2 = new User2();
    user2.setAge(22+i);
    user2.setEmail("99999"+i+"@qq.com");
    user2.setName("tom"+i);
    user2.setManagerId(2L);
    list.add(user2);
  }
  //批量插入
  userService.saveBatch(list);
}

// TableId 注解存在更新记录，否插入一条记录
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

/**
  * 测试根据主键值id进行更新
  * 如果实体类的id属性名和表的列主键值id列名保持一致,那么可以不使用@TableId
  * 否则必须使用
  */
@Test
public void testUpdateByPrimaryKey(){
  //        User2 user2 = userService.getById(1);
  //        user2.setAge(33);
  //        //测试对已经存在的记录进行更新
  //        userService.saveOrUpdate(user2);
  User2 user01 = new User2();
  user01.setName("亲爱的管");
  user01.setAge(100);
  //测试对不存在的记录进行插入
  userService.saveOrUpdate(user01);
}

/**
   * 测试根据条件进行更新
   * 如果存在,则更新,否则执行插入
   */
@Test
public void testUpdateByWrapper(){
  UpdateWrapper<User2> updateWrapper = new UpdateWrapper<>();
  updateWrapper.ge("age",300);
  User2 u = new User2();
  u.setName("ping");
  userService.saveOrUpdate(u,updateWrapper);
}

// 根据 entity 条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

@Test
public void testRemove(){
  //本人更加推荐lambda写法
  userService.lambdaUpdate().eq(User2::getId,3).remove();
}

// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereWrapper 条件，更新记录
boolean update(T updateEntity, Wrapper<T> whereWrapper);
// 根据 ID 选择修改
boolean updateById(T entity);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);

// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
//getObj（使用查询构造器，查询一条记录，返回这条记录的第一个字段值）
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

@Test
public void testGet(){
  //        LambdaQueryWrapper<User2> queryWrapper = new LambdaQueryWrapper<>();
  //        queryWrapper.eq(User2::getAge,40);
  //本人更喜欢如下方式
  //这个是方法返回结果不止一条则会抛出异常，如果想默认取第一条结果，可以给这方法传第二个参数为false。
  //User2 user2 = userService.getOne(Wrappers.<User2>lambdaQuery().eq(User2::getAge,40),false);
  //System.out.println(user2);
  //getObj（使用查询构造器，查询一条记录，返回这条记录的第一个字段值）
   Integer id = userService.getObj(Wrappers.<User2>lambdaQuery().eq(User2::getId,1),o->{return    Integer.parseInt(o.toString());});
        System.out.println(id);
}

// 查询所有
List<T> list();
// 查询列表
List<T> list(Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
Collection<T> listByIds(Collection<? extends Serializable> idList);
// 查询（根据 columnMap 条件）
Collection<T> listByMap(Map<String, Object> columnMap);
// 查询所有列表
List<Map<String, Object>> listMaps();
// 查询列表
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
// 查询全部记录
List<Object> listObjs();
// 查询全部记录
<V> List<V> listObjs(Function<? super Object, V> mapper);
// 根据 Wrapper 条件，查询全部记录
List<Object> listObjs(Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

@Test
public void testList(){
  userService.listObjs(o->{
    return "user_"+o;
  }).forEach(e-> System.out.println(e));
}

// 无条件分页查询
IPage<T> page(IPage<T> page);
// 条件分页查询
IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);
// 无条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page);
// 条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page, Wrapper<T> queryWrapper);

@Test
public void testPage(){
  Page<User2> page = new Page<>(3,2);
  //        userService.page(page).getRecords().forEach(e-> System.out.println(e));
  userService.page(page,Wrappers.<User2>lambdaQuery().eq(User2::getAge,40))
    .getRecords().forEach(e-> System.out.println(e));
}

// 查询总记录数
int count();
// 根据 Wrapper 条件，查询总记录数
int count(Wrapper<T> queryWrapper);

@Test
public void testCount(){
  System.out.println(userService.count(Wrappers.<User2>lambdaQuery().eq(User2::getAge, 40)));
}

// 链式查询 普通
QueryChainWrapper<T> query();
// 链式查询 lambda 式。注意：不支持 Kotlin
LambdaQueryChainWrapper<T> lambdaQuery(); 
// 示例：
query().eq("column", value).one();
lambdaQuery().eq(Entity::getId, value).list();

// Preparing: SELECT id,name,age,email,manager_id,create_time,update_time,version FROM user2 WHERE (age = ? OR (id = ?))
userService.lambdaQuery()
  .eq(User2::getAge,40)
  .or(e1->e1.eq(User2::getId,30))
  .list().forEach(e-> System.out.println(e));

SELECT id,name,age,email,manager_id,create_time,update_time,version FROM user2 WHERE (id = ?)
System.out.println(userService.lambdaQuery().eq(User2::getId, 1).one());

// 链式更改 普通
UpdateChainWrapper<T> update();
// 链式更改 lambda 式。注意：不支持 Kotlin 
LambdaUpdateChainWrapper<T> lambdaUpdate();
// 示例：
update().eq("column", value).remove();
lambdaUpdate().eq(Entity::getId, value).update(entity);

@Test
public void testUpdate(){
  //直接更新具体的某列,不需要实体对象
  //userService.lambdaUpdate().eq(User2::getId,1).set(User2::getName,"ss").update();
  //更新一个对象
  User2 user2 = new User2();
  user2.setName("xx");
  user2.setAge(100);
  userService.lambdaUpdate().eq(User2::getId,1).update(user2);
}

@Test
public void test条件构造器(){
  //SELECT id,name,age,email,manager_id,create_time FROM user WHERE (name = ? AND age = ?)
  QueryWrapper<User> queryWrapper = new QueryWrapper<>();
  Map<String,Object> conditional = new HashMap<>();
  conditional.put("age",18);
  conditional.put("name","小菜");
  queryWrapper.allEq(conditional);
  List<User> users = userMapper.selectList(queryWrapper);
  users.forEach(e-> System.out.println(e));
}

@Test  
public void test3() {  
  QueryWrapper<User> wrapper = new QueryWrapper<>();  
  Map<String, Object> param = new HashMap<>();  
  param.put("age", 40);  
  param.put("name", null);  
  wrapper.allEq(param);  
  List<User> users = userMapper.selectList(wrapper);  
  users.forEach(System.out::println);  
}

@Test
public void test3() {  
  QueryWrapper<User> wrapper = new QueryWrapper<>();  
  Map<String, Object> param = new HashMap<>();  
  param.put("age", 40);  
  param.put("name", null);  
  wrapper.allEq(param, false);  
  List<User> users = userMapper.selectList(wrapper);  
  users.forEach(System.out::println);  
}

QueryWrapper<User> wrapper = new QueryWrapper<>();
Map<String, Object> param = new HashMap<>();
param.put("age", 18);
param.put("name", "黄主管");
wrapper.allEq((k,v) -> !"name".equals(k), param); // 过滤掉map中key为name的元素
List<User> users = userMapper.selectList(wrapper);
users.forEach(System.out::println);

@Test
public void test条件构造器02(){
  //1. 名字中包含三，且年龄小于25
  //        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
  //        queryWrapper.like("name","三")
  //                    .lt("age",25);
  //        List<User> userList = userMapper.selectList(queryWrapper);
  //        userList.forEach(System.out::println);
  //2.姓名为黄姓，且年龄大于等于20，小于等于40，且email字段不为空
  //        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
  //        queryWrapper.likeRight("name","黄").and(
  //                (w->w.gt("age",20)
  //                        .lt("age",40).isNotNull("email"))
  //        );
  //        List<User> userList = userMapper.selectList(queryWrapper);
  //        userList.forEach(System.out::println);
  //3.或者年龄大于等于23，按照年龄降序排列，年龄相同则按照id升序排列
  //        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
  //        queryWrapper.ge("age",23)
  //                    .orderByDesc("age")
  //                    .orderByAsc("id");
  //        List<User> userList = userMapper.selectList(queryWrapper);
  //        userList.forEach(System.out::println);
  //4.创建日期为2021年2月22日，并且直属上级的名字为小姓
  //        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
  //        queryWrapper.apply("date_format(create_time,'%Y-%m-%d')={0}","2021-02-22")
  //                     .inSql("manager_id","select id from user where name like '小%'");
  //
  //
  //        List<User> userList = userMapper.selectList(queryWrapper);
  //        userList.forEach(System.out::println);
  //5. 正常嵌套
  //(年龄小于40或者邮箱不为空) 并且名字为黄姓
  //        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
  //
  //        queryWrapper.nested(c->c.lt("age",40).or().isNotNull("email"))
  //                .likeRight("name","黄")
  //
  //        //6.last
  //        //.只能调用一次,多次调用以最后一次为准 有sql注入的风险,请谨慎使用
  //                .last("limit 1");
  //
  //        List<User> userList = userMapper.selectList(queryWrapper);
  //        userList.forEach(System.out::println);
  //7. 筛选部分列
  //        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
  //
  //        queryWrapper.select("id","name");
  //        List<User> userList = userMapper.selectList(queryWrapper);
  //        userList.forEach(System.out::println);
  //8. 选出id, name, age, email, 等同于排除 manager_id 和 create_time
  // 当列特别多, 而只需要排除个别列时, 采用上面的方式可能需要写很多个列,
  // 可以采用重载的select方法，指定需要排除的列
  QueryWrapper<User> queryWrapper = new QueryWrapper<>();
  queryWrapper.select(User.class,info->{
    String colName = info.getColumn();
    return !colName.equals("manager_id") && !colName.equals("create_time");
  });
  List<User> userList = userMapper.selectList(queryWrapper);
  userList.forEach(System.out::println);
}

/**
  * 测试boolean参数
*/
@Test
public void testBooleanParam(){
String name = "";
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.like(StringUtils.hasText(name), "name", name);
// 仅当 StringUtils.hasText(name) 为 true 时, 会拼接这个like语句到WHERE中
// 其实就是对下面代码的简化
//如果字符串里面的值为null， ""， "   "，那么返回值为false；否则为true
//        if (StringUtils.hasText(name)) {
//            wrapper.like("name", name);
//        }
List<User> userList = userMapper.selectList(wrapper);
userList.forEach(e-> System.out.println(e));
}

@Test
public void testObjParams(){
  User user = new User();
  user.setName("小菜");
  QueryWrapper<User> queryWrapper = new QueryWrapper<>(user);
  List<User> userList = userMapper.selectList(queryWrapper);
  userList.forEach(System.out::println);
}

@TableField中配置的condition属性实则是一个字符串，SqlCondition类中预定义了一些字符串以供选择
SqlCondition中提供的配置比较有限，当我们需要<或>等拼接方式，则需要自己定义。比如

@Data  
public class User {  
 private Long id;  
 @TableField(condition = SqlCondition.LIKE)  
 private String name;  
    @TableField(condition = "%s > #{%s}") // 这里相当于大于, 其中 > 是字符实体  
 private Integer age;  
 private String email;  
 private Long managerId;  
 private LocalDateTime createTime;  
}

@Test
public void testLambda(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(User::getName,"三");
List<User> userList = userMapper.selectList(lambdaQueryWrapper);
userList.forEach(System.out::println);
}

@Test  
public void testLambda() {  
  LambdaQueryChainWrapper<User> chainWrapper = new LambdaQueryChainWrapper<>(userMapper);  
  List<User> users = chainWrapper.like(User::getName, "黄").gt(User::getAge, 30).list();  
  users.forEach(System.out::println);  
}

@Test
public void testLambdaUpdate(){
  User user = new User();
  user.setName("james");
  LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
  lambdaUpdateWrapper.eq(User::getId,1);
  userMapper.update(user,lambdaUpdateWrapper);
}

@Test  
public void testUpdate5() {  
  LambdaUpdateChainWrapper<User> wrapper = new LambdaUpdateChainWrapper<>(userMapper);  
  wrapper.likeRight(User::getEmail, "share")  
    .like(User::getName, "飞飞")  
    .set(User::getEmail, "ff@baomidou.com")  
    .update();  
}

@Test  
 public void testUpdate4() {  
  LambdaUpdateWrapper<User> wrapper = new LambdaUpdateWrapper<>();  
  wrapper.likeRight(User::getEmail, "share").set(User::getManagerId, 9L);  
  userMapper.update(null, wrapper);  
 }

public interface UserMapper extends BaseMapper<User> {
    @Select("select * from user")
    List<User> findAll();
}

//自定义sql - mybatis-plus方式
@Select("select * from user ${ew.customSqlSegment}")
List<User> findAllWhere(@Param(Constants.WRAPPER)Wrapper<User> wrapper);

/**
  * 自定义SQL
  * 2. 采用原生的mybatis
  * 也可以使用mp提供的Wrapper条件构造器，来自定义SQL
  */
@Test
public void testFindAllWhere(){
  LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
  wrapper.like(User::getName,"三");
  List<User> userList = userMapper.findAllWhere(wrapper);
  userList.forEach(user -> System.out.println(user));
}

List<User> findAll(Wrapper<User> wrapper);

<mapper namespace="tech.aistar.mapper.UserMapper">  
  <select id="findAll" resultType="tech.aistar.pojo.User">  
    SELECT * FROM user ${ew.customSqlSegment}  
  </select>  
</mapper>

@Configuration
public class MybatisplusConfig {
 @Bean
 public MybatisPlusInterceptor mybatisPlusInterceptor(){
     MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
     PaginationInnerInterceptor paginationInnerInterceptor = new PaginationInnerInterceptor();
     paginationInnerInterceptor.setDbType(DbType.MYSQL);
     paginationInnerInterceptor.setOverflow(true);
     interceptor.addInnerInterceptor(paginationInnerInterceptor);
     return interceptor;
 }
}

@Test
public void testSelectPage(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<User>();
lambdaQueryWrapper.ge(User::getAge,20);
//设置分页信息,查询第3页,每页显示2条
Page<User> page = new Page<>(3,2);
//执行分页查询
Page<User> pageInfo = userMapper.selectPage(page,lambdaQueryWrapper);
//展示分页的信息
System.out.println("总的记录数[条数rows]:"+page.getTotal());
System.out.println("总的页数:"+page.getPages());
System.out.println("每页显示条数:"+page.getSize());
//展示分页具体返回的内容
page.getRecords().forEach(System.out::println);
}

==>  Preparing: SELECT COUNT(*) FROM user WHERE (age >= ?)
==> Parameters: 20(Integer)
<==    Columns: COUNT(*)
<==        Row: 6
<==      Total: 1
==>  Preparing: SELECT id,name,age,email,manager_id,create_time FROM user WHERE (age >= ?) LIMIT ? OFFSET ?
==> Parameters: 20(Integer), 2(Long), 4(Long)
<==    Columns: id, name, age, email, manager_id, create_time
<==        Row: 5, 小菜, 23, boss5@baomidou.com, 2, 2021-02-22 09:48:00
<==        Row: 6, 黄主任, 23, null, 5, 2021-02-22 09:48:00
<==      Total: 2

public Page(long current, long size, boolean isSearchCount);
Page<User> page = new Page<>(3,2,false);

==>  Preparing: SELECT id,name,age,email,manager_id,create_time FROM user WHERE (age >= ?) LIMIT ? OFFSET ?
==> Parameters: 20(Integer), 2(Long), 4(Long)
<==    Columns: id, name, age, email, manager_id, create_time
<==        Row: 5, 小菜, 23, boss5@baomidou.com, 2, 2021-02-22 09:48:00
<==        Row: 6, 黄主任, 23, null, 5, 2021-02-22 09:48:00
<==      Total: 2
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@57545c3f]
总的记录数[条数rows]:0
总的页数:0
每页显示条数:2

/**
  *在实际开发中，可能遇到**多表联查**的场景，此时`BaseMapper`中提供的单表分页查询的方法无法满足需求，
  * 需要**自定义SQL**，示例如下（使用单表查询的SQL进行演示，实际进行多表联查时，
  * 修改SQL语句即可）
  *
  * 这里采用纯注解方式。当然，若SQL比较复杂，建议还是采用XML的方式
  * @param page
  * @param wrapper
  * @return
  */
@Select("select * from user ${ew.customSqlSegment}")
Page<User> selectUserPage(Page<User> page,@Param(Constants.WRAPPER)Wrapper<User> wrapper);

@Test
public void testSelectUserPage(){
  LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<User>();
  lambdaQueryWrapper.ge(User::getAge,20);
  //设置分页信息,查询第3页,每页显示2条
  //第三个参数设置成false,不会查询总的记录数
  //Page<User> page = new Page<>(3,2,false);
  Page<User> page = new Page<>(3,2);
  //执行分页查询
  Page<User> pageInfo = userMapper.selectUserPage(page,lambdaQueryWrapper);
  //展示分页的信息
  System.out.println("总的记录数[条数rows]:"+page.getTotal());
  System.out.println("总的页数:"+page.getPages());
  System.out.println("每页显示条数:"+page.getSize());
  //展示分页具体返回的内容
  page.getRecords().forEach(System.out::println);
}

mybatis-plus:
  global-config:
    db-config:
      id-type: auto

DROP TABLE IF EXISTS user;  
   CREATE TABLE user (  
     id BIGINT(20) PRIMARY KEY NOT NULL auto_increment COMMENT '主键',  
     name VARCHAR(30) DEFAULT NULL COMMENT '姓名',  
     age INT(11) DEFAULT NULL COMMENT '年龄',  
     email VARCHAR(50) DEFAULT NULL COMMENT '邮箱',  
     manager_id BIGINT(20) DEFAULT NULL COMMENT '直属上级id',  
     create_time DATETIME DEFAULT NULL COMMENT '创建时间',  
     CONSTRAINT manager_fk FOREIGN KEY(manager_id) REFERENCES user (id)  
   ) ENGINE=INNODB CHARSET=UTF8;  
   INSERT INTO user (id, name, age ,email, manager_id, create_time) VALUES  
   (1, '大BOSS', 40, 'boss1@baomidou.com', NULL, '2021-03-22 09:48:00'),  
   (2, '李三儿', 30, 'boss2@baomidou.com', 1, '2021-01-22 09:48:00'),  
   (3, '黄小三', 35, 'boss3@baomidou.com', 2, '2021-01-22 09:48:00'),  
   (4, '三德子', 25, 'boss4@baomidou.com', 2, '2021-02-22 09:48:00'),  
   (5, '小菜', 23, 'boss5@baomidou.com', 2, '2021-02-22 09:48:00'),
   (6, '黄主任',23,NULL,5, '2021-02-22 09:48:00');

mybatis-plus:  
   global-config:  
     db-config:  
       table-prefix: xx_

@Test  
public void test3() {  
 QueryWrapper<User> wrapper = new QueryWrapper<>();  
 wrapper.like("name", "黄");  
 Integer count = userMapper.selectCount(wrapper);  
 System.out.println(count);  
}

DROP TABLE IF EXISTS user2;  
CREATE TABLE user2 (  
id BIGINT(20) PRIMARY KEY NOT NULL auto_increment COMMENT '主键id',  
name VARCHAR(30) DEFAULT NULL COMMENT '姓名',  
age INT(11) DEFAULT NULL COMMENT '年龄',  
email VARCHAR(50) DEFAULT NULL COMMENT '邮箱',  
manager_id BIGINT(20) DEFAULT NULL COMMENT '直属上级id',  
create_time DATETIME DEFAULT NULL COMMENT '创建时间',  
update_time DATETIME DEFAULT NULL COMMENT '修改时间',  
version INT(11) DEFAULT '1' COMMENT '版本',  
deleted INT(1) DEFAULT '0' COMMENT '逻辑删除标识,0-未删除,1-已删除',  
CONSTRAINT manager_fk_user2 FOREIGN KEY(manager_id) REFERENCES user2(id)  
) ENGINE = INNODB CHARSET=UTF8;  
INSERT INTO user2(id, name, age, email, manager_id, create_time)  
VALUES  
(1, '老板', 40 ,'boss@baomidou.com' ,NULL, '2021-03-28 13:12:40'),  
(2, '王狗蛋', 40 ,'gd@baomidou.com' ,1, '2021-03-28 13:12:40'),  
(3, '王鸡蛋', 40 ,'jd@baomidou.com' ,2, '2021-03-28 13:12:40'),  
(4, '王鸭蛋', 40 ,'yd@baomidou.com' ,2, '2021-03-28 13:12:40'),  
(5, '王猪蛋', 40 ,'zd@baomidou.com' ,2, '2021-03-28 13:12:40'),  
(6, '王软蛋', 40 ,'rd@baomidou.com' ,2, '2021-03-28 13:12:40'),  
(7, '王铁蛋', 40 ,'td@baomidou.com' ,2, '2021-03-28 13:12:40');

@Data  
public class User2 {  
private Long id;  
private String name;  
private Integer age;  
private String email;  
private Long managerId;  
private Date createTime;  
private Date updateTime;  
private Integer version;  
private Integer deleted;  
}

public interface User2Mapper extends BaseMapper<User2> {
}

mybatis-plus:  
global-config:  
 db-config:  
   logic-delete-field: deleted # 全局逻辑删除的实体字段名  
   logic-delete-value: 1 # 逻辑已删除值(默认为1)  
   logic-not-delete-value: 0 # 逻辑未删除值(默认为0)  
   # 若逻辑已删除和未删除的值和默认值一样，则可以不配置这2项

user2Mapper.deleteById(1);

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

@Test  
public void testSelect() {  
List<User2> users = mapper.selectList(null);  
}

==>  Preparing: SELECT id,name,age,email,manager_id,create_time,update_time,version,deleted FROM user2 WHERE deleted=0
==> Parameters: 
<==    Columns: id, name, age, email, manager_id, create_time, update_time, version, deleted
<==        Row: 2, 王狗蛋, 40, gd@baomidou.com, 1, 2021-03-28 13:12:40, null, 1, 0
<==        Row: 3, 王鸡蛋, 40, jd@baomidou.com, 2, 2021-03-28 13:12:40, null, 1, 0
<==        Row: 4, 王鸭蛋, 40, yd@baomidou.com, 2, 2021-03-28 13:12:40, null, 1, 0
<==        Row: 5, 王猪蛋, 40, zd@baomidou.com, 2, 2021-03-28 13:12:40, null, 1, 0
<==        Row: 6, 王软蛋, 40, rd@baomidou.com, 2, 2021-03-28 13:12:40, null, 1, 0
<==        Row: 7, 王铁蛋, 40, td@baomidou.com, 2, 2021-03-28 13:12:40, null, 1, 0
<==      Total: 6

@TableField(select = false)
private Integer deleted;

SELECT id,name,age,email,manager_id,create_time,update_time,version FROM user2 WHERE deleted=0

@TableLogic(value = "0", delval = "1")  
private Integer deleted;

public interface User2Mapper extends BaseMapper<User2> {  
@Select("select * from user2")  
List<User2> selectRaw();  
}

@Data
public class User2 implements Serializable {
    private Long id;
    private String name;
    private Integer age;
    private String email;
    private Long managerId;
    //自动填充
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    @TableField(fill = FieldFill.UPDATE)
    private Date updateTime;
    private Integer version;
    //逻辑删除 - '逻辑删除标识,0-未删除,1-已删除'
    @TableField(select = false)
//    @TableLogic(delval = "1",value = "0")
    private Integer deleted;
}

package tech.aistar.config;
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;
import java.time.LocalTime;
import java.util.Date;
import java.util.function.Supplier;
/**
 * 本类用来演示: 实现自动填充处理器
 *
 * @author: success
 * @date: 2021/6/3 9:59 上午
 */
@Component //需要注册到Spring容器中
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
//        this.strictFillStrategy(metaObject, "createTime", new Supplier<Object>() {
//            @Override
//            public Object get() {
//                return new Date();
//            }
//        });
        this.strictFillStrategy(metaObject, "createTime",Date::new);
    }
    @Override
    public void updateFill(MetaObject metaObject) {
         this.strictFillStrategy(metaObject,"updateTime",Date::new);
    }
}

@SpringBootTest
public class TestMyMetaObjectHandler {
    @Autowired
    private User2Mapper user2Mapper;
    /**
     * 测试自动填充 - createTime字段
     */
    @Test
    public void testInsert(){
        User2 user = new User2();
        user.setName("强老师");
        user.setAge(29);
        user.setEmail("yt@baomidou.com");
        user.setManagerId(2L);
        user2Mapper.insert(user);
    }
}

@Test
public void testUpdate(){
  User2 user2 = new User2();
  user2.setId(8L);
  user2.setName("平老师");
  user2Mapper.updateById(user2);
}

/**
     * 乐观锁插件 - 新版
  */
@Bean
public MybatisPlusInterceptor oPtimisticLockerInterceptor() {
  MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
  mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
  return mybatisPlusInterceptor;
}

//乐观锁- 支持的数据类型只有:int,Integer,long,Long,Date,Timestamp,LocalDateTime
@Version
private Integer version;

@Test
public void testLock(){
  // 假设这个version是先前查询时获得的
  int version=1;
  User2 user2 = new User2();
  user2.setId(1L);
  user2.setName("管管");
  user2.setVersion(version);
  user2Mapper.updateById(user2);
}

==>  Preparing: UPDATE user2 SET name=?, update_time=?, version=? WHERE id=? AND version=?
==> Parameters: 管管(String), 2021-06-08 09:10:44.678(Timestamp), 2(Integer), 1(Long), 1(Integer)
<==    Updates: 1

@Test  
public void testOpLocker() {  
User2 user = new User2();  
user.setId(8L);  
user.setVersion(1);  
user.setAge(2);  
// 第一次使用  
LambdaQueryWrapper<User2> wrapper = new LambdaQueryWrapper<>();  
wrapper.eq(User2::getName, "王一蛋");  
mapper.update(user, wrapper);  
// 第二次复用  
user.setAge(3);  
mapper.update(user, wrapper);  
}

<dependency>  
  <groupId>p6spy</groupId>  
  <artifactId>p6spy</artifactId>  
  <version>3.9.1</version>  
</dependency>

spring:
  datasource:
#    性能分析插件引入之后,需要更改此处驱动
    driver-class-name: com.p6spy.engine.spy.P6SpyDriver
    url: jdbc:p6spy:mysql://localhost:3306/dev?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8
    # url: jdbc:mysql://localhost:3306/dev?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8
#    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root

#3.2.1以上使用
modulelist=com.baomidou.mybatisplus.extension.p6spy.MybatisPlusLogFactory,com.p6spy.engine.outage.P6OutageFactory
#3.2.1以下使用或者不配置
#modulelist=com.p6spy.engine.logging.P6LogFactory,com.p6spy.engine.outage.P6OutageFactory
# 自定义日志打印
logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger
#日志输出到控制台
appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger
# 使用日志系统记录 sql
#appender=com.p6spy.engine.spy.appender.Slf4JLogger
# 设置 p6spy driver 代理
deregisterdrivers=true
# 取消JDBC URL前缀
useprefix=true
# 配置记录 Log 例外,可去掉的结果集有error,info,batch,debug,statement,commit,rollback,result,resultset.
excludecategories=info,debug,result,commit,resultset
# 日期格式
dateformat=yyyy-MM-dd HH:mm:ss
# 实际驱动可多个
#driverlist=org.h2.Driver
# 是否开启慢SQL记录
outagedetection=true
# 慢SQL记录标准 2 秒
outagedetectioninterval=2

Consume Time：8 ms 2021-06-08 09:30:35
 Execute SQL：select * from user

@Bean
public MybatisPlusInterceptor blockAttackInterceptor() {
  MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
  // 防止全表更新与删除
  // 针对 update 和 delete 语句
  interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
  return interceptor;
}

@Test
public void testUpdateAll(){
  User2 user2 = new User2();
  user2.setAge(100);
  //更新全表
  user2Mapper.update(user2,null);
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>tech.aistar</groupId>
        <artifactId>yeb-demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>tech.aistar</groupId>
    <artifactId>yeb-generator</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>yeb-generator</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--freemarker-->
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.4.1</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-boot-starter</artifactId>
            <version>3.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>swagger-bootstrap-ui</artifactId>
            <version>1.9.6</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

package tech.aistar.generator;
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class CodeGenerator {
    /**
        * <p>
        * 读取控制台内容
        * </p>
     */
    public static String scanner(String tip) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder help = new StringBuilder();
        help.append("请输入" + tip + "：");
        System.out.println(help.toString());
        if (scanner.hasNext()) {
            String ipt = scanner.next();
            if (StringUtils.isNotBlank(ipt)) {
                return ipt;
            }
        }
        throw new MybatisPlusException("请输入正确的" + tip + "！");
    }
    public static void main(String[] args) {
        // 代码生成器
        AutoGenerator mpg = new AutoGenerator();
        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        gc.setOutputDir(projectPath + "/yeb-generator/src/main/java");
        gc.setAuthor("亲爱的小管");
        // 打开输出目录
        gc.setOpen(false);
        // xml开启BaseResultMap
        gc.setBaseResultMap(true);
        // xml开启BaseColumnList
        gc.setBaseColumnList(true);
        //实体属性 Swagger2 注解
        gc.setSwagger2(true);
        mpg.setGlobalConfig(gc);
        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/yeb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai");
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("root");
        mpg.setDataSource(dsc);
        // 包配置
        PackageConfig pc = new PackageConfig();
//        pc.setModuleName(scanner("模块名"));
        pc.setParent("tech.aistar")
                .setEntity("pojo")
                .setMapper("mapper")
                .setService("service")
                .setServiceImpl("service.impl")
                .setController("controller");
        mpg.setPackageInfo(pc);
        // 自定义配置
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
                // to do nothing
            }
        };
        // 如果模板引擎是 freemarker
        String templatePath = "/templates/mapper.xml.ftl";
        // 如果模板引擎是 velocity
        // String templatePath = "/templates/mapper.xml.vm";
        // 自定义输出配置
        List<FileOutConfig> focList = new ArrayList<>();
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
                return projectPath + "/yeb-generator/src/main/resources/mapper/" +  tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
            }
        });
        /*
        cfg.setFileCreate(new IFileCreate() {
            @Override
            public boolean isCreate(ConfigBuilder configBuilder, FileType fileType, String filePath) {
                // 判断自定义文件夹是否需要创建
                checkDir("调用默认方法创建的目录，自定义目录用");
                if (fileType == FileType.MAPPER) {
                    // 已经生成 mapper 文件判断存在，不想重新生成返回 false
                    return !new File(filePath).exists();
                }
                // 允许生成模板文件
                return true;
            }
        });
        */
        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);
        // 配置模板
        TemplateConfig templateConfig = new TemplateConfig();
        // 配置自定义输出模板
        //指定自定义模板路径，注意不要带上.ftl/.vm, 会根据使用的模板引擎自动识别
        // templateConfig.setEntity("templates/entity2.java");
        // templateConfig.setService();
        // templateConfig.setController();
        templateConfig.setXml(null);
        mpg.setTemplate(templateConfig);
        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        // 数据库表映射到实体的命名策略
        strategy.setNaming(NamingStrategy.underline_to_camel);
        // 数据库表字段映射到实体的命名策略
        strategy.setColumnNaming(NamingStrategy.no_change);
//        strategy.setSuperEntityClass("你自己的父类实体,没有就不用设置!");
        // lombok
        strategy.setEntityLombokModel(true);
        // 生产restController
        strategy.setRestControllerStyle(true);
        // 公共父类
//        strategy.setSuperControllerClass("你自己的父类控制器,没有就不用设置!");
        // 写于父类中的公共字段
//        strategy.setSuperEntityColumns("id");
        strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));
        strategy.setControllerMappingHyphenStyle(true);
        strategy.setTablePrefix("t_");
        mpg.setStrategy(strategy);
        mpg.setTemplateEngine(new FreemarkerTemplateEngine());
        mpg.execute();
    }

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>tech.aistar</groupId>
    <artifactId>mybatis-plus-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mybatis-plus-demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

DROP TABLE IF EXISTS user;  
   CREATE TABLE user (  
     id BIGINT(20) PRIMARY KEY NOT NULL COMMENT '主键',  
     name VARCHAR(30) DEFAULT NULL COMMENT '姓名',  
     age INT(11) DEFAULT NULL COMMENT '年龄',  
     email VARCHAR(50) DEFAULT NULL COMMENT '邮箱',  
     manager_id BIGINT(20) DEFAULT NULL COMMENT '直属上级id',  
     create_time DATETIME DEFAULT NULL COMMENT '创建时间',  
     CONSTRAINT manager_fk FOREIGN KEY(manager_id) REFERENCES user (id)  
   ) ENGINE=INNODB CHARSET=UTF8;  
   INSERT INTO user (id, name, age ,email, manager_id, create_time) VALUES  
   (1, '大BOSS', 40, 'boss1@baomidou.com', NULL, '2021-03-22 09:48:00'),  
   (2, '李三儿', 30, 'boss2@baomidou.com', 1, '2021-01-22 09:48:00'),  
   (3, '黄小三', 35, 'boss3@baomidou.com', 2, '2021-01-22 09:48:00'),  
   (4, '三德子', 25, 'boss4@baomidou.com', 2, '2021-02-22 09:48:00'),  
   (5, '小菜', 23, 'boss5@baomidou.com', 2, '2021-02-22 09:48:00'),
   (6, '黄主任',23,NULL,5, '2021-02-22 09:48:00');

package tech.aistar.pojo;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
    * 本类用来演示: 用户实体类
 *
    * @author: success
    * @date: 2021/5/31 9:51 上午
 */
@Data
public class User implements Serializable {
    private Long id;
    private String name;
    private Integer age;
    private String email;
    private Long managerId;
    private Date createTime;
}

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/dev?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

package tech.aistar;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@MapperScan("tech.aistar.mapper")
@SpringBootApplication
public class MybatisPlusDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(MybatisPlusDemoApplication.class, args);
    }
}

package tech.aistar.mapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
/**
    * 本类用来演示:
 *
    * @author: success
    * @date: 2021/5/31 11:14 上午
 */
@SpringBootTest
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    /**
        * 测试 - 查询所有
     */
    @Test
    public void testFindAll(){
        userMapper.selectList(null).forEach(System.out::println);
    }
}

// 插入一条记录
int insert(T entity);

/**
  * 测试Insert方法
  */
@Test
public void testInsert(){
  User user = new User();
  user.setName("success");
  user.setAge(18);
  user.setEmail("849962874@qq.com");
  user.setCreateTime(new Date());
  user.setManagerId(2L);
  userMapper.insert(user);
}