SpringCloud Eureka安裝和使用，SpringCloud使用Eureka作為服務注冊中心

SpringCloud Eureka安裝和使用，SpringCloud使用Eureka作為服務注冊中心

 

================================

©Copyright 蕃薯耀 2021-03-08

https://www.cnblogs.com/fanshuyao/

 

一、Eureka功能點
server：Eureka Server（服務注冊中心）
provider：Eureka Client（服務提供者）+Actuator（服務器監控）
consumer：Eureka Client（服務器消費者）+Actuator（服務器監控）+Ribbon（負載均衡）

 

二、Eureka server服務端
1、引入Pom依賴

<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
<version>2.2.7.RELEASE</version>
</dependency>

<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.4.4</version>
</dependency>

 

2、application.properties文件配置

server.port=8501


spring.application.name=springCloud-eureka-server

#eureka服務端的實例名稱，eureka8501.com需要修改host文件
eureka.instance.hostname=eureka8501.com
#客戶端服務名
#eureka.instance.appname=${spring.application.name}
# 是否向注冊中心注冊自己，缺省：true
# 一般情況下，Eureka服務端是不需要再注冊自己的，false表示不向注冊中心注冊自己
eureka.client.register-with-eureka=false
# 是否從Eureka獲取注冊信息，缺省：true
# 一般情況下，Eureka服務端是不需要的
eureka.client.fetch-registry=false
# Eureka服務器的地址，類型為HashMap，缺省的Key為 defaultZone；缺省的Value為 http://localhost:8761/eureka
#如果是單機，配置自己的地址：http://eureka8501.com:8501/eureka，同樣可以配置成：http://${eureka.instance.hostname}:${server.port}/eureka
#如果是集群（服務端），在這里需要配置其他eureka server的地址，用逗號進行分隔，如http://192.168.170.11:7000/eureka,http://192.168.170.12:9000/eureka 
#格式為：http://${eureka.instance.hostname}:${server.port}/eureka
eureka.client.service-url.defaultZone=http://eureka8501.com:8501/eureka

#關閉自我保護機制，保證不可用服務被及時移除
eureka.server.enable-self-preservation=false
#3秒后移除
eureka.server.eviction-interval-timer-in-ms=3000

 

3、啟動類

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

@SpringBootApplication
@EnableEurekaServer
public class SpringCloudEurekaServer8501Application {

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

 

三、Eureka provider - 服務提供者端
1、引入Pom依賴

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


<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
<version>2.2.7.RELEASE</version>
</dependency>


<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.4.4</version>
</dependency>

 

2、application.properties文件配置

server.port=8601

spring.application.name=springCloud-eureka-server

#eureka實例名稱
#eureka.instance.hostname=eureka8601.com
eureka.instance.instance-id=eureka8601
#路徑顯示IP地址
eureka.instance.prefer-ip-address=true
#eureka客戶端向服務端發送心跳的時間間隔，單元為秒，默認為30秒
eureka.instance.lease-renewal-interval-in-seconds=2
#eureka服務端收到最后一次心跳等待的時間上限，超時將移除服務，單元為秒，默認為90秒
eureka.instance.lease-expiration-duration-in-seconds=5

#false表示向注冊中心注冊自己
eureka.client.register-with-eureka=true
#是否從Eureka抓取已有的注冊信息，默認為true。單節點不用設置，集群必須設置為true，才能配置ribbon使用負載均衡
eureka.client.fetch-registry=true
#設置與Eureka server交互的地址查詢服務和注冊服務都需要依賴這個地址
eureka.client.service-url.defaultZone=http://eureka8501.com:8501/eureka
#集群配置
#eureka.client.service-url.defaultZone=http://eureka8501.com:8501/eureka,http://eureka8502.com:8501/eureka

 

3、啟動類

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

@SpringBootApplication
@EnableEurekaClient
public class SpringCloudEurekaClient8601Application {

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

}

 

4、服務類

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ClientController {

    @Value("${server.port}")
    private String serverPort;
    
    @Autowired
    private DiscoveryClient discoveryClient;
    
    @RequestMapping("/test")
    public Result test() {
        return Result.ok("端口：" + serverPort);
    }
    
    
    @RequestMapping("/discoveryClient")
    public Result discoveryClient() {
        List<String> services = discoveryClient.getServices();
        for (String service : services) {
            System.out.println("===service = " + service);
            System.out.println("");
            
            List<ServiceInstance> serviceInstances = discoveryClient.getInstances(service);
            for (ServiceInstance serviceInstance : serviceInstances) {
                System.out.println("+++getInstanceId = " + serviceInstance.getInstanceId());
                System.out.println("+++getHost = " + serviceInstance.getHost());
                System.out.println("+++getPort = " + serviceInstance.getPort());
                System.out.println("+++getUri = " + serviceInstance.getUri());
                System.out.println("");
            }
            System.out.println("-------------------------------------");
        }
        
        return Result.ok(discoveryClient);
    }    
}

 

import java.util.Date;

import cn.hutool.core.date.DateUtil;

public class Result {
    
