SpringCloud学习笔记（1）- Spring Cloud Alibaba

落日映苍穹つ 2022-09-10 13:20 321阅读 0赞

文章目录

  • SpringCloud学习笔记（1）- Spring Cloud Alibaba
  • 服务治理
    • Nacos 服务注册
    • Nacos 服务发现与调用
    • Ribbon 负载均衡
    • Sentinel 服务限流降级
      • 流控规则
      • 流控效果
      • 降级规则
      • 热点规则
      • 授权规则
      • 自定义规则异常返回
    • 整合 RocketMQ
      • 安装 RocketMQ
      • 安装 RocketMQ 控制台
      • Java 实现消息发送
      • Java 实现消息消费
    • Spring Boot 整合 RocketMQ
    • 服务网关
      • Gateway 限流
    • 分布式事务
      • 模拟分布式事务异常
      • Seata 解决（事务回滚）

SpringCloud学习笔记（1）- Spring Cloud Alibaba

创建父工程

Spring Cloud Alibaba 的环境在父工程中创建，微服务的各个组件作为子工程，继承父工程的环境。

Spring Boot —》Spring Cloud —》Spring Cloud Alibaba

pom.xml 中添加。

  1. <dependencyManagement>
  2.     <dependencies>
  3.         <!-- Spring Cloud Hoxton -->
  4.         <dependency>
  5.             <groupId>org.springframework.cloud</groupId>
  6.             <artifactId>spring-cloud-dependencies</artifactId>
  7.             <version>Hoxton.SR3</version>
  8.             <type>pom</type>
  9.             <scope>import</scope>
  10.         </dependency>
  11.         <!-- Spring Cloud Alibaba -->
  12.         <dependency>
  13.             <groupId>com.alibaba.cloud</groupId>
  14.             <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  15.             <version>2.2.1.RELEASE</version>
  16.             <type>pom</type>
  17.             <scope>import</scope>
  18.         </dependency>
  19.     </dependencies>
  20. </dependencyManagement>

服务治理

服务注册 + 服务发现

Nacos 服务注册

解压，启动服务。

Nacos 搭建成功，接下来注册服务。

在父工程路径下创建子工程，让子工程继承父工程的环境依赖，pom.xml 中添加 nacos 发现组件。

  1. <dependency>
  2.     <groupId>com.alibaba.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  4. </dependency>

application.yml 中配置

  1. spring:
  2.   cloud:
  3.     nacos:
  4.       discovery:
  5.         # 指定nacos server地址
  6.         server-addr: localhost:8848
  7.   application:
  8.     name: my-nacos

Nacos 服务发现与调用

pom.xml 添加 discovery，完成服务发现。

  1. <dependency>
  2.     <groupId>com.alibaba.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  4. </dependency>

通过 discoveryClient 发现注册到 nacos 中的 provider 服务。

  1. @RestController
  2. public class ConsumerController { 
  4.     @Autowired
  5.     private DiscoveryClient discoveryClient;
  7.     @GetMapping("/instances")
  8.     public List<ServiceInstance> instances(){ 
  9.         List<ServiceInstance> provider = discoveryClient.getInstances("provider");
  10.         return provider;
  11.     }
  13. }
  15. @Configuration
  16. public class ConsumerConfig { 
  18.     @Bean
  19.     public RestTemplate restTemplate(){ 
  20.         return new RestTemplate();
  21.     }
  23. }
  25. @RestController
  26. public class ConsumerController { 
  28.     @Autowired
  29.     private DiscoveryClient discoveryClient;
  30.     @Autowired
  31.     private RestTemplate restTemplate;
  33.     @GetMapping("/index")
  34.     public String index(){ 
  35.         List<ServiceInstance> provider = discoveryClient.getInstances("provider");
  36.         int index = ThreadLocalRandom.current().nextInt(provider.size());
  37.         String url = provider.get(index).getUri()+"/index";
  38.         return "consumer随机远程调用provier："+this.restTemplate.getForObject(url, String.class);
  39.     }
  41. }

在这里插入图片描述

Ribbon 负载均衡

  1. @Configuration
  2. public class ConsumerConfig { 
  4.     @Bean
  5.     @LoadBalanced
  6.     public RestTemplate restTemplate(){ 
  7.         return new RestTemplate();
  8.     }
  10. }
  12. @RestController
  13. public class ConsumerController { 
  15.     @Autowired
  16.     private RestTemplate restTemplate;
  18.     @GetMapping("/index")
  19.     public String index(){ 
  20.         return "consumer远程调用provier："+this.restTemplate.getForObject("http://provider/index", String.class);
  21.     }
  23. }

随机 （随机的算法）

  1. server:
  2.   port: 8180
  3. provider:
  4.   ribbon:
  5.     NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

