Spring Cloud 微服务架构与开发实战

Spring Cloud 微服务架构与开发实战 | 极客日志

├── infrastructure/ # 基础设施
│   ├── docker-compose.yml # 本地开发环境
│   ├── k8s/ # Kubernetes 部署文件
│   └── monitoring/ # 监控配置
├── config-server/ # 配置中心
├── gateway-service/ # API 网关
├── services/ # 业务服务
│   ├── user-service/ # 用户服务
│   ├── order-service/ # 订单服务
│   ├── product-service/ # 商品服务
│   └── notification-service/ # 通知服务
├── libs/ # 共享库
│   ├── common-core/ # 核心工具
│   ├── common-security/ # 安全模块
│   ├── common-tracing/ # 链路追踪
│   └── common-events/ # 事件驱动
└── tests/ # 端到端测试
    ├── contract-tests/ # 契约测试
    └── performance-tests/ # 性能测试

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-consul-discovery</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

spring:
  application:
    name: user-service
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        service-name: ${spring.application.name}
        health-check-path: /actuator/health
        health-check-interval: 15s
        health-check-timeout: 10s
        health-check-critical-timeout: 30s
        instance-id: ${spring.application.name}-${server.port}-${random.value}
        prefer-ip-address: true
        ip-address: ${spring.cloud.client.ip-address}
        tags:
          - version=1.0
          - environment=dev
management:
  endpoints:
    web:
      exposure:
        include: health,info
      endpoint:
        health:
          show-details: always

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

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-kubernetes-client-all</artifactId>
</dependency>

spring:
  application:
    name: user-service
  cloud:
    kubernetes:
      discovery:
        enabled: true
        all-namespaces: false
        namespace: default
      client:
        namespace: default

apiVersion: v1
kind: Service
metadata:
  name: user-service
  labels:
    app: user-service
spec:
  selector:
    app: user-service
  ports:
    - port: 8080
      targetPort: 8080
      name: http
  type: ClusterIP

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.8</version>
        <relativePath/>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>eureka-server</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>eureka-server</name>
    <properties>
        <java.version>11</java.version>
        <spring-cloud.version>2021.0.5</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

package com.example.eureka;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

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

server:
  port: 8761
spring:
  application:
    name: eureka-server
  eureka:
    instance:
      hostname: localhost
    client:
      register-with-eureka: false # 自己不注册到 eureka
      fetch-registry: false # 不从 eureka 获取注册信息
      service-url:
        defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
    server:
      enable-self-preservation: false # 关闭自我保护模式（开发环境）
      eviction-interval-timer-in-ms: 5000 # 清理间隔（默认 60 秒）

server:
  port: 8761
spring:
  application:
    name: eureka-server
    profiles: peer1
  eureka:
    instance:
      hostname: eureka-peer1
    client:
      service-url:
        defaultZone: http://eureka-peer2:8762/eureka/

server:
  port: 8762
spring:
  application:
    name: eureka-server
    profiles: peer2
  eureka:
    instance:
      hostname: eureka-peer2
    client:
      service-url:
        defaultZone: http://eureka-peer1:8761/eureka/

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

package com.example.user;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

server:
  port: 8081
spring:
  application:
    name: user-service
  datasource:
    url: jdbc:mysql://localhost:3306/user_db
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
      show-sql: true
  eureka:
    client:
      service-url:
        defaultZone: http://localhost:8761/eureka/
      instance:
        prefer-ip-address: true
        lease-renewal-interval-in-seconds: 30
        lease-expiration-duration-in-seconds: 90

package com.example.user.entity;

import javax.persistence.*;
import java.time.LocalDateTime;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String username;

    @Column(nullable = false)
    private String password;

    @Column(nullable = false, unique = true)
    private String email;

    private Integer age;
    private String phone;

    @Column(name = "created_at")
    private LocalDateTime createdAt;

    @PrePersist
    protected void onCreate() {
        createdAt = LocalDateTime.now();
    }

    // 构造方法、getters、setters
}

package com.example.user.controller;

import com.example.user.entity.User;
import com.example.user.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @Value("${server.port}")
    private String port;

    @GetMapping
    public List<User> getAllUsers() {
        return userService.findAll();
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        User user = userService.findById(id);
        // 添加端口信息用于测试负载均衡
        user.setUsername(user.getUsername() + " from port: " + port);
        return user;
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        return userService.update(user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteById(id);
    }
}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-consul-discovery</artifactId>
</dependency>

spring:
  application:
    name: user-service
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        service-name: ${spring.application.name}
        health-check-path: /actuator/health
        health-check-interval: 15s
        instance-id: ${spring.application.name}-${server.port}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

