Spring Cloud 微服务 ​

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient      // 启用服务发现（Spring Cloud 通用注解）
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient      // 启用服务发现（Spring Cloud 通用注解）
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
@RequestMapping("/discovery")
public class DiscoveryController {

    private final DiscoveryClient discoveryClient;

    public DiscoveryController(DiscoveryClient discoveryClient) {
        this.discoveryClient = discoveryClient;
    }

    @GetMapping("/instances/{serviceId}")
    public List<?> getInstances(@PathVariable String serviceId) {
        // 获取某个服务的所有实例
        return discoveryClient.getInstances(serviceId);
    }

    @GetMapping("/services")
    public List<String> getServices() {
        // 获取所有已注册的服务名
        return discoveryClient.getServices();
    }
}

import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
@RequestMapping("/discovery")
public class DiscoveryController {

    private final DiscoveryClient discoveryClient;

    public DiscoveryController(DiscoveryClient discoveryClient) {
        this.discoveryClient = discoveryClient;
    }

    @GetMapping("/instances/{serviceId}")
    public List<?> getInstances(@PathVariable String serviceId) {
        // 获取某个服务的所有实例
        return discoveryClient.getInstances(serviceId);
    }

    @GetMapping("/services")
    public List<String> getServices() {
        // 获取所有已注册的服务名
        return discoveryClient.getServices();
    }
}

import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/config")
@RefreshScope                          // 标注在类上，配置变更时刷新 Bean
public class ConfigController {

    @Value("${spring.datasource.url}")
    private String datasourceUrl;

    @Value("${logging.level.com.example:INFO}")
    private String logLevel;

    @GetMapping("/show")
    public String show() {
        return "Datasource URL: " + datasourceUrl + ", Log Level: " + logLevel;
    }
}

import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/config")
@RefreshScope                          // 标注在类上，配置变更时刷新 Bean
public class ConfigController {

    @Value("${spring.datasource.url}")
    private String datasourceUrl;

    @Value("${logging.level.com.example:INFO}")
    private String logLevel;

    @GetMapping("/show")
    public String show() {
        return "Datasource URL: " + datasourceUrl + ", Log Level: " + logLevel;
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.util.UUID;

/**
 * 全局请求日志过滤器
 * 为每个请求添加 Trace ID，便于链路追踪
 */
@Component
public class TraceIdGlobalFilter implements GlobalFilter, Ordered {

    private static final Logger log = LoggerFactory.getLogger(TraceIdGlobalFilter.class);

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String traceId = UUID.randomUUID().toString().replace("-", "").substring(0, 16);

        ServerHttpRequest request = exchange.getRequest().mutate()
                .header("X-Trace-Id", traceId)
                .build();

        ServerWebExchange mutatedExchange = exchange.mutate().request(request).build();

        // 记录请求日志
        log.info("[{}] {} {}",
                traceId,
                request.getMethod(),
                request.getURI().getPath());

        return chain.filter(mutatedExchange);
    }

    /**
     * 返回 order 值，数值越小优先级越高
     */
    @Override
    public int getOrder() {
        return Ordered.LOWEST_PRECEDENCE;
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.util.UUID;

/**
 * 全局请求日志过滤器
 * 为每个请求添加 Trace ID，便于链路追踪
 */
@Component
public class TraceIdGlobalFilter implements GlobalFilter, Ordered {

    private static final Logger log = LoggerFactory.getLogger(TraceIdGlobalFilter.class);

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String traceId = UUID.randomUUID().toString().replace("-", "").substring(0, 16);

        ServerHttpRequest request = exchange.getRequest().mutate()
                .header("X-Trace-Id", traceId)
                .build();

        ServerWebExchange mutatedExchange = exchange.mutate().request(request).build();

        // 记录请求日志
        log.info("[{}] {} {}",
                traceId,
                request.getMethod(),
                request.getURI().getPath());

        return chain.filter(mutatedExchange);
    }

    /**
     * 返回 order 值，数值越小优先级越高
     */
    @Override
    public int getOrder() {
        return Ordered.LOWEST_PRECEDENCE;
    }
}

import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;

/**
 * 自定义过滤器工厂：移除指定请求头
 * 使用方式：- RemoveRequestHeaderSuffix=suffix1,suffix2
 */
@Component
public class RemoveRequestHeaderSuffixGatewayFilterFactory
        extends AbstractGatewayFilterFactory<RemoveRequestHeaderSuffixGatewayFilterFactory.Config> {

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

    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            ServerHttpRequest request = exchange.getRequest();
            HttpHeaders headers = request.getHeaders();

            headers.keySet().stream()
                    .filter(key -> config.getSuffixes().stream().anyMatch(key::endsWith))
                    .forEach(key -> {
                        request.mutate().headers(h -> h.remove(key));
                    });

            return chain.filter(exchange.mutate()
                    .request(request.mutate().build())
                    .build());
        };
    }

