Eureka学习过程

最新推荐文章于 2024-08-13 09:30:00 发布

Mrs.Wang??

最新推荐文章于 2024-08-13 09:30:00 发布

阅读量655

点赞数 1

文章标签： eureka java spring spring boot

本文链接：https://blog.csdn.net/qq_42160901/article/details/107447564

版权

组件EurekaServer注册中心

*Spring-cloud是基于Http协议的，他的优势就是可以不同语言之间的交互，Dubbo局限于JAVA之间的通讯

微服务注册中心提供服务注册和服务发现，方便微服务之间的相互调用。Spring Cloud Eureka 就是对应的微服务注册中心解决方案。

Spring Cloud Eureka 微服务注册中心服务端搭建

第一步新增Spring Boot项目依赖，新增 Spring Cloud项目依赖
第二步新增 spring-cloud-starter-netflix-eureka-server依赖
第三步使用 @EnableEurekaServer 注解启动EurekaServer
第四步配置 application.yml 文件
第五步通过浏览器访问 http://localhost:8761

1.首先创建使用SpringBoot作为基本架构，创建父工程，在父工程的pom.xml文件中新增Spring Cloud项目依赖

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

   <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.SR3</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

#如果下载速度比较慢，使用阿里的仓库
<repositories>
    <repository>
        <id>aliyun-repos</id>
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </repository>
</repositories>

<pluginRepositories>
    <pluginRepository>
        <id>aliyun-plugin</id>
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </pluginRepository>
</pluginRepositories>

2.创建子项目，新增 spring-cloud-starter-netflix-eureka-server依赖

<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-web</artifactId>
</dependency>

3.在子工程中创建启动类，使用 @EnableEurekaServer 注解启动EurekaServer

package com.server;

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

/**
 * wl
 * 2020/7/19
 */
@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class,args);
    }
}

4.因为使用的Springboot框架，所以在子项目中配置文件中创建，启动默认加载的文件application.yml,并且配置服务注册相关配置。

spring.application.name: eureka-server      #服务端系统名称
server.port: 8761


eureka:
  server:
    eviction-interval-timer-in-ms: 1000     #服务端每隔1000获取一次服务列表
    enable-self-preservation: false         #关闭自我保护模式
    renewal-percent-threshold: 0.85          #自我保护的错误系数，默认为0.85
    wait-time-in-ms-when-sync-empty: 1       #同步失败的等待时间
    number-of-replication-retries: 5         #同步失败的重试次数
  client:
    serviceUrl:
      defaultZone: http://localhost:8762/eureka/   # 默认注册中心的地址，所有的微服务在启动的时候就要去找这个地址，在服务的注册时候就会注册在这个地址上
    register-with-eureka: true #允许自己注册自己

  instance:                                #指定一个instance-id因为服务之间调用都是通过 instance-id来调用的
    #hostname:eureka1                       #可以通过hostname指定（同一局域网下可以这样设置，在类似上线的大网是不能用的，可能会出现重复）,默认注册到服务中心
    prefer-ip-address: true              # 启用ip前缀
    ip-address: 127.0.0.1                 #设置前缀
    instance-id: ${eureka.instance.ip-address}:${server.port}   # 设置注册服务中心显示的实例名称

5.第五步通过浏览器访问 http://localhost:8761（注册成功）

6.也可以集群部署：通过开启自己可注册自己，根据application.yml配置完成相互注册，完成集群注册。

1.
spring.application.name: eureka-server      #服务端系统名称
server.port: 8761


eureka:
  server:
    eviction-interval-timer-in-ms: 1000     #服务端每隔1000获取一次服务列表
    enable-self-preservation: false         #关闭自我保护模式
    renewal-percent-threshold: 0.85          #自我保护的错误系数，默认为0.85
    wait-time-in-ms-when-sync-empty: 1       #同步失败的等待时间
    number-of-replication-retries: 5         #同步失败的重试次数

  client:
    serviceUrl:
      defaultZone: http://localhost:8762/eureka/   # 默认注册中心的地址，所有的微服务在启动的时候就要去找这个地址，在服务的注册时候就会注册在这个地址上
    register-with-eureka: true #允许自己注册自己

  instance:                                #指定一个instance-id因为服务之间调用都是通过 instance-id来调用的
    #hostname:eureka1                       #可以通过hostname指定（同一局域网下可以这样设置，在类似上线的大网是不能用的，可能会出现重复）,默认注册到服务中心
    prefer-ip-address: true              # 启用ip前缀
    ip-address: 127.0.0.1                 #设置前缀
    instance-id: ${eureka.instance.ip-address}:${server.port}   # 设置注册服务中心显示的实例名称

