【质量属性类型】场景名称

刺激源：<谁或什么产生了刺激>
刺激：<发生了什么事件>
环境：<在什么条件下发生>
制品：<系统的哪些部分受到影响>
响应：<系统如何应对>
响应度量：<如何衡量响应的有效性>

【性能】高峰期订单提交

刺激源：终端用户
刺激：提交订单请求
环境：促销活动期间，系统负载为正常水平的 5 倍
制品：订单创建服务及其依赖的库存服务和支付服务
响应：系统接受订单请求，异步处理库存扣减和支付，立即返回订单确认
响应度量：P95 响应时间 < 3 秒，订单创建成功率 > 99.5%

【可用性】支付服务故障

刺激源：第三方支付网关
刺激：支付服务返回超时错误
环境：正常运营时段，系统负载正常
制品：订单支付模块
响应：系统记录错误，向用户显示友好提示，提供稍后重试选项，后台定时重试未完成的支付
响应度量：用户可见的错误信息清晰易懂，后台重试成功率 > 95%，最终支付完成率 > 98%

【安全性】SQL 注入攻击

刺激源：恶意攻击者
刺激：在搜索框中输入 SQL 注入代码
环境：系统正常运行，WAF（Web 应用防火墙）已启用
制品：商品搜索功能及其数据库查询层
响应：系统检测并阻止恶意输入，记录安全事件，不暴露任何数据库信息，向安全团队发送告警
响应度量：注入尝试 100% 被阻止，无敏感信息泄露，告警在 5 分钟内发出

【可修改性】添加新的支付方式

刺激源：产品经理
刺激：要求集成新的支付渠道（如数字货币）
环境：系统已上线运营，有稳定的用户群
制品：支付模块及其接口定义
响应：开发人员只需实现新的支付适配器并配置，无需修改现有支付逻辑，经过测试后可独立部署
响应度量：开发工作量 < 5 人天，不影响现有支付功能，部署无需停机

Level 1: 业务愿景
  "系统需要高性能"

Level 2: 质量属性目标
  "订单提交响应时间 < 2 秒"

Level 3: 质量属性场景
  "当用户在正常负载下提交订单时，订单服务应在 2 秒内返回确认"

Level 4: 具体测试用例
  "使用 JMeter 模拟 1000 并发用户提交订单，测量 P95 响应时间"

场景：订单提交响应时间 < 2 秒
  ↓
架构决策：
  - 采用异步处理模式
  - 引入 Redis 缓存热点数据
  - 数据库读写分离
  - 服务水平扩展至 3 个实例

高业务价值    低业务价值
高发生频率     优先实现      计划实现
低发生频率     谨慎评估      可选实现

产品经理："系统要快。"

架构师："能具体一点吗？让我用场景来确认：
- 谁发起请求？普通用户还是管理员？
- 什么类型的请求？浏览商品还是提交订单？
- 在什么负载下？平时还是促销期间？
- 多快算快？2 秒还是 5 秒？
- 多少比例的请求需要满足这个速度？95% 还是 99%？"

通过这些问题，将模糊需求转化为具体场景。

方案 A：使用关系型数据库
方案 B：使用 NoSQL 数据库

评估场景：
1. 高并发读取场景：10000 QPS，P95 < 100ms
   - 方案 A：需要复杂的缓存层，难以保证
   - 方案 B：原生支持高并发，容易满足
   → 方案 B 胜出

2. 复杂查询场景：多表关联聚合
   - 方案 A：SQL 原生支持，简单高效
   - 方案 B：需要应用层组装，复杂且慢
   → 方案 A 胜出

综合权衡后做出选择。

审查点：这段代码是否满足性能场景？
- 是否有不必要的循环或查询？
- 是否正确使用了缓存？
- 是否有潜在的 N+1 查询问题？

审查点：这段代码是否满足可用性场景？
- 是否有适当的异常处理？
- 是否有重试机制？
- 失败时是否有降级策略？

场景：支付服务故障时，订单仍能创建

测试用例：
1. Mock 支付服务返回超时
2. 提交订单请求
3. 验证订单创建成功，状态为"待支付"
4. 验证用户收到友好提示
5. 验证后台有重试任务创建

