Eureka服务注册与发现

Eureka服务注册与发现

什么是Eureka

Netflix 在设计Eureka 时，遵循的就是AP原则

CAP原则又称CAP定理，指的是在一个分布式系统中

一致性（Consistency）可用性（Availability）

分区容错性（Partition tolerance）

CAP 原则指的是，这三个要素最多只能同时实现两点，不可能三者兼顾。

Eureka是Netflix的一个子模块，也是核心模块之一。Eureka是一个基于REST的服务，用于定位服务， 以实现云端中间层服务发现和故障转移，服务注册与发现对于微服务来说是非常重要的，有了服务发现 与注册，只需要使用服务的标识符，就可以访问到服务，而不需要修改服务调用的配置文件了，功能类 似于Dubbo的注册中心，比如Zookeeper；

原理讲解

Eureka的基本架构：

SpringCloud 封装了NetFlix公司开发的Eureka模块来实现服务注册和发现

Eureka采用了C-S的架构设计，EurekaServer 作为服务注册功能的服务器，

他是服务注册中心 而系统中的其他微服务。使用Eureka的客户端连接到EurekaServer并维持心跳连接。这样系统的维护人 员就可以通过EurekaServer来监控系统中各个微服务是否正常运行，SpringCloud的一些其他模块（比 如Zuul）就可以通过EurekaServer来发现系统中的其他微服务，并执行相关的逻辑；

Eureka 包含两个组件：Eureka Server 和 Eureka Client 。

Eureka Server 提供服务注册服务，各个节点启动后，会在EurekaServer中进行注册，这样Eureka Server中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到。

和Dubbo架构对比：

Eureka Client是一个Java客户端，用于简化EurekaServer的交互，客户端同时也具备一个内置的，使用 轮询负载算法的负载均衡器。在应用启动后，将会向EurekaServer发送心跳（默认周期为30秒）。如果 Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这 个服务节点移除掉（默认周期为90秒）

三大角色

• Eureka Server：提供服务的注册于发现
• Service Provider：将自身服务注册到Eureka中，从而使消费方能够找到。
• Service Consumer：服务消费方从Eureka中获取注册服务列表，从而找到消费服务。

Eureka服务构建

建立spring-cloud-eureka-7001模块(导入依赖)

<?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>spring-cloud-demo</artifactId>
        <groupId>top.tk.springcloud</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-cloud-eureka-7001</artifactId>

    <dependencies>
        <!-- eureka-server服务端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>
        <!--热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
</project>

在当前模块的resources下新建application.yml

server:
  port: 7001
#Eureka配置
eureka:
  instance:
    hostname: localhost #eureka服务端的实例名称
  client:
    register-with-eureka: false # 是否将自己注册到Eureka服务器中，本身是服务器，无需注册
    fetch-registry: false # false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
  service-url:
    defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
    #设置与Eureka Server交互的地址查询服务和注册服务都需要依赖这个defaultZone地址

新建EurekaApplication_7001启动类

package top.tk.springcloud;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.Environment;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * @ClassName: EurekaApplication
 * @Author: campsis-tk
 * @Date: 2020/8/26 8:57
 * @Description:
 **/
@Slf4j
@SpringBootApplication
@EnableEurekaServer //EurekaServer服务器端启动类，接受其他微服务注册进来！
public class EurekaApplication_7001 {
	public static void main(String[] args) throws UnknownHostException {
		ConfigurableApplicationContext application = SpringApplication.run(EurekaApplication_7001.class, args);
		//打印信息
		Environment env = application.getEnvironment();
		String ip = InetAddress.getLocalHost().getHostAddress();
		String port = env.getProperty("server.port");   //端口
		String path = env.getProperty("server.servlet.context-path");   //根路径
		String hj = env.getProperty("spring.profiles.active");  //环境
		log.info("\n----------------------------------------------------------\n\t" +
				"Application Tk Cloud is running! Access URLs:\n\t" +
				"IP: \t\t" + ip + "\n\t" +
				"Port: \t\t" + port + "\n\t" +
				"Local: \t\thttp://localhost:" + port + "/\n\t" +
				"当前配置环境: \t\t当前环境为:" + hj + "\n" +
				"----------------------------------------------------------");
	}
}

