Java 微服务架构设计模式:构建云原生时代的分布式系统
深入解析 Java 微服务架构的设计模式与最佳实践,涵盖从单体到微服务的演进、核心设计模式(服务发现、配置管理、熔断器、API 网关、分布式追踪)、数据管理(数据库隔离、Saga 模式)、安全设计(JWT、HTTPS)、性能优化(缓存、监控)及部署运维(Docker、K8s)。结合 Spring Cloud 生态与云原生技术,提供高可用、可扩展的分布式系统构建方案。

深入解析 Java 微服务架构的设计模式与最佳实践,涵盖从单体到微服务的演进、核心设计模式(服务发现、配置管理、熔断器、API 网关、分布式追踪)、数据管理(数据库隔离、Saga 模式)、安全设计(JWT、HTTPS)、性能优化(缓存、监控)及部署运维(Docker、K8s)。结合 Spring Cloud 生态与云原生技术,提供高可用、可扩展的分布式系统构建方案。

在云计算与微服务盛行的时代,分布式系统已成为企业级应用的核心架构。Java 凭借其强大的生态系统和成熟的并发模型,在分布式系统开发中占据主导地位。本文将深入解析 Java 微服务架构的设计模式、实战经验与最佳实践。
传统单体架构面临的主要挑战包括:
微服务架构通过将应用拆分为一组小型服务解决了这些问题,每个服务:
图:从单体架构到微服务架构的演进
Java 拥有最完善的微服务开发生态:
| 组件类型 | 主流框架 | 特点 |
|---|---|---|
| 开发框架 | Spring Boot | 快速开发、自动配置 |
| 服务治理 | Spring Cloud Netflix | 服务发现、熔断器 |
| 配置管理 | Spring Cloud Config | 集中化外部配置 |
| API 网关 | Spring Cloud Gateway | 路由、过滤、负载均衡 |
| 分布式追踪 | Sleuth + Zipkin | 请求链路追踪 |
在动态的微服务环境中,服务实例的网络位置是变化的,服务发现机制解决了如何定位服务实例的问题。
// 使用 Eureka 实现客户端服务发现
@SpringBootApplication
@EnableEurekaClient
public class UserServiceApplication {
public static void main(String[] args) {
SpringApplication.run(UserServiceApplication.class, args);
}
}
// 使用 DiscoveryClient 查找服务实例
@Service
public class OrderServiceClient {
@Autowired
private DiscoveryClient discoveryClient;
@Autowired
private RestTemplate restTemplate;
public User getUserById(Long userId) {
List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
if (instances.isEmpty()) {
throw new IllegalStateException("No available user service instances");
}
// 负载均衡策略:随机选择
ServiceInstance instance = instances.get(new Random().nextInt(instances.size()));
String url = String.format("http://%s:%s/users/%d", instance.getHost(), instance.getPort(), userId);
return restTemplate.getForObject(url, User.class);
}
}
# Kubernetes 服务配置示例
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);
}
}
微服务需要外部化配置管理,Spring Cloud Config 提供了集中化的配置解决方案。
// 配置服务器应用
@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {
public static void main(String[] args) {
SpringApplication.run(ConfigServerApplication.class, args);
}
}
# application.yml 配置
spring:
cloud:
config:
server:
git:
uri: https://github.com/your-org/config-repo
search-paths: '{application}'
# 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
}
熔断器防止分布式系统中的级联故障,提供故障恢复能力。
// 添加依赖:io.github.resilience4j:resilience4j-spring-boot2
@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
@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;
}
}
API 网关作为系统入口,负责请求路由、组合和协议转换。
@SpringBootApplication
public class ApiGatewayApplication {
public static void main(String[] args) {
SpringApplication.run(ApiGatewayApplication.class, args);
}
}
# 路由配置
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
// 身份验证过滤器
@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 != && !headers.isEmpty()) {
headers.get();
(bearerToken.startsWith()) {
bearerToken.substring();
}
}
;
}
Mono<Void> {
exchange.getResponse();
response.setStatusCode(status);
response.setComplete();
}
{
Ordered.HIGHEST_PRECEDENCE;
}
}
分布式追踪帮助理解请求在微服务间的流转,定位性能瓶颈。
# 应用配置
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();
}
}
}
@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;
}
}
图:Zipkin 分布式追踪界面展示
每个微服务拥有自己的数据库,确保服务间的松耦合。
// 主数据源配置
@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
// 使用@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 等方法
}
Saga 模式管理跨多个服务的分布式事务,确保最终一致性。
// 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()));
}
{
}
}
// 使用 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");
}
};
}
JSON Web Token 提供无状态的身份验证机制。
@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 {
getUsername(token);
List<String> roles = getRoles(token);
List<SimpleGrantedAuthority> authorities = roles.stream()
.map(SimpleGrantedAuthority::)
.collect(Collectors.toList());
(username, , authorities);
}
{
{
Jws<Claims> claims = Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token);
!claims.getBody().getExpiration().before( ());
} (JwtException | IllegalArgumentException e) {
();
}
}
}
@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);
}
}
// 配置 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) {
(, ex);
}
}
}
// 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);
}
}
}
@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, , TimeUnit.HOURS);
}
}
profile;
}
}
@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( ());
template.setValueSerializer( ());
template;
}
}
@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;
}
});
}
}
@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();
}
}
}
# 多阶段构建减少镜像大小
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
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:
# 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:
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:
服务网格将微服务通信、安全性和可观测性抽象到基础设施层。
# 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
Java 函数即服务 (FaaS) 的发展:
// 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();
}
}
机器学习在微服务运维中的应用:
// 异常检测示例
@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 <>();
meterRegistry.find().timer();
(responseTimeTimer != ) {
metrics.put(, responseTimeTimer.mean(TimeUnit.MILLISECONDS));
}
meterRegistry.find().counter();
(errorCounter != ) {
metrics.put(, errorCounter.count());
}
metrics;
}
{
baselineMetrics.compute(metricName, (key, oldValue) -> {
(oldValue == ) {
currentValue;
}
* oldValue + * currentValue;
});
}
}
Java 微服务架构已经成为构建现代分布式系统的标准方法。通过合理应用设计模式、充分利用 Spring Cloud 生态系统、实施有效的监控和运维策略,可以构建出高可用、可扩展且易于维护的微服务系统。
未来,随着服务网格、无服务器计算和 AI 驱动运维等技术的发展,Java 微服务架构将继续演进,为企业提供更强大、更智能的分布式系统解决方案。
关键成功因素:
参考资源:

微信公众号「极客日志」,在微信中扫描左侧二维码关注。展示文案:极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具,Keycode 信息在线工具,online
JavaScript 字符串转义/反转义;Java 风格 \uXXXX(Native2Ascii)编码与解码。 在线工具,Escape 与 Native 编解码在线工具,online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具,JavaScript / HTML 格式化在线工具,online
Terser 压缩、变量名混淆,或 javascript-obfuscator 高强度混淆(体积会增大)。 在线工具,JavaScript 压缩与混淆在线工具,online
生成新的随机RSA私钥和公钥pem证书。 在线工具,RSA密钥对生成器在线工具,online
基于 Mermaid.js 实时预览流程图、时序图等图表,支持源码编辑与即时渲染。 在线工具,Mermaid 预览与可视化编辑在线工具,online