package com.example.order.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {
    @Bean
    @LoadBalanced // 启用负载均衡
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

package com.example.order.service;

import com.example.order.entity.Order;
import com.example.order.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class OrderService {
    @Autowired
    private RestTemplate restTemplate;

    public Order createOrder(Order order) {
        // 通过服务名调用用户服务
        User user = restTemplate.getForObject("http://user-service/users/" + order.getUserId(), User.class);
        if (user != null) {
            order.setUsername(user.getUsername());
            // 保存订单逻辑
            return order;
        }
        throw new RuntimeException("用户不存在");
    }
}

@Configuration
public class RibbonConfig {
    @Bean
    public IRule ribbonRule() {
        // 随机策略
        return new RandomRule();
        // 轮询策略（默认）
        // return new RoundRobinRule();
        // 重试策略
        // return new RetryRule();
        // 响应时间权重策略
        // return new WeightedResponseTimeRule();
        // 最佳可用策略
        // return new BestAvailableRule();
    }
}

user-service:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule
    ConnectTimeout: 5000
    ReadTimeout: 5000
    MaxAutoRetries: 1
    MaxAutoRetriesNextServer: 2

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

@Configuration
public class LoadBalancerConfig {
    @Bean
    public ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment, LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new RandomLoadBalancer(
                loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class),
                name);
    }
}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

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

package com.example.order.feign;

import com.example.order.entity.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;
import java.util.List;

@FeignClient(name = "user-service", fallback = UserServiceFallback.class)
public interface UserServiceClient {
    @GetMapping("/users/{id}")
    User getUserById(@PathVariable("id") Long id);

    @GetMapping("/users")
    List<User> getAllUsers();

    @PostMapping("/users")
    User createUser(@RequestBody User user);

    @PutMapping("/users/{id}")
    User updateUser(@PathVariable("id") Long id, @RequestBody User user);

    @DeleteMapping("/users/{id}")
    void deleteUser(@PathVariable("id") Long id);
}

feign:
  httpclient:
    enabled: true
    max-connections: 200
    max-connections-per-route: 50
  compression:
    request:
      enabled: true
      mime-types: text/xml,application/xml,application/json
      min-request-size: 2048
    response:
      enabled: true
  client:
    config:
      default:
        connectTimeout: 5000
        readTimeout: 5000
        loggerLevel: basic

@Service
public class OrderService {
    @Autowired
    private UserServiceClient userServiceClient;

    @Autowired
    private OrderRepository orderRepository;

    public Order createOrder(Order order) {
        // 调用用户服务验证用户
        User user = userServiceClient.getUserById(order.getUserId());
        if (user != null) {
            order.setUsername(user.getUsername());
            return orderRepository.save(order);
        }
        throw new RuntimeException("用户不存在");
    }

    public List<Order> getOrdersByUserId(Long userId) {
        // 验证用户存在
        User user = userServiceClient.getUserById(userId);
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }
        return orderRepository.findByUserId(userId);
    }
}

@Component
public class FeignRequestInterceptor implements RequestInterceptor {
    @Override
    public void apply(RequestTemplate template) {
        // 添加请求头
        template.header("X-Request-Id", UUID.randomUUID().toString());
        // 传递认证信息
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes != null) {
            HttpServletRequest request = attributes.getRequest();
            String authorization = request.getHeader("Authorization");
            if (authorization != null) {
                template.header("Authorization", authorization);
            }
        }
        // 添加自定义参数
        template.query("timestamp", String.valueOf(System.currentTimeMillis()));
    }
}

@Configuration
public class FeignConfig {
    @Bean
    public Logger.Level feignLoggerLevel() {
        return Logger.Level.FULL;
    }

    @Bean
    public Contract feignContract() {
        return new SpringMvcContract();
    }

    @Bean
    public Retryer feignRetryer() {
        return new Retryer.Default(100, 1000, 3);
    }

    @Bean
    public ErrorDecoder feignErrorDecoder() {
        return new CustomErrorDecoder();
    }
}

// 自定义错误解码器
public class CustomErrorDecoder implements ErrorDecoder {
    @Override
    public Exception decode(String methodKey, Response response) {
        switch (response.status()) {
            case 400: return new BadRequestException("请求参数错误");
            case 404: return new NotFoundException("资源不存在");
            case 500: return new InternalServerErrorException("服务器内部错误");
            default: return new Exception("未知错误");
        }
    }
}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
@EnableHystrix
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

@Component
public class UserServiceFallback implements UserServiceClient {
    @Override
    public User getUserById(Long id) {
        User user = new User();
        user.setId(id);
        user.setUsername("默认用户");
        user.setEmail("[email protected]");
        return user;
    }

    @Override
    public List<User> getAllUsers() {
        return Collections.emptyList();
    }

    @Override
    public User createUser(User user) {
        throw new RuntimeException("用户服务不可用，无法创建用户");
    }

    @Override
    public User updateUser(Long id, User user) {
        throw new RuntimeException("用户服务不可用，无法更新用户");
    }

    @Override
    public void deleteUser(Long id) {
        throw new RuntimeException("用户服务不可用，无法删除用户");
    }
}

