package com.example.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.web.bind.annotation.*;

import java.sql.Timestamp;
import java.util.*;

/**
 * 反例：不分层的 Controller
 * 这是一个典型的 "面条代码" 示例
 */
@RestController
@RequestMapping("/bad/users")
public class BadUserController {

    @Autowired
    private JdbcTemplate jdbcTemplate;  // 直接注入底层数据访问工具
    
    @Autowired
    private JavaMailSender mailSender;  // 直接注入邮件服务

    /**
     * 用户注册接口
     * 问题：所有逻辑都堆砌在一个方法里
     */
    @PostMapping("/register")
    public Map<String, Object> register(@RequestBody Map<String, String> params) {
        Map<String, Object> result = new HashMap<>();
        
        // 1. 手动解析和校验参数
        String username = params.get("username");
        String password = params.get("password");
        String email = params.get("email");
        
        // 手动校验：用户名
        if (username == null || username.trim().isEmpty()) {
            result.put("code", 400);
            result.put("message", "用户名不能为空");
            return result;
        }
        if (username.length() < 4 || username.length() > 20) {
            result.put("code", 400);
            result.put("message", "用户名长度必须在4-20之间");
            return result;
        }
        
        // 手动校验：密码
        if (password == null || password.length() < 6) {
            result.put("code", 400);
            result.put("message", "密码长度不能少于6位");
            return result;
        }
        
        // 手动校验：邮箱
        if (email == null || !email.contains("@")) {
            result.put("code", 400);
            result.put("message", "邮箱格式不正确");
            return result;
        }
        
        // 2. 检查用户名是否已存在（直接写 SQL）
        String checkSql = "SELECT COUNT(*) FROM t_user WHERE username = ?";
        Integer count = jdbcTemplate.queryForObject(checkSql, Integer.class, username);
        if (count != null && count > 0) {
            result.put("code", 400);
            result.put("message", "用户名已存在");
            return result;
        }
        
        // 3. 插入用户数据（直接写 SQL）
        String insertSql = "INSERT INTO t_user (username, password, email, status, create_time) VALUES (?, ?, ?, ?, ?)";
        try {
            jdbcTemplate.update(
                insertSql, 
                username, 
                password,  // 密码明文存储（严重的安全问题！）
                email, 
                1,  // 魔法数字：1 表示正常状态
                new Timestamp(System.currentTimeMillis())
            );
        } catch (Exception e) {
            result.put("code", 500);
            result.put("message", "注册失败：" + e.getMessage());  // 暴露异常细节
            return result;
        }
        
        // 4. 发送欢迎邮件（业务逻辑与 HTTP 处理混在一起）
        try {
            SimpleMailMessage message = new SimpleMailMessage();
            message.setTo(email);
            message.setSubject("欢迎注册");
            message.setText("您好，" + username + "！欢迎注册我们的系统。");
            mailSender.send(message);
        } catch (Exception e) {
            // 邮件发送失败，但用户已经注册成功了，数据不一致！
            System.out.println("邮件发送失败：" + e.getMessage());
        }
        
        result.put("code", 200);
        result.put("message", "注册成功");
        return result;
    }

    /**
     * 用户列表查询接口
     * 问题：同样的校验逻辑、SQL 拼接在另一个方法中重复出现
     */
    @GetMapping
    public Map<String, Object> listUsers(
        @RequestParam(required = false) String username,
        @RequestParam(required = false) Integer status,
        @RequestParam(defaultValue = "1") Integer pageNum,
        @RequestParam(defaultValue = "10") Integer pageSize
    ) {
        Map<String, Object> result = new HashMap<>();
        
        // 拼接 SQL（SQL 注入风险！）
        StringBuilder sql = new StringBuilder("SELECT * FROM t_user WHERE 1=1");
        List<Object> params = new ArrayList<>();
        
        if (username != null && !username.isEmpty()) {
            sql.append(" AND username LIKE ?");
            params.add("%" + username + "%");
        }
        
        if (status != null) {
            sql.append(" AND status = ?");
            params.add(status);
        }
        
        // 分页（手动计算偏移量）
        int offset = (pageNum - 1) * pageSize;
        sql.append(" LIMIT ? OFFSET ?");
        params.add(pageSize);
        params.add(offset);
        
        // 执行查询
        List<Map<String, Object>> users = jdbcTemplate.queryForList(sql.toString(), params.toArray());
        
        // 手动处理敏感字段（不安全，容易遗漏）
        for (Map<String, Object> user : users) {
            user.remove("password");  // 删除密码字段
            
            // 手动转换状态值
            Integer userStatus = (Integer) user.get("status");
            if (userStatus != null) {
                user.put("statusText", userStatus == 1 ? "正常" : "禁用");
            }
        }
        
        result.put("code", 200);
        result.put("data", users);
        return result;
    }

