Mybatis-plus学习笔记_idtype.assign_uuid

Mybatis-plus

id设置的值

1.ASSIGN_ID（雪花算法）

如果不设置 type 值，默认则使用 IdType.ASSIGN_ID 策略（自 3.3.0 起）。该策略会使用雪花算法自动生成主键 ID，主键类型为 Long 或 String（分别对应 MySQL 的表字段为 BIGINT 和 VARCHAR）

@Data
public class UserInfo {
    //指定主键生成策略使用雪花算法（默认策略）
    @TableId(type = IdType.ASSIGN_ID)
    private Long id;
    private String userName;
    private String passWord;
}
1
2
3
4
5
6
7
8

2.ASSIGN_UUID（不含中划线的UUID）

如果使用 IdType.ASSIGN_UUID 策略，则会自动生成不含中划线的 UUID 作为主键。主键类型为 String，对应 MySQL 的表字段为 VARCHAR(32)

@Data
public class UserInfo {
    //指定主键生成策略为不含中划线的UUID
    @TableId(type = IdType.ASSIGN_UUID)
    private String id;
    private String userName;
    private String passWord;
}
1
2
3
4
5
6
7
8

3.AUTO（数据库 ID 自增）

对于像 MySQL 这样的支持主键自动递增的数据库，我们可以使用 IdType.AUTO 策略。

@Data
public class UserInfo {
    //指定主键使用数据库ID自增策略
    @TableId(type = IdType.AUTO)
    private Integer id;
    private String userName;
    private String passWord;
}
1
2
3
4
5
6
7
8

4.NONE（无状态）

如果使用 IdType.NONE 策略，表示未设置主键类型（注解里等于跟随全局,全局里约等于 INPUT）

5.全局策略配置

mybatis-plus.global-config.db-config.id-type=auto
1

配置文件

如果数据库中所有表都有个表名前缀，比如我们想让 t_user_info 表仍然对应 UserInfo 实体类，可以添加如下全局配置设置表名前缀：

mybatis-plus.global-config.db-config.table-prefix=t_
1

实体类上的注解，如实体类user名字，数据库的数据表是t_user加上这个就行

注解类

@TableName

除了上面两种全局配置方法外，我们还可以使用 @TableName 表名注解指定当前实体类对应的表名，比如下面 UserInfo 实体类对应表名为 user：

@Data
@TableName(value = "user")
public class UserInfo {
    private Integer id;
    private String userName;
    private String passWord;
1
2
3
4
5
6

@TableId和 @TableField

除了全局配置方法外，我们还可以使用 @TableId 注解（标注在主键上）和 @TableField 注解（标注在其他成员属性上）来指定对应的字段名：

@Data
public class UserInfo {
    @TableId(value = "uuid")
    private Integer id;
    @TableField(value = "uname")
    private String userName;
    @TableField(value = "pword")
    private String passWord;
}
1
2
3
4
5
6
7
8
9

1.设置模糊查询@TableField

@Data
public class UserInfo {
    private Integer id;
    @TableField(condition = SqlCondition.LIKE)
    private String userName;
    private String passWord;
    private Integer age;
}
1
2
3
4
5
6
7
8

函数

select

1.selectById（根据 id 查询一条记录）

@RestController
public class HelloController {
 
    @Autowired
    UserInfoMapper userInfoMapper;
 
