springcloud入门

SpringCloud简介

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

　　主要分为以下五个部分，本次主要讲解服务的发现与注册—Eureka与客户端负载均衡—Ribbon，再通过搭建工程来展示。

• 服务发现与注册——Netflix Eureka

• 客服端负载均衡——Netflix Ribbon

• 断路器——Netflix Hystrix

• 服务网关——Netflix Zuul

• 分布式配置——Spring Cloud Config

　　下面我先简要的对Eureka即Ribbon做一个介绍，具体的代码以及配置文件在后面的案例中再来展示

一、Eureka注册中心——Eureka Server

　　在我们现在的前后端分离架构中，服务层被拆分成了很多的微服务，这时候SpringCloud中提供了服务注册中心来管理微服务信息。

　　功能：

• 注册中心帮我们管理微服务的ip和端口，进行远程调用服务
• 微服务实时上报自己的状态，注册中心统一管理这些微服务的状态，将存在问题的服务踢出服务列表，客户端获取到可用的服务进行调用

　　Eureka介绍：

　　Spring Cloud Eureka提供服务端与客户端，服务端即是Eureka服务注册中心，客户端完成微服务向Eureka服务的注册与发现。服务端和客户端均采用Java语言的编写，下图是服务端与客户端之间的关系：

　　1、Eureka Server是服务端，负责管理各微服务节点的信息和状态，就是作为一个注册中心的功能

　　2、在微服务上部署Eureka Client程序，远程访问Eureka Server将自己注册在Eureka Server上

　　3、微服务需要调用另一个微服务时从Eureka Server中获取服务调用地址，进行远程调用其他的微服务

　　总结：就是Eureka Server作为一个注册中心，所有的Eureka Client作为微服务的提供者将服务注册到Eureka Server中来让其他的微服务进行调用。为服务工程同时充当服务者与消费者两种角色，只是看在一个服务进程当中所起的作用。

• Eureka Server工程搭建：

• 作为注册中心的Eureka Server工程中需要
  • 添加eureka-server的依赖
  • 在启动类上加上EnableEurekaServer注解标识这是一个Eureka的服务
  • 配置文件中配置相关eureka的参数
• Eureka Server的高可用环境：
  • 我们至少部署两个Eureka Server，端口号设置为不一样，相互向对方注册

• 在实际使用时Eureka Server至少部署两台服务器，实现高可用
• 两台Eureka Server相互注册
• 微服务需要连接两台Eureka Server，当其中一台Eureka死掉也不会影响服务的注册与发现
• 微服务会定时向Eureka Server发送心跳，报告自己的状态
• 微服务从注册中心获取服务地址以Restful方式发起远程调用

二、eureka客户端——Eureka Client

　　eureka的客户端中，微服务工程将服务注册到注册中心，通过注册中心获取其他为微服务的猪血信息，调用与被调用其他的微服务。

• Eureka Client工程搭建：
  • 配置服务的提供者，添加eureka-client的依赖
  • 配置文件中配置相关eureka Client的参数
  • 启动类上添加注解@EnableDiscoveryClient，表示这是一个Eureka客户端
• 在我们需要实现负载均衡调用服务的时候需要创建一个以上的工程来提供同一个服务，这些工程有不同的端口号以及相同的服务名称

三、远程调用——Ribbon

　　在前后端的分离架构中，服务层被拆分成很多的微服务，服务与服务之间相互交互，就是远程调用的过程。

• 首先我们的工程也是一个Eureka Client的客户端
• 服务调用端将自己注册到注册中心
• 从注册中心获取自己需要的服务的地址
远程调用服务 ---- 调用服务中的消费者与服务提供者是一个相对的概念
• 在自己调用其他工程的服务时，自己充当的是消费者的角色，被调用方充当的是服务提供者的角色
• 反之，当自己被其他工程调用是，角色则发生了反转
• 但是，相对于Eureka来讲，不管是消费者还是服务提供者都是作为Eureka的客户端

　　1.Ribbon

　　一个基于Http、TCP的客户端负载均衡器。不同于我们了解的Nginx等是作为服务端负载均衡器。Ribbon负载均衡的流程图如下：

