微服务相关知识复习（spring cloud 、spring cloud alibaba）

最新推荐文章于 2023-06-25 17:46:55 发布
最新推荐文章于 2023-06-25 17:46:55 发布
阅读量531 收藏
点赞数
分类专栏： 流行框架 文章标签： 微服务 中间件 springcloud CloudAlibaba
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44196561/article/details/123977034
版权

        声明：本篇主要是复习知识和熟悉各中间件作用以及大致配置流程。参考了B站上面尚硅谷的springcloud alibaba教学视频和这位同学的笔记。

最新的SpringCloud(H版&Alibaba)技术（19高级部分，熔断与限流【Sentinel】）_angenin的博客-CSDN博客

目录

Eureka

Ribbon负载均衡服务调用

RestTemplate

OpenFeign服务接口调用        

Hystrix断路器

Gateway网关

服务配置(config)与消息总线(bus)

Spring cloud Stream消息驱动

SpringCloud Alibaba Nacos服务注册和配置中心

Nacos作为配置中心

SpringCloud Alibaba Sentinel实现熔断与限流

SpringCloud Alibaba Seata处理分布式事务

Eureka、ribbon（负载均衡服务调用）、openFeign（服务调用接口）、 Hystrix(熔断、降级，监控hystrixDashboard需要搭建一个监控module)、gateway(服务网关)、spring cloud config(分布式配置中心)、springcloud bus（消息总线）、springcloud Stream消息驱动、springcloud Sleuth分布式请求链路跟踪（zipkin）、springCloud Alibaba Nacos服务注册和配置中心、spring cloud Sentinel熔断与限流、spring cloud alibaba Seata处理分布式事务。

Eureka

一、建立服务注册中心。

1)新module---pom中引入

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

 2)在resource下创建application.yml配置文件声明该module是服务注册中心

server:
  port: 7001

eureka:
  instance:
    hostname: localhost  #eureka服务端的实例名称
  client:
    #false表示不向注册中心注册自己（想注册也可以，不过没必要）
    register-with-eureka: false
    #false表示自己端就是注册中心，职责就是维护服务实例，并不需要去检索服务
    fetch-registry: false
    service-url:
      #设置与eurekaServer交互的地址查询服务和注册服务都需要依赖这个地址
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

3）主启动类上添加@EnableEurekaServer //表示此项目是eureka的服务注册中心

4）启动项目，在浏览器输入http://localhost:7001/即可进入服务注册中心界面。

二、将微服务提供者注册进Eureka。

1）引入依赖pom文件。

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

2）application.yml配置文件中配置信息

eureka:
  client:
    #true表示向注册中心注册自己，默认为true
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:7001/eureka

3）主启动类上@EnableEurekaClient注解，表示这个项目是eureka的客户端。

4）启动项目，进入Eureka注册中心界面可以查看有没有注册进去。

三、微服务消费者注册

1）引入依赖

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

2）application.yml文件

spring:
  application:
    name: cloud-order-service

eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:7001/eureka

3）启动类上加@EnableEurekaClient注解。

4）启动项目进入注册中心查看。

四、Eureka Server集群环境配置（相互注册、相互守望）

创建3个Eureka服务端（注册中心）然后互相注册。

1）7001

eureka:
  instance:
    hostname: eureka7001.com  #eureka服务端的实例名称
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
#      单机
#      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      #集群版  相互注册，相互守望
      defaultZone: http://eureka7002.com:7002/eureka/, http://eureka7003.com:7003/eureka/ 
      
#    defaultZone是固定写法，如果想自定义，需要按以下写法才行：
#    region: eureka-server
#    availability-zones:
#      eureka-server: server1,server2
#    service-url:
#      server1: http://eureka7002.com:7002/eureka/
#      server2: http://eureka7003.com:7003/eureka/

7002

eureka:
  instance:
    hostname: eureka7002.com  #eureka服务端的实例名称
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      #集群版  相互注册，相互守望
      defaultZone: http://eureka7001.com:7001/eureka/, http://eureka7003.com:7003/eureka/ #相互注册，相互守望

7003

eureka:
  instance:
    hostname: eureka7003.com  #eureka服务端的实例名称
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      #集群版  相互注册，相互守望
      defaultZone: http://eureka7001.com:7001/eureka/, http://eureka7002.com:7002/eureka/ #相互注册，相互守望

