SpringCloud

点击量:54

springcloud基础篇 包含: eureka,ribbon,feign,hystrix,zuul,config 六个组件

微服务

        将一个整体的服务按不同的需求拆分成分散的小服务.每个小服务独自完成自己的所属的小任务.

微服务架构

        一种架构模式,服务以服务之间采用轻量级的通信机制

微服务的优点

  1.         每个服务足够内聚,足够小,代码容易聚焦于一个指定的业务功能或业务需求

  2.         开发简单,开发效率高,一个服务可能就是专门干一件事

  3.         微服务能被小团队单独开发

  4.         微服务是解耦合的,是有功能意义的服务,在开发的各个阶段都是独立的

  5.         微服务能够使用不同的语言开发

  6.         易于第三方集成,微服务允许容易且灵活的方式集成自动部署,通过持续集成工具,如Jenkins,Hudson,bamboo

  7.         微服务易于被一个开发人员理解,修改和维护

  8.         微服务允许融合最新技术

  9.         微服务只是业务逻辑代码,不会和html,css或其他页面组件混合

  10.         每个微服务都有自己的存储能力,可以有自己的数据库,也可以有统一的数据库


看待微服务的角度(整个微服务体系)

  1.         服务开发 springBoot , spring ,

  2.         服务配置与管理

  3.         服务注册与发现 Eureka

  4.         服务调用

  5.         服务负载均衡 Ribbon,Feign

  6.         服务监控    

  7.         服务接口调用

  8.         消息队列

  9.         服务配置中心管理

  10.         ...


微服务备选方案

    SpringCloud      ----    spring 完整的微服务架构

    Motan               ----    新浪 RPC框架

    gRPC                 ----    google RPC框架

    Thrift                 ----    RPC框架

    Dubbo              ----    alibaba RPC框架


选择SpringCloud作为微服架构

 Dubbo   SpringCloud   
  服务注册中心  Zookeeper  SpringCloud Netfilx Eureka
  服务调用方式  RPC 远程过程调用  REST API HTTP Rest风格
  服务监控  Dubbo-monitor  Spring Boot Admin
  断路器  不完善  SpringCloud Netflix Hystrix
  服务网关 无  SpringCloud Netflix Zuul
  分布式配置 无  SpringCloud Config
  服务跟踪  无   SpringCloud Sleuth
  消息总线 无  SpringCloud Bus
  数据流 无  SpringCloud Stream
  批量任务 无  SpringCloud Task



SpringBoot和SpringCloud的关系

    springboot 是专注于快速,方便的开发单个微服务个体

    springcloud 关注全局服务治理框架

    boot可以离开cloud独立使用,但是cloud必须依赖boot


QuickStart

大致流程:

    1.搭建整体父工程 project
    2.搭建公共子模块 module
    3.创建微服务提供者 module
    4.创建微服务消费者 module

创建Maven父工程

打包方式POM

依赖:

    <!--依赖版本管理-->
   <dependencyManagement>
       <dependencies>
           <dependency>
               <groupId>org.springframework.cloud</groupId>
               <artifactId>spring-cloud-dependencies</artifactId>
               <version>Greenwich.RELEASE</version>
               <type>pom</type>
               <scope>import</scope>
           </dependency>


           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-dependencies</artifactId>
               <version>2.1.5.RELEASE</version>
               <type>pom</type>
               <scope>import</scope>
           </dependency>


           <!--MySQL数据库-->
           <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
               <version>8.0.13</version>
           </dependency>


           <!--Druid连接池-->
           <dependency>
               <groupId>com.alibaba</groupId>
               <artifactId>druid</artifactId>
               <version>1.1.16</version>
           </dependency>

           <!--mybatis启动器-->
           <dependency>
               <groupId>org.mybatis.spring.boot</groupId>
               <artifactId>mybatis-spring-boot-starter</artifactId>
               <version>2.0.1</version>
           </dependency>

           <!--日志组件-->
           <dependency>
               <groupId>ch.qos.logback</groupId>
               <artifactId>logback-core</artifactId>
               <version>1.2.3</version>
           </dependency>


           <!--Junit单元测试-->
           <dependency>
               <groupId>junit</groupId>
               <artifactId>junit</artifactId>
               <version>4.13</version>
               <scope>test</scope>
           </dependency>

           <!--Log4j日志-->
           <dependency>
               <groupId>log4j</groupId>
               <artifactId>log4j</artifactId>
               <version>1.2.17</version>
           </dependency>

           <!--Lombok-->
           <dependency>
               <groupId>org.projectlombok</groupId>
               <artifactId>lombok</artifactId>
               <version>1.16.22</version>
           </dependency>
       </dependencies>
   </dependencyManagement>


