SpringCloud学习：Eureka、Ribbon和Feign

时间 2020-06-03

标签 springcloud 学习 eureka ribbon feign 繁體版

原文原文链接

Talk is cheap，show me the code ，书上得来终觉浅，绝知此事要躬行。在本身真正实现的过程当中，会遇到不少莫名其妙的问题，而正是在解决这些问题的过程当中，你会发现本身以前思惟的盲点。
引子

看完《微服务设计》后，算是补上了本身在服务化这块的理论知识，在业界，通常有两种微服务的实践方法：基于dubbo的微服务架构、基于Spring Cloud的微服务架构。从概念上来说，Dubbo和Spring Cloud并不能放在一块儿对比，由于Dubbo仅仅是一个RPC框架，实现Java程序的远程调用，实施服务化的中间件则须要本身开发；而Spring Cloud则是实施微服务的一系列套件，包括：服务注册与发现、断路器、服务状态监控、配置管理、智能路由、一次性令牌、全局锁、分布式会话管理、集群状态管理等。

在有赞，咱们基于Dubbo实施服务化，刚开始是基于ZooKeeper进行服务注册与发现，如今已经转成使用Etcd。我此次学习Spring Cloud，则是想成体系得学习下微服务架构的实现，也许可以对基于Dubbo实施微服务架构有所借鉴。

Spring Cloud下有不少工程：

    Spring Cloud Config：依靠git仓库实现的中心化配置管理。配置资源能够映射到Spring的不一样开发环境中，可是也可使用在非Spring应用中。
    Spring Cloud Netflix：不一样的Netflix OSS组件的集合：Eureka、Hystrix、Zuul、Archaius等。
    Spring Cloud Bus：事件总线，利用分布式消息将多个服务链接起来。很是适合在集群中传播状态的改变事件（例如：配置变动事件）
    Spring Cloud Consul：服务发现和配置管理，由Hashicorp团队开发。

我决定先从Spring Cloud Netflix看起，它提供了以下的功能特性：

    服务发现：Eureka-server实例做为服务提供者，能够注册到服务注册中心，Eureka客户端能够经过Spring管理的bean发现实例；
    服务发现：嵌套式的Eureka服务能够经过声明式的Java配置文件建立；
    断路器：利用注解，能够建立一个简单的Hystrix客户端；
    断路器：经过Java配置文件能够建立内嵌的Hystrix控制面板；
    声明式REST客户端：使用Feign能够建立声明式、模板化的HTTP客户端；
    客户端负载均衡器：Ribbon
    路由器和过滤器：Zuul能够在微服务架构中提供路由功能、身份验证、服务迁移、金丝雀发布等功能。

本文计划利用Eureka实现一个简答的服务注册于发现的例子，须要建立三个角色：服务注册中心、服务提供者、服务消费者。
实践
1. 服务注册中心

在IDEA中建立一个Spring Cloud工程，引入Eureka-Server包，pom文件总体以下：

<?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>org.example.springcloud</groupId>
    <artifactId>service-register</artifactId>
    <version>1.0-SNAPSHOT</version>

    
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.1.RELEASE</version>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
    </properties>

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

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

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

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Camden.SR5</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

在src/main/java包下建立一个名为hello的包，而后建立 EurekaServiceRegisterApplication 类，并用@EnableEurekaServer和@SpringBootApplication两个注解修饰，后者是Spring Boot应用都须要用的，这里不做过多解释；@EnableEurekaServer注解的做用是触发Spring Boot的自动配置机制，因为咱们以前在pom文件中导入了eureka-server，spring boot会在容器中建立对应的bean。EurekaServiceRegisterApplication的代码以下：

package hello;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

/**
* Created by IntelliJ IDEA.
* User: duqi
* Date: 2017/3/2
* Time: 20:02
*/