    /**
     * 用户详情查询
     * 问题：相同的逻辑又重复了一遍
     */
    @GetMapping("/{id}")
    public Map<String, Object> getUserById(@PathVariable Long id) {
        Map<String, Object> result = new HashMap<>();
        
        String sql = "SELECT * FROM t_user WHERE id = ?";
        List<Map<String, Object>> users = jdbcTemplate.queryForList(sql, id);
        
        if (users.isEmpty()) {
            result.put("code", 404);
            result.put("message", "用户不存在");
            return result;
        }
        
        Map<String, Object> user = users.get(0);
        user.remove("password");  // 又一次手动删除密码
        
        // 又一次手动转换状态
        Integer status = (Integer) user.get("status");
        if (status != null) {
            user.put("statusText", status == 1 ? "正常" : "禁用");
        }
        
        result.put("code", 200);
        result.put("data", user);
        return result;
    }
}

// ❌ 禁止直接注入 Mapper
@Autowired
private UserMapper userMapper;

// ❌ 禁止写 SQL
String sql = "SELECT * FROM t_user";

// ❌ 禁止写业务逻辑
if (user.getBalance() < order.getAmount()) {
    // 复杂的计算逻辑
}

// ❌ 禁止管理事务
@Transactional  // Controller 层不应该有这个注解

// ❌ 禁止调用外部服务
mailSender.send(message);

@RestController
@RequestMapping("/users")
@RequiredArgsConstructor
public class UserController {

    private final UserService userService;  // 只注入 Service

    /**
     * 新增用户
     * 
     * Controller 的职责：
     * 1. 接收 HTTP POST 请求
     * 2. 将 JSON 绑定到 UserCreateDTO
     * 3. 触发 JSR-303 校验（@Validated）
     * 4. 调用 Service
     * 5. 封装响应
     */
    @PostMapping
    public Result<Long> createUser(@RequestBody @Validated UserCreateDTO dto) {
        // 直接调用 Service，不做任何业务逻辑处理
        Long userId = userService.createUser(dto);
        return Result.success(userId);
    }

    /**
     * 查询用户详情
     * 
     * Controller 的职责：
     * 1. 接收 GET 请求和路径参数
     * 2. 调用 Service
     * 3. Service 已经返回了 VO，直接封装
     */
    @GetMapping("/{id}")
    public Result<UserVO> getUser(@PathVariable Long id) {
        UserVO userVO = userService.getUserById(id);
        return Result.success(userVO);
    }
}

// ❌ 禁止处理 HTTP 请求相关的对象
public void createUser(HttpServletRequest request) {
    String username = request.getParameter("username");  // 不应该出现在 Service
}

// ❌ 禁止直接返回 PO 给 Controller
public User getUserById(Long id) {
    return userMapper.selectById(id);  // 应该转换为 VO
}

// ❌ 禁止在 Service 中捕获异常后不处理
try {
    userMapper.insert(user);
} catch (Exception e) {
    e.printStackTrace();  // 吞掉异常，导致调用方无法感知错误
}

@Service
@RequiredArgsConstructor
@Slf4j
public class UserServiceImpl implements UserService {

    private final UserMapper userMapper;
    private final MailService mailService;  // 可以注入其他 Service