spring-cloud-eureka-7001模块结构

启动，访问测试：http://localhost:7001/

System Status：系统信息

DS Replicas：服务器副本

Instances currently registered with Eureka：已注册的微服务列表

General Info：一般信息

Instance Info：实例信息

将 spring-cloud-provider-6001的服务入驻到 spring-cloud-eureka-7001的eureka中！

修改spring-cloud-provider-6001服务的pom文件，增加eureka的支持！

<?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>spring-cloud-demo</artifactId>
        <groupId>top.tk.springcloud</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-cloud-provider-6001</artifactId>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>6</source>
                    <target>6</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <!--引入自定义的模块，我们就可以使用这个模块中的类了-->
        <dependency>
            <groupId>top.tk.springcloud</groupId>
            <artifactId>spring-cloud-api</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <!-- spring-boot-devtools -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <!--将服务的provider注册到eureka中(新增此处)-->
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/springcloud-starter-eureka -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>
    </dependencies>
</project>

修改spring-cloud-provider-6001的yaml中配置eureka 的支持

#端口
server:
  port: 6001

#mybatis配置
mybatis:
  type-aliases-package: top.tk.tk.springcloud.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml
  config-location: classpath:mybatis/mybatis-config.xml

#Spring配置
spring:
  application:
    name: springcloud-provider-user
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource #数据源
    driver-class-name: org.gjt.mm.mysql.Driver
    url: jdbc:mysql://localhost:3306/springcloud-db?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=false
    username: root
    password: root

#eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka

修改spring-cloud-provider-6001的主启动类注解支持

package top.tk.springcloud;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.Environment;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * @ClassName: UserProviderApplication_6001
 * @Author: campsis-tk
 * @Date: 2020/8/25 14:07
 * @Description: 启动类
 **/
@Slf4j
@SpringBootApplication
@EnableDiscoveryClient //服务发现
@EnableEurekaClient // 本服务启动之后会自动注册进Eureka中！
public class UserProviderApplication_6001 {
	public static void main(String[] args) throws UnknownHostException {
		ConfigurableApplicationContext application = SpringApplication.run(UserProviderApplication_6001.class, args);
		//打印信息
		Environment env = application.getEnvironment();
		String ip = InetAddress.getLocalHost().getHostAddress();
		String port = env.getProperty("server.port");               //端口
		String path = env.getProperty("server.servlet.context-path");//根路径
		String hj = env.getProperty("spring.profiles.active");       //环境
		log.info("\n----------------------------------------------------------\n\t" +
				"Application Tk Cloud is running! Access URLs:\n\t" +
				"IP: \t\t" + ip + "\n\t" +
				"Port: \t\t" + port + "\n\t" +
				"Local: \t\thttp://localhost:" + port + "/\n\t" +
				"当前配置环境: \t\t当前环境为:" + hj + "\n" +
				"----------------------------------------------------------");
	}
}

服务端,客户端都创建好了，先启动7001，再启动6001，测试访问

actuator与注册微服务信息完善

主机名称：服务名称修改

在spring-cloud-provider-6001的yaml中修改一下配置

#端口
server:
  port: 6001

#mybatis配置
mybatis:
  type-aliases-package: top.tk.tk.springcloud.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml
  config-location: classpath:mybatis/mybatis-config.xml

#Spring配置
spring:
  application:
    name: springcloud-provider-user
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource #数据源
    driver-class-name: org.gjt.mm.mysql.Driver
    url: jdbc:mysql://localhost:3306/springcloud-db?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=false
    username: root
    password: root

#eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka
  #此处做修改
  instance:
     instance-id: springcloud-provider-user-6001 # 重点，和client平级

先启动7001，再启动6001，测试访问

访问信息有IP信息提示