@EnableEurekaServer //经过@EnableEurekaServer启动一个服务注册中心给其余应用使用
@SpringBootApplication
public class EurekaServiceRegisterApplication {

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

在application.properties中还须要增长以下配置，才能建立一个真正可使用的服务注册中心。

#注册服务的端口号
server.port=8761

#是否须要注册到注册中心，由于该项目自己做为服务注册中心，因此为false
eureka.client.register-with-eureka=false
#是否须要从注册中心获取服务列表，缘由同上，为false
eureka.client.fetch-registry=false
#注册服务器的地址：服务提供者和服务消费者都要依赖这个地址
eureka.client.service-url.defaultZone=http://localhost:${server.port}/eureka

logging.level.com.netflix.eureka=OFF
logging.level.com.netflix.discovery=OFF

启动注册服务，并访问： http://localhost:8761 ，就能够看到以下界面。

服务注册中心后台
2. 服务提供者

建立一个Spring Boot工程，表明服务提供者，该服务提供者会暴露一个加法服务，接受客户端传来的加数和被加数，并返回二者的和。

工程的pom文件内容以下：

<?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>org.example.springcloud</groupId>
    <artifactId>service-client</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.1.RELEASE</version>
        <relativePath/>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
    </properties>

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

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

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

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Camden.SR5</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

其中的关键在于spring-cloud-starter-eureka这个Jar包，其中包含了eureka的客户端实现。

在src/main/java/hello下建立工程的主类EurekaServerProducerApplication，使用@EnableDiscoveryClient注解修饰，该注解在服务启动的时候，能够触发服务注册的过程，向配置文件中指定的服务注册中心（Eureka-Server）的地址注册本身提供的服务。EurekaServerProducerApplication的源码以下：

package hello;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

/**
* Created by IntelliJ IDEA.
* User: duqi
* Date: 2017/3/2
* Time: 20:34
*/
@EnableDiscoveryClient
@SpringBootApplication
public class EurekaServerProducerApplication {

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

}

配置文件的内容以下：

#服务提供者的名字
spring.application.name=compute-service

#服务提供者的端口号
server.port=8888

#服务注册中心的地址
eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/

服务提供者的基本框架搭好后，须要实现服务的具体内容，在ServiceInstanceRestController类中实现，它的具体代码以下：

package hello;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
* Created by IntelliJ IDEA.
* User: duqi
* Date: 2017/3/2
* Time: 20:36
*/
@RestController
public class ServiceInstanceRestController {

    private static final Logger logger = LoggerFactory.getLogger(ServiceInstanceRestController.class);

    @Autowired
    private DiscoveryClient discoveryClient; //服务发现客户端

    @GetMapping(value = "/add")
    public Integer add(@RequestParam Integer a, @RequestParam Integer b) {
        ServiceInstance instance = discoveryClient.getLocalServiceInstance();
        Integer r = a + b;
        logger.info("/add, host:" + instance.getHost() + ", service_id:" + instance.getServiceId() + ", result:" + r);
        return r;
    }
}

先启动服务注册中心的工程，而后再启动服务提供者，在访问： localhost:8761，以下图所示，服务提供者已经注册到服务注册中心啦。

服务提供者注册到服务注册中心

在Spring Cloud Netflix中，使用Ribbon实现客户端负载均衡，使用Feign实现声明式HTTP客户端调用——即写得像本地函数调用同样。
3. 服务消费者-Ribbon

建立一个Spring boot工程，引入ribbon和eureka，pom文件内容以下：

<?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>org.example.springcloud</groupId>
    <artifactId>serviceconsumer</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.1.RELEASE</version>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
    </properties>

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

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

        
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</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>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Camden.SR5</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

建立EurekaConsumerApplication类，定义REST客户端实例，代码以下：

package hello;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

/**
* Created by IntelliJ IDEA.
* User: duqi
* Date: 2017/3/2
* Time: 22:55
*/
@EnableDiscoveryClient //开启服务发现的能力
@SpringBootApplication
public class EurekaConsumerApplication {

