Hz零基础学习SpringCloud

1.分布式和微服务的区别

1.分布式

将一个项目根据不同的业务，拆分为多个模块，并将这些模块分开部署，通过特定的通信方式
进行交互，这就是分布式系统。

水平拆分：根据“分层”的思想进行拆分。例如，可以将一个项目根据“三层架构”拆分成 表示层
（jsp+servlet）、业务逻辑层（service）和数据访问层（dao），然后再分开部署：把表示层部署在服务器A
上，把service和dao层部署在服务器B上。


垂直拆分：根据业务进行拆分。例如，可以根据业务逻辑，将“电商项目”拆分成“订单项目”、“用户项目”和“秒
杀项目”。拆分后的项目，仍然可以作为独立的项目使用。像这种拆分的方法，就成为垂直拆分。



2.微服务

微服务可以理解为一种非常细粒度的垂直拆分。比如可以将订单项目，拆分为购物订单、售后订单、积分订单等。

微服务优势：

1.降低复杂度，将原本比较复杂的业务，拆分为多个单个服务，降低复杂度。
2.可独立部署，当业务发生迭代是只需要发布相关服务即可，不影响其他业务的使用。
3.容错高，当某个服务发生错误，可以通过熔断、限流等方法，降低错误导致的危害。

2、SpringCloud

1.SpringCloud

SpringCloud是一个用来快速构建分布式系统的框架。

并提供了一些服务的组件，方便使用：

1.服务注册和发现
2.路由
3.负载均衡
4.断路器
5.分布式消息传递
6....

3、RPC

1.RPC

RPC是指远程过程调用，也就是说两台服务器A，B，一个应用部署在A服务器上，想要调用B服务器上应用提供的
函数/方法（统称为服务），由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义和传达调
用的数据。


RPC可以基来于TCP协议也可以基于HTTP协议，RPC的主要目的只是获取由远程机器上的程序所执行的结果。

4、注册中心

1.注册中心

维护服务的注册与发现，有个服务注册表。

通过心跳机制监听服务是否可用。


provider服务生产者：启动的时候向注册中心，注册自己的服务信息。
consumer服务消费者：启动的时候向注册中心，注册自己的服务信息，拉取对应的provider的相关网络信息。


为什么要用注册中心：


服务越来越多，调用方需要知道接口的网络地址，如果靠配置文件的方式去控制网络地址，对于动态新增服务，维护带来很大问题。

主流的注册中心：

zookeeper、Eureka、consul、etcd 等

5、分布式应用知识CAP理论知识

1.CAP理论知识

CAP定理：

指的是在一个分布式系统中，Consistency（一致性）、 Availability（可用性）、Partition 
tolerance（分区容错性），三者不可同时获得，只能3选2。（CP、AP）


一致性(C):

在分布式系统中的所有数据备份，在同一时刻数据值是一样。（所有节点在同一时间的数据完全一致，越多节点，数据同步越耗时）

可用性（A）:

收到用户的请求，服务器就必须给出回应,保证服务的可用性。（服务一直可用，而且是正常响应时间）

分区容错性（P）：

系统在遇到某节点或网络分区故障的时候，仍然能够对外提供满足一致性或可用性的服务（100个节点，挂了几个，不影响服务正常使用）


CAP理论就是说在分布式存储系统中，最多只能实现上面的两点。而由于当前的网络硬件肯定会出现延迟丢包
等问题，所以分区容错性是我们必须需要实现的。所以我们只能在一致性和可用性之间进行权衡。



CAP组合优缺点：


CA 满足的情况下，P不能满足的原因：
如果不要求P（不允许分区），则C（强一致性）和A（可用性）是可以保证的。但放弃P的同时也就意味着放
弃了系统的扩展性，也就是分布式节点受限，没办法部署子节点，这是违背分布式系统设计的初衷的。


CP 满足的情况下，A不能满足的原因：

保证服务器之间强一致型，而P（分区）会导致同步耗时(也就是等待数据同步完才能正常访问服务)，一旦发
生网络故障或者消息丢失等情况，就要牺牲用户的体验，等待所有数据全部一致了之后再让用户访问系统。

AP满足的情况下，C不能满足的原因：

保证服务器的可用性，与分区容错性，将不能保证数据的一致性。如果某个数据同步的时候发生异常，
导致数据并没有同步，用户又访问到此节点，只能将旧数据返回给用户，来达到系统的可用性。