    /**
     * 创建用户
     * 
     * Service 的职责：
     * 1. 业务规则校验（用户名是否重复）
     * 2. DTO → PO 转换
     * 3. 补全业务数据（状态、创建时间等）
     * 4. 调用 Mapper 持久化
     * 5. 调用外部服务（发送邮件）
     * 6. 返回用户 ID
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createUser(UserCreateDTO dto) {
        log.info("开始创建用户, username: {}", dto.getUsername());
        
        // 1. 业务规则校验
        if (userMapper.existsByUsername(dto.getUsername())) {
            throw new BusinessException(ResultCode.USER_ALREADY_EXIST);
        }
        
        // 2. DTO → PO 转换
        User user = new User();
        user.setUsername(dto.getUsername());
        user.setPassword(dto.getPassword());  // 实际应该加密
        user.setEmail(dto.getEmail());
        
        // 3. 补全业务数据
        user.setStatus(1);  // 正常状态
        user.setCreateTime(LocalDateTime.now());
        
        // 4. 持久化
        userMapper.insert(user);
        
        // 5. 调用外部服务
        mailService.sendWelcomeEmail(user.getEmail(), user.getUsername());
        
        log.info("用户创建成功, userId: {}", user.getId());
        return user.getId();
    }

    /**
     * 查询用户详情
     * 
     * Service 的职责：
     * 1. 调用 Mapper 查询 PO
     * 2. 校验数据存在性
     * 3. PO → VO 转换
     * 4. 返回 VO
     */
    @Override
    public UserVO getUserById(Long id) {
        // 1. 查询 PO
        User user = userMapper.selectById(id);
        
        // 2. 校验
        if (user == null) {
            throw new BusinessException(ResultCode.USER_NOT_EXIST);
        }
        
        // 3. PO → VO 转换
        UserVO vo = new UserVO();
        vo.setId(user.getId());
        vo.setUsername(user.getUsername());
        // 注意：不包含 password
        vo.setStatusText(convertStatusToText(user.getStatus()));
        vo.setCreateTime(user.getCreateTime());
        
        return vo;
    }

    private String convertStatusToText(Integer status) {
        if (status == null) return "未知";
        return status == 1 ? "正常" : "禁用";
    }
}

// ❌ 禁止在 Mapper 接口中写业务逻辑
public interface UserMapper extends BaseMapper<User> {
    // 不应该有这样的方法
    void registerUserAndSendEmail(User user, String emailContent);
}

// ❌ 禁止在 Mapper XML 中写复杂的业务规则判断
<select id="selectUser">
    SELECT * FROM t_user WHERE 1=1
    <if test="age != null and age >= 18">  <!-- 年龄限制是业务规则，不应该在 SQL 中 -->
        AND age >= 18
    </if>
</select>

/**
 * 用户数据访问接口
 * 
 * 职责：
 * 1. 定义与 t_user 表相关的所有数据访问方法
 * 2. 每个方法都是原子化的、无业务逻辑的
 * 3. 方法名清晰表达了操作意图
 */
@Mapper
public interface UserMapper extends BaseMapper<User> {

    /**
     * 根据用户名查询用户
     * 这是一个纯粹的查询操作，不包含任何业务判断
     */
    User selectByUsername(@Param("username") String username);

    /**
     * 检查用户名是否已存在
     * 返回 boolean，便于 Service 层进行业务判断
     */
    boolean existsByUsername(@Param("username") String username);

    /**
     * 根据状态查询用户列表
     */
    List<User> selectListByStatus(@Param("status") Integer status);

    /**
     * 分页查询用户（复杂查询）
     * 注意：这里只是定义查询条件，不包含 "为什么要这样查" 的业务逻辑
     */
    IPage<User> selectPageByCondition(
        IPage<User> page,
        @Param("username") String username,
        @Param("status") Integer status
    );
}

// ✅ 推荐：构造器注入（配合 Lombok）
@Service
@RequiredArgsConstructor
public class UserServiceImpl implements UserService {
    private final UserMapper userMapper;
    private final MailService mailService;
}

// ⚠️ 可用但不推荐：字段注入
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;
}

// ❌ 错误：循环依赖
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private OrderService orderService;  // 如果 OrderService 也注入了 UserService，就循环了
}

// 用户实体
@Data
@TableName("t_user")
public class User {
    private Long id;
    private String username;
    private String password;      // 密码字段
    private String email;
    private Integer status;       // 1-正常，2-禁用
    private LocalDateTime createTime;
}

// Controller
@RestController
public class UserController {
    @Autowired
    private UserMapper userMapper;
    
    @GetMapping("/user/{id}")
    public User getUser(@PathVariable Long id) {
        return userMapper.selectById(id);  // 直接返回数据库对象
    }
}

/**
 * 用户 PO - 与数据库表 t_user 完全对应
 */
@Data
@TableName("t_user")
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    
    private String username;
    private String password;        // ✅ 包含敏感字段
    private String email;
    private Integer status;         // ✅ 存储原始枚举值（1,2）
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

