Spark Streaming支持實時數據流的可擴展（scalable）、高吞吐（high-throughput）、容錯（fault-tolerant）的流處理（stream processing）。

 

                                                    架構圖

 

特性如下：

 

• 可線性伸縮至超過數百個節點；

• 實現亞秒級延遲處理；

• 可與Spark批處理和交互式處理無縫集成；

• 提供簡單的API實現複雜算法；

• 更多的流方式支持，包括Kafka、Flume、Kinesis、Twitter、ZeroMQ等。

 

原理

 

Spark在接收到實時輸入數據流后，將數據劃分成批次（divides the data into batches），然後轉給Spark Engine處理，按批次生成最後的結果流（generate the final stream of results in batches）。 

 

 

API

 

DStream

 

DStream（Discretized Stream，離散流）是Spark Stream提供的高級抽象連續數據流。

 

• 組成：一個DStream可看作一個RDDs序列。

• 核心思想：將計算作為一系列較小時間間隔的、狀態無關的、確定批次的任務，每個時間間隔內接收的輸入數據被可靠存儲在集群中，作為一個輸入數據集。

 

 

• 特性：一個高層次的函數式編程API、強一致性以及高校的故障恢復。

• 應用程序模板：

• 模板1

• 模板2

 

WordCount示例

 

 

Input DStream

 

Input DStream是一種從流式數據源獲取原始數據流的DStream，分為基本輸入源（文件系統、Socket、Akka Actor、自定義數據源）和高級輸入源（Kafka、Flume等）。

 

• Receiver：

• 每個Input DStream（文件流除外）都會對應一個單一的Receiver對象，負責從數據源接收數據並存入Spark內存進行處理。應用程序中可創建多個Input DStream并行接收多個數據流。

• 每個Receiver是一個長期運行在Worker或者Executor上的Task，所以會佔用該應用程序的一個核（core）。如果分配給Spark Streaming應用程序的核數小於或等於Input DStream個數（即Receiver個數），則只能接收數據，卻沒有能力全部處理（文件流除外，因為無需Receiver）。

• Spark Streaming已封裝各種數據源，需要時參考官方文檔。

 

Transformation Operation

 

• 常用Transformation

 

* map(func) ：對源DStream的每個元素，採用func函數進行轉換，得到一個新的DStream；

* flatMap(func)：與map相似，但是每個輸入項可用被映射為0個或者多個輸出項；

* filter(func)：返回一個新的DStream，僅包含源DStream中滿足函數func的項；

* repartition(numPartitions)：通過創建更多或者更少的分區改變DStream的并行程度；

* union(otherStream)：返回一個新的DStream，包含源DStream和其他DStream的元素；

* count()：統計源DStream中每個RDD的元素數量；

* reduce(func)：利用函數func聚集源DStream中每個RDD的元素，返回一個包含單元素RDDs的新DStream；

* countByValue()：應用於元素類型為K的DStream上，返回一個（K，V）鍵值對類型的新DStream，每個鍵的值是在原DStream的每個RDD中的出現次數；

* reduceByKey(func, [numTasks])：當在一個由(K,V)鍵值對組成的DStream上執行該操作時，返回一個新的由(K,V)鍵值對組成的DStream，每一個key的值均由給定的recuce函數（func）聚集起來；

* join(otherStream, [numTasks])：當應用於兩個DStream（一個包含（K,V）鍵值對,一個包含(K,W)鍵值對），返回一個包含(K, (V, W))鍵值對的新DStream；

* cogroup(otherStream, [numTasks])：當應用於兩個DStream（一個包含（K,V）鍵值對,一個包含(K,W)鍵值對），返回一個包含(K, Seq[V], Seq[W])的元組；

* transform(func)：通過對源DStream的每個RDD應用RDD-to-RDD函數，創建一個新的DStream。支持在新的DStream中做任何RDD操作。

 

• updateStateByKey(func)

• updateStateByKey可對DStream中的數據按key做reduce，然後對各批次數據累加

• WordCount的updateStateByKey版本

 

• transform(func)

• 通過對原DStream的每個RDD應用轉換函數，創建一個新的DStream。

• 官方文檔代碼舉例

 

• Window operations

• 窗口操作：基於window對數據transformation（個人認為與Storm的tick相似，但功能更強大）。

• 參數：窗口長度（window length）和滑動時間間隔（slide interval）必須是源DStream批次間隔的倍數。

• 舉例說明：窗口長度為3，滑動時間間隔為2；上一行是原始DStream，下一行是窗口化的DStream。

• 常見window operation

有狀態轉換包括基於滑動窗口的轉換和追蹤狀態變化(updateStateByKey)的轉換。

基於滑動窗口的轉換

* window(windowLength, slideInterval) 基於源DStream產生的窗口化的批數據，計算得到一個新的DStream；

* countByWindow(windowLength, slideInterval) 返迴流中元素的一個滑動窗口數；

* reduceByWindow(func, windowLength, slideInterval) 返回一個單元素流。利用函數func聚集滑動時間間隔的流的元素創建這個單元素流。函數func必須滿足結合律，從而可以支持并行計算；

* reduceByKeyAndWindow(func, windowLength, slideInterval, [numTasks]) 應用到一個(K,V)鍵值對組成的DStream上時，會返回一個由(K,V)鍵值對組成的新的DStream。每一個key的值均由給定的reduce函數(func函數)進行聚合計算。注意：在默認情況下，這個算子利用了Spark默認的併發任務數去分組。可以通過numTasks參數的設置來指定不同的任務數；

* reduceByKeyAndWindow(func, invFunc, windowLength, slideInterval, [numTasks]) 更加高效的reduceByKeyAndWindow，每個窗口的reduce值，是基於先前窗口的reduce值進行增量計算得到的；它會對進入滑動窗口的新數據進行reduce操作，並對離開窗口的老數據進行“逆向reduce”操作。但是，只能用於“可逆reduce函數”，即那些reduce函數都有一個對應的“逆向reduce函數”（以InvFunc參數傳入）；

* countByValueAndWindow(windowLength, slideInterval, [numTasks]) 當應用到一個(K,V)鍵值對組成的DStream上，返回一個由(K,V)鍵值對組成的新的DStream。每個key的值都是它們在滑動窗口中出現的頻率。

• 官方文檔代碼舉例 

 

• join(otherStream, [numTasks])

• 連接數據流

• 官方文檔代碼舉例1

• 官方文檔代碼舉例2

 

Output Operation

 

 

緩存與持久化

 

• 通過persist()將DStream中每個RDD存儲在內存。

• Window operations會自動持久化在內存，無需显示調用persist()。

