第213集系统模型架构实战：领域建模、状态机、事件驱动、微服务设计的企业级解决方案

/**
 * 领域驱动设计核心组件
 * 实现DDD的核心概念和模式
 */
public class DomainDrivenDesignFramework {
    
    /**
     * 聚合根基类
     */
    public abstract class AggregateRoot<ID> {
        private ID id;
        private List<DomainEvent> domainEvents;
        private int version;
        
        public AggregateRoot(ID id) {
            this.id = id;
            this.domainEvents = new ArrayList<>();
            this.version = 0;
        }
        
        protected void addDomainEvent(DomainEvent event) {
            this.domainEvents.add(event);
        }
        
        public List<DomainEvent> getDomainEvents() {
            return new ArrayList<>(domainEvents);
        }
        
        public void clearDomainEvents() {
            this.domainEvents.clear();
        }
        
        public void incrementVersion() {
            this.version++;
        }
        
        public int getVersion() {
            return version;
        }
        
        public ID getId() {
            return id;
        }
    }
    
    /**
     * 实体基类
     */
    public abstract class Entity<ID> {
        private ID id;
        
        public Entity(ID id) {
            this.id = id;
        }
        
        public ID getId() {
            return id;
        }
        
        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (obj == null || getClass() != obj.getClass()) return false;
            Entity<?> entity = (Entity<?>) obj;
            return Objects.equals(id, entity.id);
        }
        
        @Override
        public int hashCode() {
            return Objects.hash(id);
        }
    }
    
    /**
     * 值对象基类
     */
    public abstract class ValueObject {
        @Override
        public abstract boolean equals(Object obj);
        
        @Override
        public abstract int hashCode();
    }
    
    /**
     * 领域事件
     */
    public abstract class DomainEvent {
        private String eventId;
        private long timestamp;
        private String aggregateId;
        private int aggregateVersion;
        
        public DomainEvent(String aggregateId) {
            this.eventId = UUID.randomUUID().toString();
            this.timestamp = System.currentTimeMillis();
            this.aggregateId = aggregateId;
        }
        
        public String getEventId() { return eventId; }
        public long getTimestamp() { return timestamp; }
        public String getAggregateId() { return aggregateId; }
        public int getAggregateVersion() { return aggregateVersion; }
        public void setAggregateVersion(int aggregateVersion) { this.aggregateVersion = aggregateVersion; }
    }
    
    /**
     * 领域服务接口
     */
    public interface DomainService {
        // 领域服务方法
    }
    
    /**
     * 仓储接口
     */
    public interface Repository<T extends AggregateRoot<ID>, ID> {
        T findById(ID id);
        void save(T aggregate);
        void remove(T aggregate);
        List<T> findAll();
    }
    
    /**
     * 规格模式
     */
    public interface Specification<T> {
        boolean isSatisfiedBy(T candidate);
        Specification<T> and(Specification<T> other);
        Specification<T> or(Specification<T> other);
        Specification<T> not();
    }
    
    /**
     * 抽象规格类
     */
    public abstract class AbstractSpecification<T> implements Specification<T> {
        @Override
        public Specification<T> and(Specification<T> other) {
            return new AndSpecification<>(this, other);
        }
        
        @Override
        public Specification<T> or(Specification<T> other) {
            return new OrSpecification<>(this, other);
        }
        
        @Override
        public Specification<T> not() {
            return new NotSpecification<>(this);
        }
    }
    
    /**
     * 组合规格实现
     */
    public class AndSpecification<T> extends AbstractSpecification<T> {
        private Specification<T> left;
        private Specification<T> right;
        
        public AndSpecification(Specification<T> left, Specification<T> right) {
            this.left = left;
            this.right = right;
        }
        
        @Override
        public boolean isSatisfiedBy(T candidate) {
            return left.isSatisfiedBy(candidate) && right.isSatisfiedBy(candidate);
        }
    }
    
    public class OrSpecification<T> extends AbstractSpecification<T> {
        private Specification<T> left;
        private Specification<T> right;
        
        public OrSpecification(Specification<T> left, Specification<T> right) {
            this.left = left;
            this.right = right;
        }
        
        @Override
        public boolean isSatisfiedBy(T candidate) {
            return left.isSatisfiedBy(candidate) || right.isSatisfiedBy(candidate);
        }
    }
    
    public class NotSpecification<T> extends AbstractSpecification<T> {
        private Specification<T> specification;
        
        public NotSpecification(Specification<T> specification) {
            this.specification = specification;
        }
        
        @Override
        public boolean isSatisfiedBy(T candidate) {
            return !specification.isSatisfiedBy(candidate);
        }
    }
}

/**
 * 用户聚合根示例
 */
public class User extends AggregateRoot<UserId> {
    private String username;
    private String email;
    private UserStatus status;
    private Profile profile;
    private List<Role> roles;
    