/**
 * 创建用户 DTO - 只包含创建用户所需的字段
 */
@Data
public class UserCreateDTO {
    @NotBlank(message = "用户名不能为空")
    private String username;
    
    @NotBlank(message = "密码不能为空")
    private String password;
    
    @Email(message = "邮箱格式不正确")
    private String email;
    
    // ❌ 没有 id（由数据库生成）
    // ❌ 没有 createTime（由系统生成）
    // ❌ 没有 status（由系统默认设置）
}

/**
 * 更新用户 DTO - 只包含可更新的字段
 */
@Data
public class UserUpdateDTO {
    @NotNull(message = "用户ID不能为空")
    private Long id;              // ✅ 更新需要指定 ID
    
    @Email
    private String email;         // ✅ 可选字段
    
    // ❌ 没有 username（用户名通常不允许修改）
    // ❌ 没有 password（密码修改是单独的接口）
}

/**
 * 用户列表 VO - 用于列表页面展示
 */
@Data
public class UserListVO {
    private Long id;
    private String username;
    private String email;
    
    private String statusText;    // ✅ "正常"/"禁用"（不是 1/2）
    
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime createTime;
    
    // ❌ 没有 password（安全）
    // ❌ 没有 phone（列表不需要显示）
    // ❌ 没有 updateTime（列表不需要显示）
}

/**
 * 用户详情 VO - 用于详情页面展示
 */
@Data
public class UserDetailVO {
    private Long id;
    private String username;
    private String email;
    private String phone;         // ✅ 详情页显示手机号
    
    private String statusText;
    
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime createTime;
    
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime updateTime;  // ✅ 详情页显示更新时间
    
    // ❌ 依然没有 password
}

/**
 * 用户查询 QO - 封装所有查询条件
 */
@Data
public class UserQueryDTO {
    // 查询条件
    private String username;       // 用户名模糊查询
    private Integer status;        // 状态精确查询
    private LocalDate createTimeStart;  // 创建时间范围-开始
    private LocalDate createTimeEnd;    // 创建时间范围-结束
    
    // 分页参数
    private Integer pageNum = 1;
    private Integer pageSize = 10;
    
    // 排序参数
    private String sortField = "createTime";
    private String sortOrder = "desc";  // asc/desc
}

// ❌ 不使用 QO：方法签名臃肿
@GetMapping("/users")
public Result listUsers(
    @RequestParam String username,
    @RequestParam Integer status,
    @RequestParam LocalDate createTimeStart,
    @RequestParam LocalDate createTimeEnd,
    @RequestParam Integer pageNum,
    @RequestParam Integer pageSize,
    @RequestParam String sortField,
    @RequestParam String sortOrder
) {
    // 参数太多，难以阅读和维护
}

// ✅ 使用 QO：一个对象搞定
@GetMapping("/users")
public Result listUsers(UserQueryDTO query) {
    // 简洁清晰
    return Result.success(userService.listUsers(query));
}

/**
 * 订单 BO - 封装订单创建的复杂逻辑
 */
@Getter
public class OrderBO {
    private final User user;
    private final Product product;
    private final Integer quantity;
    
    private BigDecimal totalAmount;
    private BigDecimal discountAmount;
    private BigDecimal finalAmount;
    
    public OrderBO(User user, Product product, Integer quantity) {
        this.user = user;
        this.product = product;
        this.quantity = quantity;
    }
    
    /**
     * 业务方法：校验库存
     */
    public boolean validateStock() {
        return product.getStock() >= quantity;
    }
    
    /**
     * 业务方法：计算价格
     */
    public void calculatePrice() {
        this.totalAmount = product.getPrice().multiply(BigDecimal.valueOf(quantity));
        this.discountAmount = calculateDiscount();
        this.finalAmount = totalAmount.subtract(discountAmount);
    }
    
    /**
     * 业务方法：转换为订单 PO
     */
    public Order toOrderPO() {
        Order order = new Order();
        order.setUserId(user.getId());
        order.setProductId(product.getId());
        order.setTotalAmount(totalAmount);
        order.setFinalAmount(finalAmount);
        return order;
    }
    
    private BigDecimal calculateDiscount() {
        // 复杂的折扣计算逻辑
        return BigDecimal.ZERO;
    }
}

