引自B站楠哥：https://space.bilibili.com/434617924

一、创建父工程

创建父工程hello-spring-cloud-alibaba

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

Spring Boot ---》Spring Cloud ---》Spring Cloud Alibaba

引入依赖时注意提前查询一下spring cloud的版本依赖关系。

pom文件为，父工程打包时应打成pom，否则子工程构建时无法打包成功。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.3.0.RELEASE</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.yqd</groupId>
  12.     <artifactId>hello-spring-cloud-alibaba</artifactId>
  13.     <version>1.0.0-SNAPSHOT</version>
  14.     <name>hello-spring-cloud-alibaba</name>
  15.     <description>Demo project for hello-spring-cloud-alibaba</description>
  16.     <packaging>pom</packaging>
  18.     <properties>
  19.         <java.version>1.8</java.version>
  20.     </properties>
  22.     <dependencies>
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-web</artifactId>
  26.         </dependency>
  28.         <dependency>
  29.             <groupId>org.projectlombok</groupId>
  30.             <artifactId>lombok</artifactId>
  31.             <optional>true</optional>
  32.         </dependency>
  33.         <dependency>
  34.             <groupId>org.springframework.boot</groupId>
  35.             <artifactId>spring-boot-starter-test</artifactId>
  36.             <scope>test</scope>
  37.             <exclusions>
  38.                 <exclusion>
  39.                     <groupId>org.junit.vintage</groupId>
  40.                     <artifactId>junit-vintage-engine</artifactId>
  41.                 </exclusion>
  42.             </exclusions>
  43.         </dependency>
  44.     </dependencies>
  46.     <dependencyManagement>
  47.         <dependencies>
  48.             <dependency>
  49.                 <groupId>org.springframework.cloud</groupId>
  50.                 <artifactId>spring-cloud-dependencies</artifactId>
  51.                 <version>Hoxton.SR3</version>
  52.             </dependency>
  53.             <dependency>
  54.                 <groupId>com.alibaba.cloud</groupId>
  55.                 <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  56.                 <version>2.2.1.RELEASE</version>
  57.             </dependency>
  58.         </dependencies>
  59.     </dependencyManagement>
  61.     <build>
  62.         <plugins>
  63.             <plugin>
  64.                 <groupId>org.springframework.boot</groupId>
  65.                 <artifactId>spring-boot-maven-plugin</artifactId>
  66.                 <configuration>
  67.                     <excludes>
  68.                         <exclude>
  69.                             <groupId>org.projectlombok</groupId>
  70.                             <artifactId>lombok</artifactId>
  71.                         </exclude>
  72.                     </excludes>
  73.                 </configuration>
  74.             </plugin>
  75.         </plugins>
  76.     </build>
  78. </project>

父工程中只需要引入所需要的依赖就可以了，不用其他的资源，可以删除src目录和resources目录。

二、服务的提供者

在父工程中添加spring boot模块module，工程名字为provider。

pom文件为

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>com.yqd</groupId>
  7.         <artifactId>hello-spring-cloud-alibaba</artifactId>
  8.         <version>1.0.0-SNAPSHOT</version>
  9.     </parent>
  10.     <groupId>com.yqd</groupId>
  11.     <artifactId>provider</artifactId>
  12.     <version>1.0.0-SNAPSHOT</version>
  13.     <name>provider</name>
  14.     <description>Demo project for Spring Boot</description>
  16.     <properties>
  17.         <java.version>1.8</java.version>
  18.     </properties>
  20.     <dependencies>
  21.         <dependency>
  22.             <groupId>org.springframework.boot</groupId>
  23.             <artifactId>spring-boot-starter</artifactId>
  24.         </dependency>
  26.         <dependency>
  27.             <groupId>org.springframework.boot</groupId>
  28.             <artifactId>spring-boot-starter-test</artifactId>
  29.             <scope>test</scope>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>com.alibaba.cloud</groupId>
  33.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  34.             <version>2.2.1.RELEASE</version>
  35.         </dependency>
  36.     </dependencies>
  38.     <build>
  39.         <plugins>
  40.             <plugin>
  41.                 <groupId>org.springframework.boot</groupId>
  42.                 <artifactId>spring-boot-maven-plugin</artifactId>
  43.             </plugin>
  44.         </plugins>
  45.     </build>
  47. </project>

