MyBatisPlus静态工具Db的实现方法

// 传统方式：需要注入
@Autowired
private UserService userService;
userService.getById(1);

// Db 静态工具：直接调用
Db.getById(1, User.class);

// ❌ 传统方式：循环依赖，Spring 启动报错
@Service
public class OrderService {
    @Autowired
    private UserService userService; // OrderService 依赖 UserService
}

@Service
public class UserService {
    @Autowired
    private OrderService orderService; // UserService 又依赖 OrderService
}

// 定时任务中直接操作数据库
@Component
public class DataCleanTask {

    @Scheduled(cron = "0 0 2 * * ?")
    public void cleanExpiredData() {
        // 不需要注入任何 Service，直接静态调用
        Db.remove(new LambdaQueryWrapper<Order>()
            .lt(Order::getExpireTime, LocalDateTime.now())
            .eq(Order::getStatus, "EXPIRED")
        );
        
        System.out.println("过期数据清理完成");
    }
}

// 事件监听器中使用
@Component
public class UserEventListener {

    @EventListener
    public void onUserRegister(UserRegisterEvent event) {
        // 直接保存初始积分记录，无需注入 PointService
        UserPoint point = new UserPoint();
        point.setUserId(event.getUserId());
        point.setPoint(100);
        Db.save(point);
    }
}

@Data
@TableName("order")
public class Order {
    private Long id;
    private Long userId;
    private Long productId;
    private Integer amount;

    // 实体类内部直接查关联数据
    @TableField(exist = false)
    public User getUser() {
        return Db.getById(this.userId, User.class);
    }

    @TableField(exist = false)
    public Product getProduct() {
        return Db.getById(this.productId, Product.class);
    }
}

@Service
public class UserService extends ServiceImpl<UserMapper, User> {

    public void batchInsert() {
        List<User> users = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            users.add(new User("name" + i, i));
        }
        // 静态批量插入，batchSize 默认 1000
        Db.saveBatch(users);
        // 也可以指定 batchSize
        Db.saveBatch(users, 500);
    }

    public void batchUpdateById() {
        List<User> users = Db.list(new LambdaQueryWrapper<User>()
            .eq(User::getStatus, 0));
        
        users.forEach(u -> u.setStatus(1));
        
        // 批量更新
        Db.updateBatchById(users);
    }
}

// ====== 查询 ======
// 根据 ID 查询
User user = Db.getById(1L, User.class);

// 条件查询单条
User user = Db.getOne(new LambdaQueryWrapper<User>()
    .eq(User::getName, "张三"));

// 查询列表
List<User> users = Db.list(new LambdaQueryWrapper<User>()
    .eq(User::getStatus, 1));

// 查询数量
long count = Db.count(new LambdaQueryWrapper<User>()
    .eq(User::getStatus, 1));

// 分页查询
Page<User> page = Db.page(new Page<>(1, 10), 
    new LambdaQueryWrapper<User>().eq(User::getStatus, 1));

// ====== 插入 ======
Db.save(user);
Db.saveBatch(userList);
Db.saveBatch(userList, 500);

// ====== 更新 ======
Db.updateById(user);
Db.update(user, new LambdaQueryWrapper<User>()
    .eq(User::getName, "张三"));
Db.updateBatchById(userList);

// 有则更新，无则插入
Db.saveOrUpdate(user);

// ====== 删除 ======
Db.removeById(1L, User.class);
Db.remove(new LambdaQueryWrapper<User>()
    .eq(User::getStatus, 0));
Db.removeByIds(idList, User.class);