    public static class Config {
        private String suffixes;

        public String getSuffixes() {
            return suffixes;
        }

        public void setSuffixes(String suffixes) {
            this.suffixes = suffixes;
        }
    }
}

import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;

/**
 * 自定义过滤器工厂：移除指定请求头
 * 使用方式：- RemoveRequestHeaderSuffix=suffix1,suffix2
 */
@Component
public class RemoveRequestHeaderSuffixGatewayFilterFactory
        extends AbstractGatewayFilterFactory<RemoveRequestHeaderSuffixGatewayFilterFactory.Config> {

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

    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            ServerHttpRequest request = exchange.getRequest();
            HttpHeaders headers = request.getHeaders();

            headers.keySet().stream()
                    .filter(key -> config.getSuffixes().stream().anyMatch(key::endsWith))
                    .forEach(key -> {
                        request.mutate().headers(h -> h.remove(key));
                    });

            return chain.filter(exchange.mutate()
                    .request(request.mutate().build())
                    .build());
        };
    }

    public static class Config {
        private String suffixes;

        public String getSuffixes() {
            return suffixes;
        }

        public void setSuffixes(String suffixes) {
            this.suffixes = suffixes;
        }
    }
}

import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiDefinition;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiPathPredicateItem;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.GatewayApiDefinitionManager;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayFlowRule;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayRuleManager;
import jakarta.annotation.PostConstruct;
import org.springframework.context.annotation.Configuration;

import java.util.HashSet;
import java.util.Set;

@Configuration
public class GatewaySentinelConfig {

    @PostConstruct
    public void initGatewayRules() {
        // 1. 定义 API 分组
        Set<ApiDefinition> apis = new HashSet<>();
        apis.add(new ApiDefinition("user_api")
                .setPredicateItems(Set.of(
                        new ApiPathPredicateItem().setPattern("/api/user/**")
                )));
        apis.add(new ApiDefinition("order_api")
                .setPredicateItems(Set.of(
                        new ApiPathPredicateItem().setPattern("/api/order/**")
                )));
        GatewayApiDefinitionManager.loadApiDefinitions(apis);

        // 2. 定义网关流控规则
        Set<GatewayFlowRule> rules = new HashSet<>();
        rules.add(new GatewayFlowRule("user_api")
                .setCount(100)                      // QPS 阈值
                .setIntervalSec(1));                // 统计时间窗口（秒）
        rules.add(new GatewayFlowRule("order_api")
                .setCount(50)
                .setIntervalSec(1));
        GatewayRuleManager.loadRules(rules);
    }
}

import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiDefinition;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiPathPredicateItem;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.GatewayApiDefinitionManager;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayFlowRule;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayRuleManager;
import jakarta.annotation.PostConstruct;
import org.springframework.context.annotation.Configuration;

import java.util.HashSet;
import java.util.Set;

@Configuration
public class GatewaySentinelConfig {

    @PostConstruct
    public void initGatewayRules() {
        // 1. 定义 API 分组
        Set<ApiDefinition> apis = new HashSet<>();
        apis.add(new ApiDefinition("user_api")
                .setPredicateItems(Set.of(
                        new ApiPathPredicateItem().setPattern("/api/user/**")
                )));
        apis.add(new ApiDefinition("order_api")
                .setPredicateItems(Set.of(
                        new ApiPathPredicateItem().setPattern("/api/order/**")
                )));
        GatewayApiDefinitionManager.loadApiDefinitions(apis);

        // 2. 定义网关流控规则
        Set<GatewayFlowRule> rules = new HashSet<>();
        rules.add(new GatewayFlowRule("user_api")
                .setCount(100)                      // QPS 阈值
                .setIntervalSec(1));                // 统计时间窗口（秒）
        rules.add(new GatewayFlowRule("order_api")
                .setCount(50)
                .setIntervalSec(1));
        GatewayRuleManager.loadRules(rules);
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.reactive.CorsWebFilter;
import org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource;

@Configuration
public class CorsConfig {

    @Bean
    public CorsWebFilter corsWebFilter() {
        CorsConfiguration config = new CorsConfiguration();
        config.addAllowedOrigin("http://localhost:3000");
        config.addAllowedMethod("*");
        config.addAllowedHeader("*");
        config.setAllowCredentials(true);

        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", config);
        return new CorsWebFilter(source);
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.reactive.CorsWebFilter;
import org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource;

@Configuration
public class CorsConfig {

    @Bean
    public CorsWebFilter corsWebFilter() {
        CorsConfiguration config = new CorsConfiguration();
        config.addAllowedOrigin("http://localhost:3000");
        config.addAllowedMethod("*");
        config.addAllowedHeader("*");
        config.setAllowCredentials(true);

        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", config);
        return new CorsWebFilter(source);
    }
}

import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import reactor.core.publisher.Mono;

@Configuration
public class RateLimiterConfig {

    /**
     * 按请求 IP 限流
     */
    @Bean
    public KeyResolver ipKeyResolver() {
        return exchange -> Mono.just(
                exchange.getRequest().getRemoteAddress().getAddress().getHostAddress()
        );
    }

    /**
     * 按用户 ID 限流（需从 Token 解析）
     */
    @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().getURI().getPath()
        );
    }
}

import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import reactor.core.publisher.Mono;

@Configuration
public class RateLimiterConfig {

    /**
     * 按请求 IP 限流
     */
    @Bean
    public KeyResolver ipKeyResolver() {
        return exchange -> Mono.just(
                exchange.getRequest().getRemoteAddress().getAddress().getHostAddress()
        );
    }

    /**
     * 按用户 ID 限流（需从 Token 解析）
     */
    @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().getURI().getPath()
        );
    }
}

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/user")
public class UserController {