修改spring-cloud-provider-6001的yml配置

#eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
     instance-id: springcloud-provider-user-6001 # 重点，和client平级
     #修改了此处
     prefer-ip-address: true # true访问路径可以显示IP地址

测试,ip显示成功

info内容的构建

修改6001的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">
    <parent>
        <artifactId>spring-cloud-demo</artifactId>
        <groupId>top.tk.springcloud</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-cloud-provider-6001</artifactId>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>6</source>
                    <target>6</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <!--引入自定义的模块，我们就可以使用这个模块中的类了-->
        <dependency>
            <groupId>top.tk.springcloud</groupId>
            <artifactId>spring-cloud-api</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <!-- spring-boot-devtools -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <!--将服务的provider注册到eureka中-->
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/springcloud-starter-eureka -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>
        <!--actuator监控信息完善(新增此处)-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>
</project>

然后回到我们的spring-cloud-provider-6001的yaml配置文件中修改增加信息

#端口
server:
  port: 6001

#mybatis配置
mybatis:
  type-aliases-package: top.tk.tk.springcloud.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml
  config-location: classpath:mybatis/mybatis-config.xml

#Spring配置
spring:
  application:
    name: springcloud-provider-user
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource #数据源
    driver-class-name: org.gjt.mm.mysql.Driver
    url: jdbc:mysql://localhost:3306/springcloud-db?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=false
    username: root
    password: root

#eureka配置
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
     instance-id: springcloud-provider-user-6001 # 重点，和client平级
     prefer-ip-address: true # true访问路径可以显示IP地址
#此处新增
#配置info
info:
  author.name: tk
  company.name: campsis-tk
  build.artifactId: spring-cloud-provider-6001
  build.version: 1.0

打开info页面查看是否配置成功

Eureka的自我保护机制

如果出现的这些红色情况，没出现的，修改一个服务名，故意制造错误！

一句话总结：某时刻某一个微服务不可以用了，eureka不会立刻清理，依旧会对该微服务的信息进行保 存！

默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注 销该实例（默认90秒）。但是当网络分区故障发生时，微服务与Eureka之间无法正常通行，以上行为可 能变得非常危险了--因为微服务本身其实是健康的，此时本不应该注销这个服务。Eureka通过 自我保护 机制 来解决这个问题--当EurekaServer节点在短时间内丢失过多客户端时（可能发生了网络分区故 障），那么这个节点就会进入自我保护模式。一旦进入该模式，EurekaServer就会保护服务注册表中的 信息，不再删除服务注册表中的数据（也就是不会注销任何微服务）。当网络故障恢复后，该 EurekaServer节点会自动退出自我保护模式。

在自我保护模式中，EurekaServer会保护服务注册表中的信息，不再注销任何服务实例。当它收到的心 跳数重新恢复到阈值以上时，该EurekaServer节点就会自动退出自我保护模式。它的设计哲学就是宁可 保留错误的服务注册信息，也不盲目注销任何可能健康的服务实例.

综上，自我保护模式是一种应对网络异常的安全保护措施。它的架构哲学是宁可同时保留所有微服务 （健康的微服务和不健康的微服务都会保留），也不盲目注销任何健康的微服务。使用自我保护模式， 可以让Eureka集群更加的健壮和稳定。 在SpringCloud中，可以使用 eureka.server.enable-self-preservation = false 禁用自我保护 模式 【不推荐关闭自我保护机制】

对于注册进eureka里面的微服务，可以通过服务发现来获得该服务的信息。【对外暴露服务】

修改spring-cloud-provider-6001工程中的UserController(新增一个info方法)

package top.tk.springcloud.controller;

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.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import top.tk.springcloud.pojo.User;
import top.tk.springcloud.service.UserService;

import java.util.List;

/**
 * @ClassName: UserController
 * @Author: campsis-tk
 * @Date: 2020/8/25 14:04
 * @Description: user控制器
 **/
@RestController
@RequestMapping("/user")    //根路径
public class UserController {