    @Bean //定义REST客户端，RestTemplate实例
    @LoadBalanced //开启负债均衡的能力
    RestTemplate restTemplate() {
        return new RestTemplate();
    }

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

application.properties中定义了服务注册中心的地址、消费者服务的端口号、消费者服务的名称这些内容：

#应用名称
spring.application.name=ribbon-consumer

#端口号
server.port=9000

#注册中心的地址
eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/

消费者服务的入口为：ConsumerController，咱们经过这个实例进行测试。消费者服务启动过程当中，会从服务注册中心中拉最新的服务列表，当浏览器触发对应的请求，就会根据COMPUTE-SERVICE查找服务提供者的IP和端口号，而后发起调用。

package hello;

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

/**
* Created by IntelliJ IDEA.
* User: duqi
* Date: 2017/3/2
* Time: 22:58
*/
@RestController
public class ConsumerController {

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping(value = "/add")
    public String add() {
        return restTemplate.getForEntity("http://COMPUTE-SERVICE/add?a=10&b=20", String.class).getBody();
    }
}

首先启动服务注册中心，第二分别启动两个服务提供者（IP相同、端口不一样便可），而后启动服务消费者。

两个服务提供者

在浏览器里访问 localhost:9000/add 两次，能够看到请求有时候会在8888端口的服务，有时候会到8889的服务。具体背后选择的原理，还有待后续研究。
4. 服务消费者-Feign

上一节中，使用相似 restTemplate.getForEntity("http://COMPUTE-SERVICE/add?a=10&b=20", String.class).getBody() 这样的语句进行服务间调用并不是不能够，只是咱们在服务化的过程当中，但愿跨服务调用可以看起来像本地调用，这也是我理解的Feign的使用场景。

建立一个spring boot工程，该工程的pom文件与上一节的相似，只是把ribbon的依赖换为feign的便可，代码以下：

<?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>org.example.springcloud</groupId>
    <artifactId>serviceconsumer</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.1.RELEASE</version>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
    </properties>

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

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

        
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</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>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Camden.SR5</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

首先建立应用程序启动类：EurekaConsumerApplication，代码以下：

package hello;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.feign.EnableFeignClients;

/**
* Created by IntelliJ IDEA.
* User: duqi
* Date: 2017/3/19
* Time: 16:59
*/
@EnableDiscoveryClient //用于启动服务发现功能
@EnableFeignClients //用于启动Fegin功能
@SpringBootApplication
public class EurekaConsumerApplication {

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

而后定义远程调用的接口，在hello包下建立depend包，而后建立ComputeClient接口，使用@FeignClient("COMPUTE-SERVICE")注解修饰，COMPUTE-SERVICE就是服务提供者的名称，而后定义要使用的服务，代码以下：

package hello.depend;

import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

/**
* Created by IntelliJ IDEA.
* User: duqi
* Date: 2017/3/19
* Time: 17:02
*/
@FeignClient("COMPUTE-SERVICE")
public interface ComputeClient {

    @RequestMapping(method = RequestMethod.GET, value = "/add")
    Integer add(@RequestParam(value = "a") Integer a, @RequestParam(value = "b") Integer b);
}

在ConsumerController中，像引入普通的spring bean同样引入ComputeClient对象，其余的和Ribbon的相似。

package hello;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import hello.depend.ComputeClient;

/**
* Created by IntelliJ IDEA.
* User: duqi
* Date: 2017/3/19
* Time: 17:06
*/
@RestController
public class ConsumerController {

    @Autowired
    private ComputeClient computeClient;

    @RequestMapping(value = "/add", method = RequestMethod.GET)
    public Integer add() {
        return computeClient.add(10, 20);
    }
}

application.properties的内容以下：

#应用名称
spring.application.name=fegin-consumer

#端口号
server.port=9000

#注册中心的地址
eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/

启动fegin消费者，访问 localhost:9000/add ，也能够看到服务提供者已经收到了消费者发来的请求。

请求到达服务提供者1
java

请求到达服务提供者2
git

原文转自： http://lib.csdn.net/article/microservice/62911web