Spring Cloud的Eureka实现服务发现注册和Feign实现服务调用

本篇博客主要讲解Eureka组件实现服务注册与发现和Feign组件实现服务间的调用的理论以及实际操作。

Eureka

Eureka是Spring Cloud Netfix微服务套件中的一部分，可以和SpringBoot构建的微服务很容易的整合。SpringCloud将它集成在自己的子项目 spring-cloud-netflix中，实现SpringCloud的服务发现功能。

Eureka包含两个组件： Eureka Server（服务器端） 和 Eureka Client（客户端组件）。

Eureka Server（服务器端组件） ：也被称作服务注册中心，用于提高服务的注册和发现。各个节点启动后，会在Eureka Server中进行注册，这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到。Eureka Server之间通过复制的方式完成数据的同步。

Eureka Client（客户端组件）：用于简化与Eureka Server的交互，包含服务消费者和服务生产者。客户端同时也有一个内置的、使用轮询(round-robin)负载算法的负载均衡器，在应用程序运行时，Eureka客户端向注册中心注册自身提供的服务并周期性的发送心跳来更新它的服务租约,向Eureka Server发送的心跳,默认周期为30秒，如果Eureka Server在多个心跳周期内没有 接收到某个节点的心跳，Eureka Server将会从服务注册表中把这个服务节点移除(默认90 秒)。Eureka还提供了客户端缓存机制，可以从服务端查询当前注册的服务信息并把他们缓存到本地并周期性的刷新服务状态，即使所有的Eureka Server都挂掉，客户端依然可以利用缓存中的信息消费其他服务的API。

Eureka支持高可用的配置，当集群中有分片出现故障时，Eureka就会转入自动保护模式，它允许分片故障期间继续提供服务的发现和注册，当故障分片恢复正常时，集群中其他分片会把他们的状态再次同步回来。

Eureka通过心跳检查、客户端缓存等机制，确保了系统的高可用性、灵活性和可伸缩性。

Eureka实现服务发现注册

1.首先搭建Maven项目，后面的模块都放到它下面

创建完成如下

可以删除src目录，因为这个工程只是为了放置springcloud的其它模块。

2.搭建服务注册中心(eureka-server)

Eureka Server是基于springboot的,只要启动一个springboot就可以了。start.spring.io提供了一系列启动模板。创建module，选择Spring initializer.：

加入Eureka Server组件

创建完成目录

生成的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">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.5.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.changan</groupId>
<artifactId>eureka-server</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>eureka-server</name>
<description>Demo project for Spring Boot</description>

<properties>
<java.version>1.8</java.version>
<spring-cloud.version>Greenwich.SR1</spring-cloud.version>
</properties>

<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-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

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

</project>

修改启动类EurekaServerApplication.java，添加@EnableEurekaServer

package com.szh.ecurekaserver;

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

@SpringBootApplication
@EnableEurekaServer
public class EcurekaServerApplication {

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

}

在默认情况下，服务注册中心也会把自己当做是一个服务，将自己注册进服务注册中心，所以我们可以通过配置来禁用他的客户端注册行为，修改application.properties文件

spring.application.name=eureka-server
#服务注册中心端口号
server.port=8080
#服务注册中心实例的主机名
eureka.instance.hostname=localhost
#是否向服务注册中心注册自己
eureka.client.register-with-eureka=false
#是否检索服务
eureka.client.fetch-registry=false
#服务注册中心的配置内容，指定服务注册中心的位置
eureka.client.serviceUrl.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka/

启动应用，并访问http://localhost:8080/即可看到Eureka信息面板，如下：

从上图看到，在"Instances currently registered with Eureka"信息中，没有一个实例，说明目前还没有服务注册。接下来创建一个服务提供者eureka-client进行注册测试。

3.创建并注册服务提供者 Eureka Client

创建方式如eureka-server模块类似；在选择组件的时候需要选择对应的组件

注意要选择Web组件或者其它能够持久运行的。不然会注册失败

创建后目录如下

生成的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">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.5.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.changan</groupId>
<artifactId>eureka-client</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>eureka-client</name>
<description>Demo project for Spring Boot</description>

<properties>
<java.version>1.8</java.version>
<spring-cloud.version>Greenwich.SR1</spring-cloud.version>
</properties>