Nacos 权重 （基于权重的算法）

  1. @Slf4j
  2. public class NacosWeightedRule extends AbstractLoadBalancerRule { 
  4.     @Autowired
  5.     private NacosDiscoveryProperties nacosDiscoveryProperties;
  7.     @Override
  8.     public void initWithNiwsConfig(IClientConfig iClientConfig) { 
  9.         //读取配置文件
  10.     }
  12.     @Override
  13.     public Server choose(Object o) { 
  14.         ILoadBalancer loadBalancer = this.getLoadBalancer();
  15.         BaseLoadBalancer baseLoadBalancer = (BaseLoadBalancer) loadBalancer;
  16.         //获取要请求的微服务名称
  17.         String name = baseLoadBalancer.getName();
  18.         //获取服务发现的相关API
  19.         NamingService namingService = nacosDiscoveryProperties.namingServiceInstance();
  20.         try { 
  21.             Instance instance = namingService.selectOneHealthyInstance(name);
  22.             log.info("选择的实例是port={},instance={}",instance.getPort(),instance);
  23.             return new NacosServer(instance);
  24.         } catch (NacosException e) { 
  25.             e.printStackTrace();
  26.             return null;
  27.         }
  28.     }
  29. }
  31. server:
  32.   port: 8180
  33. provider:
  34.   ribbon:
  35.     NFLoadBalancerRuleClassName: com.southwind.configuration.NacosWeightedRule

Sentinel 服务限流降级

雪崩效应
在这里插入图片描述
解决方案

1、设置线程超时

2、设置限流

3、熔断器 Sentinel、Hystrix （类比保险丝）

  • 降级
  • 限流
  • 熔断

在这里插入图片描述
1、provider模块pom.xml 引入依赖

  1. <dependency>
  2.     <groupId>com.alibaba.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
  4. </dependency>
  6. <dependency>
  7.     <groupId>org.springframework.boot</groupId>
  8.     <artifactId>spring-boot-starter-actuator</artifactId>
  9. </dependency>

2、application 配置

  1. management:
  2.   endpoints:
  3.     web:
  4.       exposure:
  5.         include: '*'
  6. spring:
  7.   cloud:
  8.     sentinel:
  9.       transport:
  10.         dashboard: localhost:8080

3、下载 Sentinel 控制台，解压，启动。

流控规则

在这里插入图片描述

直接限流

关联限流

链路限流

1、pom.xml 添加依赖

  1. <dependency>
  2.     <groupId>com.alibaba.csp</groupId>
  3.     <artifactId>sentinel-core</artifactId>
  4.     <version>1.7.1</version>
  5. </dependency>
  7. <dependency>
  8.     <groupId>com.alibaba.csp</groupId>
  9.     <artifactId>sentinel-web-servlet</artifactId>
  10.     <version>1.7.1</version>
  11. </dependency>

2、application.yml

  1. spring:
  2.     cloud:
  3.         sentinel:
  4.           filter:
  5.             enabled: false

3、写配置类（让能关联到Service）

  1. package com.southwind.configuration;
  3. import com.alibaba.csp.sentinel.adapter.servlet.CommonFilter;
  4. import org.springframework.boot.web.servlet.FilterRegistrationBean;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  8. @Configuration
  9. public class FilterConfiguration { 
  11.     @Bean
  12.     public FilterRegistrationBean registrationBean(){ 
  13.         FilterRegistrationBean registrationBean = new FilterRegistrationBean();
  14.         registrationBean.setFilter(new CommonFilter());
  15.         registrationBean.addUrlPatterns("/*");
  16.         registrationBean.addInitParameter(CommonFilter.WEB_CONTEXT_UNIFY,"false");  //让所有链路开放出来才能限制
  17.         registrationBean.setName("sentinelFilter");
  18.         return registrationBean;
  19.     }
  20. }

4、Service

  1. @Service
  2. public class HelloService { 
  4.     @SentinelResource("test")
  5.     public void test(){ 
  6.         System.out.println("test");
  7.     }
  8. }

5、Controller

  1. @GetMapping("/test1")
  2. public String test1(){ 
  3.     this.helloService.test();
  4.     return "test1";
  5. }
  7. @GetMapping("/test2")
  8. public String test2(){ 
  9.     this.helloService.test();
  10.     return "test2";
  11. }

流控效果

快速失败

直接抛出异常

Warm UP

给系统一个预热的时间，预热时间段内单机阈值较低，预热时间过后单机阈值增加，预热时间内当前的单机阈值是设置的阈值的三分之一，预热时间过后单机阈值恢复设置的值。

排队等待

当请求调用失败之后，不会立即抛出异常，等待下一次调用，时间范围是超时时间，在时间范围内如果能请求成功则不抛出异常，如果请求则抛出异常。

降级规则

RT

单个请求的响应时间超过阈值，则进入准降级状态，接下来 1 S 内连续 5 个请求响应时间均超过阈值，就进行降级，持续时间为时间窗口的值。

异常比例

每秒异常数量占通过量的比例大于阈值，就进行降级处理，持续时间为时间窗口的值。

异常数

1 分钟内的异常数超过阈值就进行降级处理，时间窗口的值要大于 60S，否则刚结束熔断又进入下一次熔断了。

热点规则

热点规则是流控规则的更细粒度操作，可以具体到对某个热点参数的限流，设置限流之后，如果带着限流参数的请求量超过阈值，则进行限流，时间为统计窗口时长。

必须要添加 @SentinelResource，即对资源进行流控。

  1. @GetMapping("/hot")
  2. @SentinelResource("hot")
  3. public String hot(
  4.         @RequestParam(value = "num1",required = false) Integer num1,
  5.         @RequestParam(value = "num2",required = false) Integer num2){ 
  6.     return num1+"-"+num2;
  7. }

授权规则