• 在消费为服务使用Ribbon实现负载均衡，Ribbon先从EurekaServer中获取服务列表
• Ribbon根据负载均衡算法去调用微服务
• Ribbon的远程调用是由RestTemplate提供的，而RestTemplate又基于HttpClient、OKHttp等

　　使用Ribbon的功能需要：

• 在工程中引入ribbon以及OKHttp（或者其他能工提供远程访问请求的底层客户端）的依赖
• 在配置文件中配置ribbon的相关参数
• 在启动类中上同样需要配置@EnableDiscoveryClient注解来表示自己为Eureka的客户端
• 创建bean对象RestTemplate，在RestTemplate上使用注解@LoadBalance（标识使用Ribbon的注解）

　　2、feign

　　底层封装了Ribbon，通过定义接口加上Feign的注解，通过代理的方式创建出接口的实现类，通过调用接口接口中的方法来实现远程调用。

• 需引入Feign（Feign中封装了Ribbon）以及OKHttp的依赖
• 创建被@FeignCLient注解标识的接口——Feign通过代理的方式提供其实现类，调用定义好的方法来实现远程访问
• 配置文件中同样是配置Ribbon的相关配置

四、案例

• 搭建一个总工程：springcloud-demo：引入一些基本依赖
• 搭建两个Eureka Server的module：eureka01和eureka02，两个module相互注册，形成一个高可用的环境
• 搭建两个Eureka Client的module：micro-service01和micro-service02，两个module提供一样的服务，实现在负载均衡条件下的调度
• 搭建一个Eureka Client的modole：ribbonRequest，用于测试ribbon作为负载均衡器的实现
• 搭建一个Eureka Client的module：feignRequest，用于测试feign作为负载均衡器的实现
• 整个工程的架构如下：

　　1.创建springcloud-demo工程，引入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.buwei</groupId>
    <artifactId>springcloud-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>eureka01</module>
        <module>eureka02</module>
        <module>micro-service01</module>
        <module>micro-service02</module>
        <module>ribbon-request</module>
        <module>feign-request</module>
    </modules>
    <packaging>pom</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.SR1</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>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>


</project>

　　2.搭建eureka01和eureka02工程

• eureka01工程：

　　pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud-demo</artifactId>
        <groupId>com.buwei</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>eureka01</artifactId>
    <version>1.0-SNAPSHOT</version>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

　　引导类Eureka01Application

@EnableEurekaServer
@SpringBootApplication
public class Eureka01Application {

    public static void main(String[] args) {
        SpringApplication.run(Eureka01Application.class, args);
    }
}

　　配置文件

server:
  port: 31001 # 服务端口
spring:
  application:
    name: springcloud-eureka # 指定服务名
eureka:
  instance:
    hostname: eureka01
  client:
    register-with-eureka: true # 被其他服务调用时需要向Eureka注册
    fetch-registry: true # 服务发现，需要从Eureka查找要调用的目标服务时需要设置为true
    service-url: # Eureka客户端与Eureka服务端的交互地址，高可用状态配置对方的地址，单机状态配置自己（如果不配置则默认本机8761端口）
      defaultZone: http://127.0.0.1:31002/eureka/ # 类似于dubbox中的注册中心地址
  server:
    enable-self-preservation: false # 是否开启自我保护模式
    eviction-interval-timer-in-ms: 60000 # 服务注册表清理间隔（单位：毫秒，默认是60*1000）

• eureka02工程

　　pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud-demo</artifactId>
        <groupId>com.buwei</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>eureka02</artifactId>
    <version>1.0-SNAPSHOT</version>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

　　引导类

@EnableEurekaServer
@SpringBootApplication
public class Eureka02Application {

    public static void main(String[] args) {
        SpringApplication.run(Eureka02Application.class, args);
    }
}

　　配置文件

server:
  port: 31002 # 服务端口
spring:
  application:
    name: springcloud-eureka # 指定服务名
eureka:
  instance:
    hostname: eureka02
  client:
    register-with-eureka: true # 被其他服务调用时需要向Eureka注册
    fetch-registry: true # 服务发现，需要从Eureka查找要调用的目标服务时需要设置为true
    service-url: # Eureka客户端与Eureka服务端的交互地址，高可用状态配置对方的地址，单机状态配置自己（如果不配置则默认本机8761端口）
      defaultZone: http://127.0.0.1:31001/eureka/ # 类似于dubbox中的注册中心地址
  server:
    enable-self-preservation: false # 是否开启自我保护模式
    eviction-interval-timer-in-ms: 60000 # 服务注册表清理间隔（单位：毫秒，默认是60*1000）

