MybatisPlus

1
@Data
2
@TableName("t_user") // 关联数据库表名
3
public class User {
4
    @TableId(type = IdType.AUTO) // 主键自增
5
    private Long id;
6

7
    @TableField("user_name") // 字段名映射（可选，驼峰转下划线可省略）
8
    private String userName;
9

10
    private Integer age;
11
    private String email;
12

13
    @TableLogic // 逻辑删除字段
14
    private Integer deleted;
15

16
    @TableField(fill = FieldFill.INSERT)
17
    private LocalDateTime createTime;
18
}

1
@Service
2
public class UserService {
3
    // 注入Mapper（@Autowired或@Resource均可）
4
    @Resource
5
    private UserMapper userMapper;
6

7
    // ==================== 新增操作 ====================
8
    public void addUser() {
9
        User user = new User();
10
        user.setUserName("张三");
11
        user.setAge(20);
12
        user.setEmail("zhangsan@test.com");
13
        // 插入单条数据（返回受影响行数）
14
        int rows = userMapper.insert(user);
15
        // 插入后，主键会自动回显到user对象中（如自增id）
16
        System.out.println("新增用户ID：" + user.getId());
17
    }
18

19
    // ==================== 修改操作 ====================
20
    public void updateUser() {
21
        // 方式1：根据ID修改（只修改非null字段）
22
        User user = new User();
23
        user.setId(1L); // 主键
24
        user.setAge(21); // 要修改的字段
25
        int rows = userMapper.updateById(user);
26

27
        // 方式2：条件修改（配合Wrapper）
28
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
29
        wrapper.eq(User::getUserName, "张三");
30
        User updateUser = new User();
31
        updateUser.setEmail("zhangsan_update@test.com");
32
        // 根据条件修改（返回受影响行数）
33
        userMapper.update(updateUser, wrapper);
34
    }
35

36
    // ==================== 删除操作 ====================
37
    public void deleteUser() {
38
        // 方式1：根据ID删除
39
        int rows = userMapper.deleteById(1L);
40

41
        // 方式2：批量删除（根据ID列表）
42
        List<Long> idList = List.of(1L, 2L, 3L);
43
        userMapper.deleteBatchIds(idList);
44

45
        // 方式3：条件删除
46
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
47
        wrapper.eq(User::getAge, 20);
48
        userMapper.delete(wrapper);
49
    }
50

51
    // ==================== 查询操作 ====================
52
    public void queryUser() {
53
        // 方式1：根据ID查询单条
54
        User user = userMapper.selectById(1L);
55

56
        // 方式2：批量查询（根据ID列表）
57
        List<Long> idList = List.of(1L, 2L, 3L);
58
        List<User> userList1 = userMapper.selectBatchIds(idList);
59

60
        // 方式3：条件查询单条（若有多条会抛异常）
61
        LambdaQueryWrapper<User> wrapper1 = new LambdaQueryWrapper<>();
62
        wrapper1.eq(User::getUserName, "张三");
63
        User userOne = userMapper.selectOne(wrapper1);
64

65
        // 方式4：条件查询列表
66
        LambdaQueryWrapper<User> wrapper2 = new LambdaQueryWrapper<>();
67
        wrapper2.gt(User::getAge, 18) // 年龄>18
68
                .like(User::getUserName, "张"); // 姓名含“张”
69
        List<User> userList2 = userMapper.selectList(wrapper2);
70

71
        // 方式5：条件查询总数
72
        LambdaQueryWrapper<User> wrapper3 = new LambdaQueryWrapper<>();
73
        wrapper3.eq(User::getDeleted, 0);
74
        long count = userMapper.selectCount(wrapper3);
75

76
        // 方式6：分页查询（需先配置分页插件）
77
        Page<User> page = new Page<>(1, 10); // 第1页，每页10条
78
        LambdaQueryWrapper<User> wrapper4 = new LambdaQueryWrapper<>();
79
        wrapper4.orderByDesc(User::getId);
80
        IPage<User> userPage = userMapper.selectPage(page, wrapper4);
81
        // 分页结果
82
        System.out.println("总条数：" + userPage.getTotal());
83
        System.out.println("总页数：" + userPage.getPages());
84
        System.out.println("当前页数据：" + userPage.getRecords());
85
    }
86
}

1
import com.baomidou.mybatisplus.core.metadata.IPage;
2
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
3
import com.example.demo.entity.User;
4
import com.example.demo.service.UserService;
5
import org.springframework.web.bind.annotation.GetMapping;
6
import org.springframework.web.bind.annotation.RestController;
7
import javax.annotation.Resource;
8
import java.util.List;
9