注册中心选择：

Zookeeper：CP设计，保证了一致性，集群搭建的时候，某个节点失效，则会进行选举行的leader，或者半
数以上节点不可用，则无法提供服务，因此可用性没法满足

Eureka：AP原则，无主从节点，一个节点挂了，自动切换其他节点可以使用，去中心化


结论:
  分布式系统中P,肯定要满足，所以只能在CA中二选一，最好的选择是根据业务场景来进行架构设计

 如果要求一致性，则选择zookeeper，如金融行业
			
 如果要去可用性，则Eureka，如电商系统

6、服务注册和发现Eureka Server搭建

1.  第一步：创建项目 (通过IDEA自动生成SpringBoot项目，勾选pomeureka-server)

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

2.  第二步: 启动添加注解 @EnableEurekaServer


3.  第三步：增加配置application.yml

server:
  port: 8761

eureka:
  instance:
    hostname: localhost
  client:
    #关闭客户端，声明自己是个服务端
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/




https://cloud.spring.io/spring-cloud-netflix/reference/html/#netflix-eureka-server-starter


客户端向Eureka注册时，它会提供有关其自身的元数据，例如主机，端口，运行状况指示器URL，主页和其他详
细信息。


Eureka服务器没有后端存储，但是注册表中的所有服务实例都必须发送心跳信号以使其注册保持最新（因此可以在内存中完成）




注意点：

如果您的项目已经使用Thymeleaf作为其模板引擎，则可能无法正确加载Eureka服务器的Freemarker模板。
在这种情况下，必须手动配置模板加载器：

spring:
  freemarker:
    template-loader-path: classpath:/templates/
    prefer-file-system-access: false

7、服务注册和发现Eureka Client搭建服务

1.  第一步：创建项目 (通过IDEA自动生成SpringBoot项目，勾选pom eureka-client)

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

2.  第二步：增加配置application.yml


server:
  port: 8771

#指定注册中心地址
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/


#指定服务名称
spring:
  application:
    name: product-server


注意：

spring-cloud-starter-netflix-eureka-client存在于类路径，（不必使用@EnableEurekaClient）将会自动将服务注册Eureka Server，
但需要配置Eureka Server注册中心地址，也就是application.yml中需要配置地址。

8、Eureka Server自我保护机制

默认情况下，如果Eureka Server在一定时间内（默认90秒）没有接收到某个微服务实例的心跳，Eureka
Server将会移除该实例。但是当网络分区故障发生时，微服务与Eureka Server之间无法正常通信，而微服务
本身是正常运行的，此时不应该移除这个微服务，所以引入了自我保护机制。



EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY'RE NOT. RENEWALS 
ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE.


server:
        enable-self-preservation: false


注意：自我保护模式一般不关闭，默认是开启状态true





自我保护模式正是一种针对网络异常波动的安全保护措施，使用自我保护模式能使Eureka集群更加的健壮、稳定的运行。

自我保护机制的工作机制是如果在15分钟内超过85%的客户端节点都没有正常的心跳，那么Eureka就认为客
户端与注册中心出现了网络故障，Eureka Server自动进入自我保护机制，此时会出现以下几种情况：

1、Eureka Server不再从注册列表中移除因为长时间没收到心跳而应该过期的服务。
2、Eureka Server仍然能够接受新服务的注册和查询请求，但是不会被同步到其它节点上，保证当前节点依然可用。
3、当网络稳定时，当前Eureka Server新的注册信息会被同步到其它节点中。

9、Ribbon

1.Ribbon

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


Spring Cloud Ribbon是一个基于HTTP和TCP的客户端负载均衡工具，它基于Netflix Ribbon实现。

可以将面向服务的REST模版请求自动转换成客户端负载均衡的服务调用。


2.如何使用

(1).服务提供者只需要启动多个服务实例并注册到服务注册中心。

(2).服务消费者直接通过调用被@LoadBalanced注解修饰过的RestTemplate来实现面向服务的接口调用。


Annotation to mark a RestTemplate or WebClient bean to be configured to use a
LoadBalancerClient.

用于标记要配置为使用的RestTemplate或WebClient bean的LoadBalancerClient.

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





@Autowired
private RestTemplate restTemplate;

