MyBatisPlus使用

快速入门

• 实体

  package com.kuang.pojo;
  import lombok.Al1ArgsConstructor;
  import lombok.Data;
  import lombok.NoArgsConstructor;
  
  @Data
  @AllArgsConstructor
  @NoArgsConstructor
  public class User {
      //对应数据库的主键(uuid、自增id、雪花算法、redis、zookeeper)
  	private Long id;
  	private String name;
  	private Integer age;
  	private String email;
  }

• mapper接口

  package com.eshop.modules.business.service.mapper;
  
  import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  import com.eshop.modules.business.pojo.StoreProductRelation;
  
  
  public interface UserMapper extends BaseMapper<User> {
  
  }

• 扫描

  找到mapper包的文件夹

  

CRUD扩展

插入操作

Insert

User user = new User();
user.setName("name");
user.setAge(2);
user.setEmail("123@123.com");
userMapper.insert(user);

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

主键生成策略

雪花算法：

snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID

主键自增

1、实体类字段上 @TableId(type = IdType.AUTO)

2、数据库字段一定要是自增！

@TableId(type = IdType.AUTO)

更新操作

User user = new User();
user.setId(6L);
user.setAge(123);
//updateById()参数是一个对象
userMapper.updateById(user);

自动填充

创建时间、修改时间 等自动化完成

阿里巴巴开发手册：所有数据库表：gmt_create、gmt_modified 几乎所有的表都要配置上！且需要自动化

方式一：数据库级别(不推荐)

1、在表中新增字段：create_time,update_time

方式二：代码级别

1、在实体类中添加注解

@TableField(fill = FieldFill.INSERT) @TableField(fill = FieldFill.UPDATE)

	@TableField(fill = FieldFill.INSERT)
    private Date createTime;
    @TableField(fill = FieldFill.UPDATE)
    private Date updateTime;

2、编写处理器来处理注解

/**
 * @author reinf
 * 对数据库创建和更新时间自动填充策略
 */
@Slf4j
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "createdAt", Date.class, new Date());
        this.strictInsertFill(metaObject, "updatedAt", Date.class, new Date());
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "updatedAt", Date.class, new Date());
    }
}

乐观锁

乐观锁：十分乐观，总是认为不会出现问题，无论干什么都不去上锁！如果出现问题，再次更新值测试

悲观锁：十分悲观，总是认为总是出现问题，无论干什么都会上锁！再去操作！

乐观锁实现方式：

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

乐观锁：1、先查询，获得版本号 version = 1
-- A
update user set name = "aaa", version = version + 1
where id = 2 and version = 1

-- B 线程抢先完成，这时候 version = 2，会导致 A 修改失败！
update user set name = "aaa", version = version + 1
where id = 2 and version = 1

条件构造器

假设有张User表

@Data
public class User{
    private Long id;
    private Long name;
    private String type;
    private String age;
}

QueryWrapper

最基础的使用方式

//查询条件构造器
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("name","Reinforce");
//查询操作
List<User> userItems = UserMapper.selectList(wrapper);
>>>>
    List<User> userItems = UserMapper.selectList(new QueryWrapper<User>()
                                                 .eq("name","Reinforce"));

然后我们可以引入lambda，避免我们在代码中写类似的于name的硬编码

QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.lambda().eq(User::getName,"Reinforce");
List<User> userItems = UserMapper.selectList(wrapper);
>>>>
    List<User> userItems = UserMapper.selectList(new QueryWrapper<User>()
                                                 .eq(User::getName,"Reinforce"));

LambdaQueryWrapper

为了简化lambda的使用，我们可以改写成LambdaQueryWrapper构造器，语法如下：

//查询条件构造器
LambdaQueryWrapper<User> wrapper = new QueryWrapper<User>().lambda();
wrapper.eq(User::getName,"Reinforce");
//查询操作
List<User> userItems = UserMapper.selectList(wrapper);
>>>>
    List<User> userItems = UserMapper.selectList(new LambdaQueryWrapper<User>()
                                                 .eq(User::getName,"Reinforce"));

可以再次将QueryWrapper<BannerItem>.lambda()简化

//查询条件构造器
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getName,"Reinforce");
//查询操作
List<User> userItems = UserMapper.selectList(wrapper);
>>>>
    List<User> userItems = UserMapper.selectList(new LambdaQueryWrapper<User>()
                                                 .eq(User::getName,"Reinforce"));

LambdaQueryChainWrapper

链式查询的方式，和上面的代码效果一样。

User user = new LambdaQueryChainWrapper<>(UserMapper)
    .eq(User::getName,"name").one();

//如果只想查询一条记录，例如通过id查询某条记录的详情，使用.one()即可，例如
List<User> userList = new LambdaQueryChainWrapper<>(UserMapper)
    .eq(User::getName,"name").list();

例子

    @Test
    void TestQueryWrapperSelect() {
        //1、条件用法
        List<User> userList = userMapper.selectList(new QueryWrapper<User>()
                .like("email", "24252")
                .between("age", 20, 22)
                .or()
                .eq("name", "zcx")
        );
        System.out.println("userList:" + userList);

        //2、排序用法
        List<User> users = userMapper.selectList(new QueryWrapper<User>()
                .eq("nick_name", "xx")
                .orderByAsc("age")  //升序
//                .orderByDesc("age") //降序
                .last("limit 0,3") //last用法：在sql末尾添加sql语句，有sql注入风险
        );
        System.out.println("users:"+users);

    }

	@Test
    void TestLambdaQueryWrapper() {
        //1、查询单条
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getName,"liangd1");
        User selectOne = userMapper.selectOne(queryWrapper);
        System.out.println(selectOne);

        //2、查询list以及统计条数
        queryWrapper.eq(User::getName, "zcx");
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println("userList:" + userList);
        Integer result = userMapper.selectCount(queryWrapper);
        System.out.println("result:" + result);
    }

@Test
    void TestLambdaQueryChainWrapper() {
        //1、eq查询单条
        User one = new LambdaQueryChainWrapper<>(userMapper)
                .eq(User::getName, "liangd1")
                .one();
        System.out.println("UserOne:" + one);

        //2、查询list
        List<User> users = new LambdaQueryChainWrapper<>(userMapper)
                .eq(User::getName, "zcx")
                .list();
        System.out.println("UserList:" + users);

        //3、模糊查询
        List<User> LikeList = new LambdaQueryChainWrapper<>(userMapper)
                .like(User::getEmail, "test")
                .list();
        System.out.println("LikeUser:" + LikeList);
    }