10
@RestController
11
public class UserController {
12
    @Resource
13
    private UserService userService;
14

15
    // ==================== 新增/保存操作 ====================
16
    @GetMapping("/add")
17
    public String addUser() {
18
        User user = new User();
19
        user.setUserName("李四");
20
        user.setAge(22);
21
        user.setEmail("lisi@test.com");
22

23
        // 1. 新增单条（等价于baseMapper.insert）
24
        boolean saveFlag = userService.save(user); // 返回是否成功（boolean）
25
        // 2. 批量新增（效率高于循环insert）
26
        List<User> userList = List.of(
27
            new User(null, "王五", 23, "wangwu@test.com"),
28
            new User(null, "赵六", 24, "zhaoliu@test.com")
29
        );
30
        boolean saveBatchFlag = userService.saveBatch(userList); // 批量新增
31
        // 3. 新增或更新（根据主键判断：有主键则更新，无则新增）
32
        User saveOrUpdateUser = new User(1L, "张三更新", 21, "zhangsan_update@test.com");
33
        boolean saveOrUpdateFlag = userService.saveOrUpdate(saveOrUpdateUser);
34

35
        return "操作成功：" + saveFlag;
36
    }
37

38
    // ==================== 修改操作 ====================
39
    @GetMapping("/update")
40
    public String updateUser() {
41
        User user = new User();
42
        user.setId(1L);
43
        user.setAge(25);
44
        // 1. 根据ID修改（等价于baseMapper.updateById）
45
        boolean updateFlag = userService.updateById(user);
46

47
        // 2. 条件修改（Lambda链式调用，无需手动new Wrapper）
48
        boolean updateByWrapperFlag = userService.lambdaUpdate()
49
                .eq(User::getUserName, "李四")
50
                .set(User::getEmail, "lisi_update@test.com")
51
                .update(); // 直接执行更新
52

53
        return "修改成功：" + updateFlag;
54
    }
55

56
    // ==================== 删除操作 ====================
57
    @GetMapping("/delete")
58
    public String deleteUser() {
59
        // 1. 根据ID删除（等价于baseMapper.deleteById）
60
        boolean deleteFlag = userService.removeById(1L);
61

62
        // 2. 批量删除（等价于baseMapper.deleteBatchIds）
63
        boolean removeBatchFlag = userService.removeBatchByIds(List.of(2L, 3L));
64

65
        // 3. 条件删除（Lambda链式调用）
66
        boolean removeByWrapperFlag = userService.lambdaRemove()
67
                .eq(User::getAge, 20)
68
                .remove();
69

70
        return "删除成功：" + deleteFlag;
71
    }
72

73
    // ==================== 查询操作 ====================
74
    @GetMapping("/query")
75
    public String queryUser() {
76
        // 1. 根据ID查询（等价于baseMapper.selectById）
77
        User user = userService.getById(1L);
78

79
        // 2. 批量查询（等价于baseMapper.selectBatchIds）
80
        List<User> userList1 = userService.listByIds(List.of(1L, 2L, 3L));
81

82
        // 3. 条件查询单条（等价于baseMapper.selectOne，无数据返回null）
83
        User userOne = userService.getOne(userService.lambdaQuery().eq(User::getUserName, "张三"));
84

85
        // 4. 条件查询列表（等价于baseMapper.selectList）
86
        List<User> userList2 = userService.list(userService.lambdaQuery().gt(User::getAge, 18));
87

88
        // 5. 条件查询总数（等价于baseMapper.selectCount）
89
        long count = userService.count(userService.lambdaQuery().eq(User::getDeleted, 0));
90

91
        // 6. 分页查询（更简化，无需手动new Page后调用selectPage）
92
        Page<User> page = new Page<>(1, 10); // 第1页，每页10条
93
        IPage<User> userPage = userService.page(page, userService.lambdaQuery().orderByDesc(User::getId));
94

95
        // 7. Lambda链式查询（流式操作）
96
        List<User> lambdaList = userService.lambdaQuery()
97
                .eq(User::getAge, 22)
98
                .like(User::getUserName, "李")
99
                .list(); // 直接返回列表
100

101
        // 8. 调用自定义方法
102
        long ageCount = userService.countByAge(22);
103

104
        return "查询成功，总数：" + count;
105
    }
106

107
    // ==================== 批量操作（IService核心增强） ====================
108
    @GetMapping("/batch")
109
    public String batchOperate() {
110
        // 1. 批量新增（指定批次大小，默认1000条/批）
111
        List<User> bigList = List.of(); // 假设是10000条数据
112
        userService.saveBatch(bigList, 500); // 每500条提交一次
113

114
        // 2. 批量更新（根据ID批量更新）
115
        List<User> updateList = List.of(
116
            new User(1L, "批量更新1", 26, "batch1@test.com"),
117
            new User(2L, "批量更新2", 27, "batch2@test.com")
118
        );
119
        boolean updateBatchFlag = userService.updateBatchById(updateList);
120

121
        return "批量操作成功";
122
    }
123
}