在子工程中要引入spring-cloud-starter-alibaba-nacos-discovery依赖，这样才可以注册到nacos中。

配置文件application.yml为：

  1. spring:
  2.   cloud:
  3.     nacos:
  4.       discovery:
  5.         server-addr: localhost:8848
  6.   application:
  7.     name: provider
  9. server:
  10.   port: 8081

做个接口供外部调用：

  1. package com.yqd.controller;
  3. import org.springframework.beans.factory.annotation.Value;
  4. import org.springframework.web.bind.annotation.GetMapping;
  5. import org.springframework.web.bind.annotation.RestController;
  7. @RestController
  8. public class ProviderController {
  10.     @Value("${server.port}")  //SPEL
  11.     private String port;
  13.     @GetMapping("/index")
  14.     public String index(){
  15.         return this.port;
  16.     }
  17. }

下载解压nacos1.2.1，解压之后打开bin目录下的startup.cmd，然后通过url访问nacos，http://localhost:8848/nacos/index.html，登录的用户名和密码都默认是nocos。可以通过nacos查看注册的实例。

三、服务的消费者

在父工程中添加spring boot模块module，工程名字为consumer。

pom文件为

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>com.yqd</groupId>
  7.         <artifactId>hello-spring-cloud-alibaba</artifactId>
  8.         <version>1.0.0-SNAPSHOT</version>
  9.     </parent>
  10.     <groupId>com.yqd</groupId>
  11.     <artifactId>consumer</artifactId>
  12.     <version>1.0.0-SNAPSHOT</version>
  13.     <name>consumer</name>
  14.     <description>Demo project for Spring Boot</description>
  16.     <properties>
  17.         <java.version>1.8</java.version>
  18.     </properties>
  20.     <dependencies>
  21.         <dependency>
  22.             <groupId>org.springframework.boot</groupId>
  23.             <artifactId>spring-boot-starter</artifactId>
  24.         </dependency>
  26.         <dependency>
  27.             <groupId>org.springframework.boot</groupId>
  28.             <artifactId>spring-boot-starter-test</artifactId>
  29.             <scope>test</scope>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>com.alibaba.cloud</groupId>
  33.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  34.             <version>2.2.1.RELEASE</version>
  35.         </dependency>
  36.     </dependencies>
  38.     <build>
  39.         <plugins>
  40.             <plugin>
  41.                 <groupId>org.springframework.boot</groupId>
  42.                 <artifactId>spring-boot-maven-plugin</artifactId>
  43.             </plugin>
  44.         </plugins>
  45.     </build>
  47. </project>

在子工程中要引入spring-cloud-starter-alibaba-nacos-discovery依赖，这样才可以注册到nacos中。但是消费者只需要到提供者中调用接口就可以了，因此可以不用在配置文件中配置nacos。

配置文件application.yml为：

  1. server:
  2.   port: 8180

远程过程调用使用RestTemplate

  1. package com.yqd.config;
  3. import org.springframework.cloud.client.loadbalancer.LoadBalanced;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.context.annotation.Primary;
  7. import org.springframework.web.client.RestTemplate;
  9. @Configuration
  10. public class ConsumerConfiguration {
  11.     @Bean
  12.     @LoadBalanced //使用Ribbon进行远程调用
  13.     @Primary
  14.     public RestTemplate restTemplate(){
  15.         return new RestTemplate();
  16.     }
  18.     //必须使用自己配置的这个Bean，并且使用名称注入，否则报错java.lang.IllegalStateException: No instances available for ...
  19.     @Bean
  20.     public RestTemplate restTemplateCustom(){
  21.         return new RestTemplate();
  22.     }
  23. }

