SpringCloud核心组件依赖及相关配置

SpringCloud核心组件依赖及相关配置文件解析

1.Eureka

Spring-Cloud Euraka是Spring Cloud集合中一个组件，它是对Euraka的集成，用于服务注册和发现。Eureka是Netflix中的一个开源框架，Eureka模块来实现服务治理。在传统的RPC远程调用中，管理每个服务于服务之间依赖关系复杂，管理复杂，所以需要使用服务治理，管理服务于服务之间依赖关系，可以实现服务调用、负载均衡、容错等，实现服务发现与注册。

核心依赖包

 
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-netflix-eureka-serverartifactId>
    dependency>

相关其他依赖

    
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
    
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-actuatorartifactId>
    dependency>

核心配置文件

server:
  port: 7001 #端口号
eureka:
  instance:
    hostname: eureka7001.com #eureka服务端的实例名称
  client:
    register-with-eureka: false     #false表示不向注册中心注册自己。
    fetch-registry: false     #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url:
      #设置与eureka  server交互的地址和注册服务都需要依赖这个地址
      defaultZone: http://eureka7001.com:7001/eureka/  #集群就是指向其他的eureka

2.OpenFegin

核心依赖

 	
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-openfeignartifactId>
        dependency>

核心配置文件

设置Feign客户端超时时间

#设置feign客户端超时时间（OpenFeign默认支持ribbon）
ribbon:
  #指的是建立连接所用的时间，适用于网络状况正常的情况下，两端连接所用的实际
  ReadTimeout: 5000
  #指的是建立连接后从服务器读取到可用资源所用的时间
  ConnectTimeout: 5000

Feign日志设置

Feign提供了日志打印功能，通过yml配置文件来调整日志级别，可以通过日志了解Http请求的细节，实际上这就是对Feign接口的调用情况进行监控和输出。

NONE：默认级别，不显示任何日志
BASIC：仅记录请求方法、URL、相应状态码和执行时间
HEADERS：除了BASIC中定义的信息之外，还有请求和响应的头信息
FULL：除了HEADERS中定义的信息之外，还有请求和响应的征文及元数据

1.创建Config类

@Configuration
public class FeignConfig {
    @Bean
    Logger.Level feignLoggerLevel() {
        return Logger.Level.FULL;
    }
}

2.配置yml文件

logging:
  level:
    #feign日志以什么级别监控那个接口
    com.my.springcloud.service.PaymentFeignService: debug

3.springcloud-Gateway

在为微服务架构提供一种简单而有效的统一的API路由管理方式，例如：安全，监控/埋点，和限流。

Route(路由)：这是网关的基本构建块，它由一个ID，一个URI，一组断言和一组过滤器定义。如果断言为真，则路由匹配。

Predicate（断言）：输入类类是一个ServerWebExchange。我们可以使用它来匹配来自HTTP请求的任何内容，例如headers。如果请求与断言相匹配则进行路由。

客户端向Spring Cloud Gateway发出请求，然后在Gateway Hander Mapping中找到与请求相匹配的路由，将其发送到Gateway Web Handler。

Handler在通过指定的过滤器链来将请求发送到我们实际的服务业务逻辑，然后返回。过滤器之间用虚线分是因为过滤器可能会在发送代理请求之间（“pre”）或之后(“post”)执行业务逻辑

Filter（过滤器）：Spring框架中GatewayFilter的实例，使用过滤器，可以在请求被路由前或者后对请求进行修改。

核心依赖

<dependency>
    <groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-starter-gatewayartifactId>
dependency>

配置文件

server:
 port: 9527
spring:
 application:
  name: cloud-gateway
  eureka:
  instance:
    hostname: cloud-gateway-service
  client: #服务提供者provider注册进eureka服务列表内
    service-url:
      register-with-eureka: true
      fetch-registry: true
      defaultZone: http://eureka7001.com:7001/eureka

