Java设计模式与系统架构：从理论到实战的深度解析-优快云博客

Java设计模式与系统架构：从理论到实战的深度解析

第一章：引言

在当今快速发展的软件开发领域中，我们面临着日益复杂的系统需求和不断变化的技术环境。据统计，全球每年因软件设计缺陷导致的维护成本高达数千亿美元。在这样的背景下，良好的设计模式与架构思想成为了保障软件质量、降低维护成本的关键因素。

作为Java开发者，我们常常面临这样的困境：一方面要保证代码的灵活性和可扩展性，另一方面又要满足项目的紧迫交付期限。这就需要我们深入理解设计模式与系统架构之间的内在联系，掌握从宏观架构到微观设计的完整知识体系。

本文将带领大家深入探讨Java设计模式与系统架构的相关性，从理论基础到实战应用，从传统设计到前沿趋势，为读者构建一个完整的设计思维框架。通过系统的分析和真实的案例，帮助大家在日常开发中做出更合理的设计决策。

第二章：基石篇—深入理解设计模式与系统架构

2.1 软件设计模式的精髓

设计模式并非银弹，而是经验丰富的开发者们在特定上下文中解决常见问题的经验总结。这些模式的形成经历了实践的反复验证，最终由GoF（Gang of Four）在《设计模式：可复用面向对象软件的基础》一书中系统化地提出。

2.1.1 六大设计原则

单一职责原则（SRP） 要求一个类只应有一个引起变化的原因。这不仅适用于类级别，在方法级别同样重要。例如：

// 违反SRP的示例
public class UserService {
    public void registerUser(String username, String password) {
        // 验证逻辑
        if (username == null || username.length() < 3) {
            throw new IllegalArgumentException("用户名无效");
        }
        // 加密密码
        String encryptedPassword = encryptPassword(password);
        // 保存到数据库
        saveToDatabase(username, encryptedPassword);
        // 发送欢迎邮件
        sendWelcomeEmail(username);
    }
}

// 符合SRP的改进
public class UserValidator {
    public boolean validateUser(String username) {
        return username != null && username.length() >= 3;
    }
}

public class UserRepository {
    public void saveUser(String username, String encryptedPassword) {
        // 数据库操作
    }
}

public class EmailService {
    public void sendWelcomeEmail(String username) {
        // 邮件发送逻辑
    }
}

开闭原则（OCP） 强调对扩展开放，对修改关闭。这一原则在现代框架设计中体现得淋漓尽致。以Spring框架为例，其通过依赖注入和面向接口编程完美实现了这一原则。

里氏替换原则（LSP） 要求子类必须能够替换它们的父类而不影响程序正确性。这一原则确保了继承关系的合理性。

接口隔离原则（ISP） 指导我们设计小而专注的接口，避免"胖接口"带来的实现负担。

依赖倒置原则（DIP） 强调高层模块不应依赖低层模块，二者都应依赖于抽象。这一原则是构建可测试软件的基础。

2.1.2 模式的三大分类

创建型模式 关注对象创建机制，如工厂方法模式通过抽象创建过程来提升系统的灵活性：

public interface ConnectionFactory {
    Connection createConnection();
}

public class MySQLConnectionFactory implements ConnectionFactory {
    @Override
    public Connection createConnection() {
        return new MySQLConnection();
    }
}

结构型模式 处理类和对象的组合，如适配器模式使得不兼容的接口能够协同工作。

行为型模式 负责对象间的职责分配和算法抽象，如策略模式封装可互换的算法族。

2.2 系统架构的宏大蓝图

软件架构定义了系统的骨骼结构，正如著名软件架构师Grady Booch所言：“架构代表了系统的重要设计决策，这些决策决定了系统的质量属性及其维护的难易程度。”

2.2.1 分层架构模式

经典的三层架构将系统划分为表示层、业务逻辑层和数据访问层，每一层都有明确的职责边界：

表示层（Presentation Layer）
    ↓
业务逻辑层（Business Logic Layer）  
    ↓
数据访问层（Data Access Layer）

这种分层不仅促进了关注点分离，还使得各层可以独立演化和测试。

2.2.2 微服务架构的兴起

微服务架构通过将单一应用拆分为一组小型服务来提升系统的可维护性和可扩展性。每个服务围绕业务能力构建，可以独立部署和扩展。

