2. 程式人生 > >技術與架構之zuul（spring-cloud-zuul）原始碼解讀

技術與架構之zuul（spring-cloud-zuul）原始碼解讀

阿新 • • 發佈：2019-10-01
  1. zuul原始碼裡面一大堆test程式碼
  2. zuul好多程式碼都是11年的

閘道器是什麼,為什麼需要閘道器

百度百科是這樣解釋的：閘道器(Gateway)又稱網間聯結器、協議轉換器。閘道器在網路層以上實現網路互連，是複雜的網路互連裝置，僅用於兩個高層協議不同的網路互連。仔細看下下面的圖。

  1. 閘道器負責接收請求，並把請求轉發給後端正確的服務。這是說明與上面的圖是不是很像Nginx的功能，不錯。閘道器最基礎的功能是反向代理。

zuul的基本架構設計

zuul核心模組是zuul-core。spring-cloud集成了zuul實現的jar是spring-cloud-netflix-zuul。

zuul-core

  1. filter
  2. FilterRegistry
  3. FilterLoader
  4. FilterProcessor
  5. ZuulRunner

當一個請求來了，這是類的呼叫鏈。

filter

filter是zuul核心執行流程，IZuulFilter是介面，主要是實現run方法。而ZuulFilter又兩個抽象方法filterType（ filter型別）和filterOrder（filter的排序），麻煩仔細看下ZuulFilter的runFilter方法，主要是執行run方法，並且對run的執行行為進行處理。

public interface IZuulFilter {

    boolean shouldFilter();

    Object run() throws ZuulException;

}

public abstract class ZuulFilter implements IZuulFilter, Comparable<ZuulFilter> {

    private final AtomicReference<DynamicBooleanProperty> filterDisabledRef = new AtomicReference<>();

    abstract public String filterType();

    abstract public int filterOrder();

    public boolean isStaticFilter() {
        return true;
    }
    public String disablePropertyName() {
        return "zuul." + this.getClass().getSimpleName() + "." + filterType() + ".disable";
    }

    public boolean isFilterDisabled() {
        filterDisabledRef.compareAndSet(null, DynamicPropertyFactory.getInstance().getBooleanProperty(disablePropertyName(), false));
        return filterDisabledRef.get().get();
    }

    public ZuulFilterResult runFilter() {
        ZuulFilterResult zr = new ZuulFilterResult();
        if (!isFilterDisabled()) {
            if (shouldFilter()) {
                Tracer t = TracerFactory.instance().startMicroTracer("ZUUL::" + this.getClass().getSimpleName());
                try {
                    Object res = run();
                    zr = new ZuulFilterResult(res, ExecutionStatus.SUCCESS);
                } catch (Throwable e) {
                    t.setName("ZUUL::" + this.getClass().getSimpleName() + " failed");
                    zr = new ZuulFilterResult(ExecutionStatus.FAILED);
                    zr.setException(e);
                } finally {
                    t.stopAndLog();
                }
            } else {
                zr = new ZuulFilterResult(ExecutionStatus.SKIPPED);
            }
        }
        return zr;
    }
}

 

public class FilterConstants {
	public static final String ERROR_TYPE = "error";

	public static final String POST_TYPE = "post";

	public static final String PRE_TYPE = "pre";

	public static final String ROUTE_TYPE = "route";
}
FilterRegistry

filterRegistry是filter的註冊物件，非常簡單。只需要注意下靜態成員變數INSTANCE。注意：zuul2.0以後可能會刪除INSTANCE

public class FilterRegistry{
    private static final FilterRegistry INSTANCE = new FilterRegistry();

    public static final FilterRegistry instance() {
        return INSTANCE;
    }

    private final ConcurrentHashMap<String, ZuulFilter> filters = new ConcurrentHashMap<String, ZuulFilter>();

    public ZuulFilter remove(String key) {
        return this.filters.remove(key);
    }

    public ZuulFilter get(String key) {
        return this.filters.get(key);
    }