2）将服务提供者和消费者都注册进这三个Eureka中

修改他们的yml文件即可

      #集群版
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka,http://eureka7003.com:7003/eureka

3）构建服务提供者集群环境（服务名要一样）

4）服务消费者controller调用的时候需要服务提供者的服务名，然后ApplicationContextConfig里的restTemplate方法上加上@LoadBalanced，开启负载均衡功能。

在这里插入图片描述

 服务发现Discovery

获取注册进Eureka服务中心的微服务信息。

1）在服务提供者端的启动类上加@EnableDiscoveryClient。启动发现客户端

2）在controller中获取信息


    @Resource
    private DiscoveryClient discoveryClient;	//springframework的DiscoveryClient（不要导错包了）
    

    @GetMapping("/payment/discovery")
    public Object discovery(){
        //获取服务列表的信息
        List<String> services = discoveryClient.getServices();
        for (String element : services) {
            log.info("*******element：" + element);
        }

        //获取CLOUD-PAYMENT-SERVICE服务的所有具体实例
        List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
        for (ServiceInstance instance : instances) {
            //getServiceId服务器id getHost主机名称 getPort端口号  getUri地址
            log.info(instance.getServiceId() + "\t" + instance.getHost() + "\t" + instance.getPort() + "\t" + instance.getUri());
        }

        return this.discoveryClient;
    }

}

Eureka自我保护

默认90s内。超过就注销了

禁止自我保护

server端

#  client
#  	...		server与client对齐
  server:
    #关闭自我保护，默认为true
    enable-self-preservation: false
    #心跳的间隔时间，单位毫秒
    eviction-interval-timer-in-ms: 2000

client端

    #Eureka客户端向服务端发送心跳的时间间隔，单位秒（默认30秒）
    lease-renewal-interval-in-seconds: 1
    #Eureka服务端在收到最后一次心跳后等待的时间上限，单位秒（默认90秒），超时剔除服务
    lease-expiration-duration-in-seconds: 2

Ribbon负载均衡服务调用

1)pom引用

  <!--Ribbon的依赖-->
  <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
 </dependency>

RestTemplate

@LoadBalanced注解给RestTemplate开启负载均衡的能力。

有多种，轮询、随机、权重、并发量等等。默认为轮询

2）在服务提供者启动类上面加入@RibbonClient(name = "CLOUD-PAYMENT-SERVICE"）name为服务名

OpenFeign服务接口调用        

1)pom文件引入依赖，application.yml文件中配置注册中心信息等，主启动类上添@EnableFeignClients //激活feign

2）消费方服务接口上面添加@FeignClient注解即可，如果消费者自己实现了这个接口，就说明这个微服务调用不成功才执行，实现服务降级

feign:
  hystrix:
    enabled: true

//Feign封装了Ribbon和RestTemplate，实现负载均衡和发送请求
@Component
@FeignClient(value = "CLOUD-PAYMENT-SERVICE")    //作为feign的接口，找CLOUD-PAYMENT-SERVICE服务
public interface PaymentFeignService {

    //直接复制8001的方法
    @GetMapping("/payment/get/{id}")
    public CommonResult getPaymentById(@PathVariable("id") Long id);

}

在这里插入图片描述

 3）openFeign调用其他微服务接口的时候，默认只等待1s，超时异常等就执行自己的实现类，没有就报错。要么就配置超时时间多一点。

#没提示不管它，可以设置
ribbon:
  #指的是建立连接后从服务器读取到可用资源所用的时间
  ReadTimeout: 5000
  #指的是建立连接使用的时间，适用于网络状况正常的情况下，两端连接所用的时间
  ConnectTimeout: 5000

@FeignClient注解加上fallback = PaymentFallbackService.class属性，用于出错进行fallback处理。

Hystrix断路器

1）pom引入依赖。