    public User(UserId id, String username, String email) {
        super(id);
        this.username = username;
        this.email = email;
        this.status = UserStatus.ACTIVE;
        this.roles = new ArrayList<>();
        
        // 发布领域事件
        addDomainEvent(new UserCreatedEvent(id.getValue(), username, email));
    }
    
    public void changeEmail(String newEmail) {
        if (isValidEmail(newEmail)) {
            String oldEmail = this.email;
            this.email = newEmail;
            addDomainEvent(new UserEmailChangedEvent(getId().getValue(), oldEmail, newEmail));
        } else {
            throw new InvalidEmailException("Invalid email format: " + newEmail);
        }
    }
    
    public void activate() {
        if (this.status == UserStatus.INACTIVE) {
            this.status = UserStatus.ACTIVE;
            addDomainEvent(new UserActivatedEvent(getId().getValue()));
        }
    }
    
    public void deactivate() {
        if (this.status == UserStatus.ACTIVE) {
            this.status = UserStatus.INACTIVE;
            addDomainEvent(new UserDeactivatedEvent(getId().getValue()));
        }
    }
    
    public void assignRole(Role role) {
        if (!roles.contains(role)) {
            roles.add(role);
            addDomainEvent(new UserRoleAssignedEvent(getId().getValue(), role.getName()));
        }
    }
    
    public void removeRole(Role role) {
        if (roles.remove(role)) {
            addDomainEvent(new UserRoleRemovedEvent(getId().getValue(), role.getName()));
        }
    }
    
    private boolean isValidEmail(String email) {
        return email != null && email.matches("^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$");
    }
    
    // getters
    public String getUsername() { return username; }
    public String getEmail() { return email; }
    public UserStatus getStatus() { return status; }
    public Profile getProfile() { return profile; }
    public List<Role> getRoles() { return roles; }
}

/**
 * 用户ID值对象
 */
public class UserId extends ValueObject {
    private String value;
    
    public UserId(String value) {
        if (value == null || value.trim().isEmpty()) {
            throw new IllegalArgumentException("User ID cannot be null or empty");
        }
        this.value = value;
    }
    
    public String getValue() {
        return value;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        UserId userId = (UserId) obj;
        return Objects.equals(value, userId.value);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
    
    @Override
    public String toString() {
        return value;
    }
}

/**
 * 用户状态枚举
 */
public enum UserStatus {
    ACTIVE, INACTIVE, SUSPENDED, PENDING
}

/**
 * 用户配置文件值对象
 */
public class Profile extends ValueObject {
    private String firstName;
    private String lastName;
    private String phoneNumber;
    private Address address;
    
    public Profile(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    
    public String getFullName() {
        return firstName + " " + lastName;
    }
    
    // getters and setters
    public String getFirstName() { return firstName; }
    public void setFirstName(String firstName) { this.firstName = firstName; }
    public String getLastName() { return lastName; }
    public void setLastName(String lastName) { this.lastName = lastName; }
    public String getPhoneNumber() { return phoneNumber; }
    public void setPhoneNumber(String phoneNumber) { this.phoneNumber = phoneNumber; }
    public Address getAddress() { return address; }
    public void setAddress(Address address) { this.address = address; }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Profile profile = (Profile) obj;
        return Objects.equals(firstName, profile.firstName) &&
               Objects.equals(lastName, profile.lastName) &&
               Objects.equals(phoneNumber, profile.phoneNumber) &&
               Objects.equals(address, profile.address);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(firstName, lastName, phoneNumber, address);
    }
}

/**
 * 地址值对象
 */
public class Address extends ValueObject {
    private String street;
    private String city;
    private String state;
    private String zipCode;
    private String country;
    
    public Address(String street, String city, String state, String zipCode, String country) {
        this.street = street;
        this.city = city;
        this.state = state;
        this.zipCode = zipCode;
        this.country = country;
    }
    
    // getters
    public String getStreet() { return street; }
    public String getCity() { return city; }
    public String getState() { return state; }
    public String getZipCode() { return zipCode; }
    public String getCountry() { return country; }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Address address = (Address) obj;
        return Objects.equals(street, address.street) &&
               Objects.equals(city, address.city) &&
               Objects.equals(state, address.state) &&
               Objects.equals(zipCode, address.zipCode) &&
               Objects.equals(country, address.country);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(street, city, state, zipCode, country);
    }
}

/**
 * 角色实体
 */
public class Role extends Entity<RoleId> {
    private String name;
    private String description;
    private Set<Permission> permissions;
    
    public Role(RoleId id, String name, String description) {
        super(id);
        this.name = name;
        this.description = description;
        this.permissions = new HashSet<>();
    }
    
    public void addPermission(Permission permission) {
        permissions.add(permission);
    }
    
    public void removePermission(Permission permission) {
        permissions.remove(permission);
    }
    
    public boolean hasPermission(Permission permission) {
        return permissions.contains(permission);
    }
    
    // getters
    public String getName() { return name; }
    public String getDescription() { return description; }
    public Set<Permission> getPermissions() { return permissions; }
}

