// 外部CRM系统的模型(不可控)
public class ExternalCustomerRecord {
    private String custId;
    private String fullName;
    private String primaryPhone;
    private String secondaryPhone;
    private String emailAddress;
    private String accountStatus; // "A", "I", "S", "T"
    private String customerType;  // "INDIVIDUAL", "CORPORATE"
    private List<String> tags;
    private Map<String, Object> customFields;
    
    // getters and setters
}

// 内部领域模型
public class Customer {
    private CustomerId id;
    private Name name;
    private ContactInfo contactInfo;
    private CustomerStatus status;
    private CustomerType type;
    private Set<Tag> tags;
    
    public Customer(CustomerId id, Name name, ContactInfo contactInfo, 
                    CustomerStatus status, CustomerType type, Set<Tag> tags) {
        this.id = id;
        this.name = name;
        this.contactInfo = contactInfo;
        this.status = status;
        this.type = type;
        this.tags = tags;
    }
    
    // business methods
    public boolean isActive() {
        return status == CustomerStatus.ACTIVE;
    }
}

// 值对象
public class Name {
    private String firstName;
    private String lastName;
    
    public Name(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

public class ContactInfo {
    private PhoneNumber primaryPhone;
    private PhoneNumber secondaryPhone;
    private EmailAddress email;
    
    public ContactInfo(PhoneNumber primaryPhone, PhoneNumber secondaryPhone, 
                       EmailAddress email) {
        this.primaryPhone = primaryPhone;
        this.secondaryPhone = secondaryPhone;
        this.email = email;
    }
}

// 防腐层实现
@Component
public class CrmAntiCorruptionLayer {
    
    private static final Map<String, CustomerStatus> STATUS_MAPPING = Map.of(
        "A", CustomerStatus.ACTIVE,
        "I", CustomerStatus.INACTIVE,
        "S", CustomerStatus.SUSPENDED,
        "T", CustomerStatus.TERMINATED
    );
    
    private static final Map<String, CustomerType> TYPE_MAPPING = Map.of(
        "INDIVIDUAL", CustomerType.INDIVIDUAL,
        "CORPORATE", CustomerType.CORPORATE
    );
    
    @Autowired
    private TagRepository tagRepository;
    
    /**
     * 将外部CRM记录转换为内部Customer领域对象
     */
    public Customer translateToCustomer(ExternalCustomerRecord external) {
        if (external == null) {
            throw new IllegalArgumentException("外部记录不能为空");
        }
        
        CustomerId id = parseCustomerId(external.getCustId());
        Name name = parseName(external.getFullName());
        ContactInfo contactInfo = buildContactInfo(external);
        CustomerStatus status = translateStatus(external.getAccountStatus());
        CustomerType type = translateType(external.getCustomerType());
        Set<Tag> tags = translateTags(external.getTags());
        
        return new Customer(id, name, contactInfo, status, type, tags);
    }
    
    private CustomerId parseCustomerId(String custId) {
        if (custId == null || custId.isEmpty()) {
            throw new IllegalArgumentException("客户ID不能为空");
        }
        // 假设外部ID需要转换为内部UUID格式
        return new CustomerId(generateUuidFromExternalId(custId));
    }
    
    private Name parseName(String fullName) {
        if (fullName == null || fullName.isEmpty()) {
            return new Name("", "");
        }
        
        String[] parts = fullName.trim().split("\\s+", 2);
        String firstName = parts[0];
        String lastName = parts.length > 1 ? parts[1] : "";
        
        return new Name(firstName, lastName);
    }
    
    private ContactInfo buildContactInfo(ExternalCustomerRecord external) {
        PhoneNumber primaryPhone = external.getPrimaryPhone() != null 
            ? new PhoneNumber(external.getPrimaryPhone()) 
            : null;
            
        PhoneNumber secondaryPhone = external.getSecondaryPhone() != null 
            ? new PhoneNumber(external.getSecondaryPhone()) 
            : null;
            
        EmailAddress email = external.getEmailAddress() != null 
            ? new EmailAddress(external.getEmailAddress()) 
            : null;
        
        return new ContactInfo(primaryPhone, secondaryPhone, email);
    }
    
    private CustomerStatus translateStatus(String externalStatus) {
        if (externalStatus == null) {
            return CustomerStatus.UNKNOWN;
        }
        
        CustomerStatus status = STATUS_MAPPING.get(externalStatus.toUpperCase());
        if (status == null) {
            // 记录警告日志,使用默认状态
            log.warn("未知的客户状态: {}", externalStatus);
            return CustomerStatus.UNKNOWN;
        }
        
        return status;
    }
    
    private CustomerType translateType(String externalType) {
        if (externalType == null) {
            return CustomerType.INDIVIDUAL; // 默认值
        }
        
        CustomerType type = TYPE_MAPPING.get(externalType.toUpperCase());
        if (type == null) {
            log.warn("未知的客户类型: {}", externalType);
            return CustomerType.OTHER;
        }
        
        return type;
    }
    
    private Set<Tag> translateTags(List<String> externalTags) {
        if (externalTags == null || externalTags.isEmpty()) {
            return Collections.emptySet();
        }
        
        return externalTags.stream()
            .map(this::findOrCreateTag)
            .filter(Objects::nonNull)
            .collect(Collectors.toSet());
    }
    
    private Tag findOrCreateTag(String tagName) {
        // 尝试从仓库中查找现有标签
        Optional<Tag> existingTag = tagRepository.findByName(tagName);
        if (existingTag.isPresent()) {
            return existingTag.get();
        }
        
        // 如果标签不存在,创建新标签(需要根据业务规则决定是否允许)
        try {
            Tag newTag = new Tag(tagName);
            return tagRepository.save(newTag);
        } catch (Exception e) {
            log.error("创建标签失败: {}", tagName, e);
            return null;
        }
    }
    
    private String generateUuidFromExternalId(String externalId) {
        // 简化的转换逻辑,实际可能需要更复杂的映射
        return UUID.nameUUIDFromBytes(externalId.getBytes()).toString();
    }
}

// 发布语言:使用JSON Schema定义的标准数据格式
public class ProductPublishedDTO {
    private String productId;      // 标准化的产品ID
    private String productName;    // 产品名称
    private BigDecimal unitPrice;  // 单价
    private String currency;       // 币种代码(ISO 4217)
    private String category;       // 分类编码
    private LocalDateTime updatedAt; // 最后更新时间
    
    // 构造函数、getter、setter
}

// 开放主机服务:REST API实现
@RestController
@RequestMapping("/api/v1/products")
@CrossOrigin(origins = "*") // 允许跨域访问
public class ProductOpenHostService {
    
    @Autowired
    private ProductService productService;
    
    /**
     * 获取产品信息
     */
    @GetMapping("/{productId}")
    public ResponseEntity<ProductPublishedDTO> getProduct(@PathVariable String productId) {
        Product product = productService.findById(new ProductId(productId));
        if (product == null) {
            return ResponseEntity.notFound().build();
        }
        
        ProductPublishedDTO dto = ProductMapper.toPublishedDTO(product);
        return ResponseEntity.ok(dto);
    }
    
    /**
     * 批量获取产品信息
     */
    @PostMapping("/batch")
    public ResponseEntity<List<ProductPublishedDTO>> getProducts(@RequestBody BatchRequest request) {
        List<ProductPublishedDTO> products = request.getProductIds().stream()
            .map(id -> productService.findById(new ProductId(id)))
            .filter(Objects::nonNull)
            .map(ProductMapper::toPublishedDTO)
            .collect(Collectors.toList());
        
        return ResponseEntity.ok(products);
    }
    
    /**
     * 查询产品列表(支持分页和过滤)
     */
    @GetMapping
    public ResponseEntity<Page<ProductPublishedDTO>> listProducts(
            @RequestParam(required = false) String category,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size) {
        
        Page<Product> productPage = productService.findByCategory(category, PageRequest.of(page, size));
        Page<ProductPublishedDTO> dtoPage = productPage.map(ProductMapper::toPublishedDTO);
        
        return ResponseEntity.ok(dtoPage);
    }
}

// 消息队列中的发布语言实现
@Component
public class ProductEventPublisher {
    
    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;
    
    private static final String TOPIC = "product.events";
    
    /**
     * 发布产品变更事件
     */
    public void publishProductUpdated(Product product) {
        ProductPublishedDTO dto = ProductMapper.toPublishedDTO(product);
        
        ProductEvent event = new ProductEvent(
            "PRODUCT_UPDATED",
            product.getId().toString(),
            LocalDateTime.now(),
            dto
        );
        
        String message = JsonUtils.toJson(event);
        kafkaTemplate.send(TOPIC, product.getId().toString(), message);
    }
}

// 事件数据结构
public class ProductEvent {
    private String eventType;
    private String aggregateId;
    private LocalDateTime timestamp;
    private ProductPublishedDTO data;
    
    // constructor, getters
}

// 共享内核模块:common-kernel
package com.example.common.kernel;

/**
 * 共享的值对象:货币金额
 * 所有使用该内核的限界上下文都应使用此类表示金额
 */
public class Money implements Comparable<Money> {
    
    public static final Money ZERO = new Money(BigDecimal.ZERO, Currency.getInstance("CNY"));
    
    private final BigDecimal amount;
    private final Currency currency;
    
    public Money(BigDecimal amount, Currency currency) {
        if (amount == null || currency == null) {
            throw new IllegalArgumentException("金额和币种不能为空");
        }
        this.amount = amount.setScale(2, RoundingMode.HALF_UP);
        this.currency = currency;
    }
    
    public Money add(Money other) {
        checkSameCurrency(other);
        return new Money(this.amount.add(other.amount), this.currency);
    }
    
    public Money subtract(Money other) {
        checkSameCurrency(other);
        return new Money(this.amount.subtract(other.amount), this.currency);
    }
    
    public Money multiply(BigDecimal multiplier) {
        return new Money(this.amount.multiply(multiplier), this.currency);
    }
    
    public boolean isGreaterThan(Money other) {
        checkSameCurrency(other);
        return this.amount.compareTo(other.amount) > 0;
    }
    
    private void checkSameCurrency(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException(
                String.format("币种不一致: %s vs %s", this.currency, other.currency)
            );
        }
    }
    
    @Override
    public int compareTo(Money other) {
        checkSameCurrency(other);
        return this.amount.compareTo(other.amount);
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Money money = (Money) o;
        return amount.compareTo(money.amount) == 0 && currency.equals(money.currency);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(amount, currency);
    }
}

/**
 * 共享的枚举:订单状态
 */
public enum OrderStatus {
    CREATED,      // 已创建
    CONFIRMED,    // 已确认
    PROCESSING,   // 处理中
    SHIPPED,      // 已发货
    DELIVERED,    // 已送达
    COMPLETED,    // 已完成
    CANCELLED,    // 已取消
    REFUNDED      // 已退款
}

/**
 * 共享的工具类:日期时间工具
 */
public class DateTimeUtils {
    
