Spring Cloud 0-1配置_从0到1配置springcloud-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_41778851/article/details/114937787

这篇博客详细介绍了Spring Cloud的配置与服务治理，包括Eureka注册中心的配置，服务发现，Ribbon负载均衡，OpenFeign的使用，Hystrix熔断处理，GateWay网关配置，配置中心Config的使用，动态刷新配置，SpringCloud-Stream消息传递，以及Oauth2认证配置。内容涵盖了从单机到集群，从服务注册到服务降级的完整流程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Spring Cloud配置

根项目pom

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <java.version>1.8</java.version>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <junit.version>4.12</junit.version>
    <log4j.version>1.2.17</log4j.version>
    <lombork.version>5.1.47</lombork.version>
    <mysql.version>8.0.11</mysql.version>
    <druid.version>1.1.16</druid.version>
    <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
    <spring-boot.version>2.3.3.RELEASE</spring-boot.version>
    <spring-cloud.version>Hoxton.SR8</spring-cloud.version>
</properties>

使用dependencyManagement来标注父工程，以后的子工程都会在父工程中查找相关jar包版本信息

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2.1.0.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis.spring.boot.version}</version>
        </dependency>
    </dependencies>
</dependencyManagement>

开启热部署配置

1、导入devtools的jar包

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

2、加入相关的插件到父工程的pom文件中

<build>
    <finalName>User8001</finalName>
        <plugins>
            <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <fork>true</fork>
                <addResources>true</addResources>
            </configuration>
            </plugin>
    </plugins>
</build>

3、开启自动编译的选项

在这里插入图片描述

4、更新池

按ctrl+shift+alt弹出选项框在这里插入图片描述

选择Registry选中compiler.automake.allow.when.app.running和actionSystem.assertFocusAccessFromEdt

5、重启idea

子项目pom文件依赖配置

<dependencies>
<!--        聚合工程通用实体类和工具类-->
        <dependency>
            <groupId>com.wanxi</groupId>
            <artifactId>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.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-boot-starter</artifactId>
            <version>3.0.0</version>
        </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>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</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>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

单机版服务注册yml

1、eureka注册中心配置

spring:
  freemarker:
    template-loader-path: classpath:/templates/
    prefer-file-system-access: false
server:
  port: 7000
eureka:
  instance:
    hostname: localhost          #eurka 服务端的实例名称
  client:
    register-with-eureka: false  #false表示不向服务中心注册自己
    fetch-registry: false        #false表示自己就是注册中心，职责是维护服务实例，不需要去检测服务
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
    #设置与eureka交互的地址，查询服务与注册服务都需要通过这个地址与eureka交互

2、服务注册端配置

server:
  port: 8001

spring:
  application:
    name: User
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/system?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456

mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.wanxi.model #所有实体类所在包

eureka:
  client:
    register-with-eureka: true    #注册进eureka服务中心
    fetch-registry: true          #是否从eurekaService抓取已有注册信心，在集群模式下必须设为true才能配合ribbon使用负载均衡
    service-url:
      defaultZone: http://localhost:7000/eureka
                                  #指定服务中心地址

3、消费者端配置

server:
  port: 8080

spring:
  application:
    name: userfindall

eureka:
  client:     # 配置Eureka的信息
    register-with-eureka: true     # 设为true，表示将自己注册到Eureka Server，默认为true
    fetch-registry: true     # 是否从Eureka Server抓取已有的注册信息，默认为true；单节点无所谓，集群必须设置为true才能配合Ribbon使用负载均衡
    service-url:    # 指定Eureka注册中心的地址，其它服务在这个地址注册，不指定默认为：(defaultZone , http://localhost:8761/eureka/)
      defaultZone: http://localhost:7000/eureka    # 设置与Eureka Server交互的地址，查询服务和注册服务都需要依赖这个地址

集群配置

1.先修改windows下 C:\Windows\System32\drivers\etc 的配置文件hosts添加如下内容：

