// 构建查询条件
QueryWrapper.<USer> wapper =new QueryWrapper<User>()
    .select("id","username","info","balance")
    .like("username","o")
    .ge("balance",1000);
// 2. 查询
List<User> uers =userMapper.selectList(wapper);
user.forEach(System::println);

User user =new User();
user.setBalance(2000);
QueryWrapper.<USer> wapper =new QueryWrapper<User>().eq("username","jack");
usermapper.update(user,wapper);

List<Long> ids = List.of( 1L，2L,4L);
Updatewrapper<User> wrapper = new Updatewrapper<User>()
    .setsql(balance = balance -200")
            .in(column: "id", ids);
userMapper.update( null, wrapper) ;

// 1.构建查询条件
LambdaQuerywrapper<User> wrapper = new LambdaQuerywrapper<User>()
    .select(User::getId，User::getUsername，User::getInfo,User::getBalance)
    .like(User: :getUsername,val: "o"")
          .ge(User: :getBalance,val: 1000);
List<User> users = userMapper.selectList(wrapper);users.forEach(System.out : :println);

---------------Controller-------------
 // 1．更新条件
List<Long> ids = List.of( 1L，2L，4L);int amount = 200;
// 2.定义条件
Querywrapper<User> wrapper = new Querywrapper<User> ().in( column: "id"，ids);
// 3.调用自定义sQl方法
userMapper.updateBalanceyIds(wrapper,amount) ;

----------Service--------------
void updateBalanceEy.Idis(@Param(Constants.MRAPPER)Querywrapper<User> wrapper，Par am("amount") int amount);

------Mapper-----
    <update id="updateBalanceByIds">
UPDATE tb_user SET balance = balance - #{amount} $ {ew.customsqlsegment</update>

public interface 方法名称 extends Iservice<实体名称>{}

public class 方法名称 extends ServiceImpl<实体名称+Mapper,实体名称> implements 接口名称{}

import lombok.Getter;
import com.baomidou.mybatisplus.annotation.EnumValue;
@Getter
public enum UserStatus {
    /**
     * 正常状态
     */
    NORMAL(1, "正常"),
    /**
     * 冻结状态
     */
    FROZEN(2, "冻结");

    /**
     * 枚举值（MyBatis-Plus映射数据库字段）
     */
    @EnumValue
    private final int value;

    /**
     * 状态描述
     */
    private final String desc;

    /**
     * 构造方法
     *
     * @param value 枚举值
     * @param desc  状态描述
     */
    UserStatus(int value, String desc) {
        this.value = value;
        this.desc = desc;
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import com.baomidou.mybatisplus.annotation.DbType;

/**
 * MyBatis-Plus 配置类
 * 主要配置分页插件等核心插件
 */
@Configuration
public class MybatisConfig {

    /**
     * 配置 MyBatis-Plus 拦截器（核心插件入口）
     * 此处添加分页插件，可扩展添加乐观锁、防全表更新等插件
     *
     * @return MybatisPlusInterceptor 核心拦截器
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        // 1. 初始化 MyBatis-Plus 核心拦截器
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();

        // 2. 创建分页插件，指定数据库类型为 MySQL
        PaginationInnerInterceptor pageInterceptor = new PaginationInnerInterceptor(DbType.MYSQL);
        // 设置分页上限，最大可查询 1000 条数据
        pageInterceptor.setMaxLimit(1000L);

        // 3. 将分页插件添加到核心拦截器中
        interceptor.addInnerInterceptor(pageInterceptor);

        return interceptor;
    }
}

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.List;

/**
 * 通用分页结果DTO
 * 用于统一封装分页查询的返回数据
 * @param <T> 分页数据的泛型类型，支持任意业务实体
 */
@Data
@ApiModel(description = "分页结果数据")
public class PageDTO<T> {

    /**
     * 总记录数
     */
    @ApiModelProperty(value = "总记录数", example = "100")
    private Long total;

    /**
     * 总页数
     */
    @ApiModelProperty(value = "总页数", example = "10")
    private Integer pages;

    /**
     * 当前页码
     */
    @ApiModelProperty(value = "当前页码", example = "1")
    private Long current;

    /**
     * 每页显示条数
     */
    @ApiModelProperty(value = "每页显示条数", example = "10")
    private Long size;

    /**
     * 分页数据列表
     */
    @ApiModelProperty(value = "分页数据列表")
    private List<T> records;
}

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import cn.hutool.core.util.StrUtil;

@Data
@ApiModel(description = "分页查询实体")
public class PageQuery {

    @ApiModelProperty("页码")
    private Integer pageNo = 1;

    @ApiModelProperty("每页条数")
    private Integer pageSize = 5;

    @ApiModelProperty("排序字段")
    private String sortBy;

    @ApiModelProperty("是否升序")
    private Boolean isAsc;

    /**
     * 转换为MyBatis-Plus分页对象（基础版）
     */
    public <T> Page<T> toMpPage() {
        // 1. 分页条件
        Page<T> page = Page.of(pageNo, pageSize);
        // 2. 排序条件
        if (StrUtil.isNotBlank(sortBy)) {
            // 不为空时，使用指定排序
            page.addOrder(new OrderItem(sortBy, isAsc));
        }
        return page;
    }

    /**
     * 转换为MyBatis-Plus分页对象（支持自定义排序项）
     * @param items 自定义排序项
     */
    public <T> Page<T> toMpPage(OrderItem... items) {
        // 1. 分页条件
        Page<T> page = Page.of(pageNo, pageSize);
        // 2. 排序条件
        if (StrUtil.isNotBlank(sortBy)) {
            // 不为空时，使用指定排序
            page.addOrder(new OrderItem(sortBy, isAsc));
        } else if (items != null) {
            // 为空时，使用默认排序项
            page.addOrder(items);
        }
        return page;
    }

    /**
     * 转换为MyBatis-Plus分页对象（支持指定默认排序）
     * @param defaultSortBy 默认排序字段
     * @param defaultAsc 是否默认升序
     */
    public <T> Page<T> toMpPage(String defaultSortBy, Boolean defaultAsc) {
        return toMpPage(new OrderItem(defaultSortBy, defaultAsc));
    }

    /**
     * 默认按创建时间降序排序
     */
    public <T> Page<T> toMpPageDefaultSortByCreateTime() {
        return toMpPage(new OrderItem("create_time", false));
    }

    /**
     * 默认按更新时间降序排序
     */
    public <T> Page<T> toMpPageDefaultSortByUpdateTime() {
        return toMpPage(new OrderItem("update_time", false));
    }
}

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.util.CollectionUtils;
import java.util.Collections;
import java.util.List;

@Data
@ApiModel(description = "分页结果")
public class PageDTO<VO> {

    @ApiModelProperty("总条数")
    private Long total;

    @ApiModelProperty("总页数")
    private Long pages;

    @ApiModelProperty("集合")
    private List<VO> list;

    /**
     * 将 MyBatis-Plus 的 Page 分页结果转换为 PageDTO
     * 并将 PO 列表转换为 VO 列表
     *
     * @param page  MyBatis-Plus 分页查询结果（包含 PO 数据）
     * @param clazz 目标 VO 类的 Class 对象
     * @param <PO>  原始数据类型（如实体类）
     * @param <VO>  目标数据类型（如视图对象）
     * @return 转换后的分页结果 PageDTO
     */
    public static <PO, VO> PageDTO<VO> of(Page<PO> page, Class<VO> clazz) {
        PageDTO<VO> dto = new PageDTO<>();
        // 1. 设置总条数
        dto.setTotal(page.getTotal());
        // 2. 设置总页数
        dto.setPages(page.getPages());
        // 3. 处理当前页数据（PO 转 VO）
        List<PO> records = page.getRecords();
        if (CollectionUtils.isEmpty(records)) {
            dto.setList(Collections.emptyList());
            return dto;
        }
        // 4. 通过 BeanUtil 复制列表（PO -> VO）
        dto.setList(BeanUtil.copyToList(records, clazz));
        // 5. 返回转换后的分页结果
        return dto;
    }
     public static <PO, VO> PageDTO<VO> of(Page<PO> p, Function<PO, VO> converter) {
        PageDTO<VO> dto = new PageDTO<>();
        // 1. 设置总记录数
        dto.setTotal(p.getTotal());
        // 2. 设置总页数
        dto.setPages(p.getPages());
        // 3. 处理当前页数据（通过converter转换PO为VO）
        List<PO> records = p.getRecords();
        if (records == null || records.isEmpty()) {
            dto.setList(Collections.emptyList());
            return dto;
        }
        // 4. 流式处理：通过converter函数转换每条数据，收集为VO列表
        dto.setList(records.stream()
                .map(converter)  // 应用转换函数
                .collect(Collectors.toList()));  // 收集结果
        return dto;
    }

}