　　3.搭建micro-service01和micro-service02工程

• micro-service01工程

　　pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud-demo</artifactId>
        <groupId>com.buwei</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>micro-service01</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- 导入Eureka客户端的依赖 -->
        <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-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

　　引导类MicroService01Application

@EnableDiscoveryClient
@SpringBootApplication
public class MicroService01Application {

    public static void main(String[] args) {
        SpringApplication.run(MicroService01Application.class, args);
    }
}

　　controller层MicroService01Controller

@RestController
public class MicroService01Controller {

    /**
     * 提供Ribbon的请求
     * @return
     */
    @GetMapping("/ribbonRequest")
    public String testRibbonRequest(){
        return "MicroService01-RibbonRequest";
    }

    /**
     * 提供Feign的请求
     * @return
     */
    @GetMapping("/feignRequest")
    public String testFeignRequest(){
        return "MicroService01-FeignRequest";
    }
}

　　配置文件application.yml

server:
  port: 41001
spring:
  application:
    name: springcloud-micro-service
eureka:
  client:
    registerWithEureka: true #服务注册开关
    fetchRegistry: true #服务发现开关
    serviceUrl: #Eureka客户端与Eureka服务端进行交互的地址，多个中间用逗号分隔
      defaultZone: http://localhost:31001/eureka/,http://localhost:31002/eureka/
  instance:
    prefer-ip-address: true  #将自己的ip地址注册到Eureka服务中
    ip-address: 127.0.0.1
    instance-id: ${spring.application.name}:${server.port} #指定实例id

• MicroService02工程

　　pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud-demo</artifactId>
        <groupId>com.buwei</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>micro-service02</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- 导入Eureka客户端的依赖 -->
        <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-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

　　引导类MicroService02Application

@EnableDiscoveryClient
@SpringBootApplication
public class MicroService02Application {

    public static void main(String[] args) {
        SpringApplication.run(MicroService02Application.class, args);
    }
}

　　controller层MicroService02Controller

@RestController
public class MicroService02Controller {

    @GetMapping("/ribbonRequest")
    public String testRibbonRequest(){
        return "MicroService02-RibbonRequest";
    }

    @GetMapping("/feignRequest")
    public String testFeignRequest(){
        return "MicroService02-FeignRequest";
    }
}

　　配置文件application.yml

server:
  port: 41002
spring:
  application:
    name: springcloud-micro-service
eureka:
  client:
    registerWithEureka: true #服务注册开关
    fetchRegistry: true #服务发现开关
    serviceUrl: #Eureka客户端与Eureka服务端进行交互的地址，多个中间用逗号分隔
      defaultZone: http://localhost:31001/eureka/,http://localhost:31002/eureka/
  instance:
    prefer-ip-address:  true  #将自己的ip地址注册到Eureka服务中
    ip-address: 127.0.0.1
    instance-id: ${spring.application.name}:${server.port} #指定实例id

　　4、Ribbon测试工程ribbon-request

 　　pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud-demo</artifactId>
        <groupId>com.buwei</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ribbon-request</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- 导入Eureka客户端的依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <!--引入ribbon的依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
            <version>RELEASE</version>
        </dependency>

        <!--ribbon发起远程调用的底层客户端-->
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</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-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

　　引导类：RibbonRequestApplication

@EnableDiscoveryClient
@SpringBootApplication
public class RibbonRequestApplication {