    public void put(String key, ZuulFilter filter) {
        this.filters.putIfAbsent(key, filter);
    }

    public int size() {
        return this.filters.size();
    }

    public Collection<ZuulFilter> getAllFilters() {
        return this.filters.values();
    }
}
FilterLoader

filterLoader 負責動態載入filter。載入方法有通過className，File物件，Groovy語言原始碼。如果是Netflix這樣的大公司有一套管理系統，負責FilterLoader就很雞肋了。

public class FilterLoader {
    final static FilterLoader INSTANCE = new FilterLoader();

    private static final Logger LOG = LoggerFactory.getLogger(FilterLoader.class);

    private final ConcurrentHashMap<String, Long> filterClassLastModified = new ConcurrentHashMap<String, Long>();
    private final ConcurrentHashMap<String, String> filterClassCode = new ConcurrentHashMap<String, String>();
    private final ConcurrentHashMap<String, String> filterCheck = new ConcurrentHashMap<String, String>();
    private final ConcurrentHashMap<String, List<ZuulFilter>> hashFiltersByType = new ConcurrentHashMap<String, List<ZuulFilter>>();

    private FilterRegistry filterRegistry = FilterRegistry.instance();

    static DynamicCodeCompiler COMPILER;
    
    static FilterFactory FILTER_FACTORY = new DefaultFilterFactory();

    public void setCompiler(DynamicCodeCompiler compiler) {
        COMPILER = compiler;
    }

    public void setFilterRegistry(FilterRegistry r) {
        this.filterRegistry = r;
    }

    public void setFilterFactory(FilterFactory factory) {
        FILTER_FACTORY = factory;
    }
    
    public static FilterLoader getInstance() {
        return INSTANCE;
    }

    public ZuulFilter getFilter(String sCode, String sName) throws Exception {

        if (filterCheck.get(sName) == null) {
            filterCheck.putIfAbsent(sName, sName);
            if (!sCode.equals(filterClassCode.get(sName))) {
                LOG.info("reloading code " + sName);
                filterRegistry.remove(sName);
            }
        }
        ZuulFilter filter = filterRegistry.get(sName);
        if (filter == null) {
            Class clazz = COMPILER.compile(sCode, sName);
            if (!Modifier.isAbstract(clazz.getModifiers())) {
                filter = (ZuulFilter) FILTER_FACTORY.newInstance(clazz);
            }
        }
        return filter;

    }

    public int filterInstanceMapSize() {
        return filterRegistry.size();
    }


    public boolean putFilter(File file) throws Exception {
        String sName = file.getAbsolutePath() + file.getName();
        if (filterClassLastModified.get(sName) != null && (file.lastModified() != filterClassLastModified.get(sName))) {
            LOG.debug("reloading filter " + sName);
            filterRegistry.remove(sName);
        }
        ZuulFilter filter = filterRegistry.get(sName);
        if (filter == null) {
            Class clazz = COMPILER.compile(file);
            if (!Modifier.isAbstract(clazz.getModifiers())) {
                filter = (ZuulFilter) FILTER_FACTORY.newInstance(clazz);
                List<ZuulFilter> list = hashFiltersByType.get(filter.filterType());
                if (list != null) {
                    hashFiltersByType.remove(filter.filterType()); //rebuild this list
                }
                filterRegistry.put(file.getAbsolutePath() + file.getName(), filter);
                filterClassLastModified.put(sName, file.lastModified());
                return true;
            }
        }

        return false;
    }

    public List<ZuulFilter> getFiltersByType(String filterType) {

        List<ZuulFilter> list = hashFiltersByType.get(filterType);
        if (list != null) return list;

        list = new ArrayList<ZuulFilter>();

        Collection<ZuulFilter> filters = filterRegistry.getAllFilters();
        for (Iterator<ZuulFilter> iterator = filters.iterator(); iterator.hasNext(); ) {
            ZuulFilter filter = iterator.next();
            if (filter.filterType().equals(filterType)) {
                list.add(filter);
            }
        }
        Collections.sort(list); // sort by priority

        hashFiltersByType.putIfAbsent(filterType, list);
        return list;
    }
}
FilterProcessor