<dependencies>
<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.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>${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>

</project>

启动类EurekaClientApplication.java添加@EnableEurekaClient注解以实现Eureka中的DiscoveryClient实现。

package com.xuan.eurekaclient;

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

@EnableEurekaClient
@SpringBootApplication
public class EurekaClientApplication {

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

@EnableEurekaClient和@EnableDiscoveryClient的区别
spring cloud中discovery service有许多种实现（eureka、consul、zookeeper等等），@EnableDiscoveryClient基于spring-cloud-commons,@EnableEurekaClient基于spring-cloud-netflix。

就是如果选用的注册中心是eureka，那么就推荐@EnableEurekaClient，如果是其他的注册中心，那么推荐使用@EnableDiscoveryClient。

修改配置文件application.properties

spring.application.name=eureka-client
server.port=8090
# 这个是固定死的,这是我们要注册到哪里去
eureka.client.serviceUrl.defaultZone=http://localhost:8080/eureka/

< 20000 p>先启动：eureka-server

然后启动eureka-client

发现多了一个EUREKA-CLIENT，注册成功了

其它问题：
运行一段时间后，在http://localhost:8080/出现

如果在Eureka Server的首页看到以下这段提示，则说明Eureka已经进入了保护模式：

Eureka Server在运行期间，会统计心跳失败的比例在15分钟之内是否低于85%，如果出 现低于的情况（在单机调试的时候很容易满足，实际在生产环境上通常是由于网络不稳 定导致），Eureka Server会将当前的实例注册信息保护起来，同时提示这个警告。保护模式主要用于一组客户端和Eureka Server之间存在网络分区场景下的保护。一旦进入保护模式，Eureka Server将会尝试保护其服务注册表中的信息，不再删除服务注册表中的 数据（也就是不会注销任何微服务）。

停止eureka-client后也没有删除节点。

自我保护模式打开时，已关停节点是会一直显示在 Eureka 首页的
关闭自我保护模式后，由于其默认的心跳周期比较长等原因，要过一会儿才会发现已关停节点被自动踢出了

若想尽快的及时踢出，那就只有修改默认的心跳周期参数了

注册中心eureka-server的配置文件application.properties中修改为

spring.application.name=eureka-server
#服务注册中心端口号
server.port=8080
#服务注册中心实例的主机名
eureka.instance.hostname=localhost
#关闭自我保护
eureka.server.enableSelfPreservation=false
# 续期时间，即扫描失效服务的间隔时间（缺省为60*1000ms）
eureka.server.eviction-interval-timer-in-ms: 1000
#是否向服务注册中心注册自己
eureka.client.register-with-eureka=false
#是否检索服务
eureka.client.fetch-registry=false
#服务注册中心的配置内容，指定服务注册中心的位置
eureka.client.serviceUrl.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka/

Eureka客户端eureka-client的配置文件application.properties中修改为

spring.application.name=eureka-client
server.port=8090
# 心跳时间，即服务续约间隔时间（缺省为30s）
eureka.instance.lease-renewal-interval-in-seconds: 5
# 发呆时间，即服务续约到期时间（缺省为90s）
eureka.instance.lease-expiration-duration-in-seconds: 15
# 开启健康检查（依赖spring-boot-starter-actuator）
eureka.client.healthcheck.enabled:true
eureka.client.serviceUrl.defaultZone=http://localhost:8080/eureka/

eureka-client的pom.xml增加

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

修改后，关闭eureka-client，注册中心就会很快删除节点

Feign

Feign是简化Java HTTP客户端开发的工具（java-to-httpclient-binder），它的灵感来自于Retrofit、JAXRS-2.0和WebSocket。Feign的初衷是降低统一绑定Denominator到 HTTP API的复杂度，不区分是否为restful。

Feign实现服务调用

1.创建一个eureka-student和一个eureka-grade

创建方式和ureka-server模块类似；在选择组件的时候需要选择对应的组件


注意要选择Web组件或者其它能够持久运行的。不然会注册失败

如上再创建一个eureka-grade

完成后目录如下

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">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.5.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.changan</groupId>
<artifactId>eureka-student</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>eureka-student</name>
<description>Demo project for Spring Boot</description>

<properties>
<java.version>1.8</java.version>
<spring-cloud.version>Greenwich.SR1</spring-cloud.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.0.1</version>
</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>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.13</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</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>${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>
</project>

启动类EurekaClientApplication.java添加@EnableDiscoveryClient @EnableFeignClients注解

package com.szh.eurekastudent;

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

@EnableDiscoveryClient
@EnableFeignClients
@SpringBootApplication
public class EurekaStudentApplication {

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

}

package com.szh.eurekagrade;

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

@EnableDiscoveryClient
@EnableFeignClients
@SpringBootApplication
public class EurekaGradeApplication {

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

}

eureka-student的application.properties

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/studentdb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root

spring.application.name=eureka-student
server.port=8091
eureka.client.serviceUrl.defaultZone=http://localhost:8080/eureka/

eureka-grade的application.properties

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/studentdb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root

spring.application.name=eureka-grade
server.port=8094
eureka.client.serviceUrl.defaultZone=http://localhost:8080/eureka/

在eureka-student src文件下写client,controller,mapper,pojo,service等包

创建Student实体类

package com.szh.eurekastudent.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {

private Integer id;

private String name;

private String sex;

private Integer gradeId;
}

创建Grade实体类

package com.szh.eurekastudent.pojo;

import lombok.Data;

@Data
public class Grade {

private Integer gradeId;

private String gradeName;

}

创建StudentMapper接口

package com.szh.eurekastudent.mapper;

import com.szh.eurekastudent.pojo.Student;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public interface StudentMapper {

@Select("select * from student")
List<Student> selAllStudent();
}

创建StudentService接口

package com.szh.eurekastudent.service;

import com.szh.eurekastudent.pojo.Student;

import java.util.List;

public interface StudentService {

List<Student> selAllStudent();
}

创建StudentServiceImpl类

package com.szh.eurekastudent.service.impl;

import com.szh.eurekastudent.mapper.StudentMapper;
import com.szh.eurekastudent.pojo.Student;
import com.szh.eurekastudent.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class StudentServiceImpl implements StudentService {
@Autowired
private StudentMapper studentMapper;

@Override
public List<Student> selAllStudent() {
return studentMapper.selAllStudent();
}
}

创建StudentController类

package com.szh.eurekastudent.controller;

import com.szh.eurekastudent.client.GradeClient;
import com.szh.eurekastudent.pojo.Grade;
import com.szh.eurekastudent.pojo.Student;
import com.szh.eurekastudent.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class StudentController {

@Autowired
private StudentService studentService;

@Autowired
private GradeClient gradeClient;

@GetMapping("/students")
public List<Student> findStudents(){
return studentService.selAllStudent();
}

@GetMapping("/grades")
public List<Grade> findGrades(){
return gradeClient.findStudents();
}
}

创建GradeClient类

package com.szh.eurekastudent.client;

import com.szh.eurekastudent.pojo.Grade;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

import java.util.List;

@FeignClient("eureka-grade")
public interface GradeClient {

@GetMapping("/grades")
public List<Grade> findStudents();
}

如图所示:

在eureka-gradesrc文件下写controller,mapper,pojo,service等包，和eureka-student一样。

创建Student实体类

package com.szh.eurekagrade.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {

private Integer id;

private String name;

private String sex;

private Integer gradeId;
}

创建Grade实体类

package com.szh.eurekagrade.pojo;

import lombok.Data;

@Data
public class Grade {

private Integer gradeId;

private String gradeName;

}

创建StudentMapper接口

package com.szh.eurekagrade.mapper;

import com.szh.eurekagrade.pojo.Grade;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public interface StudentMapper {

@Select("select * from grade")
List<Grade> selAllGrade();
}

创建StudentService接口

package com.szh.eurekagrade.service;

import com.szh.eurekagrade.pojo.Grade;

import java.util.List;

public interface StudentService {

List<Grade> selAllGrade();
}

创建StudentServiceImpl类

package com.szh.eurekagrade.service.impl;

import com.szh.eurekagrade.mapper.StudentMapper;
import com.szh.eurekagrade.pojo.Grade;
import com.szh.eurekagrade.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class StudentServiceImpl implements StudentService {
@Autowired
private StudentMapper studentMapper;

@Override
public List<Grade> selAllGrade() {
return studentMapper.selAllGrade();
}
}

创建StudentController类

package com.szh.eurekagrade.controller;

import com.szh.eurekagrade.pojo.Grade;
import com.szh.eurekagrade.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class StudentController {

@Autowired
private StudentService studentService;

@GetMapping("/grades")
public List<Grade> findStudents(){
return studentService.selAllGrade();
}
}

记得要在两个包的启动类加上@MapperScan(“com.szh.eurekastudent.mapper”)

package com.szh.eurekastudent;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@EnableDiscoveryClient
@EnableFeignClients
@MapperScan("com.szh.eurekastudent.mapper")
@SpringBootApplication
public class EurekaStudentApplication {

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

}

然后从eureka-server开始启动4个模块。

去查看结果

查看服务调用结果

在eureka-student调用eureka-grade成功！