• 通過網絡接收的數據流（如Kafka、Flume、Socket、ZeroMQ、RocketMQ等）執行persist()時，默認在兩個節點上持久化序列化后的數據，實現容錯。

 

Checkpoint

 

• 用途：Spark基於容錯存儲系統（如HDFS、S3）進行故障恢復。

• 分類：

• 元數據檢查點：保存流式計算信息用於Driver運行節點的故障恢復，包括創建應用程序的配置、應用程序定義的DStream operations、已入隊但未完成的批次。

• 數據檢查點：保存生成的RDD。由於stateful transformation需要合併多個批次的數據，即生成的RDD依賴於前幾個批次RDD的數據（dependency chain），為縮短dependency chain從而減少故障恢復時間，需將中間RDD定期保存至可靠存儲（如HDFS）。

• 使用時機：

• Stateful transformation：updateStateByKey()以及window operations。

• 需要Driver故障恢復的應用程序。

• 使用方法

• Stateful transformation

streamingContext.checkpoint(checkpointDirectory)

 

• 需要Driver故障恢復的應用程序（以WordCount舉例）：如果checkpoint目錄存在，則根據checkpoint數據創建新StreamingContext；否則（如首次運行）新建StreamingContext。

 

• checkpoint時間間隔

• 方法：

dstream.checkpoint(checkpointInterval)

 

• 原則：一般設置為滑動時間間隔的5-10倍。

• 分析：checkpoint會增加存儲開銷、增加批次處理時間。當批次間隔較小（如1秒）時，checkpoint可能會減小operation吞吐量；反之，checkpoint時間間隔較大會導致lineage和task數量增長。

 

性能調優

 

降低批次處理時間

 

• 數據接收并行度

• 增加DStream：接收網絡數據（如Kafka、Flume、Socket等）時會對數據反序列化再存儲在Spark，由於一個DStream只有Receiver對象，如果成為瓶頸可考慮增加DStream。

• 設置“spark.streaming.blockInterval”參數：接收的數據被存儲在Spark內存前，會被合併成block，而block數量決定了Task數量；舉例，當批次時間間隔為2秒且block時間間隔為200毫秒時，Task數量約為10；如果Task數量過低，則浪費了CPU資源；推薦的最小block時間間隔為50毫秒。

• 顯式對Input DStream重新分區：在進行更深層次處理前，先對輸入數據重新分區。

inputStream.repartition(<number of partitions>)

 

• 數據處理并行度：reduceByKey、reduceByKeyAndWindow等operation可通過設置“spark.default.parallelism”參數或顯式設置并行度方法參數控制。

• 數據序列化：可配置更高效的Kryo序列化。

 

設置合理批次時間間隔

 

• 原則：處理數據的速度應大於或等於數據輸入的速度，即批次處理時間大於或等於批次時間間隔。

• 方法：

• 先設置批次時間間隔為5-10秒以降低數據輸入速度；

• 再通過查看log4j日誌中的“Total delay”，逐步調整批次時間間隔，保證“Total delay”小於批次時間間隔。

 

內存調優

 

• 持久化級別：開啟壓縮，設置參數“spark.rdd.compress”。

• GC策略：在Driver和Executor上開啟CMS。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※南投搬家公司費用需注意的眉眉角角，別等搬了再說!

※新北清潔公司,居家、辦公、裝潢細清專業服務

※教你寫出一流的銷售文案?

前一陣字節跳動程序員，年僅 28 歲的郭宇財務自由，宣布退休的消息在網上火了一把，這個事情大家應該都知道了，細節就不多說了。

我剛看了這個新聞之後，起初內心出現的幾個關鍵詞是：卧槽、牛、羡慕……在意識到瞎感慨、羡慕沒啥用之後，我心裏不禁有個疑問：他的錢是怎麼來的？

我找在字節上班的朋友打聽了一下，據說郭同學近幾年投資賺了錢。當然還有網上大部分傳的，郭同學的發家致富是因為有字節跳動的期權，期權的價值隨着字節的估值翻上了天。

說到期權，估計很多人對期權不太清楚，除了關注熱點，我們還得學點知識對不對。今天我就和大家聊聊期權，省的將來大家遇到類似機會了，你一臉懵逼，甚至掉坑裡。

同時，因為我不是專業的，只是接觸過，所以講的不對、不嚴謹的，大家多擔待。

講期權之前，我們先接着上面說完郭同學的期權。

郭同學 2014 年加入字節，當時字節估值 5 億美元，現在字節估值 1000 億美元以上，估值妥妥的漲了 200 倍啊。如果當時有 10 萬期權，現在值 2000 萬；如果有 100 萬期權，現在值 2 億。就算考慮上後幾輪字節融資帶來的稀釋，打個折扣，那也是一筆不小的財富啊。

那麼郭同學有多少期權呢？說實話我也不知道，引用幾年前他和同學的對話，大家自己猜測吧。

郭同學的事說完了，我們繼續說期權。

1. 什麼是期權？

先舉個例子：

比如公司承諾你說，4 年之後，可以按每股 10 塊錢的價格，購買公司 1 萬份股票。期權的“期”就是指 4 年時間；期權的“權”就是 10 塊錢購買 1 萬份股票的權利。

等 4 年之後，如果公司的股票價格漲到了 100 塊，你依然可以用 10 塊錢的價格購買 1 萬份股票。花 10 萬買的股票就值 100 萬了，轉手賣出去之後，你能賺 90 萬。恭喜你！

另外一種可能是，如果 4 年後公司股票價格掉到 8 塊錢，這時候你肯定就不會按 10 塊錢價格購買股票了，不行使這個權利你也不會虧錢。

期權在國內互聯網公司不算少見，這當初是從硅谷那些互聯網公司學來的。

公司為了留住你，同時也為了長期激勵你，期權通常不會一下都給你，按上面的例子來說，4 年時間，可能每滿一年給你 1/4 數量的期權，或者是按月給。這也是為什麼有人把期權稱為“金手銬”。

2. 離職了期權怎麼辦？

上面的例子繼續展開說，如果乾滿了兩年，還沒幹滿四年，離職了期權怎麼辦？

這種情況，需要看之前你和公司怎麼約定的。通常有 3 種方式：

1. 干滿 2 年，給了 50%，那麼就可以對這 50% 的期權行權，然後帶走，等着公司上市后變成股票。
2. 公司回購你這 50% 的期權。
3. 被公司收回，什麼都沒有。

說一個我自己的例子，我在 2008 年打工的時候，公司給過我期權，數量不多，具體的價格、時間已經完全記不住了，後來離職的時候，期權都被公司收回了。當時對期權完全不懂，想着收回就收回唄。後來那家公司發展的不是很好，即使我堅守到現在，那些期權啥也兌現不了。否則，我現在腸子都要悔青了。

