springcloud+eureka 實現微服務-------------------入門程式

阿新 • • 發佈：2019-01-13

在寫程式碼之前先了解幾個概念。

單系統架構

將業務邏輯層、資料庫訪問層、控制層放入在一個專案中。優點:適合於個人或者小團隊開發，不適合大團隊開發。
分散式專案架構

根據業務需求進行拆分成N個子系統，多個子系統相互協作才能完成業務流程子系統之間通訊使用RPC遠端通訊技術。
優點:
1.把模組拆分，使用介面通訊，降低模組之間的耦合度。
2.把專案拆分成若干個子專案，不同的團隊負責不同的子專案。
3.增加功能時只需要再增加一個子專案，呼叫其它系統的介面就可以。
4.可以靈活的進行分散式部署。

有優點就有缺點，缺點如下：
1.系統之間互動需要使用遠端通訊，介面開發增加工作量。
2.各個模組有一些通用的業務邏輯無法共用。

為了解決上面分散式架構的缺點，我們引入了soa架構，SOA：Service Oriented Architecture面向服務的架構。也就是把工程拆分成服務層、表現層兩個工程。服務層中包含業務邏輯，只需要對外提供服務即可。表現層只需要處理和頁面的互動，業務邏輯都是呼叫服務層的服務來實現。

什麼是專案叢集
多臺伺服器部署相同應用構成一個叢集
作用：通過負載均衡裝置共同對外提供服務
RPC遠端呼叫
RPC 的全稱是 Remote Procedure Call 是一種程序間通訊方式。
它允許程式呼叫另一個地址空間（通常是共享網路的另一臺機器上）的過程或函式，而不用程式設計師顯式編碼這個遠端呼叫的細節。即無論是呼叫本地介面/服務的還是遠端的介面/服務，本質上編寫的呼叫程式碼基本相同。
比如兩臺伺服器A，B，一個應用部署在A伺服器上，想要呼叫B伺服器上應用提供的函式或者方法，由於不在一個記憶體空間，不能直接呼叫，這時候需要通過就可以應用RPC框架的實現來解決
restful、soap、rpc
（1）restful是一種架構設計風格，提供了設計原則和約束條件，而不是架構。而滿足這些約束條件和原則的應用程式或設計就是 RESTful架構或服務。
（2）soap象訪問協議是一種資料交換協議規範，是一種輕量的、簡單的、基於XML的協議的規範。SOAP協議和HTTP協議一樣，都是底層的通訊協議，只是請求包的格式不同而已，SOAP包是XML格式的。
soap基於xml並封裝成了符合http協議，因此，它符合任何路由器、防火牆或代理伺服器的要求。
soap可以使用任何語言來完成，只要傳送正確的soap請求即可，基於soap的服務可以在任何平臺無需修改即可正常使用。
（3）RPC就是從一臺機器（客戶端）上通過引數傳遞的方式呼叫另一臺機器（伺服器）上的一個函式或方法（可以統稱為服務）並得到返回的結果。
RPC 會隱藏底層的通訊細節（不需要直接處理Socket通訊或Http通訊）
RPC 是一個請求響應模型。客戶端發起請求，伺服器返回響應（類似於Http的工作方式）
RPC 在使用形式上像呼叫本地函式（或方法）一樣去呼叫遠端的函式（或方法）。
rpc遠端呼叫框架
幾種比較典型的RPC的實現和呼叫框架。
（1）RMI實現，利用java.rmi包實現，基於Java遠端方法協議(Java Remote Method Protocol) 和java的原生序列化。
（2）Hessian，是一個輕量級的remoting onhttp工具，使用簡單的方法提供了RMI的功能。基於HTTP協議，採用二進位制編解碼。
（3）thrift是一種可伸縮的跨語言服務的軟體框架。thrift允許你定義一個描述檔案，描述資料型別和服務介面。依據該檔案，編譯器方便地生成RPC客戶端和伺服器通訊程式碼。
（4）SpringCloud 為開發人員提供了快速構建分散式系統的一些工具，包括配置管理、服務發現、斷路器、路由、微代理、事件匯流排、全域性鎖、決策競選、分散式會話等等。
（4） Dubbo是阿里巴巴公司開源的一個高效能優秀的服務框架，使得應用可通過高效能的 RPC 實現服務的輸出和輸入功能，可以和 Spring框架無縫整合。
面向於服務架構（SOA）
業務系統分解為多個元件，讓每個元件都獨立提供離散，自治，可複用的服務能力，通過服務的組合和編排來實現上層的業務流程
作用：簡化維護,降低整體風險,伸縮靈活
什麼是微服務架構
架構設計概念,各服務間隔離（分散式也是隔離）,自治（分散式依賴整體組合）其它特性(單一職責,邊界,非同步通訊,獨立部署)是分散式概念的跟嚴格執行 SOA到微服務架構的演進過程
作用：各服務可獨立應用，組合服務也可系統應用(巨石應用[monolith]的簡化實現策略-平臺思想)
服務提供者與消費關係

