@Service
public class UserServiceImpl implements UserService {
    
    @Override
    @Transactional
    public Long register(UserRegisterDTO dto) {
        // 1. 校验用户名是否已存在
        if (userMapper.existsByUsername(dto.getUsername())) {
            throw new BusinessException("用户名已存在");
        }
        
        // 2. 校验邮箱是否已被注册
        if (userMapper.existsByEmail(dto.getEmail())) {
            throw new BusinessException("邮箱已被注册");
        }
        
        // 3. 校验密码强度（10+行代码）
        String password = dto.getPassword();
        if (password.length() < 8) throw ...;
        if (!password.matches(".*[A-Z].*")) throw ...;
        if (!password.matches(".*[a-z].*")) throw ...;
        if (!password.matches(".*\\d.*")) throw ...;
        
        // 4. 校验手机号格式
        if (!dto.getPhone().matches("^1[3-9]\\d{9}$")) {
            throw new BusinessException("手机号格式错误");
        }
        
        // 5. 创建用户对象
        User user = new User();
        user.setUsername(dto.getUsername());
        user.setPassword(passwordEncoder.encode(password));
        user.setEmail(dto.getEmail());
        user.setPhone(dto.getPhone());
        user.setStatus(1);  // 魔法数字
        user.setCreateTime(LocalDateTime.now());
        
        // 6. 插入数据库
        userMapper.insert(user);
        
        // 7. 发送欢迎邮件
        mailService.sendWelcomeEmail(user.getEmail());
        
        // 8. 发送欢迎短信
        smsService.sendWelcomeSms(user.getPhone());
        
        return user.getId();
    }
}

// ❌ 这些字段在类型系统中没有区别
private String phone;
private String email;
private String address;

// ❌ 编译器无法阻止错误的赋值
// 这是一个合法的赋值操作，但业务上是完全错误的
user.setPhone("this-is-an-email@example.com");

// ❌ 校验逻辑分散在各处，形成大量重复代码
// 在注册时校验
if (!dto.getPhone().matches("^1[3-9]\\d{9}$")) throw ...;

// 在修改资料时，又要重复一遍
if (!dto.getPhone().matches("^1[3-9]\\d{9}$")) throw ...;

// 在管理员添加用户时，可能又忘了写
adminService.createUser(dto); // 糟糕，一个格式错误的手机号被创建了！

// ❌ 无法封装业务方法
String phone = "13800138000";
// 想要获取区号？想要脱敏显示？只能在 Service 中编写工具方法
String maskedPhone = PhoneUtils.mask(phone);

// ❌ 金额计算繁琐且易错
BigDecimal price = new BigDecimal("10.50");
BigDecimal quantity = new BigDecimal("3");
BigDecimal total = price.multiply(quantity); // 繁琐，且容易出现精度问题

import lombok.Value; // 引入 lombok.Value

@Value // 👈 就是这一个注解！
public class PhoneNumber implements Serializable {
    String value; // 自动成为 private final

    // private 的构造函数由 @Value 自动生成，我们只需提供静态工厂方法
    public static PhoneNumber of(String value) {
        if (value == null || !value.matches("^1[3-9]\\d{9}$")) {
            throw new BusinessException("手机号格式错误");
        }
        return new PhoneNumber(value);
    }

    // 可以在值对象中融入业务逻辑
    public String mask() {
        return value.substring(0, 3) + "****" + value.substring(7);
    }
}

import lombok.Value;
import java.math.BigDecimal;
import java.math.RoundingMode;

@Value
public class Money implements Serializable, Comparable<Money> {
    Long cents; // 使用 "分" 存储，避免精度问题

    public static Money ofYuan(BigDecimal yuan) {
        if (yuan == null || yuan.compareTo(BigDecimal.ZERO) < 0) {
            throw new BusinessException("金额不能为负数");
        }
        return new Money(yuan.multiply(new BigDecimal("100")).longValue());
    }
    
