此文章是已经集成了 mybatis-plus，ruoyi文件导出优化，集成mybatis-plus上一篇文章有讲

controller

package com.ruoyi.web.controller.platform;
​
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.ops.PageResult;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.platform.domain.req.PlatformPasswordsCreateReq;
import com.ruoyi.platform.domain.req.PlatformPasswordsPageReq;
import com.ruoyi.platform.domain.req.PlatformPasswordsUpdateReq;
import com.ruoyi.platform.domain.resp.PlatformPasswordsResp;
import com.ruoyi.platform.service.IPlatformPasswordsService;
import jakarta.annotation.Resource;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotNull;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
​
/**
 * 平台密码管理Controller
 * @author shack
 */
@RestController
@RequestMapping("/platform/passwords")
public class PlatformPasswordsController extends BaseController {
​
    @Resource
    private IPlatformPasswordsService platformPasswordsService;
​
    /**
     * 分页查询平台密码管理列表
     */
    @PreAuthorize("@ss.hasPermi('platform:passwords:page')")
    @PostMapping("/page")
    public TableDataInfo page(@RequestBody @Valid PlatformPasswordsPageReq request) {
        PageResult<PlatformPasswordsResp> result = platformPasswordsService.page(request);
        return TableDataInfo.success(result);
    }
​
    /**
     * 导出平台密码管理列表
     */
    @PreAuthorize("@ss.hasPermi('platform:passwords:export')")
    @Log(title = "平台密码管理", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    public AjaxResult export(@RequestBody @Valid PlatformPasswordsPageReq request) {
        platformPasswordsService.export(request);
        return toAjax(true);
    }
​
    /**
     * 获取平台密码管理详情
     */
    @PreAuthorize("@ss.hasPermi('platform:passwords:detail')")
    @GetMapping(value = "/detail/{id}")
    public AjaxResult detail(@PathVariable("id") @NotNull Long id) {
        return success(platformPasswordsService.detail(id));
    }
​
    /**
     * 创建平台密码管理
     */
    @PreAuthorize("@ss.hasPermi('platform:passwords:create')")
    @Log(title = "平台密码管理", businessType = BusinessType.INSERT)
    @PostMapping("/create")
    public AjaxResult create(@RequestBody @Valid PlatformPasswordsCreateReq request) {
        PlatformPasswordsResp result = platformPasswordsService.create(request);
        return success(result);
    }
​
    /**
     * 修改平台密码管理
     */
    @PreAuthorize("@ss.hasPermi('platform:passwords:update')")
    @Log(title = "平台密码管理", businessType = BusinessType.UPDATE)
    @PutMapping("/update")
    public AjaxResult update(@RequestBody @Valid PlatformPasswordsUpdateReq request) {
        PlatformPasswordsResp result = platformPasswordsService.update(request);
        return success(result);
    }
​
    /**
     * 删除平台密码管理
     */
    @PreAuthorize("@ss.hasPermi('platform:passwords:delete')")
    @Log(title = "平台密码管理", businessType = BusinessType.DELETE)
    @DeleteMapping("/delete/{ids}")
    public AjaxResult delete(@PathVariable @NotNull Long[] ids) {
        platformPasswordsService.delete(ids);
        return toAjax(true);
    }
}
​

service

package com.ruoyi.platform.service;
​
import com.ruoyi.common.core.domain.ops.PageResult;
import com.ruoyi.platform.domain.req.PlatformPasswordsCreateReq;
import com.ruoyi.platform.domain.req.PlatformPasswordsPageReq;
import com.ruoyi.platform.domain.req.PlatformPasswordsUpdateReq;
import com.ruoyi.platform.domain.resp.PlatformPasswordsResp;
​
/**
 * 平台密码管理Service接口
 * @author shack
 */
public interface IPlatformPasswordsService {
    /**
     * 获取平台密码管理详情
     * @param id id
     * @return 详情
     */
    PlatformPasswordsResp detail(Long id);
​
    /**
     * 分页查询平台密码管理列表
     * @param request 请求参数
     * @return 分页列表
     */
    PageResult<PlatformPasswordsResp> page(PlatformPasswordsPageReq request);
​
    /**
     * 导出平台密码管理列表
     * @param request 导出请求参数
     */
    void export(PlatformPasswordsPageReq request);
​
    /**
     * 创建平台密码管理
     * @param request 密码管理
     * @return 创建的密码管理
     */
    PlatformPasswordsResp create(PlatformPasswordsCreateReq request);
​
    /**
     * 修改平台密码管理
     * @param request 密码管理
     * @return 修改的密码管理
     */
    PlatformPasswordsResp update(PlatformPasswordsUpdateReq request);
​
    /**
     * 批量删除平台密码管理
     * @param ids 需要删除的平台密码管理ID
     */
    void delete(Long[] ids);
}
​

serviceImpl

package com.ruoyi.platform.service.impl;
​
import cn.hutool.core.collection.CollUtil;
import cn.hutool.extra.spring.SpringUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.constant.ErrorCodeConstants;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.core.domain.ops.PageResult;
import com.ruoyi.common.enums.FileBizTypeEnum;
import com.ruoyi.common.utils.AssertUtil;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.platform.domain.PlatformPasswords;
import com.ruoyi.platform.domain.req.PlatformPasswordsCreateReq;
import com.ruoyi.platform.domain.req.PlatformPasswordsPageReq;
import com.ruoyi.platform.domain.req.PlatformPasswordsUpdateReq;
import com.ruoyi.platform.domain.resp.PlatformPasswordsResp;
import com.ruoyi.platform.mapper.PlatformPasswordsMapper;
import com.ruoyi.platform.service.IPlatformPasswordsService;
import com.ruoyi.support.convert.PlatformPasswordsConvert;
import com.ruoyi.support.export.ExportService;
import com.ruoyi.support.export.PageExportDTO;
import com.ruoyi.support.export.PageExportExecutor;
import com.ruoyi.support.pager.BasePageNoPager;
import com.ruoyi.support.pager.Pager;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
​
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
​
/**
 * 平台密码管理Service业务层处理
 * @author shack
 */
@Service
public class PlatformPasswordsServiceImpl implements IPlatformPasswordsService {
​
    @Resource
    private PlatformPasswordsMapper platformPasswordsMapper;
​
    @Resource
    private ExportService exportService;
​
    @Override
    public PlatformPasswordsResp detail(Long id) {
        PlatformPasswords platformPasswords = platformPasswordsMapper.selectById(id);
        return PlatformPasswordsResp.from(platformPasswords);
    }
​
    @Override
    public PageResult<PlatformPasswordsResp> page(PlatformPasswordsPageReq request) {
        // 分页查询
        Page<PlatformPasswords> pageResult = getSelf().basePage(request);
​
        List<PlatformPasswordsResp> result = pageResult.getRecords()
                .stream()
                .map(PlatformPasswordsResp::from)
                .toList();
        return new PageResult<>(result, pageResult.getTotal());
    }
​
    public Page<PlatformPasswords> basePage(PlatformPasswordsPageReq request) {
        // 构建查询条件
        LambdaQueryWrapper<PlatformPasswords> queryWrapper = buildQueryWrapper(request);
        // 分页查询
        return platformPasswordsMapper.selectPage(request.toPageOps(), queryWrapper);
    }
​
    private LambdaQueryWrapper<PlatformPasswords> buildQueryWrapper(PlatformPasswordsPageReq request) {
        return new LambdaQueryWrapper<>(PlatformPasswords.class)
                .like(StringUtils.isNotEmpty(request.getPlatformName()), PlatformPasswords::getPlatformName,
                        request.getPlatformName())
                .like(StringUtils.isNotEmpty(request.getWebsiteUrl()), PlatformPasswords::getWebsiteUrl,
                        request.getWebsiteUrl())
                .like(StringUtils.isNotEmpty(request.getAccount()), PlatformPasswords::getAccount, request.getAccount())
                .like(StringUtils.isNotEmpty(request.getBackupEmail()), PlatformPasswords::getBackupEmail,
                        request.getBackupEmail())
                .eq(request.getStatus() != null, PlatformPasswords::getStatus, request.getStatus())
                .orderByDesc(PlatformPasswords::getCreateTime)
                .orderByDesc(PlatformPasswords::getUpdateTime);
    }
​
    @Override
    public void export(PlatformPasswordsPageReq request) {
        LoginUser loginUser = SecurityUtils.getLoginUser();
        PageExportDTO<PlatformPasswordsPageReq, PlatformPasswords> pageExportDTO =
                PageExportDTO.create(request, loginUser, FileBizTypeEnum.PLATFORM_PASSWORDS_EXPORT, new PageExportExecutor<>() {
                    @Override
                    public void checkPageCount(PlatformPasswordsPageReq page) {
                        Long count = platformPasswordsMapper.selectCount(buildQueryWrapper(page));
                        AssertUtil.isTrue(count > 0L, ErrorCodeConstants.PARAM_VALIDATE_ERROR, "导出数据为空");
                    }
​
                    @Override
                    public Pager<PlatformPasswords> exportPager(PlatformPasswordsPageReq page) {
                        return new BasePageNoPager<PlatformPasswords>() {
                            @Override
                            public List<PlatformPasswords> fetchNext(int limit) {
                                page.setPageNum(getLastPageNo());
                                page.setPageSize(limit);
                                return getSelf().basePage(page).getRecords();
                            }
                        };
                    }
​
                    @Override
                    public List<List<String>> exportOnePage(List<PlatformPasswords> platformPasswords) {
                        if (CollUtil.isEmpty(platformPasswords)) {
                            return Collections.emptyList();
                        }
                        return platformPasswords.stream().map(PlatformPasswords::toFields).toList();
                    }
​
                    @Override
                    public List<String> exportFileHeader() {
                        return PlatformPasswords.toFieldNames();
                    }
                });
        exportService.export(pageExportDTO);
    }
​
    @Override
    public PlatformPasswordsResp create(PlatformPasswordsCreateReq request) {
        PlatformPasswords platformPasswords = PlatformPasswordsConvert.INSTANCE.convertCreateReqToDomain(request);
        LoginUser loginUser = SecurityUtils.getLoginUser();
        platformPasswords.fillCreateInfo(loginUser);
        platformPasswordsMapper.insert(platformPasswords);
        return PlatformPasswordsResp.from(platformPasswords);
    }
​
    @Override
    public PlatformPasswordsResp update(PlatformPasswordsUpdateReq request) {
        PlatformPasswords platformPasswords = PlatformPasswordsConvert.INSTANCE.convertUpdateReqToDomain(request);
        LoginUser loginUser = SecurityUtils.getLoginUser();
        platformPasswords.fillUpdateInfo(loginUser);
        platformPasswordsMapper.updateById(platformPasswords);
        return PlatformPasswordsResp.from(platformPasswords);
    }
​
    @Override
    public void delete(Long[] ids) {
        platformPasswordsMapper.deleteBatchIds(Arrays.stream(ids).toList());
    }
​
    /**
     * 获得自身的代理对象，解决 AOP 生效问题
     * @return 自己
     */
    private PlatformPasswordsServiceImpl getSelf() {
        return SpringUtil.getBean(getClass());
    }
}
​

mapper

package com.ruoyi.platform.mapper;
​
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.ruoyi.platform.domain.PlatformPasswords;
import org.apache.ibatis.annotations.Mapper;
​
/**
 * 平台密码管理Mapper接口
 */
@Mapper
public interface PlatformPasswordsMapper extends BaseMapper<PlatformPasswords> {
}
​

domain

package com.ruoyi.platform.domain;
​
import com.baomidou.mybatisplus.annotation.TableName;
import com.ruoyi.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
​
import java.io.Serial;
import java.util.List;
​
/**
 * 平台密码管理对象 pm_platform_passwords
 */
@EqualsAndHashCode(callSuper = true)
@Data
@TableName("pm_platform_passwords")
public class PlatformPasswords extends BaseEntity {
​
    @Serial
    private static final long serialVersionUID = 8282937024833952947L;
​
    /**
     * 平台名称
     */
    private String platformName;
​
    /**
     * 网址
     */
    private String websiteUrl;
​
    /**
     * 账号/用户名
     */
    private String account;
​
    /**
     * 密码
     */
    private String password;
​
    /**
     * 备用邮箱
     */
    private String backupEmail;
​
    /**
     * 状态：1-有效，0-失效
     */
    private Integer status;
​
    public static List<String> toFieldNames() {
        return List.of("平台名称", "网址", "账号/用户名", "密码", "备用邮箱");
    }
​
    public List<String> toFields() {
        return List.of(this.platformName, this.websiteUrl, this.account, this.password, this.backupEmail);
    }
}
​

修改BaseEntity

package com.ruoyi.common.core.domain;
​
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.ruoyi.common.core.domain.model.LoginUser;
import lombok.Data;
​
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
​
/**
 * Entity基类
 * @author ruoyi
 */
@Data
public class BaseEntity implements IdAccessor, Serializable {
​
    @Serial
    private static final long serialVersionUID = -9161940029373708981L;
​
    /**
     * 主键id 自增
     */
    @TableId(type = IdType.AUTO)
    private Long id;
​
    /**
     * 创建者
     */
    private String createBy;
​
    /**
     * 创建时间
     */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date createTime;
​
    /**
     * 更新者
     */
    private String updateBy;
​
    /**
     * 更新时间
     */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date updateTime;
​
    /**
     * 备注
     */
    private String remark;
​
    /**
     * 请求参数
     */
    @JsonInclude(JsonInclude.Include.NON_EMPTY)
    private transient Map<String, Object> params;
​
    public Map<String, Object> getParams() {
        if (params == null) {
            params = new HashMap<>();
        }
        return params;
    }
​
    /**
     * 填充创建信息
     */
    public void fillCreateInfo(LoginUser loginUser){
        this.createBy = loginUser.getUsername();
        this.createTime = new Date();
        this.updateBy = loginUser.getUsername();
        this.updateTime = new Date();
    }
​
    /**
     * 填充更新信息
     */
    public void fillUpdateInfo(LoginUser loginUser){
        this.updateBy = loginUser.getUsername();
        this.updateTime = new Date();
    }
​
}
​

req

package com.ruoyi.platform.domain.req;
​
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
​
import java.io.Serial;
import java.io.Serializable;
​
/**
 * 平台密码管理创建参数
 */
@Data
public class PlatformPasswordsCreateReq implements Serializable {
​
    @Serial
    private static final long serialVersionUID = -2124387587565100493L;
​
    /**
     * 平台名称
     */
    @NotEmpty(message = "平台名称不能为空")
    private String platformName;
​
    /**
     * 网址
     */
    @NotEmpty(message = "网址不能为空")
    private String websiteUrl;
​
    /**
     * 账号/用户名
     */
    @NotEmpty(message = "账号不能为空")
    private String account;
​
    /**
     * 密码
     */
    @NotEmpty(message = "密码不能为空")
    private String password;
​
    /**
     * 备用邮箱
     */
    private String backupEmail;
​
    /**
     * 状态：1-有效，0-失效
     */
    @NotNull(message = "状态不能为空")
    private Integer status;
​
    /**
     * 备注
     */
    @NotEmpty(message = "备注不能为空")
    private String remark;
}
​

package com.ruoyi.platform.domain.req;
​
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.domain.BasePageReqVO;
import com.ruoyi.platform.domain.PlatformPasswords;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.apache.commons.lang3.StringUtils;
​
import java.io.Serial;
​
/**
 * 平台密码管理分页请求参数
 * @author shack
 */
@EqualsAndHashCode(callSuper = true)
@Data
public class PlatformPasswordsPageReq extends BasePageReqVO<PlatformPasswords> {
​
    @Serial
    private static final long serialVersionUID = -535584876606549606L;
​
    /**
     * 平台名称
     */
    private String platformName;
​
    /**
     * 网址
     */
    private String websiteUrl;
​
    /**
     * 账号/用户名
     */
    private String account;
​
    /**
     * 备用邮箱
     */
    private String backupEmail;
​
    /**
     * 状态：1-有效，0-失效
     */
    private Integer status;
​
    @Override
    public Page<PlatformPasswords> toPageOps() {
        Page<PlatformPasswords> page = new Page<>(this.getPageNum(), this.getPageSize());
        // 添加排序
        if (StringUtils.isNotEmpty(this.getOrderByColumn())) {
            String orderBy = this.getOrderByColumn();
            if ("asc".equalsIgnoreCase(this.getIsAsc())) {
                page.addOrder(OrderItem.asc(orderBy));
            } else {
                page.addOrder(OrderItem.desc(orderBy));
            }
        }
        return page;
    }
}
​

package com.ruoyi.platform.domain.req;
​
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
​
import java.io.Serial;
import java.io.Serializable;
​
/**
 * 平台密码管理修改参数
 */
@Data
public class PlatformPasswordsUpdateReq implements Serializable {
​
    @Serial
    private static final long serialVersionUID = 4475295030843046116L;
​
    /**
     * 记录ID
     */
    @NotNull(message = "记录ID不能为空")
    private Long id;
​
    /**
     * 平台名称
     */
    @NotEmpty(message = "平台名称不能为空")
    private String platformName;
​
    /**
     * 网址
     */
    @NotEmpty(message = "网址不能为空")
    private String websiteUrl;
​
    /**
     * 账号/用户名
     */
    @NotEmpty(message = "账号不能为空")
    private String account;
​
    /**
     * 密码
     */
    @NotEmpty(message = "密码不能为空")
    private String password;
​
    /**
     * 备用邮箱
     */
    private String backupEmail;
​
    /**
     * 状态：1-有效，0-失效
     */
    @NotNull(message = "状态不能为空")
    private Integer status;
​
    /**
     * 备注
     */
    private String remark;
}
​

resp

package com.ruoyi.platform.domain.resp;
​
import com.ruoyi.platform.domain.PlatformPasswords;
import com.ruoyi.support.convert.PlatformPasswordsConvert;
import lombok.Data;
​
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
​
/**
 * 平台密码管理 响应参数
 */
@Data
public class PlatformPasswordsResp implements Serializable {
​
    @Serial
    private static final long serialVersionUID = 7102574529346559733L;
​
    /**
     * 记录ID
     */
    private Long id;
​
    /**
     * 平台名称
     */
    private String platformName;
​
    /**
     * 网址
     */
    private String websiteUrl;
​
    /**
     * 账号/用户名
     */
    private String account;
​
    /**
     * 密码
     */
    private String password;
​
    /**
     * 备用邮箱
     */
    private String backupEmail;
​
    /**
     * 状态：1-有效，0-失效
     */
    private Integer status;
​
    /**
     * 备注
     */
    private String remark;
​
    /**
     * 创建时间
     */
    private Date createTime;
​
    /**
     * 更新时间
     */
    private Date updateTime;
​
    public static PlatformPasswordsResp from(PlatformPasswords platformPasswords) {
        return PlatformPasswordsConvert.INSTANCE.convertDomainToPageResp(platformPasswords);
    }
}
​

修改TableDataInfo

package com.ruoyi.common.core.page;
​
import com.ruoyi.common.constant.HttpStatus;
import com.ruoyi.common.core.domain.ops.PageResult;
import lombok.Data;
import lombok.NoArgsConstructor;
​
import java.io.Serial;
import java.io.Serializable;
import java.util.List;
​
/**
 * 表格分页数据对象
 * @author ruoyi
 */
@Data
@NoArgsConstructor
public class TableDataInfo implements Serializable {
​
    @Serial
    private static final long serialVersionUID = 3448761695761892244L;
​
    /**
     * 总记录数
     */
    private long total;
​
    /**
     * 列表数据
     */
    private transient List<?> rows;
​
    /**
     * 消息状态码
     */
    private int code;
​
    /**
     * 消息内容
     */
    private String msg;
​
    /**
     * 分页
     * @param list  列表数据
     * @param total 总记录数
     */
    public TableDataInfo(List<?> list, long total) {
        this.total = total;
        this.rows = list;
        this.code = HttpStatus.SUCCESS;
        this.msg = "查询成功";
    }
​
    public static TableDataInfo success(List<?> list, Long total) {
        TableDataInfo rspData = new TableDataInfo();
        rspData.total = total;
        rspData.rows = list;
        rspData.code = HttpStatus.SUCCESS;
        rspData.msg = "查询成功";
        return rspData;
    }
​
    public static TableDataInfo success(PageResult<?> pageResult) {
        TableDataInfo rspData = new TableDataInfo();
        rspData.total = pageResult.getTotal();
        rspData.rows = pageResult.getList();
        rspData.code = HttpStatus.SUCCESS;
        rspData.msg = "查询成功";
        return rspData;
    }
}
​

PageResult

package com.ruoyi.common.core.domain.ops;
​
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
​
import java.io.Serial;
import java.io.Serializable;
import java.util.List;
​
/**
 * 分页结果
 * @author shack
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public final class PageResult<T> implements Serializable {
​
    @Serial
    private static final long serialVersionUID = -1178116795075388345L;
​
    /**
     * 数据列表
     */
    private transient List<T> list;
​
    /**
     * 总数
     */
    private Long total;
}
​

此文包含mapstruct实战，下篇文章：ruoyi前后端分离-集成mapstruct