创建接口来从provider的接口中获取数据

  1. package com.yqd.controller;
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.beans.factory.annotation.Qualifier;
  6. import org.springframework.cloud.client.ServiceInstance;
  7. import org.springframework.cloud.client.discovery.DiscoveryClient;
  8. import org.springframework.web.bind.annotation.GetMapping;
  9. import org.springframework.web.bind.annotation.RestController;
  10. import org.springframework.web.client.RestTemplate;
  12. import java.util.List;
  13. import java.util.concurrent.ThreadLocalRandom;
  15. @RestController
  16. @Slf4j
  17. public class ConsumerController {
  18.     //自动装载，直接用
  19.     @Autowired
  20.     private DiscoveryClient discoveryClient;
  21.     //没有自动装载，不能直接用，需要用配置类装载
  22.     @Autowired(required = false) // 必须使用自己配置的这个Bean，并且使用名称注入，否则报错
  23.     @Qualifier("restTemplateCustom") // 表示根据名称来找bean
  24.     private RestTemplate restTemplateCustom;
  26.     /**
  27.      * 返回服务实例
  28.      * @return
  29.      */
  30.     @GetMapping("/instances")
  31.     public List<ServiceInstance> instances() {
  32.         List<ServiceInstance> provider = this.discoveryClient.getInstances("provider");
  33.         return provider;
  34.     }
  36.     @GetMapping("/index")
  37.     public String index(){
  38.         //调用provider服务的index方法
  39.         //1、找到provider实例
  40.         List<ServiceInstance> list = this.discoveryClient.getInstances("provider");
  41.         int index = ThreadLocalRandom.current().nextInt(list.size());//返回一个随机数
  42.         ServiceInstance serviceInstance = list.get(index); //获取其中一个实例
  43.         String url = serviceInstance.getUri()+"/index";//URL=URI+请求路径
  44.         //2、调用
  45.         log.info("调用的端口是，{}", serviceInstance.getPort());
  46.         return "调用了端口为："+serviceInstance.getPort()+"的服务，返回结果是："+this.restTemplateCutom.getForObject(url, String.class);
  47.     }
  48. }

四、使用Ribbon做负载均衡

配置类

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

application.yml中配置，随机调用机器

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

Nacos 权重配置，在nacos中配置机器的权重，权重越高被访问的概率越大

  1. package com.yqd.config;
  3. import com.alibaba.cloud.nacos.NacosDiscoveryProperties;
  4. import com.alibaba.cloud.nacos.ribbon.NacosServer;
  5. import com.alibaba.nacos.api.exception.NacosException;
  6. import com.alibaba.nacos.api.naming.NamingService;
  7. import com.alibaba.nacos.api.naming.pojo.Instance;
  8. import com.netflix.client.config.IClientConfig;
  9. import com.netflix.loadbalancer.AbstractLoadBalancerRule;
  10. import com.netflix.loadbalancer.BaseLoadBalancer;
  11. import com.netflix.loadbalancer.ILoadBalancer;
  12. import com.netflix.loadbalancer.Server;
  13. import lombok.extern.slf4j.Slf4j;
  14. import org.springframework.beans.factory.annotation.Autowired;
  16. @Slf4j
  17. public class NacosWeightedRule extends AbstractLoadBalancerRule {
  19.     @Autowired
  20.     private NacosDiscoveryProperties nacosDiscoveryProperties;
  22.     @Override
  23.     public void initWithNiwsConfig(IClientConfig iClientConfig) {
  24.         //读取配置文件
  25.     }
  27.     @Override
  28.     public Server choose(Object o) {
  29.         ILoadBalancer loadBalancer = this.getLoadBalancer();
  30.         BaseLoadBalancer baseLoadBalancer = (BaseLoadBalancer) loadBalancer;
  31.         //获取要请求的微服务名称
  32.         String name = baseLoadBalancer.getName();
  33.         //获取服务发现的相关API
  34.         NamingService namingService = nacosDiscoveryProperties.namingServiceInstance();
  35.         try {
  36.             Instance instance = namingService.selectOneHealthyInstance(name);
  37.             log.info("选择的实例是port={},instance={}",instance.getPort(),instance);
  38.             return new NacosServer(instance);
  39.         } catch (NacosException e) {
  40.             e.printStackTrace();
  41.             return null;
  42.         }
  43.     }
  44. }
  1. server:
  2.   port: 8180
  3. provider:
  4.   ribbon:
  5.     NFLoadBalancerRuleClassName: com.yqd.config.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.     <version>2.2.1.RELEASE</version>
  5. </dependency>
  7. <dependency>
  8.     <groupId>org.springframework.boot</groupId>
  9.     <artifactId>spring-boot-starter-actuator</artifactId>
  10. </dependency>