Eureka 注册中心

    EurekaServer 服务端
    EurekaClient 客户端

    遵守AP原则, 基于REST的服务,用于定位服务,以实现云端中间层服务发现和故障转移.

    只需要使用服务的标识符,就可以访问当服务,而不需要修改服务调用的配置文件.



Eureka注册中心搭建

1. 导入eureka坐标
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka-server</artifactId>
<version>1.4.7.RELEASE</version>
</dependency>

2. 编写application.yml
server:
port: 7001
eureka:
instance:
hostname: localhost
client:
register-with-eureka: false   //表示不向注册中心注册自己
fatch-registry: false //表示自己就是注册中心,不需要注册中心在这里寻找服务
service-url:
defaultZone: http://${eureka.instance.hostname}:${server.port}/erueka/
//表示与eureka交互的地址

3. 在启动类上标注启动该组件的注解
@EnableEurekaserver //开启eureka服务的注解


服务提供者向Eureka注册服务

1. 服务提供方添加eureka客户端依赖
<!--eureka客户端-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka</artifactId>
<version>1.4.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>

2. 配置application.yml 中把客户端注册进eureka服务列表

eureka:
client:
   service-url:
     defaultZone: http://localhost:7001/eureka
     
3. 在主启动类上添加注解,说明自己是eureka客户端
@EnableEurekaClient   //服务启动后,会自动注册进eureka

4. 重启Eureka服务端和服务提供者
微服务名称: 提供者: spring.application.name


Eureka改进(Eureka界面服务详情)(修改服务提供方)

  1. 修改服务提供者主机别名(服务提供者YML)

    eureka:  
    client:    
    service-url:      
    defaultZone: http://localhost:7001/eureka  
    instance:
              instance-id: microservicecloud-dept
  2. 访问信息有IP信息提示(将超链接改为ip地址)(服务提供者YML)

    eureka:
    client:
      service-url:
        defaultZone: http://localhost:7001/eureka
    instance:
      instance-id: microservicecloud-dept   #设置eureka中服务的别名
      prefer-ip-address: true             #访问路径可以显示ip地址
  3. 服务详细信息页面展示(服务提供者POM)

    • 添加POM依赖

      # 添加依赖
      <!--管理监控springboot配置-->
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
      </dependency>
    • 父工程中添加构建信息

      application.yml中 以$开头的为提示信息

      <build>
             <!--父工程名字-->
             <finalName>microservicecloud</finalName>
             <resources>
                 <resource>
                     <directory>src/main/resources</directory>
                     <filtering>true</filtering>
                 </resource>
             </resources>

             <plugins>
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-resources-plugin</artifactId>
                     <configuration>
                         <delimiters>
                             <delimit>$</delimit>
                         </delimiters>
                     </configuration>
                 </plugin>
             </plugins>
         </build>
    • 服务提供者application.yml中添加提示信息

      # 用于在Eureka中向用户提示的服务信息
      info:
      app.name: lsli-microservicecloud
      company.name: LSLI
      build.artifactId: $project.artifactId$
      build.version: $project.version$



Eureka自我保护机制

当EurkaServer节点在短时间内丢失过多客户端时,那么这个节点就会进入自我保护模式

自我保护机制: 某时刻存在一个微服务不可用了,eureka不会立刻清理,依旧会对该微服务的信息进行保存