给指定的资源设置流控应用（追加参数），可以对流控应用进行访问权限的设置，具体就是添加白名单和黑名单。

如何给请求指定流控应用，通过实现 RequestOriginParser 接口来完成，代码如下所示。

  1. package com.southwind.configuration;
  3. import com.alibaba.csp.sentinel.adapter.servlet.callback.RequestOriginParser;
  4. import org.springframework.util.StringUtils;
  6. import javax.servlet.http.HttpServletRequest;
  8. public class RequestOriginParserDefinition implements RequestOriginParser { 
  9.     @Override
  10.     public String parseOrigin(HttpServletRequest httpServletRequest) { 
  11.         String name = httpServletRequest.getParameter("name");
  12.         if(StringUtils.isEmpty(name)){ 
  13.             throw new RuntimeException("name is null");
  14.         }
  15.         return name;
  16.     }
  17. }

要让 RequestOriginParserDefinition 生效，需要在配置类中进行配置。

  1. package com.southwind.configuration;
  3. import com.alibaba.csp.sentinel.adapter.servlet.callback.WebCallbackManager;
  4. import org.springframework.context.annotation.Configuration;
  6. import javax.annotation.PostConstruct;
  8. @Configuration
  9. public class SentinelConfiguration { 
  11.     @PostConstruct
  12.     public void init(){ 
  13.         WebCallbackManager.setRequestOriginParser(new RequestOriginParserDefinition());
  14.     }
  15. }

自定义规则异常返回

创建异常处理类

  1. package com.southwind.handler;
  3. import com.alibaba.csp.sentinel.adapter.servlet.callback.UrlBlockHandler;
  4. import com.alibaba.csp.sentinel.slots.block.BlockException;
  5. import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
  6. import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
  8. import javax.servlet.http.HttpServletRequest;
  9. import javax.servlet.http.HttpServletResponse;
  10. import java.io.IOException;
  12. public class ExceptionHandler implements UrlBlockHandler { 
  13.     @Override
  14.     public void blocked(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, BlockException e) throws IOException { 
  15.         httpServletResponse.setContentType("text/html;charset=utf-8");
  16.         String msg = null;
  17.         if(e instanceof FlowException){ 
  18.             msg = "限流";
  19.         }else if(e instanceof DegradeException){ 
  20.             msg = "降级";
  21.         }
  22.         httpServletResponse.getWriter().write(msg);
  23.     }
  24. }

进行配置。

  1. @Configuration
  2. public class SentinelConfiguration { 
  4.     @PostConstruct
  5.     public void init(){ 
  6.         WebCallbackManager.setUrlBlockHandler(new ExceptionHandler());
  7.     }
  8. }

整合 RocketMQ

安装 RocketMQ

1、传入 Linux 服务器

2、解压缩

  1. unzip rocketmq-all-4.7.1-bin-release.zip

3、启动 NameServer

  1. nohup ./bin/mqnamesrv &

4、检查是否启动成功

  1. netstat -an | grep 9876

在这里插入图片描述
5、启动 Broker

启动之前需要编辑配置文件，修改 JVM 内存设置，默认给的内存 4 GB，超过我们的 JVM 了。

  1. cd bin
  2. vim runserver.sh

在这里插入图片描述

  1. vim runbroker.sh

在这里插入图片描述
启动 Broker

  1. nohup ./mqbroker -n localhost:9876 &

可以查看日志

  1. tail -f ~/logs/rocketmqlogs/broker.log

在这里插入图片描述
启动成功

6、测试 RocketMQ

消息发送

  1. cd bin
  2. export NAMESRV_ADDR=localhost:9876
  3. ./tools.sh org.apache.rocketmq.example.quickstart.Producer

消息接收

  1. cd bin
  2. export NAMESRV_ADDR=localhost:9876
  3. ./tools.sh org.apache.rocketmq.example.quickstart.Consumer

7、关闭 RocketMQ

  1. cd bin
  2. ./mqshutdown broker
  3. ./mqshutdown namesrv

安装 RocketMQ 控制台

1、解压缩，修改配置，打包

在这里插入图片描述

  1. mvn clean package -Dmaven.test.skip=true

在这里插入图片描述
2、进入 target 启动 jar

  1. java -jar rocketmq-console-ng-1.0.0.jar

在这里插入图片描述
打开浏览器访问 localhost:9877，如果报错如下：
在这里插入图片描述
这是因为我们的 RocketMQ 安装在 Linux 中，控制台在 windows，Linux 需要开放端口才能访问，开放 10909 和 9876 端口

  1. firewall-cmd --zone=public --add-port=10909/tcp --permanent
  2. firewall-cmd --zone=public --add-port=9876/tcp --permanent
  3. systemctl restart firewalld.service
  4. firewall-cmd --reload

重新启动控制台项目

在这里插入图片描述

Java 实现消息发送

1、pom.xml 中引入依赖

  1. <dependency>
  2.     <groupId>org.apache.rocketmq</groupId>
  3.     <artifactId>rocketmq-spring-boot-starter</artifactId>
  4.     <version>2.1.0</version>
  5. </dependency>

