解释public boolean update( T entity, com.baomidou.mybatisplus.core.conditions.Wrapper<T> updateWrapper )

<think>我们面临的核心需求是：保存生产计划详情数据，并且要求保存的日期字段在后续不会随着时间变化而改变。这意味着我们需要在保存时就将日期固定下来，存储为不可变的字符串或特定格式的日期值，而不是每次查询时动态生成。 根据之前的设计，我们在前端已经实现了详情弹窗，可以输入每天的计划交付和实际交付数量。现在需要实现后端接口来保存这些数据，并且确保日期字段在保存后不再变化。 解决方案： 1. 后端存储时，将日期字段作为字符串（例如"2024-06-01"）存储，而不是使用数据库的日期类型（如DATE）。这样即使时间过去，存储的字符串也不会改变。 2. 在实体类中，使用String类型来表示日期字段。 3. 在保存数据时，前端传递的日期字符串直接存储，不需要做任何转换（因为已经是固定格式的字符串）。 具体步骤： 一、数据库表设计 我们创建一张表来存储生产计划详情（每天的数据）。表结构如下： ```sql CREATE TABLE production_plan_detail ( id BIGINT AUTO_INCREMENT PRIMARY KEY COMMENT '主键ID', plan_id BIGINT NOT NULL COMMENT '关联的生产计划主表ID', date_str VARCHAR(10) NOT NULL COMMENT '日期字符串（格式：yyyy-MM-dd）', planned_quantity INT NOT NULL DEFAULT 0 COMMENT '计划交付数量', actual_quantity INT NOT NULL DEFAULT 0 COMMENT '实际交付数量', created_at DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间', UNIQUE KEY uniq_plan_date (plan_id, date_str) ) COMMENT '生产计划详情表'; ``` 注意：这里使用`date_str`字段存储固定格式的日期字符串（如"2024-06-01"），并且与`plan_id`组成唯一约束，避免同一天重复记录。 二、后端实现（Spring Boot） 1. 创建实体类（使用JPA） ```java @Entity @Table(name = "production_plan_detail", uniqueConstraints = { @UniqueConstraint(columnNames = {"plan_id", "date_str"}) }) public class ProductionPlanDetail { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = "plan_id", nullable = false) private Long planId; @Column(name = "date_str", nullable = false, length = 10) private String dateStr; @Column(name = "planned_quantity", nullable = false) private Integer plannedQuantity = 0; @Column(name = "actual_quantity", nullable = false) private Integer actualQuantity = 0; @Column(name = "created_at", updatable = false) @CreationTimestamp private LocalDateTime createdAt; @Column(name = "updated_at") @UpdateTimestamp private LocalDateTime updatedAt; // 省略getter和setter } ``` 2. 创建Repository接口 ```java public interface ProductionPlanDetailRepository extends JpaRepository<ProductionPlanDetail, Long> { // 根据计划ID和日期字符串查找（用于检查是否存在记录） Optional<ProductionPlanDetail> findByPlanIdAndDateStr(Long planId, String dateStr); // 根据计划ID查找所有详情 List<ProductionPlanDetail> findByPlanId(Long planId); // 根据计划ID删除所有详情（可选） void deleteByPlanId(Long planId); } ``` 3. 创建Service层 ```java @Service @RequiredArgsConstructor public class ProductionPlanDetailService { private final ProductionPlanDetailRepository detailRepository; // 保存或更新详情数据 @Transactional public void saveDetails(Long planId, List<ProductionPlanDetailDTO> details) { // 先删除该计划下原有的所有详情（如果需要完全覆盖） // detailRepository.deleteByPlanId(planId); // 或者采用逐个保存/更新（这里我们采用逐个保存/更新，避免全删全插带来的性能问题） for (ProductionPlanDetailDTO dto : details) { // 根据唯一键（planId和dateStr）查找是否已存在 Optional<ProductionPlanDetail> existing = detailRepository.findByPlanIdAndDateStr(planId, dto.getDateStr()); ProductionPlanDetail detail; if (existing.isPresent()) { detail = existing.get(); detail.setPlannedQuantity(dto.getPlannedQuantity()); detail.setActualQuantity(dto.getActualQuantity()); } else { detail = new ProductionPlanDetail(); detail.setPlanId(planId); detail.setDateStr(dto.getDateStr()); detail.setPlannedQuantity(dto.getPlannedQuantity()); detail.setActualQuantity(dto.getActualQuantity()); } detailRepository.save(detail); } } // 获取某个计划的所有详情 public List<ProductionPlanDetailDTO> getDetailsByPlanId(Long planId) { List<ProductionPlanDetail> details = detailRepository.findByPlanId(planId); return details.stream().map(detail -> { ProductionPlanDetailDTO dto = new ProductionPlanDetailDTO(); dto.setDateStr(detail.getDateStr()); dto.setPlannedQuantity(detail.getPlannedQuantity()); dto.setActualQuantity(detail.getActualQuantity()); return dto; }).collect(Collectors.toList()); } } ``` 4. DTO类 ```java @Data public class ProductionPlanDetailDTO { private String dateStr; // 日期字符串，格式：yyyy-MM-dd private Integer plannedQuantity; // 计划交付数量 private Integer actualQuantity; // 实际交付数量 } ``` 5. 控制器Controller ```java @RestController @RequestMapping("/api/production_plans/{planId}/details") @RequiredArgsConstructor public class ProductionPlanDetailController { private final ProductionPlanDetailService detailService; // 保存详情 @PostMapping public ResponseEntity<?> saveDetails(@PathVariable Long planId, @RequestBody List<ProductionPlanDetailDTO> details) { detailService.saveDetails(planId, details); return ResponseEntity.ok().build(); } // 获取详情 @GetMapping public ResponseEntity<List<ProductionPlanDetailDTO>> getDetails(@PathVariable Long planId) { List<ProductionPlanDetailDTO> details = detailService.getDetailsByPlanId(planId); return ResponseEntity.ok(details); } } ``` 三、前端调用 前端在点击“保存”按钮时，会收集表格中所有的输入框数据，然后按照以下格式组织： ```javascript [ { dateStr: "2024-06-01", plannedQuantity: 100, actualQuantity: 90 }, { dateStr: "2024-06-02", plannedQuantity: 120, actualQuantity: 0 }, // ... 其他日期 ] ``` 然后调用保存接口：`POST /api/production_plans/{planId}/details` 注意：planId是当前生产计划的ID。 四、为什么这样设计能保证日期不变？ 1. 我们使用字符串存储日期，而不是数据库的日期类型。这样存储的值就是固定的字符串，不会因为数据库的日期格式设置或时区问题而改变。 2. 在保存时，前端传递的是已经格式化好的字符串（如"2024-06-01"），后端直接存储这个字符串。 3. 在查询时，返回的也是这个字符串，所以每次显示的都是当初保存的日期字符串。 五、其他注意事项 1. 日期格式：前端和后端统一使用"yyyy-MM-dd"格式。 2. 唯一性约束：避免同一天保存多条记录，所以使用(plan_id, date_str)作为唯一键。 3. 性能考虑：如果每天的数据量很大（比如30天），那么每次保存时可能会进行30次查询和30次保存操作。如果担心性能，可以改为批量操作（先查询出该计划下所有的详情，然后在内存中匹配更新，最后批量保存）。但考虑到30条数据量不大，当前设计已经足够。 六、批量保存优化（可选） 如果希望提高性能，可以修改Service中的保存逻辑，改为批量处理： ```java @Transactional public void saveDetails(Long planId, List<ProductionPlanDetailDTO> details) { // 获取该计划下所有的已有详情 List<ProductionPlanDetail> existingDetails = detailRepository.findByPlanId(planId); Map<String, ProductionPlanDetail> existingMap = existingDetails.stream() .collect(Collectors.toMap(ProductionPlanDetail::getDateStr, Function.identity())); List<ProductionPlanDetail> toSave = new ArrayList<>(); for (ProductionPlanDetailDTO dto : details) { ProductionPlanDetail detail; if (existingMap.containsKey(dto.getDateStr())) { detail = existingMap.get(dto.getDateStr()); detail.setPlannedQuantity(dto.getPlannedQuantity()); detail.setActualQuantity(dto.getActualQuantity()); } else { detail = new ProductionPlanDetail(); detail.setPlanId(planId); detail.setDateStr(dto.getDateStr()); detail.setPlannedQuantity(dto.getPlannedQuantity()); detail.setActualQuantity(dto.getActualQuantity()); } toSave.add(detail); } detailRepository.saveAll(toSave); } ``` 这样就将多次数据库操作减少为两次（一次查询，一次批量保存）。 七、接口安全性 可以根据需要添加权限校验，例如只有管理员或有权限的用户才能保存详情。 八、测试 编写单元测试和集成测试确保功能正确。 总结：通过将日期存储为字符串，我们确保了保存后的日期不会变化。后端接口设计为接收一个日期字符串列表，每个字符串对应一天的数据，然后保存到数据库中。查询时返回的也是同样的字符串，从而保证了日期的固定不变。</think>### 后端接口实现：生产计划详情数据持久化存储（日期固定方案） #### 核心设计思路 1. **日期固化机制**：将日期存储为不可变的字符串格式而非动态计算的日期类型 2. **双重存储策略**： - `original_date`：存储原始日期值（用于审计） - `fixed_date`：存储固化后的字符串日期（业务使用） 3. **数据不变性**：保存后禁止修改日期字段 #### 数据库表设计 ```sql CREATE TABLE production_plan_details ( id BIGINT AUTO_INCREMENT PRIMARY KEY, plan_id BIGINT NOT NULL COMMENT '关联的生产计划ID', original_date DATE NOT NULL COMMENT '原始日期', fixed_date CHAR(10) NOT NULL COMMENT '固化日期(YYYY-MM-DD)', planned_quantity INT NOT NULL DEFAULT 0 COMMENT '计划交付量', actual_quantity INT NOT NULL DEFAULT 0 COMMENT '实际交付量', created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, INDEX idx_plan_date (plan_id, fixed_date) ) COMMENT '生产计划详情表'; ``` #### Spring Boot 实现代码 ##### 1. 实体类设计 ```java @Entity @Table(name = "production_plan_details") public class ProductionPlanDetail { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = "plan_id", nullable = false) private Long planId; @Column(name = "original_date", nullable = false) private LocalDate originalDate; @Column(name = "fixed_date", nullable = false, length = 10) private String fixedDate; @Column(name = "planned_quantity", nullable = false) private Integer plannedQuantity = 0; @Column(name = "actual_quantity", nullable = false) private Integer actualQuantity = 0; // Getter/Setter省略 } ``` ##### 2. 日期固化服务 ```java @Service public class DateFixationService { // 日期固化方法 public String fixDate(LocalDate date) { return date.format(DateTimeFormatter.ISO_DATE); // 转为YYYY-MM-DD } // 批量日期固化 public Map<LocalDate, String> fixDates(List<LocalDate> dates) { return dates.stream() .collect(Collectors.toMap( Function.identity(), this::fixDate )); } } ``` ##### 3. 详情保存接口 ```java @RestController @RequestMapping("/api/production_plans/{planId}/details") public class ProductionPlanDetailController { private final DetailRepository detailRepository; private final DateFixationService dateFixationService; // 保存详情数据 @PostMapping public ResponseEntity<?> saveDetails( @PathVariable Long planId, @RequestBody List<DetailDTO> details) { // 1. 提取所有日期并固化 List<LocalDate> dates = details.stream() .map(DetailDTO::getDate) .collect(Collectors.toList()); Map<LocalDate, String> fixedDates = dateFixationService.fixDates(dates); // 2. 转换为实体并保存 List<ProductionPlanDetail> entities = details.stream() .map(dto -> { ProductionPlanDetail entity = new ProductionPlanDetail(); entity.setPlanId(planId); entity.setOriginalDate(dto.getDate()); entity.setFixedDate(fixedDates.get(dto.getDate())); entity.setPlannedQuantity(dto.getPlannedQuantity()); entity.setActualQuantity(dto.getActualQuantity()); return entity; }) .collect(Collectors.toList()); detailRepository.saveAll(entities); return ResponseEntity.ok("保存成功"); } // 详情查询接口 @GetMapping public ResponseEntity<List<DetailDTO>> getDetails( @PathVariable Long planId) { List<ProductionPlanDetail> details = detailRepository.findByPlanId(planId); List<DetailDTO> response = details.stream() .map(entity -> new DetailDTO( entity.getFixedDate(), // 返回固化日期 entity.getPlannedQuantity(), entity.getActualQuantity() )) .collect(Collectors.toList()); return ResponseEntity.ok(response); } // DTO定义 @Data @NoArgsConstructor @AllArgsConstructor public static class DetailDTO { private String date; // 使用String类型 private Integer plannedQuantity; private Integer actualQuantity; } } ``` #### 关键特性说明 1. **日期固化流程**： ```mermaid sequenceDiagram 前端->>后端: 提交详情数据（含日期） 后端->>DateFixationService: 调用fixDate() DateFixationService->>后端: 返回YYYY-MM-DD字符串 后端->>数据库: 保存fixed_date字段 ``` 2. **数据不变性保障**： ```java @PreUpdate public void preventDateUpdate(ProductionPlanDetail entity) { // 禁止修改固化日期 ProductionPlanDetail original = detailRepository.findById(entity.getId()).get(); if (!original.getFixedDate().equals(entity.getFixedDate())) { throw new IllegalStateException("固化日期不可修改"); } } ``` 3. **时区处理方案**： ```java @Configuration public class DateTimeConfig { @Bean public Jackson2ObjectMapperBuilderCustomizer jsonCustomizer() { return builder -> { builder.timeZone(TimeZone.getTimeZone("UTC")); builder.serializers(new LocalDateSerializer(DateTimeFormatter.ISO_DATE)); }; } } ``` #### 前端调用示例 ```javascript async function saveDetail() { const payload = []; const inputs = document.querySelectorAll('#detailTable input'); inputs.forEach(input => { payload.push({ date: input.dataset.date, // 如"2023-06-15" plannedQuantity: parseInt(document.querySelector(`input[data-date="${input.dataset.date}"][data-type="planned"]`).value) || 0, actualQuantity: parseInt(document.querySelector(`input[data-date="${input.dataset.date}"][data-type="actual"]`).value) || 0 }); }); try { const response = await fetch(`/api/production_plans/${curDetailPlanId}/details`, { method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify(payload) }); if (response.ok) { alert('详情保存成功！'); } } catch (error) { console.error('保存失败:', error); } } ``` #### 设计优势 1. **日期不变性**： - 使用`CHAR(10)`存储固定格式日期 - 保存后不再随系统时间变化 2. **数据追溯**： - 同时保留原始日期(`original_date`)和固化日期(`fixed_date`) - 支持历史数据审计 3. **查询优化**： ```sql SELECT * FROM production_plan_details WHERE fixed_date BETWEEN '2023-06-01' AND '2023-06-30' -- 字符串比较 ``` 4. **兼容性**： - 前端无需修改日期处理逻辑 - 后端自动完成转换和验证 #### 性能优化建议 1. **批量操作**： ```java @Transactional public void batchSave(List<ProductionPlanDetail> entities) { int batchSize = 50; for (int i = 0; i < entities.size(); i += batchSize) { List<ProductionPlanDetail> batch = entities.subList(i, Math.min(i + batchSize, entities.size())); detailRepository.saveAll(batch); } } ``` 2. **缓存策略**： ```java @Cacheable(value = "planDetails", key = "#planId") public List<ProductionPlanDetail> getByPlanId(Long planId) { return detailRepository.findByPlanId(planId); } ``` 3. **索引优化**： ```sql CREATE INDEX idx_fixed_date ON production_plan_details(fixed_date); CREATE INDEX idx_plan_fixed_date ON production_plan_details(plan_id, fixed_date); ``` 此方案确保保存的日期字段固定不变，同时保持系统的高性能和可维护性，符合生产计划管理的核心需求[^1][^3]。