    /**
     * 使用 @SentinelResource 定义资源
     * value: 资源名称（唯一）
     * blockHandler: 流控/熔断触发时的回调（处理 BlockException）
     * fallback: 所有异常的回调（包括业务异常）
     */
    @GetMapping("/{id}")
    @SentinelResource(
            value = "getUserById",
            blockHandler = "getUserByIdBlockHandler",
            fallback = "getUserByIdFallback"
    )
    public User getUserById(@PathVariable Long id) {
        if (id == null || id <= 0) {
            throw new IllegalArgumentException("invalid id");
        }
        // 模拟业务调用
        return new User(id, "name_" + id);
    }

    /**
     * blockHandler 方法签名必须与资源方法一致，末尾增加 BlockException 参数
     */
    public User getUserByIdBlockHandler(Long id, BlockException e) {
        return new User(-1L, "系统繁忙，请稍后再试 [blocked]");
    }

    /**
     * fallback 处理业务异常
     */
    public User getUserByIdFallback(Long id, Throwable t) {
        return new User(-1L, "服务异常：" + t.getMessage());
    }
}

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/user")
public class UserController {

    /**
     * 使用 @SentinelResource 定义资源
     * value: 资源名称（唯一）
     * blockHandler: 流控/熔断触发时的回调（处理 BlockException）
     * fallback: 所有异常的回调（包括业务异常）
     */
    @GetMapping("/{id}")
    @SentinelResource(
            value = "getUserById",
            blockHandler = "getUserByIdBlockHandler",
            fallback = "getUserByIdFallback"
    )
    public User getUserById(@PathVariable Long id) {
        if (id == null || id <= 0) {
            throw new IllegalArgumentException("invalid id");
        }
        // 模拟业务调用
        return new User(id, "name_" + id);
    }

    /**
     * blockHandler 方法签名必须与资源方法一致，末尾增加 BlockException 参数
     */
    public User getUserByIdBlockHandler(Long id, BlockException e) {
        return new User(-1L, "系统繁忙，请稍后再试 [blocked]");
    }

    /**
     * fallback 处理业务异常
     */
    public User getUserByIdFallback(Long id, Throwable t) {
        return new User(-1L, "服务异常：" + t.getMessage());
    }
}

import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import jakarta.annotation.PostConstruct;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

@Component
public class SentinelFlowRuleConfig {

    @PostConstruct
    public void initFlowRules() {
        List<FlowRule> rules = new ArrayList<>();

        FlowRule rule = new FlowRule();
        rule.setResource("getUserById");            // 资源名
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS); // 限流阈值类型：QPS
        rule.setCount(100);                         // 阈值
        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT); // 流控效果：快速失败
        // rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP);   // 预热
        // rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER); // 排队等待

        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }
}

import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import jakarta.annotation.PostConstruct;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

@Component
public class SentinelFlowRuleConfig {

    @PostConstruct
    public void initFlowRules() {
        List<FlowRule> rules = new ArrayList<>();

        FlowRule rule = new FlowRule();
        rule.setResource("getUserById");            // 资源名
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS); // 限流阈值类型：QPS
        rule.setCount(100);                         // 阈值
        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT); // 流控效果：快速失败
        // rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP);   // 预热
        // rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER); // 排队等待

        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }
}