基本呼叫鏈postRoute,error,route,preRoute --> runFilters-->processZuulFilter【重點方法】 。獲得Filter的方式： runFilters-> FilterLoader.getInstance().getFiltersByType(sType)

public class FilterProcessor {

    static FilterProcessor INSTANCE = new FilterProcessor();
    protected static final Logger logger = LoggerFactory.getLogger(FilterProcessor.class);

    private FilterUsageNotifier usageNotifier;

    public void postRoute() throws ZuulException {
        try {
            runFilters("post");
        } catch (ZuulException e) {
            throw e;
        } catch (Throwable e) {
            throw new ZuulException(e, 500, "UNCAUGHT_EXCEPTION_IN_POST_FILTER_" + e.getClass().getName());
        }
    }


    public void error() {
        try {
            runFilters("error");
        } catch (Throwable e) {
            logger.error(e.getMessage(), e);
        }
    }


    public void route() throws ZuulException {
        try {
            runFilters("route");
        } catch (ZuulException e) {
            throw e;
        } catch (Throwable e) {
            throw new ZuulException(e, 500, "UNCAUGHT_EXCEPTION_IN_ROUTE_FILTER_" + e.getClass().getName());
        }
    }


    public void preRoute() throws ZuulException {
        try {
            runFilters("pre");
        } catch (ZuulException e) {
            throw e;
        } catch (Throwable e) {
            throw new ZuulException(e, 500, "UNCAUGHT_EXCEPTION_IN_PRE_FILTER_" + e.getClass().getName());
        }
    }

    public Object runFilters(String sType) throws Throwable {
        if (RequestContext.getCurrentContext().debugRouting()) {
            Debug.addRoutingDebug("Invoking {" + sType + "} type filters");
        }
        boolean bResult = false;
        List<ZuulFilter> list = FilterLoader.getInstance().getFiltersByType(sType);
        if (list != null) {
            for (int i = 0; i < list.size(); i++) {
                ZuulFilter zuulFilter = list.get(i);
                Object result = processZuulFilter(zuulFilter);
                if (result != null && result instanceof Boolean) {
                    bResult |= ((Boolean) result);
                }
            }
        }
        return bResult;
    }


    public Object processZuulFilter(ZuulFilter filter) throws ZuulException {

        RequestContext ctx = RequestContext.getCurrentContext();
        boolean bDebug = ctx.debugRouting();
        final String metricPrefix = "zuul.filter-";
        long execTime = 0;
        String filterName = "";
        try {
            long ltime = System.currentTimeMillis();
            filterName = filter.getClass().getSimpleName();
            
            RequestContext copy = null;
            Object o = null;
            Throwable t = null;

            if (bDebug) {
                Debug.addRoutingDebug("Filter " + filter.filterType() + " " + filter.filterOrder() + " " + filterName);
                copy = ctx.copy();
            }
            
            ZuulFilterResult result = filter.runFilter();
            ExecutionStatus s = result.getStatus();
            execTime = System.currentTimeMillis() - ltime;

            switch (s) {
                case FAILED:
                    t = result.getException();
                    ctx.addFilterExecutionSummary(filterName, ExecutionStatus.FAILED.name(), execTime);
                    break;
                case SUCCESS:
                    o = result.getResult();
                    ctx.addFilterExecutionSummary(filterName, ExecutionStatus.SUCCESS.name(), execTime);
                    if (bDebug) {
                        Debug.addRoutingDebug("Filter {" + filterName + " TYPE:" + filter.filterType() + " ORDER:" + filter.filterOrder() + "} Execution time = " + execTime + "ms");
                        Debug.compareContextState(filterName, copy);
                    }
                    break;
                default:
                    break;
            }
            
            if (t != null) throw t;

            usageNotifier.notify(filter, s);
            return o;

        } catch (Throwable e) {
            if (bDebug) {
                Debug.addRoutingDebug("Running Filter failed " + filterName + " type:" + filter.filterType() + " order:" + filter.filterOrder() + " " + e.getMessage());
            }
            usageNotifier.notify(filter, ExecutionStatus.FAILED);
            if (e instanceof ZuulException) {
                throw (ZuulException) e;
            } else {
                ZuulException ex = new ZuulException(e, "Filter threw Exception", 500, filter.filterType() + ":" + filterName);
                ctx.addFilterExecutionSummary(filterName, ExecutionStatus.FAILED.name(), execTime);
                throw ex;
            }
        }
    }
FilterUsageNotifier

每個filter執行完成或者異常，失敗。都會呼叫FilterUsageNotifier.notify的方法。這樣可以對執行結果進行監控。

