Eclipse配置运行SpringCloud（Hoxton + 2.2.4）微服务框架 + 搭建服务消费者Ribbon+RestTemplate

简介

RestTemplate

Spring用于同步client端的核心类，简化了与http服务的通信，并满足RESTful原则，程序代码可以给它提供URL，并提取结果。默认情况下，RestTemplate默认依赖jdk的HTTP连接工具。

Ribbon

Spring Cloud Ribbon是一个基于HTTP和TCP的客户端负载均衡工具，它基于Netflix Ribbon实现。通过Spring Cloud的封装，可以让我们轻松地将面向服务的REST模版请求自动转换成客户端负载均衡的服务调用。Spring Cloud Ribbon几乎存在于每一个Spring Cloud构建的微服务和基础设施中。因为微服务间的调用，API网关的请求转发等内容，实际上都是通过Ribbon来实现的，包括Feign，它也是基于Ribbon实现的工具。

在Spring Cloud中，当Ribbon与Eureka配合使用时，Ribbon可自动从Eureka Server获取服务提供者地址列表，并基于负载均衡算法，选择其中一个服务提供者实例。

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

https://blog.csdn.net/miaodichiyou/article/details/104160284

1、启动SpringCloud高可用服务注册中心（Eureka）搭建的注册中心

2、在springcloud-eureka-provider项目Hi_provider.java文件中添加一个controller，对外提供服务 "/hi"

package org.springcloud.eureka.provider;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableEurekaClient

public class Hi_provider 
{
    public static void main( String[] args )
    {
    	SpringApplication.run(Hi_provider.class, args);
    }
    
    @RestController
    public class HiController {

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

        @GetMapping("/hi")
        public String Home(@RequestParam String name){
            return "hi "+name+",This is from serverport:"+port;
        }
    }
}

启动三个springcloud-eureka-provider实例，端口分别为8001，8002和8003

创建服务消费者

添加依赖包文件POM.xml

<?xml version="1.0"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>com.springcloud</groupId>
    <artifactId>springcloud-root</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>springcloud-ribbon</artifactId>
  <name>springcloud-ribbon</name>
  <url>http://maven.apache.org</url>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
    <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>
    <dependency>
      <groupId>org.apache.httpcomponents</groupId>
      <artifactId>httpclient</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>
    <dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-configuration-processor</artifactId>
    	<optional>true</optional>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

配置application.yml文件

spring:
  application:
    name: springcloud-ribbon
  freemarker:
    prefer-file-system-access: false
  security:
    user:
      name: admin
      password: 123456
    
server:
  port: 8100
  
eureka:
  instance:
    hostname: eureka-ribbon.com
    instance-id: eureka-ribbon
  client:
    service-url:
      defaultZone: http://${spring.security.user.name}:${spring.security.user.password}@eureka-peer1.com:8897/eureka/,http://${spring.security.user.name}:${spring.security.user.password}@eureka-peer2.com:8898/eureka/,http://${spring.security.user.name}:${spring.security.user.password}@eureka-peer3.com:8899/eureka/

修改C:\Windows\System32\drivers\etc\hosts

127.0.0.1 eureka-ribbon.com

添加服务消费者启动类

• RibbonApplication.java

package org.springcloud.ribbon;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RibbonApplication {

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

添加RESTful API接口

调用springcloud-eureka-provider实例的API接口"/hi"，即消费服务。由于springcloud-eureka-provider为三个实例（端口8001、8002、8003），在调用时希望做到轮流访问这三个实例，这时需要将RestTemplate和Ribbon结合进行负载均衡。只需要在程序的IOC容器中注入一个restTemplate的Bean，并加上@LoadBalanced注解，此时RestTemplate就结合了Ribbon开启了负载均衡功能。

• RestTemplateConfig.java

package org.springcloud.ribbon;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
    	 HttpComponentsClientHttpRequestFactory httpRequestFactory = new HttpComponentsClientHttpRequestFactory();
         httpRequestFactory.setConnectionRequestTimeout(30000);
         httpRequestFactory.setConnectTimeout(30000);
         httpRequestFactory.setReadTimeout(30000);
         return new RestTemplate(httpRequestFactory);
    }
}

添加service消费服务提供者实例提供的服务

编写一个RibbonService类，在该类的hi()方法用restTemplate调用springcloud-eureka-provider的API接口，uri上不需要使用硬编码（如IP地址），只需写服务名springcloud-eureka-provider即可。

• RibbonService.java

package org.springcloud.ribbon;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class RibbonService {
    @Autowired
    RestTemplate restTemplate;
    public String hi(String name){
        return restTemplate.getForObject("http://springcloud-eureka-provider/hi?name="+name,String.class);
    }
}

注：getForObject中的url springcloud-eureka-provider为springcloud-eureka-provider项目（服务提供者）的应用名称，也就是在创建springcloud-eureka-provider项目时在配置文件中配置的spring.application.name=springcloud-eureka-provider。hi为springcloud-eureka-provider项目中接口的地址（controller）, name是请求参数。

创建controller，调用service中的方法

编写一个RibbonController类

package org.springcloud.ribbon;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RibbonController {
    @Autowired
    private RibbonService ribbonService;

    @GetMapping("/hi")
    public String hi(@RequestParam(required = false,defaultValue = "zhaojq") String name){
        return ribbonService.hi(name);
    }
}

启动springcloud-ribbon工程

查看Eureka注册中心

运行启动类，访问http://eureka-peer1.com:8897/

http://eureka-peer2.com:8898/，http://eureka-peer3.com:8899/ 结果同上。
服务消费者实例已成功注册。

在浏览器地址栏访问ribbon项目中的controller

在浏览器多次访问http://localhost:8100/hi?name=zhaojq，浏览器会轮流显示如下



当一直刷新http://localhost:8100/hi?name=zhaojq时可以发现浏览器交替显示端口8001，8002和8003，说明已经实现客户端的负载均衡，并且Ribbon默认采用轮询的负载均衡算法。

Ribbon负载均衡策略

自定义负载均衡策略(随机策略)

修改springcloud-ribbon工程的application.yml配置文件添加如下配置：

# 自定义配置负载均衡策略
Load_Balance:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

Load_Balance为需要负载的服务地址，com.netflix.loadbalancer.RandomRule为服务策略。此处我们配置为随机策略

修改RestTemplateConfig配置类:

@Bean
    public IRule ribbonRule() {
        return new RandomRule();//实例化与配置文件对应的策略类
    }

修改RibbonController

package org.springcloud.ribbon;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RibbonController {
    @Autowired
    private RibbonService ribbonService;
    
    @Autowired
    private LoadBalancerClient loadBalancerClient;

    @GetMapping("/hi")
    public String hi(@RequestParam(required = false,defaultValue = "zhaojq")String name){
    	this.loadBalancerClient.choose("Load_Balance");
        return ribbonService.hi(name);
    }
}

LoadBalancerClient（RibbonLoadBalancerClient是实现类）在初始化的时候（execute方法），会通过ILoadBalance（BaseLoadBalancer是实现类）向Eureka注册中心获取服务注册列表，并且每10s一次向EurekaClient发送“ping”，来判断服务的可用性，如果服务的可用性发生了改变或者服务数量和之前的不一致，则从注册中心更新或者重新拉取。LoadBalancerClient有了这些服务注册列表，就可以根据具体的IRule来进行负载均衡。

重新启动springcloud-ribbon项目，访问http://eureka-ribbon.com:8100/hi?name=zhaojq

在命令窗口curl http://eureka-ribbon.com:8100/hi，发现Ribbon已经实现随机负载均衡策略