自我保护模式中,EurekaServer会保护服务注册表中的信息,不再注销任何服务实例,当它收到的心跳数重新恢复到阈值以上时,该EurkaServer节点就会自动退出自我保护模式. 宁可保留错误的服务注册信息,也不盲目注销任何可能健康的服务实例.

自我保护关闭方式(一般不用):

eureka.server.enable-self-preservation=false  #禁用自我保护


Eureka服务发现 ?

  • 服务提供方主启动类添加注解

    @EnableDiscoveryClient //开启服务发现

  • 测试: 访问localhost:8001/dept/discovery


Eureka集群配置

  • 新建工程 microservicecloud-eurka-7002

  • 新建工程 microservicecloud-eurka-7003

    • 导入依赖,参考7001

    • 修改主启动类文件名

    • 模拟集群环境,修改hosts文件

      127.0.0.1   eureka7001.com
      127.0.0.1 eureka7002.com
      127.0.0.1 eureka7003.com
    • 修改每个eureka中yml文件. 每个节点都要保存其他节点的信息

      server:
      port: 7003

      eureka:
      instance:
        hostname: eureka7003.com

      client:
        register-with-eureka: false   #表示不向注册中心注册自己
        fetch-registry: false  #false 表示自己就是注册中心,不需要从自己这里寻找服务
        service-url:
           #defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ # 设置与Eureka的交互地址 单机版
          defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/  # 集群版
  • 修改服务提供者的yml(将所有eureka节点ip添加到服务提供者)

    eureka:
    client:
      service-url:
         #defaultZone: http://localhost:7001/eureka 单机版
        defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7003/eureka/,http://eureka7003.com:7003/eureka/ #集群版
    instance:
      instance-id: microservicecloud-dept-8001   #设置eureka中服务的别名
      prefer-ip-address: true             #访问路径可以显示ip地址


Zookeeper 与 Eureka

CAP(用于描述非关系型数据库): C:强一致性 A:可用性 P:分区容错性

任何一个分布式系统都只能同时较好的满足CAP中的两个条件

CP:MongoDB,HBase,Redis 满足可用性

CA:RDBMS

AP:CouchDB,Cassandra,DynamoDB,Riak

zookeeper遵守CP原则

因为有主从关系,可以确保Zookeeper中的信息永远是最新的,但是如果集群中某个zookeeper节点挂掉,整个集群需要花费大量时间选举Leader.

Eureka遵守AP原则

Eureka中各个节点都是平等的,几个节点挂掉不会影响其他节点的工作. 但是Eureka不能保证强一致性.剩下部分的节点信息可能不是最新的.

Eureka有自我保护机制,如果15分钟内超过85%的节点都没有正常心跳,那么Eureka会认为客户端与注册中心出现了网络故障.从而进入保护模式.



Ribbon 负载均衡

SpringCloud Ribbon是基于NetflixRibbon实现的一套客户端软负载均衡工具

他可以和其他所需请求的客户端结合使用,和Eureka结合只是其中一个实例

负载均衡LB {集中式负载均衡(硬件) , 进程内负载均衡(软件)}


服务发现:

1. 消费端添加pom依赖
eureka客户端
ribbon
config
2. 消费端application.yml添加eureka注册地址
3. RestTemplate的配置Bean上添加 @LoadBalanced注解,开启自带负载均衡
4. 在启动类上添加@EnableEurekaClient与Eureka整合
5. 修改客户端的访问类(由自己寻找服务转为由Eureka寻找服务)
  • 消费端添加Ribbon依赖

      <!--Eureka客户端-->
           <dependency>
               <groupId>org.springframework.cloud</groupId>
               <artifactId>spring-cloud-starter-eureka</artifactId>
               <version>1.4.7.RELEASE</version>
           </dependency>

           <dependency>
               <groupId>org.springframework.cloud</groupId>
               <artifactId>spring-cloud-starter-ribbon</artifactId>
               <version>1.4.7.RELEASE</version>
           </dependency>
           <dependency>
               <groupId>org.springframework.cloud</groupId>
               <artifactId>spring-cloud-starter-config</artifactId>
               <version>1.4.7.RELEASE</version>
           </dependency>
  • 消费端application.yml添加eureka注册地址

    #消费者向Eureka获取服务地址
    eureka:
    client:
      register-with-eureka: false  # 自己不向Eureka注册
      service-url:
         #defaultZone: http://localhost:7001/eureka 单机版
        defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7003/eureka/,http://eureka7003.com:7003/eureka/ #集群版
  • 使RestTemplate自带负载均衡

    @Bean
    @LoadBalanced   //开启自带负载均衡
    public RestTemplate getRestTemplate() {
       return new RestTemplate();
    }
  • 在启动类上添加@EnableEurekaClient与Eureka整合

    @SpringBootApplication
    @EnableEurekaClient
    public class DeptConsumer80_APP {
       public static void main(String[] args) {
           SpringApplication.run(DeptConsumer80_APP.class, args);
      }
    }
  • 修改客户端的访问类

    //private static final String URL_PREFIX = "http://localhost:8001";  //自己寻找服务的方式
    private static final String URL_PREFIX = "http://MICROSERVICECLOUD-DEPT";  //从Eureka中寻找服务
  • 启动测试

Eureka与Ribbon整合后,消费者(Consumer)可以直接调用服务,而不用再关心地址和端口号了


负载均衡:

当同一个服务在Eureka中注册了不同的实例时.消费者开启ribbon客户端软负载均衡, 默认以轮询的方式调用服务.若使用期间有服务挂掉,则轮询不再包含挂掉的服务.如果服务再次上线,则会重新加入轮询


Ribbon核心组件IRule

Ribbon自带七种负载均衡算法

# RoundRobinRule    轮询(默认)
# RandomRule 随机
# AvailabilityFilteringRule  
会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务,以及并发数量超过阈值的服务,然后对剩余的服务列表按照轮询策略进行访问
# WeightedResponseTimeRule
更具平均响应时间计算所有服务的权重,响应时间越快的服务权重越大,被选中的概率越高,刚启动时如果统计信息不足,则使用RoundRobinRule(轮询)策略,等统计信息足够,会自动切换到WeightResponseTimeRule
# RetryRule
先按照轮询的策略获取服务,如果获取服务失败则在指定时间内会进行重试,获取可用服务
# BestAvailableRule
会先过滤掉掉由于多次访问故障而处于断路器跳闸状态的服务,然后选择一个并发量最小的服务
# ZoneAvoidanceRule
默认规则,服务判断server所在区域的性能和server的可用性选择服务器
算法更换
// 在消费者端的配置类中 添加获取IRule规则的方法
@Bean
public IRule myRule() {
   return new RandomRule();
}

//重启消费者
自定义算法
  • 消费者端服务启动类上添加 @RibbonClient注解

    @RibbonClient(name="MICRO-DEPT",configuration=MyRule.class)
  • 编写自定义Rule.class

    编写的必须在配置类中加载,但是配置类不能放在主启动类及其子包下
    1. 编写MyRule.java
    2. 在主启动类以及当前包以及子包外定义配置类
  • 自定义规则



Feign负载均衡

rest 客户端负载均衡.适应社区其他程序员, 面向接口编程.通过接口调用微服务

Ribbon+RestTemplate,利用RestTemplate对Http对Http请求进行封装处理.形成一套模板化调用方式.

实际开发中,往往一个接口会被多处调用,所以通常都会针对每个微服务自动封装一些客户端类来包装这些依赖服务的调用

目的: 能够像Dubbo一样直接注入service(面向接口编程)

实际上还是使用了微服务名称进行调用,即便没有在消费者controller上编写微服务名称,也在BASE模块的Service接口上填写了微服务名称.


