Springcloud

最新推荐文章于 2022-11-04 16:28:35 发布

超级刚

最新推荐文章于 2022-11-04 16:28:35 发布

阅读量178

点赞数

文章标签：微服务架构

本文链接：https://blog.youkuaiyun.com/asetqc/article/details/112347158

版权

面试问题

什么是 spring cloud

spring cloud 是一系列框架的有序集合。它利用 spring boot 的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用 spring boot 的开发风格做到一键启动和部署。

spring cloud 断路器的作用是什么

在分布式架构中，断路器模式的作用也是类似的，当某个服务单元发生故障（类似用电器发生短路）之后，通过断路器的故障监控（类似熔断保险丝），向调用方返回一个错误响应，而不是长时间的等待。这样就不会使得线程因调用故障服务被长时间占用不释放，避免了故障在分布式系统中的蔓延。

spring cloud 的核心组件有哪些

Eureka：服务注册于发现。
Feign：基于动态代理机制，根据注解和选择的机器，拼接请求 url 地址，发起请求。
Ribbon：实现负载均衡，从一个服务的多台机器中选择一台。
Hystrix：提供线程池，不同的服务走不同的线程池，实现了不同服务调用的隔离，避免了服务雪崩的问题。
Zuul：网关管理（服务内部网关），由 Zuul 网关转发请求给对应的服务。
GateWay：网关管理，拦截外部请求，通过网关转发到相应的服务；第二代网关。

SpringCloud和Dubbo

Duoob使用RPC远程过程通信方式是基于Socket通信，是用纯java语言开发的，不能进行其他语言的合并
Springcloud使用Http方式通信的基于Tpc协议，对外暴露Rest接口，对于服务于服务之间的通信没有技术选型的要求。

SpringCloud和Dubbo都是现在主流的微服务架构

SpringCloud是Apache旗下的Spring体系下的微服务解决方案

Dubbo是阿里系的分布式服务治理框架

从技术维度上,其实SpringCloud远远的超过Dubbo,Dubbo本身只是实现了服务治理,而SpringCloud现在以及有21个子项目以后还会更多

但是由于RPC以及注册中心元数据等原因,在技术选型的时候我们只能二者选其一,所以我们常常为用他俩来对比

服务的调用方式Dubbo使用的是RPC远程调用,而SpringCloud使用的是 Rest API,其实更符合微服务官方的定义

服务的注册中心来看,Dubbo使用了第三方的ZooKeeper作为其底层的注册中心,实现服务的注册和发现,SpringCloud使用Spring Cloud Netflix Eureka实现注册中心,当然SpringCloud也可以使用ZooKeeper实现,但一般我们不会这样做

服务网关,Dubbo并没有本身的实现,只能通过其他第三方技术的整合,而SpringCloud有Zuul路由网关,作为路由服务器,进行消费者的请求分发,SpringCloud还支持断路器,与git完美集成分布式配置文件支持版本控制,事务总线实现配置文件的更新与服务自动装配等等一系列的微服务架构要素

SpringBoot和SpringCloud

SpringBoot是Spring推出用于解决传统框架配置文件冗余,装配组件繁杂的基于Maven的解决方案,旨在快速搭建单个微服务而SpringCloud专注于解决各个微服务之间的协调与配置,服务之间的通信,熔断,负载均衡等技术维度并相同,并且SpringCloud是依赖于SpringBoot的,而SpringBoot并不是依赖与SpringCloud,甚至还可以和Dubbo进行优秀的整合开发

总结:

SpringBoot专注于快速方便的开发单个个体的微服务
SpringCloud是关注全局的微服务协调整理治理框架,整合并管理各个微服务,为各个微服务之间提供,配置管理,服务发现,断路器,路由,事件总线等集成服务
SpringBoot不依赖于SpringCloud,SpringCloud依赖于SpringBoot,属于依赖关系
SpringBoot专注于快速,方便的开发单个的微服务个体,SpringCloud关注全局的服务治理框架

微服务之间是如何独立通讯的

远程过程调用（Remote Procedure Invocation）

   也就是我们常说的服务的注册与发现

   直接通过远程过程调用来访问别的service。

   优点：

   简单，常见,因为没有中间件代理，系统更简单

   缺点：

   只支持请求/响应的模式，不支持别的，比如通知、请求/异步响应、发布/订阅、发布/异步响应

   降低了可用性，因为客户端和服务端在请求过程中必须都是可用的

