SpringCloud

最新推荐文章于 2025-04-22 09:58:01 发布

MaximusT

最新推荐文章于 2025-04-22 09:58:01 发布

阅读量526

点赞数

文章标签： spring cloud eureka java

本文链接：https://blog.youkuaiyun.com/weixin_44223212/article/details/126251475

版权

一、SpringCloud简介

Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。Spring Cloud并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。

二、服务注册与发现-Eureka

创建EurekaServer

1.创建父工程

导入依赖配置SpringBoot对应版本的Cloud版本查看对应版本

 <packaging>pom</packaging> 
<properties>
    <spring.cloud-version>Hoxton.SR8</spring.cloud-version>
</properties>
<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>
    </dependencies>
</dependencyManagement>

2.创建子工程

2.1导入SpringBoot相关依赖

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

2.2.创建SpringBoot启动类创建eureka的server，添加注解，编写yml文件

@SpringBootApplication
@EnableEurekaServer
public class EurekaApplication {
    public static void main(String[] args){
        SpringApplication.run(EurekaApplication.class);

}}

2.3 配置yml文件

eureka:
  instance:
    hostname: localhost
  client:
    #当前Eureka服务为单机版
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

2.4 创建EurekaClient

1.创建maven工程，修改为SpringBoot

2.导入依赖

3.启动类上添加注解

4.编写配置文件

Eureka安全性

实现Eureka认证
1.导入依赖
2.编写配置类
3.编写配置文件
4.其他服务向注册到Eureka需要添加账户和密码

Eureka高可用

如果程序正在运行，eureka宕机了
1.如果调用方访问过一次被调用方，eureka宕机不会影响到功能
2.如果没有访问过被调用方，就会造成不可用

搭建Eureka高可用
1.搭建多台Eureka
采用复制文件方法，删除iml和target文件，修改pom中项目名称，再给父工程添加一个model
2.让服务都注册到多台Eureti
3.让多台Eureka间相互通讯

三、服务间的负载均衡-Robbin

3.1 引言

Robbin是实现服务和服务之间的负载均衡

Robbin实现客户端负载均衡：customer客户模块，将2个serch模块信息全部拉到本地的缓存，在customer中自己做一个负载均衡的策略，选择其中某一个服务

Dubbo、Nginx实现服务端负载均衡：在注册中心中，直接根据你指定的负载均衡策略，帮你选中一个指定的服务信息，并返回

客户端负载均衡和服务端负载均衡区别：客户端负载均衡和服务端负载均衡最大的区别在于服务清单所存储的位置。在客户端负载均衡中，所有的客户端节点都有一份自己要访问的服务端清单，这些清单统统都是从Eureka服务注册中心获取的。

3.2快速入门

1.启动两个search模块

2.在customer中导入robbin依赖

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

3.配置整合RestTemplate和Robbin

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

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

4.在customer中访问search

@RestController
public class CustomerController {
    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private EurekaClient eurekaClient;
    @GetMapping("/customer")
    public String customer(){

      String result = restTemplate.getForObject(url + "/search", String.class);
        String result = restTemplate.getForObject("http://SEARCH/search", String.class);

        return result;


    }
}

3.3 Robbin负载均衡策略

1.负载均衡策略
	1.RandomRule：随机策略
	2.RoundRobbinRuke:轮询策略
	3.WeightedResponseTimeRule:默认采用轮询策略，后续根据服务的响应时间，自动分配权重
	4.BestAvaliableRule：根据被调用方法并发数量最小的去分配

2.采用注解配置

   @Bean
    public IRule robbinRule(){
        return  new RandomRule();
    }

3.配置文件去指定负载均衡策略(推荐)

users:
  ribbon:
    NIWSServerListClassName: com.netflix.loadbalancer.ConfigurationBasedServerList
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.WeightedResponseTimeRule

四、服务间的调用-Feign

4.1 引言

Fegin可以帮助我们实现面向接口变成，直接调用其他的服务，简化开发

4.2 Feign快速入门

1.导入依赖

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

2.添加注释

@EnableFeignClients

3.创建一个接口，并且和Search模块做映射