4.Ribbon(负载均衡)

核心依赖

<dependency>
   <groupId>org.springframework.cloudgroupId>
   <artifactId>spring-cloud-starter-ribbonartifactId>
dependency>

<dependency>
   <groupId>org.springframework.cloudgroupId>
   <artifactId>spring-cloud-starter-netflix-ribbonartifactId>
dependency>

<dependency>
   <groupId>org.springframework.cloudgroupId>
   <artifactId>spring-cloud-starter-netflix-eureka-serverartifactId>
dependency>

<dependency>
   <groupId>org.springframework.cloudgroupId>
   <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
dependency>

核心配置参数

# 禁用 Eureka
ribbon.eureka.enabled=false
# 禁用 Eureka 后手动配置服务地址
ribbon-config-demo.ribbon.listOfServers=localhost:8081,localhost:8083
# 最大连接数
ribbon.MaxTotalConnections=500
# 每个host最大连接数
ribbon.MaxConnectionsPerHost=500
# 请求连接的超时时间
ribbon.ConnectTimeout=2000
# 请求处理的超时时间
ribbon.ReadTimeout=5000
 
#也可以为每个Ribbon客户端设置不同的超时时间, 通过服务名称进行指定：
ribbon-config-demo.ribbon.ConnectTimeout=2000
ribbon-config-demo.ribbon.ReadTimeout=5000
#不指定Ribbon默认使用轮询进行重试
feign-client.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RetryRule
 
# 在所有HTTP Method进行重试
feign-client.ribbon.OkToRetryOnAllOperations=true
 
# 每台机器最大重试次数
feign-client.ribbon.MaxAutoRetries=2
 
# 可以再重试几台机器
feign-client.ribbon.MaxAutoRetriesNextServer=2

ribbon.ReadTimeout=1000 
#处理请求的超时时间，默认为1秒

ribbon.ConnectTimeout=1000 
#连接建立的超时时长，默认1秒

ribbon.MaxAutoRetries=1 
#同一台实例的最大重试次数，但是不包括首次调用，默认为1次

ribbon.MaxAutoRetriesNextServer=0 
#重试负载均衡其他实例的最大重试次数，不包括首次调用，默认为0次

ribbon.OkToRetryOnAllOperations=false 
#是否对所有操作都重试，默认false

5.Hystrix

核心依赖

<dependency>
   <groupId>org.springframework.cloudgroupId>
   <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
dependency>
<dependency>
     <groupId>org.springframework.cloudgroupId>
     <artifactId>spring-cloud-starter-netflix-eureka-client
     artifactId>
dependency>

<dependency>
　　<groupId>org.springframework.cloudgroupId>
　　<artifactId>spring-cloud-starter-hystrixartifactId>
dependency>

核心配置参数

Execution相关的属性的配置：

# 隔离策略，默认是Thread, 可选Thread｜Semaphore
hystrix.command.default.execution.isolation.strategy=THREAD
#命令执行超时时间，默认1000ms，只在线程池隔离中有效。
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=1000
# 执行是否启用超时，默认启用true，只在线程池隔离中有效。
hystrix.command.default.execution.timeout.enabled=true
# 发生超时是是否中断，默认true，只在线程池隔离中有效。
hystrix.command.default.execution.isolation.thread.interruptOnTimeout=true
# 最大并发请求数，默认10，该参数当使用ExecutionIsolationStrategy.SEMAPHORE策略时才有效。如果达到最大并发请求数，请求会被拒绝。
# 理论上选择semaphore的原则和选择thread一致，但选用semaphore时每次执行的单元要比较小且执行速度快（ms级别），否则的话应该用thread。
# semaphore应该占整个容器（tomcat）的线程池的一小部分。
hystrix.command.default.execution.isolation.semaphore.maxConcurrentRequests=10
# 如果并发数达到该设置值，请求会被拒绝和抛出异常并且fallback不会被调用。默认10。
# 只在信号量隔离策略中有效，建议设置大一些，这样并发数达到execution最大请求数时，会直接调用fallback，而并发数达到fallback最大请求数时会被拒绝和抛出异常。
hystrix.command.default.fallback.isolation.semaphore.maxConcurrentRequests=10