springcloud如何实现服务的注册

1.服务发布时，指定对应的服务名,将服务注册到注册中心(eureka zookeeper)
2.注册中心加@EnableEurekaServer,服务用@EnableDiscoveryClient，然后用ribbon或feign进行服务直接的调用发现。

Eureka和ZooKeeper都可以提供服务注册与发现的功能,请说说两个的区别

ZooKeeper在选举期间注册服务瘫痪,虽然服务最终会恢复,但是选举期间不可用的
Eureka各个节点是平等关系,只要有一台Eureka就可以保证服务可用,而查询到的数据并不是最新的
自我保护机制会导致Eureka不再从注册列表移除因长时间没收到心跳而应该过期的服务，Eureka仍然能够接受新服务的注册和查询请求,但是不会被同步到其他节点(高可用)
zookeeper当网络稳定时,当前实例新的注册信息会被同步到其他节点中(最终一致性)
Eureka可以很好的应对因网络故障导致部分节点失去联系的情况,而不会像ZooKeeper一样使得整个注册系统瘫痪

2.ZooKeeper有Leader和Follower角色,Eureka各个节点平等

3.ZooKeeper采用过半数存活原则,Eureka采用自我保护机制解决分区问题

4.Eureka本质上是一个工程,而ZooKeeper只是一个进程

eureka自我保护机制是什么

当Eureka Server 节点在短时间内丢失了过多实例的连接时（比如网络故障或频繁启动关闭客户端）节点会进入自我保护模式，保护注册信息，不再删除注册数据，故障恢复时，自动退出自我保护模式。

什么是Ribbon

ribbon是一个负载均衡客户端，可以很好的控制http和tcp的一些行为。feign默认集成了ribbon

什么是feigin？它的优点是什么

1.feign采用的是基于接口的注解

2.feign整合了ribbon，具有负载均衡的能力

3.整合了Hystrix，具有熔断的能力

使用:

1.添加pom依赖。

2.启动类添加@EnableFeignClients

3.定义一个接口@FeignClient(name=“xxx”)指定调用哪个服务

Ribbon和Feign的区别

1.Ribbon都是调用其他服务的，但方式不同。

2.启动类注解不同，Ribbon是@RibbonClient feign的是@EnableFeignClients

3.服务指定的位置不同，Ribbon是在@RibbonClient注解上声明，Feign则是在定义抽象方法的接口中使用@FeignClient声明。

4.调用方式不同，Ribbon需要自己构建http请求，模拟http请求然后使用RestTemplate发送给其他服务，步骤相当繁琐。Feign需要将调用的方法定义成抽象方法即可。

什么是Spring Cloud Gateway?

Spring Cloud Gateway是Spring Cloud官方推出的第二代网关框架，取代Zuul网关。网关作为流量的，在微服务系统中有着非常作用，网关常见的功能有路由转发、权限校验、限流控制等作用。

使用了一个RouteLocatorBuilder的bean去创建路由，除了创建路由RouteLocatorBuilder可以让你添加各种predicates和filters，predicates断言的意思，顾名思义就是根据具体的请求的规则，由具体的route去处理，filters是各种过滤器，用来对请求做各种判断和修改。

开发问题

eureka

eureka配置

Eureka客户端工程
- user-service 服务提供
  - 服务地址使用ip方式
  - 续约
- consumer-demo 服务消费
  - 获取服务地址的频率
Eureka服务端工程 eureka-server
- 失效剔除
- 自我保护
user-service

    eureka:
      client:
        service-url:
          defaultZone: http://127.0.0.1:10086/eureka
      instance:
        # 更倾向使用ip地址，而不是host名
        prefer-ip-address: true
        # ip地址
        ip-address: 127.0.0.1
        # 续约间隔，默认30秒
        lease-renewal-interval-in-seconds: 5
        # 服务失效时间，默认90秒
        lease-expiration-duration-in-seconds: 5

consumer-demo

   eureka:
      client:
        service-url:
          defaultZone: http://127.0.0.1:10086/eureka
        # 获取服务地址列表间隔时间，默认30秒
        registry-fetch-interval-seconds: 10