127.0.0.1 eureka7000.com
127.0.0.1 eureka7001.com
127.0.0.1 eureka7002.com

2.修改配置文件

eureka注册中心配置

7001端yml配置：

server:
  port: 7001
eureka:
  instance:
    hostname: eureka7001.com     #eurka 服务端的实例名称
  client:
    register-with-eureka: false  #false表示不向服务中心注册自己
    fetch-registry: false        #false表示自己就是注册中心，职责是维护服务实例，不需要去检测服务
    service-url:
      defaultZone: http://eureka7000.com:7000/eureka/
    #设置与eureka交互的地址，查询服务与注册服务都需要通过这个地址与eureka交互

7000端yml配置

server:
  port: 7000
eureka:
  instance:
    hostname: eureka7000.com     #eurka 服务端的实例名称
  client:
    register-with-eureka: false  #false表示不向服务中心注册自己
    fetch-registry: false        #false表示自己就是注册中心，职责是维护服务实例，不需要去检测服务
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/
    #设置与eureka交互的地址，查询服务与注册服务都需要通过这个地址与eureka交互

服务端配置

8001端yml配置

server:
  port: 8001

spring:
  application:
    name: User
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/system?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456

mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.com.wanxi.model #所有实体类所在包

eureka:
  client:
    register-with-eureka: true    #注册进eureka服务中心
    fetch-registry: true          #是否从eurekaService抓取已有注册信心，在集群模式下必须设为true才能配合ribbon使用负载均衡
    service-url:
      defaultZone: http://eureka7000.com:7000/eureka,http://eureka7001.com:7001/eureka
                                  #指定服务中心地址

8002端配置

server:
  port: 8002

spring:
  application:
    name: User
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/system?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456

mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.com.wanxi.model #所有实体类所在包

eureka:
  client:
    register-with-eureka: true    #注册进eureka服务中心
    fetch-registry: true          #是否从eurekaService抓取已有注册信心，在集群模式下必须设为true才能配合ribbon使用负载均衡
    service-url:
      defaultZone: http://eureka7000.com:7000/eureka,http://eureka7001.com:7001/eureka
                                  #指定服务中心地址

消费者端配置

server:
  port: 8080

spring:
  application:
    name: userfindall

eureka:
  client:     # 配置Eureka的信息
    register-with-eureka: true     # 设为true，表示将自己注册到Eureka Server，默认为true
    fetch-registry: true     # 是否从Eureka Server抓取已有的注册信息，默认为true；单节点无所谓，集群必须设置为true才能配合Ribbon使用负载均衡
    service-url:    # 指定Eureka注册中心的地址，其它服务在这个地址注册，不指定默认为：(defaultZone , http://localhost:8761/eureka/)
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7000.com:7000/eureka/    # 设置与Eureka Server交互的地址，查询服务和注册服务都需要依赖这个地址

服务名称设置及端口暴露配置

instance:
  instance-id: User8001         #指定在服务注册中心的服务名称
  prefer-ip-address: true       #开启ip提示（鼠标悬停在服务名称上时，左下角提示服务ip、端口、接口等信息）

服务发现Discovery(获取服务注册中心的信息)

在启动类上加注解：@EnableDiscoveryClient

在controller中写接口：

@Resource
private DiscoveryClient discoveryClient;

@GetMapping("/getDiscovery")
public Object getDiscovery(){
    List<String> services = discoveryClient.getServices();
    for(String name : services){
        List<ServiceInstance> instances = discoveryClient.getInstances(name);
        for(ServiceInstance instance : instances){
            String x = instance.getServiceId() + "\t" + instance.getHost() + "\t" + instance.getPort() + "\t" + instance.getUri();
            System.out.println(x);
        }
    }
    return this.discoveryClient;
}

关闭eureka自我保护机制（eureka原属于CAP中AP分支，是有保护机制的，不会应为服务短时间未发送心跳而注销服务）

server:
  enable-self-preservation: false #关闭eureka保护机制（在90秒类没接收到心跳就注销服务）

修改服务注册端向注册中心发送心跳时间及等待上限

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