/**
 * 角色ID值对象
 */
public class RoleId extends ValueObject {
    private String value;
    
    public RoleId(String value) {
        this.value = value;
    }
    
    public String getValue() {
        return value;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        RoleId roleId = (RoleId) obj;
        return Objects.equals(value, roleId.value);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
}

/**
 * 权限枚举
 */
public enum Permission {
    READ, WRITE, DELETE, ADMIN
}

/**
 * 领域事件实现
 */
public class UserCreatedEvent extends DomainEvent {
    private String username;
    private String email;
    
    public UserCreatedEvent(String aggregateId, String username, String email) {
        super(aggregateId);
        this.username = username;
        this.email = email;
    }
    
    public String getUsername() { return username; }
    public String getEmail() { return email; }
}

public class UserEmailChangedEvent extends DomainEvent {
    private String oldEmail;
    private String newEmail;
    
    public UserEmailChangedEvent(String aggregateId, String oldEmail, String newEmail) {
        super(aggregateId);
        this.oldEmail = oldEmail;
        this.newEmail = newEmail;
    }
    
    public String getOldEmail() { return oldEmail; }
    public String getNewEmail() { return newEmail; }
}

public class UserActivatedEvent extends DomainEvent {
    public UserActivatedEvent(String aggregateId) {
        super(aggregateId);
    }
}

public class UserDeactivatedEvent extends DomainEvent {
    public UserDeactivatedEvent(String aggregateId) {
        super(aggregateId);
    }
}

public class UserRoleAssignedEvent extends DomainEvent {
    private String roleName;
    
    public UserRoleAssignedEvent(String aggregateId, String roleName) {
        super(aggregateId);
        this.roleName = roleName;
    }
    
    public String getRoleName() { return roleName; }
}

public class UserRoleRemovedEvent extends DomainEvent {
    private String roleName;
    
    public UserRoleRemovedEvent(String aggregateId, String roleName) {
        super(aggregateId);
        this.roleName = roleName;
    }
    
    public String getRoleName() { return roleName; }
}

/**
 * 用户领域服务
 */
public class UserDomainService implements DomainService {
    private final UserRepository userRepository;
    private final EmailService emailService;
    
    public UserDomainService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
    
    /**
     * 检查用户名是否唯一
     */
    public boolean isUsernameUnique(String username) {
        return !userRepository.existsByUsername(username);
    }
    
    /**
     * 检查邮箱是否唯一
     */
    public boolean isEmailUnique(String email) {
        return !userRepository.existsByEmail(email);
    }
    
    /**
     * 创建用户
     */
    public User createUser(String username, String email, String firstName, String lastName) {
        // 业务规则验证
        if (!isUsernameUnique(username)) {
            throw new UsernameAlreadyExistsException("Username already exists: " + username);
        }
        
        if (!isEmailUnique(email)) {
            throw new EmailAlreadyExistsException("Email already exists: " + email);
        }
        
        // 创建用户
        UserId userId = new UserId(UUID.randomUUID().toString());
        User user = new User(userId, username, email);
        
        // 设置用户资料
        Profile profile = new Profile(firstName, lastName);
        user.setProfile(profile);
        
        // 保存用户
        userRepository.save(user);
        
        // 发送欢迎邮件
        emailService.sendWelcomeEmail(email, firstName);
        
        return user;
    }
    
    /**
     * 重置密码
     */
    public void resetPassword(String email) {
        User user = userRepository.findByEmail(email);
        if (user == null) {
            throw new UserNotFoundException("User not found with email: " + email);
        }
        
        // 生成重置令牌
        String resetToken = generateResetToken();
        
        // 保存重置令牌
        user.setPasswordResetToken(resetToken);
        user.setPasswordResetExpiry(System.currentTimeMillis() + 3600000); // 1小时
        
        userRepository.save(user);
        
        // 发送重置邮件
        emailService.sendPasswordResetEmail(email, resetToken);
    }
    
    private String generateResetToken() {
        return UUID.randomUUID().toString().replace("-", "");
    }
}

/**
 * 用户仓储接口
 */
public interface UserRepository extends Repository<User, UserId> {
    User findByUsername(String username);
    User findByEmail(String email);
    boolean existsByUsername(String username);
    boolean existsByEmail(String email);
    List<User> findByStatus(UserStatus status);
    List<User> findByRole(Role role);
}

/**
 * 规格实现示例
 */
public class UserSpecifications {
    
    public static class ActiveUserSpecification extends AbstractSpecification<User> {
        @Override
        public boolean isSatisfiedBy(User candidate) {
            return candidate.getStatus() == UserStatus.ACTIVE;
        }
    }
    
    public static class UserWithRoleSpecification extends AbstractSpecification<User> {
        private String roleName;
        
        public UserWithRoleSpecification(String roleName) {
            this.roleName = roleName;
        }
        