    // --- 丰富的业务行为 ---
    public Money add(Money other) {
        return new Money(this.cents + other.cents);
    }
    
    public Money multiply(int quantity) {
        return new Money(this.cents * quantity);
    }
    
    @Override
    public int compareTo(Money other) {
        return this.cents.compareTo(other.cents);
    }
    
    // ... 其他业务方法
}

import com.example.domain.vo.PhoneNumber;
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

@MappedTypes(PhoneNumber.class)
@MappedJdbcTypes(JdbcType.VARCHAR)
public class PhoneNumberTypeHandler extends BaseTypeHandler<PhoneNumber> {

    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, PhoneNumber p, JdbcType jt) throws SQLException {
        ps.setString(i, p.getValue());
    }
    
    @Override
    public PhoneNumber getNullableResult(ResultSet rs, String columnName) throws SQLException {
        String value = rs.getString(columnName);
        return value == null ? null : PhoneNumber.of(value);
    }
    
    // ... 其他 getNullableResult 方法实现
}

import com.baomidou.mybatisplus.annotation.TableName;
import com.example.domain.vo.PhoneNumber;

// autoResultMap = true 必须开启，以启用 TypeHandler
@TableName(value = "t_user", autoResultMap = true)
public class User {
    private Long id;
    private String username;
    
    // 直接使用 PhoneNumber 类型，无需注解
    private PhoneNumber phone;
    
    // ... getter/setter
}

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {

    @Override
    public void register(UserRegistrationDto dto) {
        // 1. 创建值对象，校验在构造时自动完成，失败则直接抛异常
        PhoneNumber phone = PhoneNumber.of(dto.getPhone());
        
        User user = new User();
        user.setUsername(dto.getUsername());
        // 2. 赋给实体的是一个 100%合法的、富含行为的 PhoneNumber 对象
        user.setPhone(phone);
        
        this.save(user);
    }

    @Override
    public UserProfileVo getUserProfile(Long userId) {
        User user = this.getById(userId);
        // ...
        
        // 3. 直接调用值对象的业务方法，代码清晰且内聚
        PhoneNumber phone = user.getPhone();
        // phone 不可能为 null 或格式错误 (除非数据库原始数据有问题)
        vo.setMaskedPhone(phone.mask()); // 输出 "138 **** 8000"
        
        return vo;
    }
}

// 实体只是数据容器
@Data
public class User {
    private Long id;
    private String username;
    private String password;
    private Integer status;  // 魔法数字
}

// 所有逻辑在 Service
public void disableUser(Long userId) {
    User user = userMapper.selectById(userId);
    if (user.getStatus() == 2) {
        throw new BusinessException("用户已被禁用");
    }
    user.setStatus(2);  // 直接修改
    userMapper.updateById(user);
}

// 实体包含业务行为
@Getter
public class User {
    private Long id;
    private String username;
    private String password;
    private UserStatus status;  // 枚举，不是 Integer
    
    // 业务方法：禁用用户
    public void disable() {
        if (this.status == UserStatus.DISABLED) {
            throw new BusinessException("用户已被禁用");
        }
        this.status = UserStatus.DISABLED;
        this.clearToken();  // 禁用时清空令牌
    }
}

// Service 只负责协调
public void disableUser(Long userId) {
    User user = userMapper.selectById(userId);
    user.disable();  // 业务逻辑在实体内部
    userMapper.updateById(user);
}

@Data
public class User {
    private Long id;
    private String username;
    private String password;
    private Integer status;
}

// Service 中的密码修改逻辑
public void changePassword(Long userId, String oldPwd, String newPwd) {
    User user = userMapper.selectById(userId);
    
    // 校验旧密码
    if (!BCrypt.checkpw(oldPwd, user.getPassword())) {
        throw new BusinessException("原密码错误");
    }
    
    // 校验新密码强度（10+行代码）
    if (newPwd.length() < 8) throw ...;
    if (!newPwd.matches(".*[A-Z].*")) throw ...;
    if (!newPwd.matches(".*[a-z].*")) throw ...;
    if (!newPwd.matches(".*\\d.*")) throw ...;
    
    // 加密并保存
    user.setPassword(BCrypt.hashpw(newPwd));
    userMapper.updateById(user);
}