2、在provider的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 控制台，解压，启动。访问地址：http://localhost:8080。用户名和密码都是sentinel。

4、启动nacos，再启动provider项目，访问provider中的接口，等待一会刷新会出现服务相关的信息。必须有请求时才可以监控到。

5.1 流控规则

直接限流：直接对某个接口限流

关联限流：对某个接口的访问会影响对另一个接口的访问

链路限流：可以通过链路入侵到其他层，比如controller层、service层

链路过滤相关代码：

1、在服务提供者provider项目的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、在provider的application中增加配置

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

3、增加配置类

  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. @Autowired
  2. private HelloService helloService;
  4. @GetMapping("/test1")
  5. public String test1(){
  6.     this.helloService.test();
  7.     return "test1";
  8. }
  10. @GetMapping("/test2")
  11. public String test2(){
  12.     this.helloService.test();
  13.     return "test2";
  14. }

6、访问接口http://localhost:8081/test1和http://localhost:8081/test2。然后再sentinel控制台簇点链路会看到两个接口test1和test2。对test1接口增加一个流控，设置单机阈值=1，流控模式魏链路，入口资源为/test1，新增。然后再去分别刷新访问两个接口，会发现test1接口刷新太快会限流，test2接口不会限流。

5.2流控效果

快速失败

直接抛出异常

Warm UP

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

排队等待

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

5.3 降级规则

RT

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

异常比例

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

异常数

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

5.4 热点规则

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

必须要添加 @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. }

5.5 授权规则

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

如何给请求指定流控应用，通过实现 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. }

5.6 自定义规则异常返回

创建异常处理类

  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

6.1 安装 RocketMQ

1、传入 Linux 服务器

2、解压缩，把rocketmq的文件夹放到/usr/local/目录下

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

3、切换到rockmq的目录中，启动 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. JAVA_OPT="${JAVA_OPT} -server -Xms256m -Xmx256m -Xmn128m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=320m"
  1. vim runbroker.sh

改成如下参数：

  1. JAVA_OPT="${JAVA_OPT} -server -Xms256m -Xmx256m -Xmn128m"

启动 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

6.2 安装 RocketMQ 控制台

1、把rocketmq的客户端文件解压缩，进入目录rocketmq-externals-rocketmq-console-1.0.0\rocketmq-console\src\main\resources，修改配置application.yml，打包

  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=9876/tcp --permanent
  2. firewall-cmd --zone=public --add-port=10909/tcp --permanent
  3. firewall-cmd --zone=public --add-port=10911/tcp --permanent
  4. systemctl restart firewalld.service
  5. firewall-cmd --reload

重新启动控制台项目

6.3 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 控制台，可查看消息。

6.4 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. }

6.5 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. }

先启动provider，再启动consumer。然后调用provider的接口产生消息：http://localhost:8081/create，消息会存入rocketmq服务器中，consumer一直监听着服务器，当服务器新存入消息的时候就从服务器中读取消息。可能会遇到无法读取消息的情况，可以重启一下consumer。

七、服务网关

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

1、pom.xml

注意，一定不能出现 spring web 的依赖，因为 Gateway 与 Servlet 不兼容。因此需要把spring-boot-starter-web依赖从父工程中添加到需要它的子工程中，这样gateway中就不会依赖到它了。

  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

7.1 Gateway 限流