2.
spring.application.name: eureka-server      #服务端系统名称
server.port: 8762


eureka:
  server:
    eviction-interval-timer-in-ms: 1000     #服务端每隔1000获取一次服务列表
    enable-self-preservation: false         #关闭自我保护模式
    renewal-percent-threshold: 0.85          #自我保护的错误系数，默认为0.85
    wait-time-in-ms-when-sync-empty: 1       #同步失败的等待时间
    number-of-replication-retries: 5         #同步失败的重试次数

  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/   # 默认注册中心的地址，所有的微服务在启动的时候就要去找这个地址，在服务的注册时候就会注册在这个地址上
    register-with-eureka: true #允许自己注册自己

  instance:                                #指定一个instance-id因为服务之间调用都是通过 instance-id来调用的
    #hostname:eureka1                       #可以通过hostname指定（同一局域网下可以这样设置，在类似上线的大网是不能用的，可能会出现重复）,默认注册到服务中心
    prefer-ip-address: true              # 启用ip前缀
    ip-address: 127.0.0.1                 #设置前缀
    instance-id: ${eureka.instance.ip-address}:${server.port}   # 设置注册服务中心显示的实例名称

服务端注册搭建完成。

7.Eureka的自我保护机制

自我我保护模式默认是开启的，当注册中心第一个参数大于第二个参数就开启自我保护模式。第二个系数是注册列表所有服务x2。开启保护模式，当第二个参数大于第一个参数，会报一个错误：服务列表的服务不准确。网络分区故障时开启自我保护，服务列表还在，还能正常调用。假如真的有服务宕机后服务列表不会剔除服务，需要进行客户端容错机制。

注意：

自我保护的错误系数，应该设置低一点，因为生产环境我们的自我保护模式是必须开启的，因为出现网络故障可能会认为所有的服务都失效了，从而剔除掉所有的服务。

二、客户端注册服务以及调用。

1.创建客户端子工程，添加pom.xml依赖

#强调是Springboot的web项目
<dependencies>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
#eureka客户端注册依赖
       <dependency>
           <groupId>org.springframework.cloud</groupId>
           <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
       </dependency>
   </dependencies>

2.再编写配置文件

spring:
  application:
    name: eureka-client

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

server:
  port: 8764

  instance:                                #指定一个instance-id因为服务之间调用都是通过 instance-id来调用的
    #hostname:eureka1                       #可以通过hostname指定（同一局域网下可以这样设置，在类似上线的大网是不能用的，可能会出现重复）,默认注册到服务中心
    prefer-ip-address: true              # 启用ip前缀
    ip-address: 127.0.0.1                 #设置前缀
    instance-id: ${eureka.instance.ip-address}:${server.port}   # 设置注册服务中心显示的实例名称
    #最小心跳续约，默认30s
    lease-renewal-interval-in-seconds: 5
    #90s内没有心跳 则认为该服务挂掉 默认时间90s
    lease-expriation-duration-in-seconds: 10

3.编写启动类，使用 @EnableEurekaClient 注解启动EurekaClient。完成启动注册

package com._01client;

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

@SpringBootApplication
@EnableEurekaClient
public class EurekaClientApp {
    public static void main(String[] args) {
        SpringApplication.run(EurekaClientApp.class,args);
    }
}

目前次客户端服务已经注册到服务注册中心，已经被注册中心发现。

编写客户端服务的业务代码完成业务的访问。

package com._01client.controller;

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

@RestController
public class TestController {
    @Value("${server.port}")
    private String port;

    @RequestMapping(value = "test",method = RequestMethod.GET)
    public String test1(String costum){
        return  String.format(port);
    }
}

这就是微服务的调用过程，下节--------负载均衡、自定义负载均衡，和熔断机制

注意：此处有一个面试问题.

Eureka启动和客户端启动都会生成本地的服务列表缓存，缓存到自己的服务中以list集合进行保存，然后在自己的服务内部调用，如果所有的服务都宕机了，我们仍然可以调用，底层代码是缓存好服务列表后，每隔30s会拉取一次服务，如果Eureka宕机了在30s内都可以取调用，最大时间差是30s。