2.3 概念辨析：模式、架构、框架与平台

理解这些概念的差异对于构建清晰的设计思维至关重要：

设计模式是解决特定问题的经验总结，是知识的抽象
架构是系统的高层次结构，定义组件关系和约束
框架是软件的半成品，提供可扩展的代码基础
平台是应用程序运行的环境，提供基础设施支持

从复用层级来看，设计模式处于最底层，提供思想层面的指导；架构处于系统设计层面；框架处于模块复用层面；平台则提供完整的运行环境。

第三章：关联篇—设计模式与系统架构的协同与共生

3.1 微观设计与宏观结构的衔接

设计模式与系统架构的关系可以比作建筑材料与建筑蓝图的关系。优秀的建筑既需要合理的整体结构（架构），也需要优质的建材和施工工艺（设计模式）。

3.1.1 模式是架构思想的微观实现

在微服务架构中，单个服务内部往往采用多种设计模式来实现其业务逻辑。例如，一个订单服务可能使用：

工厂模式创建复杂的订单对象
策略模式处理不同的支付方式
观察者模式通知相关系统订单状态变化
装饰器模式为订单添加额外的业务逻辑

// 在微服务中应用多种设计模式
@Service
public class OrderService {
    private final PaymentStrategyFactory strategyFactory;
    private final OrderObserverManager observerManager;
    
    public Order processOrder(OrderRequest request) {
        // 工厂模式创建订单
        Order order = OrderFactory.createOrder(request);
        
        // 策略模式处理支付
        PaymentStrategy strategy = strategyFactory.getStrategy(request.getPaymentType());
        strategy.processPayment(order);
        
        // 观察者模式通知相关系统
        observerManager.notifyObservers(order);
        
        return order;
    }
}

3.1.2 架构为模式应用提供上下文

不同的架构风格会自然地引导出特定的设计模式应用。在事件驱动架构中，观察者模式和发布-订阅模式成为核心组成部分；在领域驱动设计（DDD）中，工厂模式、仓库模式和价值对象模式被广泛使用。

3.2 设计原则的共同哲学

软件设计的核心原则在不同的抽象层级上展现出惊人的一致性。以依赖倒置原则为例，这一原则在架构层面和代码层面都有重要体现。

在架构层面，依赖倒置体现为稳定抽象原则：架构中的高层策略不应依赖于低层细节。在微服务架构中，这表现为服务之间通过稳定的API契约进行通信，而不是直接依赖具体实现。

在代码层面，依赖倒置通过面向接口编程实现：

// 高层模块定义抽象
public interface OrderRepository {
    Order findById(String id);
    void save(Order order);
}

// 低层模块实现抽象
public class JpaOrderRepository implements OrderRepository {
    // 具体实现
}

// 业务逻辑依赖于抽象
@Service
public class OrderService {
    private final OrderRepository orderRepository; // 依赖抽象
    
    public OrderService(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }
}

3.3 不同层面的问题解决策略

虽然设计模式和系统架构共享相同的设计哲学，但它们解决的问题处于不同的抽象层级。

设计模式关注的问题：

对象创建的逻辑抽象
类与对象的结构组织
对象间的交互和职责分配
算法的封装和替换

系统架构关注的问题：

系统的整体分解和模块划分
技术栈选型和集成策略
数据流和控制流的规划设计
质量属性的实现和权衡

这种关注点的分离使得开发团队可以在不同层级上并行工作，架构师关注系统级问题，开发人员关注组件级实现。

第四章：实战篇—架构演进中的设计模式应用

4.1 案例背景：ID生成器的重构与演进

让我们通过一个真实的案例来展示设计模式如何支撑架构的演进。假设我们有一个为分布式系统生成唯一ID的需求，最初可能从一个简单的实现开始：

// 初始实现 - 存在多种设计问题
public class IdGenerator {
    private static long lastTimestamp = 0L;
    private static long sequence = 0L;
    