3. 有期權是不是肯定拿低工資？

這個不一定。比如小米早期，就有高工資低期權、低工資高期權兩種方案供員工選擇。

如果你覺得老闆靠譜、公司有希望，同時少拿點工資也不影響自己的生活，當然可以選擇低工資高期權。博一把，一旦成了，那麼期權帶來的財富肯定遠超過工資。

當然選擇高工資低期權，也能理解，畢竟生活不易，很多人都要養家糊口。而且創業公司的成功率非常低，期權最後能兌現都是小概率事件。萬一期權不能兌現，除了損失了工資，時間成本和機會成本也不小。

但是大家要小心，有的公司會用期權給你畫個大大的餅，刻意把你的工資壓到非常低。如果老闆真有誠意，起碼會給你開一個可接受的工資。

期權是為了留住和激勵優秀員工的，工資太低，優秀員工的忠誠度、穩定性怎麼保證？

4. 白紙黑字

如果你遇到的老闆是天天把分期權掛在嘴上，但是遲遲不和你簽協議，那你要小心了。無論怎樣，任何口頭承諾都沒有任何意義。

一定要白紙黑字落在協議上，特別是行權時間、價格、數量、期限、公司回購價格等等要寫到合同協議里，省的將來產生糾紛。

當然，最省心的還是找一個靠譜的公司，比如：

1. 公司的創始人信用好，如果他之前兌現過期權，那就更好了。
2. 是著名投資機構投資的公司。
3. 過往的融資都很順利，而且每一輪融資公司估值都漲的很快。
4. 能吸引很多優秀的人才加入，也能側面說明這家公司比較健康。大家都眼瞎的概率還是很小的。

寫完以上幾點，我不禁想到了曾經的樂視，好像能滿足以上好幾點……

5. 期權的其他知識

進入公司差一年，為什麼期權相差很多？
拿字節跳動來說，入職時間差一年，可能期權差一個數量級。發展越迅猛的公司，這個差距越大，早期公司估值低，越早加入越有優勢。

期權怎麼變現？
通常除了公司回購，只能等上市了。

員工是否可以賣掉期權？
一般來說，員工是不能出售期權的。如果員工可以出售期權，只能賣給你的公司。

6. 乾股

再說一下乾股。

有些技術大牛在加入創業公司的時候，創始人可能會對技術大牛說：你出技術，不用出錢了，我白給你 20% 的乾股（或叫技術股）。

乾股聽起來好像挺好，大家一起干，不用出錢，還可以分紅。

但是通常乾股是虛股，只有分紅的權利，沒有參与經營、決策的權利，往往也不能轉讓。

乾股是不規範的叫法，由於技術合伙人沒有實際出資，也沒經過工商登記，有可能忙活半天，最後你的名字都不會出現在股東名單里。如果之前也沒簽過協議，這麼不清不楚的，將來會不會被踢出局，都不好說。

最穩妥的辦法還是去工商局登記變更，把乾股變成法律上認可的股權。

最後

以上就是這篇文章的主要內容，估計很多讀者會覺得，期權、股票這些離自己太遠，和自己關係不大。

千萬別這麼想！

第一、現在互聯網行業給股票、期權的公司不算少見，提前儲備點知識，萬一以後談 offer 的時候出現這些字眼，你也不至於啥也不懂。

第二、覺得自己現在還很菜，公司的股票、期權都是給核心員工的，輪不到自己。現在菜又怎樣，誰不是由菜變強的，現在沒有股票、期權，不代表以後也拿不到。

第三、在工資不降低或者可接受的範圍內，我建議大家拿股票、期權，萬一哪天自己就莫名其妙的發財了呢。

第三點大家一定要謹慎，再次提醒一下你們，別為了股票、期權就接受一個特別低的工資，這塊我教訓深刻。

就寫這麼多吧，希望這篇掃盲文章能讓你們有收穫。起碼我旁邊的碼農二毛又有收穫了：

二毛說：四哥你這麼一說，我明白了，我現在就算能跳槽進字節，就算給我期權，現在太晚了，字節估值都這麼高了，別說暴富，估計連湯都喝不上了。我應該怎麼辦呢？

我說：打開你的炒股軟件……

二毛說：我明白了，四哥你是讓我買字節的股票，拿着股票也可以跟着字節市值上漲賺錢。

我說：呸，字節還沒上市，你買毛線。我的意思是，如果幾年前你能拿出來選股票的勁頭來分析、選擇出一家潛力公司，早跳槽過去堅持到現在，估計你也發財了。

感謝閱讀，如果覺得有用，希望你可以分享給你的朋友、同事，或者點個在看支持一下。

—END—

我準備了一些純手打的高質量PDF，有好友贊助的也有我自己的，大家可以免費領取：

深入淺出Java多線程、HTTP超全匯總、Java基礎核心總結、程序員必知的硬核知識大全、簡歷面試談薪的超全乾貨。

別看數量不多，但篇篇都是乾貨，看完的都說很肝。

領取方式：掃碼關注后，在公眾號後台回復：666

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※想知道最厲害的網頁設計公司"嚨底家"!

※幫你省時又省力,新北清潔一流服務好口碑

※別再煩惱如何寫文案,掌握八大原則!

基於角色的訪問控制  (RBAC) 

　　是將系統訪問限製為授權用戶的一種方法，是圍繞角色和特權定義的與策略無關的訪問控制機制，RBAC的組件使執行用戶分配變得很簡單。

　　在組織內部，將為各種職務創建角色。執行某些操作的權限已分配給特定角色。成員或職員（或其他系統用戶）被分配了特定角色，並且通過這些角色分配獲得執行特定系統功能所需的權限。由於未直接為用戶分配權限，而是僅通過其角色（一個或多個角色）獲取權限，因此，對單個用戶權限的管理就變成了簡單地為用戶帳戶分配適當角色的問題。這簡化了常見操作，例如添加用戶或更改用戶部門。

RBAC定義了三個主要規則

　　1、角色分配：僅當對象已選擇或分配了角色時，對象才能行使權限。

　　2、角色授權：必須為主體授權主體的活動角色。使用上面的規則1，此規則可確保用戶只能承擔獲得其授權的角色。

　　3、權限授權：僅當對象的活動角色被授權時，對象才能行使權限。使用規則1和2，此規則可確保用戶只能行使其被授權的權限。

創建RBAC的模型

菜單 