@Getter
public class User {
    private Long id;
    private String username;
    private String password;
    private UserStatus status;  // 枚举
    
    // 业务方法：修改密码
    public void changePassword(String oldPassword, String newPassword) {
        // 1. 校验旧密码
        if (!BCrypt.checkpw(oldPassword, this.password)) {
            throw new BusinessException("原密码错误");
        }
        // 2. 校验新密码强度（私有方法）
        validatePasswordStrength(newPassword);
        // 3. 加密并保存
        this.password = BCrypt.hashpw(newPassword);
    }
    
    // 业务方法：禁用用户
    public void disable() {
        if (this.status == UserStatus.DISABLED) {
            throw new BusinessException("用户已被禁用");
        }
        this.status = UserStatus.DISABLED;
    }
    
    // 私有校验方法
    private void validatePasswordStrength(String password) {
        if (password.length() < 8) throw ...;
        if (!password.matches(".*[A-Z].*")) throw ...;
        // ...
    }
}

// Service 变得极其简洁
public void changePassword(Long userId, String oldPwd, String newPwd) {
    User user = userMapper.selectById(userId);
    user.changePassword(oldPwd, newPwd);  // 所有逻辑在实体内部
    userMapper.updateById(user);
}

// ❌ 容易遗漏字段
User user = new User();
user.setUsername("test");
// 忘记设置 password
// 忘记设置 status
userMapper.insert(user);  // 插入了不完整的数据

@Getter
public class User {
    // 私有构造函数，外部无法直接 new
    private User() {}
    
    // 工厂方法：创建新用户
    public static User create(String username, String rawPassword, String email) {
        User user = new User();
        user.username = username;
        user.password = BCrypt.hashpw(rawPassword);  // 自动加密
        user.email = email;
        user.status = UserStatus.NORMAL;  // 默认状态
        user.createTime = LocalDateTime.now();
        return user;  // 保证返回的对象是完整的
    }
}

// 使用工厂方法
User user = User.create("zhangsan", "password123", "zhang@example.com");
// 对象一定是完整且合法的

// Service 直接操作 OrderItem
public void addProductToOrder(Long orderId, Long productId, Integer quantity) {
    // 1. 查询订单
    Order order = orderMapper.selectById(orderId);
    
    // 2. 创建订单项（直接操作）
    OrderItem item = new OrderItem();
    item.setOrderId(orderId);
    item.setProductId(productId);
    item.setQuantity(quantity);
    orderItemMapper.insert(item);  // 直接插入
    
    // 3. 手动重新计算订单总价
    List<OrderItem> items = orderItemMapper.selectByOrderId(orderId);
    BigDecimal total = items.stream()
        .map(i -> i.getPrice().multiply(new BigDecimal(i.getQuantity())))
        .reduce(BigDecimal.ZERO, BigDecimal::add);
    order.setTotalAmount(total);
    orderMapper.updateById(order);
    
    // 问题：如果忘记重新计算总价，数据就不一致了！
}

@Getter
public class Order {
    private Long id;
    private List<OrderItem> items = new ArrayList<>();
    private Money totalAmount;
    private OrderStatus status;
    
    // 工厂方法
    public static Order create(Long userId) {
        Order order = new Order();
        order.userId = userId;
        order.status = OrderStatus.PENDING_PAYMENT;
        order.totalAmount = Money.zero();
        return order;
    }
    
    // 聚合根方法：添加商品
    public void addItem(Long productId, String name, Money price, Integer qty) {
        // 1. 校验状态
        if (this.status != OrderStatus.PENDING_PAYMENT) {
            throw new BusinessException("只有待支付订单才能添加商品");
        }
        
        // 2. 检查是否已存在该商品
        for (OrderItem item : items) {
            if (item.getProductId().equals(productId)) {
                item.updateQuantity(item.getQuantity() + qty);  // 增加数量
                recalculateTotalAmount();  // 自动重算总价
                return;
            }
        }
        
        // 3. 创建新订单项
        OrderItem newItem = OrderItem.create(this.id, productId, name, price, qty);
        items.add(newItem);
        
        // 4. 自动重新计算总价
        recalculateTotalAmount();
    }
    