        @Override
        public boolean isSatisfiedBy(User candidate) {
            return candidate.getRoles().stream()
                    .anyMatch(role -> role.getName().equals(roleName));
        }
    }
    
    public static class UserWithEmailDomainSpecification extends AbstractSpecification<User> {
        private String domain;
        
        public UserWithEmailDomainSpecification(String domain) {
            this.domain = domain;
        }
        
        @Override
        public boolean isSatisfiedBy(User candidate) {
            return candidate.getEmail().endsWith("@" + domain);
        }
    }
}

/**
 * 状态机框架
 * 实现状态机的核心功能
 */
public class StateMachineFramework {
    
    /**
     * 状态接口
     */
    public interface State {
        String getName();
        void onEnter(StateMachineContext context);
        void onExit(StateMachineContext context);
        void onEvent(StateMachineContext context, Event event);
    }
    
    /**
     * 事件接口
     */
    public interface Event {
        String getName();
        Object getData();
    }
    
    /**
     * 状态机上下文
     */
    public static class StateMachineContext {
        private Object entity;
        private Map<String, Object> variables;
        private StateMachine stateMachine;
        
        public StateMachineContext(Object entity, StateMachine stateMachine) {
            this.entity = entity;
            this.stateMachine = stateMachine;
            this.variables = new HashMap<>();
        }
        
        public Object getEntity() { return entity; }
        public StateMachine getStateMachine() { return stateMachine; }
        public Map<String, Object> getVariables() { return variables; }
        public void setVariable(String key, Object value) { variables.put(key, value); }
        public Object getVariable(String key) { return variables.get(key); }
    }
    
    /**
     * 状态机
     */
    public static class StateMachine {
        private Map<String, State> states;
        private Map<String, Map<String, State>> transitions;
        private State currentState;
        private StateMachineContext context;
        
        public StateMachine() {
            this.states = new HashMap<>();
            this.transitions = new HashMap<>();
        }
        
        public void addState(State state) {
            states.put(state.getName(), state);
        }
        
        public void addTransition(String fromState, String event, String toState) {
            transitions.computeIfAbsent(fromState, k -> new HashMap<>()).put(event, states.get(toState));
        }
        
        public void setInitialState(String stateName) {
            this.currentState = states.get(stateName);
            if (currentState != null) {
                currentState.onEnter(context);
            }
        }
        
        public void setContext(StateMachineContext context) {
            this.context = context;
        }
        
        public boolean canTransition(String event) {
            if (currentState == null) return false;
            Map<String, State> stateTransitions = transitions.get(currentState.getName());
            return stateTransitions != null && stateTransitions.containsKey(event);
        }
        
        public boolean transition(String event) {
            if (!canTransition(event)) {
                return false;
            }
            
            State nextState = transitions.get(currentState.getName()).get(event);
            if (nextState != null) {
                currentState.onExit(context);
                currentState = nextState;
                currentState.onEnter(context);
                return true;
            }
            
            return false;
        }
        
        public void processEvent(Event event) {
            if (currentState != null) {
                currentState.onEvent(context, event);
            }
        }
        
        public State getCurrentState() { return currentState; }
        public String getCurrentStateName() { return currentState != null ? currentState.getName() : null; }
    }
}

/**
 * 订单状态机实现
 */
public class OrderStateMachine {
    
    /**
     * 订单状态枚举
     */
    public enum OrderState {
        PENDING("待处理"),
        CONFIRMED("已确认"),
        PAID("已支付"),
        SHIPPED("已发货"),
        DELIVERED("已送达"),
        CANCELLED("已取消"),
        REFUNDED("已退款");
        
        private final String description;
        
        OrderState(String description) {
            this.description = description;
        }
        
        public String getDescription() {
            return description;
        }
    }
    
    /**
     * 订单事件枚举
     */
    public enum OrderEvent {
        CONFIRM("确认订单"),
        PAY("支付"),
        SHIP("发货"),
        DELIVER("送达"),
        CANCEL("取消"),
        REFUND("退款");
        
        private final String description;
        
        OrderEvent(String description) {
            this.description = description;
        }
        
        public String getDescription() {
            return description;
        }
    }
    
    /**
     * 订单状态实现
     */
    public static class OrderStateImpl implements StateMachineFramework.State {
        private OrderState orderState;
        
        public OrderStateImpl(OrderState orderState) {
            this.orderState = orderState;
        }
        
        @Override
        public String getName() {
            return orderState.name();
        }
        
        @Override
        public void onEnter(StateMachineFramework.StateMachineContext context) {
            Order order = (Order) context.getEntity();
            order.setState(orderState);
            System.out.println("订单 " + order.getId() + " 进入状态: " + orderState.getDescription());
        }
        
        @Override
        public void onExit(StateMachineFramework.StateMachineContext context) {
            Order order = (Order) context.getEntity();
            System.out.println("订单 " + order.getId() + " 离开状态: " + orderState.getDescription());
        }
        