业务目标：提升用户满意度
  ↓
质量目标：提高系统响应速度
  ↓
场景：P95 页面加载时间 < 2 秒
  ↓
架构决策：CDN 加速、前端优化、后端缓存

/**
 * 场景驱动的订单系统设计
 * 
 * 关键场景：
 * 1. 性能场景：高峰期订单提交 P95 < 2 秒
 * 2. 可用性场景：支付服务故障时订单仍能创建
 * 3. 安全性场景：防止重复提交订单
 */

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;

// ==================== 领域模型 ====================

class Order {
    private final String orderId;
    private final String userId;
    private final List<OrderItem> items;
    private OrderStatus status;
    private final long createdAt;
    
    public Order(String orderId, String userId, List<OrderItem> items) {
        this.orderId = orderId;
        this.userId = userId;
        this.items = items;
        this.status = OrderStatus.CREATED;
        this.createdAt = System.currentTimeMillis();
    }
    
    // Getters
    public String getOrderId() { return orderId; }
    public String getUserId() { return userId; }
    public List<OrderItem> getItems() { return Collections.unmodifiableList(items); }
    public OrderStatus getStatus() { return status; }
    public long getCreatedAt() { return createdAt; }
    
    public void setStatus(OrderStatus status) {
        this.status = status;
    }
    
    @Override
    public String toString() {
        return "Order{" +
                "orderId='" + orderId + '\'' +
                ", userId='" + userId + '\'' +
                ", status=" + status +
                ", createdAt=" + createdAt +
                '}';
    }
}

class OrderItem {
    private final String productId;
    private final int quantity;
    private final double price;
    
    public OrderItem(String productId, int quantity, double price) {
        this.productId = productId;
        this.quantity = quantity;
        this.price = price;
    }
    
    public String getProductId() { return productId; }
    public int getQuantity() { return quantity; }
    public double getPrice() { return price; }
}

enum OrderStatus {
    CREATED,       // 已创建
    PAYING,        // 支付中
    PAID,          // 已支付
    FAILED,        // 失败
    CANCELLED      // 已取消
}

// ==================== 场景一：性能优化 - 异步处理 ====================

/**
 * 异步订单处理器
 * 
 * 场景：高峰期订单提交 P95 < 2 秒
 * 策略：接收请求后立即返回，后台异步处理库存和支付
 */
class AsyncOrderProcessor {
    private final ExecutorService executor;
    private final OrderRepository orderRepository;
    private final InventoryService inventoryService;
    private final PaymentService paymentService;
    private final AtomicLong orderCounter;
    
    public AsyncOrderProcessor(
            OrderRepository orderRepository,
            InventoryService inventoryService,
            PaymentService paymentService) {
        this.orderRepository = orderRepository;
        this.inventoryService = inventoryService;
        this.paymentService = paymentService;
        this.orderCounter = new AtomicLong(0);
        
        // 使用线程池进行异步处理
        this.executor = Executors.newFixedThreadPool(10);
    }
    
    /**
     * 创建订单（快速返回）
     * 
     * 响应度量：P95 响应时间 < 2 秒
     */
    public CompletableFuture<Order> createOrder(String userId, List<OrderItem> items) {
        String orderId = generateOrderId();
        Order order = new Order(orderId, userId, items);
        
        // 立即保存订单状态为 CREATED
        orderRepository.save(order);
        
        // 异步处理后续流程
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            try {
                processOrderAsync(order);
            } catch (Exception e) {
                handleOrderFailure(order, e);
            }
        }, executor);
        
        // 立即返回订单，不等待异步处理完成
        return CompletableFuture.completedFuture(order);
    }
    
    private void processOrderAsync(Order order) {
        // 步骤 1：检查并扣减库存
        boolean stockReserved = inventoryService.reserveStock(
                order.getItems().stream()
                    .map(item -> new InventoryReservation(item.getProductId(), item.getQuantity()))
                    .toList()
        );
        
        if (!stockReserved) {
            order.setStatus(OrderStatus.FAILED);
            orderRepository.update(order);
            return;
        }
        
        // 步骤 2：发起支付
        order.setStatus(OrderStatus.PAYING);
        orderRepository.update(order);
        
        boolean paymentSuccess = paymentService.processPayment(
                order.getOrderId(),
                order.getItems().stream().mapToDouble(OrderItem::getPrice).sum()
        );
        
        if (paymentSuccess) {
            order.setStatus(OrderStatus.PAID);
        } else {
            order.setStatus(OrderStatus.FAILED);
            // 释放库存
            inventoryService.releaseStock(order.getItems().stream()
                    .map(item -> new InventoryReservation(item.getProductId(), item.getQuantity()))
                    .toList());
        }
        
        orderRepository.update(order);
    }
    
    private void handleOrderFailure(Order order, Exception e) {
        order.setStatus(OrderStatus.FAILED);
        orderRepository.update(order);
        // 记录错误日志，发送告警
        System.err.println("Order processing failed: " + order.getOrderId() + ", error: " + e.getMessage());
    }
    
    private String generateOrderId() {
        return "ORD-" + System.currentTimeMillis() + "-" + orderCounter.incrementAndGet();
    }
    
    public void shutdown() {
        executor.shutdown();
    }
}