    @RequestMapping("/test")
    public void test(){
        // 根据id查询数据
        UserInfo user = userInfoMapper.selectById(2);
        System.out.println(user);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

2.selectOne（使用查询构造器，查询一条记录）：

注意：是数据库中符合传入条件的记录有多条，那就不能用这个方法，会报错。

(1)查询前我们需要先创建相应的 QueryWrapper，通过自己写表中相应的属性来构造 where 条件：

// 查询条件：名字中包含'ha'并且年龄小于40
QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<>();
queryWrapper.like("user_name","ha").lt("age",40);
// 开始查询
UserInfo user = userInfoMapper.selectOne(queryWrapper);
System.out.println(user);
1
2
3
4
5
6

（2）除了使用 QueryWrapper 外，我们还可以 lambda 条件构造器做同样的事。

提示：lambda 条件构造器好处是由于它是通过调用实体类中的方法，如果方法名称写错，会直接报错，从而提前纠错。不像 QueryWrapper 是通过自己写表中相应的属性来构造 where 条件，容易发生拼写错误，等到运行时才发现。
// 查询条件：名字中包含’ha’并且年龄小于40
LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.like(UserInfo::getUserName,“ha”).lt(UserInfo::getAge,40);
// 开始查询
UserInfo user = userInfoMapper.selectOne(queryWrapper);
System.out.println(user);

• MyBatis-Plus 提供了 4 种方式创建 lambda 条件构造器，前三种分别如下：

LambdaQueryWrapper<UserInfo> lqw1 = new QueryWrapper<UserInfo>().lambda();
LambdaQueryWrapper<UserInfo> lqw2= new LambdaQueryWrapper<>();
LambdaQueryWrapper<UserInfo> lqw3 = Wrappers.lambdaQuery();
1
2
3

• 无论是之前的 lambda 构造器还是 queryWrapper，每次编写完条件构造语句后都要将对象传递给 mapper 的 selectOne 方法，比较麻烦，MyBatisPlus 提供了第四种函数式编程方式，不用每次都传。

UserInfo userInfo = new LambdaQueryChainWrapper<>(userInfoMapper)
        .like(UserInfo::getUserName,"ha")
        .lt(UserInfo::getAge,40)
        .one();
1
2
3
4

• 如果想通过对象中某些属性进行模糊查询，我们可以在跟数据库表对应的实体类中相应的属性标注相应注解即可。比如我们想通过姓名进行模糊查询用户：

@Data
public class UserInfo {
    private Integer id;
    @TableField(condition = SqlCondition.LIKE)
    private String userName;
    private String passWord;
    private Integer age;
}
1
2
3
4
5
6
7
8

3.selectBatchIds（根据 ID 批量查询，返回一个 List）

List<Integer> ids = new ArrayList<>();
ids.add(1);
ids.add(2);
ids.add(3);
List<UserInfo> users = userInfoMapper.selectBatchIds(ids);
System.out.println(users);
1
2
3
4
5
6

4.selectByMap（通过 Map 封装的条件查询，返回一个 List）

注意：map 写的是数据表中的列名，而非实体类的属性名。比如属性名为 userName，数据表中字段为 user_name，这里应该写的是 user_name。
Map<String,Object> columnMap = new HashMap<>();
columnMap.put(“user_name”, “hangge”);
columnMap.put(“age”, 22);
List users = userInfoMapper.selectByMap(columnMap);
System.out.println(users);

5.selectList（使用查询构造器，返回一个 List）

注意：selectList 使用与 selectOne 类似，不同的是当数据库中符合传入的条件的记录有多条，使用 selectOne 会报错。这时就要使用 selectList。
1
// 查询条件：名字中包含'ha'并且年龄小于40
QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<>();
queryWrapper.like("user_name","ha").lt("age",40);
// 开始查询
List<UserInfo> users = userInfoMapper.selectList(queryWrapper);
System.out.println(user);
1
2
3
4
5
6
7
8

6.selectCount（使用查询构造器，查询总记录数）：

selectCount 的用法和前面的 selectList 很像，都是传入一个查询构造器进行查询，不同的是 selectCount 返回的是一个 Integer 值（符合条件的记录数）：

UserInfo userInfo = new UserInfo();
userInfo.setAge(22);
QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<>(userInfo);
// 开始查询
Integer count = userInfoMapper.selectCount(queryWrapper);
System.out.println(count);
1
2
3
4
5
6

7.selectObjs（使用查询构造器，返回一个 List）：

selectObjs 的用法和前面的 selectList 很像，都是传入一个查询构造器进行查询，然后返回一个 List。不同在于 selectObjs 返回的 List 里面只有返回的第一个字段值：

UserInfo userInfo = new UserInfo();
userInfo.setAge(22);
QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<>(userInfo);
// 开始查询
List<Object> users = userInfoMapper.selectObjs(queryWrapper);
System.out.println(users);
1
2
3
4
5
6

条件构造器

1，相等、不相等

（1）allEq 表示全部 eq（或个别 isNull）：

方法最后一个参数 null2IsNull 是可选的（默认为 true），为 true 时则在 map 的 value 为 null 时调用 isNull 方法，为 false 时则忽略：

• allEq({id:1,user_name:“hangge”,age:null}) — 生成的sql为 —> id = 1 and user_name = ‘hangge’ and age is null
• allEq({id:1,user_name:“hangge”,age:null}, false) — 生成的sql为 —> id = 1 and user_name = ‘hangge’

Map<SFunction<UserInfo, ?>, Object> map = new HashMap<>();
map.put(UserInfo::getId, 3);
map.put(UserInfo::getUserName, "hangge");
map.put(UserInfo::getAge, null);
 
List<UserInfo> userInfos = new LambdaQueryChainWrapper<>(userInfoMapper)
        .allEq(map)
        .list();
1
2
3
4
5
6
7
8

（2）eq 表示等于（=），ne 表示不等于（<>）

List<UserInfo> userInfos = new LambdaQueryChainWrapper<>(userInfoMapper)
        .eq(UserInfo::getId, 1) // id = 1
        .ne(UserInfo::getAge, 22) // age <> 22
        .list();
1
2
3
4

2，大于、小于

（1）gt 表示大于（>）、ge 表示大于等于（>=）、lt 表示小于（<）、le 表示小于等于（<=）