        @Override
        public void onEvent(StateMachineFramework.StateMachineContext context, StateMachineFramework.Event event) {
            Order order = (Order) context.getEntity();
            System.out.println("订单 " + order.getId() + " 在状态 " + orderState.getDescription() + " 处理事件: " + event.getName());
        }
    }
    
    /**
     * 订单事件实现
     */
    public static class OrderEventImpl implements StateMachineFramework.Event {
        private OrderEvent orderEvent;
        private Object data;
        
        public OrderEventImpl(OrderEvent orderEvent, Object data) {
            this.orderEvent = orderEvent;
            this.data = data;
        }
        
        @Override
        public String getName() {
            return orderEvent.name();
        }
        
        @Override
        public Object getData() {
            return data;
        }
    }
    
    /**
     * 订单状态机构建器
     */
    public static class OrderStateMachineBuilder {
        private StateMachineFramework.StateMachine stateMachine;
        
        public OrderStateMachineBuilder() {
            this.stateMachine = new StateMachineFramework.StateMachine();
        }
        
        public OrderStateMachineBuilder addStates() {
            // 添加所有状态
            for (OrderState state : OrderState.values()) {
                stateMachine.addState(new OrderStateImpl(state));
            }
            return this;
        }
        
        public OrderStateMachineBuilder addTransitions() {
            // 定义状态转换规则
            stateMachine.addTransition("PENDING", "CONFIRM", "CONFIRMED");
            stateMachine.addTransition("PENDING", "CANCEL", "CANCELLED");
            
            stateMachine.addTransition("CONFIRMED", "PAY", "PAID");
            stateMachine.addTransition("CONFIRMED", "CANCEL", "CANCELLED");
            
            stateMachine.addTransition("PAID", "SHIP", "SHIPPED");
            stateMachine.addTransition("PAID", "REFUND", "REFUNDED");
            
            stateMachine.addTransition("SHIPPED", "DELIVER", "DELIVERED");
            
            stateMachine.addTransition("DELIVERED", "REFUND", "REFUNDED");
            
            return this;
        }
        
        public StateMachineFramework.StateMachine build() {
            return stateMachine;
        }
    }
}

/**
 * 订单实体
 */
public class Order extends Entity<OrderId> {
    private OrderState state;
    private String customerId;
    private List<OrderItem> items;
    private Money totalAmount;
    private Address shippingAddress;
    private PaymentInfo paymentInfo;
    private StateMachineFramework.StateMachine stateMachine;
    
    public Order(OrderId id, String customerId, List<OrderItem> items, Address shippingAddress) {
        super(id);
        this.customerId = customerId;
        this.items = items;
        this.shippingAddress = shippingAddress;
        this.state = OrderState.PENDING;
        this.totalAmount = calculateTotalAmount();
        
        // 初始化状态机
        initializeStateMachine();
    }
    
    private void initializeStateMachine() {
        this.stateMachine = new OrderStateMachine.OrderStateMachineBuilder()
                .addStates()
                .addTransitions()
                .build();
        
        StateMachineFramework.StateMachineContext context = 
                new StateMachineFramework.StateMachineContext(this, stateMachine);
        stateMachine.setContext(context);
        stateMachine.setInitialState("PENDING");
    }
    
    public void confirm() {
        if (stateMachine.canTransition("CONFIRM")) {
            stateMachine.transition("CONFIRM");
        } else {
            throw new InvalidStateTransitionException("Cannot confirm order in current state: " + state);
        }
    }
    
    public void pay(PaymentInfo paymentInfo) {
        if (stateMachine.canTransition("PAY")) {
            this.paymentInfo = paymentInfo;
            stateMachine.transition("PAY");
        } else {
            throw new InvalidStateTransitionException("Cannot pay order in current state: " + state);
        }
    }
    
    public void ship(String trackingNumber) {
        if (stateMachine.canTransition("SHIP")) {
            stateMachine.setVariable("trackingNumber", trackingNumber);
            stateMachine.transition("SHIP");
        } else {
            throw new InvalidStateTransitionException("Cannot ship order in current state: " + state);
        }
    }
    
    public void deliver() {
        if (stateMachine.canTransition("DELIVER")) {
            stateMachine.transition("DELIVER");
        } else {
            throw new InvalidStateTransitionException("Cannot deliver order in current state: " + state);
        }
    }
    
    public void cancel(String reason) {
        if (stateMachine.canTransition("CANCEL")) {
            stateMachine.setVariable("cancelReason", reason);
            stateMachine.transition("CANCEL");
        } else {
            throw new InvalidStateTransitionException("Cannot cancel order in current state: " + state);
        }
    }
    
    public void refund(String reason) {
        if (stateMachine.canTransition("REFUND")) {
            stateMachine.setVariable("refundReason", reason);
            stateMachine.transition("REFUND");
        } else {
            throw new InvalidStateTransitionException("Cannot refund order in current state: " + state);
        }
    }
    
    private Money calculateTotalAmount() {
        return items.stream()
                .map(OrderItem::getSubtotal)
                .reduce(Money.ZERO, Money::add);
    }
    