　　public class SysMenu
    {
        /// <summary>
        ///     父級
        /// </summary>
        public int ParentId { get; set; } = 0;

        /// <summary>
        ///     菜單名稱
        /// </summary>
        [StringLength(20)]
        public string Name { get; set; }

        /// <summary>
        ///     菜單地址
        /// </summary>
        [StringLength(20)]
        [Required]
        public string Url { get; set; }

        /// <summary>
        ///     層級
        /// </summary>
        [Column(TypeName = "tinyint(4)")]
        public int Level { get; set; } = 1;

        /// <summary>
        ///     菜單權限(list<int /> json)
        /// </summary>
        [StringLength(100)]
        public string Operates { get; set; }

        /// <summary>
        ///     排序
        /// </summary>
        public int Sort { get; set; }

        /// <summary>
        /// 菜單圖標
        /// </summary>
        public string Icon { get; set; }        
    }

 功能

　　public class SysOperate
    {
        /// <summary>
        ///     按鈕名稱
        /// </summary>
        [StringLength(20)]
        [Required]
        public string Name { get; set; }

        /// <summary>
        ///     備註
        /// </summary>
        [StringLength(int.MaxValue)]
        public string Remark { get; set; }

        /// <summary>
        /// 唯一標識
        /// </summary>
        [Required]
        public int Unique { get; set; }
    }

角色

　　public class SysRole 
    {
        /// <summary>
        ///     角色名稱
        /// </summary>
        [StringLength(20)]
        [Required]
        public string Name { get; set; }

        /// <summary>
        ///     備註
        /// </summary>
        [StringLength(int.MaxValue)]
        public string Remark { get; set; }
    }

用戶

    public class SysUser
    {
        /// <summary>
        ///     角色id
        /// </summary>
        public int RoleId { get; set; }

        /// <summary>
        ///     用戶名
        /// </summary>
        [StringLength(32)]
        [Required]
        public string UserName { get; set; }

        /// <summary>
        ///     密碼
        /// </summary>
        [StringLength(500)]
        [Required]
        public string Password { get; set; }
    }

 微服務中讓它成為一個授權權限服務

　　在日常工作中，總會有很多系統要做，每個系統都要一套完整的權限功能，有現成的直接拿來粘貼複製，沒有現成的又要浪費很多時間去設計實現它。 如果有這樣一個服務，我們可以節省很多不必要的粘貼複製操作，節省很多時間。

　　於是 ketchup.zero 這樣一個服務就誕生了。它是基於ketchu微服務框架來實現的一個權限授權服務，基本可以滿足我們日常工作的的權限需求。

　　服務的前端是基於vue的模板d2admin 開發的。

ketchup.zero的功能

登陸

面板

 

 用戶配置角色

 

 菜單設置擁有那些權限

 

 權限/功能/按鈕 管理

 

 角色設置權限

 

最後安利

如果它對你有幫助，請給一波start

服務 ketchup.zero 源碼地址：https://github.com/simple-gr/ketchup.zero

微服務框架 ketchup 源碼地址：https://github.com/simple-gr/ketchup 

ketchup 交流群：592407137

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※新北清潔公司,居家、辦公、裝潢細清專業服務

※別再煩惱如何寫文案,掌握八大原則!

※教你寫出一流的銷售文案?

※超省錢租車方案

業務代碼中的配置化

工作中有許多邏輯冗雜、迭代頻繁的業務代碼，隨着迭代將越來越難以維護，一些場景適合通過配置化的方式來處理便於維護。

一、什麼是業務代碼配置化？

根據業務場景使用配置化的 Object|Array|Map 處理條件判斷邏輯，通常需要配置文件 CONFIG.js，若邏輯複雜需添加 getConfig 的處理函數 – tool.js

• 本質上 if/else 邏輯是一種狀態匹配

• 表驅動法，使用表數據，存儲對應的狀態處理

• 可讀性好，減少了繁雜嵌套的 if-else，讀取配置，邏輯更清晰

• 可維護性高，邏輯分支的增刪只是 CONFIG 的增刪

二、如何在業務場景中進行代碼配置化？

1. 簡單的狀態映射

• 按需使用 Object|Map 配置

單一條件

• Object 形式:

// CONFIG.JS
  export const STATUS = {
    STUDENT: 0,
    TEACHER: 1,
    MA_NONG: 2,
  };
  export const WORK_MAP = {
    STATUS.STUDENT: '學生',
    STATUS.TEACHER: '老師',
    STATUS.MA_NONG: '碼農',
  };

// index.js
  this.setData({
    work: WORK_MAP[status],
  });

  axios.post(url, { status: STATUS.MA_NONG });

• Map 形式：

// CONFIG.JS
export const WORK_MAP = new Map([
  [0, "學生"],
  [1, "老師"],
  [2, "碼農"],
]);
// index.js
this.setData({
  work: WORK_MAP.get(status),
});

多重條件

const config = new Map([
  [
    (condition0, condition1, condition2) =>
      condition0 && condition1 && condition2,
    () => {
      console.log("map0");
    },
  ],
  [
    (condition0, condition1, condition2) =>
      condition0 || condition1 || condition2,
    () => {
      console.log("map1");
    },
  ],
]);
config.forEach((action, _if) => _if(0, 1, 0) && action());

2. 每個狀態有多種屬性

• 多個屬性
• 使用 Array 配置

// CONFIG.JS
  export const CONFIG = [
    {
      status: STATUS.STUDENT,
      name: '學生',
      action: '談戀愛',
    },
    {
      status: STATUS.TEACHER,
      name: '老師',
      action: '教書',
    },
    {
      status: STATUS.MA_NONG,
      name: '碼農',
      action: '寫bug',
    },
  ];

// index.js
  <!-- 根據狀態不同的行為 -->
  function action(status) {
    const { name, work } = CONFIG.find(i => i.status === status);
    console.log(`${name}在${action}`);
  }

3. 每個狀態有多種屬性且參數定製化

• 參數高度定製化，不同狀態需要適配接口不同的字段
• 使用 Array 配置
• 通過配置函數並傳參注入接口數據可滿足定製化需求

// CONFIG.JS
  export const CONFIG = [
    {
      status: STATUS.STUDENT,
      name: '學生',
      action: () => {
        console.log('學生的工作是談戀愛');
      },
    },
    {
      status: STATUS.TEACHER,
      name: '老師',
      action: (info) => {
        alert(`老師${info.age}歲，每天${info.action}`);
      },
    },
    {
      status: STATUS.MA_NONG,
      name: '碼農',
      action: (info) => {
        toast(`碼農工作${info.workTime}年了，頭髮僅剩${info.hair}根了`);
      },
    },
  ];