2、生产消息

  1. package com.southwind;
  3. import org.apache.rocketmq.client.producer.DefaultMQProducer;
  4. import org.apache.rocketmq.client.producer.SendResult;
  5. import org.apache.rocketmq.common.message.Message;
  7. public class Test { 
  8.     public static void main(String[] args) throws Exception { 
  9.         //创建消息生产者
  10.         DefaultMQProducer producer = new DefaultMQProducer("myproducer-group");
  11.         //设置NameServer
  12.         producer.setNamesrvAddr("192.168.248.129:9876");
  13.         //启动生产者
  14.         producer.start();
  15.         //构建消息对象
  16.         Message message = new Message("myTopic","myTag",("Test MQ").getBytes());
  17.         //发送消息
  18.         SendResult result = producer.send(message, 1000);
  19.         System.out.println(result);
  20.         //关闭生产者
  21.         producer.shutdown();
  22.     }
  23. }

3、直接运行，如果报错 sendDefaultImpl call timeout，可以开放 10911 端口

  1. firewall-cmd --zone=public --add-port=10911/tcp --permanent
  2. systemctl restart firewalld.service
  3. firewall-cmd --reload

打开 RocketMQ 控制台，可查看消息。

Java 实现消息消费

  1. package com.southwind.service;
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
  5. import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
  6. import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
  7. import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
  8. import org.apache.rocketmq.client.exception.MQClientException;
  9. import org.apache.rocketmq.common.message.MessageExt;
  11. import java.util.List;
  13. @Slf4j
  14. public class ConsumerTest { 
  15.     public static void main(String[] args) throws MQClientException { 
  16.         //创建消息消费者
  17.         DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("myconsumer-group");
  18.         //设置NameServer
  19.         consumer.setNamesrvAddr("192.168.248.129:9876");
  20.         //指定订阅的主题和标签
  21.         consumer.subscribe("myTopic","*");
  22.         //回调函数
  23.         consumer.registerMessageListener(new MessageListenerConcurrently() { 
  24.             @Override
  25.             public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) { 
  26.                 log.info("Message=>{}",list);
  27.                 return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
  28.             }
  29.         });
  30.         //启动消费者
  31.         consumer.start();
  32.     }
  33. }

Spring Boot 整合 RocketMQ

provider

1、pom.xml

  1. <dependency>
  2.     <groupId>org.apache.rocketmq</groupId>
  3.     <artifactId>rocketmq-spring-boot-starter</artifactId>
  4.     <version>2.1.0</version>
  5. </dependency>
  6. <dependency>
  7.     <groupId>org.apache.rocketmq</groupId>
  8.     <artifactId>rocketmq-client</artifactId>
  9.     <version>4.7.0</version>
  10. </dependency>

2、application.yml

  1. rocketmq:
  2.   name-server: 192.168.248.129:9876
  3.   producer:
  4.     group: myprovider

3、Order

  1. package com.southwind.entity;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  7. import java.util.Date;
  9. @Data
  10. @AllArgsConstructor
  11. @NoArgsConstructor
  12. public class Order { 
  13.     private Integer id;
  14.     private String buyerName;
  15.     private String buyerTel;
  16.     private String address;
  17.     private Date createDate;
  18. }

4、Controller

  1. @Autowired
  2. private RocketMQTemplate rocketMQTemplate;
  4. @GetMapping("/create")
  5. public Order create(){ 
  6.     Order order = new Order(
  7.         1,
  8.         "张三",
  9.         "123123",
  10.         "软件园",
  11.         new Date()
  12.     );
  13.     this.rocketMQTemplate.convertAndSend("myTopic",order);
  14.     return order;
  15. }

consumer

1、pom.xml

  1. <dependency>
  2.     <groupId>org.apache.rocketmq</groupId>
  3.     <artifactId>rocketmq-spring-boot-starter</artifactId>
  4.     <version>2.1.0</version>
  5. </dependency>
  6. <dependency>
  7.     <groupId>org.apache.rocketmq</groupId>
  8.     <artifactId>rocketmq-client</artifactId>
  9.     <version>4.7.0</version>
  10. </dependency>

2、application.yml

  1. rocketmq:
  2.   name-server: 192.168.248.129:9876

3、Service

  1. @Slf4j
  2. @Service
  3. @RocketMQMessageListener(consumerGroup = "myConsumer",topic = "myTopic")
  4. public class SmsService implements RocketMQListener<Order> { 
  5.     @Override
  6.     public void onMessage(Order order) { 
  7.         log.info("新订单{},发短信",order);
  8.     }
  9. }

服务网关

Spring Cloud Gateway 是基于 Netty，跟 Servlet 不兼容，所以你的工程中不能出现 Servlet 的组件 。

1、pom.xml

注意，一定不能出现 spring web 的依赖，因为 Gateway 与 Servlet 不兼容。

  1. <dependency>
  2.     <groupId>org.springframework.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-gateway</artifactId>
  4. </dependency>

