springboot 集成eureka 超詳細配置

擼了今年阿里、頭條和美團的面試，我有一個重要發現.......>>>

原文鏈接: https://blog.csdn.net/nanbiebao6522/article/details/80574463

就不重復造輪子了, 以下是原文:

前言

1，什么是Eureka，什么是服務注冊與發現

      Spring Boot作為目前最火爆的web框架。那么它與Eureka又有什么關聯呢？

Eureka是Netflix開源的一個RESTful服務，主要用於服務的注冊發現。
Eureka由兩個組件組成：Eureka服務器和Eureka客戶端。Eureka服務器用作服務注冊服務器。
Eureka客戶端是一個java客戶端，用來簡化與服務器的交互、作為輪詢負載均衡器，並提供服務的故障切換支持。
Netflix在其生產環境中使用的是另外的客戶端，它提供基於流量、資源利用率以及出錯狀態的加權負載均衡。

2，先創建一個Eureka-Server服務注冊中心

    
    這里需要用到spring-cloud的Eureka模塊，他是一個服務的注冊和發現模塊
      如圖我們先new一個Spring-boot工程引入Eureka Server

        

Next>>>>Finish完成

我們來看看構建好的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>
    <groupId>com.eureka</groupId>
    <artifactId>server</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>server</name>
    <description>Demo project for Spring Boot</description>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.RC2</spring-cloud.version>
    </properties>
    <dependencies>
        <!-- 引入的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-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </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>
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
</project>

    我們看到這里與普通的Spring-boot項目不同的是，這里引用了一個Eureka-Server包。
    那么我們怎么使用它呢，怎么啟動它呢？

     這里只需要啟動一個注解就可以啦，我們在Spring-Boot工程的啟動類上加>>>>>>
    @EnableEurekaServer
    代碼如下：
  

package com.eureka.server;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
/** * 啟動一個服務注冊中心 */
@EnableEurekaServer
@SpringBootApplication
public class ServerApplication {
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">main</span><span class="hljs-params">(String[] args)</span> </span>{
    SpringApplication.run(ServerApplication.class, args);
}

}

   
差點忘了，我們還需要配置application.yml

Eureka是一個高可用的組件，每一個實例注冊之后需要向注冊中心發送心跳包，在默認情況下erureka server也是一個eureka client ,必須要指定一個 server。

eureka server的配置文件appication.yml：

server:
  port: 8081 #服務注冊中心端口號
eureka:
  instance:
    hostname: 127.0.0.1 #服務注冊中心IP地址
  client:
    registerWithEureka: false #是否向服務注冊中心注冊自己
    fetchRegistry: false #是否檢索服務
    serviceUrl: #服務注冊中心的配置內容，指定服務注冊中心的位置
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

我們來啟動一下吧

我們在瀏覽器上輸入http://127.0.0.1:8081

我們可以看到它的可視化界面

細心的朋友會發現，這里沒有發現服務？？？No instance available

why？  因為我們還沒有服務向注冊中心注冊服務，所以找不到啊。

3，先創建一個Eureka-Client客戶端也就是服務提供者

        客戶端在向注冊中心它會提供一些元數據，例如主機和端口，URL，主頁等。Eureka server 從    每        個client實例接收心跳消息。 如果心跳超時，則通常將該實例從注冊server中刪除。       

    創建客戶端和服務端差不多，只是啟動注解有點不一樣，還有yml配置文件

  

Next>>>Finish完成啦

打開會發現pom.xml其實和Server注冊中心的類似

<?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>com.eureka</groupId>
    <artifactId>provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>provider</name>
    <description>Demo project for Spring Boot</description>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.RC2</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-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>
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
</project>

怎么證明它是Client呢
很簡單
在Spring-boot的啟動類上通過注解@EnableEurekaClient 表明自己是一個eurekaclient.

 

package com.eureka.provider;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
/**  * Eureka客戶端  */
@RestController
@EnableEurekaClient
@SpringBootApplication
public class ProviderApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(ProviderApplication.class, args);
    }
 
 
    /**      * 假如這個客戶端要提供一個getUser的方法      * @return      */
    @GetMapping(value = "/getUser")
    @ResponseBody
    public Map<String,Object> getUser(@RequestParam Integer id){
        Map<String,Object> data = new HashMap<>();
        data.put("id",id);
        data.put("userName","admin");
        data.put("from","provider-A");
        return data;
    }
 
}

雖然加好了@EnableEurekaClient，總感覺差點什么，對了，配置文件yml

eureka:
  client:
    serviceUrl: #注冊中心的注冊地址
      defaultZone: http://127.0.0.1:8081/eureka/
server:
  port: 8082  #服務端口號
spring:
  application:
    name: service-provider #服務名稱--調用的時候根據名稱來調用該服務的方法

我們來啟動看看吧

我們看到這個客戶端已經向注冊中心注冊服務了，那么我們打開Eureka-server

我們看到我們啟動的服務是不是加進去了呢

我們看到我們的服務是不是加進去了呢。

那么有人會問，那一大堆飆紅的什么意思啊。因為注冊的服務都是高可用的，這里只檢測到一個服務，產生的預警，不影響使用，等下我們啟動多個實例就不會了。

我們先來測試下客戶端的方法是否可用   

顯然是沒有問題，那么我們提供好了服務，sei來消費呢？

下面我們就來建立一個消費者

為了更簡單易懂，我還是一步一步出圖吧。