// index.js
  <!-- 根據接口狀態action -->
  function action(res) {
    const { action, info } = CONFIG.find(i => i.status === res.status);
    action && action(info); // 傳參定製化
  }

三、實例

大首頁瀑布流 item 樣式

• 根據 list 接口下發的 item 的類型(type)&樣式(layout)字段取 item 中的封面、標題、標籤、頭像…，字段各不相同
• 十幾種 item 類型，有的還有不同的 layout，item 數據下發方式不同
• 公共組件，需要適配其他模塊的接口數據作展示

index.xml

• 數據驅動，減少模板中的判斷邏輯

<view class="panel" bind:tap="goDetail">
  <!-- 封面 -->
  <image  wx:if="{{panel.cover}}" class="panel__cover" src="{{panel.cover.image}}">
      <view class="panel__tag {{panel.tagClass}}" wx:if="{{panel.tagClass}}">{{panel.tag}}</view>
  </image>
  <!-- 標題 -->
  <view class="panel__titl" wx:if="{{panel.title}}">{{panel.title}}</view>
  <!-- footer -->
  <view class="panel__footer" wx:if="{{panel.showFooter}}">
    <image class="panel__footer-icon" wx:if="{{panel.user.icon}}" src="{{panel.user.icon}}"></image>
    <text class="panel__footer-name" wx:if="{{panel.user.nickname}}">{{panel.user.nickname}}</text>
    <text class="panel__footer-comment" wx:if="{{panel.commentCount}}">{{panel.commentCount}}評論</text>
  </view>
</view>

CONFIG.js

import { Layout, NewsType, Redirect } from 'src/constant';
import { formatImage, formatUser } from './tool';

/**
 * 配置項
 * @param {String} title 標題
 * @param {String} cover 封面
 * @param {String} tag 標籤
 * @param {Object} user 用戶信息
 * @param {Boolean} showFooter 是否显示footer
 * @param {Boolean} isAd 是否廣告
 * @param {Function} itemWrap 兼容接口數據函數，數據可能以ref_xxx下發，比如帖子：ref_post
 * ......
 */

<!-- 默認配置項 -->
export const DEFAULT = {
  title: ({ title = '' }) => title,
  cover: ({ image_list = [], article_images = [] }) =>
    formatImage(image_list[0]) || formatImage(article_images[0]),
  showFooter: true,
  user: ({ user, user_account, article_source_tx = '' }) =>
    user
      ? formatUser(user)
      : user_account
      ? formatUser(user_account)
      : {
          icon: '',
          nickname: article_source_tx,
        },
};

export const CONFIG = [
  {
    type: NewsType.NEWS,
    ...DEFAULT,
    tag: '資訊',
    tagClass: 'news',
  },
  {
    type: NewsType.VIDEO,
    ...DEFAULT,
    tag: '',
    tagClass: 'video',
    cover: ({ image_gif_list = [], image_list = [] }) => formatImage(image_gif_list[0] || image_list[0]),
    video: ({ video_url = '', tencent_vid = '', image_gif_list = [] }) => ({
      hasVideo: true,
      src: tencent_vid || video_url,
      video_url,
      tencent_vid,
      gifCover: formatImage(image_gif_list[0]),
    }),
  },
  {
    type: Redirect.EVAL_DETAIL,
    layouts: [
      {
        layout: Layout.EVALUATION,
        ...DEFAULT,
        tag: '口碑',
        tagClass: 'praise',
      },
      {
        layout: Layout.PRAISE_COMPONENT,
        ...DEFAULT,
        tag: '口碑',
        tagClass: 'praise',
        itemWrap: ({ ref_car_score = {} }) => ref_car_score,
        title: ({ chosen_topic = '' }) => chosen_topic,
        commentCount: ({ comment_count = null }) => comment_count,
        cover: ({ images = [], recommend_images = [] }) =>
          formatImage(images[0]) ||
          formatImage(getCoverFromRecommendImages(recommend_images)),
      },
      {
        layout: Layout.NORMAL,
        ...DEFAULT,
      },
    ],
  },
  ......
];

tool.js

import { CONFIG, DEFAULT, AD_CONFIG } from "./CONFIG";
// 獲取瀑布流item數據
export const getPanelData = (item) => {
  const getConfigByTypeAndLayout = () => {
    let config = CONFIG.find((i) => i.type == item.type);
    if (item.isAd) {
      config = AD_CONFIG;
    }
    if (config && config.layouts) {
      config = config.layouts.find(
        (i) => i.layout === item.layout_type || i.layout === item.display_style
      );
    }
    if (!config) {
      config = DEFAULT;
      console.log("no-config", item.type, item.layout_type, item);
    }
    return config;
  };
  const getPanelDataByConfig = (c) => {
    const panel = {};
    let _item = item;
    if (c.itemWrap) {
      _item = c.itemWrap(item);
    }
    Object.keys(c).forEach((key) => {
      if (typeof c[key] === "function") {
        panel[key] = c[key](_item);
      } else {
        panel[key] = c[key];
      }
    });
    return panel;
  };
  // 根據item的類型、樣式獲取配置
  const config = getConfigByTypeAndLayout(item);
  // 根據配置獲取瀑布流item信息
  return getPanelDataByConfig(config);
};

四、結語

所以，業務代碼配置化很簡單，大家也都一直在用，只是如果在一些業務場景中都形成配置化的習慣或者共識，可能更好維護吧。

鄙人拙見，大佬賜教~

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※新北清潔公司,居家、辦公、裝潢細清專業服務

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※超省錢租車方案

※教你寫出一流的銷售文案?

作者簡介

Christopher Tozzi，自2008年來以自由職業者的身份對Linux、虛擬化、容器、數據存儲及其相關主題進行報道。

時至今日，Kubernetes已然成為風靡一時的容器編排調度工具，許多IT分析師均提出了企業應當在何時採用Kubernetes的深刻建議。然而，和所有其他的軟件平台一樣，Kubernetes並非是一個適用於所有人的靈丹妙藥。我更傾向於認為人們在有些時候過分誇大了Kubernetes的作用，以至於他們產生了一種錯覺：他們無法離開Kubernetes，而實際上，Kubernetes比他們真正的需求要複雜得多。

為了分析人們真正的需求與Kubernetes的匹配程度，我分析了企業在採用Kubernetes編排之前必須考慮的5個事情。

Kubernetes是什麼？

如果您關注容器，您可能會知道Kubernetes是一個用於容器編排的開源工具，它可以自動執行諸如啟動容器、停止容器以及在同一個容器的不同實例之間的負載均衡等重要任務。