    // getters
    public OrderState getState() { return state; }
    public void setState(OrderState state) { this.state = state; }
    public String getCustomerId() { return customerId; }
    public List<OrderItem> getItems() { return items; }
    public Money getTotalAmount() { return totalAmount; }
    public Address getShippingAddress() { return shippingAddress; }
    public PaymentInfo getPaymentInfo() { return paymentInfo; }
}

/**
 * 订单ID值对象
 */
public class OrderId extends ValueObject {
    private String value;
    
    public OrderId(String value) {
        this.value = value;
    }
    
    public String getValue() {
        return value;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        OrderId orderId = (OrderId) obj;
        return Objects.equals(value, orderId.value);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
}

/**
 * 订单项实体
 */
public class OrderItem extends Entity<OrderItemId> {
    private String productId;
    private String productName;
    private int quantity;
    private Money unitPrice;
    
    public OrderItem(OrderItemId id, String productId, String productName, int quantity, Money unitPrice) {
        super(id);
        this.productId = productId;
        this.productName = productName;
        this.quantity = quantity;
        this.unitPrice = unitPrice;
    }
    
    public Money getSubtotal() {
        return unitPrice.multiply(quantity);
    }
    
    // getters
    public String getProductId() { return productId; }
    public String getProductName() { return productName; }
    public int getQuantity() { return quantity; }
    public Money getUnitPrice() { return unitPrice; }
}

/**
 * 订单项ID值对象
 */
public class OrderItemId extends ValueObject {
    private String value;
    
    public OrderItemId(String value) {
        this.value = value;
    }
    
    public String getValue() {
        return value;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        OrderItemId orderItemId = (OrderItemId) obj;
        return Objects.equals(value, orderItemId.value);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
}

/**
 * 金额值对象
 */
public class Money extends ValueObject {
    public static final Money ZERO = new Money(0, "CNY");
    
    private long amount; // 以分为单位
    private String currency;
    
    public Money(long amount, String currency) {
        this.amount = amount;
        this.currency = currency;
    }
    
    public Money add(Money other) {
        if (!currency.equals(other.currency)) {
            throw new IllegalArgumentException("Cannot add different currencies");
        }
        return new Money(amount + other.amount, currency);
    }
    
    public Money subtract(Money other) {
        if (!currency.equals(other.currency)) {
            throw new IllegalArgumentException("Cannot subtract different currencies");
        }
        return new Money(amount - other.amount, currency);
    }
    
    public Money multiply(int multiplier) {
        return new Money(amount * multiplier, currency);
    }
    
    public double getAmount() {
        return amount / 100.0;
    }
    
    public String getCurrency() {
        return currency;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Money money = (Money) obj;
        return amount == money.amount && Objects.equals(currency, money.currency);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(amount, currency);
    }
    
    @Override
    public String toString() {
        return String.format("%.2f %s", getAmount(), currency);
    }
}

/**
 * 支付信息值对象
 */
public class PaymentInfo extends ValueObject {
    private String paymentMethod;
    private String transactionId;
    private Money amount;
    private long timestamp;
    
    public PaymentInfo(String paymentMethod, String transactionId, Money amount) {
        this.paymentMethod = paymentMethod;
        this.transactionId = transactionId;
        this.amount = amount;
        this.timestamp = System.currentTimeMillis();
    }
    
    // getters
    public String getPaymentMethod() { return paymentMethod; }
    public String getTransactionId() { return transactionId; }
    public Money getAmount() { return amount; }
    public long getTimestamp() { return timestamp; }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        PaymentInfo that = (PaymentInfo) obj;
        return timestamp == that.timestamp &&
               Objects.equals(paymentMethod, that.paymentMethod) &&
               Objects.equals(transactionId, that.transactionId) &&
               Objects.equals(amount, that.amount);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(paymentMethod, transactionId, amount, timestamp);
    }
}

/**
 * 事件总线
 * 实现事件驱动的核心机制
 */
public class EventBus {
    private final Map<Class<?>, List<EventHandler<?>>> handlers;
    private final ExecutorService executorService;
    private final EventStore eventStore;
    
    public EventBus(EventStore eventStore) {
        this.handlers = new ConcurrentHashMap<>();
        this.executorService = Executors.newCachedThreadPool();
        this.eventStore = eventStore;
    }
    
    /**
     * 注册事件处理器
     */
    public <T> void registerHandler(Class<T> eventType, EventHandler<T> handler) {
        handlers.computeIfAbsent(eventType, k -> new ArrayList<>()).add(handler);
    }
    