    public static class BasicFilterUsageNotifier implements FilterUsageNotifier {
        private static final String METRIC_PREFIX = "zuul.filter-";

        @Override
        public void notify(ZuulFilter filter, ExecutionStatus status) {
            DynamicCounter.increment(METRIC_PREFIX + filter.getClass().getSimpleName(), "status", status.name(), "filtertype", filter.filterType());
        }
    }
ZuulRunner
  1. zuulRunner代理了FilterProcessor
  2. zuulRunner.init是整個體系最核心的一個方法了，負責把servletRequest放到RequestContext.getCurrentContext上下文中，在當前執行緒可以獲得HttpServletResponse，物件進行操作。同時可以傳遞其他引數。請自信看RibbonRoutingFilter。
public class ZuulRunner {

    private boolean bufferRequests;

    public ZuulRunner() {
        this.bufferRequests = true;
    }

    public ZuulRunner(boolean bufferRequests) {
        this.bufferRequests = bufferRequests;
    }

    public void init(HttpServletRequest servletRequest, HttpServletResponse servletResponse) {

        RequestContext ctx = RequestContext.getCurrentContext();
        if (bufferRequests) {
            ctx.setRequest(new HttpServletRequestWrapper(servletRequest));
        } else {
            ctx.setRequest(servletRequest);
        }

        ctx.setResponse(new HttpServletResponseWrapper(servletResponse));
    }

    public void postRoute() throws ZuulException {
        FilterProcessor.getInstance().postRoute();
    }

    public void route() throws ZuulException {
        FilterProcessor.getInstance().route();
    }

    public void preRoute() throws ZuulException {
        FilterProcessor.getInstance().preRoute();
    }

    public void error() {
        FilterProcessor.getInstance().error();
    }
}

spring-cloud-zuul

spring-cloud-zuul主要是兩個類ZuulServerAutoConfiguration與ZuulProxyAutoConfiguration。分別向spring容器注入很多filter與其他管理物件。

注入的Filter如下
  1. ServletDetectionFilter
  2. FormBodyWrapperFilter
  3. DebugFilter
  4. Servlet30WrapperFilter
  5. SendResponseFilter
  6. SendErrorFilter
  7. SendForwardFilter
  8. PreDecorationFilter
  9. RibbonRoutingFilter
  10. SimpleHostRoutingFilter
RouteLocator

routeLocator是zuul route管理體系。SimpleRouteLocator是最簡單的實現。如何大家需要維護的自己路由，向spring容器注入自己的實現就行了。

routeLocator是zuul route管理體系。SimpleRouteLocator是最簡單的實現。如何大家需要維護的自己路由，向spring容器注入自己的實現就行了。

routeLocator是zuul route管理體系。SimpleRouteLocator是最簡單的實現。如何大家需要維護的自己路由，向spring容器注入自己的實現就行了。

與Eureka整合

DiscoveryClientRouteLocator類負責與eureka進行整合。DiscoveryClientRouteLocator會從eureka伺服器獲取服務，併入住到SimpleRouteLocator

ZuulController

ZuulController負責向spring容器裡面注入ZuulServlet物件

ZuulFilterConfiguration

ZuulFilterConfiguration是整個spring-cloud-zuul核心環節，ZuulFilterInitializer負責把FilterLoader，FilterRegistry，CounterFactory（統計模組），TracerFactory（felter執行跟蹤模組），連結在一起。那麼最基礎的zuul體系元件完成

protected static class ZuulFilterConfiguration {