    public static synchronized String generateId() {
        long timestamp = System.currentTimeMillis();
        
        if (timestamp < lastTimestamp) {
            throw new RuntimeException("时钟回拨异常");
        }
        
        if (timestamp == lastTimestamp) {
            sequence = (sequence + 1) & 0xFFF;
            if (sequence == 0) {
                timestamp = tillNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0L;
        }
        
        lastTimestamp = timestamp;
        
        return ((timestamp - 1609459200000L) << 12) | sequence;
    }
}

这个初始实现存在多个问题：

使用静态方法，难以测试和扩展
硬编码算法逻辑，违反开闭原则
缺乏异常处理的灵活性
不支持多种ID生成策略

4.2 重构策略与模式应用

4.2.1 引入策略模式

首先，我们使用策略模式将ID生成算法抽象出来：

public interface IdGenerationStrategy {
    String generateId();
    boolean validate(String id);
}

public class SnowflakeStrategy implements IdGenerationStrategy {
    private final long datacenterId;
    private final long machineId;
    private long sequence = 0L;
    private long lastTimestamp = -1L;
    
    public SnowflakeStrategy(long datacenterId, long machineId) {
        this.datacenterId = datacenterId;
        this.machineId = machineId;
    }
    
    @Override
    public synchronized String generateId() {
        // 雪花算法实现
    }
}

public class UUIDStrategy implements IdGenerationStrategy {
    @Override
    public String generateId() {
        return UUID.randomUUID().toString();
    }
}

4.2.2 应用工厂方法模式

接着，使用工厂方法模式来创建不同的策略实例：

public class IdStrategyFactory {
    public static IdGenerationStrategy createStrategy(String type, 
                                                    Map<String, Object> config) {
        switch (type.toLowerCase()) {
            case "snowflake":
                long datacenterId = (Long) config.getOrDefault("datacenterId", 1L);
                long machineId = (Long) config.getOrDefault("machineId", 1L);
                return new SnowflakeStrategy(datacenterId, machineId);
                
            case "uuid":
                return new UUIDStrategy();
                
            case "redis":
                String redisHost = (String) config.get("redisHost");
                int redisPort = (Integer) config.getOrDefault("redisPort", 6379);
                return new RedisSequenceStrategy(redisHost, redisPort);
                
            default:
                throw new IllegalArgumentException("不支持的ID生成策略: " + type);
        }
    }
}

4.2.3 构建完整的ID生成服务

最后，我们构建一个完整且可扩展的ID生成服务：

@Service
public class DistributedIdService {
    private final IdGenerationStrategy strategy;
    private final IdValidator validator;
    
    public DistributedIdService(IdGenerationStrategy strategy, IdValidator validator) {
        this.strategy = strategy;
        this.validator = validator;
    }
    
    public String generateId() {
        String id = strategy.generateId();
        if (!validator.validate(id)) {
            throw new IdGenerationException("生成的ID验证失败");
        }
        return id;
    }
    
    public boolean validateId(String id) {
        return validator.validate(id);
    }
}

// 配置类
@Configuration
public class IdGeneratorConfig {
    
    @Bean
    @ConditionalOnProperty(name = "id.generator.strategy", havingValue = "snowflake")
    public IdGenerationStrategy snowflakeStrategy(Environment env) {
        long datacenterId = env.getProperty("id.generator.datacenter-id", Long.class, 1L);
        long machineId = env.getProperty("id.generator.machine-id", Long.class, 1L);
        return new SnowflakeStrategy(datacenterId, machineId);
    }
}

4.3 重构效果分析

通过应用设计模式进行重构，我们获得了显著的质量提升：

可测试性改进：

@ExtendWith(MockitoExtension.class)
class DistributedIdServiceTest {
    
    @Mock
    private IdGenerationStrategy strategy;
    
    @Mock
    private IdValidator validator;
    
    @InjectMocks
    private DistributedIdService idService;
    
    @Test
    void shouldGenerateIdSuccessfully() {
        when(strategy.generateId()).thenReturn("123456789");
        when(validator.validate(anyString())).thenReturn(true);
        
        String id = idService.generateId();
        
        assertNotNull(id);
        verify(strategy).generateId();
        verify(validator).validate("123456789");
    }
}

扩展性提升：新增ID生成算法时，只需实现IdGenerationStrategy接口并在工厂中添加配置，无需修改现有代码。

维护性增强：各组件职责单一，便于理解和维护。

第五章：前沿篇—技术演进中的新思考

5.1 Java新特性与设计模式的演化

随着Java语言的不断发展，新特性正在改变传统设计模式的实现方式。

5.1.1 记录类（Records）与不可变模式

Java 14引入的记录类极大地简化了不可变对象的创建：

// 传统方式
public final class TraditionalPoint {
    private final double x;
    private final double y;
    