// ==================== 场景二：可用性 - 熔断降级 ====================

/**
 * 带熔断器的支付服务客户端
 * 
 * 场景：支付服务故障时订单仍能创建
 * 策略：支付服务不可用时，订单状态设为"待支付"，后台重试
 */
class ResilientPaymentService implements PaymentService {
    private final PaymentService realPaymentService;
    private final CircuitBreaker circuitBreaker;
    
    public ResilientPaymentService(PaymentService realPaymentService) {
        this.realPaymentService = realPaymentService;
        this.circuitBreaker = new CircuitBreaker(5, 30); // 5 次失败后熔断，30 秒后重试
    }
    
    @Override
    public boolean processPayment(String orderId, double amount) {
        try {
            return circuitBreaker.execute(() -> realPaymentService.processPayment(orderId, amount));
        } catch (CircuitBreakerOpenException e) {
            // 熔断器打开，记录订单为待支付，稍后重试
            System.out.println("Payment service unavailable, order " + orderId + " marked as pending");
            return false; // 返回 false 但不失败订单
        }
    }
}

class CircuitBreaker {
    private final int failureThreshold;
    private final long retryDelayMs;
    private int failureCount;
    private long lastFailureTime;
    private boolean isOpen;
    
    public CircuitBreaker(int failureThreshold, long retryDelaySeconds) {
        this.failureThreshold = failureThreshold;
        this.retryDelayMs = retryDelaySeconds * 1000;
        this.failureCount = 0;
        this.isOpen = false;
    }
    
    public synchronized <T> T execute(Callable<T> callable) throws Exception {
        if (isOpen) {
            if (System.currentTimeMillis() - lastFailureTime > retryDelayMs) {
                // 半开状态，允许一次试探
                System.out.println("Circuit breaker half-open, allowing probe request");
                isOpen = false;
            } else {
                throw new CircuitBreakerOpenException("Circuit breaker is open");
            }
        }
        
        try {
            T result = callable.call();
            onSuccess();
            return result;
        } catch (Exception e) {
            onFailure();
            throw e;
        }
    }
    
    private synchronized void onSuccess() {
        failureCount = 0;
        isOpen = false;
    }
    
    private synchronized void onFailure() {
        failureCount++;
        lastFailureTime = System.currentTimeMillis();
        if (failureCount >= failureThreshold) {
            isOpen = true;
            System.out.println("Circuit breaker opened after " + failureCount + " failures");
        }
    }
}

class CircuitBreakerOpenException extends RuntimeException {
    public CircuitBreakerOpenException(String message) {
        super(message);
    }
}

// ==================== 场景三：安全性 - 防重复提交 ====================

/**
 * 防重复提交拦截器
 * 
 * 场景：防止用户重复提交同一订单
 * 策略：使用唯一令牌机制
 */
class IdempotencyInterceptor {
    private final Map<String, Long> processedRequests;
    private static final long TTL_MS = 3600000; // 1 小时过期
    
    public IdempotencyInterceptor() {
        this.processedRequests = new ConcurrentHashMap<>();
    }
    