	@Autowired
	private UserService userService;

    //注入DiscoveryClient获取服务信息
	@Autowired
	private DiscoveryClient client;

	@GetMapping("/get/{id}")
	public User get(@PathVariable("id") Integer id) {
		return userService.selectByPrimaryKey(id);
	}

	@GetMapping("/list")
	public List<User> queryAllUser() {
		return userService.queryAllUser();
	}

    //新增此方法
	@GetMapping("/info")
	public Object info() {
		//获得微服务列表清单
		List<String> list = client.getServices();
		System.out.println("client.getServices()==>" + list);
		//得到一个具体的微服务！
		List<ServiceInstance> serviceInstanceList = client.getInstances("springcloud-provider-user");
		for (ServiceInstance serviceInstance : serviceInstanceList) {
			System.out.println(
					serviceInstance.getServiceId() + "\t" +
							serviceInstance.getHost() + "\t" +
							serviceInstance.getPort() + "\t" +
							serviceInstance.getUri()
			);
		}
		return this.client;
	}
}

重启spring-cloud-provider-6001之后访问http://localhost:6001/user/info

修改主启动类(添加@EnableDiscoveryClient)

package top.tk.springcloud;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.Environment;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * @ClassName: UserProviderApplication_6001
 * @Author: campsis-tk
 * @Date: 2020/8/25 14:07
 * @Description: 启动类
 **/
@Slf4j
@SpringBootApplication
@EnableDiscoveryClient //服务发现
@EnableEurekaClient // 本服务启动之后会自动注册进Eureka中！
public class UserProviderApplication_6001 {
	public static void main(String[] args) throws UnknownHostException {
		ConfigurableApplicationContext application = SpringApplication.run(UserProviderApplication_6001.class, args);
		//打印信息
		Environment env = application.getEnvironment();
		String ip = InetAddress.getLocalHost().getHostAddress();
		String port = env.getProperty("server.port");
		String path = env.getProperty("server.servlet.context-path");
		String hj = env.getProperty("spring.profiles.active");
		log.info("\n----------------------------------------------------------\n\t" +
				"Application Tk Cloud is running! Access URLs:\n\t" +
				"IP: \t\t" + ip + "\n\t" +
				"Port: \t\t" + port + "\n\t" +
				"Local: \t\thttp://localhost:" + port + "/\n\t" +
				"当前配置环境: \t\t当前环境为:" + hj + "\n" +
				"----------------------------------------------------------");
	}
}

# consumer访问服务(spring-cloud-consumer-user-80)

修改UserConsumerController增加一个方法

package top.tk.springcloud.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import top.tk.springcloud.pojo.User;

import java.util.List;

/**
 * @ClassName: UserConsumerController
 * @Author: campsis-tk
 * @Date: 2020/8/26 14:26
 * @Description:
 **/
@RestController
@RequestMapping("/consumer")
public class UserConsumerController {
	//理解：消费者，不应该有service层
	//使用RestTemplate访问restful接口非常的简单粗暴且无脑
	//（url，requestMap，ResponseBean.class） 这三个参数分别代表
	//REST请求地址，请求参数，Http响应转换 被 转换成的对象类型

	@Autowired
	private RestTemplate restTemplate;

	private static final String REST_URL_PREFIX = "http://localhost:6001";

	@RequestMapping("/user/get/{id}")
	public User get(@PathVariable("id") Long id){
		return restTemplate.getForObject(REST_URL_PREFIX+"/user/get/" + id,User.class);
	}

	@RequestMapping("/user/list")
	public List<User> list(){
		return restTemplate.getForObject(REST_URL_PREFIX+"/user/list",List.class);
	}

	//新增此方法
	@GetMapping("/user/info")
	public Object info(){
		return restTemplate.getForObject(REST_URL_PREFIX+"/user/info",Object.class);
	}
}

启动测试http://localhost/consumer/user/info

敬请期待下次的(Eureka集群配置)[https://www.cnblogs.com/Campsis-tk/p/13565260.html]

案例在此