<dependencies>
    <!-- hystrix-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    </dependency>
    <!-- 引用自己定义的api通用包，可以使用Payment支付Entity -->
    <dependency>
        <groupId>com.angenin.springcloud</groupId>
        <artifactId>cloud-api-commons</artifactId>
        <version>${project.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--监控-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!--eureka client-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <!--   一个Java工具包     -->
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.1.0</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2）注册进服务注册中心

server:
  port: 8001


spring:
  application:
    name: cloud-provider-hystrix-payment
	

eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      #单机版
      defaultZone: http://localhost:7001/eureka
      #集群版
#      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka,http://eureka7003.com:7003/eureka

3）服务降级：提供方的Service方法上加@HystrixCommand(fallbackMethod="备用方法")，启动类上加@EnableCircuitBreaker启用熔断器。

例如：超时和运行错误都可以进入备用方法。

    @HystrixCommand(fallbackMethod = "paymentInfo_TimeOutHandler", commandProperties = {
            //设置自身超时调用时间的峰值为3秒，峰值内可以正常运行，超过了需要有兜底的方法处理，服务降级fallback
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000")
    })
    public String paymentInfo_TimeOut(Integer id){
        int timeNumber = 5;
        //int i = 1 / 0;
        try {
            TimeUnit.SECONDS.sleep(timeNumber);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "线程池：" + Thread.currentThread().getName() +
                "\tpaymentInfo_TimeOut，id：" + id + "，耗时：" + timeNumber + "秒";
    }
    public String paymentInfo_TimeOutHandler(Integer id){
        return "8001提供者，线程池：" + Thread.currentThread().getName() + 
                "\tpaymentInfo_TimeOutHandler系统繁忙，请稍后再试，id：" + id;
    }

4)消费方调用服务方的方法的时候，也会出现调用不成功的现象。也需要服务降级，

application.yml文件中配置信息。主启动类上加@EnableHystrix

feign:
  hystrix:
    enabled: true

controller方法。如果是提供者那边出问题，并且消费者设置了fallback，会优先进入消费者的fallback

    @HystrixCommand(fallbackMethod = "paymentTimeOutFallbackMethod", commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1500")
    })
    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id){
        String result = paymentHystrixService.paymentInfo_TimeOut(id);
        return result;
    }
    public String paymentTimeOutFallbackMethod(@PathVariable("id") Integer id){
        return "消费者80，支付系统繁忙";
    }

5）全局fallback方法。在controller中添加通用方法。然后加上@DefaultProperties(defaultFallback = "通用备用方法名")，需要降级的方法就添加注解@HystrixCommand

    //全局fallback方法，不能有传参
    public String payment_Global_FallbackMethod(){
        return "Global异常处理信息，请稍后再试！";
    }

在这里插入图片描述

 

服务熔断（Hystrix）

Hystrix会监控微服务间的调用情况。默认5s内请求失败20次就会启动熔断机制。@HystrixCommand

服务提供方的方法

	@HystrixCommand(fallbackMethod = "paymentCircuitBreaker_fallback",commandProperties = {
        @HystrixProperty(name = "circuitBreaker.enabled", value = "true"),                      //开启断路器
        @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),         //请求总数阈值（默认20）
        @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "10000"),   //休眠时间窗口期（休眠多久进入半开模式（单位毫秒，默认5秒））
        @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "60"),       //请求次数的错误率达到多少跳闸（百分率%，默认50%）
})
    public String paymentCircuitBreaker(@PathVariable("id") Integer id) {
        if(id < 0){
            throw  new RuntimeException("****id 不能为负数");
        }
        String serialNumber = IdUtil.simpleUUID();

        return  Thread.currentThread().getName() + "\t" + "调用成功，流水号：" + serialNumber;
    }
    public String paymentCircuitBreaker_fallback(@PathVariable("id") Integer id){
        return "id 不能为负数,请稍后再试， id: " + id;
    }

Gateway网关

Route（路由）

Predicate(断言)：用来匹配http请求中的内容，相匹配则进行路由。

Filter(过滤)

1）pom引入jar

<dependencies>
    <!--gateway-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <!--eureka client(通过微服务名实现动态路由)-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2)注册

server:
  port: 9527

spring:
  application:
    name: cloud-gateway

eureka:
  instance:
    hostname: cloud-gateway-service
  client:
    fetch-registry: true
    register-with-eureka: true
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/

3）主启动类@EnableEurekaClient

4)对需要进行路由网关的服务的进行配置（在当前yml中，也可以用配置类）

server:
  port: 9527