@Service
public class OrderService {
    @HystrixCommand(
            fallbackMethod = "createOrderFallback",
            commandProperties = {
                    @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000"),
                    @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
                    @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "50")
            })
    public Order createOrder(Order order) {
        // 调用远程服务
        User user = userServiceClient.getUserById(order.getUserId());
        order.setUsername(user.getUsername());
        return orderRepository.save(order);
    }

    public Order createOrderFallback(Order order) {
        order.setUsername("默认用户");
        order.setStatus("PENDING");
        return orderRepository.save(order);
    }
}

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080
        port: 8719
      datasource:
        ds1:
            file: file:classpath:flowrule.json
            data-type: json
            rule-type: flow

@PostConstruct
public void initFlowRules() {
    List<FlowRule> rules = new ArrayList<>();
    FlowRule rule = new FlowRule();
    rule.setResource("getUserById");
    rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
    rule.setCount(20); // 每秒最多 20 个请求
    rules.add(rule);
    FlowRuleManager.loadRules(rules);
}

@RestController
public class UserController {
    @SentinelResource(
            value = "getUserById",
            blockHandler = "getUserByIdBlockHandler",
            fallback = "getUserByIdFallback")
    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.findById(id);
    }

    // 限流处理方法
    public User getUserByIdBlockHandler(Long id, BlockException ex) {
        User user = new User();
        user.setId(id);
        user.setUsername("系统繁忙，请稍后再试");
        return user;
    }

    // 降级处理方法
    public User getUserByIdFallback(Long id, Throwable ex) {
        User user = new User();
        user.setId(id);
        user.setUsername("服务暂时不可用");
        return user;
    }
}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-circuitbreaker-resilience4j</artifactId>
</dependency>

resilience4j:
  circuitbreaker:
    instances:
      userService:
        registerHealthIndicator: true
        slidingWindowSize: 10
        permittedNumberOfCallsInHalfOpenState: 3
        slidingWindowType: COUNT_BASED
        minimumNumberOfCalls: 5
        waitDurationInOpenState: 5s
        failureRateThreshold: 50
        eventConsumerBufferSize: 10
  retry:
    instances:
      userService:
        maxAttempts: 3
        waitDuration: 1s
  ratelimiter:
    instances:
      userService:
        limitRefreshPeriod: 1s
        limitForPeriod: 10

@Service
public class OrderService {
    private final CircuitBreaker circuitBreaker;
    private final UserServiceClient userServiceClient;

    public OrderService(CircuitBreakerFactory circuitBreakerFactory, UserServiceClient userServiceClient) {
        this.circuitBreaker = circuitBreakerFactory.create("userService");
        this.userServiceClient = userServiceClient;
    }

    public Order createOrder(Order order) {
        Supplier<User> decoratedSupplier = circuitBreaker.decorateSupplier(() -> userServiceClient.getUserById(order.getUserId()));
        try {
            User user = decoratedSupplier.get();
            order.setUsername(user.getUsername());
        } catch (Exception e) {
            order.setUsername("默认用户");
        }
        return orderRepository.save(order);
    }
}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

server:
  port: 8080