start

  • 创建消费者模块

  • 导入pom依赖(基于接口, base模块也要导入)

    <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-feign</artifactId>
       <version>1.4.7.RELEASE</version>
    </dependency>
  • BASE模块创建service接口(在接口处根据微服务名称调用微服务)


    @FeignClient("MICROSERVICECLOUD-DEPT")
    public interface DeptClientService {


       @GetMapping("/dept/get/{id}")
       public Dept getOne(@PathVariable("id") Long id);


       @GetMapping("/dept/list")
       public List<Dept> deptList();


       @PostMapping("/dept/add")
       public Boolean add(Dept dept);
    }
  • 消费者启动类使用Feign进行软负载均衡 @EnableFeignClients()

    @SpringBootApplication
    @EnableEurekaClient
    @EnableFeignClients(basePackages = "com.li.springcloud")
    public class DeptConsumer_Feign_APP {
       public static void main(String[] args) {
           SpringApplication.run(DeptConsumer_Feign_APP.class, args);
      }
    }
  • 编写调用服务者API Controller

    controller中注入接口,直接调用注入的service,由feign内部完成注入

    @Autowired
    private DeptClientService deptClientService;
    //出现没有这个Bean的提示,可以直接忽略

    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
       return this.deptClientService.getOne(id);
    }
    ...
  • 测试

注意

Feign底层使用的是ribbon,所以修改负载均衡算发,也就是修改ribbon的负载均衡算法.



Hystrix断路器(熔断器)

服务熔断,服务降级,服务限流,接近实时的监控...

避免调用单次服务失败导致整个系统瘫痪

Hystrix是一个用于处理分布式系统的延迟和容错的开源库,在分布式系统里,许多依赖不可避免的会调用失败,超时,异常等.Hystrix能够保证在一个依赖出问题的情况下,不会导致整体服务失败,避免级联故障,以提高分布式系统的弹性.

向调用方返回一个符合预期的,可处理的备选响应(FallBack),而不是长时间的等待或抛出调用方无法处理的异常.


服务熔断

Start
  • 创建服务提供者

  • 导入依赖+其他相关依赖

    <!--hystrix-->
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-hystrix</artifactId>
      <version>1.4.7.RELEASE</version>
    </dependency>
  • 修改YML(修改在Eureka中注册的实例名称)

    instance-id: microservicecloud-dept-8001-hystrix
  • 修改提供者的controller

    //方法上添加注解
    @GetMapping("/dept/get/{id}")
    @HystrixCommand(fallbackMethod="errorMethod")
    public Dept findOne(@PathVariable("id") Long id){
    Dept one = deptService.findOne(id);
       if (one == null) {
          throw  new RuntimeException("没有查找到任何信息");
      }
       return one;
    }

    //hystrix熔断方法
    public Dept errorMethod(@PathVariable("id") Long id) {
      Dept dept = new Dept();
      dept.setDeptno(id);
      dept.setDname("未查找到此用户信息");
      dept.setDb_source("数据库中没有此用户信息");
      return dept;
    }
  • 主启动类开启对Hystrix的支持

    @EnableCircuitBreaker  //开启对hystrix的支持
  • 测试


服务降级

避免服务雪崩

客户端可以自己准备一个fallback返回,返回一个缺省值

整体资源不足了,先将某些服务关闭,等资源充足了,再将服务开启

服务降级的处理是在客户端,服务熔断是在服务端

当服务端挂掉,使用降级处理,让客户端在服务端不可用时也会获得提示信息而不会挂起耗死服务器


HystrixDashboard 服务监控

Hystrix提供了准实时的调用监控,

Start
  • 新建工程DashBoard

  • 导入POM

    <!--hystrix-->
    <dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-starter-hystrix</artifactId>
     <version>1.4.7.RELEASE</version>
    </dependency>

    <!--hystrix-dashboard-->
    <dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
     <version>1.4.7.RELEASE</version>
    </dependency>
  • 修改APPLICATION.YML

    server:
    port: 9001
  • 添加主启动类,并添加注解 @EnableHystrixDashboard

    @SpringBootApplication
    @EnableHystrixDashboard  //开启监控服务
    public class HystrixDashBoard_APP {
       public static void main(String[] args) {
           SpringApplication.run(HystrixDashBoard_APP.class, args);
      }
    }
  • 所有的服务提供者Provider都需要监控依赖配置

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
  • 启动Dashboard测试

    访问localhost:9001/hystrix 进入豪猪界面

  • 图形化监控

    • Title: 标题自定义

    • 因为版本问题,提供者启动类需要@Bean

      @Bean
         public ServletRegistrationBean getServlet(){
             HystrixMetricsStreamServlet streamServlet = new HystrixMetricsStreamServlet();
             ServletRegistrationBean registrationBean = new ServletRegistrationBean(streamServlet);
             registrationBean.setLoadOnStartup(1);
             registrationBean.addUrlMappings("/actuator/hystrix.stream");
             registrationBean.setName("HystrixMetricsStreamServlet");
             return registrationBean;
        }
    • 豪猪页面: http://localhost:8001/actuator/hystrix.stream