    public TraditionalPoint(double x, double y) {
        this.x = x;
        this.y = y;
    }
    
    // getters, equals, hashCode, toString 等方法
}

// 使用Record
public record Point(double x, double y) {
    // 自动生成constructor, getters, equals, hashCode, toString
}

记录类与工厂模式结合使用，可以创建更加清晰的对象创建逻辑：

public record UserInfo(String userId, String username, String email) {
    
    public static class Factory {
        public static UserInfo createFromDTO(UserDTO dto) {
            return new UserInfo(
                generateUserId(),
                dto.getUsername(),
                dto.getEmail()
            );
        }
        
        public static UserInfo createFromEntity(UserEntity entity) {
            return new UserInfo(
                entity.getUserId(),
                entity.getUsername(),
                entity.getEmail()
            );
        }
    }
}

5.1.2 Sealed Classes与策略模式

Sealed Classes（密封类）为策略模式提供了更强的编译时检查：

public sealed interface PaymentStrategy 
    permits CreditCardStrategy, PayPalStrategy, CryptoStrategy {
    
    PaymentResult processPayment(PaymentRequest request);
}

public final class CreditCardStrategy implements PaymentStrategy {
    @Override
    public PaymentResult processPayment(PaymentRequest request) {
        // 信用卡支付实现
    }
}

public final class PayPalStrategy implements PaymentStrategy {
    @Override
    public PaymentResult processPayment(PaymentRequest request) {
        // PayPal支付实现
    }
}

// 新添加的策略必须在此处声明，否则编译失败

5.2 云原生与微服务架构下的模式新内涵

在云原生环境中，传统设计模式被赋予了新的含义和实现方式。

5.2.1 服务发现与代理模式

在微服务架构中，客户端服务发现可以看作是代理模式在分布式环境下的应用：

@Service
public class ProductServiceProxy {
    private final DiscoveryClient discoveryClient;
    private final LoadBalancerClient loadBalancer;
    private final RestTemplate restTemplate;
    
    public Product getProduct(String productId) {
        ServiceInstance instance = loadBalancer.choose("product-service");
        String url = String.format("http://%s:%s/products/%s", 
            instance.getHost(), instance.getPort(), productId);
        
        return restTemplate.getForObject(url, Product.class);
    }
}

5.2.2 配置外部化与单例模式

在云原生环境中，传统的单例模式需要重新思考。配置信息通常从代码中外部化，由配置中心统一管理：

@Configuration
public class AppConfig {
    
    @Bean
    @RefreshScope  // 支持配置动态刷新
    public DataSource dataSource(
            @Value("${database.url}") String url,
            @Value("${database.username}") String username,
            @Value("${database.password}") String password) {
        
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(url);
        config.setUsername(username);
        config.setPassword(password);
        
        return new HikariDataSource(config);
    }
}

5.3 响应式编程与新模式的出现

响应式编程范式催生了一些新的设计模式和实践：

@Component
public class OrderProcessingHandler {
    
    public Mono<OrderResult> processOrder(Order order) {
        return validateOrder(order)
            .flatMap(this::checkInventory)
            .flatMap(this::processPayment)
            .flatMap(this::updateInventory)
            .onErrorResume(this::handleError)
            .doOnSuccess(this::sendNotification);
    }
    
    private Mono<Order> validateOrder(Order order) {
        return Mono.fromCallable(() -> {
            if (order.isValid()) {
                return order;
            }
            throw new ValidationException("订单验证失败");
        }).subscribeOn(Schedulers.boundedElastic());
    }
}

这种链式处理结合了责任链模式和反应式流模式，提供了更好的资源利用率和可组合性。

第六章：综合实战—构建一个可扩展的厘米秀装扮系统

6.1 案例场景介绍

厘米秀装扮系统需要支持多种风格的服饰套装，每个套装包含多个协调的部件。系统需要保证：

同一套装的各个部件风格一致
支持灵活扩展新的风格
提供统一的获取接口
具有良好的可测试性

6.2 架构与模式设计

我们采用分层架构结合抽象工厂模式来满足需求：

架构层次：

表示层：REST API接口
业务逻辑层：装扮服务核心逻辑
数据访问层：服饰数据持久化

核心模式：抽象工厂模式确保同一风格的产品族一致性

6.3 核心代码实现

6.3.1 领域模型设计

// 抽象产品接口
public interface CostumePart {
    String getPartType();
    String getStyle();
    String getDescription();
    Map<String, Object> getProperties();
}

public interface Hat extends CostumePart {}
public interface Coat extends CostumePart {}  
public interface Pants extends CostumePart {}
public interface Shoes extends CostumePart {}

// 抽象工厂接口
public interface CostumeFactory {
    String getStyle();
    Hat createHat();
    Coat createCoat(); 
    Pants createPants();
    Shoes createShoes();
    
