SpringCloud 微服务架构快速入门与实践

SpringCloud 微服务架构快速入门与实践 | 极客日志

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>3.3.4</version> <relativePath/> <!-- lookup parent from repository --> </parent> <modelVersion>4.0.0</modelVersion> <groupId>com.atguigu</groupId> <artifactId>spring-cloud-demo</artifactId> <version>1.0-SNAPSHOT</version> <packaging>pom</packaging> <properties> <maven.compiler.source>17</maven.compiler.source> <maven.compiler.target>17</maven.compiler.target> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <spring-cloud.version>2023.0.3</spring-cloud.version> <spring-cloud-alibaba.version>2023.0.3.2</spring-cloud-alibaba.version> </properties> <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> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-alibaba-dependencies</artifactId> <version>${spring-cloud-alibaba.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> </project>

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

<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies>

server.port=8000 spring.application.name=service-order spring.cloud.nacos.server-addr=127.0.0.1:8848

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

server.port=9000 spring.application.name=service-product spring.cloud.nacos.server-addr=127.0.0.1:8848

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

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

@SpringBootTest public class ProductApplicationTest { @Autowired DiscoveryClient discoveryClient; @Autowired NacosDiscoveryClient nacosDiscoveryClient;//二者效果一样，这个依赖 nacos @Test public void discoveryClientTest(){ List<String> services = discoveryClient.getServices(); for (String service : services) { System.out.println("service = " + service); List<ServiceInstance> instances = discoveryClient.getInstances(service); for (ServiceInstance instance : instances) { System.out.println("instance.getHost() = " + instance.getHost()); System.out.println("instance.getPort() = " + instance.getPort()); } } } @Test public void nacosDiscoveryClientTest(){ List<String> services = nacosDiscoveryClient.getServices(); for (String service : services) { System.out.println("service = " + service); List<ServiceInstance> instances = nacosDiscoveryClient.getInstances(service); for (ServiceInstance instance : instances) { System.out.println("instance.getHost() = " + instance.getHost()); System.out.println("instance.getPort() = " + instance.getPort()); } } } }

<dependencies> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <scope>annotationProcessor</scope> </dependency> </dependencies>

@Data public class Order { private Long id; private BigDecimal totalAmount; private Long userId; private String nickName; private String address; private List<Product> productList; }

@Data public class Product { private Long id; private BigDecimal price; private String productName; private int num; }

<dependency> <groupId>com.atguigu</groupId> <artifactId>model</artifactId> <version>1.0-SNAPSHOT</version> </dependency>

@RestController public class ProductController { @Autowired ProductService productService; @GetMapping(value = "/productId/{id}") public Product getProductById(@PathVariable("id") Long productId) { Product product = productService.getProductById(productId); return product; } }

public interface ProductService { Product getProductById(Long productId); }

@Service public class ProductServiceImpl implements ProductService { @Override public Product getProductById(Long productId) { Product product = new Product(); product.setId(productId); product.setPrice(new BigDecimal("99")); product.setProductName("苹果-" + productId); product.setNum(11); return product; } }

@RestController public class OrderController { @Autowired OrderService orderService; @GetMapping(value = "/create") public Order createOrder(@RequestParam("userId") Long userId, @RequestParam("productId") Long productId) { Order order = orderService.createOrder(userId, productId); return order; } }

public interface OrderService { Order createOrder(Long userId, Long productId); }

@Service public class OrderServiceImpl implements OrderService { @Override public Order createOrder(Long userId, Long productId) { Order order = new Order(); order.setId(1L); //TODO 总金额 order.setTotalAmount(new BigDecimal("0")); order.setUserId(userId); order.setNickName("张三"); order.setAddress("火星"); //TODO 远程查询商品列表 order.setProductList(null); return order; } }

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

@Service @Slf4j public class OrderServiceImpl implements OrderService { @Autowired DiscoveryClient discoveryClient; @Autowired RestTemplate restTemplate; @Override public Order createOrder(Long userId, Long productId) { Product product = getProductFromRemote(productId); Order order = new Order(); order.setId(1L); // 总金额=价格*数量 BigDecimal price = product.getPrice();//价格 int num = product.getNum();//数量 order.setTotalAmount(price.multiply(new BigDecimal(num)));//总价 order.setUserId(userId); order.setNickName("张三"); order.setAddress("火星"); // 远程查询商品列表 order.setProductList(Arrays.asList(product)); return order; } //远程调用获取商品信息 public Product getProductFromRemote(Long productId) { //1、获取到商品服务所在的所有机器 IP+port List<ServiceInstance> instances = discoveryClient.getInstances("service-product"); ServiceInstance instance = instances.get(0); //远程 URL String url = "http://" + instance.getHost() + ":" + instance.getPort() + "/productId/" + productId; log.info("远程请求:{}", url); //2、给远程发送请求 Product product = restTemplate.getForObject(url, Product.class); return product; } }

<!--负载均衡--> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-loadbalancer</artifactId> </dependency>

@SpringBootTest public class OrderApplicationTest { @Autowired LoadBalancerClient loadBalancerClient; @Test public void test() { ServiceInstance choose = loadBalancerClient.choose("service-product"); System.out.println("choose.getHost()+choose.getPort() = " + choose.getHost() + ":" + choose.getPort()); choose = loadBalancerClient.choose("service-product"); System.out.println("choose.getHost()+choose.getPort() = " + choose.getHost() + ":" + choose.getPort()); choose = loadBalancerClient.choose("service-product"); System.out.println("choose.getHost()+choose.getPort() = " + choose.getHost() + ":" + choose.getPort()); choose = loadBalancerClient.choose("service-product"); System.out.println("choose.getHost()+choose.getPort() = " + choose.getHost() + ":" + choose.getPort()); choose = loadBalancerClient.choose("service-product"); System.out.println("choose.getHost()+choose.getPort() = " + choose.getHost() + ":" + choose.getPort()); } }

@Service @Slf4j public class OrderServiceImpl implements OrderService { @Autowired DiscoveryClient discoveryClient; @Autowired RestTemplate restTemplate; @Autowired LoadBalancerClient loadBalancerClient; @Override public Order createOrder(Long userId, Long productId) { // Product product = this.getProductFromRemote(productId); Product product = this.getProductFromRemoteWithLoadBalance(productId); Order order = new Order(); order.setId(1L); // 总金额=价格*数量 BigDecimal price = product.getPrice();//价格 int num = product.getNum();//数量 order.setTotalAmount(price.multiply(new BigDecimal(num)));//总价 order.setUserId(userId); order.setNickName("张三"); order.setAddress("火星"); // 远程查询商品列表 order.setProductList(Arrays.asList(product)); return order; } //阶段二：加入负载均衡 public Product getProductFromRemoteWithLoadBalance(Long productId) { //1、获取到商品服务所在的所有机器 IP+port ServiceInstance choose = loadBalancerClient.choose("service-product"); //远程 URL String url = "http://" + choose.getHost() + ":" + choose.getPort() + "/productId/" + productId; log.info("远程请求:{}", url); //2、给远程发送请求 Product product = restTemplate.getForObject(url, Product.class); return product; } //远程调用获取商品信息 public Product getProductFromRemote(Long productId) { //1、获取到商品服务所在的所有机器 IP+port List<ServiceInstance> instances = discoveryClient.getInstances("service-product"); ServiceInstance instance = instances.get(0); //远程 URL String url = "http://" + instance.getHost() + ":" + instance.getPort() + "/productId/" + productId; log.info("远程请求:{}", url); //2、给远程发送请求 Product product = restTemplate.getForObject(url, Product.class); return product; } }

@Configuration public class OrderConfig { @LoadBalanced //基于注解式的负载均衡 @Bean public RestTemplate restTemplate() { return new RestTemplate(); } }

@RestController public class ProductController { @Autowired ProductService productService; @GetMapping(value = "/productId/{id}") public Product getProductById(@PathVariable("id") Long productId) { System.out.println("正在远程调用 service-product..."); Product product = productService.getProductById(productId); return product; } }

@Service @Slf4j public class OrderServiceImpl implements OrderService { @Autowired DiscoveryClient discoveryClient; @Autowired RestTemplate restTemplate; @Autowired LoadBalancerClient loadBalancerClient; @Override public Order createOrder(Long userId, Long productId) { // Product product = this.getProductFromRemote(productId); // Product product = this.getProductFromRemoteWithLoadBalance(productId); Product product = this.getProductFromRemoteWithLoadBalanceAnnotation(productId); Order order = new Order(); order.setId(1L); // 总金额=价格*数量 BigDecimal price = product.getPrice();//价格 int num = product.getNum();//数量 order.setTotalAmount(price.multiply(new BigDecimal(num)));//总价 order.setUserId(userId); order.setNickName("张三"); order.setAddress("火星"); // 远程查询商品列表 order.setProductList(Arrays.asList(product)); return order; } //阶段三：于注解的负载均衡 public Product getProductFromRemoteWithLoadBalanceAnnotation(Long productId) { //给远程发送请求；；service-product 会被动态替换 String url = "http://service-product/productId/" + productId; Product product = restTemplate.getForObject(url, Product.class); return product; } //阶段二：加入负载均衡 public Product getProductFromRemoteWithLoadBalance(Long productId) { //1、获取到商品服务所在的所有机器 IP+port ServiceInstance choose = loadBalancerClient.choose("service-product"); //远程 URL String url = "http://" + choose.getHost() + ":" + choose.getPort() + "/productId/" + productId; log.info("远程请求:{}", url); //2、给远程发送请求 Product product = restTemplate.getForObject(url, Product.class); return product; } //远程调用获取商品信息 public Product getProductFromRemote(Long productId) { //1、获取到商品服务所在的所有机器 IP+port List<ServiceInstance> instances = discoveryClient.getInstances("service-product"); ServiceInstance instance = instances.get(0); //远程 URL String url = "http://" + instance.getHost() + ":" + instance.getPort() + "/productId/" + productId; log.info("远程请求:{}", url); //2、给远程发送请求 Product product = restTemplate.getForObject(url, Product.class); return product; } }

<!--配置中心--> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId> </dependency>

server.port=8000 spring.application.name=service-order spring.cloud.nacos.server-addr=127.0.0.1:8848 spring.config.import=nacos:service-order.properties #暂未用到配置中心功能，需要关闭配置检查 spring.cloud.nacos.config.import-check.enabled=false

spring.application.name=service-product spring.cloud.nacos.server-addr=127.0.0.1:8848 #暂未用到配置中心功能，需要关闭配置检查 spring.cloud.nacos.config.import-check.enabled=false

@RestController public class OrderController { @Autowired OrderService orderService; @Value("${order.timeout}") String orderTimeout; @Value("${order.auto-confirm}") String orderAutoConfirm; @GetMapping("/config") public String getConfig() { return "OrderTimeout+OrderAutoConfirm = " + orderTimeout+" : " + orderAutoConfirm; } @GetMapping(value = "/create") public Order createOrder(@RequestParam("userId") Long userId, @RequestParam("productId") Long productId) { Order order = orderService.createOrder(userId, productId); return order; } }

@Component @ConfigurationProperties(value = "order")//配置批量绑定在 nacos 下，可以无需@RefreshScope 就能实现自动刷新 @Data public class OrderProperties { String timeout; String autoConfirm; }

//@RefreshScope @RestController public class OrderController { @Autowired OrderService orderService; // @Value("${order.timeout}") // String orderTimeout; // @Value("${order.auto-confirm}") // String orderAutoConfirm; @Autowired OrderProperties orderProperties; @GetMapping("/config") public String getConfig() { return "OrderTimeout+OrderAutoConfirm = " + orderProperties.getTimeout() + " : " + orderProperties.getAutoConfirm(); } @GetMapping(value = "/create") public Order createOrder(@RequestParam("userId") Long userId, @RequestParam("productId") Long productId) { Order order = orderService.createOrder(userId, productId); return order; } }

@SpringBootApplication public class OrderMainApplication { public static void main(String[] args) { SpringApplication.run(OrderMainApplication.class, args); } //1、项目启动就监听配置文件变化 //2、发生变化后拿到变化值 //3、发送邮件 @Bean ApplicationRunner applicationRunner(NacosConfigManager nacosConfigManager) { // return new ApplicationRunner() { // @Override // public void run(ApplicationArguments args) throws Exception { // // } // } return args -> { //这个监听的服务和 application.yml 中 naocs 的配置中心有关 ConfigService configService = nacosConfigManager.getConfigService(); configService.addListener("service-order.properties", "DEFAULT_GROUP", new Listener() { @Override public Executor getExecutor() { return Executors.newFixedThreadPool(4); } @Override public void receiveConfigInfo(String s) { System.out.println("变化的配置信息：" + s); System.out.println("邮件通知...."); } }); System.out.println("========="); }; } }

server:
  port: 8000
spring:
  profiles:
    active: prod
  application:
    name: service-order
  cloud:
    nacos:
      server-addr: 127.0.0.1:8848
      config:
        import-check:
          enabled: false
      namespace: ${spring.profiles.active:public}
---
spring:
  config:
    import:
      - nacos:common.properties?group=order
      - nacos:database.properties?group=order
  activate:
    on-profile: dev
---
spring:
  config:
    import:
      - nacos:common.properties?group=order
      - nacos:database.properties?group=order
      - nacos:haha.properties?group=order
  activate:
    on-profile: test
---
spring:
  config:
    import:
      - nacos:common.properties?group=order
      - nacos:database.properties?group=order
      - nacos:hehe.properties?group=order
  activate:
    on-profile: prod

@Component @ConfigurationProperties(value = "order")//配置批量绑定在 nacos 下，可以无需@RefreshScope 就能实现自动刷新 @Data public class OrderProperties { String timeout; String autoConfirm; String dbUrl; }

//@RefreshScope @RestController public class OrderController { @Autowired OrderService orderService; // @Value("${order.timeout}") // String orderTimeout; // @Value("${order.auto-confirm}") // String orderAutoConfirm; @Autowired OrderProperties orderProperties; @GetMapping("/config") public String getConfig() { return orderProperties.getTimeout() + " : " + orderProperties.getAutoConfirm() + " : " + orderProperties.getDbUrl(); } @GetMapping(value = "/create") public Order createOrder(@RequestParam("userId") Long userId, @RequestParam("productId") Long productId) { Order order = orderService.createOrder(userId, productId); return order; } }

spring.config.import=nacos:service-order.properties,nacos:common.properties #暂未用到配置中心功能，需要关闭配置检查 spring.cloud.nacos.config.import-check.enabled=false

server:
  port: 8000
spring:
  profiles:
    active: dev
  include: feign
  application:
    name: service-order
  cloud:
    nacos:
      server-addr: 127.0.0.1:8848
      config:
        import-check:
          enabled: false
      namespace: ${spring.profiles.active:public}
---
spring:
  config:
    import:
      - nacos:common.properties?group=order
      - nacos:database.properties?group=order
  activate:
    on-profile: dev

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

@FeignClient(value = "service-product") public interface ProductFeignClient { @GetMapping(value = "/productId/{id}") public Product getProductById(@PathVariable("id") Long productId); }

@Autowired ProductFeignClient productFeignClient; Product product = productFeignClient.getProductById(productId);

@FeignClient(value = "weather-client", url = "http://aliv18.data.moji.com") public interface WeatherFeignClient { @PostMapping("/whapi/json/alicityweather/condition") String getWeather(@RequestHeader("Authorization") String auth, @RequestParam("token") String token, @RequestParam("cityId") String cityId); }

@SpringBootTest public class WeatherTest { @Autowired WeatherFeignClient weatherFeignClient; @Test public void test() { String weather = weatherFeignClient.getWeather("自己的 AppCode", "50b53ff8dd7d9fa320d3d3ca32cf8ed1","2182"); System.out.println("weather = " + weather); } }

logging:
  level:
    com.atguigu.order.feign: debug

@Bean Logger.Level feignLoggerLevel() { return Logger.Level.FULL; }

spring:
  cloud:
    openfeign:
      client:
        config:
          default:
            logger-level: full
            connect-timeout: 1000
            read-timeout: 2000
          service-product:
            logger-level: full
            connect-timeout: 3000
            read-timeout: 5000

try { TimeUnit.SECONDS.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); }

@Bean Retryer retryer() { return new Retryer.Default(); }

@Component public class XTokenRequestIntercepter implements RequestInterceptor { @Override public void apply(RequestTemplate requestTemplate) { requestTemplate.header("X-Token", UUID.randomUUID().toString()); } }

@RestController public class ProductController { @Autowired ProductService productService; @GetMapping(value = "/productId/{id}") public Product getProductById(@PathVariable("id") Long productId, HttpServletRequest httpServletRequest) { String XToken = httpServletRequest.getHeader("X-Token"); System.out.println("XToken = " + XToken); System.out.println("正在远程调用 service-product..."); // int i = 10 / 0; Product product = productService.getProductById(productId); return product; } }

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

feign:
  sentinel:
    enabled: true

@FeignClient(value = "service-product", fallback = ProductFeignClientFallback.class) public interface ProductFeignClient { @GetMapping(value = "/productId/{id}") public Product getProductById(@PathVariable("id") Long productId); }

@Component public class ProductFeignClientFallback implements ProductFeignClient { @Override public Product getProductById(Long productId) { System.out.println("兜底回调...."); Product product = new Product(); product.setId(productId); product.setPrice(new BigDecimal("0")); product.setProductName("未知商品"); product.setNum(0); return product; } }

spring.cloud.sentinel.transport.dashboard=localhost:8080
spring.cloud.sentinel.eager=true

@Data public class R { private Integer code; private String msg; private Object data; public static R ok() { R r = new R(); r.setCode(200); return r; } public static R ok(String msg,Object data) { R r = new R(); r.setCode(200); r.setMsg(msg); r.setData(data); return r; } public static R error() { R r = new R(); r.setCode(500); return r; } public static R error(Integer code,String msg) { R r = new R(); r.setCode(code); r.setMsg(msg); return r; } }

@Component public class MyBlockExceptionHandler implements BlockExceptionHandler { private ObjectMapper objectMapper = new ObjectMapper(); @Override public void handle(HttpServletRequest request, HttpServletResponse response, String resourceName, BlockException e) throws Exception { response.setStatus(429); //too many requests response.setContentType("application/json;charset=utf-8"); PrintWriter writer = response.getWriter(); R error = R.error(500, resourceName + " 被 Sentinel 限制了，原因：" + e.getClass()); String json = objectMapper.writeValueAsString(error); writer.write(json); writer.flush(); writer.close(); } }

@Service @Slf4j public class OrderServiceImpl implements OrderService { @Autowired DiscoveryClient discoveryClient; @Autowired RestTemplate restTemplate; @Autowired LoadBalancerClient loadBalancerClient; @Autowired ProductFeignClient productFeignClient; @SentinelResource(value = "createOrder",blockHandler = "createOrderFallback") @Override public Order createOrder(Long userId, Long productId) { // Product product = this.getProductFromRemote(productId); // Product product = this.getProductFromRemoteWithLoadBalance(productId); // Product product = this.getProductFromRemoteWithLoadBalanceAnnotation(productId); Product product = productFeignClient.getProductById(productId); Order order = new Order(); order.setId(1L); // 总金额=价格*数量 BigDecimal price = product.getPrice();//价格 int num = product.getNum();//数量 order.setTotalAmount(price.multiply(new BigDecimal(num)));//总价 order.setUserId(userId); order.setNickName("张三"); order.setAddress("火星"); // 远程查询商品列表 order.setProductList(Arrays.asList(product)); return order; } public Order createOrderFallback(Long userId, Long productId, BlockException e) { Order order = new Order(); order.setId(0L); order.setTotalAmount(new BigDecimal("0")); order.setUserId(userId); order.setNickName("未知用户"); order.setAddress("异常信息" + e.getClass()); return order; } //阶段三：于注解的负载均衡 public Product getProductFromRemoteWithLoadBalanceAnnotation(Long productId) { //给远程发送请求；；service-product 会被动态替换 String url = "http://service-product/productId/" + productId; Product product = restTemplate.getForObject(url, Product.class); return product; } }

@GetMapping("/writeDb") public String writeDb() { return "writeDb success..."; }
@GetMapping("/readDb") public String readDb() { log.info("readDb success..."); return "readDb success..."; }

@GetMapping("/seckill") public Order seckill(@RequestParam("userId") Long userId, @RequestParam("productId") Long productId) { Order order = orderService.createOrder(userId, productId); order.setId(Long.MAX_VALUE); return order; }

@GetMapping("/seckill") @SentinelResource(value = "seckill-order",fallback = "seckillFallback") //此处用于测试热点规则 // public Order seckill(@RequestParam("userId") Long userId, // @RequestParam("productId") Long productId) { //此处模拟不传参数，给默认参数 // public Order seckill(@RequestParam(value = "userId",defaultValue = "888") Long userId, // @RequestParam(value = "productId",defaultValue = "1000") Long productId) { public Order seckill(@RequestParam(value = "userId",required = false) Long userId, @RequestParam(value = "productId",required = false) Long productId) { Order order = orderService.createOrder(userId, productId); order.setId(Long.MAX_VALUE); return order; } public Order seckillFallback(Long userId, Long productId, Throwable exception) { System.out.println("seckillFallback..."); Order order = new Order(); order.setId(productId); order.setUserId(userId); order.setAddress("seckillFallback 异常信息" + exception.getClass()); return order; }

<dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-gateway</artifactId> </dependency> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-loadbalancer</artifactId> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <scope>annotationProcessor</scope> </dependency> </dependencies>

spring:
  application:
    name: gateway
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    profiles:
      include: route
server:
  port: 80

spring:
  cloud:
    gateway:
      routes:
        - id: order
          uri: lb://service-order
          predicates:
            - Path=/api/order/**
        - id: product
          uri: lb://service-product
          predicates:
            - Path=/api/product/**

spring:
  cloud:
    gateway:
      globalcors:
        cors-configurations:
          '[/**]':
            allowedOriginPatterns: '*'
            allowedHeaders: '*'
            allowedMethods: '*'
      default-filters:
        - AddResponseHeader=X-Response-Abc,123
      routes:
        - id: bing
          uri: https://cn.bing.com/
          predicates:
            - name: Path
              args:
                patterns: /search
            - name: Query
              args:
                param: q
                regexp: haha
            # - Vip=user,lei
            - name: Vip
              args:
                param: user
                value: lei
          order: 10
        - id: order-route
          uri: lb://service-order
          predicates:
            - name: Path
              args:
                patterns: /api/order/**
              matchTrailingSlash: true
          filters:
            - RewritePath=/api/order/?(?<segment>.*), /$\{segment}
            - OnceToken=X-Response-Token,jwt
          order: 1
        - id: product-route
          uri: lb://service-product
          predicates:
            - Path=/api/product/**
          filters:
            - RewritePath=/api/product/?(?<segment>.*), /$\{segment}
          order: 2

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

spring:
  cloud:
    gateway:
      routes:
        - id: order
          uri: lb://service-order
          predicates:
            - Path=/api/order/**
        - id: product
          uri: lb://service-product
          predicates:
            - Path=/api/product/**

@Component public class VipRoutePredicateFactory extends AbstractRoutePredicateFactory<VipRoutePredicateFactory.Config> { public VipRoutePredicateFactory() { super(Config.class); } //段格式传参顺序 @Override public List<String> shortcutFieldOrder() { return Arrays.asList("param", "value"); } @Override public Predicate<ServerWebExchange> apply(Config config) { return new GatewayPredicate() { @Override public boolean test(ServerWebExchange serverWebExchange) { // localhost/search?q=haha&user=leifengyang ServerHttpRequest request = serverWebExchange.getRequest(); String first = request.getQueryParams().getFirst(config.param); return StringUtils.hasText(first) && first.equals(config.value); } }; } @Validated public static class Config { @NotEmpty private String param; @NotEmpty private String value; public @NotEmpty String getParam() { return param; } public void setParam(@NotEmpty String param) { this.param = param; } public @NotEmpty String getValue() { return value; } public void setValue(@NotEmpty String value) { this.value = value; } } }

@Component public class OnceTokenGatewayFilterFactory extends AbstractNameValueGatewayFilterFactory { @Override public GatewayFilter apply(NameValueConfig config) { return new GatewayFilter() { @Override public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { return chain.filter(exchange).then(Mono.fromRunnable(()->{ //注意这里是 response ServerHttpResponse response = exchange.getResponse(); HttpHeaders headers = response.getHeaders(); String value = config.getValue(); if ("uuid".equalsIgnoreCase(value)) { value = UUID.randomUUID().toString(); } if ("jwt".equalsIgnoreCase(value)) { value = "JWT"; } headers.add(config.getName(), value); })); } }; }

spring:
  cloud:
    gateway:
      globalcors:
        cors-configurations:
          '[/**]':
            allowedOriginPatterns: '*'
            allowedHeaders: '*'
            allowedMethods: '*'

/* * 此实例作用：GlobalFilter 通常，全局过滤器在网关层 用于 拦截所有请求， * 而局部过滤器（GatewayFilter）用于 单个路由。 * 案例：请求耗时=请求结束时间 - 请求进来时间 * */ @Component @Slf4j public class RTGlobalFilter implements GlobalFilter, Ordered { @Override public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { ServerHttpRequest request = exchange.getRequest(); ServerHttpResponse response = exchange.getResponse(); String uri = request.getURI().toString(); long startTime = System.currentTimeMillis(); log.info("请求【{}】开始，时间{}", uri, startTime); //=============上面是前置逻辑================== Mono<Void> filter = chain.filter(exchange).doFinally(r -> { long endTime = System.currentTimeMillis(); log.info("请求【{}】结束，时间{}，耗时：{}ms", uri, endTime, endTime - startTime); }); return filter; } @Override public int getOrder() { return 0; } }

CREATE DATABASE IF NOT EXISTS `storage_db`;
USE `storage_db`;
DROP TABLE IF EXISTS `storage_tbl`;
CREATE TABLE `storage_tbl` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `commodity_code` varchar(255) DEFAULT NULL,
  `count` int(11) DEFAULT 0,
  PRIMARY KEY (`id`),
  UNIQUE KEY (`commodity_code`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
INSERT INTO storage_tbl (commodity_code, count) VALUES ('P0001', 100);
INSERT INTO storage_tbl (commodity_code, count) VALUES ('B1234', 10);
-- 注意此处 0.3.0+ 增加唯一索引 ux_undo_log
DROP TABLE IF EXISTS `undo_log`;
CREATE TABLE `undo_log` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `branch_id` bigint(20) NOT NULL,
  `xid` varchar(100) NOT NULL,
  `context` varchar(128) NOT NULL,
  `rollback_info` longblob NOT NULL,
  `log_status` int(11) NOT NULL,
  `log_created` datetime NOT NULL,
  `log_modified` datetime NOT NULL,
  `ext` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
CREATE DATABASE IF NOT EXISTS `order_db`;
USE `order_db`;
DROP TABLE IF EXISTS `order_tbl`;
CREATE TABLE `order_tbl` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_id` varchar(255) DEFAULT NULL,
  `commodity_code` varchar(255) DEFAULT NULL,
  `count` int(11) DEFAULT 0,
  `money` int(11) DEFAULT 0,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- 注意此处 0.3.0+ 增加唯一索引 ux_undo_log
DROP TABLE IF EXISTS `undo_log`;
CREATE TABLE `undo_log` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `branch_id` bigint(20) NOT NULL,
  `xid` varchar(100) NOT NULL,
  `context` varchar(128) NOT NULL,
  `rollback_info` longblob NOT NULL,
  `log_status` int(11) NOT NULL,
  `log_created` datetime NOT NULL,
  `log_modified` datetime NOT NULL,
  `ext` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
CREATE DATABASE IF NOT EXISTS `account_db`;
USE `account_db`;
DROP TABLE IF EXISTS `account_tbl`;
CREATE TABLE `account_tbl` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_id` varchar(255) DEFAULT NULL,
  `money` int(11) DEFAULT 0,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
INSERT INTO account_tbl (user_id, money) VALUES ('1', 10000);
-- 注意此处 0.3.0+ 增加唯一索引 ux_undo_log
DROP TABLE IF EXISTS `undo_log`;
CREATE TABLE `undo_log` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `branch_id` bigint(20) NOT NULL,
  `xid` varchar(100) NOT NULL,
  `context` varchar(128) NOT NULL,
  `rollback_info` longblob NOT NULL,
  `log_status` int(11) NOT NULL,
  `log_created` datetime NOT NULL,
  `log_modified` datetime NOT NULL,
  `ext` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

service {
  #transaction service group mapping
  vgroupMapping.default_tx_group = "default"
  #only support when registry.type=file, please don't set multiple addresses
  default.grouplist = "127.0.0.1:8091"
  #degrade, current not support
  enableDegrade = false
  #disable seata
  disableGlobalTransaction = false
}

架构演进	单体架构	集群架构	分布式架构
定义	所有功能模块都在一个项目里	单体的多服务器版本	一个大型应用被拆分成很多小应用分布部署在各个机器；
优点	开发部署简单	解决大并发	解决了单体 + 集群的问题
缺点	无法应对高并发	问题 1：模块块升级麻烦问题 2：多语言团队交互不通

名	参数（个数/类型）	作用
After	1/datetime	在指定时间之后
Before	1/datetime	在指定时间之前
Between	2/datetime	在指定时间区间内
Cookie	2/string,regexp	包含 cookie 名且必须匹配指定值
Header	2/string,regexp	包含请求头且必须匹配指定值
Host	N/string	请求 host 必须是指定枚举值
Method	N/string	请求方式必须是指定枚举值
Path	2/List<String>,bool	请求路径满足规则，是否匹配最后的/
Query	2/string,regexp	包含指定请求参数
RemoteAddr	1/List<String>	请求来源于指定网络域 (CIDR 写法)
Weight	2/string,int	按指定权重负载均衡
XForwardedRemoteAddr	1/List<string>	从 X-Forwarded-For 请求头中解析请求来源，并判断是否来源于指定网络域

名	参数（个数/类型）	作用
AddRequestHeader	2/string	添加请求头
AddRequestHeadersIfNotPresent	1/List	如果没有则添加请求头，key:value 方式
AddRequestParameter	2/string、string	添加请求参数
AddResponseHeader	2/string、string	添加响应头
CircuitBreaker	1/string	仅支持 forward:/inCaseOfFailureUseThis 方式进行熔断
CacheRequestBody	1/string	缓存请求体
DedupeResponseHeader	1/string	移除重复响应头，多个用空格分割
FallbackHeaders	1/string	设置 Fallback 头
JsonToGrpc		请求体 Json 转为 gRPC
LocalResponseCache	2/string	响应数据本地缓存
MapRequestHeader	2/string	把某个请求头名字变为另一个名字
ModifyRequestBody	仅 Java 代码方式	修改请求体
ModifyResponseBody	仅 Java 代码方式	修改响应体
PrefixPath	1/string	自动添加请求前缀路径
PreserveHostHeader	0	保护 Host 头
RedirectTo	3/string	重定向到指定位置
RemoveJsonAttributesResponseBody	1/string	移除响应体中的某些 Json 字段，多个用，分割
RemoveRequestHeader	1/string	移除请求头
RemoveRequestParameter	1/string	移除请求参数
RemoveResponseHeader	1/string	移除响应头
RequestHeaderSize	2/string	设置请求大小，超出则响应 431 状态码
RequestRateLimiter	1/string	请求限流
RewriteLocationResponseHeader	4/string	重写 Location 响应头
RewritePath	2/string	路径重写
RewriteRequestParameter	2/string	请求参数重写
RewriteResponseHeader	3/string	响应头重写
SaveSession	0	session 保存，配合 spring-session 框架
SecureHeaders	0	安全头设置
SetPath	1/string	路径修改
SetRequestHeader	2/string	请求头修改
SetResponseHeader	2/string	响应头修改
SetStatus	1/int	设置响应状态码
StripPrefix	1/int	路径层级拆除
Retry	7/string	请求重试设置
RequestSize	1/string	请求大小限定
SetRequestHostHeader	1/string	设置 Host 请求头
TokenRelay	1/string	OAuth2 的 token 转发

SpringCloud 微服务架构快速入门与实践

springcloud 简介

前期准备

建 springcloud-demo 项目

导依赖

建 services 模块

导入依赖

建 service-order/product 模块

nacos - 注册/配置中心

基础入门

注册中心

服务注册

service-order 模块

service-product 模块

启动集群

服务发现

远程调用

新建 model 模块

回到 service 业务类

service-product

service-order

完善业务类中远程调用

service-order

负载均衡

1.使用 loadBalancerClient

2.使用@LoadBalanced 注解

思考：注册中心宕机，远程调用还能成功吗？

小结

配置中心

整合配置

services 导入依赖

service-order 的配置文件 application.properties

在 nacos 服务端进行配置

自动刷新

1. @Value("${xx}") 获取配置 + @RefreshScope 实现自动刷新

2. @ConfigurationProperties 无感自动刷新

3.NacosConfigManager 监听配置变化

思考：Nacos 中的数据集 和 application.properties 有相同的 配置项，哪个生效？

数据隔离

设置 application.yml

代码层面

测试效果

小节

openFeign

基础使用

services 中导依赖

启动类加注解

编写 FeignClient 接口

改造 service-order OrderServiceImpl

远程调用外部 API

进阶配置

开启日志

超时控制

重试机制

拦截器

全局拦截器——拦截所有远程调用请求

局部拦截器

fallback - 兜底返回

小节

sentinel

环境搭建

下载 sentinel dashboard

启动：

配置连接 + 热加载（服务启动就加载）

说明：

异常处理

Web 接口 出现异常

model 模块写异常类

实现 BlockExceptionHandler 接口

配置流控规则

效果

@SentinelResource 出现异常

在目标方法加@SentinelResource 注解

编写 blockHandler 方法或者 fallback 方法处理异常

测试

OpenFeign 调用 出现异常

SphU 硬编码 出现异常

规则 - 流量控制

阈值类型

集群

思考：Nacos 中的数据集和 application.properties 有相同的配置项，哪个生效？

Web 接口出现异常

OpenFeign 调用出现异常

SphU 硬编码出现异常