Java 微服务架构设计模式：云原生分布式系统实战

2.1.2 服务端发现模式

在 Kubernetes 环境下，通常采用服务端发现模式。通过 Service 资源定义服务入口，底层基础设施处理负载均衡。

apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080
  type: ClusterIP

配合 Spring Cloud LoadBalancer，代码可以更加简洁，直接使用服务名即可。

@Configuration
public class LoadBalancerConfiguration {
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@Service
public class OrderService {
    @Autowired
    private RestTemplate restTemplate;
    
    public User getUserById(Long userId) {
        // 直接使用服务名，负载均衡由底层基础设施处理
        return restTemplate.getForObject("http://user-service/users/{userId}", User.class, userId);
    }
}

2.2 配置管理模式

微服务需要外部化配置管理，Spring Cloud Config 提供了集中化的配置解决方案。

2.2.1 配置服务器实现

配置服务器通常基于 Git 仓库存储配置文件，支持多环境切换。

@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConfigServerApplication.class, args);
    }
}

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/your-org/config-repo
          search-paths: '{application}'

2.2.2 客户端配置获取

客户端需要在启动早期加载配置，因此使用 bootstrap.yml。同时利用 @RefreshScope 实现配置热更新，无需重启服务。

# bootstrap.yml (优先于 application.yml 加载)
spring:
  application:
    name: user-service
  cloud:
    config:
      uri: http://config-server:8888
      fail-fast: true
      retry:
        initial-interval: 1000
        max-attempts: 6
        max-interval: 2000
        multiplier: 1.1

// 使用@RefreshScope 实现配置热更新
@Service
@RefreshScope
public class DatabaseConfig {
    @Value("${database.url}")
    private String databaseUrl;
    
    @Value("${database.username}")
    private String username;
    
    @Value("${database.password}")
    private String password;
    
    // 配置变更时会自动刷新 Bean
}

2.3 熔断器模式

熔断器防止分布式系统中的级联故障，提供故障恢复能力。Resilience4j 是目前推荐的替代 Hystrix 的方案。

2.3.1 Resilience4j 熔断器实现

这里展示了如何使用装饰器模式包装业务逻辑。当失败率达到阈值时，熔断器会打开，后续请求直接走降级逻辑。

@Service
public class OrderService {
    private static final Logger logger = LoggerFactory.getLogger(OrderService.class);
    
    @Autowired
    private CircuitBreakerRegistry circuitBreakerRegistry;
    
    public User getUserWithCircuitBreaker(Long userId) {
        CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker("userService");
        Supplier<User> userSupplier = CircuitBreaker.decorateSupplier(circuitBreaker, () -> getUserById(userId));
        Try<User> result = Try.ofSupplier(userSupplier).recover(throwable -> {
            logger.warn("Fallback triggered due to: {}", throwable.getMessage());
            return getFallbackUser(userId);
        });
        return result.get();
    }
    
    private User getFallbackUser(Long userId) {
        // 返回降级数据
        return new User(userId, "Fallback User", "[email protected]");
    }
}

# 熔断器配置
resilience4j:
  circuitbreaker:
    instances:
      userService:
        register-health-indicator: true
        sliding-window-type: COUNT_BASED
        sliding-window-size: 10
        minimum-number-of-calls: 5
        wait-duration-in-open-state: 5s
        permitted-number-of-calls-in-half-open-state: 3
        failure-rate-threshold: 50
        event-consumer-buffer-size: 10

2.3.2 熔断器状态监控

暴露健康检查接口，方便运维人员实时查看熔断器状态。

@RestController
@RequestMapping("/circuitbreaker")
public class CircuitBreakerMetricsController {
    @Autowired
    private CircuitBreakerRegistry circuitBreakerRegistry;
    
    @GetMapping("/metrics")
    public Map<String, Object> getCircuitBreakerMetrics() {
        Map<String, Object> metrics = new HashMap<>();
        circuitBreakerRegistry.getAllCircuitBreakers().forEach(cb -> {
            CircuitBreaker.Metrics cbMetrics = cb.getMetrics();
            Map<String, Object> cbData = new HashMap<>();
            cbData.put("state", cb.getState());
            cbData.put("failureRate", cbMetrics.getFailureRate());
            cbData.put("failedCalls", cbMetrics.getNumberOfFailedCalls());
            cbData.put("successfulCalls", cbMetrics.getNumberOfSuccessfulCalls());
            cbData.put("notPermittedCalls", cbMetrics.getNumberOfNotPermittedCalls());
            metrics.put(cb.getName(), cbData);
        });
        return metrics;
    }
}