		@Autowired
		private Map<String, ZuulFilter> filters;

		@Bean
		public ZuulFilterInitializer zuulFilterInitializer(
				CounterFactory counterFactory, TracerFactory tracerFactory) {
			FilterLoader filterLoader = FilterLoader.getInstance();
			FilterRegistry filterRegistry = FilterRegistry.instance();
			return new ZuulFilterInitializer(this.filters, counterFactory, tracerFactory, filterLoader, filterRegistry);
		}

}

public class ZuulFilterInitializer {

	private static final Log log = LogFactory.getLog(ZuulFilterInitializer.class);

	private final Map<String, ZuulFilter> filters;
	private final CounterFactory counterFactory;
	private final TracerFactory tracerFactory;
	private final FilterLoader filterLoader;
	private final FilterRegistry filterRegistry;

	public ZuulFilterInitializer(Map<String, ZuulFilter> filters,CounterFactory counterFactory,TracerFactory tracerFactory, FilterLoader filterLoader,FilterRegistry filterRegistry) {
		this.filters = filters;
		this.counterFactory = counterFactory;
		this.tracerFactory = tracerFactory;
		this.filterLoader = filterLoader;
		this.filterRegistry = filterRegistry;
	}

	@PostConstruct
	public void contextInitialized() {
		log.info("Starting filter initializer");

		TracerFactory.initialize(tracerFactory);
		CounterFactory.initialize(counterFactory);

		for (Map.Entry<String, ZuulFilter> entry : this.filters.entrySet()) {
			filterRegistry.put(entry.getKey(), entry.getValue());
		}
	}

	@PreDestroy
	public void contextDestroyed() {
		log.info("Stopping filter initializer");
		for (Map.Entry<String, ZuulFilter> entry : this.filters.entrySet()) {
			filterRegistry.remove(entry.getKey());
		}
		clearLoaderCache();

		TracerFactory.initialize(null);
		CounterFactory.initialize(null);
	}

	private void clearLoaderCache() {
		Field field = ReflectionUtils.findField(FilterLoader.class, "hashFiltersByType");
		ReflectionUtils.makeAccessible(field);
		@SuppressWarnings("rawtypes")
		Map cache = (Map) ReflectionUtils.getField(field, filterLoader);
		cache.clear();
	}
ZuulServlet

zuulservlet 負責攔截所有請求，執行preRoute，route，postRoute，error行為。