服務提供者:提供服務被人呼叫
消費者:呼叫被人服務
服務的註冊與發現(Eureka )

在這裡，我們需要用的的元件上Spring Cloud Netflix的Eureka ,eureka是一個服務註冊和發現模組。
什麼是Eureka
官方的介紹在這裡Eureka wiki。Eureka是Netflix開源的一個RESTful服務，主要用於服務的註冊發現。Eureka由兩個元件組成：Eureka伺服器和Eureka客戶端。Eureka伺服器用作服務註冊伺服器。Eureka客戶端是一個java客戶端，用來簡化與伺服器的互動、作為輪詢負載均衡器，並提供服務的故障切換支援。Netflix在其生產環境中使用的是另外的客戶端，它提供基於流量、資源利用率以及出錯狀態的加權負載均衡。
在我看來，Eureka的吸引力來源於以下幾點：
開源：大家可以對實現一探究竟，甚至修改原始碼。
可靠：經過Netflix多年的生產環境考驗，使用應該比較靠譜省心
功能齊全：不但提供了完整的註冊發現服務，還有Ribbon等可以配合使用的服務。
基於Java：對於Java程式設計師來說，使用起來，心裡比較有底。

Spring Cloud,與Eureka進行了很好的整合，使用起來非常方便。

程式碼實現

Eureka服務端，程式碼結構如下：
Eureka

EurekaApplication.java

package com.example.eureka;

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

@SpringBootApplication
@EnableEurekaServer //這個註釋一定要加 eureka服務端
public class EurekaApplication {

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

application.yml

server:
  port: 8888
eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      #eureka 訪問地址為 http://localhost:8888

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.example</groupId>
    <artifactId>service-member</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>service-member</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.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>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

啟動 EurekaApplication.java
訪問http://localhost:8888，如圖：
這裡寫圖片描述
由於沒有現在還沒有服務註冊進來，所以例項為空。

下面我們寫個服務註冊到eureka上面：
程式碼結構如下圖：
這裡寫圖片描述
MemberController.java

package com.example.controller;

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

import java.util.ArrayList;
import java.util.List;

@RestController
public class MemberController {
    @Value("${server.port}")
    private String port; //port 引數用來測試 當這個服務啟動多個的時候 客戶端訪問的時候採用輪詢的方式

    @RequestMapping("/getUser")
    public List getUser(){
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add(port);
        return list;
    }
}

ServiceMemberApplication.java

package com.example.servicemember;

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

@SpringBootApplication
@EnableEurekaClient //eureka 客戶端
@ComponentScan("com.example.controller")//掃描包
public class ServiceMemberApplication {

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

application.yml

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8888/eureka/
      #將服務註冊到上面的地址
server:
  port: 8762
spring:
  application:
    name: service-member

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.example</groupId>
    <artifactId>service-member</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>service-member</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.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.M9</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>

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

啟動ServiceMemberApplication.java ，啟動完畢，這時候這個服務就被註冊到eureka中了。開啟http://localhost:8888/，如圖：
這裡寫圖片描述
如圖，服務被註冊進來了。

接下來，寫一個呼叫SERVICE-MEMBER服務的服務，即消費者服務。
專案結構如下圖：
這裡寫圖片描述
OrderController.java

package com.example.controller;


import com.example.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class OrderController {
    @Autowired
    private OrderService orderService;

    @RequestMapping("/getUser")
    public List<String> getUser(){
        return orderService.getMember();
    }



}

OrderService.java

package com.example.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@Service
public class OrderService {
    @Autowired
    private RestTemplate restTemplate;

    public List<String> getMember(){
        return restTemplate.getForObject("http://service-member/getUser",List.class);
    }
}

ServiceOrderApplication.java

package com.example;

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.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@EnableEurekaClient
@SpringBootApplication
public class ServiceOrderApplication {

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