2.4 API 网关模式

API 网关作为系统入口，负责请求路由、组合和协议转换。Spring Cloud Gateway 基于 WebFlux，性能优于 Zuul。

2.4.1 Spring Cloud Gateway 实现

配置路由规则时，可以使用 Predicate 匹配路径，Filter 进行预处理（如限流、熔断）。

spring:
  cloud:
    gateway:
      routes:
      - id: user_service_route
        uri: lb://user-service
        predicates:
        - Path=/api/users/**
        filters:
        - StripPrefix=1
        - name: RequestRateLimiter
          args:
            redis-rate-limiter.replenishRate: 10
            redis-rate-limiter.burstCapacity: 20
        - name: CircuitBreaker
          args:
            name: userServiceCircuitBreaker
            fallbackUri: forward:/fallback/user-service
      - id: order_service_route
        uri: lb://order-service
        predicates:
        - Path=/api/orders/**
        filters:
        - StripPrefix=1

2.4.2 自定义网关过滤器

如果需要更复杂的鉴权逻辑，可以实现 GlobalFilter。这里演示了 JWT 令牌验证流程。

@Component
public class AuthenticationFilter implements GlobalFilter, Ordered {
    @Autowired
    private JwtTokenProvider jwtTokenProvider;
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        // 跳过登录和公开端点
        if (request.getURI().getPath().contains("/auth/login") || request.getURI().getPath().contains("/public")) {
            return chain.filter(exchange);
        }
        try {
            String token = getJwtFromRequest(request);
            if (token != null && jwtTokenProvider.validateToken(token)) {
                String username = jwtTokenProvider.getUsernameFromToken(token);
                addAuthorizationHeaders(exchange, username);
                return chain.filter(exchange);
            }
        } catch (Exception ex) {
            return onError(exchange, "Invalid token", HttpStatus.UNAUTHORIZED);
        }
        return onError(exchange, "Authorization header is missing", HttpStatus.UNAUTHORIZED);
    }
    
    private String getJwtFromRequest(ServerHttpRequest request) {
        List<String> headers = request.getHeaders().get("Authorization");
        if (headers != null && !headers.isEmpty()) {
            String bearerToken = headers.get(0);
            if (bearerToken.startsWith("Bearer ")) {
                return bearerToken.substring(7);
            }
        }
        return null;
    }
    
    private Mono<Void> onError(ServerWebExchange exchange, String err, HttpStatus status) {
        ServerHttpResponse response = exchange.getResponse();
        response.setStatusCode(status);
        return response.setComplete();
    }
    
    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;
    }
}

2.5 分布式追踪模式

分布式追踪帮助理解请求在微服务间的流转，定位性能瓶颈。Sleuth + Zipkin 是经典组合。

2.5.1 Sleuth + Zipkin 集成

配置采样率，生产环境建议降低采样率以节省资源。自定义 Span 可以记录关键业务信息。

# 应用配置
spring:
  zipkin:
    base-url: http://zipkin-server:9411
    sender.type: web
  sleuth:
    sampler:
      probability: 1.0 # 生产环境可降低采样率

@Service
public class OrderService {
    private final Tracer tracer;
    
    @Autowired
    public OrderService(Tracer tracer) {
        this.tracer = tracer;
    }
    
    public Order createOrder(Order order) {
        // 创建自定义 span
        Span orderSpan = tracer.nextSpan().name("orderProcessing").start();
        try (SpanInScope ws = tracer.withSpanInScope(orderSpan)) {
            orderSpan.tag("order.amount", order.getAmount().toString());
            orderSpan.event("order.validation.start");
            validateOrder(order);
            orderSpan.event("order.validation.complete");
            processPayment(order);
            orderSpan.event("order.payment.processed");
            Order savedOrder = saveOrder(order);
            orderSpan.event("order.persisted");
            return savedOrder;
        } catch (Exception e) {
            orderSpan.error(e);
            throw e;
        } finally {
            orderSpan.end();
        }
    }
}

2.5.2 追踪数据可视化

可以通过自定义 SpanHandler 添加额外的标签，例如服务版本和环境信息。

@Configuration
public class TracingConfiguration {
    @Bean
    public SpanHandler spanHandler() {
        return new SpanHandler() {
            @Override
            public boolean end(TraceContext context, MutableSpan span, Cause cause) {
                // 添加自定义标签
                span.tag("service.version", "1.0.0");
                span.tag("environment", System.getenv("ENV"));
                return true;
            }
        };
    }
    
    @Bean
    public Sampler alwaysSampler() {
        return Sampler.ALWAYS_SAMPLE;
    }
}

三、数据管理设计模式

3.1 数据库 per Service 模式

每个微服务拥有自己的数据库，确保服务间的松耦合。这是微服务数据隔离的基本原则。

3.1.1 多数据源配置

Spring Boot 允许配置多个数据源，通过 @Qualifier 区分事务管理器。

// 主数据源配置
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
    basePackages = "com.example.orderservice.repository",
    entityManagerFactoryRef = "orderEntityManagerFactory",
    transactionManagerRef = "orderTransactionManager"
)
public class OrderDataSourceConfig {
    
    @Bean
    @ConfigurationProperties("spring.datasource.order")
    public DataSource orderDataSource() {
        return DataSourceBuilder.create().build();
    }
    
    @Bean
    public LocalContainerEntityManagerFactoryBean orderEntityManagerFactory(EntityManagerFactoryBuilder builder) {
        return builder
            .dataSource(orderDataSource())
            .packages("com.example.orderservice.model")
            .persistenceUnit("orderPU")
            .build();
    }
    
    @Bean
    public PlatformTransactionManager orderTransactionManager(@Qualifier("orderEntityManagerFactory") EntityManagerFactory entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory);
    }
}

# 应用配置
spring:
  datasource:
    order:
      url: jdbc:mysql://localhost:3306/order_db
      username: order_user
      password: order_pass
      driver-class-name: com.mysql.cj.jdbc.Driver
    user:
      url: jdbc:mysql://localhost:3306/user_db
      username: user_user
      password: user_pass
      driver-class-name: com.mysql.cj.jdbc.Driver

3.1.2 数据一致性保障

跨服务事务不能依赖本地数据库事务，通常采用最终一致性方案，如领域事件。

// 使用@Transactional 注解确保事务性
@Service
public class OrderService {
    @Transactional("orderTransactionManager")
    public Order createOrder(Order order) {
        // 验证用户存在
        if (!userService.existsById(order.getUserId())) {
            throw new IllegalArgumentException("User does not exist");
        }
        // 保存订单
        Order savedOrder = orderRepository.save(order);
        // 发布领域事件
        eventPublisher.publishEvent(new OrderCreatedEvent(savedOrder));
        return savedOrder;
    }
}

// 领域事件定义
public class OrderCreatedEvent {
    private final Long orderId;
    private final Long userId;
    private final BigDecimal amount;
    private final Instant createdAt;
    
    // 构造函数、getter 等方法
}

3.2 Saga 模式

Saga 模式管理跨多个服务的分布式事务，确保最终一致性。分为编排式和协同式两种。

3.2.1 编排式 Saga 实现

由一个中心协调者（Orchestrator）控制流程，失败时执行补偿操作。

// Saga 编排器
@Component
public class CreateOrderSaga {
    private final SagaManager<CreateOrderSagaData> sagaManager;
    
    public CreateOrderSaga(SagaManager<CreateOrderSagaData> sagaManager) {
        this.sagaManager = sagaManager;
    }
    
    public void createOrder(Order order) {
        CreateOrderSagaData data = new CreateOrderSagaData(order);
        sagaManager.create(data, CreateOrderSaga.class);
    }
}

// Saga 定义
public class CreateOrderSaga implements Saga<CreateOrderSagaData> {
    private final ServiceDiscovery serviceDiscovery;
    private final CommandProducer commandProducer;
    
    public CreateOrderSaga(ServiceDiscovery serviceDiscovery, CommandProducer commandProducer) {
        this.serviceDiscovery = serviceDiscovery;
        this.commandProducer = commandProducer;
    }
    
    @Override
    public SagaDefinition<CreateOrderSagaData> getSagaDefinition() {
        return sagaDefinition()
            .step().withCompensation(this::rejectOrder)
            .step().invoke(this::validateCustomer).withCompensation(this::compensateCustomerValidation)
            .step().invoke(this::reserveCredit).withCompensation(this::compensateCreditReservation)
            .step().invoke(this::approveOrder)
            .build();
    }
    
    private void validateCustomer(CreateOrderSagaData data) {
        commandProducer.sendCommand("customerService", "validateCustomer", new ValidateCustomerCommand(data.getOrder().getCustomerId()));
    }
    
    private void reserveCredit(CreateOrderSagaData data) {
        commandProducer.sendCommand("paymentService", "reserveCredit", new ReserveCreditCommand(data.getOrder().getCustomerId(), data.getOrder().getOrderTotal()));
    }
    
    private void rejectOrder(CreateOrderSagaData data) {
        // 拒绝订单补偿逻辑
    }
    
    // 其他 Saga 方法
}

3.2.2 协同式 Saga 实现

每个服务监听消息并发布事件，没有中心协调者。Apache Camel 是常用实现工具。

// 使用 Apache Camel 实现协同式 Saga
@Bean
public RouteBuilder orderSagaRoute() {
    return new RouteBuilder() {
        @Override
        public void configure() throws Exception {
            from("direct:createOrder")
                .saga().propagation(SagaPropagation.REQUIRES_NEW)
                .timeout(5, TimeUnit.MINUTES)
                .compensation("direct:cancelOrder")
                .option("orderId", header("orderId"))
                .log("Creating order: ${header.orderId}")
                .to("direct:reserveCredit")
                .to("direct:updateInventory")
                .to("direct:confirmOrder")
                .log("Order created successfully: ${header.orderId}");
                
            from("direct:reserveCredit")
                .saga().propagation(SagaPropagation.MANDATORY)
                .compensation("direct:refundCredit")
                .to("bean:paymentService?method=reserveCredit")
                .log("Credit reserved for order: ${header.orderId}");
                
            from("direct:cancelOrder")
                .log("Cancelling order: ${header.orderId}")
                .to("bean:orderService?method=cancelOrder");
                
            from("direct:refundCredit")
                .log("Refunding credit for order: ${header.orderId}")
                .to("bean:paymentService?method=refundCredit");
        }
    };
}

四、安全设计模式

4.1 JWT 认证与授权

JSON Web Token 提供无状态的身份验证机制，适合微服务架构。

4.1.1 JWT 工具类实现

生成令牌时设置过期时间，验证时检查签名和有效期。

@Component
public class JwtTokenProvider {
    @Value("${security.jwt.token.secret-key:secret}")
    private String secretKey;
    
    @Value("${security.jwt.token.expire-length:3600000}")
    private long validityInMilliseconds;
    
    @PostConstruct
    protected void init() {
        secretKey = Base64.getEncoder().encodeToString(secretKey.getBytes());
    }
    
    public String createToken(String username, List<String> roles) {
        Claims claims = Jwts.claims().setSubject(username);
        claims.put("roles", roles);
        Date now = new Date();
        Date validity = new Date(now.getTime() + validityInMilliseconds);
        return Jwts.builder()
            .setClaims(claims)
            .setIssuedAt(now)
            .setExpiration(validity)
            .signWith(SignatureAlgorithm.HS256, secretKey)
            .compact();
    }
    
    public Authentication getAuthentication(String token) {
        UserDetails userDetails = getUserDetails(token);
        return new UsernamePasswordAuthenticationToken(userDetails, "", userDetails.getAuthorities());
    }
    
    private UserDetails getUserDetails(String token) {
        String username = getUsername(token);
        List<String> roles = getRoles(token);
        List<SimpleGrantedAuthority> authorities = roles.stream()
            .map(SimpleGrantedAuthority::new)
            .collect(Collectors.toList());
        return new User(username, "", authorities);
    }
    
    public boolean validateToken(String token) {
        try {
            Jws<Claims> claims = Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token);
            return !claims.getBody().getExpiration().before(new Date());
        } catch (JwtException | IllegalArgumentException e) {
            throw new InvalidJwtAuthenticationException("Expired or invalid JWT token");
        }
    }
    
    // 其他辅助方法...
}

4.1.2 Spring Security 配置

禁用 CSRF，配置无状态会话，并集成 JWT 过滤器。

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Autowired
    private JwtTokenProvider jwtTokenProvider;
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            .authorizeRequests()
            .antMatchers("/auth/login").permitAll()
            .antMatchers("/public/**").permitAll()
            .antMatchers("/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated()
            .and()
            .apply(new JwtConfigurer(jwtTokenProvider));
    }
    
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

// JWT 配置器
public class JwtConfigurer extends SecurityConfigurerAdapter<DefaultSecurityFilterChain, HttpSecurity> {
    private final JwtTokenProvider jwtTokenProvider;
    
    public JwtConfigurer(JwtTokenProvider jwtTokenProvider) {
        this.jwtTokenProvider = jwtTokenProvider;
    }
    
    @Override
    public void configure(HttpSecurity http) {
        JwtTokenFilter customFilter = new JwtTokenFilter(jwtTokenProvider);
        http.addFilterBefore(customFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

4.2 安全通信模式

4.2.1 HTTPS 与证书管理

配置 Tomcat 启用 SSL，确保传输层加密。

// 配置 HTTPS
@Configuration
public class SSLConfig {
    @Value("${server.ssl.key-store:classpath:keystore.p12}")
    private Resource keyStore;
    
    @Value("${server.ssl.key-store-password:password}")
    private String keyStorePassword;
    
    @Value("${server.ssl.key-store-type:PKCS12}")
    private String keyStoreType;
    
    @Bean
    public ServletWebServerFactory servletContainer() {
        TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory();
        tomcat.addAdditionalTomcatConnectors(createSslConnector());
        return tomcat;
    }
    
    private Connector createSslConnector() {
        Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
        Http11NioProtocol protocol = (Http11NioProtocol) connector.getProtocolHandler();
        try {
            connector.setScheme("https");
            connector.setSecure(true);
            connector.setPort(8443);
            protocol.setSSLEnabled(true);
            protocol.setKeystoreFile(keyStore.getFile().getAbsolutePath());
            protocol.setKeystorePass(keyStorePassword);
            protocol.setKeystoreType(keyStoreType);
            protocol.setKeyAlias("tomcat");
            return connector;
        } catch (IOException ex) {
            throw new IllegalStateException("Failed to set up SSL connector", ex);
        }
    }
}

4.2.2 服务间安全认证

Feign 客户端拦截器自动注入 Token，实现服务间调用认证。

// Feign 客户端安全配置
@Configuration
public class FeignConfig {
    @Bean
    public FeignRequestInterceptor feignRequestInterceptor() {
        return new FeignRequestInterceptor();
    }
}

@Component
public class FeignRequestInterceptor implements RequestInterceptor {
    @Autowired
    private JwtTokenProvider jwtTokenProvider;
    
    @Override
    public void apply(RequestTemplate template) {
        // 获取当前用户 token 并添加到请求头
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication != null && authentication.isAuthenticated()) {
            String token = jwtTokenProvider.createToken(
                authentication.getName(), 
                authentication.getAuthorities().stream()
                    .map(GrantedAuthority::getAuthority)
                    .collect(Collectors.toList())
            );
            template.header("Authorization", "Bearer " + token);
        }
    }
}

五、性能优化与可观测性

5.1 缓存策略

5.1.1 多级缓存架构

结合本地缓存和 Redis 分布式缓存，减少数据库压力。

@Service
@CacheConfig(cacheNames = "users")
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private RedisTemplate<String, User> redisTemplate;
    
    @Cacheable(key = "#id", unless = "#result == null")
    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
    
    @CachePut(key = "#user.id")
    public User updateUser(User user) {
        return userRepository.save(user);
    }
    
    @CacheEvict(key = "#id")
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
    
    // 本地缓存 + Redis 分布式缓存
    @Cacheable(value = "userProfile", key = "#userId")
    public UserProfile getUserProfile(Long userId) {
        // 先尝试从 Redis 获取
        String redisKey = "user:profile:" + userId;
        UserProfile profile = (UserProfile) redisTemplate.opsForValue().get(redisKey);
        if (profile == null) {
            // Redis 中没有，从数据库获取
            profile = userRepository.findProfileById(userId);
            if (profile != null) {
                // 存入 Redis，设置过期时间
                redisTemplate.opsForValue().set(redisKey, profile, 1, TimeUnit.HOURS);
            }
        }
        return profile;
    }
}

5.1.2 缓存配置

配置序列化方式和过期时间，避免内存溢出和数据不一致。

@Configuration
@EnableCaching
public class CacheConfig {
    
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheConfiguration defaultConfig = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(30))
            .disableCachingNullValues()
            .serializeValuesWith(SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
        return RedisCacheManager.builder(redisConnectionFactory)
            .cacheDefaults(defaultConfig)
            .withInitialCacheConfigurations(getCacheConfigurations())
            .transactionAware()
            .build();
    }
    
    private Map<String, RedisCacheConfiguration> getCacheConfigurations() {
        Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
        configMap.put("users", RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofHours(1))
            .serializeValuesWith(SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer())));
        configMap.put("products", RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(15))
            .serializeValuesWith(SerializationPair.fromSerializer(new JdkSerializationRedisSerializer())));
        return configMap;
    }
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
}

5.2 性能监控与指标

5.2.1 Micrometer 指标收集

Micrometer 统一了不同监控库的 API，方便对接 Prometheus 等后端。

@Configuration
public class MetricsConfig {
    
    @Bean
    public MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
        return registry -> registry.config().commonTags(
            "application", "user-service",
            "environment", System.getenv().getOrDefault("ENV", "dev")
        );
    }
    
    @Bean
    public TimedAspect timedAspect(MeterRegistry registry) {
        return new TimedAspect(registry);
    }
}

@Service
public class OrderService {
    private final Counter orderCounter;
    private final Timer orderProcessingTimer;
    private final DistributionSummary orderAmountSummary;
    
    public OrderService(MeterRegistry registry) {
        this.orderCounter = registry.counter("orders.total");
        this.orderProcessingTimer = registry.timer("orders.processing.time");
        this.orderAmountSummary = registry.summary("orders.amount.summary");
    }
    
    public Order createOrder(Order order) {
        return orderProcessingTimer.record(() -> {
            try {
                // 业务逻辑
                Order savedOrder = orderRepository.save(order);
                // 记录指标
                orderCounter.increment();
                orderAmountSummary.record(order.getAmount().doubleValue());
                return savedOrder;
            } catch (Exception e) {
                // 记录错误指标
                Metrics.counter("orders.errors", "reason", e.getClass().getSimpleName()).increment();
                throw e;
            }
        });
    }
}

5.2.2 自定义健康检查

通过 Actuator 暴露健康状态，Kubernetes 据此判断 Pod 是否可用。

@Component
public class DatabaseHealthIndicator implements HealthIndicator {
    @Autowired
    private DataSource dataSource;
    
    @Override
    public Health health() {
        try (Connection connection = dataSource.getConnection()) {
            if (connection.isValid(1000)) {
                return Health.up()
                    .withDetail("database", "Available")
                    .withDetail("validationQuery", "SELECT 1")
                    .build();
            } else {
                return Health.down()
                    .withDetail("database", "Not available")
                    .withException(new SQLException("Connection validation failed"))
                    .build();
            }
        } catch (SQLException e) {
            return Health.down()
                .withDetail("database", "Not available")
                .withException(e)
                .build();
        }
    }
}

@Component
public class ServiceHealthIndicator implements HealthIndicator {
    @Autowired
    private DiscoveryClient discoveryClient;
    
    @Override
    public Health health() {
        Map<String, Object> details = new HashMap<>();
        // 检查依赖服务状态
        List<String> services = discoveryClient.getServices();
        details.put("total_services", services.size());
        List<String> unhealthyServices = new ArrayList<>();
        for (String service : services) {
            List<ServiceInstance> instances = discoveryClient.getInstances(service);
            if (instances.isEmpty()) {
                unhealthyServices.add(service);
            }
        }
        if (unhealthyServices.isEmpty()) {
            return Health.up().withDetails(details).build();
        } else {
            details.put("unhealthy_services", unhealthyServices);
            return Health.down().withDetails(details).build();
        }
    }
}

六、部署与运维模式

6.1 Docker 容器化部署

6.1.1 Dockerfile 最佳实践

使用多阶段构建减小镜像体积，非 root 用户运行增强安全性。

# 多阶段构建减少镜像大小
FROM eclipse-temurin:17-jdk-jammy as builder
WORKDIR /app
COPY . .
RUN ./mvnw clean package -DskipTests

# 运行时镜像
FROM eclipse-temurin:17-jre-jammy
WORKDIR /app

# 创建非 root 用户
RUN groupadd -r spring && useradd -r -g spring spring
USER spring:spring

# 复制构建产物
COPY --from=builder /app/target/*.jar app.jar

# 设置 JVM 参数
ENV JAVA_OPTS="-XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0 -XX:+UseG1GC"

# 添加健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=60s --retries=3 \
  CMD curl -f http://localhost:8080/actuator/health || exit 1

# 暴露端口
EXPOSE 8080

# 启动应用
ENTRYPOINT exec java $JAVA_OPTS -jar /app/app.jar

6.1.2 Docker Compose 编排

用于本地开发环境的快速搭建，包含服务发现、配置中心、网关和监控。

version: '3.8'
services:
  # 服务发现
  eureka-server:
    image: user-service-registry:1.0.0
    ports:
    - "8761:8761"
    environment:
    - SPRING_PROFILES_ACTIVE=docker
    networks:
    - microservices-net
    
  # 配置服务
  config-server:
    image: user-service-config:1.0.0
    ports:
    - "8888:8888"
    environment:
    - SPRING_PROFILES_ACTIVE=docker
    depends_on:
    - eureka-server
    networks:
    - microservices-net
    
  # API 网关
  api-gateway:
    image: user-service-gateway:1.0.0
    ports:
    - "8080:8080"
    environment:
    - SPRING_PROFILES_ACTIVE=docker
    - EUREKA_CLIENT_SERVICE_URL_DEFAULTZONE=http://eureka-server:8761/eureka
    depends_on:
    - config-server
    networks:
    - microservices-net
    
  # 用户服务
  user-service:
    image: user-service:1.0.0
    environment:
    - SPRING_PROFILES_ACTIVE=docker
    - EUREKA_CLIENT_SERVICE_URL_DEFAULTZONE=http://eureka-server:8761/eureka
    - SPRING_CLOUD_CONFIG_URI=http://config-server:8888
    deploy:
      replicas: 3
      resources:
        limits:
          memory: 512M
        reservations:
          memory: 256M
    depends_on:
    - config-server
    networks:
    - microservices-net
    
  # 监控服务
  monitoring:
    image: prom/prometheus:latest
    ports:
    - "9090:9090"
    volumes:
    - ./prometheus.yml:/etc/prometheus/prometheus.yml
    networks:
    - microservices-net
    
  # 可视化
  grafana:
    image: grafana/grafana:latest
    ports:
    - "3000:3000"
    environment:
    - GF_SECURITY_ADMIN_PASSWORD=admin
    networks:
    - microservices-net

networks:
  microservices-net:
    driver: bridge

volumes:
  prometheus-data:
  grafana-data:

6.2 Kubernetes 部署与管理

6.2.1 Kubernetes 部署配置

Deployment 管理副本数，Service 提供网络访问，Ingress 管理外部流量。

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
  labels:
    app: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "8080"
        prometheus.io/path: "/actuator/prometheus"
    spec:
      containers:
      - name: user-service
        image: user-service:1.0.0
        ports:
        - containerPort: 8080
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "kubernetes"
        - name: JAVA_OPTS
          value: "-XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0 -Xms256m -Xmx512m"
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /actuator/health/liveness
            port: 8080
          initialDelaySeconds: 60
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /actuator/health/readiness
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 5
---
# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
  ports:
  - port: 8080
    targetPort: 8080
  type: ClusterIP
---
# ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: user-service-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: user-service.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: user-service
            port:
              number: 8080

6.2.2 Horizontal Pod Autoscaler 配置

根据 CPU、内存或自定义指标自动扩缩容。

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: user-service-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: user-service
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80
  - type: Pods
    pods:
      metric:
        name: transactions_per_second
      target:
        type: AverageValue
        averageValue: 1k
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 60
      policies:
      - type: Pods
        value: 2
        periodSeconds: 60
      - type: Percent
        value: 10
        periodSeconds: 60
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
      - type: Pods
        value: 1
        periodSeconds: 60

七、未来发展趋势

7.1 服务网格 (Service Mesh)

服务网格将微服务通信、安全性和可观测性抽象到基础设施层。Istio 是主流实现。

# Istio VirtualService 示例
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: user-service
spec:
  hosts:
  - user-service
  http:
  - route:
    - destination:
        host: user-service
        subset: v1
      weight: 90
    - destination:
        host: user-service
        subset: v2
      weight: 10
    fault:
      delay:
        percentage:
          value: 10
        fixedDelay: 3s
      timeout: 2s

7.2 无服务器架构 (Serverless)

Java 函数即服务 (FaaS) 的发展，Spring Cloud Function 提供了良好支持。

// Spring Cloud Function 示例
@SpringBootApplication
public class FunctionApplication {
    public static void main(String[] args) {
        SpringApplication.run(FunctionApplication.class, args);
    }
    
    @Bean
    public Function<User, ApiResponse> createUser() {
        return user -> {
            // 业务逻辑
            User savedUser = userService.save(user);
            return new ApiResponse("User created successfully", savedUser);
        };
    }
    
    @Bean
    public Consumer<Event> processEvent() {
        return event -> {
            // 处理事件
            eventProcessor.process(event);
        };
    }
    
    @Bean
    public Supplier<List<User>> getUsers() {
        return () -> userService.getAllUsers();
    }
}

7.3 AI 驱动的运维

机器学习在微服务运维中的应用，例如异常检测。

// 异常检测示例
@Service
public class AnomalyDetectionService {
    @Autowired
    private MeterRegistry meterRegistry;
    
    private final Map<String, Double> baselineMetrics = new ConcurrentHashMap<>();
    
    @Scheduled(fixedRate = 60000)
    public void detectAnomalies() {
        // 收集当前指标
        Map<String, Double> currentMetrics = collectMetrics();
        // 与基线比较
        for (Map.Entry<String, Double> entry : currentMetrics.entrySet()) {
            String metricName = entry.getKey();
            Double currentValue = entry.getValue();
            Double baselineValue = baselineMetrics.get(metricName);
            if (baselineValue != null) {
                double deviation = Math.abs((currentValue - baselineValue) / baselineValue);
                if (deviation > 0.3) { // 30% 偏差
                    alertService.sendAlert(new AnomalyAlert(metricName, currentValue, baselineValue, deviation));
                }
            }
            // 更新基线（指数加权移动平均）
            updateBaseline(metricName, currentValue);
        }
    }
    
    private Map<String, Double> collectMetrics() {
        Map<String, Double> metrics = new HashMap<>();
        // 收集响应时间指标
        Timer responseTimeTimer = meterRegistry.find("http.server.requests").timer();
        if (responseTimeTimer != null) {
            metrics.put("response_time_mean", responseTimeTimer.mean(TimeUnit.MILLISECONDS));
        }
        // 收集错误率指标
        Counter errorCounter = meterRegistry.find("http.server.errors").counter();
        if (errorCounter != null) {
            metrics.put("error_rate", errorCounter.count());
        }
        return metrics;
    }
    
    private void updateBaseline(String metricName, Double currentValue) {
        baselineMetrics.compute(metricName, (key, oldValue) -> {
            if (oldValue == null) {
                return currentValue;
            }
            // EWMA: α=0.1
            return 0.9 * oldValue + 0.1 * currentValue;
        });
    }
}

结论

Java 微服务架构已经成为构建现代分布式系统的标准方法。通过合理应用设计模式、充分利用 Spring Cloud 生态系统、实施有效的监控和运维策略，可以构建出高可用、可扩展且易于维护的微服务系统。

未来，随着服务网格、无服务器计算和 AI 驱动运维等技术的发展，Java 微服务架构将继续演进，为企业提供更强大、更智能的分布式系统解决方案。

关键成功因素：

1. 合适的粒度：服务拆分要平衡内聚性和通信开销
2. 自动化运维：完善的 CI/CD 和监控体系
3. 文化转变：DevOps 和持续改进的文化
4. 技术选型：选择成熟且适合团队的技术栈

参考资源：

1. Spring Cloud 官方文档
2. Microservices.io 设计模式
3. Kubernetes 官方文档
4. Istio 服务网格
5. Martin Fowler 的微服务文章