Delay: 控制服务器上轮询监控信息的延迟时间,默认2000毫秒



Zuul路由网关

代理 + 路由 + 过滤

Zuul也会整合到Eureka,注册进Eureka

Start
  • 新建Zuul模块

  • 导入pom + 其他标配

    <!--Eureka客户端-->
    <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-eureka</artifactId>
       <version>1.4.7.RELEASE</version>
    </dependency>
    <!--路由网关zuul-->
    <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-zuul</artifactId>
       <version>1.4.7.RELEASE</version>
    </dependency>
  • 编写yml

    # 和服务提供者一样,只改服务名  + 实例名 + 服务端口号
  • 创建启动类并添加注解@EnableZuulProxy

    @SpringBootApplication
    @EnableZuulProxy  //开启路由
    public class Zuul_Gataway9500_APP {
       public static void main(String[] args) {
           SpringApplication.run(Zuul_Gataway9500_APP.class, args);
      }
    }
  • 测试1: 不用路由直接调用服务

    localhost:8001/dept/get/1

  • 测试2: 使用路由转发调用服务

    http://zuul.com:9500/microservicecloud-dept/dept/get/1

路由访问的映射规则

在zuul模块的yml中添加

#将真名称隐藏,假的名称暴露  
zuul:
#屏蔽单一微服务访问
ignored-services: microservicecloud-dept
#路径映射
routes:
depts.serviceId: microservicecloud-dept
depts.path: /depts/**

访问: http://zuul.com:9500/depts/dept/get/1 能正常访问

屏蔽所有微服务名称访问

zuul:
#屏蔽所有微服务名称访问
ignored-service: "*"

#统一访问前缀
prefix: /lsli

访问: http://zuul.com:9500/lsli/depts/dept/get/1 能正常访问



SpringCloud Config分布式配置中心

作用:
1. 集中管理配置文件
2. 不同环境不同配置,动态化的配置更新,分布环境部署
3. 运行期间动态调整配置,不再需要在每个服务部署的机器上编写配置文件
4. 当配置发生改变时,服务不需要重启即可感知到配置的变化并应用新的配置
5. 将配置信息以rest接口的形式暴露
6. 与github整合

SpringCloud config分为服务端和客户端

Start
  • 在GitHub上创建一个repository,获取SSH协议的地址

  • 在本地硬盘上创建新的Git本地仓库并克隆

    git clone git@XXX.xxx
  • 在本地仓库创建application.yml

    必须 保存为UTF-8格式

  • 将文件保存到GitHub

    git add .
    git commit -m "my config file"
    git push origin master
  • 新建config模块

  • 导入POM依赖

    <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-config-server</artifactId>
       <version>1.4.7.RELEASE</version>
    </dependency>
  • 编写YML

    server:
    port: 3344
    spring:
    application:
    name: microservicecloud-config  #当前服务名称
    cloud:
    config:
    server:
    git:
    url: git@XXX.xxx.git  #git仓库名称
  • 启动测试

    http://localhost:3344/application-xxx.yml


配置读取规则

# /application/dev/master    可以访问带分支的配置
# /master/application/dev
# /application-xxx

bootstrap.yml是系统级的配置文件,优先级更高


感谢您的阅读
文章由作者个人总结,欢迎指出文章错误

1楼  段小楼AA  2019-09-03 06:45

博主写的很详细




上一篇:使用java操作阿里大于的短信业务