<think>问题分析： 错误信息指出：类“UsersServiceImpl”必须声明为抽象，或为实现“UsersService”中的抽象方法“queryPage(Map<String, Object>, Wrapper<UsersEntity>)”。 原因在于：在UsersService接口中，定义的queryPage方法的第二个参数类型是Wrapper<UsersEntity>，而在UsersServiceImpl中实现该方法时，第二个参数类型却是QueryWrapper<UsersEntity>。 虽然QueryWrapper是Wrapper的子类，但Java方法重写要求参数类型严格一致，因此这里被视为未实现接口的方法。 解决方案： 修改UsersServiceImpl中的queryPage方法，使其第二个参数类型与接口中定义的一致，即改为Wrapper<UsersEntity>类型。 同时，由于MyBatis-Plus的selectPage方法要求的是QueryWrapper类型，我们需要将Wrapper<UsersEntity>转换为QueryWrapper<UsersEntity>。但注意，如果传入的Wrapper不是QueryWrapper，可能需要处理。 同样，selectList方法也存在同样的问题，需要将参数类型改为Wrapper<UsersEntity>，并在内部进行转换。 具体步骤： 1. 修改queryPage方法的参数类型为Wrapper<UsersEntity>。 2. 在方法内部，将Wrapper<UsersEntity>转换为QueryWrapper<UsersEntity>。如果传入的是QueryWrapper，直接转换；如果不是，则根据情况创建一个新的QueryWrapper并复制条件（或者抛出异常，根据需求）。 3. 同样修改selectList方法的参数类型为Wrapper<UsersEntity>，并进行相同的转换。 注意：由于QueryWrapper是Wrapper的实现类，通常我们在使用时会传入QueryWrapper，所以大多数情况下直接强制转换是安全的。但为了代码的健壮性，我们可以进行类型判断。 此外，分页参数解析部分可以增加一些安全性和异常处理。 下面给出修复后的代码：</think>### 解决方案：修复接口方法签名不匹配问题 错误原因在于 `UsersServiceImpl` 类中的方法签名与 `UsersService` 接口定义不一致。接口要求使用 `Wrapper<UsersEntity>` 类型参数，而实现类使用了更具体的 `QueryWrapper<UsersEntity>`。 #### 完整修复方案： ```java package com.app.service.impl; import com.baomidou.mybatisplus.core.conditions.Wrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.app.dao.UsersDao; import com.app.entity.UsersEntity; import com.app.exception.UserServiceException; import com.app.service.UsersService; import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.math.NumberUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Service; import java.util.List; import java.util.Map; @Service("userService") public class UsersServiceImpl extends ServiceImpl<UsersDao, UsersEntity> implements UsersService { private static final Logger logger = LoggerFactory.getLogger(UsersServiceImpl.class); // 配置常量 private static final long DEFAULT_PAGE = 1; private static final long DEFAULT_PAGE_SIZE = 10; private static final long MAX_PAGE_SIZE = 100; /** * 修复queryPage方法签名 */ @Override public Page<UsersEntity> queryPage(Map<String, Object> params, Wrapper<UsersEntity> wrapper) { // 安全转换Wrapper类型 QueryWrapper<UsersEntity> queryWrapper = convertToQueryWrapper(wrapper); // 解析分页参数 long pageNum = parsePageParam(params.get("page"), DEFAULT_PAGE); long pageSize = parsePageParam(params.get("limit"), DEFAULT_PAGE_SIZE); // 应用分页限制 pageNum = Math.max(1, pageNum); pageSize = Math.min(Math.max(1, pageSize), MAX_PAGE_SIZE); logger.debug("查询用户分页数据 - 页码: {}, 每页大小: {}", pageNum, pageSize); // 创建分页对象并执行查询 return baseMapper.selectPage(new Page<>(pageNum, pageSize), queryWrapper); } /** * 修复selectList方法签名 */ @Override public List<UsersEntity> selectList(Wrapper<UsersEntity> wrapper) { QueryWrapper<UsersEntity> queryWrapper = convertToQueryWrapper(wrapper); return baseMapper.selectList(queryWrapper); } /** * 安全地将Wrapper转换为QueryWrapper */ private QueryWrapper<UsersEntity> convertToQueryWrapper(Wrapper<UsersEntity> wrapper) { if (wrapper instanceof QueryWrapper) { return (QueryWrapper<UsersEntity>) wrapper; } // 创建新的QueryWrapper并复制条件 QueryWrapper<UsersEntity> queryWrapper = new QueryWrapper<>(); // 复制实体条件 if (wrapper != null && wrapper.getEntity() != null) { queryWrapper.setEntity(wrapper.getEntity()); } // 复制SQL片段 if (wrapper != null && StringUtils.isNotBlank(wrapper.getSqlSegment())) { queryWrapper.apply(wrapper.getSqlSegment()); } return queryWrapper; } /** * 安全解析分页参数 */ private long parsePageParam(Object value, long defaultValue) { if (value == null) { return defaultValue; } try { if (value instanceof Number) { return ((Number) value).longValue(); } else if (value instanceof String) { return NumberUtils.toLong((String) value, defaultValue); } else { return Long.parseLong(value.toString()); } } catch (Exception e) { logger.warn("分页参数解析失败: '{}' (类型: {}), 使用默认值 {}", value, value.getClass().getName(), defaultValue); return defaultValue; } } /** * 增强功能：按条件分页查询用户 */ public Page<UsersEntity> searchUsers(Map<String, Object> params) { QueryWrapper<UsersEntity> wrapper = new QueryWrapper<>(); // 动态构建查询条件 if (params.containsKey("username")) { wrapper.like("username", params.get("username")); } if (params.containsKey("email")) { wrapper.eq("email", params.get("email")); } if (params.containsKey("status")) { wrapper.eq("status", params.get("status")); } if (params.containsKey("role")) { wrapper.eq("role", params.get("role")); } // 注册时间范围查询 if (params.containsKey("startDate") && params.containsKey("endDate")) { wrapper.between("create_time", params.get("startDate"), params.get("endDate")); } // 默认按ID排序 wrapper.orderByDesc("id"); return queryPage(params, wrapper); } /** * 增强功能：批量更新用户状态 */ public int updateUserStatus(List<Long> userIds, Integer status) { if (userIds == null || userIds.isEmpty()) { throw new UserServiceException("用户ID列表不能为空"); } UsersEntity updateUser = new UsersEntity(); updateUser.setStatus(status); QueryWrapper<UsersEntity> wrapper = new QueryWrapper<>(); wrapper.in("id", userIds); return baseMapper.update(updateUser, wrapper); } /** * 增强功能：安全删除用户（逻辑删除） */ public int safeDeleteUser(Long userId) { if (userId == null || userId <= 0) { throw new UserServiceException("无效的用户ID"); } // 检查用户是否存在 UsersEntity user = baseMapper.selectById(userId); if (user == null) { throw new UserServiceException("用户不存在"); } // 执行逻辑删除 user.setDeleted(1); return baseMapper.updateById(user); } } ``` ### 关键修复点详解 #### 1. queryPage方法签名修复 ```java // 修复前（错误签名） public Page<UsersEntity> queryPage(Map<String, Object> params, QueryWrapper<UsersEntity> wrapper) // 修复后（正确实现接口） @Override public Page<UsersEntity> queryPage(Map<String, Object> params, Wrapper<UsersEntity> wrapper) ``` #### 2. selectList方法签名修复 ```java // 修复前（错误签名） public List<UsersEntity> selectList(QueryWrapper<UsersEntity> wrapper) // 修复后（正确实现接口） @Override public List<UsersEntity> selectList(Wrapper<UsersEntity> wrapper) ``` #### 3. 安全的Wrapper类型转换 ```java private QueryWrapper<UsersEntity> convertToQueryWrapper(Wrapper<UsersEntity> wrapper) { if (wrapper instanceof QueryWrapper) { return (QueryWrapper<UsersEntity>) wrapper; } QueryWrapper<UsersEntity> queryWrapper = new QueryWrapper<>(); if (wrapper != null) { // 复制实体条件 if (wrapper.getEntity() != null) { queryWrapper.setEntity(wrapper.getEntity()); } // 复制SQL片段 if (StringUtils.isNotBlank(wrapper.getSqlSegment())) { queryWrapper.apply(wrapper.getSqlSegment()); } } return queryWrapper; } ``` ### 增强功能实现 #### 1. 安全的分页参数解析 ```java private long parsePageParam(Object value, long defaultValue) { if (value == null) return defaultValue; try { if (value instanceof Number) { return ((Number) value).longValue(); } // 使用Apache Commons Lang安全转换 return NumberUtils.toLong(value.toString(), defaultValue); } catch (Exception e) { logger.error("分页参数解析错误: {}", value, e); return defaultValue; } } ``` #### 2. 动态条件查询 ```java public Page<UsersEntity> advancedUserSearch(Map<String, Object> params) { QueryWrapper<UsersEntity> wrapper = new QueryWrapper<>(); // 动态字段过滤 if (params.containsKey("fields")) { String fields = (String) params.get("fields"); wrapper.select(StringUtils.split(fields, ",")); } // 动态排序 if (params.containsKey("sort")) { String sort = (String) params.get("sort"); String[] sortParams = StringUtils.split(sort, ","); for (String sortParam : sortParams) { String[] parts = StringUtils.split(sortParam, ":"); if (parts.length == 2) { if ("asc".equalsIgnoreCase(parts[1])) { wrapper.orderByAsc(parts[0]); } else { wrapper.orderByDesc(parts[0]); } } } } // 关键词搜索 if (params.containsKey("keyword")) { String keyword = (String) params.get("keyword"); wrapper.and(w -> w.like("username", keyword) .or().like("email", keyword) .or().like("phone", keyword)); } // 状态过滤 if (params.containsKey("status")) { wrapper.eq("status", params.get("status")); } return queryPage(params, wrapper); } ``` #### 3. 用户统计功能 ```java public Map<String, Object> getUserStatistics() { QueryWrapper<UsersEntity> wrapper = new QueryWrapper<>(); wrapper.select("COUNT(*) as total_users", "SUM(CASE WHEN status = 1 THEN 1 ELSE 0 END) as active_users", "MIN(create_time) as first_registration", "MAX(create_time) as last_registration"); return getMap(wrapper); } ``` ### 最佳实践：用户管理增强 #### 1. 密码安全处理 ```java public int updatePassword(Long userId, String newPassword) { if (userId == null || userId <= 0) { throw new UserServiceException("无效的用户ID"); } // 密码强度校验 if (!isPasswordStrong(newPassword)) { throw new UserServiceException("密码强度不足"); } // 密码加密 String encryptedPassword = PasswordUtil.encrypt(newPassword); UsersEntity user = new UsersEntity(); user.setId(userId); user.setPassword(encryptedPassword); return baseMapper.updateById(user); } private boolean isPasswordStrong(String password) { // 至少8位，包含大小写字母和数字 return password != null && password.length() >= 8 && password.matches(".*[A-Z].*") && password.matches(".*[a-z].*") && password.matches(".*\\d.*"); } ``` #### 2. 用户角色管理 ```java public int assignRoles(Long userId, List<String> roles) { if (userId == null || userId <= 0) { throw new UserServiceException("无效的用户ID"); } // 验证角色是否存在 if (!roleService.allRolesExist(roles)) { throw new UserServiceException("包含无效的角色"); } // 删除旧角色 userRoleService.removeByUserId(userId); // 添加新角色 return userRoleService.addRolesToUser(userId, roles); } ``` #### 3. 用户登录历史记录 ```java public void recordLoginHistory(Long userId, String ipAddress, String deviceInfo) { UserLoginHistory history = new UserLoginHistory(); history.setUserId(userId); history.setLoginTime(new Date()); history.setIpAddress(ipAddress); history.setDeviceInfo(deviceInfo); loginHistoryMapper.insert(history); // 保留最近10条记录 QueryWrapper<UserLoginHistory> wrapper = new QueryWrapper<>(); wrapper.eq("user_id", userId) .orderByDesc("login_time"); Page<UserLoginHistory> page = new Page<>(2, 10); // 第2页开始，保留10条 loginHistoryMapper.selectPage(page, wrapper); // 删除多余记录 if (page.getRecords().size() > 10) { List<Long> idsToDelete = page.getRecords().stream() .skip(10) .map(UserLoginHistory::getId) .collect(Collectors.toList()); if (!idsToDelete.isEmpty()) { loginHistoryMapper.deleteBatchIds(idsToDelete); } } } ``` ### 完整的最佳实践实现 ```java package com.app.service.impl; import com.baomidou.mybatisplus.core.conditions.Wrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.app.dao.UsersDao; import com.app.entity.UsersEntity; import com.app.exception.UserServiceException; import com.app.service.UsersService; import com.app.utils.PasswordUtil; import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.math.NumberUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import java.util.Date; import java.util.List; import java.util.Map; @Service("userService") @Transactional public class UsersServiceImpl extends ServiceImpl<UsersDao, UsersEntity> implements UsersService { private static final Logger logger = LoggerFactory.getLogger(UsersServiceImpl.class); // 配置常量 private static final long DEFAULT_PAGE = 1; private static final long DEFAULT_PAGE_SIZE = 10; private static final long MAX_PAGE_SIZE = 100; @Autowired private UserRoleService userRoleService; @Autowired private UserLoginHistoryMapper loginHistoryMapper; @Override public Page<UsersEntity> queryPage(Map<String, Object> params, Wrapper<UsersEntity> wrapper) { QueryWrapper<UsersEntity> queryWrapper = convertToQueryWrapper(wrapper); long pageNum = parsePageParam(params.get("page"), DEFAULT_PAGE); long pageSize = parsePageParam(params.get("limit"), DEFAULT_PAGE_SIZE); // 应用分页限制 pageNum = Math.max(1, pageNum); pageSize = Math.min(Math.max(1, pageSize), MAX_PAGE_SIZE); return baseMapper.selectPage(new Page<>(pageNum, pageSize), queryWrapper); } @Override public List<UsersEntity> selectList(Wrapper<UsersEntity> wrapper) { return baseMapper.selectList(convertToQueryWrapper(wrapper)); } /** * 创建新用户 */ public UsersEntity createUser(UsersEntity user) { // 验证用户名唯一性 if (usernameExists(user.getUsername())) { throw new UserServiceException("用户名已存在"); } // 验证邮箱唯一性 if (emailExists(user.getEmail())) { throw new UserServiceException("邮箱已被注册"); } // 密码加密 user.setPassword(PasswordUtil.encrypt(user.getPassword())); user.setCreateTime(new Date()); user.setStatus(1); // 默认激活状态 if (save(user)) { logger.info("创建新用户: {}", user.getUsername()); return user; } throw new UserServiceException("用户创建失败"); } /** * 更新用户信息 */ public UsersEntity updateUserInfo(UsersEntity user) { if (user.getId() == null) { throw new UserServiceException("用户ID不能为空"); } UsersEntity existing = getById(user.getId()); if (existing == null) { throw new UserServiceException("用户不存在"); } // 更新允许修改的字段 existing.setNickname(user.getNickname()); existing.setPhone(user.getPhone()); existing.setAvatar(user.getAvatar()); if (updateById(existing)) { return existing; } throw new UserServiceException("用户信息更新失败"); } /** * 验证用户名唯一性 */ private boolean usernameExists(String username) { QueryWrapper<UsersEntity> wrapper = new QueryWrapper<>(); wrapper.eq("username", username); return baseMapper.selectCount(wrapper) > 0; } /** * 验证邮箱唯一性 */ private boolean emailExists(String email) { QueryWrapper<UsersEntity> wrapper = new QueryWrapper<>(); wrapper.eq("email", email); return baseMapper.selectCount(wrapper) > 0; } /** * 安全转换Wrapper */ private QueryWrapper<UsersEntity> convertToQueryWrapper(Wrapper<UsersEntity> wrapper) { if (wrapper instanceof QueryWrapper) { return (QueryWrapper<UsersEntity>) wrapper; } QueryWrapper<UsersEntity> queryWrapper = new QueryWrapper<>(); if (wrapper != null) { if (wrapper.getEntity() != null) { queryWrapper.setEntity(wrapper.getEntity()); } if (StringUtils.isNotBlank(wrapper.getSqlSegment())) { queryWrapper.apply(wrapper.getSqlSegment()); } } return queryWrapper; } /** * 安全解析分页参数 */ private long parsePageParam(Object value, long defaultValue) { if (value == null) return defaultValue; try { if (value instanceof Number) { return ((Number) value).longValue(); } return NumberUtils.toLong(value.toString(), defaultValue); } catch (Exception e) { throw new UserServiceException("无效的分页参数: " + value, e); } } /** * 用户登录验证 */ public UsersEntity authenticate(String username, String password) { QueryWrapper<UsersEntity> wrapper = new QueryWrapper<>(); wrapper.eq("username", username) .or().eq("email", username); UsersEntity user = baseMapper.selectOne(wrapper); if (user == null) { throw new UserServiceException("用户不存在"); } if (PasswordUtil.matches(password, user.getPassword())) { // 记录登录历史 recordLoginHistory(user.getId(), getClientIP(), getDeviceInfo()); return user; } throw new UserServiceException("密码错误"); } /** * 获取用户角色列表 */ public List<String> getUserRoles(Long userId) { return userRoleService.getRolesByUserId(userId); } /** * 重置用户密码 */ public void resetPassword(Long userId) { UsersEntity user = getById(userId); if (user == null) { throw new UserServiceException("用户不存在"); } // 生成随机密码 String newPassword = PasswordUtil.generateRandomPassword(12); user.setPassword(PasswordUtil.encrypt(newPassword)); if (!updateById(user)) { throw new UserServiceException("密码重置失败"); } // 发送密码重置邮件 sendPasswordResetEmail(user.getEmail(), newPassword); } // 辅助方法（需要根据实际环境实现） private String getClientIP() { // 实现获取客户端IP的逻辑 return "127.0.0.1"; } private String getDeviceInfo() { // 实现获取设备信息的逻辑 return "Web Browser"; } private void sendPasswordResetEmail(String email, String newPassword) { // 实现发送邮件的逻辑 logger.info("已发送密码重置邮件至: {}", email); } } ``` ### 自定义异常类 ```java package com.app.exception; public class UserServiceException extends RuntimeException { public UserServiceException(String message) { super(message); } public UserServiceException(String message, Throwable cause) { super(message, cause); } } ``` ### 接口定义示例 ```java package com.app.service; import com.baomidou.mybatisplus.core.conditions.Wrapper; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.app.entity.UsersEntity; import java.util.List; import java.util.Map; public interface UsersService { Page<UsersEntity> queryPage(Map<String, Object> params, Wrapper<UsersEntity> wrapper); List<UsersEntity> selectList(Wrapper<UsersEntity> wrapper); UsersEntity createUser(UsersEntity user); UsersEntity updateUserInfo(UsersEntity user); UsersEntity authenticate(String username, String password); void resetPassword(Long userId); List<String> getUserRoles(Long userId); } ``` ### 相关问题： 1. MyBatis-Plus中Wrapper接口与QueryWrapper的具体区别是什么？ 2. 在用户管理系统中，如何设计安全的密码存储和验证机制？ 3. 如何实现高效的用户角色和权限管理系统？ 4. 在大规模用户系统中，分页查询有哪些性能优化策略？