eureka-server

    eureka:
      server:
        # 服务失效剔除时间间隔，默认60秒
        eviction-interval-timer-in-ms: 60000
        # 关闭自我保护模式（默认是打开的）
        enable-self-preservation: false

feign

feign使用

添加feign依赖

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

在消费方的启动器上添加注解@EnableFeignClient
消费方创建接口类上添加注解@FeignClient（“获取的服务名”）

//声明当前类是一个Feign客户端，指定服务名为user-service
@FeignClient("user-service")
public interface UserClient {

    //http://user-service/user/123
    @GetMapping("/user/{id}")
    User queryById(@PathVariable Long id);
}

在controller层将UserClient注入并使用。

集成ribbon配置

Fegin内置的ribbon默认设置了请求超时时长，默认是1000，我们可以通过手动配置来修改这个超时时长:

ribbon:
	ReadTimeout: 2000 # 读取超时时长
	ConnectTimeout: 1000 # 建立链接的超时时长

因为ribbon内部有重试机制，一旦超时，会自动重新发起请求。如果不希望重试，可以添加配置：
修改消费方的application.yml 添加如下配置：

ribbon:
	ConnectTimeout: 1000 # 连接超时时长
	ReadTimeout: 2000 # 数据通信超时时长
	MaxAutoRetries: 0 # 当前服务器的重试次数
	MaxAutoRetriesNextServer: 0 # 重试多少次服务
	OkToRetryOnAllOperations: false # 是否对所有的请求方式都重试

feign集成Hystrix

Feign默认也有对Hystrix的集成只不过，默认情况下是关闭的。需要通过下面的参数来开启；
修改消费方application.yml 添加如下配置：

feign:
hystrix:
 enabled: true # 开启Feign的熔断功能

但是，Feign中的Fallback配置不像Ribbon中那样简单了。
1）首先，要定义一个类，实现刚才编写的UserFeignClient，作为fallback的处理类

@FeignClient(value = "user-service", fallback = UserClientFallback.class)
public interface UserClient {
  @GetMapping("/user/{id}")
  User queryById(@PathVariable("id") Long id);
}

2）然后在UserFeignClient中，指定刚才编写的实现类

package com.itheima.consumer.client.fallback;
import com.itheima.consumer.client.UserClient;
import com.itheima.consumer.pojo.User;
import org.springframework.stereotype.Component;

@Component
public class UserClientFallback implements UserClient {
  @Override
  public User queryById(Long id) {
    User user = new User();
    user.setId(id);
    user.setName("用户异常");
    return user;
 }
}

请求压缩(了解)

Spring Cloud Feign 支持对请求和响应进行GZIP压缩，以减少通信过程中的性能损耗。通过下面的参数即可开启请求与响应的压缩功能：

feign:
  compression:
   request:
    enabled: true # 开启请求压缩
   response:
    enabled: true # 开启响应压缩

同时，我们也可以对请求的数据类型，以及触发压缩的大小下限进行设置：

feign:
	compression:
	 request:
	  enabled: true # 开启请求压缩
	  mime-types: text/html,application/xml,application/json # 设置压缩的数据类型
	  min-request-size: 2048 # 设置触发压缩的大小下限

上面的数据类型、压缩大小下限均为默认值

日志级别(了解)

前面讲过，通过 logging.level.xx=debug 来设置日志级别。然而这个对Fegin客户端而言不会产生效果。因为
@FeignClient 注解修改的客户端在被代理时，都会创建一个新的Fegin.Logger实例。我们需要额外指定这个日志的
级别才可以。
1）在 consumer-demo 的配置文件中设置com.itheima包下的日志级别都为 debug
修改 consumer-demo\src\main\resources\application.yml 添加如下配置：

logging:
	level:
	 com.itheima: debug

2）在 consumer-demo 编写FeignConfig配置类，定义日志级别

package com.itheima.consumer.config;
import feign.Logger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FeignConfig {
  @Bean
  Logger.Level feignLoggerLevel(){
    //记录所有请求和响应的明细，包括头信息、请求体、元数据
    return Logger.Level.FULL;
 }
}

这里指定的Level级别是FULL，Feign支持4种级别：
NONE：不记录任何日志信息，这是默认值。
BASIC：仅记录请求的方法，URL以及响应状态码和执行时间
HEADERS：在BASIC的基础上，额外记录了请求和响应的头信息
FULL：记录所有请求和响应的明细，包括头信息、请求体、元数据。