    /**
     * 发布事件
     */
    public void publish(Object event) {
        // 存储事件
        eventStore.store(event);
        
        // 异步处理事件
        executorService.submit(() -> {
            List<EventHandler<?>> eventHandlers = handlers.get(event.getClass());
            if (eventHandlers != null) {
                for (EventHandler<?> handler : eventHandlers) {
                    try {
                        @SuppressWarnings("unchecked")
                        EventHandler<Object> typedHandler = (EventHandler<Object>) handler;
                        typedHandler.handle(event);
                    } catch (Exception e) {
                        System.err.println("Error handling event: " + e.getMessage());
                        e.printStackTrace();
                    }
                }
            }
        });
    }
    
    /**
     * 同步发布事件
     */
    public void publishSync(Object event) {
        // 存储事件
        eventStore.store(event);
        
        // 同步处理事件
        List<EventHandler<?>> eventHandlers = handlers.get(event.getClass());
        if (eventHandlers != null) {
            for (EventHandler<?> handler : eventHandlers) {
                try {
                    @SuppressWarnings("unchecked")
                    EventHandler<Object> typedHandler = (EventHandler<Object>) handler;
                    typedHandler.handle(event);
                } catch (Exception e) {
                    System.err.println("Error handling event: " + e.getMessage());
                    e.printStackTrace();
                }
            }
        }
    }
    