    public static void main(String[] args) {
        SpringApplication.run(RibbonRequestApplication.class, args);
    }

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

　　配置文件：application.yml

server:
  port: 8080 #u8BF7u6C42u5904u7406u7684u8D85u65F6u65F6u95F4
spring:
  application:
    name: consumer
eureka:
  client:
    registerWithEureka: true #服务注册开关
    fetchRegistry: true #服务发现开关
    serviceUrl: #Eureka客户端与Eureka服务端进行交互的地址，多个中间用逗号分隔
      defaultZone: http://localhost:31001/eureka/,http://localhost:31002/eureka/
  instance:
    prefer-ip-address:  true  #将自己的ip地址注册到Eureka服务中
    ip-address: 127.0.0.1
    instance-id: ${spring.application.name}:${server.port} #指定实例id
ribbon:
  MaxAutoRetries: 2   #最大重试次数，当Eureka中可以找到服务，但是服务连不上时将会重试
  MaxAutoRetriesNextServer: 3 #切换实例的重试次数
  OkToRetryOnAllOperations: false  #对所有操作请求都进行重试，如果是get则可以，如果是post，put等操作
                                    #没有实现幂等的情况下是很危险的,所以设置为false
  ConnectTimeout: 5000    #请求连接的超时时间
  ReadTimeout: 6000  #请求处理的超时时间

　　测试类：RibbonTest

@SpringBootTest
@RunWith(SpringRunner.class)
public class RibbonTest {
    @Autowired
    private RestTemplate restTemplate;

    @Test
    public void testRibbon(){
        String name = "springcloud-micro-service"; // 大小写均可
        for (int i = 0; i < 10; i++) {
            ResponseEntity<String> forEntity = restTemplate.getForEntity("http://"+name+"/ribbonRequest", String.class);
            String body = forEntity.getBody();
            System.out.println(body);
        }

    }
}

　　5、feign测试工程feign-request

　　pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud-demo</artifactId>
        <groupId>com.buwei</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>feign-request</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- 导入Eureka客户端的依赖 -->
        <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-feign</artifactId>
            <version>RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</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-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>


</project>

　　引导类：FeignRequestApplication

@EnableFeignClients //开始feignClient
@EnableDiscoveryClient
@SpringBootApplication
public class FeignRequestApplication {

    public static void main(String[] args) {
        SpringApplication.run(FeignRequestApplication.class, args);
    }

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

　　实现远程调用的接口：FeignClientInterface

@FeignClient(value = "springcloud-micro-service")
public interface FeignClientInterface {

    @GetMapping("/feignRequest")
    public String feignRequest();
}

　　配置文件：application.yml

server:
  port: 8080 #u8BF7u6C42u5904u7406u7684u8D85u65F6u65F6u95F4
spring:
  application:
    name: consumer
eureka:
  client:
    registerWithEureka: true #服务注册开关
    fetchRegistry: true #服务发现开关
    serviceUrl: #Eureka客户端与Eureka服务端进行交互的地址，多个中间用逗号分隔
      defaultZone: http://localhost:31001/eureka/,http://localhost:31002/eureka/
  instance:
    prefer-ip-address:  true  #将自己的ip地址注册到Eureka服务中
    ip-address: 127.0.0.1
    instance-id: ${spring.application.name}:${server.port} #指定实例id
ribbon:
  MaxAutoRetries: 2 #最大重试次数，当Eureka中可以找到服务，但是服务连不上时将会重试
  MaxAutoRetriesNextServer: 3 #切换实例的重试次数
  OkToRetryOnAllOperations: false  #对所有操作请求都进行重试，如果是get则可以，如果是post，put等操作没有实现幂等的情况下是很危险的,所以设置为false
  ConnectTimeout: 5000  #请求连接的超时时间
  ReadTimeout: 6000 #请求处理的超时时间

　　测试类：FeignTest

@SpringBootTest
@RunWith(SpringRunner.class)
public class FeignTest {

    @Autowired
    private FeignClientInterface feignClientInterface;

    @Test
    public void testFeign(){
        for (int i = 0; i < 10; i++) {
            String s = feignClientInterface.feignRequest();
            System.out.println(s);
        }
    }
}

　　6、执行测试

• 首先开启注册中心：eureka01和eureka02，在首次执行启动类的时候控制台会打印连接不上的报错，这是因为eureka01和eureka02相互注册服务，但是在初次启动时找不到服务，属于正常现象
• 开启两个提供服务的工程micro-service01和micro-service02
• 执行RibbonTest类中的testRibbon()方法，控制台打印如下：
• 
• 执行FeignTest类中的额testFeign()方法，控制台打印如下：
• 
• 发现：无论是用Ribbon还是Feign，在两次测试请求服务的过程中，都是采用轮询的方式向两个提供服务的微服务工程进行调用，实现了负载均衡的调配。