使用zookeeper作为服务注册中心

server:
  port: 8004

spring:
  application:
    name: userzookeeper
  cloud:
    zookeeper:
      connect-string: 192.168.253.201:2181    #指定zookeeper地址及端口

consol服务注册中心

在这里插入图片描述

导入依赖包

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-consul-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>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

写yml配置文件

server:
  port: 8006

spring:
  application:
    name: UserConsul
  cloud:
    consul:
      host: 192.168.253.201
      port: 8500
      discovery:
        service-name: ${spring.application.name}
        heartbeat:       #开启consul心跳，默认为关闭服务不可用
          enabled: true
        register: true   #服务注册与发现

三个注册中心对比

在这里插入图片描述

Ribbon负载均衡

pom坐标：在导入eureka坐标后，eureka自带ribbon坐标，不需要在去额外添加

RestTemplate使用

在这里插入图片描述

Ribbon负载均衡方式（实现IRule接口）

注意事项

在这里插入图片描述

如何使用IRule

1、去掉配置类上的LoadBalanced注解

在这里插入图片描述

2、编写自己需要的负载均衡实现类（实现IRule接口）

具体实现放在spring配置类能扫描到的地方

3、在java目录下建包写自己的配置类

在这里插入图片描述

OpenFeign使用

导入openfeign依赖包

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

编写yml配置文件

server:
  port: 8080

eureka:
  client: # 配置Eureka的信息
    register-with-eureka: true     # 设为true，表示将自己注册到Eureka Server，默认为true
    fetch-registry: true     # 是否从Eureka Server抓取已有的注册信息，默认为true；单节点无所谓，集群必须设置为true才能配合Ribbon使用负载均衡
    service-url: # 指定Eureka注册中心的地址，其它服务在这个地址注册，不指定默认为：(defaultZone , http://localhost:8761/eureka/)
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7000.com:7000/eureka/    # 设置与Eureka Server交互的地址，查询服务和注册服务都需要依赖这个地址
  instance:
    instance-id: OpenFeign-FindAll8080         #指定在服务注册中心的服务名称
    prefer-ip-address: true

service编写

@Component
@FeignClient(value = "USER")   //对应服务提供者所提供服务的名称
public interface UserService {
    @PostMapping("/user/findAll")//对应服务提供者contorller的方法
    public CommonResult findAll(@RequestBody User user);
}

controller编写

@RestController
public class UserController {
    @Resource
    private UserService userService;
    @GetMapping("/findAll/{name}")//restFull风格编写接口
    public CommonResult findALl(@PathVariable String name){
        User user = new User();
        user.setRealName(name);
        return userService.findAll(user);//调用openfengn实现接口的方法
    }
}

openfengn请求服务超时处理

#设置feign客户端超时时间(OpenFeign默认支持ribbon)
ribbon:
#指的是建立连接所用的时间，适用于网络状况正常的情况下,两端连接所用的时间
  ReadTimeout: 5000
  #建立连接后从服务器读取到可用资源所用的时间为5秒,默认为1秒
  connectTimeout: 5000

Hystrix熔断处理

pom文件导入坐标

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

yml文件配置（单机版）

server:
  port: 8001

spring:
  application:
    name: User

eureka:
  client:
    register-with-eureka: true    #注册进eureka服务中心
    fetch-registry: true          #是否从eurekaService抓取已有注册信心，在集群模式下必须设为true才能配合ribbon使用负载均衡
    service-url:                  #指定服务中心地址
      defaultZone: http://eureka7000.com:7000/eureka
  instance:
    instance-id: User8001         #指定在服务注册中心的服务名称
    prefer-ip-address: true       #开启ip提示（鼠标悬停在服务名称上时，左下角提示服务ip、端口、接口等信息）

服务端降级：

提供者在service方法上添加注解

@HystrixCommand(fallbackMethod = "timeoutHandler",commandProperties = {
        @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",value = "1000")//表示该方法超时时间，如果超时就转到                                                                                                   //timeoutHandler方法执行
})