spring:
  application:
    name: gateway-server
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true # 启用服务发现
          lower-case-service-id: true
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/users/**
          filters:
            - StripPrefix=0
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/orders/**
          filters:
            - StripPrefix=0
        - id: product-service
          uri: lb://product-service
          predicates:
            - Path=/products/**
          filters:
            - StripPrefix=0
  eureka:
    client:
      service-url:
        defaultZone: http://localhost:8761/eureka/

@Component
@Slf4j
public class GlobalAuthFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();
        String path = request.getPath().toString();
        log.info("请求路径：{}", path);

        // 白名单路径
        List<String> whitelist = Arrays.asList("/users/login", "/users/register");
        if (whitelist.contains(path)) {
            return chain.filter(exchange);
        }

        // 验证 Authorization 头
        String authorization = request.getHeaders().getFirst("Authorization");
        if (authorization == null || !authorization.startsWith("Bearer ")) {
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }

        // JWT token 验证
        String token = authorization.substring(7);
        if (!validateToken(token)) {
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }

        // 添加用户信息到请求头
        String userId = extractUserIdFromToken(token);
        ServerHttpRequest modifiedRequest = request.mutate().header("X-User-Id", userId).build();
        return chain.filter(exchange.mutate().request(modifiedRequest).build());
    }

    @Override
    public int getOrder() {
        return -100; // 优先级高
    }

    private boolean validateToken(String token) {
        // JWT token 验证逻辑
        return true;
    }

    private String extractUserIdFromToken(String token) {
        // 从 token 中提取用户 ID
        return "123";
    }
}

@Component
public class RequestTimeGatewayFilterFactory extends AbstractGatewayFilterFactory<RequestTimeGatewayFilterFactory.Config> {
    private static final String REQUEST_TIME_BEGIN = "requestTimeBegin";

    public RequestTimeGatewayFilterFactory() {
        super(Config.class);
    }

    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            exchange.getAttributes().put(REQUEST_TIME_BEGIN, System.currentTimeMillis());
            return chain.filter(exchange).then(Mono.fromRunnable(() -> {
                Long startTime = exchange.getAttribute(REQUEST_TIME_BEGIN);
                if (startTime != null) {
                    long duration = System.currentTimeMillis() - startTime;
                    log.info("请求耗时：{}ms, 路径：{}", duration, exchange.getRequest().getPath());
                }
            }));
        };
    }

    @Data
    public static class Config {
        private boolean enabled = true;
    }
}

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/users/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10 # 每秒产生的令牌数
                redis-rate-limiter.burstCapacity: 20 # 令牌桶容量
                key-resolver: "#{@ipKeyResolver}"

@Configuration
public class KeyResolverConfig {
    @Bean
    @Primary
    public KeyResolver ipKeyResolver() {
        return exchange -> Mono.just(exchange.getRequest().getRemoteAddress().getAddress().getHostAddress());
    }

    @Bean
    public KeyResolver userKeyResolver() {
        return exchange -> Mono.just(exchange.getRequest().getHeaders().getFirst("X-User-Id"));
    }

    @Bean
    public KeyResolver pathKeyResolver() {
        return exchange -> Mono.just(exchange.getRequest().getPath().toString());
    }
}

@RestController
@RequestMapping("/gateway")
public class GatewayController {
    @Autowired
    private RouteDefinitionWriter routeDefinitionWriter;

    @Autowired
    private ApplicationEventPublisher publisher;

    @PostMapping("/routes")
    public ResponseEntity<String> addRoute(@RequestBody RouteDefinition definition) {
        try {
            routeDefinitionWriter.save(Mono.just(definition)).subscribe();
            publisher.publishEvent(new RefreshRoutesEvent(this));
            return ResponseEntity.ok("路由添加成功");
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("路由添加失败：" + e.getMessage());
        }
    }

    @DeleteMapping("/routes/{id}")
    public ResponseEntity<String> deleteRoute(@PathVariable String id) {
        try {
            routeDefinitionWriter.delete(Mono.just(id)).subscribe();
            publisher.publishEvent(new RefreshRoutesEvent(this));
            return ResponseEntity.ok("路由删除成功");
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("路由删除失败：" + e.getMessage());
        }
    }
}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

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

server:
  port: 8888
spring:
  application:
    name: config-server
  cloud:
    config:
      server:
        git:
          uri: https://github.com/example/config-repo
          username: your-username
          password: your-password
          default-label: main
          search-paths: config
        # 本地文件系统
        # native:
        #   search-locations: classpath:/config/
  eureka:
    client:
      service-url:
        defaultZone: http://localhost:8761/eureka/

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

spring:
  application:
    name: user-service
  cloud:
    config:
      uri: http://localhost:8888
      profile: dev
      label: main
      fail-fast: true
      retry:
        initial-interval: 2000
        max-attempts: 5
  management:
    endpoints:
      web:
        exposure:
          include: refresh

@ConfigurationProperties(prefix = "app")
@RefreshScope
@Component
public class AppConfig {
    private String name;
    private String version;
    private String description;

    // getters and setters
}

@RestController
@RefreshScope
public class ConfigController {
    @Value("${app.name:Default App}")
    private String appName;

    @Autowired
    private AppConfig appConfig;

    @GetMapping("/config")
    public Map<String, Object> getConfig() {
        Map<String, Object> config = new HashMap<>();
        config.put("appName", appName);
        config.put("appConfig", appConfig);
        return config;
    }
}

# 手动刷新配置
curl -X POST http://localhost:8081/actuator/refresh

# application.yml
encrypt:
  key: mySecretKey
# 加密密码：
# 加密 curl http://localhost:8888/encrypt -d mysecret
# 解密 curl http://localhost:8888/decrypt -d 682bc583f4641835fa2db009355293665d2647dade3375c0ee201de2a49f7bda
# 使用加密配置：
spring:
  datasource:
    password: '{cipher}682bc583f4641835fa2db009355293665d2647dade3375c0ee201de2a49f7bda'

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

spring:
  application:
    name: user-service
  cloud:
    nacos:
      config:
        server-addr: localhost:8848
        file-extension: yml
        group: DEFAULT_GROUP
        namespace: dev
        refresh-enabled: true
      discovery:
        server-addr: localhost:8848

@Component
@NacosConfigurationProperties(prefix = "app", autoRefreshed = true)
public class AppConfig {
    private String name;
    private String version;

    @NacosValue(value = "${app.description:default}", autoRefreshed = true)
    private String description;

    // getters and setters
}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

spring:
  sleuth:
    sampler:
      probability: 1.0 # 采样率
  zipkin:
    base-url: http://localhost:9411
  application:
    name: user-service
  logging:
    pattern:
      level: "%5p [${spring.application.name:},%X{traceId:-},%X{spanId:-}]"

@Service
public class UserService {
    @Autowired
    private Tracer tracer;

    @NewSpan("findUser")
    public User findById(@SpanTag("userId") Long id) {
        // 业务逻辑
        return userRepository.findById(id).orElse(null);
    }

    public List<User> findAll() {
        Span span = tracer.nextSpan().name("findAllUsers").start();
        try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) {
            span.tag("operation", "findAll");
            return userRepository.findAll();
        } finally {
            span.end();
        }
    }
}

docker run -d -p 9411:9411 openzipkin/zipkin

@Configuration
public class ZipkinConfig {
    @Bean
    public Sender sender() {
        return OkHttpSender.create("http://localhost:9411/api/v2/spans");
    }

    @Bean
    public AsyncReporter<Span> spanReporter() {
        return AsyncReporter.create(sender());
    }

    @Bean
    public Brave brave() {
        return Brave.newBuilder()
                .localServiceName("user-service")
                .spanReporter(spanReporter())
                .sampler(Sampler.create(1.0f))
                .build();
    }
}

@Component
public class PerformanceTracer {
    @EventListener
    public void onSpanFinished(SpanFinishedEvent event) {
        Span span = event.getSpan();
        long duration = span.getRemoteServiceName() != null ? span.getDurationInNanos() / 1000000 : 0;
        if (duration > 1000) { // 超过 1 秒的请求
            log.warn("慢请求检测：{} 耗时：{}ms", span.getName(), duration);
        }
        // 记录到监控系统
        recordMetrics(span.getName(), duration);
    }

    private void recordMetrics(String operation, long duration) {
        // 记录指标到 Micrometer
        Timer.Sample.start().stop(Timer.builder("request.duration").tag("operation", operation).register(Metrics.globalRegistry));
    }
}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
</dependency>
<!-- 或者使用 Kafka -->
<!--<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-stream-kafka</artifactId></dependency>-->

spring:
  cloud:
    stream:
      bindings:
        output:
          destination: user-events
          content-type: application/json
        input:
          destination: order-events
          content-type: application/json
        group: user-service-group
      rabbit:
        bindings:
          output:
            producer:
              routing-key-expression: headers.routingKey
          input:
            consumer:
              auto-bind-dlq: true
              republish-to-dlq: true

@EnableBinding(Source.class)
@Service
public class UserEventPublisher {
    @Autowired
    private Source source;

    public void publishUserCreated(User user) {
        UserEvent event = new UserEvent();
        event.setEventType("USER_CREATED");
        event.setUserId(user.getId());
        event.setUsername(user.getUsername());
        event.setTimestamp(LocalDateTime.now());
        Message<UserEvent> message = MessageBuilder.withPayload(event)
                .setHeader("routingKey", "user.created")
                .setHeader("eventType", "USER_CREATED")
                .build();
        source.output().send(message);
    }
}

@EnableBinding(Sink.class)
@Component
public class OrderEventListener {
    @StreamListener(Sink.INPUT)
    public void handleOrderEvent(OrderEvent event) {
        log.info("接收到订单事件：{}", event);
        switch (event.getEventType()) {
            case "ORDER_CREATED":
                handleOrderCreated(event);
                break;
            case "ORDER_PAID":
                handleOrderPaid(event);
                break;
            case "ORDER_CANCELLED":
                handleOrderCancelled(event);
                break;
        }
    }

    private void handleOrderCreated(OrderEvent event) {
        // 处理订单创建事件
        log.info("处理订单创建事件：订单 ID={}", event.getOrderId());
    }
}

spring:
  cloud:
    function:
      definition: processOrder;userProcessor
    stream:
      bindings:
        processOrder-in-0:
          destination: order-events
        processOrder-out-0:
          destination: user-notifications
        userProcessor-in-0:
          destination: user-events

@Configuration
public class StreamFunctions {
    @Bean
    public Function<OrderEvent, UserNotification> processOrder() {
        return orderEvent -> {
            UserNotification notification = new UserNotification();
            notification.setUserId(orderEvent.getUserId());
            notification.setMessage("您的订单 " + orderEvent.getOrderId() + " 已创建");
            notification.setType("ORDER_NOTIFICATION");
            return notification;
        };
    }

    @Bean
    public Consumer<UserEvent> userProcessor() {
        return userEvent -> {
            log.info("处理用户事件：{}", userEvent);
            // 处理用户相关业务逻辑
        };
    }

    @Bean
    public Supplier<String> heartbeat() {
        return () -> "heartbeat-" + System.currentTimeMillis();
    }
}

spring:
  cloud:
    stream:
      bindings:
        input:
          consumer:
            max-attempts: 3
            back-off-initial-interval: 1000
            back-off-max-interval: 10000
            back-off-multiplier: 2
      rabbit:
        bindings:
          input:
            consumer:
              auto-bind-dlq: true
              republish-to-dlq: true
              dlq-ttl: 60000

@Component
public class StreamErrorHandler {
    @ServiceActivator(inputChannel = "user-events.user-service-group.errors")
    public void handleError(ErrorMessage errorMessage) {
        log.error("消息处理失败", errorMessage.getPayload());
        Throwable cause = errorMessage.getPayload();
        Message<?> originalMessage = (Message<?>) errorMessage.getOriginalMessage();

        // 自定义错误处理逻辑
        if (shouldRetry(cause)) {
            // 重试逻辑
            retryMessage(originalMessage);
        } else {
            // 发送到死信队列
            sendToDeadLetterQueue(originalMessage);
        }
    }

    private boolean shouldRetry(Throwable cause) {
        // 判断是否应该重试
        return !(cause instanceof IllegalArgumentException);
    }
}

<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-server</artifactId>
    <version>2.7.0</version>
</dependency>

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

<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-client</artifactId>
    <version>2.7.0</version>
</dependency>

spring:
  boot:
    admin:
      client:
        url: http://localhost:8090
        instance:
          prefer-ip: true
  management:
    endpoints:
      web:
        exposure:
          include: "*"
      endpoint:
        health:
          show-details: always

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

@Component
public class CustomMetrics {
    private final Counter userRegistrationCounter;
    private final Timer userLoginTimer;
    private final Gauge activeUsersGauge;

    public CustomMetrics(MeterRegistry meterRegistry) {
        this.userRegistrationCounter = Counter.builder("user_registrations_total")
                .description("用户注册总数")
                .register(meterRegistry);
        this.userLoginTimer = Timer.builder("user_login_duration_seconds")
                .description("用户登录耗时")
                .register(meterRegistry);
        this.activeUsersGauge = Gauge.builder("active_users_count")
                .description("当前活跃用户数")
                .register(meterRegistry, this, CustomMetrics::getActiveUserCount);
    }

    public void incrementUserRegistration() {
        userRegistrationCounter.increment();
    }

    public Timer.Sample startLoginTimer() {
        return Timer.start();
    }

    public void recordLoginTime(Timer.Sample sample) {
        sample.stop(userLoginTimer);
    }

    private double getActiveUserCount() {
        // 返回当前活跃用户数
        return userService.getActiveUserCount();
    }
}

<!-- logback-spring.xml -->
<configuration>
    <springProfile name="!local">
        <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
            <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
                <providers>
                    <timestamp/>
                    <logLevel/>
                    <loggerName/>
                    <mdc/>
                    <arguments/>
                    <message/>
                    <stackTrace/>
                </providers>
            </encoder>
        </appender>
        <appender name="LOGSTASH" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
            <destination>localhost:5000</destination>
            <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
                <providers>
                    <timestamp/>
                    <version/>
                    <logLevel/>
                    <message/>
                    <mdc/>
                    <loggerName/>
                    <stackTrace/>
                </providers>
            </encoder>
        </appender>
        <root level="INFO">
            <appender-ref ref="STDOUT"/>
            <appender-ref ref="LOGSTASH"/>
        </root>
    </springProfile>
</configuration>

@Component
@Slf4j
public class StructuredLogger {
    public void logUserAction(String action, Long userId, Map<String, Object> details) {
        MDC.put("action", action);
        MDC.put("userId", String.valueOf(userId));
        MDC.put("service", "user-service");
        try {
            log.info("用户操作：{} 详情：{}", action, details);
        } finally {
            MDC.clear();
        }
    }

    public void logBusinessEvent(String event, Map<String, Object> data) {
        ObjectNode logNode = JsonNodeFactory.instance.objectNode();
        logNode.put("timestamp", Instant.now().toString());
        logNode.put("event", event);
        logNode.put("service", "user-service");
        logNode.set("data", objectMapper.valueToTree(data));
        log.info(logNode.toString());
    }
}

# 构建阶段
FROM maven:3.8.4-openjdk-11 AS builder
WORKDIR /app
COPY pom.xml .
COPY src ./src
RUN mvn clean package -DskipTests

# 运行阶段
FROM openjdk:11-jre-slim
WORKDIR /app

# 创建非 root 用户
RUN groupadd -r appuser && useradd -r -g appuser appuser

# 复制应用程序
COPY --from=builder /app/target/*.jar app.jar

# 更改所有权
RUN chown -R appuser:appuser /app

# 切换到非 root 用户
USER appuser

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

EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

version: '3.8'
services:
  eureka-server:
    build: ./eureka-server
    ports:
      - "8761:8761"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8761/actuator/health"]
      interval: 30s
      timeout: 10s
      retries: 3
  config-server:
    build: ./config-server
    ports:
      - "8888:8888"
    depends_on:
      eureka-server:
        condition: service_healthy
    environment:
      - EUREKA_CLIENT_SERVICE_URL_DEFAULTZONE=http://eureka-server:8761/eureka/
  user-service:
    build: ./user-service
    ports:
      - "8081:8081"
    depends_on:
      - eureka-server
      - config-server
      - mysql
    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: 2
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
  mysql:
    image: mysql:8.0
    ports:
      - "3306:3306"
    environment:
      MYSQL_ROOT_PASSWORD: 123456
      MYSQL_DATABASE: microservice_db
    volumes:
      - mysql_data:/var/lib/mysql
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
  redis:
    image: redis:6.2-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
volumes:
  mysql_data:
  redis_data:

# 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
    spec:
      containers:
        - name: user-service
          image: user-service:latest
          ports:
            - containerPort: 8081
          env:
            - name: SPRING_PROFILES_ACTIVE
              value: "k8s"
            - name: EUREKA_CLIENT_SERVICE_URL_DEFAULTZONE
              value: "http://eureka-server:8761/eureka/"
          resources:
            requests:
              memory: "256Mi"
              cpu: "250m"
            limits:
              memory: "512Mi"
              cpu: "500m"
          livenessProbe:
            httpGet:
              path: /actuator/health
              port: 8081
            initialDelaySeconds: 60
            periodSeconds: 30
          readinessProbe:
            httpGet:
              path: /actuator/health
              port: 8081
            initialDelaySeconds: 30
            periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
  ports:
    - protocol: TCP
      port: 8081
      targetPort: 8081
  type: ClusterIP
---
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

apiVersion: v1
kind: ConfigMap
metadata:
  name: user-service-config
data:
  application.yml: |
    spring:
      datasource:
        url: jdbc:mysql://mysql:3306/user_db
        username: root
      jpa:
        hibernate:
          ddl-auto: update
      eureka:
        client:
          service-url:
            defaultZone: http://eureka-server:8761/eureka/
      management:
        endpoints:
          web:
            exposure: include: "*"
---
apiVersion: v1
kind: Secret
metadata:
  name: user-service-secret
type: Opaque
data:
  database-password: MTIzNDU2 # base64 编码的密码

# prometheus.yml
global:
  scrape_interval: 15s
scrape_configs:
  - job_name: 'user-service'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['user-service:8081']
    scrape_interval: 5s
  - job_name: 'order-service'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['order-service:8082']
    scrape_interval: 5s
  rule_files:
    - "alert_rules.yml"
  alerting:
    alertmanagers:
      - static_configs:
          - targets:
              - alertmanager:9093

# alert_rules.yml
groups:
  - name: microservice_alerts
    rules:
      - alert: ServiceDown
        expr: up==0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "服务 {{ $labels.job }} 不可用"
          description: "服务 {{ $labels.job }} 已经宕机超过 1 分钟"
      - alert: HighErrorRate
        expr: rate(http_requests_total{status=~"5.."}[5m])>0.1
        for: 2m
        labels:
          severity: warning
        annotations:
          summary: "高错误率检测"
          description: "服务 {{ $labels.job }} 错误率超过 10%"
      - alert: HighLatency
        expr: histogram_quantile(0.95,rate(http_request_duration_seconds_bucket[5m]))>0.5
        for: 3m
        labels:
          severity: warning
        annotations:
          summary: "高延迟检测"
          description: "服务 {{ $labels.job }} 95% 请求延迟超过 500ms"

// 用户聚合根
@Entity
public class User {
    @Id
    private Long id;
    private String username;
    private String email;

    // 用户相关业务逻辑
    public void changePassword(String newPassword) {
        // 密码变更逻辑
        this.password = encryptPassword(newPassword);
        // 发布密码变更事件
        DomainEventPublisher.publish(new PasswordChangedEvent(this.id));
    }
}

// 订单聚合根
@Entity
public class Order {
    @Id
    private Long id;
    private Long userId;
    private OrderStatus status;
    private List<OrderItem> items;

    // 订单相关业务逻辑
    public void confirm() {
        if (this.status != OrderStatus.PENDING) {
            throw new IllegalStateException("只有待确认订单才能确认");
        }
        this.status = OrderStatus.CONFIRMED;
        // 发布订单确认事件
        DomainEventPublisher.publish(new OrderConfirmedEvent(this.id, this.userId));
    }
}

@Component
public class OrderSaga {
    @SagaOrchestrationStart
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 1. 扣减库存
        choreography.call("inventory-service", "reduceStock", event.getItems())
                .compensate("inventory-service", "restoreStock", event.getItems());
        // 2. 扣减余额
        choreography.call("payment-service", "deductBalance", event.getPayment())
                .compensate("payment-service", "refund", event.getPayment());
        // 3. 确认订单
        choreography.call("order-service", "confirmOrder", event.getOrderId())
                .compensate("order-service", "cancelOrder", event.getOrderId());
    }

    @SagaOrchestrationEnd
    public void handleOrderCompleted(OrderCompletedEvent event) {
        log.info("订单处理完成：{}", event.getOrderId());
    }

    @SagaOrchestrationError
    public void handleOrderFailed(OrderFailedEvent event) {
        log.error("订单处理失败：{}", event.getOrderId());
        // 执行补偿操作
    }
}

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                .antMatchers("/api/auth/**").permitAll()
                .antMatchers(HttpMethod.GET, "/api/users/**").hasAnyRole("USER", "ADMIN")
                .antMatchers(HttpMethod.POST, "/api/users/**").hasRole("ADMIN")
                .anyRequest().authenticated()
                .and()
                .addFilterBefore(jwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
    }

    @Bean
    public JwtAuthenticationFilter jwtAuthenticationFilter() {
        return new JwtAuthenticationFilter();
    }
}

// 服务间认证
@Component
public class ServiceToServiceAuthInterceptor implements RequestInterceptor {
    @Override
    public void apply(RequestTemplate template) {
        // 添加服务间认证 token
        String serviceToken = generateServiceToken();
        template.header("X-Service-Token", serviceToken);
    }

    private String generateServiceToken() {
        // 生成服务间认证 token
        return jwtTokenUtil.generateServiceToken();
    }
}

@Service
@CacheConfig(cacheNames = "users")
public class UserService {
    @Cacheable(key = "#id")
    public User findById(Long id) {
        return userRepository.findById(id).orElse(null);
    }

    @CachePut(key = "#user.id")
    public User save(User user) {
        return userRepository.save(user);
    }

    @CacheEvict(key = "#id")
    public void deleteById(Long id) {
        userRepository.deleteById(id);
    }

    @Cacheable(key = "'all:' + #pageable.pageNumber + ':' + #pageable.pageSize")
    public Page<User> findAll(Pageable pageable) {
        return userRepository.findAll(pageable);
    }
}

spring:
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      connection-timeout: 20000
      idle-timeout: 300000
      max-lifetime: 1200000
      leak-detection-threshold: 60000

@Component
public class CustomHealthIndicator implements HealthIndicator {
    @Autowired
    private UserServiceClient userServiceClient;

    @Override
    public Health health() {
        try {
            // 检查依赖服务
            userServiceClient.healthCheck();
            // 检查数据库连接
            dataSource.getConnection().close();
            // 检查 Redis 连接
            redisTemplate.opsForValue().get("health-check");
            return Health.up()
                    .withDetail("database", "Connected")
                    .withDetail("redis", "Connected")
                    .withDetail("userService", "Available")
                    .build();
        } catch (Exception e) {
            return Health.down().withDetail("error", e.getMessage()).build();
        }
    }
}

# 2025 年推荐的 K8s 集成配置
spring:
  cloud:
    kubernetes:
      discovery:
        enabled: true
        include-external-name-services: false
      config:
        enabled: true
        sources:
          - name: app-config
            namespace: default
          - name: shared-config
            namespace: shared
      loadbalancer:
        mode: service

// Istio 集成示例
@Configuration
@ConditionalOnProperty("spring.cloud.istio.enabled")
public class IstioConfig {
    @Bean
    public IstioLoadBalancer istioLoadBalancer() {
        return new IstioLoadBalancer();
    }
}

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-tracing-bridge-otel</artifactId>
</dependency>
<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-exporter-zipkin</artifactId>
</dependency>

management:
  tracing:
    sampling:
      probability: 1.0
  zipkin:
    tracing:
      endpoint: http://zipkin:9411/api/v2/spans

@Configuration
public class ModernGatewayConfig {
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route("modern-route", r -> r
                        .path("/api/v2/**")
                        .filters(f -> f
                                .circuitBreaker(config -> config
                                        .setName("userServiceCB")
                                        .setFallbackUri("/fallback"))
                                .retry(retryConfig -> retryConfig
                                        .setRetries(3)
                                        .setBackoff(Duration.ofMillis(100), Duration.ofSeconds(1), 2, true)))
                        .uri("lb://user-service"))
                .build();
    }
}

@Component
public class CloudEventHandler {
    @EventListener
    public void handleCloudEvent(CloudEvent event) {
        log.info("Received CloudEvent: {}", event.getType());
        // 处理标准化事件
    }
}

Spring Cloud 微服务架构与开发实战

SpringCloud 简介

微服务架构概述

服务注册与发现

负载均衡

服务调用

服务熔断与限流

API 网关

配置中心

服务链路追踪

消息驱动

服务监控

部署与运维

最佳实践

2025 年 SpringCloud 发展趋势与新特性

总结

更多推荐文章

相关免费在线工具

Spring Cloud 微服务架构与开发实战

SpringCloud 简介

微服务架构概述

服务注册与发现

负载均衡

服务调用

服务熔断与限流

API 网关

配置中心

服务链路追踪

消息驱动

服务监控

部署与运维

最佳实践

2025 年 SpringCloud 发展趋势与新特性

总结

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具