7.1.1 基于路由限流

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;
  32.     public GatewayConfiguration(ObjectProvider<List<ViewResolver>> viewResolversProvider,
  33.                                 ServerCodecConfigurer serverCodecConfigurer) {
  34.         this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
  35.         this.serverCodecConfigurer = serverCodecConfigurer;
  36.     }
  38.     //配置限流的异常处理
  39.     @Bean
  40.     @Order(Ordered.HIGHEST_PRECEDENCE)
  41.     public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
  42.         return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
  43.     }
  45.     //配置初始化的限流参数
  46.     @PostConstruct
  47.     public void initGatewayRules(){
  48.         Set<GatewayFlowRule> rules = new HashSet<>();
  49.         rules.add(
  50.                 new GatewayFlowRule("provider_route")
  51.                 .setCount(1)
  52.                 .setIntervalSec(1)
  53.         );
  54.         GatewayRuleManager.loadRules(rules);
  55.     }
  57.     //初始化限流过滤器
  58.     @Bean
  59.     @Order(Ordered.HIGHEST_PRECEDENCE)
  60.     public GlobalFilter sentinelGatewayFilter() {
  61.         return new SentinelGatewayFilter();
  62.     }
  64.     //自定义限流异常页面
  65.     @PostConstruct
  66.     public void initBlockHandlers(){
  67.         BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {
  68.             @Override
  69.             public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {
  70.                 Map map = new HashMap();
  71.                 map.put("code",0);
  72.                 map.put("msg","被限流了");
  73.                 return ServerResponse.status(HttpStatus.OK)
  74.                         .contentType(MediaType.APPLICATION_JSON)
  75.                         .body(BodyInserters.fromObject(map));
  76.             }
  77.         };
  78.         GatewayCallbackManager.setBlockHandler(blockRequestHandler);
  79.     }
  80. }

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

7.1.2 基于 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;
  38.     public GatewayConfiguration(ObjectProvider<List<ViewResolver>> viewResolversProvider,
  39.                                 ServerCodecConfigurer serverCodecConfigurer) {
  40.         this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
  41.         this.serverCodecConfigurer = serverCodecConfigurer;
  42.     }
  44.     //配置限流的异常处理
  45.     @Bean
  46.     @Order(Ordered.HIGHEST_PRECEDENCE)
  47.     public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
  48.         return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
  49.     }
  51.     //配置初始化的限流参数
  52.     @PostConstruct
  53.     public void initGatewayRules(){
  54.         Set<GatewayFlowRule> rules = new HashSet<>();
  55.         rules.add(new GatewayFlowRule("provider_api1").setCount(1).setIntervalSec(1));
  56.         rules.add(new GatewayFlowRule("provider_api2").setCount(1).setIntervalSec(1));
  57.         GatewayRuleManager.loadRules(rules);
  58.     }
  60.     //初始化限流过滤器
  61.     @Bean
  62.     @Order(Ordered.HIGHEST_PRECEDENCE)
  63.     public GlobalFilter sentinelGatewayFilter() {
  64.         return new SentinelGatewayFilter();
  65.     }
  67.     //自定义限流异常页面
  68.     @PostConstruct
  69.     public void initBlockHandlers(){
  70.         BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {
  71.             @Override
  72.             public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {
  73.                 Map map = new HashMap();
  74.                 map.put("code",0);
  75.                 map.put("msg","被限流了");
  76.                 return ServerResponse.status(HttpStatus.OK)
  77.                         .contentType(MediaType.APPLICATION_JSON)
  78.                         .body(BodyInserters.fromObject(map));
  79.             }
  80.         };
  81.         GatewayCallbackManager.setBlockHandler(blockRequestHandler);
  82.     }
  84.     //自定义API分组
  85.     @PostConstruct
  86.     private void initCustomizedApis(){
  87.         Set<ApiDefinition> definitions = new HashSet<>();
  88.         ApiDefinition api1 = new ApiDefinition("provider_api1")
  89.                 .setPredicateItems(new HashSet<ApiPredicateItem>(){{
  90.                     add(new ApiPathPredicateItem().setPattern("/provider/api1/**")
  91.                             .setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX));
  92.                 }});
  93.         ApiDefinition api2 = new ApiDefinition("provider_api2")
  94.                 .setPredicateItems(new HashSet<ApiPredicateItem>(){{
  95.                     add(new ApiPathPredicateItem().setPattern("/provider/api2/demo1"));
  96.                 }});
  97.         definitions.add(api1);
  98.         definitions.add(api2);
  99.         GatewayApiDefinitionManager.loadApiDefinitions(definitions);
  100.     }
  101. }