fallbackMethod指定的方法可处理因超时或发生错误的情况

在主启动类上添加开启的注解：@EnableCircuitBreaker

客户端降级：

在yml中添加配置：

feign:
  hystrix:
    enabled: true                 #开启服务降级

主启动类上添加注解==@EnableHystrix==

业务类方法加注与服务端同样的注释，并编写号相应的处理方法

使用全局统一服务降级方法

1、在需要服务降级的类上添加注解==@DefaultProperties(defaultFallback = “timeoutHandler”)==

2、在需要服务降级的方法上添加注解==@HystrixCommand==

服务熔断

当在一定时间段内请求失败比例达到设定值时，先为此服务熔断降级，就算有正确的请求通过依然会对请求做降级处理，直到在一段时间后，正确请求次数变多才逐渐恢复服务的正确使用。

在这里插入图片描述

在需要服务熔断的业务方法上添加注解@HystrixCommand

@HystrixCommand(fallbackMethod = "paymentCircuitBreaker_fallback" ,commandProperties = {
        @HystrixProperty(name = "circuitBreaker.enabled" ,value = "true"),//是否开启断路器
        @HystrixProperty(name = "circuitBreaker. requestvolumeThreshold" ,value = "10"),//请求次数
        @HystrixProperty(name = "circuitBreaker.sleepwindowInNilliseconds " ,value = "10000"),//时间窗口期
        @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage" ,value = "60"),//失败率达到多少后跳闸
})

搭建dashboard服务监控可视化界面

1、为监控模块导入依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>

2、为需要监控的模块添加bean

/**
 * *此配置是为了服务监控而配置，与服务容错本身无关，springcloud升级后的坑
 * ServletRegistrationBean因为springboot的默认路径不是"/hystrix.stream"
 *只要在自己的项目里配置上下面的servlet就可以了
 * @return
 */
@Bean
public ServletRegistrationBean getServlet(){
    HystrixMetricsStreamServlet streamServlet  = new HystrixMetricsStreamServlet();
    ServletRegistrationBean<HystrixMetricsStreamServlet> registrationBean = new ServletRegistrationBean<>(streamServlet);
    registrationBean.setLoadOnStartup(1);
    registrationBean.addUrlMappings("/hystrix.stream");
    registrationBean.setName("HystrixMetricStreamServlet");
    return registrationBean;
}

在这里插入图片描述

GateWay网关配置

pom文件依赖

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

    </dependencies>

yml配置文件

server:
  port: 9527