    private static final ZoneId DEFAULT_ZONE = ZoneId.of("Asia/Shanghai");
    
    public static LocalDate today() {
        return LocalDate.now(DEFAULT_ZONE);
    }
    
    public static LocalDateTime now() {
        return LocalDateTime.now(DEFAULT_ZONE);
    }
    
    public static boolean isBusinessDay(LocalDate date) {
        DayOfWeek dayOfWeek = date.getDayOfWeek();
        return dayOfWeek != DayOfWeek.SATURDAY && dayOfWeek != DayOfWeek.SUNDAY;
    }
    
    public static LocalDate addBusinessDays(LocalDate date, int days) {
        LocalDate result = date;
        int remainingDays = days;
        
        while (remainingDays > 0) {
            result = result.plusDays(1);
            if (isBusinessDay(result)) {
                remainingDays--;
            }
        }
        
        return result;
    }
}

# 共享内核使用规范

## 版本管理
- 当前版本: 1.2.0
- 变更日志: 见 CHANGELOG.md

## 添加新功能到内核的流程
1. 在内核仓库中提交RFC(Request for Comments)
2. 所有相关团队评审RFC
3. 获得至少两个团队的批准后合并
4. 发布新版本并通知所有消费者

## 兼容性承诺
- 主版本号变更: 不兼容的API变更
- 次版本号变更: 向后兼容的功能新增
- 修订号变更: 向后兼容的问题修复

## 已知问题
- Money类在处理极高精度计算时可能存在舍入误差
- DateTimeUtils未考虑夏令时变化