2、在provider的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. }

7.1.3 基于 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.         }});

八、分布式事务

8.1 模拟分布式事务异常

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，两个微服务分别访问。

order数据库里面建一个表orders，字段有id和username。

pay数据库里面建一个表pay，字段有id和username。

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?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
  1. server:
  2.   port: 8020
  3. spring:
  4.   application:
  5.     name: pay
  6.   datasource:
  7.     driver-class-name: com.mysql.cj.jdbc.Driver
  8.     username: root
  9.     password: 123456
  10.     url: jdbc:mysql://localhost:3306/pay?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC

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. }
  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 PayService {
  9.     @Autowired
  10.     private JdbcTemplate jdbcTemplate;
  12.     public void save(){
  13.         this.jdbcTemplate.update("insert into pay(username) values ('张三')");
  14.     }
  15. }

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. }
  1. package com.southwind.controller;
  3. import com.southwind.service.PayService;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.web.bind.annotation.GetMapping;
  6. import org.springframework.web.bind.annotation.RestController;
  8. @RestController
  9. public class PayController {
  10.     @Autowired
  11.     private PayService payService;
  13.     @GetMapping("/save")
  14.     public String save(){
  15.         this.payService.save();
  16.         return "success";
  17.     }
  18. }

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. }
  1. package com.southwind;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @SpringBootApplication
  7. public class PayApplication {
  9.     public static void main(String[] args) {
  10.         SpringApplication.run(PayApplication.class, args);
  11.     }
  13. }

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

8.2 Seata 解决

1、下载

2、解压，进入到conf文件夹下修改两个文件

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，通过git bish的命令行窗口来运行 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 已经提供。复制conf文件夹下db_undo_log.sql中的建表语句分别在order数据库和pay数据库中新建undo_log表。

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. }
  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;
  9. import javax.sql.DataSource;
  11. @SpringBootApplication
  12. public class PayApplication {
  14.     public static void main(String[] args) {
  15.         SpringApplication.run(PayApplication.class, args);
  16.     }
  18.     @Bean
  19.     public JdbcTemplate jdbcTemplate(DataSource dataSource){
  20.         return new JdbcTemplate(new DataSourceProxy(dataSource));
  21.     }
  23. }

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}
  1. spring:
  2.   application:
  3.     name: pay
  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}

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. }

