面向服務的體系架構 SOA（二） --- 服務的路由和負載均衡

2. 服務的路由和負載均衡

1.2.1 服務化的演變

SOA設計思想：分布式應用架構體系對於業務邏輯復用的需求十分強烈，上層業務都想借用已有的底層服務來快速搭建更多、更豐富的應用，降低新業務開展的人力和時間成本，快速滿足瞬息萬變的市場需求。公共的業務被拆分出來行程可共用的服務，最大程度的保障了代碼和邏輯的復用，避免重復建設，這種設計也稱為SOA 。

服務的路由：SOA架構中，服務消費者通過服務名稱，在眾多的服務器中找到要調用的服務的地址列表，稱為服務的路由。

負載均衡：對於負載較高的服務來說，往往對應着由多台服務器組成的集群，在請求到來時，為了將請求均衡的分配到后端服務器，負載均衡程序將從服務器對應的地址列表中，通過相應的負載均衡算法和規則，選取一台服務器進行訪問，這個過程稱為服務的負載均衡。

服務配置中心：當服務器數量龐大時，人工來管理和維護服務及地址的配置信息變得困難，依賴單一的硬件負載均衡設備或者使用LVS、Nginx等軟件方案進行路由和負載均衡調度也容易引發單點問題，一旦服務路由或者負載均衡服務器宕機，依賴它的所有服務均將失效。此時，需要一個能夠動態注冊和獲取服務信息的地方來統一管理服務名稱和其對應的服務器列表信息，稱為服務配置中心。

服務配置中心的意義：服務提供者在啟動時，會將其提供的服務名稱、服務器地址注冊到服務配置中心，服務消費者通過服務配置中心來獲得需要調用的服務的機器列表，通過相應的負載均衡算法，選取其中一台服務器進行調用。當服務器宕機或者下線時，相應的機器需要動態的從服務配置中心移除，並通知相應的服務消費者，防止其調用到已經失效的服務而發生錯誤。在這個過程中，服務消費者只有在第一次調用服務時需要查詢服務配置中心，然后將查詢到的信息緩存到本地，后面的調用直接使用緩存的服務地址列表信息即可，直到服務的地址列表有變更（機器上線或者下線）。這種無中心化的結構解決了單點故障問題，並且大大減輕了服務配置中心的壓力。

1.2.2 負載均衡算法

常見的負載均衡算法包括：輪詢法、隨機法、源地址哈希法、加權輪詢法、加權隨機法、最小連接法等，根據不同場景需要選取不同的算法。

我們暫時將服務器地址及其權重置於map中：

    serverWeightMap.put("192.168.1.10", 1);
    serverWeightMap.put("192.168.1.11", 1);
    serverWeightMap.put("192.168.1.12", 3);
    serverWeightMap.put("192.168.1.13", 1);
    serverWeightMap.put("192.168.1.14", 5);
    serverWeightMap.put("192.168.1.15", 2);
    serverWeightMap.put("192.168.1.16", 1);

1）輪詢法：

將請求按順序輪流的分配到后端服務器上，它均衡的對待后端每一台服務器，而不關心服務器實際的連接數和當前的系統負載。

　　public String getServerIP() {
        //新建map，避免出現服務器上線、下線、宕機引發的並發問題、數組越界等
        Map<String, Integer> serverMap = new HashMap<String, Integer>();
        serverMap.putAll(serverWeightMap);
        //取得服務器列表list
        List<String> serverList = new ArrayList<String>();
        serverList.addAll(serverMap.keySet());
        
        String server = null;
        Integer pos = 0;//當前服務器位置
        synchronized (pos) {
            if (pos >= serverList.size()) {
                pos = 0;
            }
            server = serverList.get(pos);
            pos++;
        }
        return server;
    }

將服務器地址先復制到本地，可以避免被多個線程修改，但這樣也會引發新的問題，當出現新增或者下線服務器時，負載均衡算法將無法獲知，因此，在服務消費者的實現端需要考慮該問題並進行相應的容錯處理，比如重新發起一次調用。輪詢的位置pos添加synchronized鎖可防止pos變量被並發修改，導致數組越界問題，但也導致輪詢代碼的並發吞吐量發生明顯的下降。