    /**
     * 关闭事件总线
     */
    public void shutdown() {
        executorService.shutdown();
        try {
            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
                executorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            executorService.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

/**
 * 事件处理器接口
 */
public interface EventHandler<T> {
    void handle(T event);
}

/**
 * 事件存储接口
 */
public interface EventStore {
    void store(Object event);
    List<Object> getEvents(String aggregateId);
    List<Object> getEvents(String aggregateId, long fromVersion);
}

/**
 * 内存事件存储实现
 */
public class InMemoryEventStore implements EventStore {
    private final Map<String, List<StoredEvent>> events;
    private final List<Object> allEvents;
    
    public InMemoryEventStore() {
        this.events = new ConcurrentHashMap<>();
        this.allEvents = new ArrayList<>();
    }
    
    @Override
    public void store(Object event) {
        StoredEvent storedEvent = new StoredEvent(event);
        allEvents.add(event);
        
        if (event instanceof DomainEvent) {
            DomainEvent domainEvent = (DomainEvent) event;
            events.computeIfAbsent(domainEvent.getAggregateId(), k -> new ArrayList<>()).add(storedEvent);
        }
    }
    
    @Override
    public List<Object> getEvents(String aggregateId) {
        List<StoredEvent> storedEvents = events.get(aggregateId);
        if (storedEvents == null) {
            return new ArrayList<>();
        }
        
        return storedEvents.stream()
                .map(StoredEvent::getEvent)
                .collect(Collectors.toList());
    }
    
    @Override
    public List<Object> getEvents(String aggregateId, long fromVersion) {
        List<StoredEvent> storedEvents = events.get(aggregateId);
        if (storedEvents == null) {
            return new ArrayList<>();
        }
        
        return storedEvents.stream()
                .filter(se -> se.getVersion() >= fromVersion)
                .map(StoredEvent::getEvent)
                .collect(Collectors.toList());
    }
    
    public List<Object> getAllEvents() {
        return new ArrayList<>(allEvents);
    }
}

/**
 * 存储的事件
 */
public class StoredEvent {
    private Object event;
    private long version;
    private long timestamp;
    
    public StoredEvent(Object event) {
        this.event = event;
        this.version = System.currentTimeMillis();
        this.timestamp = System.currentTimeMillis();
    }
    
    public Object getEvent() { return event; }
    public long getVersion() { return version; }
    public long getTimestamp() { return timestamp; }
}

/**
 * 用户事件处理器
 */
@Component
public class UserEventHandler {
    private final EmailService emailService;
    private final NotificationService notificationService;
    private final AuditService auditService;
    
    public UserEventHandler(EmailService emailService, 
                           NotificationService notificationService,
                           AuditService auditService) {
        this.emailService = emailService;
        this.notificationService = notificationService;
        this.auditService = auditService;
    }
    
    @EventHandler
    public void handleUserCreated(UserCreatedEvent event) {
        // 发送欢迎邮件
        emailService.sendWelcomeEmail(event.getEmail(), "User");
        
        // 发送通知
        notificationService.sendNotification("user.created", event.getAggregateId());
        
        // 记录审计日志
        auditService.logEvent("USER_CREATED", event.getAggregateId(), event);
    }
    
    @EventHandler
    public void handleUserEmailChanged(UserEmailChangedEvent event) {
        // 发送邮件变更确认邮件
        emailService.sendEmailChangeConfirmation(event.getNewEmail());
        
        // 记录审计日志
        auditService.logEvent("USER_EMAIL_CHANGED", event.getAggregateId(), event);
    }
    
    @EventHandler
    public void handleUserActivated(UserActivatedEvent event) {
        // 发送激活通知
        notificationService.sendNotification("user.activated", event.getAggregateId());
        
        // 记录审计日志
        auditService.logEvent("USER_ACTIVATED", event.getAggregateId(), event);
    }
    
    @EventHandler
    public void handleUserDeactivated(UserDeactivatedEvent event) {
        // 发送停用通知
        notificationService.sendNotification("user.deactivated", event.getAggregateId());
        
        // 记录审计日志
        auditService.logEvent("USER_DEACTIVATED", event.getAggregateId(), event);
    }
}

/**
 * 订单事件处理器
 */
@Component
public class OrderEventHandler {
    private final InventoryService inventoryService;
    private final PaymentService paymentService;
    private final ShippingService shippingService;
    private final NotificationService notificationService;
    
    public OrderEventHandler(InventoryService inventoryService,
                            PaymentService paymentService,
                            ShippingService shippingService,
                            NotificationService notificationService) {
        this.inventoryService = inventoryService;
        this.paymentService = paymentService;
        this.shippingService = shippingService;
        this.notificationService = notificationService;
    }
    
    @EventHandler
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 预留库存
        inventoryService.reserveInventory(event.getProductId(), event.getQuantity());
        
        // 发送订单确认通知
        notificationService.sendNotification("order.created", event.getAggregateId());
    }
    
    @EventHandler
    public void handleOrderConfirmed(OrderConfirmedEvent event) {
        // 发送确认邮件
        notificationService.sendOrderConfirmation(event.getAggregateId());
    }
    
    @EventHandler
    public void handleOrderPaid(OrderPaidEvent event) {
        // 处理支付
        paymentService.processPayment(event.getPaymentInfo());
        
        // 准备发货
        shippingService.prepareShipment(event.getAggregateId());
        
        // 发送支付确认通知
        notificationService.sendNotification("order.paid", event.getAggregateId());
    }
    
    @EventHandler
    public void handleOrderShipped(OrderShippedEvent event) {
        // 更新库存
        inventoryService.releaseReservedInventory(event.getProductId(), event.getQuantity());
        
        // 发送发货通知
        notificationService.sendShippingNotification(event.getAggregateId(), event.getTrackingNumber());
    }
    
    @EventHandler
    public void handleOrderDelivered(OrderDeliveredEvent event) {
        // 发送送达确认
        notificationService.sendDeliveryConfirmation(event.getAggregateId());
        
        // 触发评价流程
        notificationService.sendReviewRequest(event.getAggregateId());
    }
    
    @EventHandler
    public void handleOrderCancelled(OrderCancelledEvent event) {
        // 释放库存
        inventoryService.releaseReservedInventory(event.getProductId(), event.getQuantity());
        
        // 处理退款
        if (event.getPaymentInfo() != null) {
            paymentService.processRefund(event.getPaymentInfo());
        }
        
        // 发送取消通知
        notificationService.sendNotification("order.cancelled", event.getAggregateId());
    }
}

/**
 * 订单相关事件
 */
public class OrderCreatedEvent extends DomainEvent {
    private String productId;
    private int quantity;
    private String customerId;
    
    public OrderCreatedEvent(String aggregateId, String productId, int quantity, String customerId) {
        super(aggregateId);
        this.productId = productId;
        this.quantity = quantity;
        this.customerId = customerId;
    }
    
    public String getProductId() { return productId; }
    public int getQuantity() { return quantity; }
    public String getCustomerId() { return customerId; }
}

public class OrderConfirmedEvent extends DomainEvent {
    public OrderConfirmedEvent(String aggregateId) {
        super(aggregateId);
    }
}

public class OrderPaidEvent extends DomainEvent {
    private PaymentInfo paymentInfo;
    
    public OrderPaidEvent(String aggregateId, PaymentInfo paymentInfo) {
        super(aggregateId);
        this.paymentInfo = paymentInfo;
    }
    
    public PaymentInfo getPaymentInfo() { return paymentInfo; }
}

public class OrderShippedEvent extends DomainEvent {
    private String productId;
    private int quantity;
    private String trackingNumber;
    
    public OrderShippedEvent(String aggregateId, String productId, int quantity, String trackingNumber) {
        super(aggregateId);
        this.productId = productId;
        this.quantity = quantity;
        this.trackingNumber = trackingNumber;
    }
    
    public String getProductId() { return productId; }
    public int getQuantity() { return quantity; }
    public String getTrackingNumber() { return trackingNumber; }
}

public class OrderDeliveredEvent extends DomainEvent {
    public OrderDeliveredEvent(String aggregateId) {
        super(aggregateId);
    }
}

public class OrderCancelledEvent extends DomainEvent {
    private String productId;
    private int quantity;
    private PaymentInfo paymentInfo;
    private String reason;
    
    public OrderCancelledEvent(String aggregateId, String productId, int quantity, PaymentInfo paymentInfo, String reason) {
        super(aggregateId);
        this.productId = productId;
        this.quantity = quantity;
        this.paymentInfo = paymentInfo;
        this.reason = reason;
    }
    
    public String getProductId() { return productId; }
    public int getQuantity() { return quantity; }
    public PaymentInfo getPaymentInfo() { return paymentInfo; }
    public String getReason() { return reason; }
}