ThreadPool 相关参数

# 并发执行的最大线程数，默认10
hystrix.threadpool.default.coreSize=10
# BlockingQueue的最大队列数，当设为-1，会使用SynchronousQueue，值为正时使用LinkedBlcokingQueue。
# 该设置只会在初始化时有效，之后不能修改threadpool的queue size，除非reinitialising thread executor。默认-1。
hystrix.threadpool.default.maxQueueSize=-1
# 即使maxQueueSize没有达到，达到queueSizeRejectionThreshold该值后，请求也会被拒绝。
hystrix.threadpool.default.queueSizeRejectionThreshold=20
# 线程存活时间，单位是分钟。默认值为1。
hystrix.threadpool.default.keepAliveTimeMinutes=1

Fallback相关的属性

# 当执行失败或者请求被拒绝，是否会尝试调用fallback方法 。默认true 
hystrix.command.default.fallback.enabled=true

Circuit Breaker相关的属性

 # 是否开启熔断器。默认true 
hystrix.command.default.circuitBreaker.enabled=true 
# 一个rolling window内最小的请求数。如果设为20，那么当一个rolling window的时间内（比如说1个rolling window是10毫秒）收到19个请求
# 即使19个请求都失败，也不会触发circuit break。默认20
hystrix.command.default.circuitBreaker.requestVolumeThreshold=20
# 触发短路的时间值，当该值设为5000时，则当触发circuit break后的5000毫秒内都会拒绝远程服务调用，也就是5000毫秒后才会重试远程服务调用。默认5000
hystrix.command.default.circuitBreaker.sleepWindowInMilliseconds=5000
# 错误比率阀值，如果错误率>=该值，circuit会被打开，并短路所有请求触发fallback。默认50
hystrix.command.default.circuitBreaker.errorThresholdPercentage=50
# 强制打开熔断器
hystrix.command.default.circuitBreaker.forceOpen=false
# 强制关闭熔断器
hystrix.command.default.circuitBreaker.forceClosed=false

6.SpringCloudBus

使用轻量级的消息代理来构建一个共用的消息主题，并让系统中所有微服务实例都连接上来，由于该主题中产生的消息会被所有实例监听和消费

核心依赖

<dependency>
	<groupId>org.springframework.cloudgroupId>
	<artifactId>spring-cloud-starter-bus-amqpartifactId>
dependency>

配置文件

# RabbitMQ相关配置
spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
# 暴露总线刷新配置的端点  
management:
  endpoints:
    web:
      exposure:
        include: 'bus-refresh'

属性名	默认值	说明
spring.cloud.bus.ack.destination-service		想要听ack的服务。默认为null（表示所有服务）。
spring.cloud.bus.ack.enabled	true	标志关闭acks（默认打开）。
spring.cloud.bus.destination	springCloudBus	名称Spring Cloud消息的流目的地。
spring.cloud.bus.enabled	true	标志表示总线已启用。
spring.cloud.bus.env.enabled	true	标志关闭环境变化事件（默认为开）。
spring.cloud.bus.refresh.enabled	true	关闭刷新事件的标志（默认为开）。
spring.cloud.bus.trace.enabled	false	打开acks跟踪的标志（默认关闭）。

7.SpringConfig

Spring Cloud Config为微服务架构中的微服务提供了集中化的外部配置支持，配置服务器为各个不同的微服务应用的所有环境提供了中心的化额外部配置。

为分布式系统中的基础设施和微服务提供集中化的外部配置支持，分为服务端和客户端两个部分。

