第八周总结

Java 学习第八周总结
一、学习概述
本周学习内容聚焦于分布式系统核心技术，涵盖消息队列集成、弹性系统设计、安全架构、服务网格及领域驱动设计等前沿领域。通过 RabbitMQ 实现了微服务间的异步通信，使用 Resilience4j 构建了具备熔断限流能力的弹性系统，基于 OAuth2+JWT 实现了分布式安全认证，结合 Istio 实践了服务网格的流量管理与可观测性，并深入理解了事件驱动架构与领域驱动设计的核心思想。
二、消息队列集成（RabbitMQ）

  1. Spring Boot 整合 RabbitMQ
    核心依赖配置
org.springframework.boot spring-boot-starter-amqp 连接参数配置（application.yml）

spring:
rabbitmq:
host: localhost # 服务器地址
port: 5672 # 端口
username: guest # 用户名
password: guest # 密码
virtual-host: / # 虚拟主机
2. 生产者与消费者实现
消息发送（生产者）

@RestController
public class OrderController {
@Autowired
private RabbitTemplate rabbitTemplate;

@PostMapping("/orders") 
public String createOrder(@RequestBody Order order) { 
    // 发送消息到指定交换机和路由键 
    rabbitTemplate.convertAndSend("order-exchange", "order.create", order); 
    return "Order sent!"; 
}

}
消息接收（消费者）

@Component
public class OrderListener {
@RabbitListener(queues = "order-queue")
public void processOrder(Order order) {
System.out.println("Received order: " + order.getId());
// 处理订单业务逻辑
}
}
队列与交换机配置

@Configuration
public class RabbitMQConfig {
@Bean
public TopicExchange orderExchange() {
return new TopicExchange("order-exchange"); // 创建主题交换机
}

@Bean 
public Queue orderQueue() { 
    return new Queue("order-queue"); // 创建队列 
} 
 
@Bean 
public Binding binding() { 
    // 绑定队列到交换机，并指定路由规则 
    return BindingBuilder.bind(orderQueue()) 
            .to(orderExchange()) 
            .with("order.*"); 
}

}
3. 核心原理

  1. 交换机类型：Direct（精确匹配）、Topic（模式匹配）、Fanout（广播）
  2. 消息确认机制：生产者确认（Publisher Confirm）、消费者手动确认（Acknowledge）
  3. 死信队列（DLQ）：处理失败消息的重新路由
    三、弹性系统设计（Resilience4j）
  4. 熔断与降级实现
    编程式熔断配置

// 配置熔断器参数
CircuitBreakerConfig config = CircuitBreakerConfig.custom()
.failureRateThreshold(50) // 失败率阈值50%
.waitDurationInOpenState(Duration.ofMillis(1000)) // 开路状态持续1秒
.build();
CircuitBreaker circuitBreaker = CircuitBreaker.of("orderService", config);
// 执行带熔断的服务调用
Order order = CircuitBreaker
.decorateSupplier(circuitBreaker, () -> orderClient.findById(id))
.get();
注解式熔断应用

@Service
public class OrderService {
@CircuitBreaker(name = "orderService", fallbackMethod = "fallback")
public Order getOrder(String id) {
return orderClient.findById(id);
}

// 降级方法（需与原方法参数兼容，最后添加Exception参数） 
public Order fallback(String id, Exception ex) { 
    log.error("服务调用失败", ex); 
    return Order.emptyOrder(); // 返回空订单作为降级响应 
}

}
2. 限流与重试机制
限流器配置

RateLimiterConfig rateLimiterConfig = RateLimiterConfig.custom()
.limitRefreshPeriod(Duration.ofSeconds(1)) // 刷新周期1秒
.limitForPeriod(10) // 周期内最大请求数10
.timeoutDuration(Duration.ofMillis(25)) // 等待获取令牌的超时时间
.build();
RateLimiter rateLimiter = RateLimiter.of("orderService", rateLimiterConfig);
// 应用限流
CheckedRunnable restrictedCall = RateLimiter
.decorateCheckedRunnable(rateLimiter, this::processOrder);
restrictedCall.run();
重试策略配置