spring:
  application:
    name: gateway
  cloud:
    gateway:
      routes:
        - id: UserRouter              #路由的名称，路由名称要唯一
          uri: http://localhost:8001  #匹配后的服务路由地址
          predicates:
            - Path=/user/**   #断言，路径相匹配的进行路由

        - id: UserRouter2             #路由的名称，路由名称要唯一
          uri: http://localhost:8001  #匹配后的服务路由地址
          predicates:
            - Path=/user/getDiscovery   #断言，路径相匹配的进行路由
eureka:
  instance:
    hostname: gateway-service
  client:
    service-url:
      register-with-eureka: true
      fetch-registry: true
      defaultZone: http://localhost:7000/eureka

主启动类上添加注解

@SpringBootApplication
@EnableEurekaClient

配置类方式添加路由

@Configuration
public class GateWayConfig {
    @Bean
    public RouteLocator getRouteLocator(RouteLocatorBuilder routeLocatorBuilder){
        return routeLocatorBuilder.routes().route("GateWay-baidu",
                r -> r.path("/guonei")
                .uri("https://news.baidu.com/")).build();
    }

}

使用注册中心服务来动态注册路由

spring:
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true                #开启从注册中心动态创建路由的功能，利用微服务名进行路由
      routes:
        - id: UserRouter               #路由的名称，路由名称要唯一
          uri: lb://USER               #lb代表从注册中心获取服务,只要匹配路径就从服务注册中心调取服务
          predicates:
            - Path=/user/findAll       #断言，路径相匹配的进行路由

断言配置项的解析

1、After，Before，Between：指定路由在指定时间规则内生效，否则会返回404

predicates:
 - Path=/user/getDiscovery/**   #断言，路径相匹配的进行路由
 - After=2020-10-28T10:06:09.260+08:00[Asia/Shanghai]   #路由生效时间限制
 - Before=2020-10-28T10:06:09.260+08:00[Asia/Shanghai]   #路由生效时间限制
 - Between=2020-10-28T10:06:09.260+08:00[Asia/Shanghai],2020-10-28T11:06:09.260+08:00[Asia/Shanghai] #路由生效时间限制

时区限制格式可以用java.time.ZonedDateTime来获取（2020-10-28T10:06:09.260+08:00[Asia/Shanghai]）

2、Cookie：限制携带cookie的请求，满足正则表达式就通过，否则就拦截

- Cookie=username,tang

3、-Header：通过请求头内容限制非法请求

- Header=X-Request-Id,\d+  #请求头要有x-Request-Id属性并且值为整数的正则表达式

自定义过滤器

@Component
public class MyFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String name = exchange.getRequest().getQueryParams().getFirst("uname");
        if(name == null){//判断头中是否带有“uname”参数，是就放过，否则返回错误码
            exchange.getResponse().setStatusCode(HttpStatus.NOT_ACCEPTABLE);
            return exchange.getResponse().setComplete();
        }
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return 0;//指定filter优先级顺序
    }
}

配置中心Config

服务端配置

1、pom依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-config-server</artifactId>
    </dependency>
    <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>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2、yml配置文件

server:
  port: 3000

spring:
  application:
    name: spring-cloud-config-server
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/tang_renhong/spring-cloud-config.git    #仓库路径
          username: tang_renhong
          password: 052013trh
          search-paths:           #搜索路径
            - spring-cloud-config
        default-label: master     #默认搜索分支

eureka:
  client:
    service-url:
      defaultZone: http://localhost:7000/eureka

3、主启动类

@SpringBootApplication
@EnableConfigServer    //开启配置中心
public class SpringCloudConfigApplication3000 {
    public static void main(String[] args) {
        SpringApplication.run(SpringCloudConfigApplication3000.class,args);
    }
}

客户端配置

1、pom依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-config</artifactId>
    </dependency>
    <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>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2、yml配置文件（bootstarp.yml)

server:
  port: 3001

spring:
  application:
    name: spring-cloud-config-client
  cloud:
    config:
      label: master       #在marster分支下读入config-dev.yml里的配置信息
      name: config
      profile: dev
      uri: http://localhost:3000

eureka:
  client:
    service-url:
      defaultZone: http://localhost:7000/eureka

3、主启动类

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

动态刷新客户端配置信息

1、在客户端yml配置中添加暴露监控端点的配置

#暴露监控端点
management:
  endpoints:
    web:
      exposure:
        include: "*"

2、在客户端controller上添加注解

3、手动发生post请求到http:localhost:3001/actuator/refresh

使用总线bus通知服务更改

1、在配置中心以及客户端添加包

<!--        安装消息中线支持-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-bus-amqp</artifactId>
        </dependency>

2、配置中心yml配置

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest

# 暴露bus配置端点
management:
  endpoints:
    web:
      exposure:
        include: 'bus-refresh'

3、客户端yml配置

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
#暴露监控端点
management:
  endpoints:
    web:
      exposure:
        include: "*"

4、对服务端发送刷新配置post请求，curl -X POST “http://localhost:3000/actuator/bus-refresh”

5、指定通知部分服务：==curl -X POST “http://localhost:3000/actuator/bus-refresh/spring-cloud-config-client:3001”==只通知客户端3001服务，而不通知3002

SpringCloud-Stream

在这里插入图片描述

一、消息发送方

1、pom文件导入包

<dependencies>
<!--        导入stream整合rabbitMq包-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rabbit</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.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</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>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

yml配置信息

server:
  port: 8001
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:          #这个名字是一个通道名称
          destination: studyExchange      #指定要使用的Exchange的名称
          content-type: application/json  #设置消息类型，本次为json，文本则设置"text/plain"
          binder: defaultrabbit           #设置要绑定的消息服务的具体设置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7000/eureka
  instance:
    lease-expiration-duration-in-seconds: 5  #服务过期时间
    lease-renewal-interval-in-seconds: 2  #心跳间隔时间
    instance-id: send-8001.com            #在消息列表时显示主机名称
    prefer-ip-address: true               #访问路径变为ip

注意：binder名称与binders指定的名称要一致

在这里插入图片描述

3、消息发送方service

@EnableBinding(Source.class)//定义消息推送管道
public class ImessageServiceImpl implements IMessageService {
    @Autowired
    private MessageChannel output;//消息发送管道
    @Override
    public String send(String message) {
        output.send(MessageBuilder.withPayload(message).build());
        return "已发送消息";
    }
}

二、消息接收方

1、pom文件依赖

<dependencies>
    <!--        导入stream整合rabbitMq包-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-stream-rabbit</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.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</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>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2、yml配置

server:
  port: 8002
spring:
  application:
    name: cloud-stream-consumer
  cloud:
    stream:
      binders:           #绑定rabbitmq服务信息
        defaultrabbit:   #表示定义的名称，用于与binding整合
          type: rabbit   #消息组件类型
          environment:   #设置rabbitmq的相关环境配置
            spring:
              rabbitmq:
                host: localhost
                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:7000/eureka
  instance:
    lease-expiration-duration-in-seconds: 5  #服务过期时间
    lease-renewal-interval-in-seconds: 2  #心跳间隔时间
    instance-id: receive-8002.com            #在消息列表时显示主机名称
    prefer-ip-address: true               #访问路径变为ip

3、消息接受者

@RestController
@EnableBinding(Sink.class)
public class ReceiveMessageListenerController {
    @StreamListener(Sink.INPUT)
    public void input(Message<String> message){
        System.out.println("8002接收到消息:\t" + message.getPayload());
    }
}

解决消息接收方存在多次消费的问题

给消费者指定组别（再同一个组的消费之只有一个能拿到消息，同时解决消费者宕机后，重新启动拿到消息发生方发送的消息）

在yml配置中添加分组信息

在这里插入图片描述

zipkin监控依赖

1、pom导入坐标

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

2、yml添加配置

spring:
  application:
    name: userfindall
  zipkin:
    base-url: http://localhost:9411     #服务监控地址
    sleuth:
      sampler:
        probability: 1        #采样率介于0-1，一般为0.5；

Oauth2认证

pom依赖

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

配置项

AuthorizationServerConfiguration

ase-expiration-duration-in-seconds: 5 #服务过期时间
lease-renewal-interval-in-seconds: 2 #心跳间隔时间
instance-id: receive-8002.com #在消息列表时显示主机名称
prefer-ip-address: true #访问路径变为ip


###### 3、消息接受者

@RestController
@EnableBinding(Sink.class)
public class ReceiveMessageListenerController {
@StreamListener(Sink.INPUT)
public void input(Message message){
System.out.println(“8002接收到消息:\t” + message.getPayload());
}
}


###### 解决消息接收方存在多次消费的问题

给消费者指定组别（再同一个组的消费之只有一个能拿到消息，同时解决消费者宕机后，重新启动拿到消息发生方发送的消息）

在yml配置中添加分组信息

[外链图片转存中...(img-yxJUMAx6-1615971291729)]

#### zipkin监控依赖

##### 1、pom导入坐标

```xml
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>

2、yml添加配置

spring:
  application:
    name: userfindall
  zipkin:
    base-url: http://localhost:9411     #服务监控地址
    sleuth:
      sampler:
        probability: 1        #采样率介于0-1，一般为0.5；

Oauth2认证

pom依赖

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

配置项

AuthorizationServerConfiguration

在这里插入图片描述