    default CostumeSet createCompleteSet() {
        return new CostumeSet(
            getStyle(),
            createHat(),
            createCoat(),
            createPants(),
            createShoes()
        );
    }
}

// 值对象
public record CostumeSet(
    String style,
    Hat hat,
    Coat coat, 
    Pants pants,
    Shoes shoes
) {
    public boolean isComplete() {
        return hat != null && coat != null && pants != null && shoes != null;
    }
    
    public String getDisplayInfo() {
        return String.format(
            "%s套装: [帽子: %s, 上衣: %s, 裤子: %s, 鞋子: %s]",
            style, hat.getDescription(), coat.getDescription(), 
            pants.getDescription(), shoes.getDescription()
        );
    }
}

6.3.2 具体产品实现

// 现代风产品族
public class ModernHat implements Hat {
    @Override public String getPartType() { return "HAT"; }
    @Override public String getStyle() { return "MODERN"; }
    @Override public String getDescription() { return "潮流棒球帽"; }
    @Override public Map<String, Object> getProperties() { 
        return Map.of("material", "棉质", "hasBrim", true); 
    }
}

public class ModernCoat implements Coat {
    @Override public String getPartType() { return "COAT"; }
    @Override public String getStyle() { return "MODERN"; }
    @Override public String getDescription() { return "时尚夹克"; }
    @Override public Map<String, Object> getProperties() {
        return Map.of("material", "皮革", "hasHood", false);
    }
}

// 复古风产品族
public class RetroHat implements Hat {
    @Override public String getPartType() { return "HAT"; }
    @Override public String getStyle() { return "RETRO"; }
    @Override public String getDescription() { return "贝雷帽"; }
    @Override public Map<String, Object> getProperties() {
        return Map.of("material", "羊毛", "isVintage", true);
    }
}

public class RetroCoat implements Coat {
    @Override public String getPartType() { return "COAT"; }
    @Override public String getStyle() { return "RETRO"; }
    @Override public String getDescription() { return "双排扣大衣"; }
    @Override public Map<String, Object> getProperties() {
        return Map.of("material", "呢料", "hasBelt", true);
    }
}

6.3.3 具体工厂实现

@Component
public class ModernCostumeFactory implements CostumeFactory {
    @Override public String getStyle() { return "MODERN"; }
    
    @Override public Hat createHat() { 
        return new ModernHat(); 
    }
    
    @Override public Coat createCoat() { 
        return new ModernCoat(); 
    }
    
    @Override public Pants createPants() { 
        return new ModernPants(); 
    }
    
    @Override public Shoes createShoes() { 
        return new ModernShoes(); 
    }
}

@Component  
public class RetroCostumeFactory implements CostumeFactory {
    @Override public String getStyle() { return "RETRO"; }
    
    @Override public Hat createHat() { 
        return new RetroHat(); 
    }
    
    @Override public Coat createCoat() { 
        return new RetroCoat(); 
    }
    
    @Override public Pants createPants() { 
        return new RetroPants(); 
    }
    
    @Override public Shoes createShoes() { 
        return new RetroShoes(); 
    }
}

6.3.4 服务层实现

@Service
@Transactional
public class CostumeService {
    private final Map<String, CostumeFactory> factoryRegistry;
    private final CostumePartRepository partRepository;
    
    public CostumeService(List<CostumeFactory> factories, 
                         CostumePartRepository partRepository) {
        this.factoryRegistry = factories.stream()
            .collect(Collectors.toMap(CostumeFactory::getStyle, Function.identity()));
        this.partRepository = partRepository;
    }
    
    public CostumeSet createCostumeSet(String style) {
        CostumeFactory factory = factoryRegistry.get(style.toUpperCase());
        if (factory == null) {
            throw new UnsupportedStyleException("不支持的风格: " + style);
        }
        
        CostumeSet set = factory.createCompleteSet();
        validateCostumeSet(set);
        
        return set;
    }
    