核心依赖

 
<dependency>
     <groupId>org.springframework.cloudgroupId>
     <artifactId>spring-cloud-config-serverartifactId>
dependency>
 
 <dependency>
     <groupId>org.springframework.cloudgroupId>
     <artifactId>spring-cloud-starter-configartifactId>
dependency>

核心配置

server:
  port: 3344 #端口号
spring:
  application:
    name: cloud-config-server #设置服务名称
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/xing-hen/springcloud_config.git 	#配置Git仓库的地址
          #配置仓库路径下的相对搜索位置，可以配置多个
          search-paths: config-file
          #这里配置你的Git仓库的用户名
          username: xing-hen
          #这里配置你的Git仓库的密码
          password: li20010719
  rabbitmq:
    host: 192.168.78.188 #访问地址
    port: 5672 #端口号
    username: guest #rabbitMq 用户名
    password: guest #rabbitMq 密码
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka

8.Consul

Consul是一个服务网格（微服务间的 TCP/IP，负责服务之间的网络调用、限流、熔断和监控）解决方案，它是一个一个分布式的，高度可用的系统，而且开发使用都很简便。它提供了一个功能齐全的控制平面，主要特点是：服务发现、健康检查、键值存储、安全服务通信、多数据中心。

核心依赖

<dependency>
    <groupId>org.springframework.cloudgroupId>
     <artifactId>spring-cloud-starter-consul-discoveryartifactId>
dependency>

配置文件

server:
  # consul服务端口
  port: 8004
spring: 
  application:
    name: cloud-provider-payment #服务名称
  cloud:
    consul:
      # consul注册中心地址
      host: localhost
      port: 8500
      discovery:
        #hostname: 127.0.0.1
        service-name: ${spring.application.name}

9.Stream

SpringCloud Stream是一个构件消息驱动微服务的框架。应用程序通过inputs和outputs来与SpringCloud Stream中的绑定器（binder）对象交互，通过配置来绑定，而SpringCloud Stream的绑定器对象负责与消息中间件交互，所以，我们只需要搞清楚如何与SpringCloud Stream交互就可以方便使用消息驱动的方式。但是截至到目前时间，SpringCloud Stream目前仅支持RabbitMQ和Kafka

核心依赖

<dependency>
	<groupId>org.springframework.cloudgroupId>
	<artifactId>spring-cloud-starter-stream-rabbitartifactId>
dependency>

配置文件

server:
  port: 8801 #端口号
spring:
  application:
    name: cloud-stream-provider #服务名
  cloud:
    stream:
      binders: # 在此处配置要绑定的rabbitmq的服务信息；
        defaultRabbit: # 表示定义的名称，用于于binding整合
          type: rabbit # 消息组件类型
          environment: # 设置rabbitmq的相关的环境配置
            spring:
              rabbitmq:
                host: localhost
                port: 5672
                username: guest
                password: guest
      bindings: # 服务的整合处理
        output: # 这个名字是一个通道的名称，OUTPUT表示这是消息的发送方
          destination: testExchange # 表示要使用的Exchange名称定义
          content-type: application/json # 设置消息类型，本次为json，文本则设置“text/plain”
          binder: defaultRabbit # 设置要绑定的消息服务的具体设置
eureka:
  client: # 客户端进行Eureka注册的配置
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
  instance:
    lease-renewal-interval-in-seconds: 2 # 设置心跳的时间间隔（默认是30秒）
    lease-expiration-duration-in-seconds: 5 # 如果现在超过了5秒的间隔（默认是90秒）
    instance-id: send-8801.com  # 在信息列表时显示主机名称
    prefer-ip-address: true     # 访问的路径变为IP地址

而在消息驱动的消费者配置文件中同消息生产者几乎一致只需要注意

spring:
  cloud:
      bindings: 
        input: # 这个名字是一个通道的名称，INPUT表示消息消费者

10.Sleuth

