Spring Cloud系列（三）：服务消费与负载均衡

上一篇介绍了服务提供者，有了注册中心和服务提供者，我们就可以进行服务消费了。Spring Cloud可以通过RestTemplate+Ribbon和Feign这两种方式消费服务。

我们仍然在上一篇的项目中添加功能，btw，源码是分章节的，而且后一份代码其实包含了前一份代码，也就是chapter2包含了chapter1的代码，每个chapter的源码其实都是完整可以独立运行的。

一、启动注册中心和服务提供者

先启动之前的注册中心和服务提供者，这里为了方便启动单节点的注册中心就够了，如果想测试注册中心集群的请自行测试，方法在前面的章节已经介绍过，这里就不再赘述。

启动成功后访问http://localhost:8761/，可以看到现在注册的服务只有一个服务提供者

二、RestTemplate+Ribbon

2.1、新建一个module

新建一个Spring Initializr的module，名称为service-consumer-ribbon，选择Spring Web、Eureka Discovery Client和Ribbon三个依赖，完成后主要依赖如下

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<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-ribbon</artifactId>
</dependency>

2.2、创建RestTemplate

为了方便直接在启动类添加好了，另外需要加上注解@EnableEurekaClient，把自身注册到注册中心

@SpringBootApplication
@EnableEurekaClient
public class ServiceConsumerRibbonApplication {

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

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

2.3、创建Service和Controller

创建一个RibbonConsumerService类和一个RibbonConsumerController类

@Service
public class RibbonConsumerService {
    @Autowired
    private RestTemplate restTemplate;

    public String index(String uid) {
        return restTemplate.getForObject("http://SERVICE-PROVIDER/callServiceProvider?uid=" + uid, String.class);
    }
}

@RestController
public class RibbonConsumerController {
    @Autowired
    private RibbonConsumerService ribbonConsumerService;

    @RequestMapping("/index")
    public String index(@RequestParam("uid") String uid) {
        return ribbonConsumerService.index(uid);
    }
}

稍微解释一下这两个类：这两个类的写法其实就和springboot项目中的写法没有什么区别，就是在Controller中调用Service，唯一需要说明的就是Service类中，通过RestTemplate对象来调用服务提供者提供的接口，其中域名SERVICE-PROVIDER（这里姑且认为是域名吧）就是服务提供者的应用名称（在配置文件中指定）。

2.4、添加配置信息

在application.properties文件中添加以下配置

server.port=8080
spring.application.name=consumer-ribbon

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

这时访问http://localhost:8761/可以看到注册的服务多了一个消费者CONSUMER-RIBBON

2.5、测试

在浏览器访问http://localhost:8080/index?uid=ribbon将会返回以下信息

三、Feign

使用Ribbon的方式有一个比较麻烦的地方就是调用提供者的http服务需要手动去构建，而Feign就简单很多。

3.1、新建一个module

新建一个module，名称为service-consumer-feign，选择Spring Web、Eureka Discovery Client和OpenFeign三个依赖，如下

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<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-openfeign</artifactId>
</dependency>

3.2、创建Service和Controller

先在启动类上加上@EnableEurekaClient和@EnableFeignClients，再创建一个FeignConsumerService接口和一个FeignConsumerController类，FeignConsumerService接口定义如下：

@FeignClient(value = "service-provider")
public interface FeignConsumerService {