@Override
public ProductOrder save(int userId, int productId) {

 Object obj = restTemplate.getForObject("http://product-server/api/v1/product/find?
id="+productId, Object.class);

 System.out.println(obj);

 ProductOrder productOrder = new ProductOrder();
 productOrder.setCreateTime(new Date());
 productOrder.setUserId(userId);
 productOrder.setTradeNo(UUID.randomUUID().toString());

 return productOrder;
}


IRule接口来指定使用哪个负载均衡策略

默认用的轮询调度

private static final IRule DEFAULT_RULE = new RoundRobinRule();




设置负载均衡策略：


#自定义负载均衡策略  改为随机
product-server:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule



Ribbon 七种负载均衡策略

https://blog.csdn.net/weixin_42868206/article/details/89069937

10、Feign

Feign:

是一个http请求调用的轻量级框架，可以以Java接口注解的方式调用Http请求。
Feign通过处理注解，将请求模板化，进而转化成真正的请求，这种请求相对而言比较直观。


Feign客户端请求使用：

1.引入pom包

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

2.启动类添加@EnableFeignClients

开启包扫描，扫描被@FeignClient注解接口。扫描出该注解后，通过beanDefinition注入到IOC容器中，方便
后续被调用使用。




#设置feign请求超时
feign:
  client:
    config:
      default:
        connectTimeout: 2000  #连接超时
        readTimeout: 2000     #请求超时


3.创建调用服务的Client接口

/**
 * 商品服务客户端
 */
@FeignClient(name = "product-server")
public interface ProductClient {

    /**
     * 通过Feign调用服务
     * @param id
     * @return
     */
    @GetMapping("/api/v1/product/find")
    String findOrderById(@RequestParam(value = "id") int id);
    
}

4.通过注入服务FeignClient调用服务

    @Autowired
    private ProductClient productClient;


    @Override
    public ProductOrder save(int userId, int productId) {

        String response = productClient.findOrderById(productId);
        JsonNode jsonNode = JsonUtils.str2JsonNode(response);
        ProductOrder productOrder = new ProductOrder();
        productOrder.setCreateTime(new Date());
        productOrder.setUserId(userId);
        productOrder.setTradeNo(UUID.randomUUID().toString());
        productOrder.setProductName(jsonNode.get("name").toString());
        productOrder.setPrice(Integer.parseInt(jsonNode.get("price").toString()));
        return productOrder;
    }

11、熔断、降级

雪崩效应：

一个服务失败，导致整条链路的服务都失败的情形，我们称之为服务雪崩。

服务提供者的不可用导致服务调用者的不可用，并将不可用逐渐放大的过程，就叫服务雪崩效应。


A => B => C

A服务请求B服务，B服务请求C服务，C服务可能出现异常或响应时间变长，导致B服务的不可用从而导致A服务也
变的不可用，最终产生服务的雪崩效应。


如何解决服务雪崩：

服务熔断：

当下游的服务因为某种原因突然变得不可用或响应过慢，上游服务为了保证自己整体服务的可用性，不再继续
调用目标服务。如果目标服务情况好转则恢复调用。



实现原理：

1、实时监控接口的健康值，在达到熔断条件时，自动开启熔断。
2、开启熔断之后，每隔一段时间，释放一个请求到服务端进行探测，如果服务已经恢复，则自动恢复调用。





服务降级：

当下游的服务因为某种原因不可用，上游主动调用本地的一些降级逻辑，避免卡顿，迅速返回给用户！

服务降级有很多种降级方式！
如：开关降级、限流降级、熔断降级!

服务熔断属于降级方式的一种！

12、Hystrix断路器

1.Hystrix断路器原理


默认超时时间：

execution.isolation.thread.timeoutInMilliseconds = 1000 毫秒


#设置超时时间:

hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 4000


#关闭超时时间
hystrix:
  command:
    default:
      execution:
        timeout:
          enabled: false

1.引入pom文件

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

2.启动类里面添加注解

@EnableCircuitBreaker

3.熔断降级

    @RequestMapping("save")
    @HystrixCommand(fallbackMethod = "findOrderId")
    public Object save(@RequestParam("user_id")int userId, @RequestParam("product_id") int productId){
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return productOrderService.save(userId, productId);
    }

    /**
     * 熔断降级
     * 当下游可的服务因为某种原因不用，上游主动调用本地的一些降级逻辑，避免卡顿，迅速返回给用户！
     * 注意：
     * 编写fallback方法实现，方法签名一定要和api方法签名一致（注意点！！！）
     * @param userId
     * @param productId
     * @return
     */
    public Object findOrderId(int userId,int productId){
        Map<String,Object> map = new HashMap<>();
        map.put("code",200);
        map.put("msg","人数过多,请稍后再重试");
        return map;
    }




-----------------------------------------------------------------------------------------


Feign结合Hystrix断路器

1.开启feign支持hystrix  (注意，一定要开启，旧版本默认支持，新版本默认关闭)

feign:
  hystrix:
    enabled: true


2.创建fallback类实现标有@FeignClient的接口类


@Component
public class ProductFallBack implements ProductClient {

    private static final Logger log = Logger.getGlobal();

    @Override
    public String findOrderById(int id) {

        log.info("Feign接口请求失败");

        return null;
    }
}

3.在标有@FeignClient接口类上，指定fallback类。


/**
 * 商品服务客户端
 */
@FeignClient(name = "product-server",fallback = ProductFallBack.class)
public interface ProductClient {

    /**
     * 通过Feign调用服务
     * @param id
     * @return
     */
    @GetMapping("/api/v1/product/find")
    String findOrderById(@RequestParam(value = "id") int id);

}

13、Dashboard监控仪表盘

1、加入依赖
<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>

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


2、启动类增加注解
   @EnableHystrixDashboard


3、配置文件增加endpoint

management:
  endpoints:
    web:
      exposure:
        include: "*"


访问入口
http://ip:port/hystrix

Hystrix Dashboard输入： http://ip:port/actuator/hystrix.stream 

14、Gateway

API Gateway


API Gateway，是系统的唯一对外的入口，介于客户端和服务器端之间的中间层，处理非业务功能 提供路由
请求、鉴权、监控、缓存、限流等功能。



统一接入
 智能路由
 AB测试、灰度测试
 负载均衡、容灾处理
 日志埋点（类似Nignx日志）

流量监控
 限流处理
 服务降级

安全防护
 鉴权处理
 监控
 机器网络隔离(节点访问都是通过服务内网访问的，不会对外暴露外网地址)


1.网关产品：

zuul：是Netflix开源的微服务网关，和Eureka,Ribbon,Hystrix等组件配合使用，Zuul 2.0比1.0的性能提高很多

15、Zuul

1.添加pom依赖

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

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

2.启动类添加注解 开启网关代理

@EnableZuulProxy


3.配置文件


server:
  port: 9000


#指定注册中心地址
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/



#指定服务名称
spring:
  application:
    name: api-gateway



4.访问规则

http://gatewayip:port/注册中心注册的服务名称/**

列如：
http://localhost:9000/order-server/api/v1/order/save?user_id=1&product_id=1




5.设置自定路由服务名 

#自定义路由转发
zuul:
  routes:
    #不想使用注册中心中的服务名称 替换成自定义  /** 指定的可以访问该服务中的所有接口
    #自定义的服务名称不能重复 重复后面会覆盖前面的
    order-server: /apigateway/order/**
    #http://localhost:9000/apigateway/order/api/v1/order/save?user_id=1&product_id=1
    product-server: /apigateway/product/**

  #禁止product-server服务通过通过网关访问
  #http://网关服务ip:port/product-server/api/v1/product/list    不可以访问
  #如果product-server服务配置了自定义路由服务名，可通过自定义路由服务名访问
  #http://localhost:9000/apigateway/product/api/v1/product/list 可以访问
  #ignored-services: product-server

  #禁用匹配正则规则的服务直接通过网关访问，
  #如果配置了自定义路由服务名，可通过路由服务名访问，否则不能访问
  ignored-patterns: /*-server/**

  #设置zuul网关,过滤header为空
  #默认过滤Cookie,Set-Cookie,Authorization
  sensitive-headers:

16、zuul网关登录校验

流程实现步骤

1、新建一个filter包

2、新建一个类，实现ZuulFilter，重写里面的方法

3、在类顶部加注解，@Component,让Spring扫描


package com.cloud.gateway.api_gateway;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.apache.commons.lang.StringUtils;
import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;

/**
 * 登录校验器
 */
@Component
public class LoginFilter extends ZuulFilter {

    /**
     * 过滤器类型
     * 设置为前置过滤器
     * @return
     */
    @Override
    public String filterType() {
        return FilterConstants.PRE_TYPE;
    }

    /**
     * 多个filter执行顺序 数字越小最前执行
     * @return
     */
    @Override
    public int filterOrder() {
        return 0;
    }

    /**
     * 是否执行当前filter
     * true执行
     * false不执行
     * @return
     */
    @Override
    public boolean shouldFilter() {
        RequestContext requestContext = RequestContext.getCurrentContext();
        HttpServletRequest request = requestContext.getRequest();
        //System.out.println(request.getRequestURI());  /apigateway/order/api/v1/order/save
        //System.out.println(request.getRequestURL());  /http://localhost:9000/apigateway/order/api/v1/order/save
        if("/apigateway/order/api/v1/order/save".equalsIgnoreCase(request.getRequestURI())){
            //只匹配订单接口登录权限
            return true;
        }
        return false;
    }

    /**
     * 具体执行业务
     * @return
     * @throws ZuulException
     */
    @Override
    public Object run() throws ZuulException {
        RequestContext requestContext = RequestContext.getCurrentContext();
        HttpServletRequest request = requestContext.getRequest();
        String token = request.getHeader("token");
        //登录校验
        if(StringUtils.isBlank(token)){
            //设置ZuulResponse 为false 请求将不会继续发送到后续服务
            requestContext.setSendZuulResponse(false);
            requestContext.setResponseStatusCode(HttpStatus.UNAUTHORIZED.value());
        }
        return null;
    }
}

17、高并发zuul限流

import com.google.common.util.concurrent.RateLimiter;
import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;

import static org.springframework.cloud.netflix.zuul.filters.support.FilterConstants.PRE_TYPE;

/**
 * 订单限流
 */
@Component
public class OrderRateLimiterFilter extends ZuulFilter {
    //谷歌guava

    //令牌桶实现原理

    //每秒产生500个令牌
    private static final RateLimiter RATE_LIMITER = RateLimiter.create(500);

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

    @Override
    public int filterOrder() {
        return -4;
    }



    @Override
    public boolean shouldFilter() {


        RequestContext requestContext = RequestContext.getCurrentContext();
        HttpServletRequest request = requestContext.getRequest();

        //只对订单接口限流
        if ("/apigateway/order/api/v1/order/save".equalsIgnoreCase(request.getRequestURI())){
            return true;
        }

        return false;
    }

    @Override
    public Object run() throws ZuulException {
        RequestContext requestContext = RequestContext.getCurrentContext();
		//取令牌
        if(!RATE_LIMITER.tryAcquire()){
            requestContext.setSendZuulResponse(false);
            requestContext.setResponseStatusCode(HttpStatus.TOO_MANY_REQUESTS.value());
        }
        return null;
    }



}

18、链路追踪

1.链路追踪

微服务下一个业务，可能涉及多个服务的调用，通过链路追踪可以完整的看到每个服务的调用情况。

1.Sleuth

一个组件，专门用于记录链路数据的开源组件


[product-server,6866b563060888cb,8cf177314bb7afe4,false]

1、第一个值，spring.application.name的值
			
2、第二个值，6866b563060888cb，sleuth生成的一个ID，叫Trace ID，用来标识一条请求链路，一条请求
链路中包含一个Trace ID，多个Span ID
			
3、第三个值，8cf177314bb7afe4、spanid 基本的工作单元，获取元数据，如发送一个http

4、第四个值：false，是否要将该信息输出到zipkin服务中来收集和展示。




对应的服务上添加依赖
<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>

1.zipkin

官网：https://zipkin.io/
大规模分布式系统的APM工具（Application Performance Management）,基于Google Dapper的基础实现，
和sleuth结合可以提供可视化web界面分析调用链路耗时情况.


2.Zipkin+Sleuth

sleuth收集跟踪信息通过http请求发送给zipkin server，zipkinserver进行跟踪信息的存储以及提供Rest
API即可，Zipkin UI调用其API接口进行数据展示

默认存储是内存，可也用mysql、或者elasticsearch等存储


3.加入依赖
<! -- 里面包含 spring-cloud-starter-sleuth、spring-cloud-sleuth-zipkin -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>


4.配置属性

#执行服务名称
spring:
  application:
    name: order-server
  #zipkin服务地址
  zipkin:
    base-url: zipkin服务地址
  #配置采样百分比  默认是0.1 开发时可以配置为1 100%
  sleuth:
    sampler: 1

		

19、配置中心

配置中心：

统一管理配置, 快速切换各个环境的配置

相关产品：
	百度的disconf 
	地址:https://github.com/knightliao/disconf
			
	阿里的diamand
	地址：https://github.com/takeseem/diamond

	springcloud的configs-server:
	地址：http://cloud.spring.io/spring-cloud-config/

搭建配置中心服务

1.pom包

<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>


2.启动类上添加注解

@EnableConfigServer


3.配置文件

server:
  port: 9100


#将配置中心注入注册中心
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/


#服务名称
spring:
  application:
    name: config-server






4.创建配置仓库（GIT）

#服务名称
spring:
  application:
    name: config-server
  #设置配置中心的仓库地址
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/lddjava/config-server.git
          username: 用户名
          password: 密码
          timeout: 5
          #指定默认分支
          default-label: master




访问格式：

多种访问路径，可以通过启动日志去查看
例子 http://localhost:9100/dev/product-server-test.yml

/{name}-{profiles}.properties
/{name}-{profiles}.yml
/{name}-{profiles}.json
/{label}/{name}-{profiles}.yml

name 服务器名称
profile 环境名称，开发、测试、生产
lable 仓库分支、默认master分支

20、服务节点使用配置中心

1.添加依赖

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


2.修改对应服务的配置文件,把application.yml 改为 bootstrap.yml


3.指定注册中心和配置中心


eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

spring:
  application:
    name: product-server
  cloud:
    config:
      discovery:
        #设置使用配置中心服务名
        service-id: config-server
        enabled: true
      #指定分支 默认是master
      label: dev
      #指定使用的文件
      profile: dev




注意点：
   1.配置文件要用bootstrap.yml
   2.默认读取文件名是 服务名称

21、消息总线Bus

消息总线

1、什么是消息
	
   一个事件，需要广播或者单独传递给某个接口

2、为什么使用这个
	
   解决配置中心文件更新了，服务无法动态更新


3.结合RabbitMQ使用

官方文档：http://www.rabbitmq.com/getstarted.html
中文文档：http://rabbitmq.mr-ping.com/

4.实战系列使用Docker搭建RabbitMQ3.7




1、安装步骤

1.拉取镜像：docker pull rabbitmq:management
2.查看当前镜像列表：docker images
3.删除指定镜像：docker rmi  IMAGE_ID  (如果需要强制删除加 -f)
			
4.创建容器

docker run -d --name="myrabbitmq" -p 5672:5672 -p 15672:15672 rabbitmq:management

参数讲解: 
	run: 创建一个新的容器并运行一个命令
	-d: 后台运行容器，并返回容器ID
	-p: 端口映射，格式为：主机(宿主)端口:容器端口
	--name="rabbitmq": 为容器指定一个名称


3、RabbitMQ默认创建了一个 guest 用户，密码也是 guest, 如果访问不了记得查看防火墙，端口或者云
服务器的安全组

管理后台：http://ip:15672

22、服务节点使用消息总线动态获取配置文件的变化

1.config-client引入依赖

<!--配置中心结合消息队列-->
		       
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

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


2、在配置文件中增加关于RabbitMQ的连接(如果是本机，则可以直接启动，采用默认连接配置)

spring:
  application:
    name: product-server
  cloud:
    config:
      discovery:
        service-id: config-server
        enabled: true
      label: dev
      profile: dev
  rabbitmq:
    host: 192.168.182.162
    port: 5672
    username: guest
    password: guest

#暴露全部的监控信息
management:
  endpoints:
    web:
      exposure:
        include: "*"


3、需要刷新配置的地方，增加注解 
   @RefreshScope



@RestController
@RequestMapping("/api/v1/product")
@RefreshScope
public class ProductController {

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

    @Value("${ftype}")
    private String type;



4.修改git仓库config-client对应的配置文件


5.手动post请求当前config-client项目

http://ip:port/actuator/bus-refresh

23、配置中心服务以Ip+Port显示

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
  #在注册中心以Ip+Port显示服务    
  instance:
    instance-id: ${spring.cloud.client.ip-address}:${server.port}
    prefer-ip-address: true