    public static final String SUCCESS = "操作成功。";
    public static final String FAILURE = "操作失敗！";
    
    private boolean result;
    private String timestamp;
    private String msg;
    private Object datas;
    
    private Result() {}
    
    public static Result ok() {
        return Result.ok(SUCCESS, null);
    }
    
    
    public static Result ok(Object datas) {
        return Result.ok(SUCCESS, datas);
    }
    
    
    public static Result okMsg(String msg) {
        return Result.ok(msg, null);
    }
    
    
    public static Result ok(String msg, Object datas) {
        Result result = new Result();
        result.setResult(true);
        result.setTimestamp(DateUtil.formatDateTime(new Date()));
        
        if(msg == null || msg == "" || msg.trim() == "") {
            result.setMsg(SUCCESS);
        }else {
            result.setMsg(msg);
        }
        
        result.setDatas(datas);
        return result;
    }
    
    public static Result fail() {
        return Result.fail(FAILURE, null);
    }
    
    
    public static Result failMsg(String msg) {
        return Result.fail(msg, null);
    }
    
    
    public static Result fail(Object datas) {
        return Result.fail(FAILURE, datas);
    }
    
    public static Result fail(String msg, Object datas) {
        Result result = new Result();
        result.setResult(false);
        result.setTimestamp(DateUtil.formatDateTime(new Date()));
        
        if(msg == null || msg == "" || msg.trim() == "") {
            result.setMsg(FAILURE);
        }else {
            result.setMsg(msg);
        }
        result.setDatas(datas);
        return result;
    }
    
    public boolean isResult() {
        return result;
    }
    public void setResult(boolean result) {
        this.result = result;
    }
    public String getTimestamp() {
        return timestamp;
    }

    public void setTimestamp(String timestamp) {
        this.timestamp = timestamp;
    }

    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
    public Object getDatas() {
        return datas;
    }
    public void setDatas(Object datas) {
        this.datas = datas;
    }
    

    public static void main(String[] args) {
        
    }
    
}

 

四、Eureka consumer - 服務消費者端
1、引入Pom依賴

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

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    <version>2.2.7.RELEASE</version>
</dependency>

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.4.4</version>
</dependency>

 

2、application.properties文件配置

server.port=8701

spring.application.name=springCloud-eureka-web

#eureka服務端的實例名稱
eureka.instance.hostname=eureka8701.com

#eureka實例名稱
eureka.instance.instance-id=eureka8701
#路徑顯示IP地址
eureka.instance.prefer-ip-address=true
#eureka客戶端向服務端發送心跳的時間間隔，單元為秒，默認為30秒
eureka.instance.lease-renewal-interval-in-seconds=2
#eureka服務端收到最后一次心跳等待的時間上限，超時將移除服務，單元為秒，默認為90秒
eureka.instance.lease-expiration-duration-in-seconds=5

#false表示向注冊中心注冊自己
eureka.client.register-with-eureka=false
#是否從Eureka抓取已有的注冊信息，默認為true。單節點不用設置，集群必須設置為true，才能配置ribbon使用負載均衡
eureka.client.fetch-registry=true
#設置與Eureka server交互的地址查詢服務和注冊服務都需要依賴這個地址
eureka.client.service-url.defaultZone=http://eureka8501.com:8501/eureka

 

3、啟動類

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

@SpringBootApplication
@EnableEurekaClient
public class SpringCloudEurekaWebApplication {

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

}

 

 

4、RestTemplate類

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

@Configuration
public class RestConfig {

    //@LoadBalanced實現負載均衡
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

 

5、服務請求類

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@RequestMapping("/web")
public class TestController {