spring:
  application:
    name: cloud-gateway
  cloud:
    gateway:
      routes:
        - id: payment_route # 路由的id,没有规定规则但要求唯一,建议配合服务名
          #匹配后提供服务的路由地址
          uri: http://localhost:8001
          predicates:
            - Path=/payment/get/** # 断言，路径相匹配的进行路由

        - id: payment_route2
          uri: http://localhost:8001
          predicates:
            - Path=/payment/lb/** #断言,路径相匹配的进行路由

eureka:
  instance:
    hostname: cloud-gateway-service
  client:
    fetch-registry: true
    register-with-eureka: true
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/

服务配置(config)与消息总线(bus)

spring cloud config:分布式配置中心，bootstrap比application优先级要高。

congfig端：

server:
  port: 3344


spring:
  application:
    name: cloud-config-center #注册进Eureka服务器的微服务名
  cloud:
    config:
      server:
        git:
          uri: https://github.com/angenin/springcloud-config.git  #git的仓库地址
          search-paths:   #搜索目录
            - springcloud-config
      label: master   #读取的分支


eureka:
  client:
    service-url: 
      defaultZone: http://localhost:7001/eureka   #服务注册到的eureka地址

微服务端

server:
  port: 3355


spring:
  application:
    name: config-client
  cloud:
    config: #config客户端配置
      label: master   #分支名称
      name: config    #配置文件名称       这三个综合：master分支上的config-dev.yml的配置文件
      profile: dev    #读取后缀名称       被读取到http://config-3344.com:3344/master/config/dev
      uri: http://localhost:3344  #配置中心地址


eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka   #服务注册到的eureka地址

测试controller

@RestController
public class ConfigClientController {

    @Value("${config.info}")	//spring的@Value注解
    private String configInfo;

    @GetMapping("/configInfo")
    public String getConfigInfo(){
        return configInfo;
    }

}

动态刷新的话微服务端需要被访问通知一次才更新，需要结合消息总线（此时用RabbitMQ）

服务端

pom

  <!--添加消息总线RabbitMQ的支持-->
  <dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-starter-bus-amqp</artifactId>
 </dependency>

yml

  rabbitmq:
    host: 10.211.55.17  #本机写localhost，服务器的写服务器地址
    port: 5672   #客户端和RabbitMQ进行通信的端口
    username: guest #默认也是guest
    password: guest #默认也是guest


#RabbitMQ相关配置
management:
  endpoints:  #暴露bus刷新配置的端点
    web:
      exposure:
        include: 'bus-refresh'

在这里插入图片描述

客户端

  <!--添加消息总线RabbitMQ的支持-->
  <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-bus-amqp</artifactId>
  </dependency>

 

  rabbitmq:
    host: 10.211.55.17  #本机写localhost，服务器的写服务器地址
    port: 5672   #客户端和RabbitMQ进行通信的端口
    username: guest #默认也是guest
    password: guest #默认也是guest

在这里插入图片描述

 

Spring cloud Stream消息驱动

用来屏蔽消息中间件MQ（目前是RabbitMQ和Kafka）的底层差异，降低切换成本。

分组消费：得把消费方绑定成一个组,group不然会有重复消费

持久化：没组的重启后不会消费。有组的才会消费

 

消息生成者

<dependencies>
    <!--stream rabbit -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
    </dependency>
    <!--eureka client-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--监控-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!--热部署-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

server:
  port: 8801

spring:
  application:
    name: cloud-stream-provider
  cloud:
    stream:
      binders: #在此处配置要绑定的rabbitmq的服务信息
        defaultRabbit: #表示定义的名称，用于binding整合
          type: rabbit #消息组件类型
          environment: #设置rabbitmq的相关环境配置
            spring:
              rabbitmq:
                host: 10.211.55.17  #RabbitMQ在本机的用localhost，在服务器的用服务器的ip地址
                port: 5672
                username: guest
                password: guest
      bindings: #服务的整合处理
        output: #这个名字是一个通道的名称
          destination: studyExchange #表示要使用的Exchange名称定义
          content-type: application/json #设置消息类型，本次为json，本文要设置为“text/plain”
          binder: defaultRabbit #设置要绑定的消息服务的具体设置（爆红不影响使用，位置没错）

eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
    lease-renewal-interval-in-seconds: 2 #设置心跳的时间间隔（默认是30S)
    lease-expiration-duration-in-seconds: 5 #如果超过5S间隔就注销节点 默认是90s
    instance-id: send-8801.com #在信息列表时显示主机名称
    prefer-ip-address: true #访问的路径变为IP地址

发送消息的方法：

import com.angenin.springcloud.service.IMessageProvider;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.messaging.Source;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.messaging.MessageChannel;
import javax.annotation.Resource;
import java.util.UUID;

@EnableBinding(Source.class)    //定义消息的推送管道（Source是spring的）
public class IMessageProviderImpl implements IMessageProvider {

    @Resource
    private MessageChannel output;  //消息发送管道

    @Override
    public String send() {
        String serial = UUID.randomUUID().toString();
        output.send(MessageBuilder.withPayload(serial).build());     //MessageBuilder是spring的integration.support.MessageBuilder
        System.out.println("*******serial: " + serial);
        return null;
    }
}

消息消费方

<dependencies>
    <!--stream rabbit -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
    </dependency>
    <!--eureka client-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--监控-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!--热部署-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

server:
  port: 8802

spring:
  application:
    name: cloud-stream-provider
  cloud:
    stream:
      binders: #在此处配置要绑定的rabbitmq的服务信息
        defaultRabbit: #表示定义的名称，用于binding整合
          type: rabbit #消息组件类型
          environment: #设置rabbitmq的相关环境配置
            spring:
              rabbitmq:
                host: 10.211.55.17  #RabbitMQ在本机的用localhost，在服务器的用服务器的ip地址
                port: 5672
                username: guest
                password: guest
      bindings: #服务的整合处理
        input: #这个名字是一个通道的名称
          destination: studyExchange #表示要使用的Exchange名称定义
          content-type: application/json #设置消息类型，本次为json，本文要设置为“text/plain”
          binder: defaultRabbit #设置要绑定的消息服务的具体设置（爆红不影响使用，位置没错）

eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
    lease-renewal-interval-in-seconds: 2 #设置心跳的时间间隔（默认是30S)
    lease-expiration-duration-in-seconds: 5 #如果超过5S间隔就注销节点 默认是90s
    instance-id: receive-8802.com #在信息列表时显示主机名称
    prefer-ip-address: true #访问的路径变为IP地址

消费方法（配置的时候和需要监听的管道绑定，这两个用的是studyExchange）

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.annotation.StreamListener;
import org.springframework.cloud.stream.messaging.Sink;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Controller;


@EnableBinding(Sink.class)
@Controller
public class ReceiveMessageListenerController {

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

    @StreamListener(Sink.INPUT) //监听
    public void input(Message<String> message){
        System.out.println("消费者1号------>收到的消息：" + message.getPayload() + "\t port：" + serverPort);
    }

}

SpringCloud Sleuth分布式请求链路追踪

就是zipkin。参照官网配置一下即可。

Spring Cloud Sleuth

SpringCloud Alibaba Nacos服务注册和配置中心

官网：home

下载安装运行。浏览器ip+端口（如10.211.55.17:8848/nacos/）进入nacos主页。账号秘密都是nacos。

服务方：

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

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

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

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

application.yml

server:
  port: 9001


spring:
  application:
    name: nacos-payment-provider
  cloud:
    nacos:
      discovery:
        server-addr: 10.211.55.17:8848  #配置的Nacos地址（本机的写localhost:8848，服务器的写IP地址）


management:
  endpoints:
    web:
      exposure:
        include: '*'

@EnableDiscoveryClient
@SpringBootApplication
public class PaymentMain9001 {

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

}

消费方

<dependencies>
    <!--SpringCloud Alibaba nacos-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <!-- 引用自己定义的api通用包，可以使用Payment支付Entity -->
    <dependency>
        <groupId>com.angenin.springcloud</groupId>
        <artifactId>cloud-api-commons</artifactId>
        <version>${project.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

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

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

server:
  port: 83


spring:
  application:
    name: nacos-order-consumer
  cloud:
    nacos:
      discovery:
        server-addr: 10.211.55.17:8848  #配置的Nacos地址（本机的写localhost:8848，服务器的写IP地址）


#消费者要访问的微服务名称（成功注册进nacos的服务提供者）
service-url:
  nacos-user-service: http://nacos-payment-provider

@EnableDiscoveryClient
@SpringBootApplication
public class OrderNacosMain83 {

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

}

@Configuration
public class ApplicationContextConfig {
 
    @Bean
@LoadBalanced //不能忘记添加这个负载均衡的注解
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
 
}

整合Feign

1)引入pom

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

2)在主启动类上加上@EnableFeignClients，激活feign。

3)注释掉config配置类的@Configuration注解，不使用RestTemplate。

4)新建Service接口.注入进controller调用就行了。        

@Component
@FeignClient(value = "nacos-payment-provider")
public interface PaymentFeignService {

    @GetMapping("/payment/nacos/{id}")
    public String getPayment(@PathVariable("id") Integer id);

}

Nacos作为配置中心

1)pom

<dependencies>
    <!-- nacos config-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
    <!-- openfeign -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    <!--SpringCloud Alibaba nacos-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

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

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2)boostrap.yml和application.yml

server:
  port: 3377

spring:
  application:
    name: nacos-config-client
  cloud:
    nacos:
      discovery:
        server-addr: 10.211.55.17:8848 #Nacos服务注册中心地址（本机的写localhost）
      config:
        server-addr: 10.211.55.17:8848 #Nacos作为配置中心地址（本机的写localhost）
        file-extension: yml #指定yml格式配置

spring:
  profiles:
    active: dev #表示开发环境

3)主启动类

@EnableDiscoveryClient
@SpringBootApplication
public class NacosConfigClientMain3377 {

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

}

4）controller

@RefreshScope   //支持Nacos的动态刷新功能
@RestController
public class ConfigClientController {

    @Value("${config.info}")
    private String configInfo;


    @GetMapping("/config/info")
    public String getConfigInfo(){
        return configInfo;
    }

}

在这里插入图片描述

要配置的话进入nacos主页点点点就行了

在这里插入图片描述 

分类配置：新建配置，根据Group来实现环境区分，要用的时候就在bootstrap文件中指定group.什么dev了，test了。

在这里插入图片描述 

 在这里插入图片描述

在这里插入图片描述 

Nacos集群和持久化配置

Nacos支持三种部署模式 

集群部署说明

参考：在Docker上用3个Nacos1.3容器+一个MySQL5和8容器+一个Nginx容器进行集群的具体操作（Nacos集群版）_angenin的博客-CSDN博客

SpringCloud Alibaba Sentinel实现熔断与限流

官网：https://github.com/alibaba/Sentinel/wiki/%E4%BB%8B%E7%BB%8D

具体步骤参考：

最新的SpringCloud(H版&Alibaba)技术（19高级部分，熔断与限流【Sentinel】）_angenin的博客-CSDN博客

SpringCloud Alibaba Seata处理分布式事务

官网：Seata

调用微服务的service方法上面加@GlobalTransactional

    //name随便命名，只要不重复即可
 	//rollbackFor = Exception.class表示出现所有异常都回滚
    //rollbackFor表示哪些需要回滚
    //noRollbackFor表示哪些不需要回滚
    @GlobalTransactional(name = "fsp-create-order", rollbackFor = Exception.class)

在这里插入图片描述

1） pom

<dependencies>
    <!-- nacos -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <!-- seata-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
        <exclusions>
            <exclusion>
                <groupId>io.seata</groupId>
                <artifactId>seata-all</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>io.seata</groupId>
        <artifactId>seata-all</artifactId>
        <version>1.2.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
            <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!--jdbc-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

yml  

server:
  port: 2001

spring:
  application:
    name: seata-order-service
  cloud:
    alibaba:
      seata:
        # 自定义事务组名称需要与seata-server中的对应
        tx-service-group: my_test_tx_group #因为seata的file.conf文件中没有service模块，事务组名默认为my_test_tx_group
        #service要与tx-service-group对齐，vgroupMapping和grouplist在service的下一级，my_test_tx_group在再下一级
        service:
          vgroupMapping:
            #要和tx-service-group的值一致
            my_test_tx_group: default
          grouplist:
            # seata seaver的 地址配置，此处可以集群配置是个数组
            default: 10.211.55.26:8091
    nacos:
      discovery:
        server-addr: 10.211.55.26:8848  #nacos
  datasource:
    # 当前数据源操作类型
    type: com.alibaba.druid.pool.DruidDataSource
    # mysql驱动类
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://10.211.55.26:3305/seata_storage?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8
    username: root
    password: 123456
feign:
  hystrix:
    enabled: false
logging:
  level:
    io:
      seata: info

mybatis:
  mapperLocations: classpath*:mapper/*.xml

失忆机器
关注
专栏目录
阿里巴巴资深架构师深度解析微服务架构设计之SpringCloud+Dubbo
m0_63437643的博客
12-11 1344
微服务软件架构是一个包含各种组织的系统组织，这些组件包括Web服务器，应用服务器,数据库，存储，通讯层)，它们彼此或和环境存在关系。系统架构的目标是解决利益相关者的关注点。​编辑切换为居中添加图片注释，不超过 140 字（可选）什么是微服务架构微服务架构优势独立部署，由于微服务具备独立的运行进程，所以每个微服务也可以独立部署。当某个微服务发生变更时无需编译、部署整个应用。由微服务组成的应用相当于具备一系列可并行的发布流程，使得发布更加高效，同时降低对生产环境所造成的风险，最终缩短应用交付周期。
微服务总复习
weixin_43762083的博客
03-19 809
Day01~微服务架构入门 核心知识点 微服务架构诞生的背景(软件即服务，将一个大型软件，拆成若干个小系统；分而治之~北京一个火车站到多个火车站) 微服务架构解决方案(大厂基本自研~自己研发各种组件,中小公司用Spring Cloud Netflix,Alibaba,…) 微服务架构下Maven聚合项目的创建方式?(Maven聚合项目~资源复用:extends,import,简化编译,打包,部署方式) 微服务架构入门聚合项目创建?(01-sca,sca-consumer
微服务复习
weixin_43762083的博客
12-30 323
什么是微服务 就是把大系统拆分为很多小系统，几个人负责一个服务这样 ，每个服务独立的开发、测试和上线， 代码冲突少 ，每次上线就回归测试自己的一个服务即可 ，只要向后兼容接口就行了，不需要跟别人等待和协调 。 SpringCloud Alibaba微服务解决方案 Spring Cloud Alibaba 是Spring Cloud的一个子项目 核心组件分析 服务注册与发现： 基于Spring Cloud 服务注册与发现标准，借助Nacos进行实现 分布式配置管理： 基于Nacos支持分布式系统中
springboot--springCloud--微服务--思考、实现的复习
fhzheng for c java javascript sql html css
05-16 219
SpringCloud的目的 将一个大的系统进行拆分，成为多个子系统 然后通过RESTful风格的请求将它们集成起来 进一步简化分布式系统的开发 SpringBoot的目的 简化Spring应用的共搭建以及开发过程 约定优于配置【Spring4.x已经可以完全脱离xml配置方式，全部用注解来搞定】 特点： 内嵌服务器 大量的默认约定 属性文件 大量的自定义配置 打包更容易 测试更容易 分布...
Spring Cloud微服务复习笔记总结
weixin_48826306的博客
12-08 257
Spring Cloud微服务 微服务架构4个核心问题？ 服务很多，客户端该怎么访问？ 这么多服务？服务之间如何通信？ 这么多服务？如何治理？ 服务挂了怎么办？ 解决方案： Spring Cloud 生态！ Spring Cloud NetFlix （一站式解决方案） api网关，zuul组件 Feign ----HttpClient---- Http通信方式，阻塞 服务注册与发现：Eureka 熔断机制：Hystrix Apache Dubbo zookeeper （半自动，需要整合
基于Spring Boot 3.0、 Spring Cloud 2022 & Alibaba 的微服务RBAC 权限管理系统
05-31
同时，该系统还具备其他强大的功能，如基于Spring Boot 3.0的快速开发能力、基于Spring Cloud的分布式微服务架构，以及与Alibaba相关的云服务集成能力。总体而言，这个系统是一个高效、安全、可扩展的现代化管理系统...
详解Spring Cloud Alibaba Sidecar多语言微服务异构
08-25
Spring Cloud Alibaba Sidecar 是一个为实现多语言微服务异构集成而设计的组件。自版本 2.1.1 开始，它作为一个代理服务，允许非 Java 的微服务也能利用 Spring Cloud Alibaba 的功能，比如 Nacos 注册发现、...
Java-spring cloud alibaba 微服务单点登录及组件配置学习源码
04-23
本资源“Java-spring cloud alibaba 微服务单点登录及组件配置学习源码”是专为初学者设计的，旨在帮助他们快速理解和实践微服务中的单点登录（SSO）机制，以及如何配置相关组件。 首先，让我们深入了解Spring ...
【附答案解析】最常⻅的 SpringCloud 微服务⾯试题（VIP典藏版）
06-06
Spring Cloud微服务⾯试题 1. Spring Cloud Netflix 和 Spring Cloud Alibaba 包括哪些组件 2. Nacos是CP还是AP? 3. Nacos作为注册中⼼应该选择是CP还是AP？ 4. Nacos如何实现就近访问？ 5. Nacos底层负载均衡...
微服务Spring Cloud学习重点整理
coolpan123的博客
12-13 502
Spring Boot 集成开框架 Spring Cloud 是一个基于Java语言的工具套件 Spring initializr 快速生成想要的项目 http://start.spring.io  Eureka 实现服务的注册与发现 Spring Boot Actuator 提供服务的监控端点功能 Ribbon 实现客户端的负载均衡 Feign 实现客户端 rest 调用 Hy
微服务学习笔记
sinat_34979820的博客
08-27 776
微服务学习笔记微服务学习笔记开始吧微服务1.什么是微服务架构2.什么是微服务3.微服务优缺点4.微服务技术栈有哪些SpringCloud1.为什么选择SpringCloud2.SpringCloud是什么3.SpringCloud和SpringBoot的区别与关系 微服务学习笔记 开始吧 微服务 1.什么是微服务架构 微服务架构是一种架构模式或者说是一种架构风格，它提倡将单一应用程序划分成一组小的服务，每个服务运行在其独立的自己的进程中，服务之间互相协调、互相配合，为用户提供最终价值。服务之间采用轻量级的通
微服务期末复习练习
最新发布
lmy21的博客
06-25 759
微服务期末复习文档的简单总结，当作复习记忆使用。
微服务的一些知识点梳理
强颜欢笑
09-07 3346
摘要：大概解释了什么是rpc以及rpc的注意事项，还有各个rpc框架 RPC(Remote Procedure Call)，远程过程调用。在先介绍远程过程调用之前，先介绍一下什么是本地调用，形象点说，就是你想次饭，然后自己去厨房做了个饭，远程过程调用就是你打开饿了么，订了个外卖，厨师去厨房给你做了个饭，这么说，是不是很容易理解。 个人理解，rpc的起源为分布式，是分布式促使了rpc的诞生。 ...
微服务知识点总复习
ANNNNNNNNNNNNN的博客
06-11 594
微服务
SpringCloud Gateway日志唯一流水号优化
laomei
12-08 1046
实现SpringCloud Gateway每笔请求日志唯一流水号。
SpringCloud Gateway打印请求、响应内容和唯一流水号配置
laomei
11-29 4049
SpringCloudGateway默认不打印请求和响应body，对于问题排查非常不友好。通过以下方式打印请求和响应body,header等内容。 实现自定义netty handler，转发请求和接受响应内容时打印请求内容。 package xxx import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelDuplexHandler; import io.netty.channel.ChannelHandlerContext; impor
关于org.springframework.cloud的spring-cloud-alibaba-dependencies版本问题
热门推荐
he_sk的博客
08-28 1万+
spring-cloud-alibaba-dependencies管理的nacos最新版本是0.9.0.RELEASE，貌似不再维护了，用起来可能会对有版本问题。 如果要使用nacos比较新的版本，需要修改依赖，修改后： <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-alibaba-dependencies</artifactId> &l
Spring Cloud分布式框架：微服务实践与SpringCloud Alibaba选择
Spring Cloud与Spring Cloud Alibaba是微服务开发的强大组合，通过结合Nacos等组件，开发者能够有效地构建、管理并扩展分布式系统，提高开发效率和系统稳定性。在选择和使用过程中，需要根据实际项目需求和组件的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

失忆机器

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值