1
/**
2
 * DB 静态工具类使用示例
3
 */
4
public class DbToolDemo {
5

6
    // ==================== 新增操作 ====================
7
    public static void testInsert() {
8
        User user = new User();
9
        user.setUserName("测试DB工具");
10
        user.setAge(25);
11
        user.setEmail("db_test@test.com");
12

13
        // 新增单条数据（主键自动回显）
14
        boolean success = Db.save(user);
15
        System.out.println("新增用户ID：" + user.getId());
16

17
        // 批量新增
18
        List<User> userList = List.of(
19
            new User(null, "批量1", 26, "batch1@test.com"),
20
            new User(null, "批量2", 27, "batch2@test.com")
21
        );
22
        Db.saveBatch(userList);
23
    }
24

25
    // ==================== 修改操作 ====================
26
    public static void testUpdate() {
27
        User user = new User();
28
        user.setId(1L); // 主键
29
        user.setAge(28); // 要修改的字段
30

31
        // 根据ID修改（只改非null字段）
32
        boolean success = Db.updateById(user);
33

34
        // 条件修改（配合Lambda条件构造器）
35
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
36
        wrapper.eq(User::getUserName, "测试DB工具");
37
        User updateUser = new User();
38
        updateUser.setEmail("db_update@test.com");
39
        Db.update(updateUser, wrapper);
40
    }
41

42
    // ==================== 删除操作 ====================
43
    public static void testDelete() {
44
        // 根据ID删除
45
        boolean success = Db.removeById(User.class, 1L);
46

47
        // 批量删除（ID列表）
48
        Db.removeByIds(User.class, List.of(2L, 3L));
49

50
        // 条件删除
51
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
52
        wrapper.eq(User::getAge, 25);
53
        Db.remove(wrapper);
54
    }
55

56
    // ==================== 查询操作 ====================
57
    public static void testQuery() {
58
        // 根据ID查询
59
        User user = Db.getById(User.class, 1L);
60

61
        // 批量查询（ID列表）
62
        List<User> userList1 = Db.listByIds(User.class, List.of(1L, 2L, 3L));
63

64
        // 条件查询列表
65
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
66
        wrapper.gt(User::getAge, 20)
67
               .like(User::getUserName, "测试");
68
        List<User> userList2 = Db.list(wrapper);
69

70
        // 条件查询总数
71
        long count = Db.count(wrapper);
72

73
        // 分页查询（需先配置分页插件）
74
        Page<User> page = new Page<>(1, 10);
75
        IPage<User> userPage = Db.page(page, wrapper);
76
        System.out.println("总条数：" + userPage.getTotal());
77
        System.out.println("当前页数据：" + userPage.getRecords());
78
    }
79

80
    // ==================== 新增或更新（核心便捷方法） ====================
81
    public static void testSaveOrUpdate() {
82
        // 有主键则更新，无主键则新增
83
        User user = new User(1L, "新增或更新", 29, "save_or_update@test.com");
84
        Db.saveOrUpdate(user);
85
    }
86
}

1
@Data
2
@TableName("t_user")
3
public class User {
4
    @TableId(type = IdType.AUTO)
5
    private Long id;
6
    private String userName;
7
    private Integer age;
8

9
    // 逻辑删除字段（核心注解）
10
    @TableLogic(
11
        value = "0",  // 未删除的值（默认 0）
12
        delval = "1"  // 已删除的值（默认 1）
13
    )
14
    private Integer deleted;
15
}

1
@Service
2
public class UserBizService {
3
    @Resource
4
    private UserService userService;
5

6
    // 1. 逻辑删除：deleteById 转为 UPDATE
7
    public void testDelete() {
8
        // 原物理删除：DELETE FROM t_user WHERE id = 1
9
        // 现逻辑删除：UPDATE t_user SET deleted = 1 WHERE id = 1 AND deleted = 0
10
        boolean success = userService.removeById(1L);
11
    }
12

13
    // 2. 查询自动过滤：selectList 自动加 WHERE deleted = 0
14
    public void testQuery() {
15
        // 执行 SQL：SELECT id, user_name, age, deleted FROM t_user WHERE deleted = 0
16
        List<User> userList = userService.list();
17
    }
18

19
    // 3. 批量删除：同样转为批量 UPDATE
20
    public void testBatchDelete() {
21
        // 执行 SQL：UPDATE t_user SET deleted = 1 WHERE id IN (1,2,3) AND deleted = 0
22
        userService.removeBatchByIds(List.of(1L, 2L, 3L));
23
    }
24
}