@FeignClient("SEARCH")//指定服务名称
public interface SearchClient {

    @RequestMapping(value = "/search",method = RequestMethod.GET)
    String search();
}

4.测试使用

   @Autowired
    private SearchClient searchClient;
    @GetMapping("/customer")
    public String customer(){

        String result = searchClient.search();

        return result;


    }

4.3 Feign的传递参数方式

1、注意事项
	1.如果传递参数较复杂时，默认采用POST方式
	2.传递单个参数时，推荐使用@PathVariable，如果传递的单个参数较多，可以采用@RequestParam，不要省略value属性
	3.传递对象信息时，统一采用json方式，添加@RequestBody
	4.Client接口必须使用@RequestMapping

2、在Search模块下准备三个接口

    @GetMapping("/search/{id}")
    public Customer findById(@PathVariable Integer id){
        return new Customer(1,"张三",11);
    }
    @GetMapping("/getCustomer")
    public Customer getCustomer(@RequestParam Integer id,@RequestParam String name){
        return new Customer(id,name,20);
    }
    @PostMapping("/save") 
    public Customer save(@RequestBody Customer customer){
        return customer;
    }

3、封装Customer模块下的Controller

  @GetMapping("/customer/{id}")
    public Customer findById(@PathVariable Integer id){
        return searchClient.findById(id);
    }
    @GetMapping("/getCustomer")
    public Customer getCustomer(@RequestParam Integer id, @RequestParam String name){
        return searchClient.getCustomer(id,name);
    }
    @GetMapping("/save") //自动转换为POST请求，405
    public Customer save(Customer customer){
        return searchClient.save(customer);
    }

4.再封装Client接口

    @RequestMapping(value = "/search/{id}",method = RequestMethod.GET)
        Customer findById(@PathVariable(value = "id") Integer id);

    @RequestMapping(value = "/getCustomer",method = RequestMethod.GET)
        Customer getCustomer(@RequestParam(value = "id") Integer id, @RequestParam(value = "name") String name);

    @RequestMapping(value ="/save",method = RequestMethod.GET)//自动转换为POST请求，405
        Customer save(@RequestBody Customer customer);

5.测试

4.4 Feign的Fallback

Fallback可以帮助我们在使用Feign去调用另外一个服务时，如果出现问题，走服务降级，返回一个错误数据，避免功能因为一个服务出现问题，全部失效

1.创建一个POJO类，实现Client接口

@Component
public class SearchFallBack implements SearchClient {
    @Override
    public String search() {
        return "出现问题";
    }

    @Override
    public Customer findById(Integer id) {
        return null;
    }

    @Override
    public Customer getCustomer(Integer id, String name) {
        return null;
    }

    @Override
    public Customer save(Customer customer) {
        return null;
    }
}

2.修改Client接口中的注解，添加一个属性

@FeignClient(value = "SEARCH",fallback = SearchFallBack.class)//指定服务名称

3.添加一个配置文件

feign:
  hystrix:
    enabled: true

调用方无法知道具体的错误信息是什么，通过FallBackFactory的方式去实现这个功能

1、FallBackFactory基于Fallback

2、创建一个POJO类，实现FallBackFactory<Client>

@Component
public class SearchClientFallBackFactory implements FallbackFactory<SearchClient> {
    @Autowired
    private SearchFallBack searchFallBack;
    @Override
    public SearchClient create(Throwable throwable) {
        throwable.printStackTrace();
        return searchFallBack;
    }
}

3、修改Client接口中的属性

@FeignClient(value = "SEARCH",
       fallbackFactory = SearchClientFallBackFactory.class)

五、服务的隔离及断路器-Hystrix

5.1 引言

Hystrix主要是为了解决服务器雪崩问题
1、降级机制：当你的某一个服务出现的超时，资源不足，出现异常时，可以执行一个降级方法，返回一个托底数据
2、隔离：提供一个Hystrix线程池，信号量，和Tomcat的线程池相互隔离
3、熔断：当你的某一个服务的失败率达到一定的阈值时，自动触发降级
4、缓存：请求缓存的功能