    /**
     * 检查请求是否已处理
     * @return true 如果是新请求，false 如果是重复请求
     */
    public boolean isNewRequest(String idempotencyKey) {
        long now = System.currentTimeMillis();
        
        // 清理过期记录
        processedRequests.entrySet().removeIf(entry -> now - entry.getValue() > TTL_MS);
        
        // 检查是否已处理
        Long previousTime = processedRequests.putIfAbsent(idempotencyKey, now);
        
        if (previousTime != null) {
            System.out.println("Duplicate request detected for key: " + idempotencyKey);
            return false;
        }
        
        return true;
    }
}

// ==================== 辅助接口和类 ====================

interface OrderRepository {
    void save(Order order);
    void update(Order order);
    Order findById(String orderId);
}

interface InventoryService {
    boolean reserveStock(List<InventoryReservation> reservations);
    void releaseStock(List<InventoryReservation> reservations);
}

interface PaymentService {
    boolean processPayment(String orderId, double amount);
}

class InventoryReservation {
    private final String productId;
    private final int quantity;
    
    public InventoryReservation(String productId, int quantity) {
        this.productId = productId;
        this.quantity = quantity;
    }
    
    public String getProductId() { return productId; }
    public int getQuantity() { return quantity; }
}

// ==================== 测试 ====================

public class ScenarioDrivenDesign {
    public static void main(String[] args) throws Exception {
        System.out.println("===== 场景驱动设计演示 =====\n");
        
        // 模拟依赖
        OrderRepository orderRepo = new InMemoryOrderRepository();
        InventoryService inventoryService = new MockInventoryService();
        PaymentService paymentService = new MockPaymentService();
        
        // 创建异步处理器
        AsyncOrderProcessor processor = new AsyncOrderProcessor(
                orderRepo, inventoryService, paymentService
        );
        
        // 场景一：测试快速创建订单
        System.out.println("--- 场景一：高峰期订单提交 ---");
        List<OrderItem> items = Arrays.asList(
                new OrderItem("PROD-1", 2, 99.9),
                new OrderItem("PROD-2", 1, 199.9)
        );
        
        long startTime = System.currentTimeMillis();
        Order order = processor.createOrder("USER-123", items).get();
        long elapsed = System.currentTimeMillis() - startTime;
        
        System.out.println("订单创建耗时: " + elapsed + "ms");
        System.out.println("订单 ID: " + order.getOrderId());
        System.out.println("订单状态: " + order.getStatus());
        System.out.println("(注意：订单已创建，但支付和库存扣减在后台异步进行)\n");
        
        // 等待异步处理完成
        Thread.sleep(2000);
        
        // 场景二：测试支付服务故障
        System.out.println("--- 场景二：支付服务故障 ---");
        PaymentService failingPaymentService = new AlwaysFailingPaymentService();
        ResilientPaymentService resilientPaymentService = new ResilientPaymentService(failingPaymentService);
        
        boolean result = resilientPaymentService.processPayment("ORDER-TEST", 100.0);
        System.out.println("支付结果: " + result);
        System.out.println("(注意：支付失败但订单未失败，标记为待支付)\n");
        
        // 场景三：测试防重复提交
        System.out.println("--- 场景三：防重复提交 ---");
        IdempotencyInterceptor interceptor = new IdempotencyInterceptor();
        
        String idempotencyKey = "ORDER-SUBMIT-123";
        boolean first = interceptor.isNewRequest(idempotencyKey);
        boolean second = interceptor.isNewRequest(idempotencyKey);
        
        System.out.println("第一次提交: " + (first ? "允许" : "拒绝"));
        System.out.println("第二次提交: " + (second ? "允许" : "拒绝"));
        
        processor.shutdown();
    }
}

// ==================== 模拟实现 ====================

class InMemoryOrderRepository implements OrderRepository {
    private final Map<String, Order> orders = new ConcurrentHashMap<>();
    
    @Override
    public void save(Order order) {
        orders.put(order.getOrderId(), order);
        System.out.println("Order saved: " + order.getOrderId());
    }
    
