Java 微服务架构设计模式涵盖服务发现、配置管理、熔断器、API 网关及分布式追踪等核心组件。通过 Spring Cloud 生态实现服务治理，结合数据库隔离与 Saga 模式保障数据一致性。安全方面采用 JWT 认证与 HTTPS 通信。性能优化涉及多级缓存与 Micrometer 指标监控。部署阶段支持 Docker 容器化与 Kubernetes 编排，并引入服务网格与无服务器架构趋势。AI 驱动的运维技术进一步提升了系统的可观测性与自动化水平。
在云计算与微服务盛行的时代，分布式系统已成为企业级应用的核心架构。Java 凭借其强大的生态系统和成熟的并发模型，在分布式系统开发中占据主导地位。本文将深入解析 Java 微服务架构的设计模式、实战经验与最佳实践。
传统单体架构面临的主要挑战包括：
微服务架构通过将应用拆分为一组小型服务解决了这些问题，每个服务：
单体应用网关服务用户服务订单服务产品服务用户数据库订单数据库产品数据库
图：从单体架构到微服务架构的演进
Java 拥有最完善的微服务开发生态：
| 组件类型 | 主流框架 | 特点 |
|---|---|---|
| 开发框架 | Spring Boot | 快速开发、自动配置 |
| 服务治理 | Spring Cloud Netflix | 服务发现、熔断器 |
| 配置管理 | Spring Cloud Config | 集中化外部配置 |
| API 网关 | Spring Cloud Gateway | 路由、过滤、负载均衡 |
| 分布式追踪 | Sleuth + Zipkin | 请求链路追踪 |
在动态的微服务环境中，服务实例的网络位置是变化的，服务发现机制解决了如何定位服务实例的问题。
// 使用 Eureka 实现客户端服务发现@SpringBootApplication@EnableEurekaClientpublicclassUserServiceApplication{publicstaticvoidmain(String[] args){SpringApplication.run(UserServiceApplication.class, args);}}// 使用 DiscoveryClient 查找服务实例@ServicepublicclassOrderServiceClient{@AutowiredprivateDiscoveryClient discoveryClient;@AutowiredprivateRestTemplate restTemplate;publicUsergetUserById(Long userId){List<ServiceInstance> instances = discoveryClient.getInstances("user-service");if(instances.isEmpty()){thrownewIllegalStateException("No available user service instances");}// 负载均衡策略：随机选择ServiceInstance instance = instances.get(newRandom().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:80targetPort:8080type: ClusterIP
// 使用 Spring Cloud LoadBalancer 实现服务端发现@ConfigurationpublicclassLoadBalancerConfiguration{@Bean@LoadBalancedpublicRestTemplaterestTemplate(){returnnewRestTemplate();}}@ServicepublicclassOrderService{@AutowiredprivateRestTemplate restTemplate;publicUsergetUserById(Long userId){// 直接使用服务名，负载均衡由底层基础设施处理return restTemplate.getForObject("http://user-service/users/{userId}",User.class, userId );}}
微服务需要外部化配置管理，Spring Cloud Config 提供了集中化的配置解决方案。
// 配置服务器应用@SpringBootApplication@EnableConfigServerpublicclassConfigServerApplication{publicstaticvoidmain(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@RefreshScopepublicclassDatabaseConfig{@Value("${database.url}")privateString databaseUrl;@Value("${database.username}")privateString username;@Value("${database.password}")privateString password;// 配置变更时会自动刷新 Bean}
熔断器防止分布式系统中的级联故障，提供故障恢复能力。
// 添加依赖：io.github.resilience4j:resilience4j-spring-boot2@ServicepublicclassOrderService{privatestaticfinalLogger logger =LoggerFactory.getLogger(OrderService.class);// 定义熔断器@AutowiredprivateCircuitBreakerRegistry circuitBreakerRegistry;publicUsergetUserWithCircuitBreaker(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());returngetFallbackUser(userId);});return result.get();}privateUsergetFallbackUser(Long userId){// 返回降级数据returnnewUser(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")publicclassCircuitBreakerMetricsController{@AutowiredprivateCircuitBreakerRegistry circuitBreakerRegistry;@GetMapping("/metrics")publicMap<String,Object>getCircuitBreakerMetrics(){Map<String,Object> metrics =newHashMap<>(); circuitBreakerRegistry.getAllCircuitBreakers().forEach(cb ->{CircuitBreaker.Metrics cbMetrics = cb.getMetrics();Map<String,Object> cbData =newHashMap<>(); 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 网关作为系统入口，负责请求路由、组合和协议转换。
@SpringBootApplicationpublicclassApiGatewayApplication{publicstaticvoidmain(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
// 身份验证过滤器@ComponentpublicclassAuthenticationFilterimplementsGlobalFilter,Ordered{@AutowiredprivateJwtTokenProvider jwtTokenProvider;@OverridepublicMono<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){returnonError(exchange,"Invalid token",HttpStatus.UNAUTHORIZED);}returnonError(exchange,"Authorization header is missing",HttpStatus.UNAUTHORIZED);}privateStringgetJwtFromRequest(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);}}returnnull;}privateMono<Void>onError(ServerWebExchange exchange,String err,HttpStatus status){ServerHttpResponse response = exchange.getResponse(); response.setStatusCode(status);return response.setComplete();}@OverridepublicintgetOrder(){returnOrdered.HIGHEST_PRECEDENCE;}}
分布式追踪帮助理解请求在微服务间的流转，定位性能瓶颈。
# 应用配置spring:zipkin:base-url: http://zipkin-server:9411sender.type: web sleuth:sampler:probability:1.0# 生产环境可降低采样率
// 自定义追踪信息@ServicepublicclassOrderService{privatefinalTracer tracer;@AutowiredpublicOrderService(Tracer tracer){this.tracer = tracer;}publicOrdercreateOrder(Order order){// 创建自定义 spanSpan 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();}}}
@ConfigurationpublicclassTracingConfiguration{@BeanpublicSpanHandlerspanHandler(){returnnewSpanHandler(){@Overridepublicbooleanend(TraceContext context,MutableSpan span,Cause cause){// 添加自定义标签 span.tag("service.version","1.0.0"); span.tag("environment",System.getenv("ENV"));returntrue;}};}@BeanpublicSampleralwaysSampler(){returnSampler.ALWAYS_SAMPLE;}}
图：Zipkin 分布式追踪界面展示
每个微服务拥有自己的数据库，确保服务间的松耦合。
// 主数据源配置@Configuration@EnableTransactionManagement@EnableJpaRepositories( basePackages ="com.example.orderservice.repository", entityManagerFactoryRef ="orderEntityManagerFactory", transactionManagerRef ="orderTransactionManager")publicclassOrderDataSourceConfig{@Bean@ConfigurationProperties("spring.datasource.order")publicDataSourceorderDataSource(){returnDataSourceBuilder.create().build();}@BeanpublicLocalContainerEntityManagerFactoryBeanorderEntityManagerFactory(EntityManagerFactoryBuilder builder){return builder .dataSource(orderDataSource()).packages("com.example.orderservice.model").persistenceUnit("orderPU").build();}@BeanpublicPlatformTransactionManagerorderTransactionManager(@Qualifier("orderEntityManagerFactory")EntityManagerFactory entityManagerFactory){returnnewJpaTransactionManager(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 注解确保事务性@ServicepublicclassOrderService{@Transactional("orderTransactionManager")publicOrdercreateOrder(Order order){// 验证用户存在if(!userService.existsById(order.getUserId())){thrownewIllegalArgumentException("User does not exist");}// 保存订单Order savedOrder = orderRepository.save(order);// 发布领域事件 eventPublisher.publishEvent(newOrderCreatedEvent(savedOrder));return savedOrder;}}// 领域事件定义publicclassOrderCreatedEvent{privatefinalLong orderId;privatefinalLong userId;privatefinalBigDecimal amount;privatefinalInstant createdAt;// 构造函数、getter 等方法}
Saga 模式管理跨多个服务的分布式事务，确保最终一致性。
// Saga 编排器@ComponentpublicclassCreateOrderSaga{privatefinalSagaManager<CreateOrderSagaData> sagaManager;publicCreateOrderSaga(SagaManager<CreateOrderSagaData> sagaManager){this.sagaManager = sagaManager;}publicvoidcreateOrder(Order order){CreateOrderSagaData data =newCreateOrderSagaData(order); sagaManager.create(data,CreateOrderSaga.class);}}// Saga 定义publicclassCreateOrderSagaimplementsSaga<CreateOrderSagaData>{privatefinalServiceDiscovery serviceDiscovery;privatefinalCommandProducer commandProducer;publicCreateOrderSaga(ServiceDiscovery serviceDiscovery,CommandProducer commandProducer){this.serviceDiscovery = serviceDiscovery;this.commandProducer = commandProducer;}@OverridepublicSagaDefinition<CreateOrderSagaData>getSagaDefinition(){returnsagaDefinition().step().withCompensation(this::rejectOrder).step().invoke(this::validateCustomer).withCompensation(this::compensateCustomerValidation).step().invoke(this::reserveCredit).withCompensation(this::compensateCreditReservation).step().invoke(this::approveOrder).build();}privatevoidvalidateCustomer(CreateOrderSagaData data){ commandProducer.sendCommand("customerService","validateCustomer",newValidateCustomerCommand(data.getOrder().getCustomerId()));}privatevoidreserveCredit(CreateOrderSagaData data){ commandProducer.sendCommand("paymentService","reserveCredit",newReserveCreditCommand(data.getOrder().getCustomerId(), data.getOrder().getOrderTotal()));}privatevoidrejectOrder(CreateOrderSagaData data){// 拒绝订单补偿逻辑}// 其他 Saga 方法}
// 使用 Apache Camel 实现协同式 Saga@BeanpublicRouteBuilderorderSagaRoute(){returnnewRouteBuilder(){@Overridepublicvoidconfigure()throwsException{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 提供无状态的身份验证机制。
@ComponentpublicclassJwtTokenProvider{@Value("${security.jwt.token.secret-key:secret}")privateString secretKey;@Value("${security.jwt.token.expire-length:3600000}")privatelong validityInMilliseconds;@PostConstructprotectedvoidinit(){ secretKey =Base64.getEncoder().encodeToString(secretKey.getBytes());}publicStringcreateToken(String username,List<String> roles){Claims claims =Jwts.claims().setSubject(username); claims.put("roles", roles);Date now =newDate();Date validity =newDate(now.getTime()+ validityInMilliseconds);returnJwts.builder().setClaims(claims).setIssuedAt(now).setExpiration(validity).signWith(SignatureAlgorithm.HS256, secretKey).compact();}publicAuthenticationgetAuthentication(String token){UserDetails userDetails =getUserDetails(token);returnnewUsernamePasswordAuthenticationToken(userDetails,"", userDetails.getAuthorities());}privateUserDetailsgetUserDetails(String token){String username =getUsername(token);List<String> roles =getRoles(token);List<SimpleGrantedAuthority> authorities = roles.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());returnnewUser(username,"", authorities);}publicbooleanvalidateToken(String token){try{Jws<Claims> claims =Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token);return!claims.getBody().getExpiration().before(newDate());}catch(JwtException|IllegalArgumentException e){thrownewInvalidJwtAuthenticationException("Expired or invalid JWT token");}}// 其他辅助方法...}
@Configuration@EnableWebSecurity@EnableGlobalMethodSecurity(prePostEnabled =true)publicclassSecurityConfigextendsWebSecurityConfigurerAdapter{@AutowiredprivateJwtTokenProvider jwtTokenProvider;@Overrideprotectedvoidconfigure(HttpSecurity http)throwsException{ http .csrf().disable().sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and().authorizeRequests().antMatchers("/auth/login").permitAll().antMatchers("/public/**").permitAll().antMatchers("/admin/**").hasRole("ADMIN").anyRequest().authenticated().and().apply(newJwtConfigurer(jwtTokenProvider));}@Bean@OverridepublicAuthenticationManagerauthenticationManagerBean()throwsException{returnsuper.authenticationManagerBean();}@BeanpublicPasswordEncoderpasswordEncoder(){returnnewBCryptPasswordEncoder();}}// JWT 配置器publicclassJwtConfigurerextendsSecurityConfigurerAdapter<DefaultSecurityFilterChain,HttpSecurity>{privatefinalJwtTokenProvider jwtTokenProvider;publicJwtConfigurer(JwtTokenProvider jwtTokenProvider){this.jwtTokenProvider = jwtTokenProvider;}@Overridepublicvoidconfigure(HttpSecurity http){JwtTokenFilter customFilter =newJwtTokenFilter(jwtTokenProvider); http.addFilterBefore(customFilter,UsernamePasswordAuthenticationFilter.class);}}
// 配置 HTTPS@ConfigurationpublicclassSSLConfig{@Value("${server.ssl.key-store:classpath:keystore.p12}")privateResource keyStore;@Value("${server.ssl.key-store-password:password}")privateString keyStorePassword;@Value("${server.ssl.key-store-type:PKCS12}")privateString keyStoreType;@BeanpublicServletWebServerFactoryservletContainer(){TomcatServletWebServerFactory tomcat =newTomcatServletWebServerFactory(); tomcat.addAdditionalTomcatConnectors(createSslConnector());return tomcat;}privateConnectorcreateSslConnector(){Connector connector =newConnector("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){thrownewIllegalStateException("Failed to set up SSL connector", ex);}}}
// Feign 客户端安全配置@ConfigurationpublicclassFeignConfig{@BeanpublicFeignRequestInterceptorfeignRequestInterceptor(){returnnewFeignRequestInterceptor();}}@ComponentpublicclassFeignRequestInterceptorimplementsRequestInterceptor{@AutowiredprivateJwtTokenProvider jwtTokenProvider;@Overridepublicvoidapply(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")publicclassUserService{@AutowiredprivateUserRepository userRepository;@AutowiredprivateRedisTemplate<String,User> redisTemplate;@Cacheable(key ="#id", unless ="#result == null")publicUsergetUserById(Long id){return userRepository.findById(id).orElse(null);}@CachePut(key ="#user.id")publicUserupdateUser(User user){return userRepository.save(user);}@CacheEvict(key ="#id")publicvoiddeleteUser(Long id){ userRepository.deleteById(id);}// 本地缓存 + Redis 分布式缓存@Cacheable(value ="userProfile", key ="#userId")publicUserProfilegetUserProfile(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;}}
@Configuration@EnableCachingpublicclassCacheConfig{@BeanpublicCacheManagercacheManager(RedisConnectionFactory redisConnectionFactory){RedisCacheConfiguration defaultConfig =RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(30)).disableCachingNullValues().serializeValuesWith(SerializationPair.fromSerializer(newGenericJackson2JsonRedisSerializer()));returnRedisCacheManager.builder(redisConnectionFactory).cacheDefaults(defaultConfig).withInitialCacheConfigurations(getCacheConfigurations()).transactionAware().build();}privateMap<String,RedisCacheConfiguration>getCacheConfigurations(){Map<String,RedisCacheConfiguration> configMap =newHashMap<>(); configMap.put("users",RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofHours(1)).serializeValuesWith(SerializationPair.fromSerializer(newGenericJackson2JsonRedisSerializer()))); configMap.put("products",RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(15)).serializeValuesWith(SerializationPair.fromSerializer(newJdkSerializationRedisSerializer())));return configMap;}@BeanpublicRedisTemplate<String,Object>redisTemplate(RedisConnectionFactory redisConnectionFactory){RedisTemplate<String,Object> template =newRedisTemplate<>(); template.setConnectionFactory(redisConnectionFactory); template.setKeySerializer(newStringRedisSerializer()); template.setValueSerializer(newGenericJackson2JsonRedisSerializer());return template;}}
@ConfigurationpublicclassMetricsConfig{@BeanpublicMeterRegistryCustomizer<MeterRegistry>metricsCommonTags(){return registry -> registry.config().commonTags("application","user-service","environment",System.getenv().getOrDefault("ENV","dev"));}@BeanpublicTimedAspecttimedAspect(MeterRegistry registry){returnnewTimedAspect(registry);}}@ServicepublicclassOrderService{privatefinalCounter orderCounter;privatefinalTimer orderProcessingTimer;privatefinalDistributionSummary orderAmountSummary;publicOrderService(MeterRegistry registry){this.orderCounter = registry.counter("orders.total");this.orderProcessingTimer = registry.timer("orders.processing.time");this.orderAmountSummary = registry.summary("orders.amount.summary");}publicOrdercreateOrder(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;}});}}
@ComponentpublicclassDatabaseHealthIndicatorimplementsHealthIndicator{@AutowiredprivateDataSource dataSource;@OverridepublicHealthhealth(){try(Connection connection = dataSource.getConnection()){if(connection.isValid(1000)){returnHealth.up().withDetail("database","Available").withDetail("validationQuery","SELECT 1").build();}else{returnHealth.down().withDetail("database","Not available").withException(newSQLException("Connection validation failed")).build();}}catch(SQLException e){returnHealth.down().withDetail("database","Not available").withException(e).build();}}}@ComponentpublicclassServiceHealthIndicatorimplementsHealthIndicator{@AutowiredprivateDiscoveryClient discoveryClient;@OverridepublicHealthhealth(){Map<String,Object> details =newHashMap<>();// 检查依赖服务状态List<String> services = discoveryClient.getServices(); details.put("total_services", services.size());List<String> unhealthyServices =newArrayList<>();for(String service : services){List<ServiceInstance> instances = discoveryClient.getInstances(service);if(instances.isEmpty()){ unhealthyServices.add(service);}}if(unhealthyServices.isEmpty()){returnHealth.up().withDetails(details).build();}else{ details.put("unhealthy_services", unhealthyServices);returnHealth.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: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:8888deploy:replicas:3resources: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:
# deployment.yamlapiVersion: apps/v1 kind: Deployment metadata:name: user-service labels:app: user-service spec:replicas:3selector: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:8080env:-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:8080initialDelaySeconds:60periodSeconds:10readinessProbe:httpGet:path: /actuator/health/readiness port:8080initialDelaySeconds:30periodSeconds:5---# service.yamlapiVersion: v1 kind: Service metadata:name: user-service spec:selector:app: user-service ports:-port:8080targetPort:8080type: ClusterIP ---# ingress.yamlapiVersion: 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
apiVersion: autoscaling/v2 kind: HorizontalPodAutoscaler metadata:name: user-service-hpa spec:scaleTargetRef:apiVersion: apps/v1 kind: Deployment name: user-service minReplicas:2maxReplicas:10metrics:-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:60policies:-type: Pods value:2periodSeconds:60-type: Percent value:10periodSeconds:60scaleDown:stabilizationWindowSeconds:300policies:-type: Pods value:1periodSeconds:60
服务网格将微服务通信、安全性和可观测性抽象到基础设施层。
# 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:10fixedDelay: 3s timeout: 2s
Java 函数即服务 (FaaS) 的发展：
// Spring Cloud Function 示例@SpringBootApplicationpublicclassFunctionApplication{publicstaticvoidmain(String[] args){SpringApplication.run(FunctionApplication.class, args);}@BeanpublicFunction<User,ApiResponse>createUser(){return user ->{// 业务逻辑User savedUser = userService.save(user);returnnewApiResponse("User created successfully", savedUser);};}@BeanpublicConsumer<Event>processEvent(){return event ->{// 处理事件 eventProcessor.process(event);};}@BeanpublicSupplier<List<User>>getUsers(){return()-> userService.getAllUsers();}}
机器学习在微服务运维中的应用：
// 异常检测示例@ServicepublicclassAnomalyDetectionService{@AutowiredprivateMeterRegistry meterRegistry;privatefinalMap<String,Double> baselineMetrics =newConcurrentHashMap<>();@Scheduled(fixedRate =60000)publicvoiddetectAnomalies(){// 收集当前指标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(newAnomalyAlert(metricName, currentValue, baselineValue, deviation));}}// 更新基线（指数加权移动平均）updateBaseline(metricName, currentValue);}}privateMap<String,Double>collectMetrics(){Map<String,Double> metrics =newHashMap<>();// 收集响应时间指标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;}privatevoidupdateBaseline(String metricName,Double currentValue){ baselineMetrics.compute(metricName,(key, oldValue)->{if(oldValue ==null){return currentValue;}// EWMA: α=0.1return0.9* oldValue +0.1* 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