5.2 降级机制实现

1.导入依赖

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

2.添加一个注解
@EnableCircuitBreaker

3.针对某一个接口编写他的降级方法

@GetMapping("/customer/{id}")
 @HystrixCommand(fallbackMethod = "findByIdFallBack")
 public Customer findById(@PathVariable Integer id){

     return searchClient.findById(id);
 }

 //findById的降级方法，方法的描述要和接口一致
 public Customer findByIdFallBack(@PathVariable Integer id){
     return new Customer(-1,"",0);
 }

4.在接口上添加注解
@HystrixCommand(fallbackMethod = "findByIdFallBack")

5.测试

5.3 线程隔离

如果使用Tomcat的线程池去接收用户的请求，使用当前线程去执行其他服务的功能，如果当某一个服务出现了故障，导致tomcat的线程大量堆积，导致tomcat无法处理其他的业务功能

1、Hystrix的线程池(默认使用)，接收用户请求采用tomcat的线程池，执行业务代码，调用其他服务时，采用Hystrix的线程池。

2、信号量，使用的还是Tomcat的线程池，帮助我们去管理Tomcat的线程池

1、Hystrix的线程池配置

1.线程隔离策略：name=hystrix.command.default.execution.isolation.strategy,value=THREAD, SEMAPHORE

2.指定超时时间（针对线程池）:name=hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds,value=10000

3.是否开启超时时间配置: name=hystrix.command.default.execution.timeout.enabled,value=true

4.超时之后是否中断线程:name=hystrix.command.default.execution.isolation.thread.interruptOnTimeout,value=true

5.取消任务后是否中断线程:name=hystrix.command.default.execution.isolation.thread.interruptOnCancel,value=false

2、信号量的配置信息

1.指定信号量的最大并发请求数:name=hystrix.command.default.execution.isolation.semaphore.maxConcurrentRequests，value=10

5.4 断路器

5.4.1断路器介绍

在调用指定服务时，如果说这个服务的失败率达到输入的一个阈值，将断路器从closed状态，转变为open状态，指定服务时无法被访问的，如果你访问就直接走fallback方法，在一定时间内，open状态会再次转变为半开的half open 状态，允许一个请求发送到我的指定服务，如果成功，转变为closed状态，如果失败，再次转变为open，直到断路器回到一个closed状态

5.4.2 配置断路器的监控界面

1.导入依赖

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

2.在启动类中添加注解
@EnableHystrixDashboard

3.配置一个servlet

@WebServlet("/hystrix.stream")
public class HystrixServlet extends HystrixMetricsStreamServlet {
}

//在启动类中添加一个扫描servlet的注解
@WebServlet("/hystrix.stream")
public class HystrixServlet extends HystrixMetricsStreamServlet {
}

4.测试

直接访问http://host:port/hystrix

输入映射好的servlet路径

5.4.3 配置断路器的属性

断路器的属性

1.断路器的开关:name=hystrix.command.default.circuitBreaker.enabled,value=true

2.失败阈值的总请求数:name=hystrix.command.default.circuitBreaker.requestVolumeThreshold,value=20

3.请求总数失败率达到多少时:name=hystrix.command.default.circuitBreaker.errorThresholdPercentage,value=50

4.断路器open状态后，多少秒是拒绝请求的:name=hystrix.command.default.circuitBreaker.sleepWindowInMilliseconds,value=5000

5.强制让服务拒绝请求:name=hystrix.command.default.circuitBreaker.forceOpen,value=false

6.强制让服务接受请求:name=hystrix.command.default.circuitBreaker.forceClosed,value=false

5.5请求缓存

5.5.1请求缓存简介

1、请求缓存的生命周期是一次请求

2、请求缓存是缓存当前线程中的一个方法，将方法参数作为key，方法的返回结果作为value

3、在一次请求中，目标方法被调用过一次，以后都会被缓存。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c9xrRskj-1660035636271)(C:\Users\wuyutian\AppData\Roaming\Typora\typora-user-images\image-20220808171725941.png)]

5.5.2 请求缓存的实现