Spring Cloud Alibaba学习笔记的更多相关文章

  1. Spring Cloud Alibaba学习笔记（1） - 整合Spring Cloud Alibaba

    Spring Cloud Alibaba从孵化器版本毕业:https://github.com/alibaba/spring-cloud-alibaba,记录一下自己学习Spring Cloud Al ...

  2. Spring Cloud Alibaba学习笔记（15） - 整合Spring Cloud Gateway

    Spring Cloud Gateway 概述 Spring Cloud Gateway 是 Spring Cloud 的一个全新项目,该项目是基于Netty.Reactor以及WEbFlux构建,它 ...

  3. Spring Cloud Alibaba学习笔记（3） - Ribbon

    1.手写一个客户端负载均衡器 在了解什么是Ribbon之前,首先通过代码的方式手写一个负载均衡器 RestTemplate restTemplate = new RestTemplate(); // ...

  4. Spring Cloud Alibaba学习笔记（22） - Nacos配置管理

    目前业界流行的统一配置管理中心组件有Spring Cloud Config.Spring Cloud Alibaba的Nacos及携程开源的Apollo,本文将介绍Nacos作为统一配置管理中心的使用 ...

  5. Spring Cloud Alibaba学习笔记（2） - Nacos服务发现

    1.什么是Nacos Nacos的官网对这一问题进行了详细的介绍,通俗的来说: Nacos是一个服务发现组件,同时也是一个配置服务器,它解决了两个问题: 1.服务A如何发现服务B 2.管理微服务的配置 ...

  6. Spring Cloud Alibaba学习笔记（23） - 调用链监控工具Spring Cloud Sleuth + Zipkin

    随着业务发展,系统拆分导致系统调用链路愈发复杂一个前端请求可能最终需要调用很多次后端服务才能完成,当整个请求陷入性能瓶颈或不可用时,我们是无法得知该请求是由某个或某些后端服务引起的,这时就需要解决如何 ...

  7. Spring Cloud Alibaba学习笔记（18） - Spring Cloud Gateway 内置的过滤器工厂

    参考:https://cloud.spring.io/spring-cloud-static/spring-cloud-gateway/2.1.0.RELEASE/single/spring-clou ...

  8. Spring Cloud Alibaba学习笔记（14） - Spring Cloud Stream + RocketMQ实现分布式事务

    发送消息 在Spring消息编程模型下,使用RocketMQ收发消息 一文中,发送消息使用的是RocketMQTemplate类. 在集成了Spring Cloud Stream之后,我们可以使用So ...

  9. Spring Cloud Alibaba学习笔记（12） - 使用Spring Cloud Stream 构建消息驱动微服务

    什么是Spring Cloud Stream 一个用于构建消息驱动的微服务的框架 应用程序通过 inputs 或者 outputs 来与 Spring Cloud Stream 中binder 交互, ...

随机推荐

  1. React中JSX的理解

    React中JSX的理解 JSX是快速生成react元素的一种语法,实际是React.createElement(component, props, ...children)的语法糖,同时JSX也是J ...

  2. css做keylogger

    下载keylogger:https://github.com/maxchehab/css-keylogging 参考讲解:https://blog.csdn.net/weixin_34138139/a ...

  3. 响应式网站设计---Bootstrap

    响应式布局可以帮助我们实现网站布局随屏幕大小自动调整的需求,实现不同屏幕分辨率的终端上浏览网页的不同展示方式,使得网页在PC端和手机端均可以完美的展现其内容,具有自适应性. 使用基于Bootstrap ...

  4. jQuery中live()使用报错，TypeError: $(...).live is not a function

    原博文 https://blog.csdn.net/sdfdyubo/article/details/59536781 使用 原写法 /*为选项卡绑定右键*/ $(".tabs li&quo ...

  5. Redis 设计与实现：Redis 对象

    本文的分析都是基于 Redis 6.0 版本源码 redis 6.0 源码:https://github.com/redis/redis/tree/6.0 在 Redis 中,有五大数据类型,都统一封 ...

  6. Json串的字段如果和类中字段不一致，如何映射、转换？

    Json串是我们现在经常会遇到的一种描述对象的字符串格式.在用Java语言开发的功能中,也经常需要做Json串与Java对象之间的转换. fastjson就是经常用来做Json串与Java对象之间的转 ...

  7. Lombok注解-@SneakyThrows

    @SneakyThrows注解的用途得从java的异常设计体系说起. java中我们常见的2类异常. 1.普通Exception类,也就是我们常说的受检异常或者Checked Exception. 2 ...

  8. node-sass 安装失败报错的原因及解决办法(整理)

    npm install 时偶尔遇到报错:没有安装python或node-sass 安装失败的问题,百度之后发现是被墙了,但根据百度的方法换了淘宝镜像和用了vpn都安装失败,最后发现原来是因为没有卸载之 ...

  9. Docker下配置KeepAlive支持nginx高可用

    案例子任务一.安装配置keepalived 步骤1:使用nginx镜像生成nginx-keep镜像 1) 启动nginx容器并进入 docker run -d --privileged nginx / ...

  10. (class: org/apache/jasper/runtime/PageContextImpl, method: getELResolver signature: ()Ljavax/el/ELResolver;) Incompatible argument to

    网上大多都说是jsp版本原因: 引用: .............................................. ................................. ...