    @Override
    public void update(Order order) {
        orders.put(order.getOrderId(), order);
        System.out.println("Order updated: " + order.getOrderId() + ", status: " + order.getStatus());
    }
    
    @Override
    public Order findById(String orderId) {
        return orders.get(orderId);
    }
}

class MockInventoryService implements InventoryService {
    @Override
    public boolean reserveStock(List<InventoryReservation> reservations) {
        System.out.println("Reserving stock for " + reservations.size() + " items");
        return true; // 模拟成功
    }
    
    @Override
    public void releaseStock(List<InventoryReservation> reservations) {
        System.out.println("Releasing stock for " + reservations.size() + " items");
    }
}

class MockPaymentService implements PaymentService {
    @Override
    public boolean processPayment(String orderId, double amount) {
        System.out.println("Processing payment for order " + orderId + ": $" + amount);
        return true; // 模拟成功
    }
}

class AlwaysFailingPaymentService implements PaymentService {
    @Override
    public boolean processPayment(String orderId, double amount) {
        System.out.println("Payment service failed for order " + orderId);
        throw new RuntimeException("Payment service unavailable");
    }
}

"""
质量属性场景验证框架
用于定义、执行和验证质量属性场景
"""

from dataclasses import dataclass, field
from typing import Callable, List, Optional, Any
from enum import Enum
import time


class ScenarioStatus(Enum):
    """场景执行状态"""
    PENDING = "pending"       # 待执行
    RUNNING = "running"       # 执行中
    PASSED = "passed"         # 通过
    FAILED = "failed"         # 失败


@dataclass
class QualityAttributeScenario:
    """质量属性场景定义"""
    name: str
    quality_attribute: str  # 性能、可用性、安全性等
    
    # 六要素
    source: str           # 刺激源
    stimulus: str         # 刺激
    environment: str      # 环境
    artifact: str         # 制品
    response: str         # 响应
    response_measure: str # 响应度量
    
    # 验证相关
    test_function: Optional[Callable] = None
    status: ScenarioStatus = ScenarioStatus.PENDING
    actual_result: Optional[Any] = None
    expected_result: Optional[Any] = None
    execution_time: float = 0.0
    
    def __str__(self):
        return f"""
【{self.quality_attribute}】{self.name}
  刺激源: {self.source}
  刺激: {self.stimulus}
  环境: {self.environment}
  制品: {self.artifact}
  响应: {self.response}
  响应度量: {self.response_measure}
  状态: {self.status.value}
"""


class ScenarioValidator:
    """场景验证器"""
    
    def __init__(self):
        self.scenarios: List[QualityAttributeScenario] = []
    
    def add_scenario(self, scenario: QualityAttributeScenario):
        """添加场景"""
        self.scenarios.append(scenario)
    
    def execute_scenario(self, scenario: QualityAttributeScenario) -> bool:
        """执行单个场景"""
        print(f"\n执行场景: {scenario.name}")
        print("-" * 50)
        
        scenario.status = ScenarioStatus.RUNNING
        start_time = time.time()
        
        try:
            if scenario.test_function:
                result = scenario.test_function()
                scenario.actual_result = result
                
                # 验证结果
                if scenario.expected_result is not None:
                    passed = result == scenario.expected_result
                else:
                    # 如果没有预期结果，假设返回 True 表示通过
                    passed = result is True or result is None
                
                scenario.status = ScenarioStatus.PASSED if passed else ScenarioStatus.FAILED
            else:
                # 没有测试函数，标记为待实现
                scenario.status = ScenarioStatus.FAILED
                raise NotImplementedError("Test function not implemented")
                
        except Exception as e:
            scenario.status = ScenarioStatus.FAILED
            scenario.actual_result = str(e)
            print(f"场景执行失败: {e}")
        
        finally:
            scenario.execution_time = time.time() - start_time
            print(f"执行时间: {scenario.execution_time:.3f}s")
            print(f"状态: {scenario.status.value}")
            
            return scenario.status == ScenarioStatus.PASSED
    
    def execute_all(self) -> dict:
        """执行所有场景"""
        results = {
            "total": len(self.scenarios),
            "passed": 0,
            "failed": 0,
            "details": []
        }
        
        for scenario in self.scenarios:
            passed = self.execute_scenario(scenario)
            
            if passed:
                results["passed"] += 1
            else:
                results["failed"] += 1
            
            results["details"].append({
                "name": scenario.name,
                "status": scenario.status.value,
                "execution_time": scenario.execution_time
            })
        
        return results
    
    def report(self) -> str:
        """生成报告"""
        lines = [
            "\n" + "=" * 60,
            "质量属性场景验证报告",
            "=" * 60,
        ]
        
        for scenario in self.scenarios:
            lines.append(str(scenario))
        
        results = {s.name: s.status.value for s in self.scenarios}
        passed = sum(1 for s in self.scenarios if s.status == ScenarioStatus.PASSED)
        
        lines.extend([
            "-" * 60,
            f"总计: {len(self.scenarios)} 个场景",
            f"通过: {passed}",
            f"失败: {len(self.scenarios) - passed}",
            f"通过率: {passed / len(self.scenarios) * 100:.1f}%",
            "=" * 60,
        ])
        
        return "\n".join(lines)