3）在 consumer-demo 的 UserClient 接口类上的@FeignClient注解中指定配置类：

@FeignClient(value = "user-service", fallback = UserClientFallback.class,
configuration = FeignConfig.class)
public interface UserClient {
  @GetMapping("/user/{id}")
  User queryById(@PathVariable Long id);
}

Gateway

配置

在gateway的微服务中的配置文件配置

server:
 port: 10010
spring:
 application:
   name: api-gateway
 cloud:
   gateway:
     routes:
       # 路由id，可以任意
       - id: user-service-route
         # 代理的服务地址
         #uri: http://127.0.0.1:9091
         # lb表示从eureka中获取具体服务，实现动态路由，不用将地址写死，但是服务必须是注册了的服务
         uri: lb://user-service
         # 路由断言： 可以匹配映射路径，路由前缀处理
         predicates:
           #- Path=/user/**
           #- Path=/**
           - Path=/api/user/**
         filters:
           # 添加请求路径的前缀
           #- PrefixPath=/user
           #1表示过滤1个路径，2表示两个路径，以此类推
           - StripPrefix=1
           - MyParam=name
     # 默认过滤器，对所有路由都生效
     default-filters:
     # 添加响应头
       - AddResponseHeader=X-Response-Foo, Bar
       - AddResponseHeader=abc-myname,heima
     globalcors:
       corsConfigurations:
         '[/**]':
           #allowedOrigins: * # 这种写法或者下面的都可以，*表示全部
           allowedOrigins:
             - "http://docs.spring.io"
           allowedMethods:
             - GET
eureka:
 client:
   service-url:
     defaultZone: http://127.0.0.1:10086/eureka
 instance:
   prefer-ip-address: true
hystrix:
 command:
   default:
     execution:
       isolation:
         thread:
           timeoutInMilliseconds: 6000
ribbon:
 ConnectTimeout: 1000
 ReadTimeout: 2000
 MaxAutoRetries: 0
 MaxAutoRetriesNextServer: 0

核心概念

路由（route）路由信息的组成：由一个ID、一个目的URL、一组断言工厂、一组Filter组成。如果路由断言为
真，说明请求URL和配置路由匹配。
断言（Predicate） Spring Cloud Gateway中的断言函数输入类型是Spring 5.0框架中的
ServerWebExchange。Spring Cloud Gateway的断言函数允许开发者去定义匹配来自于Http Request中的任何
信息比如请求头和参数。
过滤器（Filter）一个标准的Spring WebFilter。 Spring Cloud Gateway中的Filter分为两种类型的Filter，分别
是Gateway Filter和Global Filter。过滤器Filter将会对请求和响应进行修改处理。

入门

添加依赖

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

编写启动类

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

编写路由规则

server:
  port: 10010
spring:
  application:
   name: api-gateway
eureka:
  client:
   service-url:
    defaultZone: http://127.0.0.1:10086/eureka
  instance:
   prefer-ip-address: true

自定义过滤器

自定义局部过滤器

写过滤器工厂类MyParamGatewayFilterFactory
书写规则按照GatewayFilterFactory其他接口书写方式编写，配置文件中按照MyParam配置过滤器。

@Component
public class MyParamGatewayFilterFactory extends
AbstractGatewayFilterFactory<MyParamGatewayFilterFactory.Config> {
  public static final String PARAM_NAME = "param";
  public MyParamGatewayFilterFactory() {
    super(Config.class);
 }
  @Override
  public List<String> shortcutFieldOrder() {
    return Arrays.asList(PARAM_NAME);
 }
  @Override
  public GatewayFilter apply(Config config) {
    return (exchange, chain) -> {
      ServerHttpRequest request = exchange.getRequest();
      if (request.getQueryParams().containsKey(config.param)) {
        request.getQueryParams().get(config.param)
           .forEach(value -> System.out.printf("----------局部过滤器-----%s
= %s-----",
                config.param, value));
     }
      return chain.filter(exchange);
   };
 }
  public static class Config {
    private String param;
    public String getParam() {
      return param;
   }
    public void setParam(String param) {
      this.param = param;
   }
 }
}

修改配置文件
在heima-gateway工程修改 heima-gateway\src\main\resources\application.yml 配置文件

server
  port: 10010
    spring:
      application:
        name: api-gateway
cloud:
 gateway:
  routes:
    # 路由id，可以随意写
   - id: user-service-route
     # 代理的服务地址；lb表示从eureka中获取具体服务
    uri: lb://user-service
     # 路由断言，可以配置映射路径
    predicates:
     - Path=/api/user/**
    filters:
      # 表示过滤1个路径，2表示两个路径，以此类推
     - StripPrefix=1
      # 自定义过滤器
     - MyParam=name
eureka:
  client:
   service-url:
    defaultZone: http://127.0.0.1:10086/eureka
  instance:
   prefer-ip-address: true

自定义全局过滤器

需求：模拟一个登录的校验。基本逻辑：如果请求中有token参数，则认为请求有效，放行。
在heima-gateway工程编写全局过滤器类MyGlobalFilter

@Component
public class MyGlobalFilter implements GlobalFilter, Ordered {
  @Override
  public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    System.out.println("-----------------全局过滤器MyGlobalFilter-------------------
--");
    String token = exchange.getRequest().getQueryParams().getFirst("token");
    if (StringUtils.isBlank(token)) {
      exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
      return exchange.getResponse().setComplete();
   }
    return chain.filter(exchange);
 }
  @Override
  public int getOrder() {
    //值越小越先执行
    return 1;
 }
}

负载均衡和熔断

Gateway中默认就已经集成了Ribbon负载均衡和Hystrix熔断机制。但是所有的超时策略都是走的默认值，比如熔断
超时时间只有1S，很容易就触发了。因此建议手动进行配置

hystrix:
  command:
   default:
    execution:
     isolation:
      thread:
       timeoutInMilliseconds: 6000
ribbon:
  ConnectTimeout: 1000
  ReadTimeout: 2000
  MaxAutoRetries: 0
  MaxAutoRetriesNextServer: 0

Gateway跨域配置

跨域：在js请求访问中，如果访问的地址与当前服务器的域名、ip或者端口号不一致则称为跨域请求。若不解决则不
能获取到对应地址的返回结果。
如：从在http://localhost:9090中的js访问 http://localhost:9000的数据，因为端口不同，所以也是跨域请求。
在访问Spring Cloud Gateway网关服务器的时候，出现跨域问题的话；可以在网关服务器中通过配置解决，允许哪
些服务是可以跨域请求的；具体配置如下：

spring:
cloud:
 gateway:
  globalcors:
   corsConfigurations:
    '[/**]':
      #allowedOrigins: * # 这种写法或者下面的都可以，*表示全部
     allowedOrigins:
     - "http://docs.spring.io"
     allowedMethods:
     - GET

上述配置表示：可以允许来自 http://docs.spring.io 的get请求方式获取服务数据。
allowedOrigins 指定允许访问的服务器地址，如：http://localhost:10000 也是可以的。
‘[/**]’ 表示对所有访问到网关服务器的请求地址
官网具体说明：https://cloud.spring.io/spring-cloud-static/spring-cloud-gateway/2.1.1.RELEASE/multi/mul
ti__cors_configuration.html

Gateway的高可用

启动多个Gateway服务，自动注册到Eureka，形成集群。如果是服务内部访问，访问Gateway，自动负载均衡，没
问题。
但是，Gateway更多是外部访问，PC端、移动端等。它们无法通过Eureka进行负载均衡，那么该怎么办？
此时，可以使用其它的服务网关，来对Gateway进行代理。比如：Nginx

Gateway与Feign的区别

Gateway 作为整个应用的流量入口，接收所有的请求，如PC、移动端等，并且将不同的请求转发至不同的处理
微服务模块，其作用可视为nginx；大部分情况下用作权限鉴定、服务端流量控制
Feign 则是将当前微服务的部分服务接口暴露出来，并且主要用于各个微服务之间的服务调用

Spring Cloud Config分布式配置中心

介绍

在分布式系统中，由于服务数量非常多，配置文件分散在不同的微服务项目中，管理不方便。为了方便配置文件集中
管理，需要分布式配置中心组件。在Spring Cloud中，提供了Spring Cloud Config，它支持配置文件放在配置服务
的本地，也支持放在远程Git仓库（GitHub、码云）

使用方法

创建远程码云仓库
创建配置文件
在新建的仓库中创建需要被统一配置管理的配置文件。
配置文件的命名方式：{application}-{profile}.yml 或 {application}-{profile}.properties
application为应用名称
profile用于区分开发环境，测试环境、生产环境等
如user-dev.yml，表示用户微服务开发环境下使用的配置文件。
搭建配置微服务
添加依赖

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

启动类上加注解@EnableConfigServer
创建配置中心工程 config-server 的配置文件

server:
  port: 12000
spring:
  application:
   name: config-server
cloud:
 config:
  server:
   git:
   # git仓库的地址
    uri: https://gitee.com/liaojianbin/heima-config.git
eureka:
  client:
   service-url:
    defaultZone: http://127.0.0.1:10086/eureka

在需要拉取配置文件的微服务这个添加依赖

<dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-config</artifactId>
      <version>2.1.1.RELEASE</version>
    </dependency>

修改配置
5. 删除 user-service 工程的 user-service\src\main\resources\application.yml 文件（因为该文件从配置
中心获取）
6. 创建 user-service 工程 user-service\src\main\resources\bootstrap.yml 配置文件

spring:
cloud:
 config:
   # 与远程仓库中的配置文件的application保持一致
  name: user
   # 远程仓库中的配置文件的profile保持一致
  profile: dev
   # 远程仓库中的版本保持一致
label: master
  discovery:
    # 使用配置中心
   enabled: true
    # 配置中心服务id
   service-id: config-server
eureka:
client:
 service-url:
  defaultZone: http://127.0.0.1:10086/eureka

bootstrap.yml文件也是Spring Boot的默认配置文件，而且其加载的时间相比于application.yml更早。
application.yml和bootstrap.yml虽然都是Spring Boot的默认配置文件，但是定位却不相同。bootstrap.yml
可以理解成系统级别的一些参数配置，这些参数一般是不会变动的。application.yml 可以用来定义应用级别的
参数，如果搭配 spring cloud config 使用，application.yml 里面定义的文件可以实现动态替换。
总结就是，bootstrap.yml文件相当于项目启动时的引导文件，内容相对固定。application.yml文件是微服务的一些常规配置参数，变化比较频繁

Spring Cloud Bus服务总线

前面已经完成了将微服务中的配置文件集中存储在远程Git仓库，并且通过配置中心微服务从Git仓库拉取配置文件，
当用户微服务启动时会连接配置中心获取配置信息从而启动用户微服务。
如果我们更新Git仓库中的配置文件，那用户微服务是否可以及时接收到新的配置信息并更新呢？

使用方法

在配置中心微服务这个添加依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-bus</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-stream-binder-rabbit</artifactId>
</dependency>

在配置服务中心上修改配置文件

server:
port: 12000
spring:
application:
 name: config-server
cloud:
 config:
  server:
   git:
    uri: https://gitee.com/liaojianbin/heima-config.git
 # rabbitmq的配置信息；如下配置的rabbit都是默认值，其实可以完全不配置
 rabbitmq:
   host: localhost
   port: 5672
   username: guest
   password: guest
eureka:
  client:
   service-url:
    defaultZone: http://127.0.0.1:10086/eureka
management:
  endpoints:
   web:
    exposure:
      # 暴露触发消息总线的地址
     include: bus-refresh

改造用户提供方

<dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-bus</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-stream-binder-rabbit</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>

修改用户提供方bootstrap.yml配置文件

spring:
cloud:
 config:
   # 与远程仓库中的配置文件的application保持一致
  name: user
   # 远程仓库中的配置文件的profile保持一致
  profile: dev
   # 远程仓库中的版本保持一致
  label: master
  discovery:
    # 使用配置中心
   enabled: true
   # 配置中心服务id
   service-id: config-server
 # rabbitmq的配置信息；如下配置的rabbit都是默认值，其实可以完全不配置
rabbitmq:
  host: localhost
  port: 5672
  username: guest
  password: guest
eureka:
  client:
   service-url:
    defaultZone: http://127.0.0.1:10086/eureka

在用户提供方的启动类上添加注解@RefreshScope刷新配置

开发问题

扫描其他微服务注解

@EntityScan("com.xuecheng.framework.domain.cms")//扫描实体类
@ComponentScan(basePackages={"com.xuecheng.api"})//扫描接口