    // 私有方法：重新计算总价
    private void recalculateTotalAmount() {
        this.totalAmount = items.stream()
            .map(OrderItem::calculateSubtotal)
            .reduce(Money.zero(), Money::add);
    }
}

// Service 变得极其简洁
public void addProductToOrder(Long orderId, Long productId, Integer qty) {
    // 1. 加载聚合
    Order order = loadOrderAggregate(orderId);
    
    // 2. 通过聚合根添加商品（自动计算总价）
    Product product = productMapper.selectById(productId);
    order.addItem(product.getId(), product.getName(), 
                  Money.ofYuan(product.getPrice()), qty);
    
    // 3. 持久化
    orderMapper.updateById(order);
    // ... 保存新增的订单项
}

// ❌ 错误：领域服务依赖 Mapper
@Service
public class TransferDomainService {
    @Autowired
    private AccountMapper accountMapper;  // ❌ 领域服务不能依赖 Mapper
    
    public void transfer(Long fromId, Long toId, Money amount) {
        Account from = accountMapper.selectById(fromId);  // ❌ 破坏了领域层的纯粹性
        // ...
    }
}

// ✅ 正确：通过应用服务传入已加载的实体
@Service
public class TransferDomainService {
    // ✅ 不依赖任何基础设施
    
    public Money transfer(Account from, Account to, Money amount) {
        // 纯业务逻辑
        from.debit(amount);
        to.credit(amount);
        return calculateFee(amount);
    }
}

// ❌ 错误：技术导向的命名
public class AccountDomainService {  // 太宽泛
    public void handle() { }         // 含义不明
}

// ✅ 正确：业务导向的命名
public class TransferDomainService {      // 明确转账业务
    public Money transfer() { }           // 动词+名词
}

public class PriceCalculationService {    // 明确价格计算
    public Money calculate() { }
}

public class DiscountService {            // 明确折扣业务
    public Money applyDiscount() { }
}

// ❌ 错误：一个领域服务承担太多职责
public class AccountDomainService {
    public void transfer() { }        // 转账
    public void withdraw() { }        // 取款
    public void calculateInterest() { }  // 计息
    public void freeze() { }          // 冻结
    // 太多职责，难以维护
}

// ✅ 正确：按业务能力拆分
public class TransferDomainService {
    public Money transfer(Account from, Account to, Money amount) { }
}

public class WithdrawalDomainService {
    public void withdraw(Account account, Money amount) { }
}

public class InterestCalculationService {
    public Money calculate(Account account, LocalDate date) { }
}

// ❌ 错误：领域服务有状态
@Service
public class TransferDomainService {
    private Money totalFee;  // ❌ 实例变量（有状态）
    
    public void transfer(Account from, Account to, Money amount) {
        this.totalFee = calculateFee(amount);  // ❌ 多线程不安全
        from.debit(amount.add(totalFee));
    }
}

// ✅ 正确：无状态设计
@Service
public class TransferDomainService {
    // ✅ 没有实例变量
    
    public Money transfer(Account from, Account to, Money amount) {
        Money fee = calculateFee(amount);  // ✅ 局部变量
        from.debit(amount.add(fee));
        to.credit(amount);
        return fee;
    }
}

// ❌ 错误：循环依赖
@Service
public class OrderDomainService {
    @Autowired
    private PaymentDomainService paymentService;  // 依赖 Payment
}

@Service
public class PaymentDomainService {
    @Autowired
    private OrderDomainService orderService;  // 依赖 Order（❌ 循环）
}

// ✅ 正确：重构为单向依赖或提取第三方服务
@Service
public class OrderDomainService {
    // 不依赖 Payment
}

