// 用户服务核心功能
public class UserService {
    // 用户注册
    public User registerUser(RegisterUserRequest request) { ... }
    
    // 用户登录
    public LoginResponse loginUser(LoginRequest request) { ... }
    
    // 获取用户信息
    public User getUserById(String userId) { ... }
    
    // 更新用户信息
    public User updateUser(String userId, UpdateUserRequest request) { ... }
    
    // 用户权限管理
    public Set<String> getUserPermissions(String userId) { ... }
}

2. 商品服务（Product Service）

// 商品服务核心功能
public class ProductService {
    // 创建商品
    public Product createProduct(CreateProductRequest request) { ... }
    
    // 获取商品详情
    public Product getProductById(String productId) { ... }
    
    // 商品搜索
    public List<Product> searchProducts(SearchCriteria criteria) { ... }
    
    // 更新商品信息
    public Product updateProduct(String productId, UpdateProductRequest request) { ... }
    
    // 商品分类管理
    public List<Category> getCategories() { ... }
}

3. 购物车服务（Cart Service）

// 购物车服务核心功能
public class CartService {
    // 添加商品到购物车
    public Cart addItemToCart(String userId, AddItemRequest request) { ... }
    
    // 更新购物车商品数量
    public Cart updateItemQuantity(String userId, UpdateItemRequest request) { ... }
    
    // 删除购物车商品
    public Cart removeItemFromCart(String userId, String productId) { ... }
    
    // 获取用户购物车
    public Cart getUserCart(String userId) { ... }
    
    // 清空购物车
    public void clearUserCart(String userId) { ... }
}

4. 订单服务（Order Service）

// 订单服务核心功能
public class OrderService {
    // 创建订单
    public Order createOrder(CreateOrderRequest request) { ... }
    
    // 获取订单详情
    public Order getOrderById(String orderId) { ... }
    
    // 更新订单状态
    public Order updateOrderStatus(String orderId, OrderStatus status) { ... }
    
    // 取消订单
    public Order cancelOrder(String orderId) { ... }
    
    // 查询用户订单
    public List<Order> getUserOrders(String userId, Pageable pageable) { ... }
}

5. 库存服务（Inventory Service）

// 库存服务核心功能
public class InventoryService {
    // 检查库存
    public InventoryCheckResult checkInventory(String productId, int quantity) { ... }
    
    // 扣减库存
    public boolean decreaseStock(String productId, int quantity) { ... }
    
    // 增加库存
    public boolean increaseStock(String productId, int quantity) { ... }
    
    // 获取库存信息
    public Inventory getInventory(String productId) { ... }
    
    // 库存预警
    public List<InventoryWarning> getLowStockWarnings() { ... }
}

6. 支付服务（Payment Service）

// 支付服务核心功能
public class PaymentService {
    // 处理支付
    public Payment processPayment(ProcessPaymentRequest request) { ... }
    
    // 查询支付状态
    public Payment getPaymentById(String paymentId) { ... }
    
    // 处理支付回调
    public void handlePaymentCallback(PaymentCallback callback) { ... }
    
    // 处理退款
    public Refund processRefund(ProcessRefundRequest request) { ... }
}

7. 通知服务（Notification Service）

// 通知服务核心功能
public class NotificationService {
    // 发送订单确认通知
    public void sendOrderConfirmation(String orderId) { ... }
    
    // 发送支付成功通知
    public void sendPaymentSuccess(String paymentId) { ... }
    
    // 发送系统公告
    public void sendSystemAnnouncement(Announcement announcement) { ... }
    
    // 发送营销通知
    public void sendMarketingNotification(MarketingNotification notification) { ... }
}

服务间通信设计

同步通信

对于需要实时响应的操作，采用同步通信方式：

// 订单服务调用库存服务检查库存
@Service
public class OrderProcessingService {
    
    @Autowired
    private InventoryServiceClient inventoryServiceClient;
    
    public boolean checkInventory(String productId, int quantity) {
        InventoryCheckRequest request = new InventoryCheckRequest(productId, quantity);
        InventoryCheckResponse response = inventoryServiceClient.checkInventory(request);
        return response.isAvailable();
    }
}

异步通信

对于不需要实时响应的操作，采用异步通信方式：

// 订单创建后异步发送通知
@Service
public class OrderNotificationService {
    
    @Autowired
    private NotificationServiceClient notificationServiceClient;
    
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 异步发送订单确认通知
        notificationServiceClient.sendOrderConfirmationAsync(event.getOrderId());
    }
}

数据存储设计

服务数据隔离

每个服务拥有独立的数据存储，避免数据耦合：

# Docker Compose配置示例
version: '3'
services:
  user-db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: user_db
    volumes:
      - user-db-data:/var/lib/mysql
  
  product-db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: product_db
    volumes:
      - product-db-data:/var/lib/mysql
  
  order-db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: order_db
    volumes:
      - order-db-data:/var/lib/mysql