RetryConfig retryConfig = RetryConfig.custom()
.maxAttempts(3) // 最大重试次数
.waitDuration(Duration.ofMillis(500)) // 重试间隔
.retryExceptions(IOException.class, TimeoutException.class) // 重试的异常类型
.ignoreExceptions(AuthenticationException.class) // 不重试的异常类型
.build();
Retry retry = Retry.of("orderService", retryConfig);
// 应用重试
Order order = Retry
.decorateSupplier(retry, () -> orderClient.findById(id))
.get();
四、安全架构（OAuth2 + JWT）

  1. Spring Security 配置

@Configuration
@EnableWebSecurity
public class SecurityConfig {
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
.oauth2ResourceServer(oauth2 -> oauth2.jwt()) // 启用JWT资源服务器
.authorizeRequests(auth -> auth
.antMatchers("/public/**").permitAll() // 公开接口无需认证
.anyRequest().authenticated() // 其他接口需认证
);
return http.build();
}
}
2. JWT 签发与验证
JWT 令牌生成

// 生成JWT令牌（包含用户信息和过期时间）
String token = Jwts.builder()
.setSubject("user1") // 主题（用户标识）
.setIssuedAt(new Date()) // 签发时间
.setExpiration(new Date(System.currentTimeMillis() + 3600000)) // 过期时间（1小时）
.claim("roles", Arrays.asList("USER", "ADMIN")) // 自定义声明（角色信息）
.signWith(SignatureAlgorithm.HS512, "secret-key") // 签名算法和密钥
.compact();
JWT 令牌验证

// 解析并验证JWT令牌
Claims claims = Jwts.parser()
.setSigningKey("secret-key") // 设置签名密钥
.parseClaimsJws(token) // 解析令牌
.getBody(); // 获取载荷
// 提取用户信息
String userId = claims.getSubject();
List roles = (List) claims.get("roles");
3. 分布式会话管理
4. 无状态设计：JWT 本身包含用户信息，服务端无需存储会话
5. 刷新令牌：使用 Refresh Token 获取新的 Access Token，避免频繁登录
6. 黑名单机制：通过 Redis 存储失效的 JWT 令牌 ID
五、服务网格（Istio）与 Spring Cloud 集成

  1. Istio 核心功能
    流量管理
  2. 动态路由：基于权重、版本、用户身份等条件路由请求
  3. 故障注入：模拟服务故障，测试系统容错能力
  4. 超时与重试：配置请求超时时间和重试策略
    可观测性
  5. Metrics：自动收集服务性能指标（请求量、延迟、错误率）
  6. Tracing：集成 Jaeger 实现分布式链路追踪
  7. Logging：统一收集服务日志，支持 ELK Stack
    安全策略
  8. mTLS：服务间通信自动加密，无需应用层处理
  9. 身份认证：基于服务身份的访问控制
  10. 限流策略：全局流量限制，防止服务过载
  11. Spring Cloud 与 Istio 协同
    金丝雀发布配置（VirtualService）

apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
name: order-service # 虚拟服务名称
spec:
hosts:
- order-service # 目标服务域名
http:
- route:
- destination:
host: order-service # 服务主机名
subset: v1 # 版本子集v1
weight: 90 # 90%流量
- destination:
host: order-service
subset: v2 # 版本子集v2
weight: 10 # 10%流量
服务版本管理（DestinationRule）

apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
name: order-service
spec:
host: order-service
subsets:
- name: v1 # 版本v1
labels:
version: v1
- name: v2 # 版本v2
labels:
version: v2
3. 集成要点
16. 移除重复组件：若使用 Istio Ingress，可替代 Spring Cloud Gateway
17. 服务注册共存：保留 Spring Cloud 的服务发现（如 Nacos）或直接使用 Kubernetes Service
18. 流量治理分层：Istio 负责网络层流量管理，Spring Cloud 负责应用层逻辑
六、事件驱动架构（EDA）与领域驱动设计（DDD）

  1. 事件驱动架构
    事件溯源（Event Sourcing）