來，貼上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>
    <groupId>com.eureka</groupId>
     <artifactId>consumer</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <packaging>jar</packaging>
    <name>consumer</name>
     <description>Demo project for Spring Boot</description>
    <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
         <version>2.0.2.RELEASE</version>
         <relativePath/> <!-- lookup parent from repository -->
     </parent>
    <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
         <java.version>1.8</java.version>
         <spring-cloud.version>Finchley.RC2</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-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>
    <repositories>
         <repository>
             <id>spring-milestones</id>
             <name>Spring Milestones</name>
             <url>https://repo.spring.io/milestone</url>
             <snapshots>
                 <enabled>false</enabled>
             </snapshots>
         </repository>
     </repositories>
</project>

主要是啟動類，里面內容就豐富啦，都在注釋里

package com.eureka.consumer;
import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.cloud.client.loadbalancer.LoadBalanced;
 import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
 import org.springframework.context.annotation.Bean;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.client.RestTemplate;
import java.util.HashMap;
 import java.util.Map;
/**
  * Eureka客戶端-消費者
  */
 @RestController
 @EnableEurekaClient
 @SpringBootApplication
 public class ConsumerApplication {
    @Autowired
     RestTemplate restTemplate;
    public static void main(String[] args) {
         SpringApplication.run(ConsumerApplication.class, args);
     }
    /**
      * 實例化RestTemplate
      * @return
      */
     @LoadBalanced
     @Bean
     public RestTemplate rest() {
         return new RestTemplate();
     }
    /**
      * Rest服務端使用RestTemplate發起http請求,然后得到數據返回給前端----gotoUser是為了區分getUser怕小伙伴暈頭
      * @param id
      * @return
      /
     @GetMapping(value = "/gotoUser")
     @ResponseBody
     public Map<String,Object> getUser(@RequestParam Integer id){
         Map<String,Object> data = new HashMap<>();
         /**
           小伙伴發現沒有，地址居然是http://service-provider
          * 居然不是http://127.0.0.1:8082/
          * 因為他向注冊中心注冊了服務，服務名稱service-provider,我們訪問service-provider即可
          */
         data = restTemplate.getForObject("http://service-provider/getUser?id="+id,Map.class);
         return data;
     }
}

配置文件

eureka:
  client:
    serviceUrl: #注冊中心的注冊地址
      defaultZone: http://127.0.0.1:8081/eureka/
server:
  port: 8083  #服務端口號
spring:
  application:
    name: service-consumer #服務名稱--調用的時候根據名稱來調用該服務的方法

我們啟動看看效果吧

看看我們的提供者和消費者是不是都進來了

那么我們看看我們消費者的方法是否可用 

哈哈，是不是很神奇

下面介紹個更神奇的東西--實現微服務負載均衡

我們把服務提供者復制一個工程出來，我們再做下小小的修改，看看是否能實現負載均衡。

我們需要修改兩個文件

一個是啟動類，改了哪些呢？看看就曉得咯

package com.eureka.provider;
import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
 import java.util.Map;
/**
  * Eureka客戶端
  */
 @RestController
 @EnableEurekaClient
 @SpringBootApplication
 public class ProviderApplication {
    public static void main(String[] args) {
         SpringApplication.run(ProviderApplication.class, args);
     }
    /**
      * 假如這個客戶端要提供一個getUser的方法
      * @return
      */
     @GetMapping(value = "/getUser")
     @ResponseBody
     public Map<String,Object> getUser(@RequestParam Integer id){
         Map<String,Object> data = new HashMap<>();
         data.put("id",id);
         data.put("userName","admin");
         data.put("from","provider-B");//改這里是為了讓大家更能理解它負載均衡的機制
         return data;
     }
}

還有就是yml配置文件

eureka:
  client:
    serviceUrl: #注冊中心的注冊地址
      defaultZone: http://127.0.0.1:8081/eureka/
server:
  port: 8088  #服務端口號--該端口不要沖突
spring:
  application:
    name: service-provider #服務名稱--調用的時候根據名稱來調用該服務的方法--名字絕對不能改，改了就訪問不到了

我們來啟動一下吧

看看Eureka-server后台的效果    ServerA      ServerB    

這個叫做Service-provider是不是有兩個實例啊
那么，我們分別訪問一下，看看效果怎么樣

看到了嗎，8082端口，from是provider-A，8088端口，from是provider-B.

 

那么我們訪問消費者的服務器看看會出現什么樣的情況呢  飛機直達

一開始是from A,你刷新一下，誒？ 變成 from B了。
說明這個時候兩台提供者在交替工作，從而達到了一個負載均衡的作用。

來來來，我給你畫個圖

每個微服務都是一個Eureka-Client，我們把每個app（SpringBootApplication）都向注冊中心注冊一個服務。
有時候，某個服務的工作量比較大的時候，我們可以多注冊幾個同名稱的微服務，從而讓他們交替工作，減輕單個服務的壓力。

寫到這里就結束咯。

明天還要上班呢。

有哪里不對的地方，希望大家幫忙指正。

我也在學習的道路上。
--------------------- 
作者：TIny1995 
來源：CSDN 
原文：https://blog.csdn.net/nanbiebao6522/article/details/80574463 
版權聲明：本文為博主原創文章，轉載請附上博文鏈接！

                                    </div>

原文地址：https://my.oschina.net/java1314/blog/3023108