簡而言之，Kubernetes的主要目的是最大限度地減少工程師必須手動執行的管理工作量，並通過簡化容器操作，幫助企業大規模運行複雜的容器化應用程序。

決定是否採用Kubernetes的關鍵要素

基於Kubernetes的設立初衷，如果您喜歡自動化，討厭手動執行重複性的任務，那麼Kubernetes無疑是您的極佳選擇。

這是您決定是否採用Kubernetes的重要前提，但是，您不能僅根據這一“前提”就決定是否採用Kubernetes。在採用Kubernetes之前，您還需要考慮並權衡其他重要的因素。

1、Kubernetes的基礎設施規模

您的基礎設施規模是其中一個決定Kubernetes是否能夠很好地為您所用的關鍵要素。

Kubernetes的設計初衷是協調分佈在真正龐大的環境中的容器，這往往意味着企業應當擁有數十台主機服務器。根據過往的實施經驗，如果基礎架構中的服務器少於50個，那麼您可能沒有足夠的資源來利用Kubernetes的全部優勢。

這並不是指Kubernetes無法在較小規模的基礎設施上運行。實際上，如果您願意，您可以在單個主機上運行Kubernetes。然而，由於Kubernetes其中的一個研發目的是：通過在數量龐大的集群中分佈容器化應用程序提供高可用性，因此，如果您只有少量服務器，則無法享受到Kubernetes的某些價值。

除此之外，考慮到設置和維護Kubernetes的複雜性，如果您的基礎設施規模較小，無法完全實現Kubernetes的高可用性承諾，那麼或許您不應投入過多時間和精力在Kubernetes上。

對於較小的基礎架構，您可以使用較為簡單的容器編排工具，或者使用如AWS ECS等具有內置編排的基於雲的容器服務。

2、Kubernetes操作系統環境

Kubernetes主要是一種Linux技術。儘管Kubernetes可以用於管理託管Windows服務器上的容器化應用程序，這些應用程序作為Kubernetes服務器集群內的所謂工作節點運行。但託管Kubernetes核心服務的主要服務器或者說主節點必須是Linux。

因此，如果您的商店以Windows為中心，那麼Kubernetes並非您的最佳選擇。但是您可以選擇Rancher輕鬆將Kubernetes的優勢引入Windows，並且極大程度降低使用的複雜性。

3、安裝和設置Kubernetes

在決定採用Kubernetes之前，您還需要評估您可以在此項目上投入的工作時間。

普通的開放源代碼版本的Kubernetes缺少內置的應用程序，也並未提供一種可以適用於所有默認配置的安裝方式。在集群正常運行之前，您需要投入大量的時間從頭開始編寫及調整配置文件。因此，安裝和配置Kubernetes的過程或許是一個令人生畏的過程，您需要投入大量的時間和精力。

部分Kubernetes發行版提供了交互式安裝程序腳本，可以幫助您自動執行大部分設置過程。如果您選擇Rancher等Kubernetes發行版，則有望在一两天內輕鬆完成配置及安裝。

第三種選擇是使用諸如Google Kubernetes Engine等雲供應商解決方案，將Kubernetes作為託管服務在雲上運行。在這種情況下，您可以自行選擇安裝及設置。但值得注意的一點是，在確定如何配置Kubernetes環境時，您的選擇可能會受到限制。

您必須意識到最為關鍵的一點：不要低估配置Kubernetes的難度。在您真的要全身心投入Kubernetes之前，請確保您所付出的努力是值得的。另一方面，如果您無法確定為企業在生產集群上安裝和部署Kubernetes的難度，您可以嘗試使用K3s等輕量級Kubernetes發行版來進行測試，預估後續需要付出多少努力來進行Kubernetes的配置和設置。

4、Kubernetes和聲明式配置管理

Kubernetes採用了所謂的聲明式配置管理方法，這就意味着，您需要自行編寫配置文件來設置Kubernetes應用程序應當如何運行，而Kubernetes將自動指出如何使應用程序符合規範。

聲明式配置管理與命令式配置管理相反，在命令式配置管理中，您可以自行配置應用程序的每個組件，並讓其按照您所想要的方式運行。

聲明式配置是Kubernetes在許多用戶實例中如此強大和可伸縮的其中一個原因。您可以設置一次配置，並且根據需要多次應用它。

但是，如果您的配置需求不斷變化，或者在工作負載或環境中的不同部分之間變化，那麼您應當如何處理呢？在這種情況下，聲明式配置管理將成為一個障礙，您將發現自己需要不斷地調整先前認為是“一勞永逸”的配置文件。

因此，在您選擇採用Kubernetes之前，您需要考慮應用程序的配置需求。只有當您所需要的配置相對通用且靜態時，Kubernetes才是一個不錯的選項。

5、Kubernetes和多雲

Rancher等部分Kubernetes發行版的主要功能之一，是單個Kubernetes部署可以編排多個集群，無論集群位於在不同的公有雲還是私有雲上。這一功能使Kubernetes成為協助控制多雲架構複雜性的優秀工具。

在跨多雲部署容器化應用程序，並且Kubernetes的設置和配置工作很合理時，多雲上的Kubernetes是十分有意義的。

在這一因素中，您需要留意的是，在考慮是否以及何時採用Kubernetes時，應考慮您當前的多雲戰略以及多雲擴展計劃。

結 語

Kubernetes是一個非常棒的工具，在正確設置的情況下，它可以產生巨大的價值。但是，它並沒有達到殺手級應用程序的狀態，因為它無法在所有用戶實例中交付價值。在您被巨大的宣傳攻勢攻陷，並確定您無法離開Kubernetes之前，請清醒地對自己的需求進行評估，明確Kubernetes是否能在真正意義上幫助您更加有效、更加可靠地運行應用程序。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※教你寫出一流的銷售文案?

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※回頭車貨運收費標準

※別再煩惱如何寫文案,掌握八大原則!

※超省錢租車方案

原文鏈接：https://fuckcloudnative.io/posts/lens/

Kubernetes 的桌面客戶端有那麼幾個，曾經 Kubernetic 應該是最好用的，但最近有個叫 Lens 的 APP 改變了這個格局，功能比 Kubernetic 多，使用體驗更好，適合廣大系統重啟工程師裝逼。它有以下幾個亮點：

① Lens 就是一個強大的 IDE，可以實時查看集群狀態，實時查看日誌流，方便排查故障。有了 Lens，你可以更方便快捷地使用你的集群，從根本上提高工作效率和業務迭代速度。

日誌流界面可以選擇显示或隱藏時間戳，也可以指定显示的行數：

② Lens 可以管理多集群，它使用內置的 kubectl 通過 kubeconfig 來訪問集群，支持本地集群和外部集群（如EKS、AKS、GKE、Pharos、UCP、Rancher 等），甚至連 Openshift 也支持：