1.创建一个service，在service中调用search服务

@Service
public class CustomerService {
 @Autowired
 private SearchClient searchClient;

 @CacheResult
 @HystrixCommand( commandKey = "findById")
 public Customer findById(@CacheKey Integer id){
     return searchClient.findById(id);
 }

 @CacheRemove(commandKey = "findById")
 @HystrixCommand
 public void ClearFindById(@CacheKey Integer id){
     System.out.println("findById缓存被清空");
 }
}

2.使用请求缓存的注解

@CacheResult:帮助我们缓存当前方法的返回结果(必须配合@HystrixCommand使用)

@CachetRemove:帮助我们清除某一个缓存信息（基于commndKey）

@CacheKey：指定哪个方法参数作为缓存标识

3.修改Search模块的返回结果

4.编写Filter,去构建HystrixRequestContext

@WebFilter("/*")
public class HystrixRequestContextiniFilter implements Filter {
 @Override
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
     HystrixRequestContext.initializeContext();
     filterChain.doFilter(servletRequest,servletResponse);
 }
}

5.测试

六、服务的网关-Zuul

6.1引言

1、客户端维护大量ip和port信息，直接访问指定服务

2、认证和授权操作，需要在每一个模块中都添加认证和授权的操作

3.项目的迭代，服务要拆分，服务要合并，，需要客户端进行大量的变化

4.统一的把安全性校验都放在Zuul中。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DIrtZKH3-1660035636274)(C:\Users\wuyutian\AppData\Roaming\Typora\typora-user-images\image-20220808174458627.png)]

6.2 Zuul快速入门

1.创建Maven项目,修改为SpringBoot

2.导入依赖

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

3.添加注解

@EnableEurekaClient
@EnableZuulProxy

4.编写配置文件

eureka:
  client:
    service-url:
      defaultZone: http://root:root@localhost:8761/eureka,http://root:root@localhost:8762/eureka

spring:
  application:
    name: ZUUL

server:
  port: 80

5.测试

6.3 Zuul常用配置信息

6.3.1.Zuul的监控界面

1、导入依赖

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

2、编写配置文件

#查看Zuul的监控界面,开发时配置为*,上线时不得为*
management:
endpoint:
 web:
   exposure:
     include: "*"

3.直接访问

6.3.2 忽略服务配置