@Service
public class PaymentDomainService {
    @Autowired
    private OrderDomainService orderService;  // 单向依赖
}

// 或者提取第三方服务
@Service
public class OrderPaymentDomainService {  // 新的领域服务
    public void processOrderPayment(Order order, Payment payment) {
        // 协调 Order 和 Payment
    }
}

// ❌ 错误：领域服务控制事务
@Service
public class TransferDomainService {
    @Transactional  // ❌ 领域服务不应控制事务
    public void transfer(Account from, Account to, Money amount) {
        from.debit(amount);
        to.credit(amount);
    }
}

// ✅ 正确：应用服务控制事务
@Service
public class AccountServiceImpl {
    @Transactional  // ✅ 应用服务控制事务
    public void transfer(Long fromId, Long toId, BigDecimal amount) {
        Account from = accountMapper.selectById(fromId);
        Account to = accountMapper.selectById(toId);
        
        transferDomainService.transfer(from, to, Money.ofYuan(amount));
        
        accountMapper.updateById(from);
        accountMapper.updateById(to);
    }
}

// ❌ 错误：返回 void 或布尔值
public class TransferDomainService {
    public void transfer(Account from, Account to, Money amount) {
        // ❌ 手续费信息丢失了
    }
    
    public boolean canTransfer(Account account, Money amount) {
        return account.getBalance().isGreaterThan(amount);
        // ❌ 无法知道为什么不能转账
    }
}

// ✅ 正确：返回有意义的业务对象
public class TransferDomainService {
    public TransferResult transfer(Account from, Account to, Money amount) {
        Money fee = calculateFee(amount);
        from.debit(amount.add(fee));
        to.credit(amount);
        
        return new TransferResult(amount, fee, LocalDateTime.now());
    }
}

// 结果对象
public class TransferResult {
    private final Money amount;
    private final Money fee;
    private final LocalDateTime timestamp;
    
    // 构造方法、getter...
}

// ❌ 错误：吞掉异常或抛出技术异常
public class TransferDomainService {
    public void transfer(Account from, Account to, Money amount) {
        try {
            from.debit(amount);
        } catch (Exception e) {
            e.printStackTrace();  // ❌ 吞掉异常
        }
    }
}

// ✅ 正确：抛出业务异常
public class TransferDomainService {
    public Money transfer(Account from, Account to, Money amount) {
        // 检查业务规则
        if (from.isFrozen()) {
            throw new AccountFrozenException("账户已冻结，无法转账");
        }
        
        if (amount.isGreaterThan(DAILY_LIMIT)) {
            throw new TransferLimitExceededException("超过单日转账限额");
        }
        
        // 业务逻辑
        Money fee = calculateFee(amount);
        from.debit(amount.add(fee));
        to.credit(amount);
        
        return fee;
    }
}

// ✅ 领域服务天生易于测试（不依赖数据库）
@Test
public void testTransfer() {
    // 准备测试数据
    Account from = new Account(new Money(1000));
    Account to = new Account(new Money(500));
    
    // 调用领域服务
    TransferDomainService service = new TransferDomainService();
    Money fee = service.transfer(from, to, new Money(100));
    
    // 断言
    assertEquals(new Money(899), from.getBalance());  // 1000 - 100 - 1(手续费)
    assertEquals(new Money(600), to.getBalance());    // 500 + 100
    assertEquals(new Money(1), fee);
}

// ❌ 如果领域服务依赖 Mapper，测试会很痛苦
@Test
public void testTransfer() {
    // 需要 Mock Mapper、启动 Spring 容器等
    // ...
}

// ❌ 过度设计：简单逻辑抽成领域服务
public class UserDomainService {
    public void changePassword(User user, String newPassword) {
        user.setPassword(newPassword);  // 太简单，不需要领域服务
    }
}

