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

2. 服務的路由和負載均衡 1.2.1 服務化的演變 SOA設計思想：分散式應用架構體系對於業務邏輯復用的需求十分強烈，上層業務都想借用已有的底層服務來快速搭建更多、更豐富的應用，降低新業務開展的人力和時間成本，快速滿足瞬息萬變的市場需求。公共的業務被拆分出來行程可共用的服務，最大程度的保障了代碼和 ...

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

1.2.1 服務化的演變

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

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

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

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

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

1.2.2 負載均衡演算法

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

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

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

1）輪詢法：

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

 1 　　public String getServerIP() {
 2         //新建map，避免出現伺服器上線、下線、宕機引發的併發問題、數組越界等
 3         Map<String, Integer> serverMap = new HashMap<String, Integer>();
 4         serverMap.putAll(serverWeightMap);
 5         //取得伺服器列表list
 6         List<String> serverList = new ArrayList<String>();
 7         serverList.addAll(serverMap.keySet());
 8         
 9         String server = null;
10         Integer pos = 0;//當前伺服器位置
11         synchronized (pos) {
12             if (pos >= serverList.size()) {
13                 pos = 0;
14             }
15             server = serverList.get(pos);
16             pos++;
17         }
18         return server;
19     }

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

2）隨機法：

 1     public String getServerIP() {
 2         //新建map，避免出現伺服器上線、下線引發的併發問題
 3         Map<String, Integer> serverMap = new HashMap<String, Integer>();
 4         serverMap.putAll(serverWeightMap);
 5         //取得伺服器列表list
 6         List<String> serverList = new ArrayList<String>();
 7         serverList.addAll(serverMap.keySet());
 8         
 9         java.util.Random random = new java.util.Random();
10         int pos = random.nextInt(serverList.size());
11         return serverList.get(pos);
12     }

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

3）源地址哈希（Hash）法

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

 1     public String getServerIP(String targetIP) {
 2         //新建map，避免出現伺服器上線、下線引發的併發問題
 3         Map<String, Integer> serverMap = new HashMap<String, Integer>();
 4         serverMap.putAll(serverWeightMap);
 5         //取得伺服器列表list
 6         List<String> serverList = new ArrayList<String>();
 7         serverList.addAll(serverMap.keySet());
 8         
 9         int hashcode = targetIP.hashCode();
10         int pos = hashcode % serverList.size();
11         return serverList.get(pos);
12     }

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

4）加權輪詢法：

 1     public String getServerIP() {
 2         //新建map，避免出現伺服器上線、下線引發的併發問題
 3         Map<String, Integer> serverMap = new HashMap<String, Integer>();
 4         serverMap.putAll(serverWeightMap);
 5         Set<String> keySet = serverMap.keySet();
 6         Iterator<String> iterator = keySet.iterator();
 7         //新建空的伺服器列表list
 8         List<String> serverList = new ArrayList<String>();
 9         while(iterator.hasNext()) {
10             String server = iterator.next();
11             Integer weight = serverMap.get(server);
12             //若該伺服器的權重為4，則在伺服器列表中添加四個該伺服器
13             for (int i = 0; i < weight; i++) {
14                 serverList.add(server);
15             }
16         }
17         Integer pos = 0;
18         String server = null;
19         synchronized (pos) {
20             if (pos >= serverList.size()) {
21                 pos = 0;
22             }
23             server = serverList.get(pos);
24             pos++;
25         }
26         return server;
27     }

5）加權隨機法：

 1     public String getServerIP() {
 2         //新建map，避免出現伺服器上線、下線引發的併發問題
 3         Map<String, Integer> serverMap = new HashMap<String, Integer>();
 4         serverMap.putAll(serverWeightMap);
 5         Set<String> keySet = serverMap.keySet();
 6         Iterator<String> iterator = keySet.iterator();
 7         //新建空的伺服器列表list
 8         List<String> serverList = new ArrayList<String>();
 9         while(iterator.hasNext()) {
10             String server = iterator.next();
11             Integer weight = serverMap.get(server);
12             //若該伺服器的權重為4，則在伺服器列表中添加四個該伺服器
13             for (int i = 0; i < weight; i++) {
14                 serverList.add(server);
15             }
16         }
17         
18         Random random = new Random();
19         int pos = random.nextInt(serverList.size());
20         return serverList.get(pos);
21     }

6）最小連接法：

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

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