    //private String serviceUrl = "http://eureka8601.com:8601";
    //springCloud使用RestTemplate，如果使用了服務的地址，RestTemplate必須加上@LoadBalanced注解，不然會java.net.UnknownHostException
    private String serviceUrl = "http://SPRINGCLOUD-EUREKA-SERVER";
    
    @Autowired
    private RestTemplate restTemplate;
    
    @RequestMapping(value="/get", produces = MediaType.APPLICATION_JSON_VALUE)
    public Result get() {
        Result result = restTemplate.getForObject(serviceUrl + "/test", Result.class);
        return result;
    }
    
}

 

五、eureka配置項解析
1、eureka通用配置

# 應用名稱，將會顯示在Eureka界面的應用名稱
spring.application.name=config-service
# 應用端口，Eureka服務端默認為：8761
server.port=3333

 

2、eureka.server前綴的配置項

# 是否允許開啟自我保護模式，缺省：true
# 當Eureka服務器在短時間內丟失過多客戶端時，自我保護模式可使服務端不再刪除失去連接的客戶端
eureka.server.enable-self-preservation = false

# Peer節點更新間隔，單位：毫秒
eureka.server.peer-eureka-nodes-update-interval-ms =

# Eureka服務器清理無效節點的時間間隔，單位：毫秒，缺省：60000，即60秒
eureka.server.eviction-interval-timer-in-ms = 60000

 

3、eureka.instance前綴的配置項

# 服務名，默認取 spring.application.name 配置值，如果沒有則為 unknown
eureka.instance.appname = eureka-client

# 實例ID
eureka.instance.instance-id = eureka-client-instance1

# 應用實例主機名
eureka.instance.hostname = localhost

# 客戶端在注冊時使用自己的IP而不是主機名，缺省：false
eureka.instance.prefer-ip-address = false

# 應用實例IP
eureka.instance.ip-address = 127.0.0.1

# 服務失效時間，失效的服務將被剔除。單位：秒，默認：90
eureka.instance.lease-expiration-duration-in-seconds = 90

# 服務續約（心跳）頻率，單位：秒，缺省30
eureka.instance.lease-renewal-interval-in-seconds = 30

# 狀態頁面的URL，相對路徑，默認使用 HTTP 訪問，如需使用 HTTPS則要使用絕對路徑配置，缺省：/info
eureka.instance.status-page-url-path = /info

# 健康檢查頁面的URL，相對路徑，默認使用 HTTP 訪問，如需使用 HTTPS則要使用絕對路徑配置，缺省：/health
eureka.instance.health-check-url-path = /health

 

4、eureka.client前綴的配置項

# Eureka服務器的地址，類型為HashMap，缺省的Key為 defaultZone；缺省的Value為 http://localhost:8761/eureka
# 如果服務注冊中心為高可用集群時，多個注冊中心地址以逗號分隔。 
eureka.client.service-url.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka

# 是否向注冊中心注冊自己，缺省：true
# 一般情況下，Eureka服務端是不需要再注冊自己的
eureka.client.register-with-eureka = true

# 是否從Eureka獲取注冊信息，缺省：true
# 一般情況下，Eureka服務端是不需要的
eureka.client.fetch-registry = true

# 客戶端拉取服務注冊信息間隔，單位：秒，缺省：30
eureka.client.registry-fetch-interval-seconds = 30

# 是否啟用客戶端健康檢查
eureka.client.health-check.enabled = true

# 
eureka.client.eureka-service-url-poll-interval-seconds = 60

# 連接Eureka服務器的超時時間，單位：秒，缺省：5
eureka.client.eureka-server-connect-timeout-seconds = 5

# 從Eureka服務器讀取信息的超時時間，單位：秒，缺省：8
eureka.client.eureka-server-read-timeout-seconds = 8

# 獲取實例時是否只保留狀態為 UP 的實例，缺省：true
eureka.client.filter-only-up-instances = true

# Eureka服務端連接空閑時的關閉時間，單位：秒，缺省：30
eureka.client.eureka-connection-idle-timeout-seconds = 30

# 從Eureka客戶端到所有Eureka服務端的連接總數，缺省：200
eureka.client.eureka-server-total-connections = 200

# 從Eureka客戶端到每個Eureka服務主機的連接總數，缺省：50
eureka.client.eureka-server-total-connections-per-host = 50

 

 

（時間寶貴，分享不易，捐贈回饋，^_^）

 

================================

©Copyright 蕃薯耀 2021-03-08

https://www.cnblogs.com/fanshuyao/