Sleuth 提供了一套完整的服务跟踪的解决方案，在分布式系统中提供了追踪解决方案并且兼容支持了zipkin，SpringCloud Sleuth负责对微服务调用链路的收集整理，而zipkin负责对链路的展现。

在分布式链路跟踪中有两个重要的概念：跟踪（trace）和 跨度（ span）。trace 是请求在分布式系统中的整个链路视图，span 则代表整个链路中不同服务内部的视图，span 组合在一起就是整个 trace 的视图。 通过在访问日志和业务日志里记录的traceid、spanid 和 pspanid 能完整的还原出整个请求的调用链路视图，对错误排查能起到很大的帮助

zipkin

Zipkin是一个分布式跟踪系统。它有助于收集解决服务体系结构中的延迟问题所需的时序数据。功能包括该数据的收集和查找

核心依赖

<dependency>
    <groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-starter-sleuthartifactId>
dependency>
<dependency>
    <groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-sleuth-zipkinartifactId>
dependency>

<dependency>
   	<groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-starter-zipkinartifactId>
dependency>

配置文件

server:
  port: 80
spring:
  application:
    name: mcroservice-order  #服务名
  zipkin:
    base-url: http://localhost:9411 #指定zipkin server的地址
    sleuth:
      sampler:
        # 采样率值介于0到1之间，1表示全部采集
        probability: 1 #设置请求监控抽样百分比(0%-100%)，意思就是不可能所有的请求数据都发送给链路监控系统，这样会耗费系统性能

logback-spring.xml

<configuration>
    <include resource="org/springframework/boot/logging/logback/defaults.xml" />

<springProperty scope="context" name="springAppName"
                source="spring.application.name" />
 

<property name="LOG_FILE" value="${BUILD_FOLDER:-build}/${springAppName}" />
 

<property name="CONSOLE_LOG_PATTERN"
          value="%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}" />
 

<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
        <level>INFOlevel>
    filter>
    
    <encoder>
        <pattern>${CONSOLE_LOG_PATTERN}pattern>
        <charset>utf8charset>
    encoder>
appender>
 

<appender name="logstash"
          class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>${LOG_FILE}.jsonfile>
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
        
        <fileNamePattern>${LOG_FILE}.json.%d{yyyy-MM-dd}.gzfileNamePattern>
        
        <MaxHistory>3MaxHistory>
    rollingPolicy>
    
    <encoder
            class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
        <providers>
            <timestamp>
                <timeZone>UTCtimeZone>
            timestamp>
            <pattern>
                <pattern>
                    {
                    "severity": "%level",
                    "service": "${springAppName:-}",
                    "trace": "%X{X-B3-TraceId:-}",
                    "span": "%X{X-B3-SpanId:-}",
                    "exportable": "%X{X-Span-Export:-}",
                    "pid": "${PID:-}",
                    "thread": "%thread",
                    "class": "%logger{40}",
                    "rest": "%message"
                    }
                pattern>
            pattern>
        providers>
    encoder>
appender>

<appender name="logstash2"
          class="net.logstash.logback.appender.LogstashTcpSocketAppender">
    <destination>localhost:9600destination>
    
    <encoder
            class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
        <providers>
            <timestamp>
                <timeZone>UTCtimeZone>
            timestamp>
            <pattern>
                <pattern>
                    {
                    "severity": "%level",
                    "service": "${springAppName:-}",
                    "trace": "%X{X-B3-TraceId:-}",
                    "span": "%X{X-B3-SpanId:-}",
                    "exportable": "%X{X-Span-Export:-}",
                    "pid": "${PID:-}",
                    "thread": "%thread",
                    "class": "%logger{40}",
                    "rest": "%message"
                    }
                pattern>
            pattern>
        providers>
    encoder>
appender>
 

<root level="INFO">
    <appender-ref ref="console" />
    <appender-ref ref="logstash" />
    <appender-ref ref="logstash2" />
root>
configuration>