只是與 Openshift 的監控還不太兼容。也可以很輕鬆地查看並編輯 CR：

有了 Lens，你就可以統一管理所有的集群。

③ Lens 內置了資源利用率的儀錶板，支持多種對接 Prometheus 的方式：

④ Lens 內置了 kubectl，它的內置終端會確保集群的 API Server 版本與 kubectl 版本兼容，所以你不需要在本地安裝 kubectl。可以驗證一下：

你會看到本地安裝的 kubectl 版本和 Lens 裏面打開的終端里的 kubectl 版本信息是不一樣的，Lens 確實內置了 kubectl。

⑤ Lens 內置了 helm 模板商店，可直接點擊安裝：

現在 Lens 迎來了最新版 3.5.0，換上了全新的 Logo：

穩定性也提升了很多，快去試試吧。

Kubernetes 1.18.2 1.17.5 1.16.9 1.15.12離線安裝包發布地址http://store.lameleg.com ，歡迎體驗。 使用了最新的sealos v3.3.6版本。 作了主機名解析配置優化，lvscare 掛載/lib/module解決開機啟動ipvs加載問題， 修復lvscare社區netlink與3.10內核不兼容問題,sealos生成百年證書等特性。更多特性 https://github.com/fanux/sealos 。歡迎掃描下方的二維碼加入釘釘群 ，釘釘群已經集成sealos的機器人實時可以看到sealos的動態。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

用Map+函數式接口來實現策略模式

目前在魔都，貝殼找房是我的僱主，平時關注一些 java 領域相關的技術，希望你們能在這篇文章中找到些有用的東西。個人水平有限，如果文章有錯誤還請指出，在留言區一起交流。

本文已投稿至公眾號 Hollis 原文鏈接：https://mp.weixin.qq.com/s/hkypvNBkRjPM6HM51_jW9g

我想大家肯定都或多或少的看過各種“策略模式”的講解、佈道等等，這篇文章就是來好好“澄清”一下策略模式，並嘗試回答以下的問題：

1. 策略模式是如何優化業務邏輯代碼結構的？
2. 殺雞焉用宰牛刀？就是幾個if else場景我需要用到策略模式？！
3. 有沒有什麼更好的代碼結構來實現策略模式的嗎？

策略模式是如何優化業務邏輯代碼結構的？

要回答這個問題，我們還得先扒一扒策略模式的定義，從定義着手來理解它：

策略模式的教科書定義

它的定義很精簡：一個類的行為或其算法可以在運行時更改。我們把它降維到代碼層面，用人話翻譯一下就是，運行時我給你這個類的方法傳不同的“key”，你這個方法會執行不同的業務邏輯。細品一下，這不就是 if else 乾的事嗎？

策略模式優化了什麼？

其實策略模式的核心思想和 if else如出一轍，根據不同的key動態的找到不同的業務邏輯，那它就只是如此嗎？

實際上，我們口中的策略模式其實就是在代碼結構上調整，用接口+實現類+分派邏輯來使代碼結構可維護性好點。

一般教科書上講解到接口與實現類就結束了，其他博客上會帶上提及分派邏輯。這裏就不啰嗦了。

小結一下，即使用了策略模式，你該寫的業務邏輯照常寫，到邏輯分派的時候，還是變相的if else。而它的優化點是抽象了出了接口，將業務邏輯封裝成一個一個的實現類，任意地替換。在複雜場景（業務邏輯較多）時比直接 if else 來的好維護些。

殺雞焉用宰牛刀？就是幾個if else場景我需要用到策略模式？！

我想小夥伴們經常有這樣的不滿，我的業務邏輯就3 4 行，你給我整一大堆類定義？有必要這麼麻煩嗎？我看具體的業務邏輯還需要去不同的類中，簡單點行不行。

其實我們所不滿的就是策略模式帶來的缺點：1、策略類會增多 2、業務邏輯分散到各個實現類中，而且沒有一個地方可以俯視整個業務邏輯

針對傳統策略模式的缺點，在這分享一個實現思路，這個思路已經幫我們團隊解決了多個複雜if else的業務場景，理解上比較容易，代碼上需要用到Java8的特性——利用Map與函數式接口來實現。

直接show代碼結構：為了簡單演示一個思路，代碼用String 類型來模擬一個業務BO

其中：

1. getCheckResult() 為傳統的做法
2. getCheckResultSuper()則事先在Map中定義好了“判斷條件”與“業務邏輯”的映射關係,具體講解請看代碼註釋

/**
 * 某個業務服務類
 */
@Service
public class BizService {

    /**
     * 傳統的 if else 解決方法
     * 當每個業務邏輯有 3 4 行時，用傳統的策略模式不值得，直接的if else又顯得不易讀
     */
    public String getCheckResult(String order) {
        if ("校驗1".equals(order)) {
            return "執行業務邏輯1";
        } else if ("校驗2".equals(order)) {
            return "執行業務邏輯2";
        }else if ("校驗3".equals(order)) {
            return "執行業務邏輯3";
        }else if ("校驗4".equals(order)) {
            return "執行業務邏輯4";
        }else if ("校驗5".equals(order)) {
            return "執行業務邏輯5";
        }else if ("校驗6".equals(order)) {
            return "執行業務邏輯6";
        }else if ("校驗7".equals(order)) {
            return "執行業務邏輯7";
        }else if ("校驗8".equals(order)) {
            return "執行業務邏輯8";
        }else if ("校驗9".equals(order)) {
            return "執行業務邏輯9";
        }
        return "不在處理的邏輯中返回業務錯誤";
    }

    /**
     * 業務邏輯分派Map
     * Function為函數式接口，下面代碼中 Function<String, String> 的含義是接收一個Stirng類型的變量，返回一個String類型的結果
     */
    private Map<String, Function<String, String>> checkResultDispatcher = new HashMap<>();

    /**
     * 初始化 業務邏輯分派Map 其中value 存放的是 lambda表達式
     */
    @PostConstruct
    public void checkResultDispatcherInit() {
        checkResultDispatcher.put("校驗1", order -> String.format("對%s執行業務邏輯1", order));
        checkResultDispatcher.put("校驗2", order -> String.format("對%s執行業務邏輯2", order));
        checkResultDispatcher.put("校驗3", order -> String.format("對%s執行業務邏輯3", order));
        checkResultDispatcher.put("校驗4", order -> String.format("對%s執行業務邏輯4", order));
        checkResultDispatcher.put("校驗5", order -> String.format("對%s執行業務邏輯5", order));
        checkResultDispatcher.put("校驗6", order -> String.format("對%s執行業務邏輯6", order));
        checkResultDispatcher.put("校驗7", order -> String.format("對%s執行業務邏輯7", order));
        checkResultDispatcher.put("校驗8", order -> String.format("對%s執行業務邏輯8", order));
        checkResultDispatcher.put("校驗9", order -> String.format("對%s執行業務邏輯9", order));
    }