public class Order {
private List events = new ArrayList<>(); // 事件列表
private OrderStatus status; // 当前状态

// 应用事件到聚合根 
public void apply(OrderCreatedEvent event) { 
    this.status = OrderStatus.CREATED; 
    events.add(event); // 记录事件 
} 
 
public void apply(OrderPaidEvent event) { 
    this.status = OrderStatus.PAID; 
    events.add(event); 
} 
 
// 从事件流重建状态 
public static Order reconstituteFrom(List<DomainEvent> events) { 
    Order order = new Order(); 
    for (DomainEvent event : events) { 
        order.apply(event); 
    } 
    return order; 
}

}
CQRS 模式
19. 命令端：处理写操作，更新事件存储

public class OrderCommandHandler {
private EventStore eventStore;

public void handle(CreateOrderCommand command) { 
    Order order = Order.create(command); 
    eventStore.save(order.getEvents()); 
}

}
20. 查询端：从物化视图读取数据

public class OrderQueryService {
private OrderReadModelRepository repository;

public OrderDTO findById(String id) { 
    return repository.findById(id).map(OrderDTO::from).orElse(null); 
}

}
2. 领域驱动设计实战
战术设计要素
21. 实体（Entity）

public class Product {
private ProductId id; // 唯一标识
private String name;
private Money price;

// 业务方法（确保业务规则） 
public void changePrice(Money newPrice) { 
    if (newPrice.isNegative()) { 
        throw new DomainException("价格不能为负"); 
    } 
    this.price = newPrice; 
}

}
22. 值对象（Value Object）

public class Money implements Serializable {
private BigDecimal amount;
private Currency currency;

// 不可变设计（所有修改返回新对象） 
public Money add(Money other) { 
    if (!currency.equals(other.currency)) { 
        throw new DomainException("货币类型不一致"); 
    } 
    return new Money(amount.add(other.amount), currency); 
}

}
23. 领域服务（Domain Service）

public class OrderCreationService {
private ProductRepository productRepo;
private InventoryService inventoryService;

public Order createOrder(CustomerId customerId, List<OrderLine> lines) { 
    // 跨聚合的复杂业务逻辑 
    Order order = new Order(customerId); 
    lines.forEach(line -> { 
        Product product = productRepo.findById(line.getProductId()); 
        inventoryService.reserve(product.getId(), line.getQuantity()); 
        order.addLineItem(product, line.getQuantity()); 
    }); 
    return order; 
}

}
限界上下文（Bounded Context）
24. 上下文映射：

  1. 电商平台：订单上下文、客户上下文、产品上下文
  2. 金融系统：账户上下文、交易上下文、风控上下文
  3. 通信方式：
  4. 同步：REST API、gRPC
  5. 异步：领域事件、消息队列
    七、本周学习总结与反思
  6. 学习成果
  7. 掌握 RabbitMQ 在微服务中的集成方式，实现了异步消息通信
  8. 能够使用 Resilience4j 构建具备熔断、限流、重试能力的弹性系统
  9. 基于 OAuth2+JWT 实现了分布式系统的安全认证与授权
  10. 理解 Istio 服务网格的核心功能，完成了 Spring Cloud 与 Istio 的协同配置
  11. 深入理解事件驱动架构与领域驱动设计的核心思想及实践方法
  12. 存在问题
  13. 消息队列的高级特性（如死信队列、消息重试）实践不足
  14. Istio 的网络策略配置（如 TrafficPolicy）不够熟练
  15. 领域驱动设计中聚合根的边界划分缺乏实际项目经验
  16. 改进方向
  17. 实践 RabbitMQ 的死信队列与延迟消息功能
  18. 学习 Istio 的流量镜像（Traffic Mirroring）与熔断配置
  19. 通过模拟项目练习领域建模，掌握聚合根设计原则
  20. 下周计划
  21. 学习分布式事务解决方案（Seata），理解 AT/TCC/SAGA 模式
  22. 深入研究微服务监控与可观测性（Prometheus+Grafana+Jaeger）
  23. 实践容器编排高级特性（Kubernetes StatefulSet、Helm Chart）
  24. 阅读《领域驱动设计：软件核心复杂性应对之道》相关章节
posted @ 2025-06-15 20:59  执笔诉相思  阅读(8)  评论(0)    收藏  举报