MyBatisPlus

CREATE TABLE `user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
  `user_name` varchar(20) NOT NULL COMMENT '用户名',
  `password` varchar(20) NOT NULL COMMENT '密码',
  `name` varchar(30) DEFAULT NULL COMMENT '姓名',
  `age` int(11) DEFAULT NULL COMMENT '年龄',
  `address` varchar(100) DEFAULT NULL COMMENT '地址',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

insert  into `user`(`id`,`user_name`,`password`,`name`,`age`,`address`) values 
(1,'ruiwen','123','瑞文',12,'诺克萨斯'),
(2,'gailun','1332','盖伦',13,'德玛西亚'),
(3,'timu','123','提姆',22,'约德尔'),
(4,'daji','1222','亚索',221,'艾欧尼亚');

<!-- SpringBoot 的父依赖 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.0</version>
</parent>

<!-- Maven 依赖 -->
<dependencies>
    <!-- SpringBoot starter依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- SpringBoot test测试程序依赖; -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!-- Lombok 依赖,为了方便快速加载实体类~ -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>

    <!-- 使用Mybatis-plus 依赖;
                加载了Mybatis-plus 依赖,就可以不需要Mybatis 依赖了, plus依赖中默认集成了 Mybatis依赖;
        -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.4.3</version>
    </dependency>
    <!-- mysql的驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

//SpringBoot 启动类注解~
@SpringBootApplication
public class SpringBootRun {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootRun.class);
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String address;
}

@Mapper
//@Mapper 注解,使当前的Mapper 接口,被Spring进行管理,不然需要在,启动类上声明 @MapperScan("com.wsm.mapper") 类扫描指定包下,mapper接口文件;
public interface UserMapper  extends BaseMapper<User> {
    //Mapper 接口 extends集成 BaseMapper<T> 泛型对应的实体类;
    //  Ctrl+右击, 进入BaseMapper 中可以看到, MP 默认给对应实体类提供好的实现方法();
    //  增删改查... 即各种的, 重载 CRUD 的操作;
    
    //如果,BaseMapper<T> 中,没有提供的,后面还可以在,该 xxxMapper 文件中, 自定义自己需要的方法();
}

spring:
  # 配置SpringBoot 连接的数据源,注意 这里的Mysql连接 用户名 密码 要根据自己的实际情况来~
  datasource:
    url: jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=utf-8&serverTimezone=UTC
    username: root
    password: ok
    driver-class-name: com.mysql.cj.jdbc.Driver

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.5.0)

/* MP的测试类; **/
@SpringBootTest
//@SpringBootTest JUnit等其他测试框架结合起来，提供了便捷高效的测试手段.
//使用@SpringBootTest后，Spring将加载所有被管理的bean，基本等同于启动了整个服务，此时便可以开始功能测试. 需要引入: spring-boot-starter-test 依赖;
public class MPTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectList(){
        System.out.println("测试 selectList(null); 查询全部!");
            // selectList(queryWrapper); 参数需要是一个 查询添加Wrapper; 不设置,则无条件查询全部！

        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }
}

# MP 参数设置:
mybatis-plus:
  global-config:
    db-config:
      # 设置数据库映射 实体时候添加的 前缀;
      table-prefix: tb_

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

mybatis-plus:
  configuration:
    # 设置MP 打印SQL 语句日志;
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

// insert(); 新增用户
@Test
public void testInsert(){
    User user = new User();
    user.setName("wsm");
    user.setAge(540);
    user.setPassword("qwer");
    user.setUserName("wsm");
    user.setAddress("皮尔及沃特");

    // 讲创建的对象,新增入库,并返回影响行数;
    int insert = userMapper.insert(user);
    // 判断影响行数,是否新增成功！
    if(insert >0)
        System.out.println("新增成功");
    else
        System.out.println("新增失败");
}

// deleteById(); 根据id 删除数据;
@Test
public void testDelByid(){
    // deleteById(Serializable id);
    // Java 数值类型 继承了 Number抽象类 实现了 Serializable序列化接口,所以传入一个 Serializable对象;
    int del = userMapper.deleteById(1);
    // 判断影响行数,是否删除成功！
    if(del >0)
        System.out.println("删除成功");
    else
        System.out.println("删除失败");
}

// deleteBatchIds(Collection); 根据 id 集合,批量删除数据！
@Test
public void testDelBat(){
    List<Integer> ids = new ArrayList<>();
    ids.add(2);
    ids.add(3);
    ids.add(4);
    // 批量删除 2 3 4 主键列的数据;
    int del = userMapper.deleteBatchIds(ids);
    // 判断影响行数,是否删除成功！
    if(del >0)
        System.out.println("批量删除成功");
    else
        System.out.println("批量删除失败");
}

// deleteByMap(Map); 根据传入Map 指定的K作为列名和V作为列值进行等值匹配查找;
@Test
public void testDelByMap(){
    HashMap<String, Object> map = new HashMap<>();
    map.put("name","wsm");
    map.put("age",540);
    // 删除 name = wsm age = 540 的数据;
    int del = userMapper.deleteByMap(map);
    // 判断影响行数,是否删除成功！
    if(del >0)
        System.out.println("删除匹配的数据");
    else
        System.out.println("未删除数据");
}

// updateByid(T) 根据传入对象,id属性来修改对应数据的对应字段值...
@Test
public void updByid(){
    User user = new User();
    user.setId(2L);
    user.setUserName("wsm");
    // 修改数据库 id=2 的数据,user_name 值为wsm 其它属性未赋值,数据库不会改动~
    int upd = userMapper.updateById(user);
    // 判断影响行数,是否修改成功！
    if(upd >0)
        System.out.println("数据修改成功!");
    else
        System.out.println("数据修改失败!");
}

// 假设name变量是一个外部传入的参数
String name = ""; 
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.like(StringUtils.hasText(name), "name", name);	

// 仅当 StringUtils.hasText(name) 为 true 时, 会拼接这个like语句到WHERE中
// 其实就是对下面代码的简化
if (StringUtils.hasText(name)) {
	wrapper.like("name", name);
}

// StringUitils.hasText(""); 	里面的值为 null 、"" 、 " ",那么返回值为false... 
// 即：上面的表示,name 不存在则不加该条件, 当然判断是否成立的方式有很多: Lambda函数式接口...

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
between		相当于SQL中的BETWEEN AND 	
			between("age", 18, 30) ---> age between 18 and 30  (18 ≤ age ≥ 30)
notBetween 	相当于between 取反
			notBetween("age", 18, 30) ---> age not between 18 and 30
like		模糊匹配
			like("name", "王") ---> name like '%王%'
notLike 	模糊匹配取反
			notLike("name", "王") ---> name not like '%王%'
likeRight	模糊匹配右半边
			likeRight("name", "王") ---> name like '王%'
likeLeft	模糊匹配左半边
			likeLeft("name", "王") ---> name like '%王'
isNull 		判断字段为空的匹配
			isNull("name") ---> name is null
isNotNull	字段不为空的匹配
			isNotNull("name") ---> name is not null
and			嵌套
			and(i -> i.eq("name", "李白").ne("status", "活着")) ---> and (name = '李白' and status <> '活着')
or			拼接
			eq("id",1).or().eq("name","老王") ---> id = 1 or name = '老王'
in					
			in("age",{1,2,3})--->age in (1,2,3)

groupBy		分组
			groupBy("id", "name")--->group by id,name

orderByAsc 	正排序
			orderByAsc("id", "name")--->order by id ASC,name ASC

orderByDesc 倒排
			orderByDesc("id", "name")--->order by id DESC,name DESC

SELECT 
	id,user_name,PASSWORD,NAME,age,address 
FROM 
	tb_user 
WHERE 
	age > 18 or address like 'tb_德玛%'

/** AbstractWrapper 使用 **/
@Test
public void testAbsWra(){
    QueryWrapper query = new QueryWrapper();
    query.gt("age", 18);
    query.or();
    query.likeRight("address", "tb_德玛");
    // 查询传入 wrapper 条件构造器,查询: 年龄大于18 或 地址是 tb_德玛 开头的;
    List<User> users = userMapper.selectList(query);
    users.forEach(System.out::println);
}

SELECT id,`name`
FROM tb_user 
WHERE age > 18

// select(String... sqlSelect) 方法的指定要查询的列名
public void testQueryWra1(){
    // 创建QueryWrapper<T> 实例;
    QueryWrapper<User> query = new QueryWrapper<>();
    // .select('列1','列2',...); 指定要查询的列, QueryWrapper支持链式编程...
    query.select("id","name").gt("age", 18);
    // 传入QueryWrapper 开始查询~
    List<User> users = userMapper.selectList(query);
    users.forEach(System.out::println);
}

SELECT id,user_name,`name`,age,address FROM tb_user WHERE age > 18

// select(Class<T> entityClass, Predicate<TableFieldInfo> predicate)
@Test
public void testQueryWra2(){
    // 创建QueryWrapper<T> 实例;
    QueryWrapper<User> query = new QueryWrapper<>();

    // .select(类对象,Predicate); 内部类实现;
    //        query.select(User.class, new Predicate<TableFieldInfo>() {
    //            @Override
    //            public boolean test(TableFieldInfo tableFieldInfo) {
    //                return !"password".equals(tableFieldInfo.getColumn());
    //            }
    //        }).gt("age", 18);

    // .select(类对象,Predicate); 支持使用Lambda表达式实现;
    // Predicate中的test(); 方法返回 boolean类型, 程序会循环对每个字段进行比较,为 true 的才会查询该列~
    query.select(User.class,u-> !"password".equals(u.getColumn())).gt("age", 18);
    // 传入QueryWrapper 开始查询~
    List<User> users = userMapper.selectList(query);
    users.forEach(System.out::println);
}

-- 小于等于 18 岁的用户,都更新为 540;
UPDATE tb_user SET age = 540 WHERE age <= 18

/** UpdateWrapper使用 **/
@Test
public void tetsUpdWra(){
    UpdateWrapper<User> updwra = new UpdateWrapper<>();
    // 小于等于 18 岁的用户,都更新为 540
    updwra.le("age",1).set("age","540");
    // 传入UpdateWrapper 开始查询~
    int update = userMapper.update(null, updwra);
    // 判断影响行数,是否修改成功！
    if(update >0)
        System.out.println("数据修改成功!");
    else
        System.out.println("数据修改失败!");
}

SELECT id,user_name,`name`,age,address FROM tb_user WHERE age > 18

/** LambdaQueryWrapper使用 **/
// Lamdba 表达式实现的
@Test
public void testQueryWralmd(){
    LambdaQueryWrapper<User> lam = new LambdaQueryWrapper<>();
    // gt(User::getAge,18); 使用方法引用的形式,对参数进行绑定,避免了编译期不确定数据库列,而造成的失误~
    lam.select(User.class,u-> !"password".equals(u.getColumn())).gt(User::getAge,18);
    // 传入QueryWrapper 开始查询~
    List<User> users = userMapper.selectList(lam);
    users.forEach(System.out::println);
}

@Mapper
//@Mapper 注解,使当前的Mapper 接口,被Spring进行管理,不然需要在,启动类上声明 @MapperScan("com.wsm.mapper") 类扫描指定包下,mapper接口文件;
public interface UserMapper  extends BaseMapper<User> {
    //Mapper 接口 extends集成 BaseMapper<T> 泛型对应的实体类;
    //  Ctrl+右击, 进入BaseMapper 中可以看到, MP 默认给对应实体类提供好的实现方法();
    //  增删改查... 即各种的, 重载 CRUD 的操作;

    //如果,BaseMapper<T> 中,没有提供的,后面还可以在,该 xxxMapper 文件中, 自定义自己需要的方法();

    /** 自定义方法 **/
    // 根据id查询对象;
    User findMyUser(Long id);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<!-- 指定映射的mapper -->
<mapper namespace="com.wsm.mapper.UserMapper">
    <!-- 指定sql 对应的方法名,返回的结果集类型; -->
    <select id="findMyUser" resultType="com.wsm.entity.User">
       select * from user where id = #{id}
    </select>
</mapper>

mybatis-plus:
  # 设置扫描的sql映射文件,加载至环境中;
  mapper-locations: classpath*:/mapper/**/*.xml

/** 测试自定义方法查询结果 **/
@Test
public void testfindMyUser(){
    User myUser = userMapper.findMyUser(1L);
    System.out.println(myUser);
}

@Mapper
//@Mapper 注解,使当前的Mapper 接口,被Spring进行管理,不然需要在,启动类上声明 @MapperScan("com.wsm.mapper") 类扫描指定包下,mapper接口文件;
public interface UserMapper  extends BaseMapper<User> {
    //Mapper 接口 extends集成 BaseMapper<T> 泛型对应的实体类;
    //  Ctrl+右击, 进入BaseMapper 中可以看到, MP 默认给对应实体类提供好的实现方法();
    //  增删改查... 即各种的, 重载 CRUD 的操作;

    //如果,BaseMapper<T> 中,没有提供的,后面还可以在,该 xxxMapper 文件中, 自定义自己需要的方法();

    /** 自定义方法 **/
    // 根据id查询对象;
    User findMyUser(Long id);

    // 自定义方法,使用MP 的Wrapper
    List<User> findUsers(@Param(Constants.WRAPPER) Wrapper<User> wrapper);  //wrapper 是MP包下的依赖~
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<!-- 指定映射的mapper -->
<mapper namespace="com.wsm.mapper.UserMapper">
    <!-- 指定sql 对应的方法名,返回的结果集类型; -->
    <select id="findMyUser" resultType="com.wsm.entity.User">
       select * from user where id = #{id}
    </select>

    <!-- 指定sql 对应的方法名,返回的结果集类型; -->
    <select id="findUsers" resultType="com.wsm.entity.User">
       select * from user  ${ew.customSqlSegment}
    </select>
</mapper>

/** 自定义方法查询 +MP的 wrapper 条件构造 **/
@Test
public void testfindusers(){
    // 定义QueryWrapper 构造器,查询 age 大于 18 的数据;
    QueryWrapper<User> query = new QueryWrapper<>();
    query.gt("age", 18);
    // 调用 自定义的方法(wrapper 参数);
    List<User> users = userMapper.findUsers(query);
    users.forEach(System.out::println);
}

/** MP 分页,配置类 */
// @Configuration 将类加载至Spring容器中去;
@Configuration
public class MPPageConfig {
    /**
     * 3.4.0之前的版本
     * @return
     */
//    @Bean
//    public PaginationInterceptor paginationInterceptor(){
//        return  new PaginationInterceptor();
//    }

    /**
     * 3.4.0之后版本
     * @return
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mybatisPlusInterceptor;
    }
}

/** selectPage(); Mapper 单表分页 */
@Test
public void testPage(){
    // 定义分页对象
    Page<User> userPage = new Page<>();
    // 设置分页参数
    // 每页行数
    userPage.setSize(2);
    // 当前查询的第几页
    userPage.setCurrent(1L);	//后台会自动根据 每页行 第几页 计算拼接limit sql;

    // 执行分页查询 selectPage(page,wrapper); 两个参数: 分页对象,条件构造器;
    userMapper.selectPage(userPage, null);
    
    // 返回的分页对象,就算传入的对象 userPage
    System.out.println("获取当前页的数据");
    System.out.println(userPage.getRecords());
    System.out.println("获取总记录数");
    System.out.println(userPage.getTotal());
    System.out.println("当前页码");
    System.out.println(userPage.getCurrent());
}

CREATE TABLE `orders` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `price` int(11) DEFAULT NULL COMMENT '价格',
  `remark` varchar(100) DEFAULT NULL COMMENT '备注',
  `user_id` int(11) DEFAULT NULL COMMENT '用户id',
  `update_time` timestamp NULL DEFAULT NULL COMMENT '更新时间',
  `create_time` timestamp NULL DEFAULT NULL COMMENT '创建时间',
  `version` int(11) DEFAULT '1' COMMENT '版本',
  `del_flag` int(1) DEFAULT '0' COMMENT '逻辑删除标识,0-未删除,1-已删除',
  `create_by` varchar(100) DEFAULT NULL COMMENT '创建人',
  `update_by` varchar(100) DEFAULT NULL COMMENT '更新人',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

/*Data for the table `orders` */

insert  into `orders`
(`id`,`price`,`remark`,`user_id`,`update_time`,`create_time`,`version`,`del_flag`,`create_by`,`update_by`) values 
(1,2000,'无',2,'2021-08-24 21:02:43','2021-08-24 21:02:46',1,0,NULL,NULL),
(2,3000,'无',3,'2021-08-24 21:03:32','2021-08-24 21:03:35',1,0,NULL,NULL),
(3,4000,'无',2,'2021-08-24 21:03:39','2021-08-24 21:03:41',1,0,NULL,NULL);

@Data
@NoArgsConstructor
@AllArgsConstructor
// 因为设置了全局的表前缀 tb_ 为了方便操作,@TableName 指定表;
@TableName("orders")
public class Orders {
    // Orders 表属性:
    private Long id;
    private Integer price;
    private String remark;
    private Integer userId;
    private LocalDateTime updateTime;
    private LocalDateTime createTime;
    private Integer version;
    private Integer delFlag;

    // 多表查询,User表扩展属性;
    // MP 默认的CRUD 不对该属性进行sql映射,自定义Mapper 可以通过同名/取别名 自动映射;
    @TableField(exist = false)
    public String userName;
}

@Mapper
public interface OrdersMapper extends BaseMapper<Orders> {
    // 自定义多表分页方法
    public Page<Orders> selPageOrdUs(Page<Orders> page);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<!-- 指定映射的mapper -->
<mapper namespace="com.wsm.mapper.OrdersMapper">

    <!-- MP多表分页 -->
    <select id="selPageOrdUs" resultType="com.wsm.entity.Orders">
        SELECT
            o.*,u.`user_name` as userName
        FROM  orders o
        INNER JOIN tb_user u
        ON u.id = o.user_id
    </select>
</mapper>

/** selectPage(); Mapper 多表分页 */
//定义 OrdersMapper 对象;
@Autowired        
OrdersMapper ordersMapper;

@Test
public void testselPageOrdUs(){ 
    // 定义MP 分页对象,并设置分页属性
    Page<Orders> ordersPage = new Page<>();
    // 每页行,当前页
    ordersPage.setSize(2);
    ordersPage.setCurrent(1);

    // 进行查询,返回分页对象, 因为: 引用类型的实参改变形参会受影响~所以, ordersPage == ordersIPage
    Page<Orders> ordersIPage = ordersMapper.selPageOrdUs(ordersPage);
    System.out.println("ordersPage == ordersIPage是否相等:"+(ordersPage == ordersIPage));
    // 返回的结果
    System.out.println("获取总记录数");
    System.out.println(ordersIPage.getTotal());
    System.out.println("获取当前页的数据");
    System.out.println(ordersIPage.getRecords());
}

ordersPage == ordersIPage是否相等:true
获取总记录数
3
获取当前页的数据
[Orders(id=1, price=2000, remark=无, userId=2, updateTime=2021-08-24T21:02:43, createTime=2021-08-24T21:02:46, version=1, delFlag=0, userName=gailun), Orders(id=3, price=4000, remark=无, userId=2, updateTime=2021-08-24T21:03:39, createTime=2021-08-24T21:03:41, version=1, delFlag=0, userName=gailun)]

// Service接口 继承MP的 IService<T>  T泛型,要CRUD对应映射的实体;
public interface UserService extends IService<User> {       }

// Spring注解,表示改类是一个 Service 业务逻辑类,并交给Spring容器管理;
@Service
// ServiceImpl 是 Service 的实现
// 继承MP 的ServiceImpl<对应的Mapper,映射表的实体类> 
// 因为是 Service的实现, 实现对应的接口 implement Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {   }

/** Service 的CRUD **/
// 从Spring容器中获取Service对象;
@Autowired
UserService userService;
// 只获取匹配的第一条数据;
@Test
public void testGetOne(){
    LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery();
    wrapper.gt(User::getAge, 28);
    User one = userService.getOne(wrapper, false); // 第二参数指定为false,使得在查到了多行记录时,不抛出异常,而返回第一条记录
    System.out.println(one);
}

// Service接口 继承MP的 IService<T>  T泛型,要CRUD对应映射的实体;
public interface UserService extends IService<User> {
    //自定义Service 实现:
    List<User> selall();
}

// Spring注解,表示改类是一个 Service 业务逻辑类,并交给Spring容器管理;
@Service
// ServiceImpl 是 Service 的实现
// 继承MP 的ServiceImpl<对应的Mapper,映射表的实体类>
// 因为是 Service的实现, 实现对应的接口 implement Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

    // 创建UserMapper 对象实例;
    @Autowired
    UserMapper userMapper;

    @Override
    public List<User> selall() {
        // 直接调用Mapper 的查询全部~ 当然Service业务逻辑层,可以写很多更加复杂的操作...
        return userMapper.selectList(null);
    }
}

<!-- Mybatsi-Plus 代码生成器依赖: -->
<!--mybatisplus代码生成器-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.4.1</version>
</dependency>
<!--模板引擎-->
<dependency>
    <groupId>org.freemarker</groupId>
    <artifactId>freemarker</artifactId>
</dependency>

public class GeneratorTest {
	@Test
	public void generate() {
		AutoGenerator generator = new AutoGenerator();
        
		// 全局配置
		GlobalConfig config = new GlobalConfig();
		String projectPath = System.getProperty("user.dir");
		
        // 设置输出到的目录: 可以更改为任何路径 D盘 C盘...
        // config.setOutputDir("D:/MP");
		config.setOutputDir(projectPath + "/src/main/java");
        // 生成的作者名
		config.setAuthor("wsm");
		// 生成结束后是否打开文件夹
		config.setOpen(false);
		// 全局配置添加到 generator 上
		generator.setGlobalConfig(config);
		// 数据源配置： 配置自己的数据库要生成的数据库 用户/密码 
		DataSourceConfig dataSourceConfig = new DataSourceConfig();
		dataSourceConfig.setUrl("jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=utf-8&serverTimezone=UTC");
		dataSourceConfig.setDriverName("com.mysql.cj.jdbc.Driver");
		dataSourceConfig.setUsername("root");
		dataSourceConfig.setPassword("ok");
		// 数据源配置添加到 generator
		generator.setDataSource(dataSourceConfig);

		// 包配置, 生成的代码放在哪个包下
		PackageConfig packageConfig = new PackageConfig();
		packageConfig.setParent("com.wsm");
		// 包配置添加到 generator
		generator.setPackageInfo(packageConfig);
        
		// 策略配置
		StrategyConfig strategyConfig = new StrategyConfig();
		// 下划线驼峰命名转换
		strategyConfig.setNaming(NamingStrategy.underline_to_camel);
		strategyConfig.setColumnNaming(NamingStrategy.underline_to_camel);
		// 开启lombok,生成的实体类上面就会又 lombok注解;
		strategyConfig.setEntityLombokModel(true);
		// 开启RestController
		strategyConfig.setRestControllerStyle(true);
		generator.setStrategy(strategyConfig);
		generator.setTemplateEngine(new FreemarkerTemplateEngine());

        // 开始生成
		generator.execute();
	}
}

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    // 新增时候触发,并设置新增时候对应数据要赋的值
    @Override
    public void insertFill(MetaObject metaObject) {
        this.setFieldValByName("createTime", LocalDateTime.now(), metaObject);
        this.setFieldValByName("updateTime", LocalDateTime.now(), metaObject);
    }

    // 修改时候触发,并设置修改时候对应数据要赋的值
    @Override
    public void updateFill(MetaObject metaObject) {
        this.setFieldValByName("updateTime", LocalDateTime.now(), metaObject);
    }
}

/** MP 自动填充： **/
@Test
public void testinsertOrd(){
    // 创建新增对象
    Orders orders = new Orders();
    orders.setPrice(1000);
    orders.setRemark("无");
    orders.setUserId(2);
    // 执行新增
    int insert = ordersMapper.insert(orders);
    if(insert>0)
        System.out.println("新增成功");
    else
        System.out.println("新增失败");
}

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: delFlag  	# 全局逻辑删除的实体字段名, 3.3.0配置后可以不添加注解,之前的还需要添加注解 @Tablelogic)
      logic-delete-value: 1 		# 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 	# 逻辑未删除值(默认为 0)

/** MP 逻辑删除 **/
@Test
public void delOrd(){
    // 配置了逻辑删除之后,直接调用MP 的删除方法就是进行逻辑删除了！ 注意: 自定义sql的操作还需要自己完成注意！
    int i = ordersMapper.deleteById(1);
    if(i>0)
        System.out.println("逻辑删除成功");
    else
        System.out.println("逻辑删除失败");
}

@Configuration
public class MybatisPlusConfig {
    /**
     * 旧版
     */
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
    
    /**
     * 新版
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return mybatisPlusInterceptor;
    }
}

// 添加乐观锁的注解,使用MP 的方式实现乐观锁 保证数据安全;
// version字段，类型只支持int，long，Date，Timestamp，LocalDateTime
@Version
private Integer version;

/** MP 乐观锁 */
// 操作前要去抱必须获取到数据最新的 version: 先查询在修改:
@Test
public void testupdVer(){
    // 先查询:
    Orders orders = ordersMapper.selectById(1);
    // 设置更新列
    orders.setPrice(123);
    System.out.println(orders);

    // 修改: 乐观锁插件仅支持`updateById(id)`与`update(entity, wrapper)`方法
    int i = ordersMapper.updateById(orders);
    if(i>0)
        System.out.println("修改成功,version+1");
    else
        System.out.println("修改失败");
}

查询
==>  Preparing: SELECT id,price,remark,user_id,update_time,create_time,version,del_flag,create_by,update_by FROM orders WHERE id=? AND del_flag=0
==> Parameters: 1(Integer)
<==    Columns: id, price, remark, user_id, update_time, create_time, version, del_flag, create_by, update_by
<==        Row: 1, 2000, 无, 2, 2021-08-24 21:02:43, 2021-08-24 21:02:46, 1, 0, null, null
<==      Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@772caabe]
Orders(id=1, price=123, remark=无, userId=2, updateTime=2021-08-24T21:02:43, createTime=2021-08-24T21:02:46, version=1, delFlag=0, createBy=null, updateBy=null, userName=null)
Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@51da32e5] was not registered for synchronization because synchronization is not active

修改
JDBC Connection [HikariProxyConnection@2069678360 wrapping com.mysql.cj.jdbc.ConnectionImpl@4538856f] will not be managed by Spring
==>  Preparing: UPDATE orders SET price=?, remark=?, user_id=?, update_time=?, create_time=?, version=?, update_by=? WHERE id=? AND version=? AND del_flag=0
==> Parameters: 123(Integer), 无(String), 2(Integer), 2022-01-07T00:54:39.578(LocalDateTime), 2021-08-24T21:02:46(LocalDateTime), 2(Integer), www(String), 1(Long), 1(Integer)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@51da32e5]
修改成功,version+1