    public String getCheckResultSuper(String order) {
        //從邏輯分派Dispatcher中獲得業務邏輯代碼，result變量是一段lambda表達式
        Function<String, String> result = checkResultDispatcher.get(order);
        if (result != null) {
            //執行這段表達式獲得String類型的結果
            return result.apply(order);
        }
        return "不在處理的邏輯中返回業務錯誤";
    }
}

通過http調用一下看看效果：

/**
 * 模擬一次http調用
 */
@RestController
public class BizController {

    @Autowired
    private BizService bizService;

    @PostMapping("/v1/biz/testSuper")
    public String test2(String order) {
        return bizService.getCheckResultSuper(order);
    }
}

這是個簡單的demo演示，之後會舉一些複雜的場景案例。

魯迅曾說過，“每解決一個問題，就會引出更多的問題”。我們一起來看看這樣的實現有什麼好處，會帶來什麼問題。

好處很直觀：

1. 在一段代碼里直觀的看到”判斷條件”與業務邏輯的映射關係
2. 不需要單獨定義接口與實現類，直接使用現有的函數式接口（什麼？不知道函數式接口？快去了解），而實現類直接就是業務代碼本身。

不好的點：

1. 需要團隊成員對lambda表達式有所了解(什麼？Java14都出來了還有沒用上Java8新特性的小夥伴？)

接下來我舉幾個在業務中經常遇到的if else場景，並用Map+函數式接口的方式來解決它

在真實業務場景問題的解決思路

有的小夥伴會說，我的判斷條件有多個啊，而且很複雜，你之前舉個例子只有單個判斷邏輯，而我有多個判斷邏輯該怎麼辦呢？

很好解決：寫一個判斷邏輯的方法，Map的key由方法計算出

/**
 * 某個業務服務類
 */
@Service
public class BizService {

    private Map<String, Function<String, String>> checkResultDispatcherMuti = new HashMap<>();

    /**
     * 初始化 業務邏輯分派Map 其中value 存放的是 lambda表達式
     */
    @PostConstruct
    public void checkResultDispatcherMuitInit() {
        checkResultDispatcherMuti.put("key_訂單1", order -> String.format("對%s執行業務邏輯1", order));
        checkResultDispatcherMuti.put("key_訂單1_訂單2", order -> String.format("對%s執行業務邏輯2", order));
        checkResultDispatcherMuti.put("key_訂單1_訂單2_訂單3", order -> String.format("對%s執行業務邏輯3", order));
    }

    public String getCheckResultMuti(String order, int level) {
        //寫一段生成key的邏輯：
        String ley = getDispatcherKey(order, level);

        Function<String, String> result = checkResultDispatcherMuti.get(ley);
        if (result != null) {
            //執行這段表達式獲得String類型的結果
            return result.apply(order);
        }
        return "不在處理的邏輯中返回業務錯誤";
    }

    /**
     * 判斷條件方法
     */
    private String getDispatcherKey(String order, int level) {
        StringBuilder key = new StringBuilder("key");
        for (int i = 1; i <= level; i++) {
            key.append("_" + order + i);
        }
        return key.toString();
    }
}

用http模擬一下：

/**
 * 模擬一次http調用
 */
@RestController
public class BizController {

    @Autowired
    private BizService bizService;

    @PostMapping("/v1/biz/testMuti")
    public String test1(String order, Integer level) {
        return bizService.getCheckResultMuti(order, level);
    }
}

只要設計好你的key的生成規則就好。

還有小夥伴會問：我的業務邏輯有很多很多行，在checkResultDispatcherMuitInit()方法的Map中直接寫不會很長嗎？

直接寫當然長了，我們可以抽象出一個service服務專門放業務邏輯，然後在定義中調用它就好了：

提供一個業務邏輯單元：

/**
 * 提供業務邏輯單元
 */
@Service
public class BizUnitService {

    public String bizOne(String order) {
        return order + "各種花式操作1";
    }
    public String bizTwo(String order) {
        return order + "各種花式操作2";
    }
    public String bizThree(String order) {
        return order + "各種花式操作3";
    }
}

/**
 * 某個業務服務類
 */
@Service
public class BizService {
    @Autowired
    private BizUnitService bizUnitService;

    private Map<String, Function<String, String>> checkResultDispatcherComX = new HashMap<>();

    /**
     * 初始化 業務邏輯分派Map 其中value 存放的是 lambda表達式
     */
    @PostConstruct
    public void checkResultDispatcherComXInit() {
        checkResultDispatcherComX.put("key_訂單1", order -> bizUnitService.bizOne(order));
        checkResultDispatcherComX.put("key_訂單1_訂單2", order -> bizUnitService.bizTwo(order));
        checkResultDispatcherComX.put("key_訂單1_訂單2_訂單3", order -> bizUnitService.bizThree(order));
    }

    public String getCheckResultComX(String order, int level) {
        //寫一段生成key的邏輯：
        String ley = getDispatcherComXKey(order, level);

        Function<String, String> result = checkResultDispatcherComX.get(ley);
        if (result != null) {
            //執行這段表達式獲得String類型的結果
            return result.apply(order);
        }
        return "不在處理的邏輯中返回業務錯誤";
    }

    /**
     * 判斷條件方法
     */
    private String getDispatcherComXKey(String order, int level) {
        StringBuilder key = new StringBuilder("key");
        for (int i = 1; i <= level; i++) {
            key.append("_" + order + i);
        }
        return key.toString();
    }
}

調用結果：

總結

最後，我們一起嘗試回答以下幾個問題：

1. 策略模式是如何優化業務邏輯代碼結構的？
   —— 抽象了出了接口，將業務邏輯封裝成一個一個的實現類，任意地替換。在複雜場景（業務邏輯較多）時比直接 if else 來的好維護些。
2. 殺雞焉用宰牛刀？就是幾個if else場景我需要用到策略模式？！——我們所不滿的其實就是傳統接口實現的缺點：1、策略類會很多。 2、業務邏輯分散到各個實現類中，而且沒有一個地方可以俯覽整個業務邏輯
3. 有沒有什麼更好的代碼結構來實現策略模式的嗎？——針對傳統策略模式的缺點，分享了利用Map與函數式接口來實現的思路。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!