volumes:
  user-db-data:
  product-db-data:
  order-db-data:

缓存策略

采用多级缓存策略提升性能：

@Service
public class CachedProductService {
    
    @Autowired
    private RedisTemplate<String, Product> redisTemplate;
    
    @Autowired
    private ProductService productService;
    
    // 一级缓存：本地缓存
    private final Cache<String, Product> localCache = 
        Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(Duration.ofMinutes(5))
            .build();
    
    public Product getProductById(String productId) {
        // 检查本地缓存
        Product product = localCache.getIfPresent(productId);
        if (product != null) {
            return product;
        }
        
        // 检查Redis缓存
        product = redisTemplate.opsForValue().get("product:" + productId);
        if (product != null) {
            localCache.put(productId, product);
            return product;
        }
        
        // 数据库查询
        product = productService.findById(productId);
        if (product != null) {
            // 更新缓存
            redisTemplate.opsForValue().set("product:" + productId, product, 
                                          Duration.ofHours(1));
            localCache.put(productId, product);
        }
        
        return product;
    }
}

安全架构设计

认证授权体系

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(authz -> authz
            .requestMatchers("/api/public/**").permitAll()
            .requestMatchers("/api/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated()
        )
        .oauth2ResourceServer(OAuth2ResourceServerConfigurer::jwt)
        .sessionManagement(session -> session
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS));
        
        return http.build();
    }
}

API网关安全

@Component
public class SecurityGatewayFilter implements GlobalFilter {
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        
        // API密钥验证
        String apiKey = request.getHeaders().getFirst("X-API-Key");
        if (!isValidApiKey(apiKey)) {
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }
        
        // JWT令牌验证
        String authHeader = request.getHeaders().getFirst("Authorization");
        if (!isValidJwtToken(authHeader)) {
            exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN);
            return exchange.getResponse().setComplete();
        }
        
        return chain.filter(exchange);
    }
    
    private boolean isValidApiKey(String apiKey) {
        // 实现API密钥验证逻辑
        return apiKeyService.isValidApiKey(apiKey);
    }
    
    private boolean isValidJwtToken(String authHeader) {
        // 实现JWT令牌验证逻辑
        return jwtService.isValidToken(authHeader);
    }
}

容错性设计

断路器模式

@Service
public class ResilientInventoryService {
    
    private final CircuitBreaker circuitBreaker;
    
    public ResilientInventoryService() {
        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
            .failureRateThreshold(50)
            .waitDurationInOpenState(Duration.ofSeconds(10))
            .slidingWindowType(CircuitBreakerConfig.SlidingWindowType.TIME_BASED)
            .slidingWindowSize(100)
            .minimumNumberOfCalls(10)
            .build();
            
        this.circuitBreaker = CircuitBreaker.of("inventory-service", config);
    }
    
    public InventoryCheckResult checkInventory(String productId, int quantity) {
        Supplier<InventoryCheckResult> decoratedSupplier = 
            CircuitBreaker.decorateSupplier(circuitBreaker, 
                () -> inventoryServiceClient.checkInventory(productId, quantity));
                
        try {
            return decoratedSupplier.get();
        } catch (CallNotPermittedException e) {
            log.warn("Circuit breaker is open for inventory service");
            // 返回降级结果
            return new InventoryCheckResult(false, 0, "Service temporarily unavailable");
        }
    }
}

重试机制

@Service
public class RetryableUserService {
    
    private final Retry retry;
    
    public RetryableUserService() {
        RetryConfig config = RetryConfig.custom()
            .maxAttempts(3)
            .waitDuration(Duration.ofSeconds(1))
            .retryExceptions(TimeoutException.class, ConnectException.class)
            .build();
            
        this.retry = Retry.of("user-service", config);
    }
    
    public User getUserById(String userId) {
        Supplier<User> retryableSupplier = 
            Retry.decorateSupplier(retry, 
                () -> userServiceClient.getUserById(userId));
                
        return retryableSupplier.get();
    }
}

架构图示例

总结

通过这个实际案例，我们可以看到设计一个微服务系统需要考虑多个方面：

深入理解业务需求是设计良好架构的基础
合理的服务划分能够提高系统的可维护性和可扩展性
选择合适的通信方式对于系统性能至关重要
完善的安全设计是保障系统可靠运行的关键
容错性机制能够提高系统的稳定性和可用性

在实际项目中，我们需要根据具体的业务场景和技术约束，灵活应用这些设计原则和方法，持续优化和改进系统架构，构建出高质量的微服务系统。在后续的实现阶段，我们将深入探讨如何将这些设计转化为具体的代码实现和部署方案。