    @Bean
    @LoadBalanced //ribbon實現負載均衡，需要加入ribbon依賴
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

application.yml

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8888/eureka/
      #將該服務註冊到上面地址的eureka中
server:
  port: 8764
  tomcat:
    max-threads: 50
spring:
  application:
    name: service-order

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.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.10.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>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

好了，啟動ServiceOrderApplication ，再開啟http://localhost:8888/ 會發現又多了一個服務，如下圖：
這裡寫圖片描述

我們訪問getUser這個介面，得到結果：如圖：
這裡寫圖片描述
這樣我們一個簡單的微服務就寫完了。

我們可以將服務提供者service-member的埠改掉，現在是8762，我們將埠改為8763，再啟動一下service-member，之前啟動的8762不要停，現在相當於service-member這個服務有兩個。再重新整理一下http://localhost:8888/ 這個地址，發現service-member變成了兩個。如下圖：
這裡寫圖片描述
這是我們重複的去訪問getUser這個介面，發現返回的port這個引數在8762和8763之間來回切換，這個就說明是對service-member服務的輪詢訪問。

zuul攔截
Zuul的主要功能是路由轉發和過濾器。路由功能是微服務的一部分，比如／api/user轉發到到user服務，/api/shop轉發到到shop服務。zuul預設和Ribbon結合實現了負載均衡的功能，類似於nginx轉發。

新建一個工程用來實現zuul轉發功能。
專案結構如下圖：
這裡寫圖片描述
依賴：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.example</groupId>
    <artifactId>service-zuul</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>service-zuul</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.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.RC1</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.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</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>

ServiceZuulApplication.java

package com.example.servicezuul;

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

@EnableZuulProxy //必須要加這個註解
@EnableEurekaClient
@SpringBootApplication
public class ServiceZuulApplication {

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

application.yml

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8888/eureka/
server:
  port: 8769
spring:
  application:
    name: service-zuul
zuul:
  routes:
    api-a:
      path: /api-member/**
      #path自定義即可
      service-id: service-member 
      #service-id是對應得服務工程名,這裡表示訪問/api-member/** 會轉發到service-member這個服務
    api-b:
      path: /api-order/**
      service-id: service-order

ZuulFilter攔截器
對所有請求進行攔截過濾，新建攔截器，MyFilter.java

package com.example.servicezuul;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
@Component
public class MyFilter extends ZuulFilter {
    private static Logger logger = LoggerFactory.getLogger(MyFilter.class);

    /**
     * filterType：返回一個字串代表過濾器的型別，在zuul中定義了四種不同生命週期的過濾器型別，具體如下：
     * pre：可以在請求被路由之前呼叫
     * route：在路由請求時候被呼叫
     * post：在route和error過濾器之後被呼叫
     * error：處理請求時發生錯誤時被呼叫
     * @return
     */
    @Override
    public String filterType() {
        return "pre";// 前置過濾器
    }

    /**
     * filterOrder：通過int值來定義過濾器的執行順序
     * @return
     */
    @Override
    public int filterOrder() {
        return 0;// 優先順序為0，數字越大，優先順序越低
    }

    /**
     * shouldFilter：返回一個boolean型別來判斷該過濾器是否要執行，所以通過此函式可實現過濾器的開關。在上例中，我們直接返回true，所以該過濾器總是生效
     * @return
     */
    @Override
    public boolean shouldFilter() {
        return true;// 是否執行該過濾器，此處為true，說明需要過濾
    }

    /**
     * run：過濾器的具體邏輯。需要注意，這裡我們通過ctx.setSendZuulResponse(false)令zuul過濾該請求，不對其進行路由，然後通過ctx.setResponseStatusCode(401)設定了其返回的錯誤碼
     * @return
     * @throws ZuulException
     */
    @Override
    public Object run() throws ZuulException {
        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletRequest request = ctx.getRequest();
        logger.info(String.format("%s >>> %s", request.getMethod(), request.getRequestURL().toString()));
        String refer=request.getHeader("refer");
        Object accessToken = request.getParameter("token");
        if (accessToken != null) {
            return null;
        }
        logger.warn("token is empty");
        ctx.setSendZuulResponse(false);//過濾該請求，不對其進行路由
        ctx.setResponseStatusCode(401);
        try {
            ctx.getResponse().getWriter().write("token is empty");
        } catch (Exception e) {
        }
        return null;
    }

    public static void main(String[] args) {
        logger.info(String.format("%s >>> %s", "jiangjz", "www.baidu.con"));
    }
}

springcloud+eureka 實現微服務-------------------入門程式

springcloud+eureka 實現微服務-------------------入門程式

spring-boot-admin 配合eureka實現微服務監控

Spring Boot + Eureka 實現微服務負載均衡

大型電商基於Springboot+Springcloud微服務+Dubbo分散式，JVM虛擬機器，併發原理程式設計，實現微服務架構

基於SpringBoot和SpringCloud實現微服務架構

Eureka + Ribbon實現微服務的服務發現和負載均衡

微服務springcloud—為什麼要實現微服務跟蹤和SpringCloudSleuth簡介

用nodejs快速實現微信小程式的websocket服務端

史上最簡單的springcloud微服務入門例項，開箱即用，工資翻倍不是夢

SpringCloud實戰 | 第五篇：SpringCloud整合OpenFeign實現微服務之間的呼叫

springcloud~演化的微服務架構

ZooKeeper分布式專題與Dubbo微服務入門

基於Spring Boot和Spring Cloud實現微服務架構學習

基於Spring Boot和Spring Cloud實現微服務架構學習(四)

微服務入門06AspectCore Aop

微服務入門08 Ocelot

基於天氣預報項目談springcloud構建的微服務（一）

《SpringCloud與Docker微服務架構實戰》第七八章服務容錯閘道器

《SpringCloud與Docker微服務架構實戰》第四五六章服務註冊發現與呼叫

如何通過本地化事件正確實現微服務內部強一致性，事件匯流排跨微服務間最終一致性

springcloud+eureka 實現微服務-------------------入門程式

相關推薦