    @RequestMapping("/callServiceProvider")
    String index(@RequestParam("uid") String uid);
}

主要就是通过注解的方式声明一个提供者的服务，@FeignClient注解的值就是服务提供者的应用名称。

FeignConsumerController类的写法和RibbonConsumerController的写法无异，都是在controller中调用service，这里不多说。

3.3、添加配置信息

在application.properties文件中添加以下配置

server.port=8080
spring.application.name=consumer-feign

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

3.4、启动&测试

启动注册中心、服务提供者和feign消费者项目（如果ribbon消费者项目还在运行先停掉，不然端口会冲突），访问http://localhost:8080/index?uid=feign

四、负载均衡

到目前为止我们的服务提供者是单节点的，如果这个节点挂了，那么所有调用了这个服务提供的接口的服务都无法正常工作，为了保证服务的高可用，我们需要有多个服务提供者的节点，然后在消费服务时，一方面假如某个甚至几个服务提供者挂掉之后，还可以有正常的服务在工作，另一方面，加入请求量很大的时候，多个服务提供者的节点也可以分摊流量，减轻单个节点的处理压力，这一点和Nginx+多个Tomcat的架构是一致的，只不过在这里我们做负载均衡的组件不是Nginx，而是Ribbon，（Feign的底层也是依赖Ribbon来做负载均衡的）。

4.1、Ribbon负载均衡策略

Ribbon的负载均衡策略源于com.netflix.loadbalancer.IRule接口，有一个抽象类AbstractLoadBalancerRule实现了该接口，而其它官方提供的策略类都是直接或者间接继承了这个抽象类。下面介绍几种官方提供的策略

4.1.1、AvailabilityFilteringRule

可用过滤策略：过滤掉一直连接失败并被标记为 circuit tripped 的 Server，过滤掉那些高并发连接的 Server（active connections 超过配置的网值）。

4.1.2、BestAvailableRule

最低并发策略：逐个考察 Server，如果 Server 断路器打开，则忽略，再选择其中并发连接最低的 Server。

4.1.3、RandomRule

随机策略：随机选择Server。

4.1.4、RetryRule

重试策略：在一个配置时间段内当选择 Server 不成功，则一直尝试选择一个可用的 Server。

4.1.5、RoundRobinRule

轮询策略：按顺序循环选择Server。

4.1.6、WeightedResponseTimeRule

响应时间权重策略：这是一个基于响应时间来分配的策略，响应时间越短的节点，被选中的概率越大。在旧的版本这个策略的类叫ResponseTimeWeightedRule，新版本建议使用WeightedResponseTimeRule。

4.1.7、ZoneAvoidanceRule

区域权衡策略：综合判断Server所在区域的性能和Server的可用性轮询选择Server，并且判定一个AWS Zone的运行性能是否可用，剔除不可用的Zone中的所有Server。

4.1.8、CustomRule

自定义策略：好吧，官方当然没有这么一个策略类，这里写出来的意思是我们可以自己自定义一种策略。

4.2、启动多个服务提供者

既然要做负载均衡，那么服务提供者自然不能是单节点，单节点也无法测试各种策略。先在service-provider module中添加三个配置文件application-provider1.properties、application-provider2.properties、application-provider3.properties，然后把application.properties中的内容复制到三个配置文件中，把其中的端口号改掉，创建三个启动配置项

为了等会知道调用了那个服务提供者，稍微修改一下启动类，在其中加上端口的信息

@SpringBootApplication
@EnableEurekaClient
@RestController
public class ServiceProviderApplication {

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

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

    @RequestMapping("/callServiceProvider")
    public String callServiceProvider(@RequestParam("uid") String uid) {
//        return "用户" + uid + "调用了此服务";
        return "服务" + port + "的消息：用户" + uid + "调用了此服务";
    }
}

可以先把所有正在运行的服务都停止，然后分别启动注册中心和这三个服务提供者和Ribbon消费者，然后访问http://localhost:8080/index?uid=ribbon，当不断访问返回的结果是不同的，但是总会按照某个顺序返回，比如我的就是8771-8773-8772-8771……这样的顺序返回

服务8771的消息：用户ribbon调用了此服务
服务8773的消息：用户ribbon调用了此服务
服务8772的消息：用户ribbon调用了此服务

目前我们并没有配置任何的负载均衡策略，但是从结果看已经实现了负载均衡，默认就是RoundRobinRule这种顺序轮询的策略，如果希望按照其它策略分发，只需要在service-consumer-ribbon中的配置文件加上以下配置

SERVICE-PROVIDER.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule

service-provider是服务提供者的名称，值是策略类，比如上面配置的是随机分发策略。重启service-consumer-ribbon，再次不断地访问http://localhost:8080/index?uid=ribbon，可以发现每次返回的结果都是随机的了。

Feign消费者中的做法是完全一致的，这里不再赘述。

指定负载均衡策略的另一种方式

我们还可以在启动类加上一个策略类的Bean，spring在启动的时候就会加载这个bean来覆盖默认的策略了

@Bean
public RandomRule randomRule() {
    return new RandomRule();
}

更多的负载均衡的策略可以自行尝试，这里就不再过多介绍了。

五、总结

到此，服务消费和负载均衡介绍完毕，下一篇介绍断路器。

源码已经上传到github：https://github.com/spareyaya/spring-cloud-demo/tree/master/chapter3