// ❌ 不使用 BO：Service 方法臃肿
@Transactional
public void createOrder(OrderCreateDTO dto) {
    User user = userMapper.selectById(dto.getUserId());
    Product product = productMapper.selectById(dto.getProductId());
    
    // 校验库存
    if (product.getStock() < dto.getQuantity()) {
        throw new RuntimeException("库存不足");
    }
    
    // 计算价格（大量业务逻辑堆砌）
    BigDecimal totalAmount = product.getPrice().multiply(...);
    BigDecimal discountAmount = ...;
    BigDecimal finalAmount = ...;
    
    // 创建订单
    Order order = new Order();
    order.setUserId(user.getId());
    // ... 设置很多字段 ...
    orderMapper.insert(order);
}

// ✅ 使用 BO：Service 方法清晰简洁
@Transactional
public void createOrder(OrderCreateDTO dto) {
    User user = userMapper.selectById(dto.getUserId());
    Product product = productMapper.selectById(dto.getProductId());
    
    // 创建业务对象
    OrderBO orderBO = new OrderBO(user, product, dto.getQuantity());
    
    // 执行业务逻辑（封装在 BO 中）
    if (!orderBO.validateStock()) {
        throw new RuntimeException("库存不足");
    }
    orderBO.calculatePrice();
    
    // 持久化
    orderMapper.insert(orderBO.toOrderPO());
}

// Service 层：PO → VO
public UserDetailVO getUserById(Long id) {
    // 1. Mapper 返回 PO
    User user = userMapper.selectById(id);
    
    // 2. PO → VO 转换
    UserDetailVO vo = new UserDetailVO();
    vo.setId(user.getId());
    vo.setUsername(user.getUsername());
    vo.setEmail(user.getEmail());
    vo.setStatusText(user.getStatus() == 1 ? "正常" : "禁用");  // ✅ 枚举转文本
    // ❌ 不设置 password
    
    return vo;
}

// Service 层：DTO → PO
public Long createUser(1UserCreateDTO dto) {
    // 1. DTO → PO 转换
    User user = new User();
    user.setUsername(dto.getUsername());
    user.setPassword(BCrypt.hashpw(dto.getPassword()));  // ✅ 密码加密
    user.setEmail(dto.getEmail());
    
    // 2. 补全系统字段（DTO 中没有的）
    user.setStatus(1);                      // ✅ 默认状态
    user.setCreateTime(LocalDateTime.now()); // ✅ 创建时间
    
    // 3. 插入数据库
    userMapper.insert(user);
    
    return user.getId();
}

// Service 层：QO → 查询条件，PO 列表 → VO 列表
public PageResult<UserListVO> listUsers(UserQueryDTO query) {
    // 1. QO → 查询条件
    LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
    wrapper.like(query.getUsername() != null, User::getUsername, query.getUsername())
           .eq(query.getStatus() != null, User::getStatus, query.getStatus());
    
    // 2. 分页查询
    Page<User> page = new Page<>(query.getPageNum(), query.getPageSize());
    Page<User> userPage = userMapper.selectPage(page, wrapper);
    
    // 3. PO 列表 → VO 列表（批量转换）
    List<UserListVO> voList = userPage.getRecords().stream()
        .map(this::convertToListVO)  // 每个 PO 转换为 VO
        .collect(Collectors.toList());
    
    // 4. 封装分页结果
    PageResult<UserListVO> result = new PageResult<>();
    result.setRecords(voList);
    result.setTotal(userPage.getTotal());
    
    return result;
}

import cn.hutool.core.bean.BeanUtil;

// 示例 1：简单复制
public UserDetailVO convertToDetailVO(User user) {
    UserDetailVO vo = new UserDetailVO();
    
    // ✅ 自动复制同名同类型字段：id, username, email, createTime...
    BeanUtil.copyProperties(user, vo);
    
    // ✅ 手动处理特殊字段
    vo.setStatusText(user.getStatus() == 1 ? "正常" : "禁用");
    
    // ✅ password 字段因为 VO 中不存在，会被自动忽略
    return vo;
}

// 示例 2：忽略特定字段
BeanUtil.copyProperties(user, vo, "password", "updateTime");

// 示例 3：批量转换
List<UserListVO> voList = BeanUtil.copyToList(userList, UserListVO.class);

// ❌ 陷阱 1：浅拷贝问题
User user1 = new User();
user1.setRoles(Arrays.asList("admin"));

User user2 = new User();
BeanUtil.copyProperties(user1, user2);