#ZUUL的配置
zuul:
  #基于服务名忽略服务，无法查看.如果要忽略全部的服务， "*"默认配置的全部路径都会被忽略掉(自定义服务的配置，无法忽略的)
  ignored-services: eureka
  #基于路径，监控界面依然可以查看，在访问的时候404
  ignored-patterns: /**/search/**


  #指定自定义服务(方式一，key（服务名）:value（路径）)
#  routes:
#    search: /SS/**
#    customer: /cc/**
  #指定自定义服务(方式二)
  routes:
    kehu:
      path: /ccc/** #映射的路径
      serviceId: customer #服务名称

6.3.4 灰度发布

1、添加一个配置类

@Bean
 public PatternServiceRouteMapper serviceRouteMapper() {
     return new PatternServiceRouteMapper(
             "(?<name>^.+)-(?<version>v.+$)",
             "${version}/${name}");
 }

2、准备一个服务，提供两个版本

#指定服务名
spring:
application:
 name: CUSTOMER-${version}

version: v1

3、测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uroDiyps-1660035636275)(C:\Users\wuyutian\AppData\Roaming\Typora\typora-user-images\image-20220809100355203.png)]

6.4Zuul过滤器

客户端请求发送到Zuul服务上，首先通过PreFilter链，如果正常放行，会把请求再次转发给RoutingFilter，请求转发到一个指定的服务，在指定的服务响应一个结果后，再次走一个PostFilter的过滤器，最终再将响应信息返还给客户端。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0APHcNZF-1660035636276)(C:\Users\wuyutian\AppData\Roaming\Typora\typora-user-images\image-20220809100758977.png)]

6.5 Zuul过滤器入门

1、创建POJO类，继承ZuulFilter抽象类
@Component
public class TestZuulFilter extends ZuulFilter{}

2、指定当前过滤器的类型

@Override
 public String filterType() {
     return FilterConstants.PRE_TYPE;
 }

3.指定过滤器的执行顺序

@Override
 public int filterOrder() {
     return FilterConstants.PRE_DECORATION_FILTER_ORDER-1;
 }

4、配置是否启用

@Override
 public boolean shouldFilter() {
     //开启当前过滤器
     return true;
 }

5、指定过滤器中的具体业务代码

@Override
 public Object run() throws ZuulException {
     System.out.println("过滤器开始执行");
     return null;
 }

6、测试

6.6 PreFilter实现token校验

1、准备访问路径，请求参数传递token

http://localhost/v1/customer/version?token=123

2、创建AuthenticationFilter

@Component
public class AuthenticationFilter extends ZuulFilter {
 @Override
 public String filterType() {
     return FilterConstants.PRE_TYPE;
 }

 @Override
 public int filterOrder() {
     return FilterConstants.PRE_DECORATION_FILTER_ORDER-2;
 }

 @Override
 public boolean shouldFilter() {
     return true;
 }

 @Override
 public Object run() throws ZuulException {
     //1.获取request对象
     RequestContext currentContext = RequestContext.getCurrentContext();
     HttpServletRequest request = currentContext.getRequest();

     //2.获取token参数
     String token = request.getParameter("token");


     return null;
 }
}

3、在run方法中编写具体的业务逻辑代码

     //3.对比token
     if (token==null || !"123".equalsIgnoreCase(token)){
         //4.token校验失败，直接响应数据
         currentContext.setSendZuulResponse(false);
         currentContext.setResponseStatusCode(HttpStatus.UNAUTHORIZED.value());
     }

4、测试

6.7 Zuul的降级

1、创建POJO类，实现接口FallBackProvider
@Component
public class ZuulFallBack implements FallbackProvider {}

2、重写两个方法

@Override
public String getRoute() {
 return "*";  //代表指定全部出现问题的服务，都走这个降级方法
}

@Override
public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
 System.out.println("降级的服务："+ route);
 cause.printStackTrace();

 return new ClientHttpResponse() {
     @Override
     public HttpStatus getStatusCode() throws IOException {
         //指定具体的HttpStatus
         return HttpStatus.INTERNAL_SERVER_ERROR;
     }

     @Override
     public int getRawStatusCode() throws IOException {
         //返回的状态码
         return HttpStatus.INTERNAL_SERVER_ERROR.value();
     }

     @Override
     public String getStatusText() throws IOException {
         //指定错误信息
         return HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase() ;
     }

     @Override
     public void close() {

     }

     @Override
     public InputStream getBody() throws IOException {
         //给用户响应的信息
         String msg="当前服务:"+route +" 出现问题！";
         return new ByteArrayInputStream(msg.getBytes());
     }

     @Override
     public HttpHeaders getHeaders() {
         //响应头信息指定
         HttpHeaders headers=new HttpHeaders();
         headers.setContentType(MediaType.APPLICATION_JSON);
         return headers;
     }}

3、测试

6.8 Zuul动态路由

1、创建一个过滤器

执行顺序最好放在Pre过滤器的后面

2、在run方法中编写业务逻辑

public class DynamicRoutingFilter extends ZuulFilter {
 @Override
 public String filterType() {
     return FilterConstants.PRE_TYPE;
 }

 @Override
 public int filterOrder() {
     return FilterConstants.PRE_DECORATION_FILTER_ORDER+2;
 }

 @Override
 public boolean shouldFilter() {
     return true;
 }

 @Override
 public Object run() throws ZuulException {
     //1.获取request对象
     RequestContext context=RequestContext.getCurrentContext();
     //2.获取参数redisKey
     HttpServletRequest request = context.getRequest();
     String redisKey = request.getParameter("redisKey");
     //3.直接判断
     if (redisKey!=null && redisKey.equalsIgnoreCase("customer")){
         //http://localhost:8080/customer
         context.put(FilterConstants.SERVICE_ID_KEY,"customer-v1");
         context.put(FilterConstants.REQUEST_URI_KEY,"/customer");

     }else if(redisKey!=null && redisKey.equalsIgnoreCase("search")){
         //http://localhost:8081/search/1
         context.put(FilterConstants.SERVICE_ID_KEY,"search");
         context.put(FilterConstants.REQUEST_URI_KEY,"/search/1");
     }
     return null;
 }
}

3、测试

七、多语言支持-Sidecar

7.1 引言

在SpringCloud的项目中，需要接入一些非java程序，第三方接口，无法接入eureka，hystrix，feign等等组件。启动一个代理的微服务，代理微服务和非java的程序或者第三方接口交流，通过代理的微服务去接入SpringCloud的相关组件。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iZtqh8Wd-1660035636277)(C:\Users\wuyutian\AppData\Roaming\Typora\typora-user-images\image-20220809134253801.png)]

7.2 Sidecar的实现

1.创建一个第三方的接口

创建一个SpringBoot工程，并且添加一个Controller

2.创建maven工程，修改为SpringBoot

3.导入依赖

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

4.添加注解

@EnableSideCar

5.编写配置文件

server:
 port: 81

eureka:
 client:
  service-url:
    defaultZone: http://root:root@localhost:8761/eureka,http://root:root@localhost:8762/eureka


  #指定服务名
spring:
    application:
      name: other-service

#指定代理的第三方服务
sidecar:
    port: 7001

6.通过customer通过feign调用第三方服务

八、服务间消息传递-Stream

8.1 Stream快速入门

1.启动RabbitMQ

2.消费者-导入依赖

3.消费者-配置文件

4.消费者-监听的队列

5.生产者-导入依赖

6.生产者-配置文件

7.生产者-发布消息

九、服务的动态配置-Config

9.1 引言

1、配置文件分散在不同的项目中，不方便维护

2、配置文件的安全问题

3、修改完配置文件，无法立即生效

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b3txOft7-1660035636278)(C:\Users\wuyutian\AppData\Roaming\Typora\typora-user-images\image-20220809152832183.png)]

9.2 搭建Config-Server

1、搭建Maven工程，修改为SpringBoot

2、导入依赖

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

3、添加注解

@EnableConfigServer

4、编写配置文件(Git的操作)

eureka:
  client:
    service-url:
      defaultZone: http://root:root@localhost:8761/eureka,http://root:root@localhost:8762/eureka

spring:
  application:
    name: config
  cloud:
    config:
      server:
        git:
          basedir: D:\basedir #本地仓库地址
          username:   #远程仓库用户名
          password:  #远程仓库密码
          uri: https://gitee.com/maximust/config-resp.git #远程仓库地址

5、测试

http://localhost:8080/master/customer-aaa.yml

9.3 修改Customer连接Config

1.导入依赖

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

2.编写配置文件

#指定服务名
spring:
  application:
    name: CUSTOMER-${version}
  cloud:
    config:
      discovery:
        enabled: true
        service-id: config
      profile: dev
version: v1

3.修改配置名称

转换为bootstrap.yml

4.测试

9.4实现动态配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DYsFJKEZ-1660035636279)(C:\Users\wuyutian\AppData\Roaming\Typora\typora-user-images\image-20220809163010513.png)]

十、服务的追踪-Sleuth

10.1 引言

在整个微服务架构中，微服务很多，一个请求可能调用很多的服务，最终才能完成一个功能，如果说，整个功能出现了问题在这么多的服务中，如何去定位到问题的所在点，出现的问题的原因是什么。

1.Sleuth可以获得整个服务链路的信息

2.Zipkin通过图形化界面去看到信息

3.Sleuth将日志信息存储到数据库中。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JTOm8Feh-1660035636280)(C:\Users\wuyutian\AppData\Roaming\Typora\typora-user-images\image-20220809163518091.png)]

10.2 Sleuth使用

1.导入依赖

2.编写配置文件

3.测试

SpringCloud完整架构总结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-alxMXVPi-1660035636281)(C:\Users\wuyutian\AppData\Roaming\Typora\typora-user-images\image-20220809165319400.png)]