2、application.yml

  1. server:
  2.   port: 8010
  3. spring:
  4.   application:
  5.     name: gateway
  6.   cloud:
  7.     gateway:
  8.       discovery:
  9.         locator:
  10.           enabled: true
  11.       routes: 
  12.         - id: provider_route   
  13.           uri: http://localhost:8081 
  14.           predicates: 
  15.             - Path=/provider/** 
  16.           filters:
  17.             - StripPrefix=1

上面这种做法其实没有用到 nacos ，现在我们让 gateway 直接去 nacos 中发现服务，配置更加简单了。

1、pom.xml 引入 nacos

  1. <dependency>
  2.     <groupId>org.springframework.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-gateway</artifactId>
  4. </dependency>
  6. <dependency>
  7.     <groupId>com.alibaba.cloud</groupId>
  8.     <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  9. </dependency>

2、application.yml

  1. server:
  2.   port: 8010
  3. spring:
  4.   application:
  5.     name: gateway
  6.   cloud:
  7.       gateway:
  8.         discovery:
  9.           locator:
  10.             enabled: true

Gateway 限流

基于路由限流

1、pom.xml

  1. <dependency>
  2.     <groupId>org.springframework.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-gateway</artifactId>
  4. </dependency>
  6. <dependency>
  7.     <groupId>com.alibaba.csp</groupId>
  8.     <artifactId>sentinel-spring-cloud-gateway-adapter</artifactId>
  9. </dependency>

2、配置类

  1. package com.southwind.configuration;
  3. import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayFlowRule;
  4. import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayRuleManager;
  5. import com.alibaba.csp.sentinel.adapter.gateway.sc.SentinelGatewayFilter;
  6. import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.BlockRequestHandler;
  7. import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.GatewayCallbackManager;
  8. import com.alibaba.csp.sentinel.adapter.gateway.sc.exception.SentinelGatewayBlockExceptionHandler;
  9. import org.springframework.beans.factory.ObjectProvider;
  10. import org.springframework.cloud.gateway.filter.GlobalFilter;
  11. import org.springframework.context.annotation.Bean;
  12. import org.springframework.context.annotation.Configuration;
  13. import org.springframework.core.Ordered;
  14. import org.springframework.core.annotation.Order;
  15. import org.springframework.http.HttpStatus;
  16. import org.springframework.http.MediaType;
  17. import org.springframework.http.codec.ServerCodecConfigurer;
  18. import org.springframework.web.reactive.function.BodyInserters;
  19. import org.springframework.web.reactive.function.server.ServerResponse;
  20. import org.springframework.web.reactive.result.view.ViewResolver;
  21. import org.springframework.web.server.ServerWebExchange;
  22. import reactor.core.publisher.Mono;
  24. import javax.annotation.PostConstruct;
  25. import java.util.*;
  27. @Configuration
  28. public class GatewayConfiguration { 
  29.     private final List<ViewResolver> viewResolvers;
  30.     private final ServerCodecConfigurer serverCodecConfigurer;
  33.     public GatewayConfiguration(ObjectProvider<List<ViewResolver>> viewResolversProvider,
  34.                                 ServerCodecConfigurer serverCodecConfigurer) { 
  35.         this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
  36.         this.serverCodecConfigurer = serverCodecConfigurer;
  37.     }
  39.     //配置限流的异常处理
  40.     @Bean
  41.     @Order(Ordered.HIGHEST_PRECEDENCE)
  42.     public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() { 
  43.         return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
  44.     }
  46.     //配置初始化的限流参数
  47.     @PostConstruct
  48.     public void initGatewayRules(){ 
  49.         Set<GatewayFlowRule> rules = new HashSet<>();
  50.         rules.add(
  51.                 new GatewayFlowRule("provider_route")
  52.                 .setCount(1)
  53.                 .setIntervalSec(1)
  54.         );
  55.         GatewayRuleManager.loadRules(rules);
  56.     }
  58.     //初始化限流过滤器
  59.     @Bean
  60.     @Order(Ordered.HIGHEST_PRECEDENCE)
  61.     public GlobalFilter sentinelGatewayFilter() { 
  62.         return new SentinelGatewayFilter();
  63.     }
  65.     //自定义限流异常页面
  66.     @PostConstruct
  67.     public void initBlockHandlers(){ 
  68.         BlockRequestHandler blockRequestHandler = new BlockRequestHandler() { 
  69.             @Override
  70.             public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) { 
  71.                 Map map = new HashMap();
  72.                 map.put("code",0);
  73.                 map.put("msg","被限流了");
  74.                 return ServerResponse.status(HttpStatus.OK)
  75.                         .contentType(MediaType.APPLICATION_JSON)
  76.                         .body(BodyInserters.fromObject(map));
  77.             }
  78.         };
  79.         GatewayCallbackManager.setBlockHandler(blockRequestHandler);
  80.     }
  81. }

3、application.yml

  1. server:
  2.   port: 8010
  3. spring:
  4.   application:
  5.     name: gateway
  6.   cloud:
  7.     gateway:
  8.       discovery:
  9.         locator:
  10.           enabled: true
  11.       routes:
  12.         - id: provider_route
  13.           uri: http://localhost:8081
  14.           predicates:
  15.             - Path=/provider/**
  16.           filters:
  17.             - StripPrefix=1

基于 API 分组限流

1、修改配置类，添加基于 API 分组限流的方法，修改初始化的限流参数

  1. package com.southwind.configuration;
  3. import com.alibaba.csp.sentinel.adapter.gateway.common.SentinelGatewayConstants;
  4. import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiDefinition;
  5. import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiPathPredicateItem;
  6. import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiPredicateItem;
  7. import com.alibaba.csp.sentinel.adapter.gateway.common.api.GatewayApiDefinitionManager;
  8. import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayFlowRule;
  9. import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayRuleManager;
  10. import com.alibaba.csp.sentinel.adapter.gateway.sc.SentinelGatewayFilter;
  11. import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.BlockRequestHandler;
  12. import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.GatewayCallbackManager;
  13. import com.alibaba.csp.sentinel.adapter.gateway.sc.exception.SentinelGatewayBlockExceptionHandler;
  14. import org.springframework.beans.factory.ObjectProvider;
  15. import org.springframework.cloud.gateway.filter.GlobalFilter;
  16. import org.springframework.context.annotation.Bean;
  17. import org.springframework.context.annotation.Configuration;
  18. import org.springframework.core.Ordered;
  19. import org.springframework.core.annotation.Order;
  20. import org.springframework.http.HttpStatus;
  21. import org.springframework.http.MediaType;
  22. import org.springframework.http.codec.ServerCodecConfigurer;
  23. import org.springframework.web.reactive.function.BodyInserters;
  24. import org.springframework.web.reactive.function.server.ServerResponse;
  25. import org.springframework.web.reactive.result.view.ViewResolver;
  26. import org.springframework.web.server.ServerWebExchange;
  27. import reactor.core.publisher.Mono;
  29. import javax.annotation.PostConstruct;
  30. import java.util.*;
  32. @Configuration
  33. public class GatewayConfiguration { 
  35.     private final List<ViewResolver> viewResolvers;
  36.     private final ServerCodecConfigurer serverCodecConfigurer;
  39.     public GatewayConfiguration(ObjectProvider<List<ViewResolver>> viewResolversProvider,
  40.                                 ServerCodecConfigurer serverCodecConfigurer) { 
  41.         this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
  42.         this.serverCodecConfigurer = serverCodecConfigurer;
  43.     }
  45.     //配置限流的异常处理
  46.     @Bean
  47.     @Order(Ordered.HIGHEST_PRECEDENCE)
  48.     public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() { 
  49.         return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
  50.     }
  52.     //配置初始化的限流参数
  53.     @PostConstruct
  54.     public void initGatewayRules(){ 
  55.         Set<GatewayFlowRule> rules = new HashSet<>();
  56.         rules.add(new GatewayFlowRule("provider_api1").setCount(1).setIntervalSec(1));
  57.         rules.add(new GatewayFlowRule("provider_api2").setCount(1).setIntervalSec(1));
  58.         GatewayRuleManager.loadRules(rules);
  59.     }
  61.     //初始化限流过滤器
  62.     @Bean
  63.     @Order(Ordered.HIGHEST_PRECEDENCE)
  64.     public GlobalFilter sentinelGatewayFilter() { 
  65.         return new SentinelGatewayFilter();
  66.     }
  68.     //自定义限流异常页面
  69.     @PostConstruct
  70.     public void initBlockHandlers(){ 
  71.         BlockRequestHandler blockRequestHandler = new BlockRequestHandler() { 
  72.             @Override
  73.             public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) { 
  74.                 Map map = new HashMap();
  75.                 map.put("code",0);
  76.                 map.put("msg","被限流了");
  77.                 return ServerResponse.status(HttpStatus.OK)
  78.                         .contentType(MediaType.APPLICATION_JSON)
  79.                         .body(BodyInserters.fromObject(map));
  80.             }
  81.         };
  82.         GatewayCallbackManager.setBlockHandler(blockRequestHandler);
  83.     }
  85.     //自定义API分组
  86.     @PostConstruct
  87.     private void initCustomizedApis(){ 
  88.         Set<ApiDefinition> definitions = new HashSet<>();
  89.         ApiDefinition api1 = new ApiDefinition("provider_api1")
  90.                 .setPredicateItems(new HashSet<ApiPredicateItem>(){ { 
  91.                     add(new ApiPathPredicateItem().setPattern("/provider/api1/**")
  92.                             .setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX));
  93.                 }});
  94.         ApiDefinition api2 = new ApiDefinition("provider_api2")
  95.                 .setPredicateItems(new HashSet<ApiPredicateItem>(){ { 
  96.                     add(new ApiPathPredicateItem().setPattern("/provider/api2/demo1"));
  97.                 }});
  98.         definitions.add(api1);
  99.         definitions.add(api2);
  100.         GatewayApiDefinitionManager.loadApiDefinitions(definitions);
  101.     }
  102. }

2、Controller 添加方法

  1. @GetMapping("/api1/demo1")
  2. public String demo1(){ 
  3.     return "demo";
  4. }
  6. @GetMapping("/api1/demo2")
  7. public String demo2(){ 
  8.     return "demo";
  9. }
  11. @GetMapping("/api2/demo1")
  12. public String demo3(){ 
  13.     return "demo";
  14. }
  16. @GetMapping("/api2/demo2")
  17. public String demo4(){ 
  18.     return "demo";
  19. }

也可以基于 Nacos 服务发现组件进行限流

  1. server:
  2.   port: 8010
  3. spring:
  4.   application:
  5.     name: gateway
  6.   cloud:
  7.     gateway:
  8.       discovery:
  9.         locator:
  10.           enabled: true

API 分组代码修改，改为 discovery 中的服务名。

  1. ApiDefinition api2 = new ApiDefinition("provider_api2")
  2.         .setPredicateItems(new HashSet<ApiPredicateItem>(){ { 
  3.             add(new ApiPathPredicateItem().setPattern("/p1/api2/demo1"));
  4.         }});

分布式事务

模拟分布式事务异常

1、创建两个工程 order、pay，pom.xml

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-jdbc</artifactId>
  4. </dependency>
  5. <dependency>
  6.     <groupId>org.springframework.boot</groupId>
  7.     <artifactId>spring-boot-starter-web</artifactId>
  8. </dependency>
  10. <dependency>
  11.     <groupId>mysql</groupId>
  12.     <artifactId>mysql-connector-java</artifactId>
  13.     <scope>runtime</scope>
  14. </dependency>
  15. <dependency>
  16.     <groupId>org.projectlombok</groupId>
  17.     <artifactId>lombok</artifactId>
  18.     <optional>true</optional>
  19. </dependency>

2、建两个数据库 order、pay，两个微服务分别访问。

3、分别写两个服务的 application.yml

  1. server:
  2.   port: 8010
  3. spring:
  4.   application:
  5.     name: order
  6.   datasource:
  7.     driver-class-name: com.mysql.cj.jdbc.Driver
  8.     username: root
  9.     password: 123456
  10.     url: jdbc:mysql://localhost:3306/order
  12. server:
  13.   port: 8020
  14. spring:
  15.   application:
  16.     name: pay
  17.   datasource:
  18.     driver-class-name: com.mysql.cj.jdbc.Driver
  19.     username: root
  20.     password: 123456
  21.     url: jdbc:mysql://localhost:3306/pay

4、分别写两个 Service

  1. package com.southwind.service;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.jdbc.core.JdbcTemplate;
  5. import org.springframework.stereotype.Service;
  7. @Service
  8. public class OrderService { 
  9.     @Autowired
  10.     private JdbcTemplate jdbcTemplate;
  12.     public void save(){ 
  13.         this.jdbcTemplate.update("insert into orders(username) values ('张三')");
  14.     }
  15. }
  17. package com.southwind.service;
  19. import org.springframework.beans.factory.annotation.Autowired;
  20. import org.springframework.jdbc.core.JdbcTemplate;
  21. import org.springframework.stereotype.Service;
  23. @Service
  24. public class PayService { 
  25.     @Autowired
  26.     private JdbcTemplate jdbcTemplate;
  28.     public void save(){ 
  29.         this.jdbcTemplate.update("insert into pay(username) values ('张三')");
  30.     }
  31. }

5、控制器 Order 通过 RestTemplate 调用 Pay 的服务

  1. package com.southwind.controller;
  3. import com.southwind.service.OrderService;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.web.bind.annotation.GetMapping;
  6. import org.springframework.web.bind.annotation.RestController;
  7. import org.springframework.web.client.RestTemplate;
  9. @RestController
  10. public class OrderController { 
  12.     @Autowired
  13.     private OrderService orderService;
  14.     @Autowired
  15.     private RestTemplate restTemplate;
  17.     @GetMapping("/save")
  18.     public String save(){ 
  19.         //订单
  20.         this.orderService.save();
  21.         int i = 10/0;
  22.         //支付
  23.         this.restTemplate.getForObject("http://localhost:8020/save",String.class);
  24.         return "success";
  25.     }
  26. }
  28. package com.southwind.controller;
  30. import com.southwind.service.PayService;
  31. import org.springframework.beans.factory.annotation.Autowired;
  32. import org.springframework.web.bind.annotation.GetMapping;
  33. import org.springframework.web.bind.annotation.RestController;
  35. @RestController
  36. public class PayController { 
  37.     @Autowired
  38.     private PayService payService;
  40.     @GetMapping("/save")
  41.     public String save(){ 
  42.         this.payService.save();
  43.         return "success";
  44.     }
  45. }

6、启动类

  1. package com.southwind;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.web.client.RestTemplate;
  8. @SpringBootApplication
  9. public class OrderApplication { 
  11.     public static void main(String[] args) { 
  12.         SpringApplication.run(OrderApplication.class, args);
  13.     }
  15.     @Bean
  16.     public RestTemplate restTemplate(){ 
  17.         return new RestTemplate();
  18.     }
  19. }
  21. package com.southwind;
  23. import org.springframework.boot.SpringApplication;
  24. import org.springframework.boot.autoconfigure.SpringBootApplication;
  26. @SpringBootApplication
  27. public class PayApplication { 
  29.     public static void main(String[] args) { 
  30.         SpringApplication.run(PayApplication.class, args);
  31.     }
  33. }

分布式异常模拟结束，Order 存储完成之后，出现异常，会导致 Pay 无法存储，但是 Order 数据库不会进行回滚。

Seata 解决（事务回滚）

1、下载

2、解压，修改两个文件
在这里插入图片描述
regisry.conf

  1. registry {
  2.   type = "nacos"
  3.   nacos {
  4.     serverAddr = "localhost"
  5.     namespace = "public"
  6.     cluster = "default"
  7.   }
  8. }
  10. config {
  11.   type = "nacos"
  12.   nacos {
  13.     serverAddr = "localhost"
  14.     namespace = "public"
  15.     cluster = "default"
  16.   }
  17. }

nacos-config.txt
在这里插入图片描述
3、启动 Nacos，运行 nacos-config.sh 将 Seata 配置导入 Nacos

进入 conf，右键 Git Bash Here

  1. cd conf
  2. sh nacos-config.sh 127.0.0.1

执行成功，刷新 Nacos，配置加入（如下图）
在这里插入图片描述
nacos-config.txt 配置已生效
在这里插入图片描述
4、启动 Seata Server， JDK 8 以上环境无法启动

  1. cd bin
  2. seata-server.bat -p 8090 -m file

在这里插入图片描述
启动成功，Nacos 注册成功。
在这里插入图片描述
Seata 服务环境搭建完毕，接下来去应用中添加。

1、初始化数据库，在两个数据库中添加事务日志记录表，SQL Seata 已经提供。

在这里插入图片描述
2、直接在两个数据库运行脚本。

  1. CREATE TABLE `undo_log` (
  2.   `id` bigint(20) NOT NULL AUTO_INCREMENT,
  3.   `branch_id` bigint(20) NOT NULL,
  4.   `xid` varchar(100) NOT NULL,
  5.   `context` varchar(128) NOT NULL,
  6.   `rollback_info` longblob NOT NULL,
  7.   `log_status` int(11) NOT NULL,
  8.   `log_created` datetime NOT NULL,
  9.   `log_modified` datetime NOT NULL,
  10.   `ext` varchar(100) DEFAULT NULL,
  11.   PRIMARY KEY (`id`),
  12.   UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
  13. ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

3、两个工程的 pom.xml 添加 Seata 组件和 Nacos Config 组件。

  1. <dependency>
  2.     <groupId>com.alibaba.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
  4.     <version>2.1.1.RELEASE</version>
  5. </dependency>
  7. <dependency>
  8.     <groupId>com.alibaba.cloud</groupId>
  9.     <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
  10. </dependency>

4、给 JDBCTemplate 添加代理数据源

  1. package com.southwind;
  3. import io.seata.rm.datasource.DataSourceProxy;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.jdbc.core.JdbcTemplate;
  8. import org.springframework.web.client.RestTemplate;
  10. import javax.sql.DataSource;
  12. @SpringBootApplication
  13. public class OrderApplication { 
  15.     public static void main(String[] args) { 
  16.         SpringApplication.run(OrderApplication.class, args);
  17.     }
  19.     @Bean
  20.     public RestTemplate restTemplate(){ 
  21.         return new RestTemplate();
  22.     }
  24.     @Bean
  25.     public JdbcTemplate jdbcTemplate(DataSource dataSource){ 
  26.         return new JdbcTemplate(new DataSourceProxy(dataSource));
  27.     }
  28. }
  30. package com.southwind;
  32. import io.seata.rm.datasource.DataSourceProxy;
  33. import org.springframework.boot.SpringApplication;
  34. import org.springframework.boot.autoconfigure.SpringBootApplication;
  35. import org.springframework.context.annotation.Bean;
  36. import org.springframework.jdbc.core.JdbcTemplate;
  38. import javax.sql.DataSource;
  40. @SpringBootApplication
  41. public class PayApplication { 
  43.     public static void main(String[] args) { 
  44.         SpringApplication.run(PayApplication.class, args);
  45.     }
  47.     @Bean
  48.     public JdbcTemplate jdbcTemplate(DataSource dataSource){ 
  49.         return new JdbcTemplate(new DataSourceProxy(dataSource));
  50.     }
  52. }

5、将 registry.conf 复制到两个工程的 resources 下。

6、给两个工程添加 bootstrap.yml 读取 Nacos 配置。

  1. spring:
  2.   application:
  3.     name: order
  4.   cloud:
  5.     nacos:
  6.       config:
  7.         server-addr: localhost:8848
  8.         namespace: public
  9.         group: SEATA_GROUP
  10.     alibaba:
  11.       seata:
  12.         tx-service-group: ${ spring.application.name}
  14. spring:
  15.   application:
  16.     name: pay
  17.   cloud:
  18.     nacos:
  19.       config:
  20.         server-addr: localhost:8848
  21.         namespace: public
  22.         group: SEATA_GROUP
  23.     alibaba:
  24.       seata:
  25.         tx-service-group: ${ spring.application.name}

tx-service-group 需要和 Nacos 配置中的名称一致。
在这里插入图片描述
7、在 Order 调用 Pay 处添加注解 @GlobalTransactional

  1. package com.southwind.controller;
  3. import com.southwind.service.OrderService;
  4. import io.seata.spring.annotation.GlobalTransactional;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.web.bind.annotation.GetMapping;
  7. import org.springframework.web.bind.annotation.RestController;
  8. import org.springframework.web.client.RestTemplate;
  10. @RestController
  11. public class OrderController { 
  13.     @Autowired
  14.     private OrderService orderService;
  15.     @Autowired
  16.     private RestTemplate restTemplate;
  18.     @GetMapping("/save")
  19.     @GlobalTransactional
  20.     public String save(){ 
  21.         //订单
  22.         this.orderService.save();
  23.         int i = 10/0;
  24.         //支付
  25.         this.restTemplate.getForObject("http://localhost:8020/save",String.class);
  26.         return "success";
  27.     }
  28. }

【视频参考】https://www.bilibili.com/video/BV1Mt4y1i7JW
【源码参考】https://github.com/monkeyhlj/spring-study

发表评论

表情：
评论列表 （有 0 条评论，321人围观）

还没有评论，来说两句吧...

相关阅读