user2.getRoles().add("user");  // user1 的 roles 也会被修改！

// ✅ 解决方案：手动深拷贝集合字段
BeanUtil.copyProperties(user1, user2, "roles");
user2.setRoles(new ArrayList<>(user1.getRoles()));

// ❌ 陷阱 2：字段名必须完全相同
class Source { private String userName; }
class Target { private String username; }
BeanUtil.copyProperties(source, target);  // ❌ 复制失败

// ✅ 解决方案：使用 CopyOptions 自定义映射
CopyOptions options = CopyOptions.create()
    .setFieldMapping(Map.of("userName", "username"));
BeanUtil.copyProperties(source, target, options);

// Controller：接收 DTO，返回 VO
@PostMapping
public Result createUser(@RequestBody UserCreateDTO dto) {
    Long userId = userService.createUser(dto);
    return Result.success(userId);
}

// Service：DTO → PO，PO → VO
@Transactional
public Long createUser(UserCreateDTO dto) {
    // DTO → PO
    User user = new User();
    BeanUtil.copyProperties(dto, user);
    user.setStatus(1);
    user.setCreateTime(LocalDateTime.now());
    
    // 保存
    userMapper.insert(user);
    return user.getId();
}

// Controller：使用 QO 简化查询参数
@GetMapping("/search")
public Result searchUsers(UserQueryDTO query) {
    PageResult<UserListVO> result = userService.listUsers(query);
    return Result.success(result);
}

// Service：QO → 查询条件
public PageResult<UserListVO> listUsers(UserQueryDTO query) {
    LambdaQueryWrapper<User> wrapper = buildQueryWrapper(query);
    Page<User> userPage = userMapper.selectPage(
        new Page<>(query.getPageNum(), query.getPageSize()), 
        wrapper
    );
    
    // PO 列表 → VO 列表
    List<UserListVO> voList = BeanUtil.copyToList(
        userPage.getRecords(), 
        UserListVO.class
    );
    
    return PageResult.of(voList, userPage.getTotal());
}

// 使用 MapStruct（编译期生成转换代码）
@Mapper(componentModel = "spring")
public interface UserConverter {
    UserDetailVO toDetailVO(User user);
    
    @Mapping(target = "statusText", expression = "java(convertStatus(user.getStatus()))")
    UserListVO toListVO(User user);
    
    default String convertStatus(Integer status) {
        return status == 1 ? "正常" : "禁用";
    }
}

// Service：注入 Converter
@Service
@RequiredArgsConstructor
public class UserServiceImpl implements UserService {
    private final UserMapper userMapper;
    private final UserConverter userConverter;  // 专门的转换器
    
    public UserDetailVO getUserById(Long id) {
        User user = userMapper.selectById(id);
        return userConverter.toDetailVO(user);  // 使用转换器
    }
}

// ❌ 错误示例
@GetMapping("/{id}")
public User getUser(@PathVariable Long id) {
    return userMapper.selectById(id);  // 密码泄露！
}

// ✅ 正确示例
@GetMapping("/{id}")
public Result<UserDetailVO> getUser(@PathVariable Long id) {
    return Result.success(userService.getUserById(id));  // 返回 VO
}

// ❌ 错误示例
@RestController
public class UserController {
    @Autowired
    private UserMapper userMapper;  // 跨层依赖
}

// ✅ 正确示例
@RestController
@RequiredArgsConstructor
public class UserController {
    private final UserService userService;  // 只注入 Service
}

// ❌ 错误示例
@Data
public class UserVO {
    private Integer status;
    
    // ❌ 不应该在 VO 中写业务逻辑
    public String getStatusText() {
        return status == 1 ? "正常" : "禁用";
    }
}

// ✅ 正确示例
@Data
public class UserVO {
    private String statusText;  // 在 Service 转换时直接赋值
}

// Service 中转换
vo.setStatusText(user.getStatus() == 1 ? "正常" : "禁用");

// ❌ 错误示例
@Data
public class UserDTO {
    private Long id;          // 创建时不需要
    private String username;
    private String password;
    private String email;
    // ... 所有字段都在一个 DTO 中
}

// ✅ 正确示例：不同操作使用不同 DTO
public class UserCreateDTO {
    private String username;
    private String password;
    // 只包含创建所需字段
}

public class UserUpdateDTO {
    private Long id;
    private String email;
    // 只包含更新所需字段
}