2）隨機法：

    public String getServerIP() {
        //新建map，避免出現服務器上線、下線引發的並發問題
        Map<String, Integer> serverMap = new HashMap<String, Integer>();
        serverMap.putAll(serverWeightMap);
        //取得服務器列表list
        List<String> serverList = new ArrayList<String>();
        serverList.addAll(serverMap.keySet());
        
        java.util.Random random = new java.util.Random();
        int pos = random.nextInt(serverList.size());
        return serverList.get(pos);
    }

由概率統計理論可知，隨着調用量的增大，隨機法的效果會越來越接近輪詢的效果。因此，你還會考慮一定要使用需要付出一定性能代價的輪詢算法嗎？

3）源地址哈希（Hash）法

源地址哈希的思想是獲取客戶端訪問的IP地址值，通過哈希函數計算得到一個數值，用該數值對服務器列表的大小進行取模運算，得到的結果便是要訪問的服務器的需要。這樣相同IP地址的客戶端，當后端服務器列表不變時，它都會被映射到同一個后端服務器。

    public String getServerIP(String targetIP) {
        //新建map，避免出現服務器上線、下線引發的並發問題
        Map<String, Integer> serverMap = new HashMap<String, Integer>();
        serverMap.putAll(serverWeightMap);
        //取得服務器列表list
        List<String> serverList = new ArrayList<String>();
        serverList.addAll(serverMap.keySet());
        
        int hashcode = targetIP.hashCode();
        int pos = hashcode % serverList.size();
        return serverList.get(pos);
    }

源地址哈希法可以在服務消費者與服務提供者之間建立有狀態的session會話。

4）加權輪詢法：

    public String getServerIP() {
        //新建map，避免出現服務器上線、下線引發的並發問題
        Map<String, Integer> serverMap = new HashMap<String, Integer>();
        serverMap.putAll(serverWeightMap);
        Set<String> keySet = serverMap.keySet();
        Iterator<String> iterator = keySet.iterator();
        //新建空的服務器列表list
        List<String> serverList = new ArrayList<String>();
        while(iterator.hasNext()) {
            String server = iterator.next();
            Integer weight = serverMap.get(server);
            //若該服務器的權重為4，則在服務器列表中添加四個該服務器
            for (int i = 0; i < weight; i++) {
                serverList.add(server);
            }
        }
        Integer pos = 0;
        String server = null;
        synchronized (pos) {
            if (pos >= serverList.size()) {
                pos = 0;
            }
            server = serverList.get(pos);
            pos++;
        }
        return server;
    }

5）加權隨機法：

    public String getServerIP() {
        //新建map，避免出現服務器上線、下線引發的並發問題
        Map<String, Integer> serverMap = new HashMap<String, Integer>();
        serverMap.putAll(serverWeightMap);
        Set<String> keySet = serverMap.keySet();
        Iterator<String> iterator = keySet.iterator();
        //新建空的服務器列表list
        List<String> serverList = new ArrayList<String>();
        while(iterator.hasNext()) {
            String server = iterator.next();
            Integer weight = serverMap.get(server);
            //若該服務器的權重為4，則在服務器列表中添加四個該服務器
            for (int i = 0; i < weight; i++) {
                serverList.add(server);
            }
        }
        
        Random random = new Random();
        int pos = random.nextInt(serverList.size());
        return serverList.get(pos);
    }

6）最小連接法：

以上算法我們都是為了平均給后端服務器分配工作量，最大程度的提高服務器的利用率，但是實際情況並非一定如此，我們可以從算法實施的角度來看，以后端服務器的視角來觀察系統的負載，而非請求發起方來觀察。因此，我們需要有其他的算法來實現可供選擇，最小連接法變屬於此類算法。

最小連接法比較靈活和智能，由於后端服務器的配置不盡相同，對於請求的處理快慢不同，它正是根據后端服務器當前的連接情況動態選取當前積壓連接數最少的一台服務器來處理當前請求，盡可能的提高后端服務器的利用效率，將負載合理的分流到每一台機器。