// ✅ 直接在实体中处理
public class User {
    public void changePassword(String newPassword) {
        if (newPassword.length() < 6) {
            throw new IllegalArgumentException("密码长度不能少于6位");
        }
        this.password = passwordEncoder.encode(newPassword);
    }
}

// ✅ 只有在涉及多个实体或复杂计算时才需要领域服务
public class OrderDomainService {
    public Money calculateTotalPrice(Order order, List<Coupon> coupons, VipLevel vipLevel) {
        // 复杂的价格计算逻辑（涉及订单、优惠券、会员等级）
        // ...
    }
}

// 📂 domain/entity/User.java

@Getter // 尽量减少 Setter 的使用，保护内部状态
@TableName("t_user")
public class User {
    
    @TableId(type = IdType.AUTO)
    private Long id;
    
    private String username;
    
    private String password;
    
    // 状态：0-冻结，1-激活
    private Integer status;

    // ❌ 错误做法：Service 层写 logic: if(user.getStatus()==0) { user.setStatus(1); }
    
    // ✅ 正确做法：充血模型（Rich Domain Model）
    public void activate() {
        if (Objects.equals(this.status, 1)) {
            throw new BusinessException("用户已处于激活状态");
        }
        this.status = 1;
        // 可以在此发布领域事件，例如 DomainEventPublisher.publish(new UserActivatedEvent(this.id));
    }

    public void changePassword(String oldPwd, String newPwd) {
        if (!this.password.equals(oldPwd)) {
            throw new BusinessException("旧密码错误");
        }
        this.password = newPwd;
    }
    
    // 基础设施层字段，不参与持久化
    @TableField(exist = false) 
    private List<Role> roles; 
}

@Service
public class UserService {
    @Autowired UserMapper userMapper;

    public void activeUser(Long userId) {
        User user = userMapper.selectById(userId);
        // 调用领域行为
        user.activate(); 
        // 显式调用持久化
        userMapper.updateById(user);
    }
}

// 值对象是不可变的
@Data
@AllArgsConstructor
public class ContactInfo {
    private String email;
    private String phone;
    
    // 值对象内部的自我校验
    public void validate() {
        if (!phone.startsWith("1")) throw new IllegalArgumentException("手机号格式错误");
    }
}

@TableName(value = "t_user", autoResultMap = true) // 必须开启 autoResultMap
public class User {
    @TableId
    private Long id;

    // 数据库中可能是 JSON 字段，或者通过自定义 Handler 映射
    @TableField(typeHandler = JacksonTypeHandler.class)
    private ContactInfo contactInfo;

    // 业务方法
    public void updateContact(String newEmail, String newPhone) {
        ContactInfo newContact = new ContactInfo(newEmail, newPhone);
        newContact.validate(); // 校验逻辑内聚
        this.contactInfo = newContact;
    }
}

// 不依赖 MyBatis-Plus 任何包
public class User {
    private UserId id; // 强类型 ID
    private String name;
    
    // 纯业务逻辑
    public void register() { ... }
}

// 仓储接口
public interface UserRepository {
    void save(User user);
    User find(UserId id);
}

@TableName("t_user")
@Data
public class UserPO { // 专门用于映射数据库表
    @TableId
    private Long id;
    private String name;
    private Date gmtCreate;
}

@Repository
public class UserRepositoryImpl implements UserRepository {
    
    @Autowired private UserMapper userMapper; // MP 的 Mapper
    @Autowired private UserConverter converter; // 转换器（如 MapStruct）

    @Override
    public void save(User user) {
        // 1. Domain -> PO
        UserPO po = converter.toPO(user);
        
        // 2. 使用 MP 进行操作
        if (po.getId() == null) {
            userMapper.insert(po);
            // 回填 ID 到领域对象（如果需要）
            user.setId(new UserId(po.getId())); 
        } else {
            userMapper.updateById(po);
        }
    }

    @Override
    public User find(UserId id) {
        // 1. MP 查询 PO
        UserPO po = userMapper.selectById(id.getValue());
        // 2. PO -> Domain
        return converter.toEntity(po);
    }
}