    public List<String> getAvailableStyles() {
        return new ArrayList<>(factoryRegistry.keySet());
    }
    
    public boolean validateCostumeSet(CostumeSet set) {
        if (!set.isComplete()) {
            throw new IncompleteCostumeException("装扮套装不完整");
        }
        
        // 验证所有部件风格一致
        String expectedStyle = set.style();
        return set.hat().getStyle().equals(expectedStyle) &&
               set.coat().getStyle().equals(expectedStyle) &&
               set.pants().getStyle().equals(expectedStyle) &&
               set.shoes().getStyle().equals(expectedStyle);
    }
    
    public CostumeSet mixAndMatch(String hatStyle, String coatStyle, 
                                 String pantsStyle, String shoesStyle) {
        // 支持混搭功能的实现
        Hat hat = createPart(hatStyle, "HAT");
        Coat coat = createPart(coatStyle, "COAT");
        Pants pants = createPart(pantsStyle, "PANTS");
        Shoes shoes = createPart(shoesStyle, "SHOES");
        
        return new CostumeSet("MIXED", hat, coat, pants, shoes);
    }
    
    private <T extends CostumePart> T createPart(String style, String partType) {
        CostumeFactory factory = factoryRegistry.get(style.toUpperCase());
        if (factory == null) {
            throw new UnsupportedStyleException("不支持的风格: " + style);
        }
        
        return switch (partType) {
            case "HAT" -> (T) factory.createHat();
            case "COAT" -> (T) factory.createCoat();
            case "PANTS" -> (T) factory.createPants();
            case "SHOES" -> (T) factory.createShoes();
            default -> throw new IllegalArgumentException("不支持的部件类型: " + partType);
        };
    }
}

6.3.5 REST API接口

@RestController
@RequestMapping("/api/costumes")
@Validated
public class CostumeController {
    private final CostumeService costumeService;
    
    public CostumeController(CostumeService costumeService) {
        this.costumeService = costumeService;
    }
    
    @GetMapping("/styles")
    public ResponseEntity<List<String>> getAvailableStyles() {
        return ResponseEntity.ok(costumeService.getAvailableStyles());
    }
    
    @PostMapping("/sets")
    public ResponseEntity<CostumeSet> createCostumeSet(
            @RequestParam @NotBlank String style) {
        CostumeSet set = costumeService.createCostumeSet(style);
        return ResponseEntity.ok(set);
    }
    
    @PostMapping("/mix")
    public ResponseEntity<CostumeSet> mixAndMatch(
            @RequestParam String hatStyle,
            @RequestParam String coatStyle,
            @RequestParam String pantsStyle, 
            @RequestParam String shoesStyle) {
        CostumeSet set = costumeService.mixAndMatch(
            hatStyle, coatStyle, pantsStyle, shoesStyle);
        return ResponseEntity.ok(set);
    }
}

6.3.6 配置和测试

@Configuration
public class CostumeConfig {
    
    @Bean
    @ConditionalOnProperty(name = "costume.feature.mix-match", havingValue = "true")
    public CostumeService costumeServiceWithMixMatch(List<CostumeFactory> factories,
                                                   CostumePartRepository repository) {
        return new CostumeService(factories, repository) {
            @Override
            public boolean validateCostumeSet(CostumeSet set) {
                // 混搭模式下放宽风格一致性验证
                if ("MIXED".equals(set.style())) {
                    return set.isComplete();
                }
                return super.validateCostumeSet(set);
            }
        };
    }
}

@ExtendWith(SpringExtension.class)
@SpringBootTest
class CostumeServiceTest {
    
    @Autowired
    private CostumeService costumeService;
    
    @Test
    void shouldCreateModernCostumeSet() {
        CostumeSet set = costumeService.createCostumeSet("MODERN");
        
        assertNotNull(set);
        assertTrue(set.isComplete());
        assertEquals("MODERN", set.style());
        assertEquals("MODERN", set.hat().getStyle());
    }
    
    @Test
    void shouldValidateConsistentStyle() {
        CostumeSet set = costumeService.createCostumeSet("RETRO");
        
        assertTrue(costumeService.validateCostumeSet(set));
    }
}