# ==================== 示例场景 ====================

def test_response_time():
    """测试响应时间场景"""
    start = time.time()
    
    # 模拟处理
    time.sleep(0.1)
    
    elapsed = time.time() - start
    # 要求响应时间 < 0.5 秒
    return elapsed < 0.5


def test_fault_tolerance():
    """测试容错场景"""
    try:
        # 模拟依赖服务调用
        raise ConnectionError("Service unavailable")
    except ConnectionError:
        # 系统应该捕获异常并降级
        return True  # 降级成功
    return False


def test_idempotency():
    """测试幂等性场景"""
    processed = set()
    
    # 第一次提交
    key = "request-123"
    if key in processed:
        return False  # 不应该被识别为重复
    
    processed.add(key)
    
    # 第二次提交
    if key in processed:
        return True  # 正确识别为重复
    
    return False


if __name__ == "__main__":
    validator = ScenarioValidator()
    
    # 添加性能场景
    perf_scenario = QualityAttributeScenario(
        name="高峰期订单提交",
        quality_attribute="性能",
        source="终端用户",
        stimulus="提交订单请求",
        environment="促销活动期间，系统负载为正常水平的 5 倍",
        artifact="订单创建服务",
        response="系统接受订单请求，立即返回确认",
        response_measure="P95 响应时间 < 2 秒",
        test_function=test_response_time,
        expected_result=True
    )
    validator.add_scenario(perf_scenario)
    
    # 添加可用性场景
    avail_scenario = QualityAttributeScenario(
        name="支付服务故障",
        quality_attribute="可用性",
        source="第三方支付网关",
        stimulus="支付服务返回超时错误",
        environment="正常运营时段",
        artifact="订单支付模块",
        response="系统降级处理，订单标记为待支付",
        response_measure="订单创建成功率 > 99%",
        test_function=test_fault_tolerance,
        expected_result=True
    )
    validator.add_scenario(avail_scenario)
    
    # 添加安全性场景
    security_scenario = QualityAttributeScenario(
        name="防止重复提交",
        quality_attribute="安全性",
        source="终端用户",
        stimulus="短时间内多次点击提交按钮",
        environment="网络延迟较高",
        artifact="订单提交接口",
        response="系统识别并拒绝重复请求",
        response_measure="重复请求 100% 被阻止",
        test_function=test_idempotency,
        expected_result=True
    )
    validator.add_scenario(security_scenario)
    
    # 执行所有场景
    results = validator.execute_all()
    
    # 生成报告
    print(validator.report())
    
    print("\n详细结果:")
    for detail in results["details"]:
        print(f"  {detail['name']}: {detail['status']} ({detail['execution_time']:.3f}s)")

场景：[场景名称]

架构分析：
- 相关组件：[列出受影响的组件]
- 当前机制：[描述当前如何处理此类场景]
- 满足程度：[完全满足 / 部分满足 / 不满足]

风险评估：
- 风险等级：[高 / 中 / 低]
- 风险描述：[详细说明]

改进建议：
- 建议方案：[描述改进措施]
- 预期效果：[改进后的表现]
- 工作量估算：[人天]