    public void service(javax.servlet.ServletRequest servletRequest, javax.servlet.ServletResponse servletResponse) throws ServletException, IOException {
        try {
            init((HttpServletRequest) servletRequest, (HttpServletResponse) servletResponse);
            RequestContext context = RequestContext.getCurrentContext();
            context.setZuulEngineRan();

            try {
                preRoute();
            } catch (ZuulException e) {
                error(e);
                postRoute();
                return;
            }
            try {
                route();
            } catch (ZuulException e) {
                error(e);
                postRoute();
                return;
            }
            try {
                postRoute();
            } catch (ZuulException e) {
                error(e);
                return;
            }

        } catch (Throwable e) {
            error(new ZuulException(e, 500, "UNHANDLED_EXCEPTION_" + e.getClass().getName()));
        } finally {
            RequestContext.getCurrentContext().unset();

相關推薦

技術與架構之zuul（spring-cloud-zuul）原始碼解讀

zuul原始碼裡面一大堆test程式碼 zuul好多程式碼都是11年的 閘道器是什麼,為什麼需要閘道器 百度百科是這樣解釋的：閘道器(Gateway)又稱網間聯結器、協議轉換器。閘道器在網路層以上實現網路互連，是複雜的網路互連裝置，僅用於兩個高層協議不同的網路互連。仔細看下下面的圖。 閘道器負

負載均衡（Spring Cloud Ribbon）之快速入門

背景介紹： 目前主要流行的負載均衡分為兩種：一種是集中式負載均衡，在消費者和提供者中間使用獨立的代理方式進行負載，有硬體也有軟體，另外一種就是客戶端自己進行負載均衡，ribbon就是屬於客戶端負載均衡。 ribbon是一個基於http和tcp的客戶端負載均衡工具，基於Ne

java架構之路-（spring原始碼篇）由淺入深-spring實戰詳細使用

　　今天我更新了一篇jvm垃圾回收的演算法和垃圾回收器的內部邏輯，但是看的人不多啊......貌似大家還是比較喜歡看原始碼吧，畢竟實戰要比理論用的多。 　　這篇文章不會詳細的深入底層原始碼，只是基於註解和配置來說說我們的spring的使用，別小看基礎，保證有你沒用過的註解和配置，走起。我們先來建立一個mave

java架構之路-（mysql底層原理）Mysql事務隔離與MVCC

　　上幾篇部落格我們大致講了一下mysql的底層結構，什麼B+tree，什麼Hash需要回行啊，再就是講了mysql優化的explain，這次我們來說說mysql的鎖。 mysql鎖 　　鎖從效能上分為樂觀鎖(用版本對比來實現)和悲觀鎖，樂觀鎖的效能要比悲觀鎖高。 　　從對資料庫操作的型別分，分為讀鎖和寫

java架構之路-（spring原始碼篇）springIOC容器原始碼解析（上）

　　我們這次來叭叭一下Spring的原始碼，這次部落格主要來說說Spring原始碼，先粗略的擼一遍，下篇部落格選幾個重點去說，由於過於複雜，我也是看了一點點，我們先來過一遍原始碼，然後上流程圖，最後我們再回頭總結一下，我們來循序漸進的叭叭一下。 我們來回顧一下上次Spring部落格的內容，每次都有用到Anno

java架構之路（多執行緒）原子操作，Atomic與Unsafe魔術類

　　這次不講原理了,主要是一些應用方面的知識,和上幾次的JUC併發程式設計的知識點更容易理解. 知識回顧： 　　上次主要說了Semaphore訊號量的使用，就是一個票據的使用，我們舉例了看3D電影拿3D眼鏡的例子，還說了內部的搶3D眼鏡，和後續排隊的原始碼解析，還有CountDownLatch的使用，我們是用

java架構之路-（微服務專題）初步認識微服務與nacos初步搭建

歷史演變： 　　以前我們都是一個war包，包含了很多很多的程式碼，反正我開始工作的時候做的就是這樣的專案，一個金融系統，程式碼具體多少行記不清楚了，內部功能超多，但是實際能用到的不多，程式碼冗餘超大，每次部署大概要10分鐘以上。 　　這個war包包含了我們的所有，jsp、js、css、java程式碼。程式碼很

SpringCloud進擊 | 一深入：高可用的分散式配置中心（Spring Cloud Config）【Finchley版本】

1.前言 上一節：SpringCloud進擊 | 七淺出：服務閘道器 - 過濾器（Zuul Filter）【Finchley版本】 通常情況下，Config Server 與 Eureka 服務註冊中心一樣，也需要將其架構成高可用的叢集。所以，我們來改進一下，以一種更為簡單的方式 -

springcloud 分散式配置中心（spring cloud config）

官方中文文件：https://springcloud.cc/spring-cloud-config.html 條件：每次修改配置，都需要去找相應的配置檔案，造成了不必要的開銷，現在我們可以在遠端Git上修改，然後修改相應的服務 1.現在碼雲上建立一個私有專案config-repo

SpringCloud——分散式配置中心（Spring Cloud Config）

一、Spring Cloud Config簡介           Spring Cloud Config為分散式系統中的外部配置提供伺服器和客戶端支援。使用Config Server，您可以在所有環境中管理應用程式的外部屬性。客戶端和伺服器上的概念對映與Spring En

定時任務（Spring Cloud Task）

引入依賴 <dependency> <groupId>org.springframework.boot</groupId> <artifactI

Spring Cloud（十）整合異構系統Nodejs（Spring Cloud Sidecar）

一、 Sidecar簡介 什麼是Sidecar模式？ Sidecar模式是一種將應用功能從應用本身剝離出來作為單獨程序的方式。該模式允許我們嚮應用無侵入新增多種功能，避免了為滿足第三方元件需求而嚮應用新增額外的配置程式碼。 就像邊車加裝在摩托車上一樣，在軟體架構

Spring Cloud入門：API閘道器服務（Spring Cloud Gateway）

文章例項使用的Spring Cloud版本為Finchley.SR1，Spring Boot版本為2.0.4。 1 Spring Cloud Gateway 在微服務架構中，閘道器作為服務的一個統一入口，所有的外部客戶端訪問都需要經過它來排程和過濾，可以實現的功能包括動

Spring Cloud入門：分散式配置中心（Spring Cloud Config）

文章例項使用的Spring Cloud版本為Finchley.SR1，Spring Boot版本為2.0.4。 1 Spring Cloud Config Spring Cloud Config是Spring Cloud團隊建立的一個全新專案，用來為分散式系統中的基礎設

Spring Cloud入門：服務消費（Spring Cloud Feign）

文章例項使用的Spring Cloud版本為Finchley.SR1，Spring Boot版本為2.0.4。 1 Spring Cloud Feign Spring Cloud Feign是一套基於Netflix Feign實現的宣告式服務呼叫客戶端。使用Spring

Spring Cloud入門：服務消費（Spring Cloud Ribbon）

文章例項使用的Spring Cloud版本為Finchley.SR1，Spring Boot版本為2.0.4。 1 Spring Cloud Ribbon Spring Cloud Ribbon是一個基於HTTP和TCP的客戶端負載均衡工具，它基於Netflix Rib

SpringCloud：配置中心（spring cloud config）

spring cloud config簡介 為什麼要使用配置中心 簡單來說，就是為了方便所有服務的配置統一管理，實時更新。 在分散式的微服務架構中，服務數量會越來越多，而每個服務例項都會有一個或幾個配置檔案(yml,properties,json…)。而這些檔案，分佈在系統的各個

Spring Boot + Spring Cloud 構建微服務系統（九）：配置中心（Spring Cloud Config）

技術背景 如今微服務架構盛行，在分散式系統中，專案日益龐大，子專案日益增多，每個專案都散落著各種配置檔案，且隨著服務的增加而不斷增多。此時，往往某一個基礎服務資訊變更，都會導致一系列服務的更新和重啟，運維也是苦不堪言，而且還很容易出錯。於是，配置中心便由此應運而生了。 目前市面上開源的配置中心有很多，像Spr

Spring Boot + Spring Cloud 構建微服務系統（十）：配置中心（Spring Cloud Bus）

技術背景 我們在上一篇講到，Spring Boot程式只在啟動的時候載入配置檔案資訊，這樣在GIT倉庫配置修改之後，雖然配置中心伺服器能夠讀取最新的提交資訊，但是配置中心客戶端卻不會重新讀取，以至於不能及時的讀取更新後的配置資訊。這個時候就需要一種通知重新整理機制來支援了。 Refresh機制 refresh

spring cloud ：五、分散式配置中心（spring cloud config）

在分散式系統中，每一個功能模組都能拆分成一個獨立的服務，一次請求的完成，可能會呼叫很多個服務協調來完成，為了方便服務配置檔案統一管理，更易於部署、維護，所以就需要分散式配置中心元件了，在spring cloud中，有分散式配置中心元件spring cloud config，它