<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Rick on Medium]]></title>
        <description><![CDATA[Stories by Rick on Medium]]></description>
        <link>https://medium.com/@rickbsr?source=rss-4a9adf38ab9------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*BFRREoUpJuasqsxYANAeXw.png</url>
            <title>Stories by Rick on Medium</title>
            <link>https://medium.com/@rickbsr?source=rss-4a9adf38ab9------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 17:39:38 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rickbsr/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[淺談大佬們如何煮「Prompt」]]></title>
            <link>https://rickbsr.medium.com/%E6%B7%BA%E8%AB%87%E5%A4%A7%E4%BD%AC%E5%80%91%E5%A6%82%E4%BD%95%E7%85%AE-prompt-e7b663308a74?source=rss-4a9adf38ab9------2</link>
            <guid isPermaLink="false">https://medium.com/p/e7b663308a74</guid>
            <category><![CDATA[軟體開發]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Rick]]></dc:creator>
            <pubDate>Thu, 13 Aug 2026 06:24:22 GMT</pubDate>
            <atom:updated>2026-08-13T08:43:01.870Z</atom:updated>
            <content:encoded><![CDATA[<h4>來聊聊大佬們都怎麼煮「Prompt」：Karpathy 與 Matt Pocock 的方法論比較</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6NIFwDHixDlP6MCa" /><figcaption>Photo by <a href="https://unsplash.com/@kevinmccutcheon?utm_source=medium&amp;utm_medium=referral">Kevin McCutcheon</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>黑暗料理界的魔爪已經伸向「AI」了。</p><p>大魔術熊貓麻婆 Prompt。</p><h3>前言</h3><p>如果要說最近有什麼爆火的 AI 新鮮事，那麼筆者最近正在研究的「<a href="https://github.com/mattpocock/skills">skills</a>」，必須是其中之一；「<a href="https://github.com/mattpocock/skills">skills</a>」是「Matt Pocock」發佈在 GitHub 上的項目，是他彙整他日常所使用的「Agent Skills」後的內容。</p><p>「Matt Pocock」是一位以「TypeScript」教學聞名的軟體工程師；所以我們可以將「<a href="https://github.com/mattpocock/skills">skills</a>」理解成 Pocock 的個人技能庫，也就是一位 AI 大佬的私家工具箱。</p><p>試想，若能掌握一位大佬平常所使用的 Agent Skills，是一件多令人興奮的事情，再不濟，我們只要像對待大多數的「Agent Skill」那樣，直接把「<a href="https://github.com/mattpocock/skills">skills</a>」複製到自己的環境中，那麼，我們日常使用 AI Agent 的品質、效率不也得提上一階；只是，這樣就真的有些可惜了。</p><p>的確，若單純從形式上來看，「<a href="https://github.com/mattpocock/skills">skills</a>」不過是一套套 AI Agent 的技能；但只要仔細咀嚼，就會驚訝地發現，這些看似獨立的技能彼此並非各自為政，而是分別對應到需求釐清、決策整理、工作切分與成果驗證等工作流程中的不同節點，並且環環相扣，相互串接成一套完整且可實際運作的工作流方法論。</p><p>所以，若只是把它們當成一般 Skills 複製貼上，雖然也能有效提升 AI Agent 的工作品質與效率，但卻錯過了筆者認為更值得學習，隱藏在其背後的工作流思維；不過，這篇文章並不打算深度剖析「<a href="https://github.com/mattpocock/skills">skills</a>」的內容。主要是，筆者最近在滑社交平台耍廢時，碰巧刷到另一位大佬，「Andrej Karpathy」，的貼文，他在上面分享了一種煮「Prompt」的方式，細節我們稍後再介紹，但主軸就是：在描述需求時，以一種不刻意思考、想到什麼就說什麼的方式來描述；「Andrej Karpathy」稱之為「Ramble Session」。</p><p>說真的，若提出者不是「Andrej Karpathy」，乍看之下，筆者大概會說，這是哪位腦迴路清奇的小伙子。</p><p>但先別管這小伙子適不適合練武，「Andrej Karpathy」提出的這個思路，確實與眾不同。</p><p>恰巧，「Matt Pocock」的「<a href="https://github.com/mattpocock/skills">skills</a>」中，也有一段關於煮「Prompt」的方式：「/grill-me」。</p><p>如果說 Karpathy 的方法帶著幾分輕鬆隨意，那麼 Matt 的「/grill-me」就完全是另一種路數，它秉持著「打破砂鍋問到底」的精神，其方式是要求 AI 不斷地追問使用者，只要 AI 評估需求內容仍存在未知、不確定，就不斷地追問，直到雙方逐步把需求釐清為止。</p><p>看似南轅北轍，卻又同樣是在處理一件事情：我們究竟該如何把「腦中的想法」，轉換成「AI 真正能夠理解並執行的需求」？</p><p>兩種迥異的方法論，兩位程式碼界的翹楚。</p><p>究竟是「Ramble Session」這種看似隨性的方式更有效，還是「/grill-me」這種打破砂鍋問到底的方法更勝一籌？又或者，兩者其實根本不是非此即彼，而是分別解決了 Prompt Engineering 中不同階段的問題？</p><p>接下來，就讓我們一探這兩種方法背後的邏輯思維。</p><h3>正文</h3><h4>什麼是 Prompt？</h4><p>在開始介紹兩位大佬的「Prompt Engineering」方法之前，我們先來說明下：什麼是「Prompt」？</p><p>簡單地說，「Prompt」就是我們提供給 LLM 的資訊；「Prompt」可以來自使用者輸入、對話歷史、附加文件或程式碼，也可以是我們從網路上擷取的任何資訊片段。</p><p>而 LLM 在產生回覆時，其能依據的資料源僅有兩類，一是 LLM 在訓練過程中所學會的知識，這些資訊最終會以模型參數的形式被「記住」，因此在模型完成訓練並發布之後，這部分知識基本上就已經固定下來；除非重新訓練、微調模型，或透過其他方式更新模型參數，否則我們很難直接改變模型本身所「學會」的內容。</p><p>二則是模型在推論時所取得的外部資訊，也就是我們剛才所說過的「Prompt」。</p><p>所以，如果我們想交辦任務給「AI」，那麼，「Prompt」就是我們與 LLM 溝通的主要管道。這就像人與人之間的溝通：若雙方有共同背景或相近的思維，就更容易彼此理解；LLM 亦然。若我們希望 LLM 能更好地完成交辦的任務，就要儘量讓它擁有足夠的資訊，例如與任務相關的背景、目標與限制，以及與指派者偏好相關的呈現方式與細節程度。</p><p>但就如前言中提到的，人們在表達需求時，往往會不自覺地遺漏部分資訊。尤其當需求牽涉既有脈絡、例外情況或尚未成形的想法時，那些我們以為理所當然的事情，只要沒有呈現在「Prompt」中，也不存在於模型已內化的訓練資料裡，就會成為我們與 LLM 之間的資訊落差。</p><p>不過，這不代表把越多資料塞進「Prompt」就越好；事實上，這也不切實際。</p><p>要知道，就模型本身而言，LLM 是無狀態的；換句話說，每次推論都是獨立的，模型不會自動記得未被放入輸入中的脈絡。因此，如果我們要讓 LLM 的回應有脈絡，就必須將相關脈絡一併放進輸入的「Prompt」中。然而，LLM 一次能接受的「Prompt」長度是有限的，我們稱之為「Context Window」。正因為「Context Window」有限，放進「Prompt」的資訊就必須精挑細選；這類設計與管理脈絡的工作，通常稱為「Context Engineering」。</p><p>再者，先不說更多資訊通常意味著更高的成本，就算我們選用「Context Window」較大的模型，不計成本地增加「Prompt」，也不代表模型就能有效處理。事實上，研究指出，當輸入的「Prompt」過多時，LLM 可能會忽略位於中間的資訊，這種現象常被稱為「Lost in the Middle」；過多且彼此無關的內容也可能讓模型在回應時失焦，增加誤解或自行補全的機會，讓真正重要的資訊反而被淹沒。</p><p>因此，現在知道煮「Prompt」的重要性了吧？</p><p>題外話，「煮 Prompt」是口語上的說法，較常見的專有名詞是「Prompt Engineering」，泛指設計指令、輸入內容與互動方式，讓模型更容易理解並完成任務。岔題一下，另外還有一個相關名詞「Context Engineering」，它更著重於準備、組織與管理模型在特定任務中所需要的脈絡，兩者關注的範圍與所處階段不完全相同；這部分，未來筆者再另闢一篇說明。</p><p>接著，就讓我們來細品 Karpathy 和 Pocock 兩位大佬各自「煮 Prompt」的哲學。</p><h4>Karpathy 的 Ramble Session</h4><p>首先，讓我們從 Karpathy 的「煮」法開始介紹起：他所說的「a nice long ramble」，貼文如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Qv_rR_Bau0wec9BDP9RMfg.png" /></figure><p>如貼文所描述，Karpathy「煮」Prompt 的方式，就是進行一場輕鬆而漫長的碎念。他會透過語音，把腦中與需求有關的內容說出來，包含目標、顧慮、例外與過去試過的方法；這些內容可以重複、瑣碎、片段，就算前後矛盾或存在些許不合理也沒關係。總之，就是儘量把腦中與需求相關的資訊與脈絡倒出來。</p><p>這個方法的關鍵，在於避免事前過度加工腦中的資訊。就如同前言中提到的，若每個念頭都得先整理成完美的句子才能輸入，使用者可能會省略那些一時想不到該如何表達的背景；透過較自然的敘述，這些細節或許更容易被帶出來。</p><p>當然，如此一來，內容可能變得重複、矛盾，甚至混入一些最後並不重要的資訊；但這些瑕疵不必在輸入前就先被修正，因為這套做法會讓 LLM 將散亂的內容重新組織，並以較清楚的形式回述，再交由使用者確認。只是，LLM 並不一定能正確辨識其中的矛盾、衝突或雜訊，因此不能把整理結果直接視為正確答案。</p><p>細品，就會發現這個方法蘊含著「先發散，後收斂」的思考方式。</p><p>從這個角度來看，本文將這套做法整理成兩個階段。第一階段是資訊蒐集，採取發散式的方式，盡可能把腦中的背景、顧慮與想法倒出來；第二階段則是資訊彙整，由 LLM 從散亂的資訊中彙整、過濾，再輔以使用者的決斷，逐步從龐雜的資訊中辨識出關鍵內容。</p><p>可以說，這是一種新穎且有效的「煮」Prompt 方式，但它仍有其適用對象與限制。</p><p>第一是適用對象。當使用者已經對問題累積了不少經驗或直覺，卻還沒整理成規格；或任務背景很長，夾雜許多暫時無法判斷是否重要的細節；又或者一開始的目的不是立刻執行，而是想先請 LLM 幫忙整理思緒時，這種方式就很適合。若需求本身已經很明確，或任務只需要幾個清楚的參數，長篇敘述反而可能增加整理成本。</p><p>第二，長篇碎碎念也不會自動讓需求變得完整或正確。LLM 可以協助歸納與整理，從敘述中提取脈絡，但不能代替使用者做出尚未決定的判斷。若使用者本身對需求不夠明確，或是建立在錯誤的認知上，LLM 也可能整理出錯誤的內容，甚至把猜測補成看似確定的結論。因此，整理後的結果仍需要使用者逐一確認與修正。</p><p>更多關於 Karpathy 的 Ramble Session 的解析，可以參考「<a href="https://www.bnext.com.tw/article/91600/karpathy-voice-prompting-method">Karpathy 也推 Voice Prompting？從「說」到「做」：提示詞寫作的新趨勢</a>」。</p><h4>Matt Pocock 的 Grill Me</h4><p>介紹完 Karpathy 的 Ramble Session 後，接著來看看 Matt Pocock 的「/grill-me」。</p><p>這個方式的核心概念就如字面意思：「拷問我」。</p><p>Matt Pocock 提出的「/grill-me」，要求 AI 不要急著替使用者整理答案，而是針對需求中的各個環節與設計持續追問。只要細節、設計理由或決策分支中有不夠清楚的地方，就逐一提出問題；每次只處理一個問題，並針對問題提供建議與理由。若答案可以從專案脈絡中取得，例如說明文件或程式碼，AI 就應該先自行查證，而不是直接把問題丟回使用者，直到雙方逐步釐清需求為止。</p><p>這個方法的重點，是把「自己尚未意識到的未決事項」變成可見的問題。</p><p>以「新增登入功能」為例，真正會影響實作的，不只是是否需要登入頁面，還包括驗證方式、既有帳號來源、錯誤處理、權限模型、測試切點，以及本次不包含哪些功能。若一開始沒有對齊這些決策，AI 仍然可以很快產出程式碼，但產出的程式碼未必符合我們的需求；後續反覆修改，也可能造成疊床架屋，甚至讓文件與實際功能逐漸不一致。</p><p>進一步來說，「/grill-me」的用途是協助收斂決策，其目的一言以蔽之，就是拾遺補缺，也就是找出需求中的遺漏與缺口；它可以抓出目前脈絡中的缺漏、矛盾或不明確之處，避免這些問題在未來影響實作方向、成本或架構。</p><p>更重要的是，Matt Pocock 還提到一個延伸概念：「grill-with-docs」。它不只是在對話中釐清需求，也會同步查閱並更新專案文件，將決策、共用詞彙與重要脈絡留下來，避免共識只停留在單一對話裡。</p><p>簡單總結，「/grill-me」是一種透過逐題追問，協助人與 AI 對齊需求的「Prompt Engineering」方法；它不負責替使用者做決定，而是把尚未釐清的問題攤開，讓使用者在實作前補上必要的背景與決策。</p><h4>兩種方法的差異</h4><p>在簡單介紹了兩種不同的「Prompt Engineering」方法後，接著來比較兩者的差異。</p><p>顯而易見地，不管是 Karpathy 的 Ramble Session，還是 Matt Pocock 的 Grill Me，兩者的目標都是在對齊人與 LLM 之間的資訊，只是前者著眼於蒐集脈絡，後者則專注於消除歧異與不確定性。</p><p>那麼，兩者孰優孰劣呢？</p><p>其實這就像「張飛打岳飛」；兩人都是人類戰力巔峰，但所處時代不同。</p><p>仔細品味就會發現，雖然 Ramble Session 與 Grill Me 都是「Prompt Engineering」方法，目標也一致，但兩者適用的時間點並不相同：Ramble Session 適合在多數資訊都還停留在使用者腦中，需要從零開始建構脈絡時使用；Grill Me 則適合在 AI 已經掌握一定脈絡之後，用來找出使用者「自己尚未意識到的未決事項」，簡單來說就是釐清邊界。</p><p>換句話說，兩者想要解決的問題都是：「人與 LLM 的資訊沒有對齊」，只是作用時機點不同，一個負責先把脈絡盡量攤開，一個負責在脈絡具備後，把還沒說清楚的地方一一補上；所以兩者不是對立，而是可以共同作用於同一個工作流程，也就是先用碎碎念攤開脈絡，然後以 LLM 進行彙整，最後再用逐題追問收斂決策。</p><p>最後，筆者還是忍不住想要額外提醒大家一個觀念：不是每件事都要煮成大餐。我們應該根據目前需求狀態，彈性地調整工作流程，譬如在脈絡已經很清楚的情況下，就不需要再碎碎念，這不僅浪費 Token，更讓需求發散、焦點模糊。方法論的價值，不在於每次都遵守完整儀式，而在於知道不確定性位於哪裡：如果缺的是背景，就先補脈絡；如果缺的是決策，就先問問題；如果缺的是可重複使用的共識，就留下文件。依任務成本與風險調整火候，才是「煮 prompt」真正值得學的地方。</p><h4>補充</h4><p>就在筆者寫完這篇沒多久，就滑到了一篇很有意思的貼文，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1006/1*lE-YFKJ2ob4Ga0SO6xJkdA.png" /></figure><p>是不是心中突湧萬千草泥馬奔騰，沒想過「/grill me」能這麼使用。</p><p>筆者感覺 AI 會比真人還難纏；諸位求職者，RIP。</p><h3>參考資料</h3><ul><li><a href="https://www.bnext.com.tw/article/91600/karpathy-voice-prompting-method">Karpathy 也推 Voice Prompting？從「說」到「做」：提示詞寫作的新趨勢</a></li><li><a href="https://github.com/mattpocock/skills">Matt Pocock, skills</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e7b663308a74" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[在「Mac OS」上完整移除「IntelliJ IDEA」的設定檔、暫存檔]]></title>
            <link>https://rickbsr.medium.com/%E5%9C%A8-mac-os-%E4%B8%8A%E5%AE%8C%E6%95%B4%E7%A7%BB%E9%99%A4-intellij-idea-%E7%9A%84%E8%A8%AD%E5%AE%9A%E6%AA%94-%E6%9A%AB%E5%AD%98%E6%AA%94-a15911e6263e?source=rss-4a9adf38ab9------2</link>
            <guid isPermaLink="false">https://medium.com/p/a15911e6263e</guid>
            <category><![CDATA[jetbrains]]></category>
            <category><![CDATA[macos]]></category>
            <category><![CDATA[intellij-idea]]></category>
            <dc:creator><![CDATA[Rick]]></dc:creator>
            <pubDate>Wed, 31 Jan 2024 07:54:21 GMT</pubDate>
            <atom:updated>2026-08-13T07:30:21.676Z</atom:updated>
            <content:encoded><![CDATA[<h4>Mac 完整移除 IntelliJ IDEA 設定檔與暫存檔教學</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xv456g66NiMjeLlz" /><figcaption>Photo by <a href="https://unsplash.com/@cdr6934?utm_source=medium&amp;utm_medium=referral">Chris Ried</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3><strong>前言</strong></h3><p>之前由於某些原因，需要完整移除「MacBook」中的「IntelliJ IDEA」，一時間找不到它預設存放偏好設定檔、暫存檔的路徑，紀錄一下。</p><h3><strong>正文</strong></h3><p>提醒一下，筆者不能肯定所有版本的「IntelliJ IDEA」的設定檔、暫存檔的預設路徑都一致，印象中，好像有變更過，但不論如何，筆者目前使用的「IntelliJ IDEA」的版本是「2022.1.4」，其預設的存放位置一共有四個位置，如下：</p><pre># 「{username}」為「使用者帳號名稱」（即家目錄名稱，可以終端機執行「whoami」取得），而非「電腦名稱」。<br>rm -rf /Users/{username}/Library/Preferences/jetbrains.jetprofile.asset.plist<br>rm -rf /Users/{username}/Library/Caches/JetBrains<br>rm -rf /Users/{username}/Library/Application\ Support/JetBrains<br>rm -rf /Users/{username}/Library/Logs/JetBrains</pre><p>上述的三個路徑：「Caches/JetBrains」、「Application Support/JetBrains」，以及「Logs/JetBrains」，在部分版本中是所有「JetBrains」產品共用的上層目錄，直接刪除可能會連帶移除「PyCharm」、「WebStorm」等其他「JetBrains」IDE 的設定與快取。</p><p>然而，若只想移除「IntelliJ IDEA」，請改刪對應的子目錄，例如「~/Library/Application Support/JetBrains/IntelliJIdea2022.1」。</p><p>刪除前，也建議先關閉「IntelliJ IDEA」，並確認是否仍需要保留其他「JetBrains」IDE 的設定與外掛。</p><h3>參考資料</h3><ul><li><a href="https://www.jetbrains.com/help/idea/directories-used-by-the-ide-to-store-settings-caches-plugins-and-logs.html">Directories used by the IDE</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a15911e6263e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[淺談「設計原則」的「閱讀姿勢」]]></title>
            <link>https://rickbsr.medium.com/%E6%B7%BA%E8%AB%87%E8%A8%AD%E8%A8%88%E5%8E%9F%E5%89%87%E7%9A%84-%E9%96%B1%E8%AE%80%E5%A7%BF%E5%8B%A2-155acf6e491d?source=rss-4a9adf38ab9------2</link>
            <guid isPermaLink="false">https://medium.com/p/155acf6e491d</guid>
            <category><![CDATA[重構]]></category>
            <category><![CDATA[軟體開發]]></category>
            <category><![CDATA[設計原則]]></category>
            <category><![CDATA[物件導向]]></category>
            <category><![CDATA[程式碼品質]]></category>
            <dc:creator><![CDATA[Rick]]></dc:creator>
            <pubDate>Sat, 27 Jan 2024 02:56:54 GMT</pubDate>
            <atom:updated>2026-08-13T07:31:35.581Z</atom:updated>
            <content:encoded><![CDATA[<h4>如何閱讀設計原則：在不同情境中理解與取捨</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CCsGsDGsmFo2pOT2" /><figcaption>Photo by <a href="https://unsplash.com/@worldsbetweenlines?utm_source=medium&amp;utm_medium=referral">Patrick Hendry</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>有人說，「設計原則」就像是一種「經驗法則」，是前方大佬給我們的「告誡」；他們藉由這些「原則」告訴我們，應該如何才能撰寫出具有「高可維護性」的程式碼。</p><p>但就筆者的觀察，對於有些開發者而言，尤其是資歷較淺的開發者；「設計原則」就只是個「口號」，或是「告誡」。</p><p>有些「告誡」，它淺顯易懂，但「知道」跟「實踐」之間，完全是「鬆耦合」。</p><p>有些「告誡」，它貌似清晰，但卻不易理解，或存在「模糊邊界」，讓「經驗較為不足」的開發者容易陷入困惑。</p><p>有些「告誡」，它可能目標一致，但作法卻牴觸，「WTF」？</p><p>那怎樣才是閱讀「設計原則」最適合的「姿勢」呢？</p><h3>前言</h3><p>在開始文章之前，筆者想先與各位讀者建立一些共識：第一，本文討論的設計原則與觀念，皆以「物件導向」程式設計為背景。第二，雖然各種物件導向程式語言的概念大同小異，但彼此間仍存在差異；為避免溝通上的落差，本文中提到程式語言時，除非筆者另有說明，否則皆預設為「Java」。</p><p>在「軟體工程」領域中，存在著各種不同的「流派」；而不同流派對程式設計的「理念」、「見解」與「方法論」也各不相同。但若說對近代軟體工程影響最為深遠的流派，就不能不提到由「Robert Martin」、「Kent Beck」、「Martin Fowler」等大佬共同提倡的「敏捷聯盟」；許多耳熟能詳的設計原則，例如「SOLID」，正是由這群開發者陸續整理並推廣。</p><p>有人說，「設計原則」多半是一種「經驗法則」，是前方大佬給後輩的一些「告誡」；他們藉由傳遞這些「原則」來告訴我們：應該怎麼做才能撰寫出具有「高品質」的程式碼。</p><p>但不知道各位讀者有沒有想過，「設計原則」林林總總，除了可能彼此重複或部分重疊，甚至也可能相互衝突。對此，我們應該如何看待這些所謂的「設計原則」呢？</p><h3>正文</h3><h4>敏捷聯盟</h4><p>延續前言中提到的「敏捷聯盟」，關於「敏捷聯盟（Agile Alliance）」的起源，最早可以追溯至 2001 年；當時，包括「Robert Martin」、「Kent Beck」與「Martin Fowler」在內的 17 位軟體開發者，齊聚在美國猶他州的「Snowbird」滑雪度假村，討論各自實踐的「輕量級開發方法」。會議結束後，他們共同發表了「敏捷宣言（Manifesto for Agile Software Development）」，並進一步成立「敏捷聯盟」，作為推廣敏捷開發理念的非營利組織。</p><p>而所謂的「敏捷宣言」，指的是這群開發者當時共同撰寫的文件；內容由四項核心價值組成，分別強調「個人與互動」重於「流程與工具」、「可用的軟體」重於「詳盡的文件」、「與客戶合作」重於「合約協商」，以及「回應變化」重於「遵循計畫」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EByqS_pkNlitlQikc8a7Pw.png" /></figure><p>完整資訊可以參考「<a href="https://agilemanifesto.org/iso/en/manifesto.html">Manifesto for Agile Software Development</a>」。</p><p>事實上，「敏捷聯盟」並不是一個多麼具有約束力的組織，它不是傳統那種高高在上、訂立強制法規的官方機構，而是一個由理念驅動的交流平台；就像是如今的技術社群，大家是因為認同某種技術理念而聚集，而不是為了接受監管或執行硬性指令 — — 它不頒布律法，只是培育共同實踐的土壤。</p><h4>敏捷聯盟的那些大佬</h4><p>雖說「敏捷聯盟」並不是一個具有約束力的組織，但參與者多是在軟體界具有影響力的開發者。他們提出的許多軟體開發準則與理念，對後續的軟體開發領域有著深遠影響；例如廣為人知的「SOLID」原則，就由「Robert Martin」整理並推廣。「Robert Martin」是知名的軟體工程師、講師與作家，也是敏捷軟體開發的主要推廣者之一，經常使用的暱稱是「Uncle Bob」。他的經典著作包括「<a href="https://www.amazon.com/Software-Development-Principles-Patterns-Practices/dp/0135974445">Agile Software Development, Principles, Patterns, and Practices</a>」、「<a href="https://www.amazon.com/-/zh_TW/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882">Clean Code: A Handbook of Agile Software Craftsmanship</a>」、「<a href="https://www.amazon.com/-/zh_TW/Robert-Martin/dp/0134494164">Clean Architecture: A Craftsman’s Guide to Software Structure and Design</a>」與「<a href="https://www.amazon.com/Clean-Agile-Basics-Robert-Martin/dp/0135781868">Clean Agile: Back to Basics</a>」等。</p><p>額外補充一下，「SOLID」原則又被稱為物件導向程式設計的「五大原則」，其每個英文字母都代表一個設計原則：S 是 SRP（Single Responsibility Principle）、O 是 OCP（Open-Closed Principle）、L 是 LSP（Liskov Substitution Principle）、I 是 ISP（Interface Segregation Principle），D 是 DIP（Dependency Inversion Principle）。因此，SOLID 既可以指一組設計原則，也可以指其中的五個原則。</p><p>附帶一提，許多人都誤以為「SOLID」是「Robert Martin」所提出的，這並不全對；「SOLID」這個縮寫，其實是「Michael Feathers」在 2004 年提出的，用來把「Robert Martin」多年來陸續談過的幾個原則組合成一個好記的字母縮寫。而在這五個原則之中，「OCP」最早由「Bertrand Meyer」於 1988 年提出，「LSP」則是「Barbara Liskov」於 1987 年提出，兩者都早於「Robert Martin」的整理；只有「SRP」、「ISP」與「DIP」，才是由「Robert Martin」本人提出或整理的原則。</p><p>當然，除了「Robert Martin」之外，「敏捷聯盟」的其他成員也都有提出或提倡一些知名的理論，例如「Kent Beck」，他是「極限編程」的創始人之一，該方法強調「簡單設計」，可參考「<a href="https://wiki.c2.com/?XpSimplicityRules">XP Simplicity Rules</a>」；「Martin Fowler」則在著作「<a href="https://www.amazon.com/Refactoring-Improving-Existing-Addison-Wesley-Signature-ebook/dp/B07LCM8RG2">Refactoring: Improving the Design of Existing Code</a>」中介紹了「重構的三次原則」。</p><h4>什麼是「設計原則」？</h4><p>延續前言中的問題：我們該如何看待這些「設計原則」？</p><p>在回答這個問題之前，我們先來談談什麼是「設計原則」，以及它的本質是什麼。</p><p>在筆者看來，「設計原則」的本質其實就是一種「告誡」。</p><p>舉例來說，「Robert Martin」曾在他的個人部落格中發表過一篇文章，篇名為「The Principles of OOD」，內容講述關於「OOD」的一些原則。文中，「Robert Martin」表示，他所介紹的這些「OOD」原則，主要關注點都在於程式碼之間「依賴關係」的管理，原文如下：「The principles, however, focus very tightly on dependency management.」；接著他又說，若程式碼之間的「依賴關係」缺乏良好的管理，就會導致程式碼變得脆弱、難以維護及重用，原文描述如下：「Poor dependency management leads to code that is hard to change, fragile, and non-reusable.」。</p><p>我們簡單總結一下，根據「<a href="http://www.butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod">The Principles of OOD</a>」的內容，可以整理出「Robert Martin」想傳遞的訊息：若要開發出具有品質、且易於維護的「程式碼」，就應該遵循他提出的「開發原則」，留意程式碼之間的「依賴關係」，避免過度「耦合」的情況發生。</p><p>這段話是不是就像一種「告誡」，一種「Robert Martin」基於過去經驗而想傳遞給其他軟體開發者的告誡？</p><p>再者，根據「Robert Martin」的說法，其表示：這些 OOD 原則包含後來廣為人知的 SOLID 原則，其早期脈絡可追溯到他在 1995 年於「Google groups comp.object」上參與「The Ten Commandments of OO Programming」討論串時的回覆，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8ioTG5iaSlujm5c1LA0N8Q.png" /></figure><p>有注意到討論串的名稱嗎？</p><p>「Commandments」，其意思是「告誡」；事實上，這個討論串的內容就如其標題，是在討論一個「OO」開發者應該遵守的「Commandments」。</p><p>題外話，雖然前面提到「The Ten Commandments of OO Programming」中的回覆是後續許多論點的原型，但這並不是他第一次發表程式碼相互依賴關係的文章。早在這個討論串之前的 1994 年，「Robert Martin」就發表了「<a href="https://www.semanticscholar.org/paper/OO-Design-Quality-Metrics-Martin-October/18acd7eb21b918c8a5f619157f7e4f6d451d18f8">OO Design Quality Metrics</a>」論文，指出程式碼之間若缺乏良好的依賴關係管理，可能產生「僵化（Rigidity）」與「脆弱（Fragility）」等問題。</p><p>倘若各位讀者曾經閱讀過他的著作，應該就會發現，「Robert Martin」對於「相互依賴關係」非常的重視，這點在他一直以來的論述中都是如此，差別只在於「Robert Martin」在早期時，其觀點比較著重於「程式碼」本身，而到中期之後，就更多著眼在「系統架構」的層級；而「Robert Martin」最核心的「SOLID」原則亦在這個過程中不斷地昇華，關於「Robert Martin」的一些論點，未來若有機會，筆者會再另闢戰場，在此，我們暫時不過多著墨。</p><p>所以，如果有人問筆者，什麼是「設計原則」？</p><p>筆者的答案會是：「設計原則」是軟體開發人員進行程式設計時應遵循的準則，可能是一種概念、一種思維，甚至是經驗的總結；它通常較為抽象，不是一套可以直接套用的「SOP」。</p><p>舉例來說，「開放封閉原則（OCP）」只告訴我們，程式應該對擴充開放、對修改封閉，但具體該怎麼做，才能在新增功能時不去動到既有程式碼呢？</p><p>而至此就不得不提到「設計原則」的好搭檔：「設計模式」。</p><p>「設計模式」是針對特定情境、經過驗證且可重複套用的解決方案，通常有明確的角色、結構與實作步驟，例如「工廠模式」或「觀察者模式」，開發者可以直接參考範本落地實作。就像「工廠模式」，只要新增產品類型時改動的是新增的工廠與產品類別，不必修改既有的建立邏輯 — — 這正是「開放封閉原則」所要求的。換句話說，如果說「設計原則」是概念層次的方向，那麼「設計模式」就是可以直接落地執行的具體手段。</p><p>「設計原則」與「設計模式」兩者相輔相成：只了解設計原則而不懂設計模式的人，可能徒有想法卻不得其門，最後淪為空談；反之，只會設計模式而不懂設計原則的人，容易只具其形而不得其意，知其然而不知其所以然，最後落入過度設計的陷阱。</p><h4>面對「設計原則」的態度</h4><p>介紹完什麼是「設計原則」後，接著談談應該用什麼態度看待它。</p><p>上一小節提到，「設計原則」是前人給予我們的「告誡」。筆者無法保證這些告誡都正確，但能通過時間考驗、廣為人知的設計原則，通常有其道理。因此在大多數情況下，我們應該嘗試遵循並理解它們，相信這能幫助我們建立良好的開發觀念，少走一些彎路。</p><p>話雖如此，但設計原則如此之多，我們又該何去何從？</p><p>就如我們前面所說，「設計原則」是前人給予我們的「告誡」，但並非所有的「告誡」都是必須遵守的；隨著時代背景、技術框架、工具、語言特性、公司文化與專案規範的不同，經過時間汰選，真正適合的往往只是那些較廣泛流傳的幾個。</p><p>除此之外，理想總是豐滿，現實總是骨感，理想總難免會受制於現實的限制，例如時間成本。軟體開發過程中難免需要重構，包括調整架構、抽取共用邏輯或建立抽象；此外，開發者對業務的熟稔度也往往很大程度的影響程式架構的設計，譬如，兩段當下看起來完全相同的程式碼，若背後其實服務於不同的業務情境，未來很可能會因為各自的業務需求而走向不同的變化方向；若開發者對業務不夠熟悉，就可能誤把這兩段程式碼合併成共用邏輯，等到日後業務分歧時，才發現當初的抽象其實是一種「意外的重複」，反而得再花力氣把它們拆開。</p><p>再者，部分「設計原則」的論述較為籠統，或存在模糊的邊界，讓經驗較不足的開發者不易理解，從而造成誤會或困惑。</p><p>舉例來說，「Robert Martin」在早期對「單一職責原則（SRP）」的描述如下：「A class should have only one reason to change.」。</p><p>該段描述是源自於「<a href="https://www.amazon.com/Software-Development-Principles-Patterns-Practices/dp/0135974445">Agile Software Development, Principles, Patterns, and Practices</a>」一書，而這個「論述」，引起了眾多軟體開發者的抨擊，說其描述過於籠統、模糊，不夠明確；其中比較知名的如「Dan North」，他是「CUPID」原則的提出者，詳細內容可以參考其部落格文章：「<a href="https://dannorth.net/2022/02/10/cupid-for-joyful-coding/">CUPID — for joyful coding</a>」；此外，「Dan North」還是個「SOLID」原則的反對者，而在他所發表的言論中，不乏他對「SOLID」的「諷刺」，譬如「<a href="https://dannorth.net/cupid-the-back-story/">CUPID — the back story</a>」。</p><p>題外話，面對「Dan North」的質疑，「Robert Martin」也曾在他個人的部落格中公開回應，「Robert Martin」在回應裡更進一步地解釋「SOLID」原則中的每個原則的意義，完整內容請見「<a href="http://blog.cleancoder.com/uncle-bob/2020/10/18/Solid-Relevance.html">Solid Relevance</a>」。</p><p>說實話，比起「Dan North」的說法，筆者還是比較推崇「Robert Martin」的觀點，但這並不代表「Dan North」是在胡說八道，實際上，也正是因為有「Dan North」的質疑，我們才能更清楚了解「Robert Martin」想傳遞的「SOLID」原則。</p><p>筆者始終認為，「戰」不見得都是壞事。生活中難免會遇到觀點不同的人，此時只要保持理性與尊重，不妨與對方辯論，正所謂：「真理越辯越明」。</p><p>除了描述本身籠統之外，有些設計原則的問題不在文字，而在於缺乏明確的適用邊界，讓開發者難以判斷該不該用、該用到什麼程度。舉例來說，「合成／聚合複用原則（CARP）」。</p><p>這項原則主張在程式設計時，應儘量使用「組合」或「聚合」達成複用，而不是優先使用「繼承」，因為繼承關係可能提高程式碼之間的耦合度。它的英文是「Composition/Aggregation Reuse Principle」。這項原則的論述相當明確，但缺乏明確界線；經驗較少的開發者可能難以判斷使用時機，甚至誤以為不應該使用繼承。事實上並非如此，CARP 通常會與「里氏替換原則（LSP）」一起被提起：應儘量以組合或聚合替代繼承，但若確實需要使用繼承，則應遵循里氏替換原則。</p><p>CARP 著重於選擇組合、聚合或繼承來進行複用；如果選擇繼承，則需要遵循 LSP，才能維持替換上的一致性。兩者與 OCP 都關注耦合與擴充性，但不能直接說 CARP 與 LSP 都是 OCP 的實踐手段。</p><p>實際上，許多設計原則之間都存在關聯，例如「單一職責原則（SRP）」與「關注點分離原則（Separation of Concerns, SoC）」在某個層面上相似，只是 SoC 比 SRP 更抽象。關於 SRP 的細節，未來有機會再另文介紹。</p><p>但並非所有設計原則都像 CARP 與 LSP 一樣相輔相成，也不是都像 SRP 與 SoC 一樣部分重疊。各種理論之間也可能存在相互衝突的論述。</p><p>譬如「DRY」原則與「WET」原則。「DRY」的全名是「Don’t repeat yourself.」，意即「不要重複程式碼」；「WET」的全名是「Write everything twice.」，簡單地說就是把同樣的程式碼寫兩次。當然，或許有人聽過「We enjoy typing.」或「Waste everyone’s time」等諷刺意味較強的解讀，但不論如何，「DRY」與「WET」幾乎可以說是背道而馳的兩個原則。</p><p>其中，「DRY」原則是多數軟體開發者都耳熟能詳的設計原則。以筆者的軟體開發經驗來看，「避免重複程式碼」的觀念可說是根深蒂固；「重複程式碼（Duplicate code）」不僅是程式設計中惡名昭彰的「壞味道（Bad Smell）」之一，也可能導致另一種壞味道：「霰彈式修改（Shotgun surgery）」。</p><p>但仔細思考一下，「WET」就真的沒道理嗎？</p><p>美國軟體工程師「Sandi Metz」曾說過：「Duplication is cheaper than the wrong abstraction.」從字面上看，她認為「重複程式碼」產生的技術債，比「錯誤的抽象（Wrong abstraction）」造成的技術債更低廉。更多內容請參考她的部落格文章：「<a href="https://sandimetz.com/blog/2016/1/20/the-wrong-abstraction">The Wrong Abstraction</a>」。</p><p>延伸這個觀點，軟體工程師「Kent Dodds」介紹了「AHA Programming」概念。AHA 代表「Avoid Hasty Abstractions」，也就是「避免過早抽象」；他在文章中也說明，這個縮寫是從「Cher Scarlett」的用法而來。詳見「<a href="https://kentcdodds.com/blog/aha-programming">AHA Programming</a>」。</p><p>除了「WET」之外，「DRY」也與「三次重構原則（Rule of Three）」存在部分牴觸。「三次重構原則」由「Don Roberts」提出，並由「Martin Fowler」推廣，原文描述為：「Three strikes and you refactor.」意思很直白：如果一段程式碼重複了三次以上，就應該將它重構。不過，只有兩次呢？</p><p>另外一個常被提及的設計原則是「KISS」，通常解作「Keep it simple, stupid.」。意思很直白，就是保持程式碼簡單、易懂；其中的「stupid」與「傻瓜相機」的「傻瓜」、「防呆裝置」的「呆」相似，並非貶義，而是指在閱讀與使用上都很容易。</p><p>若遵循 DRY 原則，遇到共用邏輯時就應該將它抽取出來；但如果這段程式碼只有兩個使用處呢？我們真的有必要特地抽取嗎？</p><p>是否保留「重複程式碼」會更貼近「KISS」所闡述的「Simple &amp; stupid」呢？</p><p>我們思考一下，「重複程式碼」真的那麼萬惡嗎？</p><p>並不盡然。正如「<a href="https://www.amazon.com/Five-Lines-Code-When-Refactor/dp/B09NCHWVG1">Five Lines of Code: How and when to refactor</a>」一書的作者「Christian Clausen」所描述，「重複程式碼」能增加區域性行為改變的速度，原文如下：「Sharing code increases global behavior-change velocity, while duplicating code increases local behavior-change velocity.」近幾年隨著微服務盛行，「DRY」似乎已經不再是鐵則。微服務是一種分散式軟體架構，與傳統的單體式應用不同；在微服務概念中，一個完整的應用程式由多個小型服務構成，每個服務都是可以獨立運行的單位，服務之間保持鬆耦合，甚至擁有各自獨立的資料庫。</p><p>在這個概念下，共用程式碼的代價可能變得更加昂貴。正如「<a href="https://blog.bitsrc.io/the-dilemma-of-code-reuse-in-microservices-a925ff2b9981">The Dilemma of Code Reuse in Microservices</a>」一文所描述，在微服務架構中，不當的共用程式碼可能破壞各服務的獨立性。</p><p>讀到這裡應該可以發現，不論是 DRY、WET、KISS 還是 Rule of Three，都有其存在的道理。它們之所以看似抵觸，可能是因為環境不同，例如單體式應用與微服務架構的差異；也可能是思考角度不同。仔細思考就會發現，它們的目標其實一致，都是提高程式碼的可維護性。</p><p>所以，我們該如何看待「設計原則」呢？</p><p>說到底，仍然要取決於目的與環境，例如專案的規模與性質，而不是一味將某些設計原則奉為圭臬。程式設計從來就沒有唯一解，正如「林信良」在「<a href="https://www.ithome.com.tw/voice/97462">設計原則五四三</a>」中所描述，死抱著 SOLID 原則、試圖完美遵守，問題在於程式碼不存在所謂的完美設計。</p><p>在「<a href="https://www.amazon.com/-/zh_TW/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882">Clean Code: A Handbook of Agile Software Craftsmanship</a>」一書中，作者「Robert Martin」曾說，比起技術教科書，這本書更像是一門關於軟體開發的藝術教科書；筆者認為，設計原則也是如此。</p><p>那什麼是「藝術」？</p><p>筆者曾聽過有人如此形容：藝術是一個追求完美的過程，會不斷迭代，也不存在終點。</p><p>程式設計不也就如此嗎？</p><p>不同專案的程式設計標準本來就應該有所不同；即使在同一個專案中，「Context」與「Boundary」也會隨著進度與需求變化。當需求異動時，我們必須重新審視目前的設計與架構是否仍符合需求；如果不符合，就應該修正甚至重構，而不是只顧開發功能，讓既有結構不斷疊床架屋。</p><p>「<a href="https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124">Head First Design Patterns: A Brain-Friendly Guide</a>」一書中有一段經典描述：在軟體開發領域，唯一不變的真理就是「改變」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yrIFo04m2-XF_Ddm3Ufc3A.png" /></figure><h4>程式碼風格</h4><p>最後，筆者還是不免俗地想要談一下：「程式碼風格（Coding Style）」。</p><p>事實上，我們可以將程式碼風格視為一種設計原則，也就是撰寫程式碼時遵循的規範。</p><p>如前面所說，程式設計不存在所謂的完美程式碼；多數設計原則與程式碼規範，都是為了讓程式碼更容易理解與維護。</p><p>大多數專案都無法避免與他人合作，不論是共同開發或接手維護，因此需要遵守共同規範，讓合作者更容易開發與維護。企業團隊通常會制定自己的程式碼規範；即使沒有，也能在網路上找到許多知名企業提供的守則，例如 Oracle 的「<a href="https://www.oracle.com/java/technologies/javase/codeconventions-contents.html">Code Conventions for the Java™ Programming Language</a>」、Google 的「<a href="https://google.github.io/styleguide/javaguide.html">Google Java Style Guide</a>」、Alibaba 的「<a href="https://github.com/alibaba/Alibaba-Java-Coding-Guidelines">Alibaba-Java-Coding-Guidelines</a>」與「<a href="https://github.com/alibaba/p3c">Alibaba Java Coding Guidelines pmd implements and IDE plugin</a>」。閱讀這些守則便會發現，它們的內容大同小異；與其說是規則，不如說更像開發者之間的共識。</p><p>不過，有些企業團隊的程式碼守則制定得比較詳細，甚至可能與上述共識有所衝突。這是因為團隊在制定規則時，可能考量了成員的習慣、共識或專案特性。此時，我們就應該以團隊規範為最高準則。</p><h3>參考資料</h3><ul><li><a href="https://www.amazon.com/Software-Development-Principles-Patterns-Practices/dp/0135974445">Robert Martin, Agile Software Development, Principles, Patterns, and Practices</a></li><li><a href="https://www.amazon.com/-/zh_TW/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882">Robert Martin, Clean Code: A Handbook of Agile Software Craftsmanship</a></li><li><a href="https://www.amazon.com/-/zh_TW/Robert-Martin/dp/0134494164">Robert Martin, Clean Architecture: A Craftsman’s Guide to Software Structure and Design</a></li><li><a href="https://www.amazon.com/Clean-Agile-Basics-Robert-Martin/dp/0135781868">Robert Martin, Clean Agile: Back to Basics</a></li><li><a href="http://www.butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod">Robert Martin, The Principles of OOD</a></li><li><a href="https://www.semanticscholar.org/paper/OO-Design-Quality-Metrics-Martin-October/18acd7eb21b918c8a5f619157f7e4f6d451d18f8">Robert Martin, OO Design Quality Metrics</a></li><li><a href="http://blog.cleancoder.com/uncle-bob/2020/10/18/Solid-Relevance.html">Robert Martin, Solid Relevance</a></li><li><a href="https://wiki.c2.com/?XpSimplicityRules">Kent Beck, XP Simplicity Rules</a></li><li><a href="https://www.amazon.com/Refactoring-Improving-Existing-Addison-Wesley-Signature-ebook/dp/B07LCM8RG2">Martin Fowler, Refactoring: Improving the Design of Existing Code</a></li><li><a href="https://groups.google.com/g/comp.object/c/WICPDcXAMG8/m/EbGa2Vt-7q0J">Google groups comp.object, The Ten Commandments of OO Programming</a></li><li><a href="https://dannorth.net/2022/02/10/cupid-for-joyful-coding/">Dan North, CUPID — for joyful coding</a></li><li><a href="https://dannorth.net/2021/03/16/cupid-the-back-story/">Dan North, CUPID — the back story</a></li><li><a href="https://sandimetz.com/blog/2016/1/20/the-wrong-abstraction">Sandi Metz, The Wrong Abstraction</a></li><li><a href="https://kentcdodds.com/blog/aha-programming">Kent Dodds, AHA Programming</a></li><li><a href="https://makeoptim.com/training/composite-reuse-principle/">Make Optim, 合成／聚合複用原則</a></li><li><a href="https://ithelp.ithome.com.tw/m/articles/10236782">iThome, 合成／聚合複用原則</a></li><li><a href="https://www.amazon.com/Five-Lines-Code-When-Refactor/dp/B09NCHWVG1">Christian Clausen, Five Lines of Code: How and when to refactor</a></li><li><a href="https://blog.bitsrc.io/the-dilemma-of-code-reuse-in-microservices-a925ff2b9981">Ashan Fernando, The Dilemma of Code Reuse in Microservices</a></li><li><a href="https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124">Eric Freeman, Head First Design Patterns: A Brain-Friendly Guide</a></li><li><a href="https://www.ithome.com.tw/voice/97462">林信良, 設計原則五四三</a></li><li><a href="https://www.oracle.com/java/technologies/javase/codeconventions-contents.html">Oracle, Code Conventions for the Java™ Programming Language</a></li><li><a href="https://google.github.io/styleguide/javaguide.html">Google, Google Java Style Guide</a></li><li><a href="https://github.com/alibaba/Alibaba-Java-Coding-Guidelines">Alibaba, Alibaba-Java-Coding-Guidelines</a></li><li><a href="https://github.com/alibaba/p3c">Alibaba, Alibaba Java Coding Guidelines pmd implements and IDE plugin</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=155acf6e491d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[淺談「錯誤的抽象」]]></title>
            <link>https://rickbsr.medium.com/%E6%B7%BA%E8%AB%87-%E9%8C%AF%E8%AA%A4%E7%9A%84%E6%8A%BD%E8%B1%A1-28c0adbf792e?source=rss-4a9adf38ab9------2</link>
            <guid isPermaLink="false">https://medium.com/p/28c0adbf792e</guid>
            <category><![CDATA[重構]]></category>
            <category><![CDATA[重複程式碼]]></category>
            <category><![CDATA[錯誤的抽象]]></category>
            <dc:creator><![CDATA[Rick]]></dc:creator>
            <pubDate>Fri, 26 Jan 2024 16:06:26 GMT</pubDate>
            <atom:updated>2026-08-13T07:41:38.718Z</atom:updated>
            <content:encoded><![CDATA[<h4>從「錯誤的抽象」談重複程式碼與重構</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XLI0qepLPAMDhiJg" /><figcaption>Photo by <a href="https://unsplash.com/@lishakov?utm_source=medium&amp;utm_medium=referral">Andrej Lišakov</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>我達達的馬蹄是美麗的錯誤</p><p>我不是歸人，是那匹「碼」</p><h3>前言</h3><p>在「2014」年的「RailsConf」中，美國工程師「Sandi Metz」談到了「錯誤的抽象」這個概念。她認為，「重複程式碼（Duplicated Code）」所造成的「技術債」，比起「錯誤的抽象」所造成的「技術債」更「低廉」。因此，她寧願接受「重複程式碼」的存在，也不願冒著形成「錯誤的抽象」的風險。完整內容請參考「<a href="https://www.youtube.com/watch?v=8bZh5LMaSmE">RailsConf 2014 — All the Little Things by Sandi Metz</a>」。</p><p>從「Sandi Metz」的敘述中可以得知，她認為「錯誤的抽象」會造成相對昂貴的「技術債」，其代價甚至高於保留「重複程式碼」所產生的代價。</p><p>在筆者以往的經驗中，「重複程式碼」一直是相當糟糕的事情。將一段程式碼「複製」後，粗暴地「黏貼」到其他地方，使相同的程式碼出現在同一個專案中的兩處，甚至多處，無疑是撰寫程式碼時的「禁忌」。不少前輩都告誡我們應該盡量避免這種行為，耳熟能詳的「DRY」原則就是其中之一。其全文為「Don’t repeat yourself.」，也就是告訴我們「不要」重複程式碼。這是因為「重複程式碼」不僅會讓程式碼變得冗長，還可能因為相同的程式邏輯散佈在專案各處，而導致「霰彈式修改（Shotgun Surgery）」；也因此，在筆者的認知中，「重複程式碼」一直都是不應該被容許的。</p><p>但如今，忽然有人告訴我：寧願接受「重複程式碼」的存在，也不要冒著形成「錯誤的抽象」的風險。這不禁讓筆者好奇：什麼是「錯誤的抽象」，它又到底有多糟糕？</p><p>所以，今天我們就來談談「Sandi Metz」口中的「錯誤的抽象」。</p><h3>正文</h3><h4>錯誤的抽象</h4><p>什麼是「錯誤的抽象」？</p><p>在「<a href="https://sandimetz.com/blog/2016/1/20/the-wrong-abstraction">The Wrong Abstraction</a>」一文中，「Sandi Metz」舉了一個例子來解釋她所稱的「錯誤的抽象」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/717/1*dx9aWibszg4x_dNHabv9KA.png" /></figure><p>根據其內容的敘述，筆者認為，「Sandi Metz」所謂的「錯誤的抽象」，並不是單純指抽象本身寫得「亂七八糟」且「邏輯不清」，而是指原本合理的抽象，在需求變化後被不斷加入參數與條件分支，最後變得難以理解。</p><p>事實上，「Sandi Metz」所描述的現象，在軟體開發領域中相當常見；多人合作的開發模式，可能會放大這個問題。不同的開發者通常存在一些差異，譬如「程度的落差」、「習慣的不同」，以及「思維的歧異」等。當既有抽象被視為不可更動時，這些差異就可能讓後續需求以參數與條件分支的形式堆疊在原有程式碼上。</p><p>「不同人共同開發」並非無法改善。透過員工「教育訓練」、制定完整的「開發規範」，以及使用較容易上手的技術框架，都能在一定程度上減少多人合作所造成的程式碼紊亂。</p><p>除了「不同人共同開發」之外，筆者認為，這也可以連結到「過早的抽象」這個議題。專案開發初期，開發人員通常還不了解專案全貌；在這種情況下，若貿然進行架構設計，當下的程式架構可能無法滿足未來的需求，最後迫使我們為了因應新需求而重構既有架構，甚至形成「疊床架屋」的局面。</p><p>知名電腦科學家「Donald Knuth」曾談過「過早的優化（Premature Optimization）」；這段話原本是針對優化行為，筆者在此將它類比到「過早的抽象」的情境，其原文如下：</p><blockquote>The real problem is that programmers have spent far too much time worrying about efficiency in the wrong places and at the wrong times; premature optimization is the root of all evil (or at least most of it) in programming.</blockquote><p>因此，有些人開始提倡避免「過早的優化」，並將這個觀念延伸到「過早的抽象」。他們認為，在某些情況下，我們應該允許一定程度的「重複程式碼」。這種做法雖然可能讓程式碼稍嫌「冗餘」，但至少能維持程式碼的「簡單」與「直覺」，也符合「KISS」原則；「KISS」是「Keep it simple, stupid.」的縮寫。</p><p>題外話，雖然「過早的優化」聽起來似乎有其道理，但何謂「過早」？或者反過來問，到底什麼時候才是適合優化的時機？</p><p>對於這個問題，由「Don Roberts」提出、並經「Martin Fowler」在著作中引述的「三次重構原則（Rule of Three）」，或許就是一個不錯的選擇。這是一個簡單、直接，也容易用來判斷「重複程式碼」是否該「重構」的標準，詳見「<a href="https://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672">Refactoring: Improving the Design of Existing Code</a>」。其全文為：「Three strikes and you refactor.」簡單地說，就是「重複三次，就重構」。</p><p>但「三次重構原則」並不是絕對的。事實上，筆者覺得「重構」的「最佳時機」，會因專案特性、團隊習慣等因素而有所不同；只是在毫無頭緒時，「三次重構原則」是一個很不錯的起點。</p><p>關於「過早的優化」這個議題，未來倘若有機會，筆者會再另闢篇幅。現在，我們先將焦點放回「錯誤的抽象」上。若從「過早的抽象」這個角度解讀，「錯誤的抽象」確實可能造成比「重複程式碼」更高的「技術債」，所以「Sandi Metz」認為，與其承擔「錯誤的抽象」可能產生的代價，不如先接受「重複程式碼」。</p><p>上述這段話乍聽之下很合理，但不知道大家有沒有察覺出一個問題？</p><p>到底是「過早的抽象」導致了「錯誤的抽象」，還是「過早的抽象」經過多次「疊床架屋」的改動後，才逐漸變成「錯誤的抽象」？</p><p>兩者不應該混為一談。正如「Jason Swett」在「<a href="https://www.codewithjason.com/duplication-cheaper-wrong-abstraction/">Why I don’t buy “duplication is cheaper than the wrong abstraction”</a>」一文中的描述，他認為「Sandi Metz」所稱的「錯誤的抽象」，只是「壞程式碼（Bad Code）」的「代名詞」。如果一段程式碼本來就「亂七八糟、邏輯不清」，那麼無論它是否經過「抽象化」，都只是「壞程式碼」。原文如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/635/1*wQ1TS4HEjNc2LNzM4fO5Hw.png" /></figure><p>筆者其實比較認同這個觀點。</p><p>就筆者的角度而言，我不認為「錯誤的抽象」是「過早的抽象」直接造成的結果；它應該是「疊床架屋」的結果，是開發人員沒有持續迭代與重構的結果。</p><p>事實上，「優化」應該是「軟體開發」過程中持續進行的工作。我們應該在程式碼尚未變得「亂七八糟、邏輯不清」以前就進行「重構」，而不是等到它變成一團「混亂」後，才稱呼它為「錯誤的抽象」。</p><p>或許有人會說，持續重構需要付出相當的成本，尤其在缺乏完整的自動化測試、既有架構缺乏彈性，或程式碼耦合度過高的情況下。當然，也可能只是因為不熟悉程式碼，例如在多人開發時，還不了解合作夥伴所撰寫的內容。</p><p>但就如同「Jason Swett」所說，不論程式人員不願「重構」的理由是什麼，處理方式都應該是解決問題的根源，例如補上測試程式碼、在合理的條件下調整原有架構，或建立程式碼審查制度，而不是放任「重複程式碼」持續增加。</p><p>接著，我們簡單地討論一下，應該如何看待「重複程式碼」。</p><p>以筆者的觀點來看，「重複程式碼」並不是完全不能存在。在某些前提下，「重複程式碼」不一定糟糕，也是可以接受的。</p><p>但這與「Sandi Metz」談論「錯誤的抽象」時的出發點不同。在筆者的認知裡，「優化」是一個持續進行的過程；不論在「開發時期」或「維護時期」，只要有需要，我們就應該持續「迭代」與「重構」，而不是放任程式碼發展到「亂七八糟、邏輯不清」時，再將責任推給「過早的抽象」。</p><p>筆者曾經聽過一句相當認同的話：「程式的設計是必然的，但是不能因為擔心專案需求會改動，就乾脆不做程式設計；事實上，沒有設計本身就是最糟糕的設計。」當我們發現目前的程式架構無法滿足需求時，就應該進行重構，而不是為了貪圖方便而讓架構繼續疊床架屋。</p><p>這句話放在「抽象化」上也同樣適用：「抽象化是必然的，但是不能因為擔心專案需求會改動，就乾脆不要抽象化。」事實上，抽象化就是程式設計的一種形式。</p><h4>抽象化</h4><p>最後，筆者補充一些「抽象化」的議題。「抽象化」是「程式設計」中常見的手段，也是我們用來「優化」程式碼的方式。此外，「重構」通常是指改善程式碼的過程，但不一定要將程式碼「抽象化」，也可能反其道而行。這就如同「林信良」在「面對抽象雙面刃」中的敘述：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*cZLz8FiWcC2Mhjdz8ddkNw.png" /></figure><p>「抽象化」一直存在一些爭論，著名的「抽象滲漏原則（The Law of Leaky Abstractions）」就是其中之一。該原則由「Joel Spolsky」提出，詳見「<a href="https://www.joelonsoftware.com/2002/11/11/the-law-of-leaky-abstractions/">The Law of Leaky Abstractions</a>」或「<a href="https://www.amazon.com/-/zh_TW/Joel-Spolsky/dp/1590593898">Joel on Software: And on Diverse and Occasionally Related Matters That Will Prove of Interest to Software Developers, Designers, and Managers, and to Those Who, Whether by Good Fortune or Ill Luck, Work with Them in Some Capacity</a>」。</p><p>此外，也可以參考「林信良」的「<a href="https://www.ithome.com.tw/voice/139011">另眼看抽象滲漏</a>」。</p><h3>參考資料</h3><ul><li><a href="https://www.youtube.com/watch?v=8bZh5LMaSmE">RailsConf 2014 — All the Little Things by Sandi Metz</a></li><li><a href="https://sandimetz.com/blog/2016/1/20/the-wrong-abstraction">Sandi Metz, The Wrong Abstraction</a></li><li><a href="https://www.codewithjason.com/duplication-cheaper-wrong-abstraction/">Jason Swett, Why I don’t buy “duplication is cheaper than the wrong abstraction”</a></li><li><a href="https://www.joelonsoftware.com/2002/11/11/the-law-of-leaky-abstractions/">Joel Spolsky, The Law of Leaky Abstractions</a></li><li><a href="https://www.amazon.com/-/zh_TW/Joel-Spolsky/dp/1590593898">Joel on Software: And on Diverse and Occasionally Related Matters That Will Prove of Interest to Software Developers, Designers, and Managers, and to Those Who, Whether by Good Fortune or Ill Luck, Work with Them in Some Capacity</a></li><li><a href="https://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672">Martin Fowler, Refactoring: Improving the Design of Existing Code</a></li><li><a href="https://www.ithome.com.tw/voice/106025">林信良, 面對抽象雙面刃</a></li><li><a href="https://www.ithome.com.tw/voice/139011">林信良, 另眼看抽象滲漏</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=28c0adbf792e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[淺談「重覆程式碼」]]></title>
            <link>https://rickbsr.medium.com/%E6%B7%BA%E8%AB%87-%E9%87%8D%E8%A6%86%E7%A8%8B%E5%BC%8F%E7%A2%BC-fdc45d4990fc?source=rss-4a9adf38ab9------2</link>
            <guid isPermaLink="false">https://medium.com/p/fdc45d4990fc</guid>
            <category><![CDATA[軟體開發]]></category>
            <category><![CDATA[重構]]></category>
            <category><![CDATA[程式設計]]></category>
            <dc:creator><![CDATA[Rick]]></dc:creator>
            <pubDate>Fri, 26 Jan 2024 15:46:23 GMT</pubDate>
            <atom:updated>2026-08-13T07:44:26.446Z</atom:updated>
            <content:encoded><![CDATA[<h4>淺談「重覆程式碼」：共用，還是保留？</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6unuwixD86ag0tV8" /><figcaption>Photo by <a href="https://unsplash.com/@judithprins?utm_source=medium&amp;utm_medium=referral">Judith Prins</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>就算殺了一個我，還有千千萬萬個我。</p><h3>前言</h3><p>幾天前，「Teddy」在「搞笑談軟工」發佈了一篇貼文；在貼文中，「Teddy」說，他最近讀了一本書為「<a href="https://www.amazon.com/Five-Lines-Code-when-refactor/dp/161729831X">Five Lines of Code: How and when to refactor</a>」，而他認為書中對於「重覆程式碼（Duplicated Code）」的見解相當有道理，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w1snxM3neWTlnXbYw-Vk8A.png" /></figure><p>事實上，也就如貼文中所述，近年來由於「微服務架構」的盛行，透過讓相同的程式碼「重覆」存在於不同的組件中，以此來減少程式組件之間「依賴」的方式越發常見。</p><p>不過這種方式與過往的軟體開發觀念相互牴觸，在過去，「重覆程式碼」是一個相當負面的詞，其不僅會降低程式碼的「可維護性」，還可能會損害「程式架構」的穩定性；「<a href="https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882">Clean Code: A Handbook of Agile Software Craftsmanship</a>」一書的作者「Robert Martin」就曾說過，他認為，「重覆程式碼」是一種程式的「壞味道（Bad Smell）」。</p><p>但為什麼現在人們開始接受「重覆程式碼」了呢？</p><p>對於這個問題，「Teddy」認為，「Christian Clausen」在「<a href="https://www.amazon.com/Five-Lines-Code-when-refactor/dp/161729831X">Five Lines of Code: How and when to refactor</a>」一書中的解釋相當獨到；「Christian Clausen」認為，使用「共用程式碼」的方式可以增加「全域」異動的速度，而使用「重覆程式碼」的方式則是可以提高「局部」異動的速度，原文如下：</p><blockquote><em>Sharing code increases global behavior-change velocity, while duplicating code increases local behavior-change velocity.</em></blockquote><p>對於該描述，「Teddy」用生物學中的「特有種」來譬喻，他說，在生物學中有一個名詞叫「特有種」，其是指，同一物種，因隔離成獨立的不同族群，最後因為各自的生存環境不同進而演化出各自獨特的「性徵」的情況；「Teddy」說，程式碼也是如此，同樣一段「程式邏輯」，其可能會因為使用的地方不同，而需要一些額外且獨有的邏輯，詳見「<a href="http://teddy-chen-tw.blogspot.com/2023/01/blog-post.html">也許我不會刪除你：重複程式碼不等於壞味道</a>」，原文描述如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nhAmdFy1fpwTF_dpNFZSQQ.png" /></figure><p>對於「Teddy」的這段描述，筆者深以為然，舉例來說，在銀行的系統中，「櫃檯人員」使用的「端末系統」與一般客戶使用的「網路銀行」就明顯地存在「區域性差異」，譬如，「現金」相關的操作就是其中之一，因為「網路銀行」無法接受「現金」，所以它就無法操作與「現金」相關的交易，以「轉帳」來說，若使用「網路銀行」操作「轉帳」，「扣款帳號」就會是一個必要的參數，但若以「臨櫃」來說，其就會因為可以使用「現金」，而使得「扣款帳號」不再必要。</p><p>在上述的例子中，若我們要「網路銀行」與「端末系統」能使用同一個「轉帳」的程式邏輯，那麼我們就必須在該段程式碼中加入一些必要的判斷式，但如此一來，其多少都會提高該段「程式碼」的複雜度，倘若過度，甚至可能會導致該段「程式碼」的「可維護性」降低；反之，若我們將「網路銀行」的「轉帳」與「端末系統」的「轉帳」分為兩個「服務」，並讓它們擁有各自獨立的程式碼，那麼我們就可以避免這種為了因應「區域性」差異而存在的程式碼，但同樣的，同為「轉帳」功能，其必然存在許多相同的部分，而該些部分就會面臨「重覆程式碼」的議題。</p><p>所以，我們就要來談談，如何對待「重覆程式碼」。</p><p>其實筆者最近的工作項目恰巧是負責一大型「微服務專案」的「程式架構」的「規劃」與「審查」，為此，筆者已經燒死不少腦細胞，尤其在「重覆程式碼」的議題，更是讓筆者反覆思量許久；由於「微服務架構」的關係，使得「共用程式碼」的成本變得更高，因此，在專案的領域切分，或是架構設計，都必須更為考究；所以，我們今天就來談一談重覆程式碼「抽取」的標準。</p><h3>正文</h3><h4>「重覆」或「共用」</h4><p>開門見山的說，就如同「DRY」原則的描述：</p><blockquote><em>Don’t repeat yourself.</em></blockquote><p>在大原則下，筆者仍然認為：「重覆程式碼」是不應該被允許的。</p><p>在筆者過去的經驗中，「重覆程式碼」是一種在軟體開發時相當常見的情況，導致其發生的原因很多，譬如「歷史的包袱」、「多人共同開發」、「時程的過度擠壓」，甚至是「開發者的素質」都是；但不管成因為何，毫無疑問地，「重覆程式碼」顯然不是一件好事，它不僅是讓程式碼顯得「冗餘」，還會導致另外一個「壞味道」：「霰彈式修改（Shotgun Surgery）」，一言以蔽之，就是「到處都是」；譬如說，我們將資料庫連線的資訊撰寫在各個有使用到的類別中，如此一來，倘若當資料庫的連線資訊改變時，其就會發生我們必須分別地將所有有存放資料庫連線資訊的類別都進行修改，先不說其費時費力，萬一修改時發生遺漏，那麼就會導致程式的錯誤；而「重覆程式碼」亦是同理，當一段相同的程式邏輯出現在多個不同的地方時，此時，萬一該段程式碼的邏輯需要異動，那麼，我們就同樣地會面臨到須對所有的「重覆程式碼」都進行同樣修改的情況。</p><p>因此，筆者始終認為，「重覆程式碼」是不應該被允許的；但這並不是說，我們需要將「重覆程式碼」視為萬惡淵藪、毒蛇猛獸，事實上，倘若盲目地遵守「DRY」原則，其可能就衍伸出另外一個問題，「過早的抽象（Premature Abstraction）」。</p><p>何謂「過早的抽象」？</p><p>簡單的說，就是在不夠清楚專案全貌時，就將「程式碼」給「架」進了「設計的框」；關於該議題，網路上其實有著不少的相關討論，譬如「<a href="https://softwareengineering.stackexchange.com/questions/386570/what-is-premature-abstraction">What is “premature abstraction”?</a>」、「<a href="https://softwareengineering.stackexchange.com/questions/65690/solid-vs-avoiding-premature-abstraction">SOLID vs. Avoiding Premature Abstraction</a>」。</p><p>而這樣會有什麼的問題呢？</p><p>試想，當專案隨著時間的推移，其可能會「增加」新的功能，也可能會「修改」既有的功能，但不論何者，它們都可能會使專案的「Context」或「Boundary」產生變化；此時，原先「設計的框」就可能會出現不敷「新邏輯」使用的情況；換句話說，就是「新需求」使得「程式碼」的邏輯超出既有程式架構所預期的「框」。</p><p>這聽起來很糟，但是這種情況卻是相當的常見，因為沒有人能夠提前知道專案最終的情況，即便是相當專業的應用架構師；雖然在規劃程式架構時，其通常會盡可能地保有架構的彈性、擴展性，但這也是有限度的，不能盲目地「無限上綱」，否則就可能會落入「過度設計」的「胡同」之中，關於「過度設計」的議題可以參考「<a href="https://www.ithome.com.tw/voice/91845">探索真正的需要，避免過度工程化</a>」。</p><p>然而，在多數情況下，「新需求」都是必須執行的，即使在新的「業務邏輯」會破壞既有的框架的情況下亦然，所以，通常我們也只能被迫在「疊床架屋」或「重構」之間做選擇，前者，我們將會產生一定程度的「技術債」，或許不用在當下立刻償還，但其終究是「潛在成本」，而後者就更不用說了，「重構」就是「成本所在」。</p><p>那如何解決上述的問題呢？</p><h4>重構的最佳時機</h4><p>若我們仔細思考，其實很容易就會發現，上述的問題在於「過早（Premature）」，而非「優化」，也就是「時機點」不對；事實上，關於「過早的優化（Premature Optimization）」，知名電腦科學家「Donald Knuth」就曾說過：「過早的優化」，是萬惡的根源，更是導致「成本」大幅提高的主要兇手，其原文如下：</p><blockquote><em>The real problem is that programmers have spent far too much time worrying about efficiency in the wrong places and at the wrong times; premature optimization is the root of all evil (or at least most of it) in programming.</em></blockquote><p>那哪時候是適合的「時機點」呢？</p><p>對於該問題，由「Don Roberts」提出、並經「Martin Fowler」在其著作中引述的「三次重構原則（Rule of Three）」，就是相當簡單、直接，且容易用來判斷「重覆程式碼」是否該「重構」的方法之一；「三次重構原則」的定義如下：</p><blockquote><em>Three strikes and you refactor.</em></blockquote><p>其意思是說，在開發的過程中，當第三次碰到需要相同邏輯的程式碼時，我們就將之「重構」；詳見其著作：「<a href="https://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672">Refactoring: Improving the Design of Existing Code</a>」；雖然「三次重構原則」是一個相當簡單、易懂，用於判斷是否該「重構」的指標，但思考一下，僅憑「次數」的判斷方式，是否顯得有些許粗暴呢？</p><p>在回答這個問題之前，我們暫且先回歸本質來思考一下，為什麼需要將「重覆」的程式碼抽取成「共用」？</p><p>前面說過，「重覆程式碼」的問題在於，其可能會導致該專案的「可維護性」降低；那抽取成「共用程式碼」之後就不存在維護上的問題了嗎？</p><p>當然不是，很多的事情都是「一體兩面」，而「共用程式碼」亦不例外，事實上，「共用程式碼」的缺陷在「微服務架構」中尤其明顯；就如同在「<a href="https://www.amazon.com/Five-Lines-Code-when-refactor/dp/161729831X">Five Lines of Code: How and when to refactor</a>」中，「Christian Clausen」的描述如下：</p><blockquote><em>Increasing global behavior-change velocity can be awesome because our code can adapt quickly when needed. Increasing system fragility is the price we pay, alongside the risk of introducing a bad change into the shared code and causing global damage.</em></blockquote><p>根據「Christian Clausen」敘述，我們可以知道，雖然「共用程式碼」的優點是顯而易見的，但其代價也是不菲的，最直接的「影響」就是當它的程式碼存在問題時，其可能會導致「全域性」的破壞，因為「共用程式碼」的作用範圍是「全域性」的，所以當它存在錯誤時，其影響的範圍也將會是遍佈「全域」；此外「Christian Clausen」認為，「共用程式碼」會因為增加程式碼間的「耦合度」，進而增加系統「脆弱性（Fragility）」。</p><p>由上述這段話，我們可以知道，將程式碼抽取成「共用」並不是代表其就不再需要調整，事實上，就如同，「林信良」在「<a href="https://www.ithome.com.tw/voice/106025">面對抽象雙面刃</a>」中的敘述，「重構」是指「優化」程式碼的過程，但不見得都是將程式碼「抽象化」，亦可能為反向，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IJB1hl4DhXXIEtgiR0sjRA.png" /></figure><p>所以，在筆者的觀念裡，「重構」應該是一個「持續」發生的過程，我們應該不斷地「重構」，在任何我們有需要時，就如同「<a href="https://www.ithome.com.tw/voice/79813">對於重構的兩則常見誤解</a>」一文中所描述的：「重構的活動應該伴隨著我們一般開發過程中的主要活動來進行」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/704/1*opaImvLde82pyJe8qwVW0g.png" /></figure><p>至此，我們知道，「重構」應該是一件持續的事情，無論在開發時期、維護時期、錯誤處理，只要遇到不合宜的狀況，我們就應該修正；接著，回到我們原先的問題：若依照「三次重構原則」的概念，僅憑「次數」就作為判斷是否「重構」的依據，其是否顯得有些許粗暴呢？</p><p>其實「三次重構原則」本來就是一個概念，就「重構」而言，所謂的「最佳時機」本來就無法一概而論，其會因為業務性質、專案特性、團隊習慣⋯等因素的不同而有所不同；但別忘了，「重構」本就應該是一件持續的事情，「三次重構原則」只是讓我們降低發生「過早的優化」機率，並非讓我們能夠一勞永逸的魔法。</p><h4>區域性不變量</h4><p>接著，我們來談一個名詞：「區域性不變量（Local invariants）」。</p><p>其是「Christian Clausen」在「<a href="https://www.amazon.com/Five-Lines-Code-when-refactor/dp/161729831X">Five Lines of Code: How and when to refactor</a>」中，談論「共用程式碼」時所提到的「詞彙」；他說，對「共用程式碼」而言，其可能會因為呼叫它的區域不同，而有著不同的流程、邏輯，以「跨行轉帳」為例，「跨行轉帳」是「銀行」的一個服務項目，通常來說，銀行的客戶可以透過「臨櫃」，或是操作「ATM」、「網頁」與「手機應用」來完成，而上述的四種方式，雖然都是「跨行轉帳」，但其業務邏輯卻可能會因為來源途徑不同而有著不同的流程，譬如「臨櫃」可能還需要輸入「櫃檯」服務專員的員工編號，而且不同業務的執行權限也可能不同，而「ATM」則是得先從「卡號」獲得客戶資訊；「網頁」與「手機應用」則有「憑證」、「綁定硬體裝置」的限制；而我們為了使「共用程式碼」能因應各種不同的呼叫，所以我們就被迫需要在「共用程式碼」中加入一些判斷，或修改流程，而如此行為的代價就是會提高「共用程式碼」的「複雜度」與「耦合度」，最後反而導致程式碼的「可維護性」降低。</p><p>所以，我們就不應該抽取「共用程式碼」嗎？</p><p>在「<a href="https://medium.com/@mariusbongarts/when-you-should-duplicate-code-b0d747bc1c67">When You SHOULD Duplicate Code</a>」一文中，其作者「Marius Bongarts」引用了「Andy Hunt」和「Dave Thomas」在「<a href="https://www.amazon.com/gp/product/0135957052">The Pragmatic Programmer: Your Journey To Mastery</a>」一書中，他們對「DRY」原則的描述：</p><blockquote><em>Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.</em></blockquote><p>在描述中，「Marius Bongarts」特別點出「Andy Hunt」和「Dave Thomas」的用詞是「Every piece of knowledge」，而非「Every piece of code」，原文如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SILfZl0R9Rb3SgCNv_AadQ.png" /></figure><p>事實上，「Robert Martin」在「<a href="https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164">Clean Architecture: A Craftsman’s Guide to Software Structure and Design</a>」一書中也有類似的描述，在談論「重覆程式碼」的議題時，「Robert Martin」寫道，即使是兩段完全相同的程式碼，若其有著各自不同的「演化」軌跡，那麼，它就不能算是真正的「重覆程式碼」，原文如下：</p><blockquote><em>If two apparently duplicated sections of code evolve along different paths — if they change at different rates, and for different reasons — then they are not true duplicates.</em></blockquote><p>對於這類的「重覆」，「Robert Martin」稱它們為「意外的重覆（Accidental Duplication）」；他進一步解釋道，即便是兩段完全相同的程式碼，它們也只是當下「情況」是「相同」的，但最後它們終究會因為「業務性質」的差異而發展成不同的樣子，所以我們應避免將它們「統一」，否則，我們之後就必須面臨到將它們分開的挑戰。</p><p>至此，我們已經清楚地知道要判斷是否為「意外的重覆」的關鍵是：「業務特性」；也就是「Andy Hunt」和「Dave Thomas」所說的「Every piece of knowledge」；倘若以這個角度來看的話，「三次重構原則」的僅憑「重覆次數」就判斷的方式，稱其為「粗暴」似乎也不為過；但令人尷尬的是，就如同「Marius Bongarts」在「<a href="https://javascript.plainenglish.io/rule-of-three-three-strikes-and-you-refactor-942d13e7d5cd">Rule of Three — Three Strikes And You Refactor</a>」所說的，對多數的開發者而言，尤其是在缺乏產業知識的情況下，其想要區別「真正的重覆」與「意外的重覆」是困難的，但判斷是否為「第三次」碰到的「重覆程式碼」卻是輕而易舉。</p><h3>參考資料</h3><ul><li><a href="https://softwareengineering.stackexchange.com/questions/65690/solid-vs-avoiding-premature-abstraction">SOLID vs. Avoiding Premature Abstraction</a></li><li><a href="https://softwareengineering.stackexchange.com/questions/386570/what-is-premature-abstraction">What is “premature abstraction”?</a></li><li><a href="https://medium.com/@mariusbongarts/when-you-should-duplicate-code-b0d747bc1c67">Marius Bongarts, When You SHOULD Duplicate Code</a></li><li><a href="https://javascript.plainenglish.io/rule-of-three-three-strikes-and-you-refactor-942d13e7d5cd">Marius Bongarts, Rule of Three — Three Strikes And You Refactor</a></li><li><a href="https://www.amazon.com/Five-Lines-Code-when-refactor/dp/161729831X">Christian Clausen, Five Lines of Code: How and when to refactor</a></li><li><a href="https://www.amazon.com/gp/product/0135957052">David Thomas, Andrew Hunt, The Pragmatic Programmer: Your Journey To Mastery</a></li><li><a href="https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882">Robert Martin, Clean Code: A Handbook of Agile Software Craftsmanship</a></li><li><a href="https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164">Robert Martin, Clean Architecture: A Craftsman’s Guide to Software Structure and Design</a></li><li><a href="https://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672">Martin Fowler, Refactoring: Improving the Design of Existing Code</a></li><li><a href="https://www.ithome.com.tw/voice/106025">林信良, 面對抽象雙面刃</a></li><li><a href="https://www.ithome.com.tw/voice/91845">王建興, 探索真正的需要，避免過度工程化</a></li><li><a href="https://www.ithome.com.tw/voice/79813">王建興, 對於重構的兩則常見誤解</a></li><li><a href="http://teddy-chen-tw.blogspot.com/2023/01/blog-post.html">陳建村, 也許我不會刪除你：重複程式碼不等於壞味道</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fdc45d4990fc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[從「維護者」的思維看待「開發」]]></title>
            <link>https://rickbsr.medium.com/%E5%BE%9E-%E7%B6%AD%E8%AD%B7%E8%80%85-%E7%9A%84%E6%80%9D%E7%B6%AD%E7%9C%8B%E5%BE%85-%E9%96%8B%E7%99%BC-4e2695a8f1bf?source=rss-4a9adf38ab9------2</link>
            <guid isPermaLink="false">https://medium.com/p/4e2695a8f1bf</guid>
            <category><![CDATA[康威定律]]></category>
            <category><![CDATA[可維護性]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[系統架構]]></category>
            <dc:creator><![CDATA[Rick]]></dc:creator>
            <pubDate>Wed, 24 Jan 2024 15:34:12 GMT</pubDate>
            <atom:updated>2026-08-13T07:46:09.389Z</atom:updated>
            <content:encoded><![CDATA[<h4>從維護者的思維看待開發：康威定律、架構與可維護性</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*10yHP7Endw3yUGfI" /><figcaption>Photo by <a href="https://unsplash.com/@joshcala?utm_source=medium&amp;utm_medium=referral">Josh Calabrese</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>每一次的擴充，都不應該是疊床架屋的開始，而是以維運為本的藝術。</p><h3>前言</h3><p>前些日子，筆者因公參加了一場由「VMware」舉辦的研討會，議題涵蓋「金融數位轉型」、「雲原生應用」與「DevSecOps」等。其中一場演講分享了台灣某金融企業現代化轉型的過程與經該場的分享者是該企業的一位科長，同時也是該組織中，「DevOps」團隊的領導者。</p><p>該場演講的分享者是這家企業的一位科長，同時也是該組織「DevOps」團隊的領導者。</p><p>在那場演講中，講者敘述了團隊在轉型過程中遭遇的問題與阻礙，以及因應、處理這些問題的方式。例如在「團隊建立」時，該如何組成與配置人員；在「環境建置」時，該如何挑選產品與廠商，以及挑選時應注意的重點等。</p><p>另外，由於金融業的特殊性，對資安的要求相對嚴格。因此在轉型過程中，涉及資安的決策必須更加謹慎，也更需要經驗；更不用說金融單位還有法規與稽核等議題需要考量。</p><p>在這場分享中，講者的一些論述讓筆者覺得相當有意思。例如在「團隊建立」的議題上，講者引用「康威定律」作為建立團隊的基礎準則；在「系統架構」的設計上，則採用他自創的「魚缸式架構」。不過，最令筆者印象深刻的，還是他說的一句話：「每一次的擴充，不是疊床架屋的開始，而是以維運為本的藝術。」這部分稍後再介紹。</p><p>除了上述議題外，講者還提到另一個讓筆者深有同感的重點：在整個轉型過程中，最棘手、最難處理的問題仍然是「人」，包含「溝通」與「協調」。尤其在「跨部門合作」與「向上溝通」時，還可能涉及「組織文化」的革新。對於「人」的議題，他們至今仍持續奮戰。</p><p>前言到此結束，接著就來介紹上述幾個有趣的理論吧！</p><h3>正文</h3><h4>康威定律</h4><p>首先是「康威定律」。在該場演講中，那位科長提到，他在「建立團隊」時，以「康威定律」作為執行的基礎準則。不過，什麼是「康威定律」呢？</p><p>為什麼它能作為「構建團隊」的基礎準則？</p><p>其實，「康威定律」之所以能作為「建立團隊」的準則，是因為它本來就是與「組織架構」相關的概念。「康威定律」的英文是「Conway’s Law」，其中的「Conway」是人名，全名為「Melvin Conway」，是一位美國科學家。這個概念源自他在「1968」年刊登於「Datamation」的文章「<a href="http://www.melconway.com/Home/pdf/committees.pdf">How Do Committees Invent?</a>」，內容探討「系統設計」與「組織架構」之間的關係。</p><p>備註：「Datamation」是著名的「IT」雜誌。</p><p>說個題外話，根據「Melvin Conway」的描述，「康威定律」一詞並非由他本人提出，雖然其概念源自他發表的「<a href="http://www.melconway.com/Home/pdf/committees.pdf">How Do Committees Invent?</a>」。這個詞是在「1975」年誕生的；當年，「Frederick Phillips Brooks」的經典著作「<a href="https://www.amazon.com/Frederick-Phillips-Brooks/dp/0201006502">The Mythical Man-Month: Essays on Software Engineering</a>」問世，書中引用了「Melvin Conway」在該文中的觀點，並以「康威定律」一詞稱之。</p><p>那麼，「Melvin Conway」在「<a href="http://www.melconway.com/Home/pdf/committees.pdf">How Do Committees Invent?</a>」中是如何闡述的呢？</p><p>關於這個問題，「Melvin Conway」在「<a href="http://www.melconway.com/Home/Committees_Paper.html">Mel Conway — How Do Committees Invent?</a>」中如此描述：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*IhbAhW0X1dXGEWsOcf3muw.png" /></figure><p>這段話的意思是，任何系統的「架構設計」都會受到設計者所屬「組織架構」的影響；這也是「康威定律」的一種表述：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/990/1*p3eyA9Y64QKJa-G5YOZGYQ.png" /></figure><p>或許有讀者會產生疑問：為什麼說是「一種表述」？</p><p>如上圖紅線標示的部分，「Melvin Conway」使用了「one form of the paper&#39;s thesis.」這個說法。也就是說，關於「康威定律」的那段敘述，只是「<a href="http://www.melconway.com/Home/pdf/committees.pdf">How Do Committees Invent?</a>」一文的一種表述形式。</p><p>筆者猜測，「Melvin Conway」認為「康威定律」應具有更高層次的視野與更廣泛的適用性，不應侷限於「軟體工程」領域。這一點也可以從他在「<a href="http://www.melconway.com/Home/Committees_Paper.html">Mel Conway — How Do Committees Invent?</a>」中的描述看出：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*sP3mfGaShBQ_BSmr1PPlxw.png" /></figure><p>不過，正如「Melvin Conway」所述，「康威定律」在「軟體工程」上的引用確實相對多。例如知名軟體大師、「SOLID」的提出者「Robert Martin」，就曾在「<a href="https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164">Clean Architecture: A Craftsman’s Guide to Software Structure and Design</a>」一書中引用「康威定律」來解釋「SRP（Single Responsibility Principle）」；他認為「SRP」可以視為「康威定律」的積極推論，原文如下：</p><blockquote><em>An active corollary to Conway’s law: The best structure for a software system is heavily influenced by the social structure of the organization that uses it so that each software module has one, and only one, reason to change.</em></blockquote><p>此外，「康威定律」還存在的許多「變體」，譬如：</p><blockquote><em>The organization of the software and the organization of the software team will be congruent.</em></blockquote><p>這段描述是「Eric S. Raymond」在「<a href="https://www.amazon.com/New-Hackers-Dictionary-3rd/dp/0262680920">The New Hacker’s Dictionary</a>」一書中對「康威定律」的重新定義。與「Melvin Conway」的原始描述相比，「Eric S. Raymond」的版本指向更明確、針對性也更高。關鍵在於它明確使用了「software」一詞，將範圍限定在「軟體架構」上。雖然這個版本比原始版本更侷限，但也因為更加直覺、不需要太多解釋，而更常被引用。</p><p>除了「Eric S. Raymond」之外，「康威定律」還有諸多知名的「變體」，譬如：</p><blockquote><em>The structure of any system designed by an organization is isomorphic to the structure of the organization.</em></blockquote><p>其意思是，任何系統的結構都會與其設計組織的結構同構；這個說法是源自於「Structured Design: Fundamentals of a Discipline of Computer Program and Systems Design」一書，而該書的作者是「Edward Yourdon」和「Larry L. Constantine」。</p><p>再舉一個，如下：</p><blockquote><em>If the parts of an organization — such as teams, departments, or subdivisions — do not closely reflect the essential parts of the product, or if the relationships between organizations do not reflect the relationships between product parts, then the project will be in trouble.</em></blockquote><p>這段話的意思是，倘若某個「組織結構」與「產品結構」脫鉤，產品就可能面臨困境。這是「James O. Coplien」與「Neil B. Harrison」在「<a href="https://www.amazon.com/Organizational-Patterns-Agile-Software-Development/dp/0131467409">Organizational Patterns of Agile Software Development</a>」一書中的描述。</p><p>至此，本文先暫時介紹「康威定律」到這裡；至於具體細節，未來有機會再另闢篇幅討論。</p><h4>魚缸式架構</h4><p>接著介紹講者談論「系統架構設計」時提到的「魚缸式架構」。不同於「康威定律」，「魚缸式架構」是講者自創的設計理論。它主張系統架構應該像魚缸一樣：一個「大魚缸」可以由多個「小魚缸」組成，而每個「魚缸」都是具備獨立性的個體，可以輕易擴充或移除。</p><p>也就是說，在「魚缸式」系統架構中，每個「子系統」都應該能獨立存在與運作。簡單地說，就是「子系統」本身具備「高內聚」，子系統之間則保持「鬆耦合」。</p><p>咦，這個概念聽起來是不是與「微服務架構」非常相似？</p><p>所以，筆者認為，「魚缸式架構」的設計概念在一定程度上與「微服務架構」重疊，兩者都強調系統架構應具備「高內聚」與「鬆耦合」的特性。</p><h4>維運為本</h4><p>最後，讓我們來談談在這場演講中，最令筆者印象深刻的一個概念：「維運為本」。</p><p>在這場分享中，講者提到一個觀念：「每一次的擴充，都不應該是疊床架屋的開始，而是以維運為本的藝術。」；我們來咀嚼一下這句話的意思。「擴充」可能是增加新功能，也可能是修改既有功能；無論是哪一種，都會涉及程式碼異動。而有經驗的開發者都知道，異動往往是程式架構走向「疊床架屋」的起點。</p><p>事實上，程式碼異動本身很正常，問題在於異動不符合當前的架構設計，才容易導致「疊床架屋」。這個描述同時適用於系統架構與程式架構。</p><p>在系統架構層面，只要涉及架構異動，不論規模大小，代價往往都不低。例如抽換容器平台，將原本使用的「K8s」更換成「OCP」；或是變更資料庫架構與種類，因應微服務概念將單一資料庫改為多個資料庫，或將「Microsoft SQL Server」換成「Oracle Database」等。</p><p>上述行為並非不可行，但每一項都可能牽動整個系統。在執行前，應該審慎規劃，確認異動內容與現行架構的相容性，並準備好風險因應與備援方案。執行時也必須謹慎處理，否則一個疏忽或思慮不周，就可能釀成難以挽回的災難。</p><p>程式架構也是如此。每次程式碼異動後，除了確認基本的程式碼風格，也必須確認修改是否符合原先架構的設計理念，以及所屬的類別、組件與模組是否仍遵守「單一職責」等原則。</p><p>「維運為本」想表達的是，當我們更改架構時，應該從維護的角度思考。更直白地說，無論改動的是一個系統、一段邏輯或一個組件，都可以先問問自己：如果三個月後又出現新的異動需求，這次的改變會讓下一次的工作變得更複雜嗎？</p><p>如果會，是不是就意味著我們正在「疊床架屋」，或是已經離它不遠了？</p><p>或許有人會疑惑，為什麼是問「自己」，而不是「別人」？</p><p>當然也可以問別人，例如其他同事或共同開發者。不過想想看，如果連修改者本身都覺得下一次維護會更複雜，那又何必等別人提醒呢？</p><p>筆者相當認同這個想法。以自己作為基準，是一個簡單且有效的判斷方式。雖然它不是明確、可量化的指標，但這並不重要，因為多數時候，自己也正是那個維護者。</p><p>說真的，這場演講讓筆者感觸良多。從維護的思維看待修改，這句話想傳遞的其實就是可維護性，或者更精確地說，是可維護性的本質。當我們追求以各種複雜的量化指標或方法論衡量可維護性時，或許應該放慢腳步，回歸本質，用最簡單的角度看待開發這件事。</p><p>筆者並不是說那些量化指標或方法論沒有用，而是認為，當我們追求經過估算的量化數值時，仍應不斷自檢、自省，提醒自己不要忘記數值背後的初衷，才能避免落入一味追求數值的陷阱，走向矯枉過正的歧途。</p><h3>參考資料</h3><ul><li><a href="http://www.melconway.com/Home/Conways_Law.html">Melvin Conway, Mel Conway — CONWAY’S LAW</a></li><li><a href="http://www.melconway.com/Home/Committees_Paper.html">Melvin Conway, Mel Conway — How Do Committees Invent?</a></li><li><a href="http://www.melconway.com/Home/pdf/committees.pdf">Melvin Conway, How Do Committees Invent?</a></li><li><a href="https://www.amazon.com/-/zh_TW/Edward-Yourdon/dp/0917072111">Edward Yourdon, Structured Design: Fundamentals of a Discipline of Computer Program and Systems Design</a></li><li><a href="https://www.amazon.com/New-Hackers-Dictionary-3rd/dp/0262680920">Eric S. Raymond, The New Hacker’s Dictionary</a></li><li><a href="https://www.amazon.com/Frederick-Phillips-Brooks/dp/0201006502">Frederick Phillips Brooks, The Mythical Man-Month: Essays on Software Engineering</a></li><li><a href="https://www.amazon.com/Organizational-Patterns-Agile-Software-Development/dp/0131467409">James Coplien &amp; Neil Harrison, Organizational Patterns of Agile Software Development</a></li><li><a href="https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164">Robert Martin, Clean Architecture: A Craftsman’s Guide to Software Structure and Design</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4e2695a8f1bf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[淺談「Eureka」]]></title>
            <link>https://rickbsr.medium.com/%E6%B7%BA%E8%AB%87-spring-cloud-eureka-529b2213a52b?source=rss-4a9adf38ab9------2</link>
            <guid isPermaLink="false">https://medium.com/p/529b2213a52b</guid>
            <category><![CDATA[spring-cloud]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Rick]]></dc:creator>
            <pubDate>Thu, 16 Dec 2021 09:22:20 GMT</pubDate>
            <atom:updated>2022-01-22T09:02:06.567Z</atom:updated>
            <content:encoded><![CDATA[<h4>Microservices：Spring Cloud</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3KusnXdNmkratxYtE7OTEA.jpeg" /></figure><h3>概要</h3><blockquote>「Eureka！Eureka！Eureka！」阿基米德邊跑邊大聲的喊叫著，過度興奮的他一點都沒察覺自己正光著身子⋯⋯。</blockquote><p>這是一段耳熟能詳，關於科學家如何開始裸奔的故事，呃，不是，筆者想說的是：這是一個與「Eureka」有關的故事。</p><p>然而，看似語助詞的「Eureka！」其實是源自於希臘用語，是用以表達發現某件新事物及真相時的感嘆詞，更多內容請參考「<a href="https://zh.wikipedia.org/wiki/%E5%B0%A4%E9%87%8C%E5%8D%A1_(%E8%AF%8D%E8%AF%AD)">尤里卡</a>」。</p><h3>正文</h3><h4><a href="https://github.com/Netflix/eureka/wiki/Eureka-at-a-glance#what-is-eureka">什麼是「Eureka」？</a></h4><p>本文的主角：「<a href="https://github.com/Netflix/eureka">Netflix/eureka</a>」，它是「Netflix」的項目之一，根據其官方描述，「Eureka」是一種基於「RESTful」的服務，用於雲服務，主要的作用為「服務註冊/發現」、「負載平衡」以及「<a href="https://zh.wikipedia.org/wiki/%E6%95%85%E9%9A%9C%E8%BD%AC%E7%A7%BB">故障轉移</a>」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZVvTyrlVaM5-asvIpyVGtA.png" /></figure><p>因此，「<a href="https://github.com/Netflix/eureka">Eureka</a>」的命名就是取其原意「發現」的意思。</p><p>而本文要介紹的是「<a href="https://github.com/Netflix/eureka">Eureka</a>」在「Spring Cloud」中的應用。</p><p>首先，我們要知道，「<a href="https://www.springcloud.cc/">Spring Cloud</a>」是一套以「Spring Boot」為核心的微服務框架，而且它並不是從無到有的「造輪子」，而是個「集成」各家輪子的「整合性項目」。</p><p>而「<a href="https://github.com/Netflix/eureka">Netflix/eureka</a>」就是其中的一個輪子，由「<a href="https://spring.io/projects/spring-cloud-netflix">Spring Cloud Netflix</a>」項目所集成，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*31ZRk5RI-woRnOJCXQgqPA.png" /></figure><p>備註：「<a href="https://spring.io/projects/spring-cloud-netflix">Spring Cloud Netflix</a>」曾是「Spring Cloud」最重要的項目，它提供與「Netflix OSS」的自動集成，其包含「Eureka」、「Hystrix」、「Zuul」、「Ribbon」⋯等；後來由於其中的多個項目不再開發，甚至是不再維護，而使得「<a href="https://spring.io/projects/spring-cloud-netflix">Spring Cloud Netflix</a>」的佔有率逐漸下降。</p><p>就如同上述所描述，「<a href="https://github.com/Netflix/eureka">Eureka</a>」的功能是與「服務註冊/發現」相關，也因此在「<a href="https://github.com/Netflix/eureka">Eureka</a>」常作為「Spring Cloud」架構中「<a href="https://spring.io/cloud">Service Registry</a>」功能模塊的組件被使用。</p><p>官方提供的「Spring Cloud」架構概念如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2Smnk_v1cBenerrgNZ8i5g.png" /></figure><h4>「<a href="https://spring.io/cloud">Service Registry</a>」的作用</h4><p>就「微服務」架構的概念而言，應用服務群的各個服務應具有獨立性與隔離性，也就是說，應用服務群的各個服務不會知道彼此的位置與狀態，而服務間的調用都會藉由引導組件來完成。</p><p>事實上，在微服務的配置中，由於可用性的考量，因此，即便是相同的服務，其同時存在的數目也不會只有一個，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/818/1*0_1cOi1ZOBFXWnIieF_p5A.png" /></figure><p>因此，我們會需要一個負責「服務引導」的功能件，而「<a href="https://spring.io/cloud">Service Registry</a>」就是負責扮演「引導者」的模塊，我們又稱之為「註冊中心」。</p><p>備註：「故障轉移」的原理也是相同。</p><h4>「<a href="https://github.com/Netflix/eureka">Eureka</a>」的架構與原理</h4><p>那麼「<a href="https://github.com/Netflix/eureka">Eureka</a>」引導機制的原理什麼呢？</p><p>首先這要從「<a href="https://github.com/Netflix/eureka">Eureka</a>」的架構說起，下圖為官方所提供的「架構圖」：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/0*uXl78iu3FCvLARQB.png" /></figure><p>是不是有點矇？別急，我們慢慢說；首先，ㄡ由上圖可知，「<a href="https://github.com/Netflix/eureka">Eureka</a>」是屬於「<a href="https://zh.wikipedia.org/wiki/%E4%B8%BB%E5%BE%9E%E5%BC%8F%E6%9E%B6%E6%A7%8B">主從式架構</a>」，分為「Client」端與「Server」端。</p><p>而「Eureka Server」可用於記錄、監控其它服務的狀態，事實上，我們可以理解成「Eureka Server」是在維護一張「各服務的狀態列表」。</p><p>此外，基於「可用性」的原則，「Eureka Server」的允許多台配置，而不同的「Eureka Server」是會同步信息的，如下圖：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*qtybBts2Is6ojSCf9jrb1w.png" /></figure><p>然而，與「Eureka Server」可獨立部署的特性不同，「Eureka Client」則是駐於各服務應用上，而其功能有二，分別是向「Eureka Server」發送信息以及從「Eureka Server」獲取註冊列表；這稍後再說。</p><p><strong>註冊列表</strong></p><p>先前，我們說「Eureka Server」就好比是「服務列表」的維護者，而可用的服務會被登記在該列表上。</p><p>但「Eureka Server」怎麼會知道總共有哪些服務呢？</p><p>其實，就是駐在「各服務」上的「Eureka Client」會向「Eureka Server」發送「註冊信息」，當「Eureka Server」獲取到由「Eureka Client」所發送的註冊信息後，就會將該服務進行登記。</p><p>如此一來，若我們要去調用該服務，我們就可以從「Eureka Server」獲取註冊列表，並從中得知可用服務的相關資訊。</p><p><strong>心跳機制</strong></p><p>但問題來了？假設今某一服務在運行過程中發生異常，無回應了。</p><p>那麼，「Eureka Server」要怎麼知道該服務已經故障，並即時地從註冊列表中將其剔除呢？</p><p>事實上，其關鍵仍然是在「Eureka Client」所發送的信息，在「服務」註冊之後，「Eureka Client」仍會持續地向「Eureka Server」發送信息；只是該信息的目的並不是註冊，而是為了續約，告知其當前服務仍正常運作。</p><p>因此，「續約的訊息」又被稱為「心跳」。</p><p>在默認情況下，「Eureka Client」每 30 秒發送一次「心跳」。</p><p>倘若「Eureka Server」在持續一段時間內都沒有收到來自「Eureka Client」所發送的「心跳」，「Eureka Server」就會將該服務判定為失效，並從將之從其「註冊列表」中剔除，而其默認的等待時間為 90 秒。</p><p>其整體架構如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/941/1*8LEQIixZpoOW_VxNOkUIuA.png" /></figure><p><strong>自我保護機制</strong></p><p>事實上，「Eureka」的自我保護機制可以視為其「心跳機制」的配套。</p><p>因為微服務屬於「分散式架構」，因此，其存在一個相當關鍵的不穩定因素：「網路」。</p><p>什麼是「自我保護機制」呢？</p><p>假如一「Eureka Server」在 90 秒內都沒收到某個服務的「心跳」，那麼根據我們先前所述，該「Eureka Server」會將這個服務判定為「故障」，並從註冊列表中將其移除。</p><p>但是否真的就是「服務」故障了呢？會不會是因為網路異常而導致「心跳」沒有成功被傳遞，但其實服務本身的運作是正常的情形呢？</p><p>因此，為了因應這種可能是誤判而導致服務誤刪的情況，「Eureka」就設計了所謂的「保護機制」；即在短暫的時間內，若多個服務同時或相繼被判定為失效，則啟動保護機制，而此時的「Eureka Server」便不會再從列表中刪除任何服務。</p><p><strong>負載平衡</strong></p><p>最後是「負載平衡」，其最主要的作用就是分散壓力。</p><p>在一些需求高流量承載的網站，如電商、銀行⋯等，負載平衡是一種常見的分散壓力手段，其藉由引導外部請求的方式來降低單一伺服器的負載壓力，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/848/1*JegUegssdXUHmuhLbAhtXg.png" /></figure><p>而「Eureka」的負載平衡機制是依賴「Netflix」的另一項目：「Ribbon」。</p><p>其實「Ribbon」是一種「客戶端」的「負載均衡」機制，與「Eureka」同作為「Spring Cloud Netflix」所整合的項目之一，是早期構建「Spring Cloud」專案最常被選用的組件之一。</p><p>至於其內容與使用方式，筆者未來會寫一篇「Ribbon」的介紹。</p><h4><strong>「Eureka」的使用方式</strong></h4><p>在介紹完「Eureka」的架構與原理，接著就是實際的配置方式。</p><p>根據「<a href="https://github.com/Netflix/eureka/wiki/Configuring-Eureka">Configuring Eureka</a>」中的內容描述，我們可以得知「Eureka」有分分為「Server」端與「Client」端兩個部分；必須分別配置。</p><p><strong>環境需求</strong></p><p>但在講解「Eureka」之前，我們先暸解一下「Eureka」的環境需求。</p><p>根據官方文件的描述，我們可以得知「Eureka」的構建需要「Java」且版本需在「8」以上，首先是「<a href="https://github.com/Netflix/eureka/wiki/Configuring-Eureka#configuring-eureka-client">Client</a>」端的描述：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X1DM0zsFjqK-lpThC5zFzg.png" /></figure><p>而「<a href="https://github.com/Netflix/eureka/wiki/Configuring-Eureka#configuring-eureka-server">Server</a>」端，在「JDK」的版本同樣是要求「1.8」或以上，但此外，還多了對「Tomcat」的要求，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eQmqA3J4WjqqZ96OZamymg.png" /></figure><p>在確認了環境後，接著我們來介紹「Eureka Server」的配置。</p><p><a href="https://cloud.spring.io/spring-cloud-netflix/multi/multi_spring-cloud-eureka-server.html#spring-cloud-eureka-server-standalone-mode"><strong>「Server」端的配置</strong></a></p><p>而「Eureka」在「Server」端的配置大致可以分為「導入依賴」、「配置檔」及「啟動類」三個部分。</p><p>首先是「導入依賴」，此處以「Gradle」為例。</p><p>由於「Eureka」與「Spring Boot」的整合是依賴於「Spring Cloud」，第一步就是必須先導入「Spring Cloud BOM」，導入方式如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XARxQn0pV7-JdgvuLjOaFQ.png" /></figure><p>關於「Spring Cloud」配置的詳細內容請參考「<a href="https://spring.io/projects/spring-cloud">官方文件</a>」。</p><p>在「Spring Cloud BOM」導入後，就是本體，導入「Eureka Server」的依賴，但其實也就一行，如下：</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8cb5e65b7d72906f5d4254e9ae39dd73/href">https://medium.com/media/8cb5e65b7d72906f5d4254e9ae39dd73/href</a></iframe><p>然後是「配置檔」的部分，即「.yml」的部分。</p><p>以一「<a href="https://cloud.spring.io/spring-cloud-netflix/multi/multi_spring-cloud-eureka-server.html#spring-cloud-eureka-server-standalone-mode">單體模式</a>」的「Eureka Server」為例，其「application.yml」的配置內容如下：</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/90aa283ab4ee091ab6de4ccd0916c7da/href">https://medium.com/media/90aa283ab4ee091ab6de4ccd0916c7da/href</a></iframe><p>單體模式意即只配置有一台「Eureka Server」，因此，它就是唯一的「註冊中心」，所以將「register-with-eureka」設置為「false」，代表不需要將自己註冊到其它的「註冊中心」。</p><p>其實「fetch-registry」、「serveice」的配置也是同樣的道理。</p><p>最後是「啟動類」的部分。</p><p>一句話，在啟動類上加入啟動註解：「@EnableEurekaClient」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/577/1*OIaJuKpy_Rx26k6ZwAXYmw.png" /></figure><p>題外話，在官方文件中有提到，若使用的「JDK」版本是「11」，記得要載入「JAXB」的依賴，因為「JAXB」在「JDK 11」中已被移除，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-6MGecd3y0WJJn6rbrBTMw.png" /></figure><p>至此，關於「Eureka Server」的配置內容就介紹到這，更完整的內容就請參考「<a href="https://cloud.spring.io/spring-cloud-netflix/multi/multi_spring-cloud-eureka-server.html#spring-cloud-eureka-server-standalone-mode">官方手冊</a>」。</p><p><a href="https://cloud.spring.io/spring-cloud-netflix/multi/multi__service_discovery_eureka_clients.html"><strong>「Client」端的配置</strong></a></p><p>然後「Eureka」在「Client」端的配置，其與「Server」端的配置內容基本一樣；同樣是分為「導入依賴」、「配置檔」及「啟動類」三個部分。</p><p>在「導入依賴」同樣也是一行：</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/43766818a84d60f2d6e8ae378c2c7eac/href">https://medium.com/media/43766818a84d60f2d6e8ae378c2c7eac/href</a></iframe><p>而「配置檔」亦類似，下為一「提供者服務」的配置：</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b54e954a78e9fbf31c9b34e29997e3ad/href">https://medium.com/media/b54e954a78e9fbf31c9b34e29997e3ad/href</a></iframe><p>最後是「啟動類」，也同樣是加入一行註解，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eS543I1OcmPGpizPis8vWQ.png" /></figure><p>如圖中所述，「@EnableEurekaClient」是由「Netflix」原生提供，而「@EnableDiscoveryClient」則是由「Spring Cloud」整合後提供，但兩者作用相同，至於省略不寫也行，筆者個人是比較不建議。</p><p>題外話，筆者在讀「官方的使用手冊」的這部分時，發現官方文件中的啟動類範例跟我們平常遇到的不同，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0ZlbyPVslXiP_X465t3Knw.png" /></figure><p>後來，查了一下才知道，原來還真的有這樣的用法，詳細請見「<a href="https://stackoverflow.com/questions/45911357/when-do-we-use-a-springapplicationbuilder/45911976?fbclid=IwAR3gKdZAp05CX75QiYWAZYMYuCd2Jw4lDAIuup5morl_vk4BUs8kTlQLtXY">When do we use a SpringApplicationBuilder?</a>」。</p><p>那個關於「Eureka Client」的內容就介紹到這，而完整內容就請參考「<a href="https://cloud.spring.io/spring-cloud-netflix/multi/multi__service_discovery_eureka_clients.html">官方手冊</a>」。</p><h3>總結</h3><p>雖然「Eureka」是元老級的組件，功能健全、穩定且經過時間考驗，以目前來說，它仍是相當不錯的選擇。</p><p>但它畢竟是屬於「Spring-Cloud-Netflix」的成員；而該項目的成員可以說是老弱病殘，有「維護模式的」、「閉源的」、「停止更新的」⋯等，整內容請參考「<a href="https://spring.io/blog/2018/12/12/spring-cloud-greenwich-rc1-available-now#spring-cloud-netflix-projects-entering-maintenance-mode%E5%8E%9F%E6%96%87%E7%B6%B2%E5%9D%80%EF%BC%9Ahttps://kknews.cc/education/4nlj4l2.html">Spring Cloud Greenwich.RC1 available now</a>」。</p><p>雖然「Eureka」並不在此列，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eTaPUg6wlHILPPQMX97m4A.png" /></figure><p>事實上，本文所說的「Eureka」都是指「Eureka 1.0」；「Eureka 2.0」早在之前就停止開發了，然而，根據官方的說法，「Eureka 1.0」至目前仍然都是處於活躍的狀態，是可以安心服用的，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y3mplEhs8sz2IVBzSh3gqg.png" /></figure><p>但講是這樣講啦。</p><p>其實，以目前來說，除了正在使用的舊有「Spring Cloud」專案，不然，一般新構建的專案都不再建議選擇任何「Spring Cloud Netflix」的組件了。</p><p>事實上，能替代「Eureka」的項目不少，其中也不乏有表現相當優秀的，例如「Zookeeper」、「Consul」，以及目前正夯的「Nacos」都屬之。</p><p>此外，由於「容器化」是現在主流，而不少容器都內建「服務引導」等相關功能，比起使用「Eureka」作為「註冊中心」的組件，其實交由容器來處理還能更好地讓「服務應用」與「Spring Boot」解耦。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=529b2213a52b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[淺談「Spring Boot」的自動裝載]]></title>
            <link>https://rickbsr.medium.com/%E6%B7%BA%E8%AB%87-spring-boot-%E7%9A%84%E8%87%AA%E5%8B%95%E8%A3%9D%E8%BC%89-4e205c1b9bde?source=rss-4a9adf38ab9------2</link>
            <guid isPermaLink="false">https://medium.com/p/4e205c1b9bde</guid>
            <category><![CDATA[java-web]]></category>
            <category><![CDATA[spring-boot]]></category>
            <dc:creator><![CDATA[Rick]]></dc:creator>
            <pubDate>Thu, 25 Nov 2021 07:10:35 GMT</pubDate>
            <atom:updated>2021-12-03T08:17:33.545Z</atom:updated>
            <content:encoded><![CDATA[<h4>Java Web：Spring Boot</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4cKGeyUaTzAAFrE1QH9zHw.jpeg" /></figure><h3>概要</h3><p>對以「Java」為主要開發語言的後端開發者來說，「<a href="https://docs.spring.io/spring-framework/docs/current/reference/html/web.html">Spring Web MVC</a> 」必然不會陌生；在過去幾年中，「<a href="https://docs.spring.io/spring-framework/docs/current/reference/html/web.html">Spring Web MVC</a> 」是開發「Java」網站應用項目的主流框架之一。</p><p>備註：「<a href="https://docs.spring.io/spring-framework/docs/current/reference/html/web.html">Spring Web MVC</a> 」是「<a href="https://spring.io/projects/spring-framework">Spring Framework</a>」其中的一個模塊，是針對網站應用所設計的，詳細資訊請參考「<a href="https://docs.spring.io/spring-framework/docs/current/reference/html/web.html#mvc">Web on Servlet Stack</a>」，其描述如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1znglHjbXuhL1Mm2U8zL9g.png" /></figure><p>而本次要介紹的「<a href="https://spring.io/projects/spring-boot">Spring Boot</a>」，也同樣是「Java」網站應用的框架之一，與「<a href="https://docs.spring.io/spring-framework/docs/current/reference/html/web.html">Spring Web MVC</a> 」是基於「<a href="https://spring.io/projects/spring-framework">Spring</a>」核心的產物，「WiKi 百科」介紹如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*on64VGiJLIG9tBwttX4L_Q.png" /></figure><p>而「<a href="https://spring.io/projects/spring-framework">Spring Framework</a>」的兩個重要特性，分別是「<a href="https://chikuwa-tech-study.blogspot.com/2021/06/spring-boot-ioc-and-di.html">IoC</a>」跟「<a href="https://medium.com/chikuwa-tech-study/sprint-boot-%E7%AC%AC20%E8%AA%B2-%E5%88%87%E9%9D%A2%E5%B0%8E%E5%90%91%E7%A8%8B%E5%BC%8F%E8%A8%AD%E8%A8%88-aop-33a93c576fa4">AOP</a>」，它們為開發者提供大量的便利，而本文的主角：「自動裝載」，便與前者相關。</p><p>「<a href="https://chikuwa-tech-study.blogspot.com/2021/06/spring-boot-ioc-and-di.html">IoC</a>」藉由工廠設計模式的實現將物件交予容器管理，由容器來管理物件與其生命週期，如此一來，開發者們就可避免在程式碼中大量的「new」出物件，並提高物件的重用性，避免緊密的耦合。</p><p>也由於不再需要在程式中撰寫物件管理的相關代碼，所以程式碼也會相對簡潔，但若省去了代碼，那麼物件的產生、注入⋯等管理邏輯又該如何呢？</p><p>以「<a href="https://docs.spring.io/spring-framework/docs/current/reference/html/web.html">Spring Web MVC</a> 」而言，其物件的管理邏輯，包含其它與專案相關的配置細節就會被放在「配置文件」中，也就是所謂的「.xml」檔案；如此的設計其實相當不錯，易於專案的維護，但隨著網站的規模逐漸發展，配置檔也會隨之逐漸增加，甚至到最後變得複雜、難以管理，而這樣的情況就是所謂的「Xml」地獄。</p><p>為了解決這個問題，「<a href="https://spring.io/projects/spring-boot">Spring Boot</a>」這個相對簡潔的框架就被推出了，它最主要的解決的問題就是傳統「<a href="https://docs.spring.io/spring-framework/docs/current/reference/html/web.html">Spring Web MVC</a> 」的文件配置問題，官方介紹如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/877/1*xfSws730l19SBuSuhzO64w.png" /></figure><p>在「Spring Boot」的配置中，開發者們不再需撰寫「.xml」的配置文件，而是藉由標設置「Annotation」的方式來管理物件的注入，例如「@Autowired」、「@Component」⋯等。</p><p>為什麼「Spring Boot」可以如此神奇呢？</p><p>其中的關鍵就是本文要介紹的「Spring Boot」框架的特性：「自動裝載」。</p><h3>正文</h3><h4>「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/SpringBootApplication.html">@SpringBootApplication</a>」</h4><p>當我們要啟動一個「Spring Boot」應用時，首先，我們必須要先找到對應該應用的「啟動類別」，而在「Spring Boot」的配置中，「啟動類別」必需要以「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/SpringBootApplication.html">@SpringBootApplication</a>」標記，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/832/1*BSBjU2WoFw_sZNIVVES3oQ.png" /></figure><p>話不多說，直接點進去，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/464/1*WObsllYG4lXCmZdydB0koA.png" /></figure><p>在「@SpringBootApplication」中，我們可以看到一排的「Annotation」，其中與「Spring Framework」有關的註解為「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/SpringBootConfiguration.html">@SpringBootConfiguration</a>」以及「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/EnableAutoConfiguration.html">@EnableAutoConfiguration</a>」和「<a href="https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/ComponentScan.html">@ComponentScan</a>」；而前兩者又是屬於「Spring Boot」。</p><p>關於「Spring Boot」註解中，前者「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/SpringBootConfiguration.html">@SpringBootConfiguration</a>」是作為標準「Spring Framework」中「<a href="https://docs.spring.io/spring-framework/docs/5.3.13/javadoc-api/org/springframework/context/annotation/Configuration.html?is-external=true">@Configuration</a>」的替代，功能一致，官方敘述如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uLL-jzityJeHqpEB-_rHxg.png" /></figure><p>而後者「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/EnableAutoConfiguration.html">@EnableAutoConfiguration</a>」，就是本文主角「Spring Boot」自動裝載的關鍵。</p><h4>「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/EnableAutoConfiguration.html">@EnableAutoConfiguration</a>」</h4><p>關於「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/EnableAutoConfiguration.html">@EnableAutoConfiguration</a>」的功能，就如官方描述那樣，能夠自動裝載所需要的「Bean」，會在「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/SpringBootApplication.html">@SpringBootApplication</a>」啟動時自動被啟動⋯等，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gyCVhOaAx_56PSzlcAWFXw.png" /></figure><p>介紹的描述稍微看一下即可，重點還是程式碼的部分，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/656/1*Ltf9lNqbD8-4GqFudFUEjA.png" /></figure><p>如上圖，在「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/EnableAutoConfiguration.html">@EnableAutoConfiguration</a>」中，與「Spring Boot」自動裝載相關的註解有二，我們先介紹「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/AutoConfigurationPackage.html">@AutoConfigurationPackage</a>」，該註解的功能是：「將標有該註解的類別，其所在的『Package』位置作為自動配置的路徑。」；這也就是為了「Spring Boot」應用會要求「Application.java」配置路徑的原因，「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/AutoConfigurationPackage.html">@AutoConfigurationPackage</a>」的源碼如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/431/1*LesKNbf-SQ1km_j1NiBlGA.png" /></figure><p>看到「@Import({Registrar.class})」，繼續走下去，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pjc2gtkkkivKHRlMMrIkEQ.png" /></figure><p>是的，就如同我們所見，「Registrar」是個靜態內部類別，而它的外部類別是「AutoConfigurationPackages」，並實作「ImportBeanDefinitionRegistrar」中的「registerBeanDefinitions()」方法，上圖紅色底線標示處是實作內容，也是關鍵的所在。</p><p>而「<a href="https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/ImportBeanDefinitionRegistrar.html">ImportBeanDefinitionRegistrar</a>」是「Spring Framework」中相當重要的一個類別，它是一個接口，「registerBeanDefinitions()」是其唯一的方法，功能是向容器執行「Bean」註冊。</p><p>備註：該內容屬於「Spring Framework」的「反轉注入」，故筆者就不多談，詳細可以參考「<a href="https://www.cnblogs.com/binghe001/p/13150084.html">在@Import注解中使用ImportBeanDefinitionRegistrar向容器中注册bean</a>」。</p><p>回到標示紅色底線的地方，看到「AutoConfigurationPackages.register()」方法的第二個傳入參數，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1008/1*USNZX2WekTy5B0nAjW8jnw.png" /></figure><p>其中的「PackageImport.class」，點進去，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/715/1*QoBaGpkFL8EYmDL-oZ2JGg.png" /></figure><p>如上圖，「PackageImport.class」也是個靜態內部類，在建構子的部分，它會去呼叫「<a href="https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/type/AnnotationMetadata.html">AnnotationMetadata</a>」的「getClassName()」取得元數據的「ClassName」，後再藉由「ClassUtils.getPackageName()」方法就可以獲得元數據的「PackageName」。</p><p>接著同樣是紅色底線的地方，「AutoConfigurationPackages.register()」方法，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lyw3LKtLNWnhj8tOdaT1PQ.png" /></figure><p>老樣子，對著方法點進去，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*NU-LyD6C2CRNUzJvabyl2w.png" /></figure><p>如我們所見，「register()」的邏輯相當清晰，一開始就先藉由邏輯判斷的方法「containsBeanDefinition()」來判斷目標「Bean」是否已經存在，若存在，直接取得「Bean Definition」，並將「Package Name」加入，官方文件的描述如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6c7OGGdvvpcjRfRMR-0VeQ.png" /></figure><p>但一般來說，新服務啟動時，在初始化的情況下，容器內自然是空的，故走「else」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/836/1*Uw7Np22djoXvHqRhDVTGSQ.png" /></figure><p>在「else」中會建構一個新的「BeanDefinition」物件，並進行註冊。</p><p>順帶一提，在「else」內容的第二行中，有個「BasePackages.class」，其實該類別可以用於保存「Packages」的資訊，其建構子如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/652/1*s5-Ki9Ux69LhivTTxGYgfQ.png" /></figure><p>至此，總算是將「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/AutoConfigurationPackage.html">@AutoConfigurationPackage</a>」介紹到一個段落了。</p><h4>@Import(AutoConfigurationImportSelector.class)</h4><p>接著，我們要關注的是，在「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/EnableAutoConfiguration.html">@EnableAutoConfiguration</a>」中的另外一個註解：@Import(AutoConfigurationImportSelector.class)，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/689/1*2g_37sUvHv6rzMP83s-viw.png" /></figure><p>首先「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/AutoConfigurationImportSelector.html">AutoConfigurationImportSelector</a>」類的字尾是「ImportSelector」，而「ImportSelector」是一個與注入有關且非常重要的一個介面，廢話不多說，直接點進去：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/839/1*d_q9HOUHRzn9e0TpshZ28w.png" /></figure><p>我們可以看到「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/AutoConfigurationImportSelector.html">AutoConfigurationImportSelector</a>」實作一堆的接口，包含「<a href="https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/DeferredImportSelector.html">DeferredImportSelector</a>」與「Aware」的子類；「Aware」也是「Spring Framework」中相當重要的機制。</p><p>雖說如此，但其實「Aware」也只是個標識用的接口而已，其子類才是真正地有明確定義，但由於「Spring Framework」的「Aware」機制不在本文的所要探討的範圍內，詳細的資訊可以參考「<a href="https://zhuanlan.zhihu.com/p/352968904">”感知(Aware)“ Spring 框架的能力</a>」。</p><p>回到先前的「<a href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/autoconfigure/AutoConfigurationImportSelector.html">AutoConfigurationImportSelector</a>」，往下捲可以找到一個很關鍵的方法「selectImports()」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/879/1*SoXp0Z6DvM3JYN8xQZK7Vw.png" /></figure><p>備註：「ImportSelector.selectImports()」是「ImportSelector」介面的唯一一個方法，它與「Spring Framework」的注入機制有關，本文主探討的內容是「Spring Boot」的自動裝載，關於「ImportSelector」的機制原理可以參考「<a href="https://blog.csdn.net/l1028386804/article/details/106725815">深入理解Spring的ImportSelector接口</a>」。</p><p>接著，在「selectImports()」方法中就會大量的加載外部配置，其關鍵的方法是「getAutoConfigurationEntry()」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/865/1*KU7JHPvut4_VZvPdqExRYw.png" /></figure><p>點進去，其關鍵的方法是「getCandidateConfigurations()」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/911/1*YB7kWamLkGbqQ_vF_ZWTbQ.png" /></figure><p>再點進去，找到「SpringFactoriesLoader.loadFactoryNames()」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/992/1*wQ7R3HvQVVznbvZQ7WcdDA.png" /></figure><p>同樣地繼續走下去，在「loadFactoryNames()」有兩行代碼，第一會加載自定義的配置檔，而第二行則有個關鍵的方法：「loadSpringFactories()」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/903/1*i77_THDuOAst3K2_3aXo7A.png" /></figure><p>稍微往下滑，找到「loadSpringFactories()」的實作，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/849/1*AZAgBLTa1zVOPbZaYjIsGg.png" /></figure><p>其關鍵在紅色框包覆的區塊中的「FACTORIES_RESOURCE_LOCATION」，它代表著「Spring Boot」相關組件配置檔的位置，其路徑如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/753/1*Lp_JuvSf6ctXqruAgp5lRA.png" /></figure><p>而「Spring Boot」相關的組件就會在該配置檔內定義需要的內容，以我們先前介紹過的「EnableAutoConfiguration」為例，目錄如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/511/1*R6JIztTF4Pedwfa7SCbiiQ.png" /></figure><p>其配置內容如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/1*PNL14762yeFkjshn87ZZpg.png" /></figure><p>如上圖，文件中是以「Key-Value」的形式表示，而前面的「Key」代表所對應的「Annotation」，如此處的就是「EnableAutoConfiguration」，廢話不多說，直接開點，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/449/1*5qdIakY2k-iG32FGPltZ0g.png" /></figure><p>而後面的「Value」則代表對應的「Configuration」，我們直接點第一個，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*q1TgmzmcwtyD9cma6YrZJg.png" /></figure><p>此外，一個「Annotation」是可以對應多個配置類的。</p><p>至此，「Spring Boot」的自動裝載已介紹完畢。</p><h4>實作範例</h4><p>接著，我們就來實作一個自動裝載的範例。</p><p>首先，我們要建立一個「Bean」，以「User」為例，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/276/1*Kewa7_HfjZNfXhqwn0vUvA.png" /></figure><p>如果有引入「Lombok」，就可省略「Getter/Setter」，由套件自動生成。</p><p>有著「Bean」之後，我們要建立一個配置類，其目的是在「Bean」生成時給予配置，例如配置「User」的「username」和「age」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/1*xcVm3ieE2hqv_eB3fRYhYw.png" /></figure><p>到時候，「Bean」生成就會按照我們的設定產生。</p><p>接著我們還需要建立一個「Annotation」，就叫做「EnableUserBean」，類別內容如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/357/1*LTHcv7Fr94CRCB5368k2vg.png" /></figure><p>最後，我們需要一個「ImportSelector」。</p><p>因此我們建立「UserImportSelector」，並繼承「ImportSelector」後，再覆寫「selectImports()」方法，類別內容如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/646/1*ktQ98W4a4b8JnIlobxwWmA.png" /></figure><p>至此，我們就完成了，為了方便，我們在此就將「UserConfiguration」直接寫死，而不是像源碼一樣寫在「META-INF/spring.factories」，並藉由文檔讀取來載入配置。</p><p>寫個測試類別，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/678/1*ddqtzs4v6EeBea2umXqnnw.png" /></figure><p>執行結果如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/338/1*4UKCYYgQAg4MoEOl6iAfwg.png" /></figure><p>收工。</p><h3>總結</h3><p>自動裝載的機制可以說是「Spring Boot」的核心之一，例如近些年如日中天的微服務框架：「Spring Cloud」，其有許多組件就是以這樣的方式被集成的，如「Spring Cloud Netflix」中的「Eureka」、「Ribbon」⋯等。</p><p>其實「Spring Boot」可以理解為傳統「Spring Web MVC」的精簡版，它藉由大量的自動化來簡化原本繁瑣的文件配置。</p><p>由於「Spring Boot」簡潔的特性，外加「Spring Cloud」的崛起，所以相對的，以傳統「Spring Web MVC」為主的專案逐漸變少，但到底它仍然是基於「Spring Framework」的框架，所以它們仍有著許多相同的技術原理，若時間允許，仍建議花時間熟悉其源碼。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4e205c1b9bde" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[淺談微服務與網站架構的發展史]]></title>
            <link>https://rickbsr.medium.com/%E6%B7%BA%E8%AB%87%E7%B6%B2%E7%AB%99%E6%9E%B6%E6%A7%8B%E7%9A%84%E6%BC%94%E9%80%B2-bae068ea6e2d?source=rss-4a9adf38ab9------2</link>
            <guid isPermaLink="false">https://medium.com/p/bae068ea6e2d</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[architecture]]></category>
            <dc:creator><![CDATA[Rick]]></dc:creator>
            <pubDate>Fri, 03 Sep 2021 07:19:53 GMT</pubDate>
            <atom:updated>2021-12-16T09:20:52.481Z</atom:updated>
            <content:encoded><![CDATA[<h4>Microservices：Talks</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UxhBnhixnU7AsKOKg52Hig.jpeg" /></figure><h3>概要</h3><p>架構的觀念在我們開始學程式時就已經接觸，只是對多數的初階程式設計人員來說，架構的意義過於模糊，當時的我們所關注的更多是語法的正確性或者是「API」的使用方式⋯等，但僅能說我們沒有關注「架構」，而不代表我們與它無關，事實是我們始終都在接觸著架構，例如物件導向的概念、設計模式、「<a href="https://zh.wikipedia.org/wiki/SOLID_(%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E8%AE%BE%E8%AE%A1)">SOLID</a>」、「<a href="https://zh.wikipedia.org/wiki/GRASP_(%E7%89%A9%E4%BB%B6%E5%B0%8E%E5%90%91%E8%A8%AD%E8%A8%88)">GRASP</a>」⋯等。</p><p>架構種類很多，如本文的主角：「單體式架構」和「微服務架構」，又或是耳熟能詳的「前後分離架構」、「主從式架構」，又或是經常被一起討論與比較的「MVC」、「MVP」、「MVVM」設計架構。</p><p>雖然它們都是架構，但不見得都是同一回事，畢竟不是所有架構關注的面向都是同樣的，更可能其關注的問題本身就不屬於同個層級，因此，架構與架構之間的關係並不一定都是衝突的，它們或許真的是對立、競爭的關係，但也可能是互補、依賴。</p><p>那麼在要學習架構之前，我們先來了解架構的「前世今生」。</p><h3>正文</h3><h4>單體式應用程式（Monolithic Application）</h4><p><a href="https://zh.wikipedia.org/wiki/%E5%88%86%E5%B8%83%E5%BC%8F%E8%AE%A1%E7%AE%97"><strong>單體應用架構</strong></a></p><p>單體式應用程式，又稱為「整體式應用」，意即將網站的所有功能、模組，包含邏輯、服務，甚至是畫面，都集中於一個應用程式中，是種「大雜燴」的概念。</p><p>以一個含有「商品資訊」、「會員中心」與「購物車」⋯等項目的電商網站為例；在「<a href="https://dubbo.apache.org/zh/docs/v2.7/user/preface/background/#%E5%8D%95%E4%B8%80%E5%BA%94%E7%94%A8%E6%9E%B6%E6%9E%84">單體應用架構</a>」的設計理念中，其會將所有業務模組集中於一個應用內，並以一個整體為單位進行維護、管理與部署⋯等，圖如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S02KQOz_IWO858VJFbfY0A.png" /></figure><p>於上述架構中，「商品資訊」、「會員中心」與「購物車」等項目，通常會是以「Service」的形式存在，在同一「目錄」或「Package」下，以本地端接口的形式被呼叫、使用，並集中部署，非獨立、程式碼相依性極高且耦合緊密；但對於一定規模以下的專案來說，其更易於修改、管理與維護，部署的成本也比較低。</p><p>但是對於規模較大的專案來說，「高耦合」所導致的問題也會隨之顯現；即所謂的「牽一髮動全身」，由於程式碼彼此關聯、依賴，使得當我們因為需求要修改程式碼時，就必須連其牽動的部分一併修改，甚至會牽扯到架構的改動，不僅傷筋動骨，還可能破壞程式碼原有的一致性。</p><p>此外，「高耦合」除了讓程式彈性變差，不易擴展外，還有一個很關鍵的問題，就是不利於「多人協作」的，別的不說，僅就版控而言：「聽說過一句話嗎？衝突的話，慢的那個負責『Merge』！」。</p><p>這很嚴重嗎？這個⋯，遇過就知道。</p><p>事實上，「多人協作」的衝突管理問題一直都是實務上的痛點，隨著數位化時代的來臨，網站的開發越發注重效率，並且需求相對複雜，尤其是特定領域的應用，如「電商」、「金融」⋯等，其「單兵作戰」早已成為過去式。</p><p>總之，隨著時代的發展，「單體應用架構」已經逐漸不適用於所有的網站開發，所以才會有所謂的「微服務架構」出現。</p><p>其實「<a href="https://zh.wikipedia.org/wiki/%E5%96%AE%E9%AB%94%E5%BC%8F%E6%87%89%E7%94%A8%E7%A8%8B%E5%BC%8F">單體式應用程式</a>」這個名詞是在「<a href="https://zh.wikipedia.org/wiki/%E5%BE%AE%E6%9C%8D%E5%8B%99">微服務</a>」盛行後才常被提起並拿來與之比較的；而與之對應的應該是「單體應用架構」，之所以這麼說是因為在網站發展早期根本沒有什麼「分布式系統」的概念，所有網站都是「單體應用程式」。</p><p>分布式系統，乃至於微服務架構都是最近幾年才比較盛行的架構設計模式。</p><p>故此，「單體應用程式」在網站架構史上發展了相當長的一段時間，但就如同先前所說的「單體應用程式」是個「大雜燴」，其緊密耦合的問題一直困擾著所有的程式開發人員，為此，人們陸續提出解決方案，譬如對程式碼結構分層，例如「<a href="https://zh.wikipedia.org/wiki/MVC">MVC</a>」、「<a href="https://zh.wikipedia.org/wiki/Model-view-presenter">MVP</a>」、「MVVM」⋯等，其中，最廣為人知的模型就是「<a href="https://zh.wikipedia.org/wiki/MVC">MVC</a>」，它的概念就是將程式碼分為三大結構，分別是「資料模型（Model）」、「視圖（View）」和「控制器（Controller）」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/321/1*kZDRWj7-Bx6FgwTjYBxfSg.png" /></figure><p>但不論「<a href="https://zh.wikipedia.org/wiki/MVC">MVC</a>」，或是其衍伸的「<a href="https://zh.wikipedia.org/wiki/Model-view-presenter">MVP</a>」或是「MVVM」，其本質都還是一個「應用程式」，即所謂的「單體式應用程式」。</p><h4>前、後端分離</h4><p>在網站架構發展的過程中，其中有一個相當重要的轉捩點，就是「前、後端分離」的架構模式逐漸成為主流。</p><p>在還沒有「前、後端」觀念之前，「UI」部分的處理同樣是由網站負責，事實上，這時期網站的畫面邏輯相對簡單，網站會藉由「Response」將網站頁面的「HTML」回傳，並直接顯示於網站上，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1018/1*ZircfCujknV1NBtlFdDwMw.png" /></figure><p>但隨著科技的發展，用戶端設備的運算能力逐漸強大，並足夠勝任更複雜的畫面處理，因此，「前端」的概念開始出現；此時，瀏覽器不再只負責呈現畫面，它開始能夠運算，所以，我們開始將畫面邏輯的相關處理放到瀏覽器上。</p><p>此外，更由於「畫面邏輯處理」的轉移，我們已經不需要在「網站」上進行有關畫面邏輯的運算，我們只要將單純的數據資料交付給予「前端」即可，因此，「Response」中所回傳的也不再是用以描述畫面的「HTML」，而是更單純的數據格式，如「JSON」⋯等。</p><p>另外，既然傳輸的是單純的數據，無關於畫面的處理，因此，跨平台也就跟著實現，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1014/1*eNTj70jtPE0l8SCRdQKjgQ.png" /></figure><h4>分散式系統（Distributed System）</h4><p>與「單體式應用程式」對立的就是「<a href="https://zh.wikipedia.org/wiki/%E5%88%86%E5%B8%83%E5%BC%8F%E8%AE%A1%E7%AE%97">分散式系統</a>」。</p><p><a href="https://dubbo.apache.org/zh/docs/v2.7/user/preface/background/#%E5%9E%82%E7%9B%B4%E5%BA%94%E7%94%A8%E6%9E%B6%E6%9E%84"><strong>垂直應用架構</strong></a></p><p>若提到「分散式系統」，基本上提起的通常是「<a href="https://dubbo.apache.org/zh/docs/v2.7/user/preface/background/#%E5%88%86%E5%B8%83%E5%BC%8F%E6%9C%8D%E5%8A%A1%E6%9E%B6%E6%9E%84">分布式架構</a>」，或基於它之後所發展的架構；但是在它之前，還有一個「垂直應用架構」。</p><p>先前我們曾說過「單體應用架構」不利於「大規模網站的開發」；但問題是大規模網站的需求就是存在，那怎麼辦呢？「垂直應用架構」就是一開始被提出來的解決方式。</p><p>它的作法就是將單體式應用根據特定面向進行拆分，如「業務項目」、「客群」⋯等；「業務項目」就如上述例子中的「商品服務」、「訂單服務」以及「商品服務」⋯等；而「客群」就好比「一般戶」、「企業戶」⋯等。</p><p>要注意的是，拆分後的單位是「系統」，是相互獨立的系統，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W3j85x9xvjER4dVdDtEyLw.png" /></figure><p>經拆分後，原本「單體應用架構」不利於大規模網站開發的兩大因素：「程式彈性差、不易擴展」與「多人協作困難」，雖不能說完全解決，但至少都得到一定程度的紓解。</p><p>題外話，雖然「垂直應用架構」已經初步具有「<a href="https://zh.wikipedia.org/wiki/%E5%88%86%E5%B8%83%E5%BC%8F%E8%AE%A1%E7%AE%97">分散式系統</a>」的概念，但根據筆者觀察，不少書籍仍將之視為「單體式應用程式」的衍伸，而並非歸類在「<a href="https://zh.wikipedia.org/wiki/%E5%88%86%E5%B8%83%E5%BC%8F%E8%AE%A1%E7%AE%97">分散式系統</a>」，當然也有不少書籍將其獨立為一個項目，呃，就各憑所好，筆者在此就將之歸類為「<a href="https://zh.wikipedia.org/wiki/%E5%88%86%E5%B8%83%E5%BC%8F%E8%AE%A1%E7%AE%97">分散式系統</a>」吧。</p><p>言歸正傳，雖然「垂直應用架構」改善了「單體應用架構」的痛點，但同時又產生出新的問題，其中最讓人詬病的問題是「<a href="https://zh.wikipedia.org/wiki/%E9%87%8D%E9%80%A0%E8%BD%AE%E5%AD%90">重覆造輪子</a>」，即大量重工的現象；這是因為網站拆分成系統後，其不論拆分依據為何，都一定有原本架構中「共用的部分」，但問題是在「垂直應用架構」中的各系統是「無法直接交互」的，所以其原本「共用的部分」就必須在各個系統中重刻一份。</p><p>另外，除了「重覆造輪子」的問題外，還有另一個問題，就是「系統間訊息傳遞不易」。</p><p>雖說系統間彼此獨立能夠有效地「解耦合」，但不同系統間必定會有資訊傳遞的需求，例如使用者要將「商品系統」中的某一商品項目加入到「訂單系統」中的「購物車」內；是的，或許有人會說，我們可以藉由「資料庫」作為溝通橋樑，是的，可以的，但稍微思考一下就會發現，這並不合理。</p><p>倘若網站的所有資料全仰賴「資料庫」傳遞，先不談論是否會需要撰寫過多冗餘的程式碼，僅單是「資料庫的負載力」就是個大問題了，更何況我們還必須考量資料傳遞間的「即時性」、「一致性」⋯等因素。</p><p><a href="https://dubbo.apache.org/zh/docs/v2.7/user/preface/background/#%E5%88%86%E5%B8%83%E5%BC%8F%E6%9C%8D%E5%8A%A1%E6%9E%B6%E6%9E%84"><strong>分布式應用架構</strong></a></p><p>在網站架構的演化上，「分布式應用架構」是一個相當重要的里程碑。</p><p>與「垂直應用架構」相比，「分布式應用架構」是真正意義上的實現系統間遠端通訊。</p><p>而關鍵就是「<a href="https://zh.wikipedia.org/wiki/%E9%81%A0%E7%A8%8B%E9%81%8E%E7%A8%8B%E8%AA%BF%E7%94%A8">遠端程序調用</a>（RPC）」。</p><p>試想，在過去我們要如何讓兩隻遠端程式相互溝通呢？</p><p>我們可以將資料「<a href="https://zh.wikipedia.org/wiki/%E5%BA%8F%E5%88%97%E5%8C%96">序列化</a>」，再經由各種不同介面或協定來傳輸，常見的傳輸協議如「HTTP」、「TCP」、「UDP」、「FTP」⋯等，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e33lIP7x_uF9s7wjb5Ja0g.png" /></figure><p>而「<a href="https://zh.wikipedia.org/wiki/%E9%81%A0%E7%A8%8B%E9%81%8E%E7%A8%8B%E8%AA%BF%E7%94%A8">RPC</a>」就是這段過程的「通訊協議」，它的目的就是：「讓調用遠端程式時的操作就像是在調用本地端的程式一樣。」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*BG-BuPBT6AxOv1SYV1_iDQ.jpeg" /></figure><p>圖片來源為「<a href="https://sheharagrabau.medium.com/java-rpc-cad04978e618">Java RPC</a>」。</p><p>當然，它並不是真的做到直接將遠端程式「import」並呼叫，而是透過設計來模擬本地方法暴露的情況。</p><p>事實上，為了達到「遠端調用」目的，「<a href="https://www.ibm.com/docs/en/aix/7.2?topic=call-rpc-model">RPC 的模型</a>」可能還是會涉及有關於「二進制編碼」、「序列化」或是「XML」⋯等機制，而其網路間的傳輸協議也仍是「TCP」、「UDP」、「HTTP」⋯等，其圖如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/545/0*0rBn6Hq4Hq6vS7GS.jpg" /></figure><p>實際上，「RPC」協議並沒有對實作模型有限制，所以上圖僅是其中的一種例子，更詳細的介紹可以參考「<a href="https://www.ibm.com/docs/en/aix/7.2?topic=concepts-remote-procedure-call">IBM Remote Procedure Call</a>」。</p><p>題外話，以「微服務架構」來說，若提到服務間的通信，其更被常提到的名詞是「<a href="https://www.redhat.com/zh/topics/api/what-is-a-rest-api">Restful API</a>」，那「RESTful API」與「RPC」的差異在哪？</p><p>起初，筆者以為「<a href="https://zh.wikipedia.org/wiki/%E8%A1%A8%E7%8E%B0%E5%B1%82%E7%8A%B6%E6%80%81%E8%BD%AC%E6%8D%A2">RESTful</a>」與「RPC」是兩種同層級的平行概念；但實際上，並不是的，兩者其實是不同的概念；「REST」是一種基於協議上的設計風格，如「HTTP」、「URI」、「XML」⋯等，但它本身並不是一種標準，它是面向資源，關注接口規範；而「RPC」是面向程式方法設計，用於解決複雜的遠端通訊協議；實際上，這個問題在「StackOverFlow」也曾有過相關的討論：「<a href="https://stackoverflow.com/questions/26830431/web-service-differences-between-rest-and-rpc">Web service differences between REST and RPC</a>」。</p><p>言歸正傳，先前筆者曾說，基於「RPC」的實現，使得「分散式系統」中的各遠端系統得以相互溝通，也因為如此，我們便可以把各系統中的共用部分抽走，建立成共用服務，圖如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ogZbOP8Wt1CLXF_2N6isGg.png" /></figure><p>如此一來，「垂直應用架構」的兩大痛點：「重覆造輪子」和「獨立系統間訊息傳遞不易」就有效地被解決了；此外，「單體應用架構」的問題：「不利於多人開發」和「程式彈性差、不易擴展」，在「分布式架構」中同樣得到了改善。</p><p>似乎一切都很美好，但真的就沒問題了嗎？</p><p>試想，當專案規模逐漸擴展，項目分拆越來越多，依賴越發複雜時呢？情況大概就會如下圖：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/617/1*6wGXxoUrMhvIRi6fnuNNVQ.png" /></figure><p>圖片資料來源：「<a href="https://zato.io/docs/intro/esb-soa-cn.html">ESB和SOA到底是什么？</a>」。</p><p>系統與服務之間的關係將越發錯綜複雜，耦合度變高，然後彼此關係難以疏理，最後走向無法維護，是吧？</p><p>事實上，除上述問題之外，由於該將架構缺乏統一管理，在資源調度上也會出現問題，尤其，若當某服務負荷過大，我們想以分流設計時，那系統層要如何導向？其依據為何？</p><p><strong>服務導向架構（Service-Oriented Architecture, SOA）</strong></p><p>因此，為了解決「分布式應用架構」所衍伸的資源調度與難以管理的次序依賴關係，所以又一個新的概念被提出來：「<a href="https://zh.wikipedia.org/wiki/%E9%9D%A2%E5%90%91%E6%9C%8D%E5%8A%A1%E7%9A%84%E4%BD%93%E7%B3%BB%E7%BB%93%E6%9E%84">服務導向架構</a>（SOA）」。</p><p>嚴格來說，「SOA」並不是一種技術，而是一種設計方法、一種概念。</p><p>根據「IBM」的「<a href="https://www.ibm.com/cloud/learn/soa">What is SOA?</a>」文中描述，「SOA」的目標就是「定義一種透過『服務介面』讓軟體元件『可以重複使用』的方式。」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*8Nm95QluqWV7uL2wTVD64A.png" /></figure><p>更直白地說，就是在各項服務之間建立一個「整合性介面」，然後由它統籌資源的調度與分派，可以參考「<a href="https://www.oreilly.com/library/view/hands-on-microservices/9781789133608/936cb8b7-b10c-4093-9001-17fddcca0b30.xhtml">Service-oriented architecture (SOA)</a>」，概念圖如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PvvhLVi274mfhHMjR2IhVg.png" /></figure><p>而「SOA」架構中，最關鍵的元件就是「整合性介面」，而「ESB」就是其中的一種實現的方式。</p><p>那何謂「<a href="https://zh.wikipedia.org/wiki/%E4%BC%81%E4%B8%9A%E6%9C%8D%E5%8A%A1%E6%80%BB%E7%BA%BF">ESB</a>」呢？在「IBM」的「<a href="https://www.ibm.com/tw-zh/cloud/learn/esb#toc-esb--Upk6FRnk">ESB（企業服務匯流排）</a>」一文中是這樣敘述的，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aGCcAIpVrWmJY303v9lByQ.png" /></figure><p>與「ESB」同樣為「SOA」框架的還有「<a href="https://dubbo.apache.org/zh/">Dubbo</a>」，官方對它描述如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LoOF2s0dgNBz9NG9E8pJ-A.png" /></figure><p>咦？「Dubbo3」的敘述是不是有些奇怪？是微服務框架，同時又是服務導向架構？</p><p>這問題我們晚點再說，我們先簡單總結一下，到底「SOA」是什麼？</p><p>它是面向「服務」的架構，就如同「<a href="https://www.cc.ntu.edu.tw/chinese/epaper/20070620_1008.htm">服務導向架構(Service-Oriented Architecture，SOA) 簡介</a>」一文中的概述：「『以客為尊』的核心概念，提供網路服務單位建構一個具彈性、可重複使用的整合性介面，加速達到網路服務提升的目標。」。</p><p><a href="https://zh.wikipedia.org/wiki/%E5%BE%AE%E6%9C%8D%E5%8B%99"><strong>微服務架構</strong></a>（Microservices）</p><p>最後是「微服務架構」。</p><p>所以「SOA」又有什麼問題呢？「微服務架構」又是為了解決什麼呢？</p><p>事實上，「微服務架構」的提出並不是因為「SOA」有什麼問題，更精確的說，「微服務架構」與「SOA」的面相並不同，這之後再說，在此之前，我們先來談一下「微服務架構」的定義。</p><p>什麼是「微服務架構」呢？</p><p>在「IBM」的「微服務」一文中，它是這樣敘述的，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bu-twpynVksodlNHly6m7g.png" /></figure><p>如上所述，「微服務」是「應用」的架構，它的概念就是將一個整體的應用服務拆分成眾多「可獨立部署的小型服務」，如下圖：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*en0UG-3XubbxfHXzOMuDyg.png" /></figure><p>但要注意的是，不論「微服務」如何分拆，在本質上，「微服務應用」仍舊是「一個應用」；而「微服務架構」就是一個專注於「解耦合」的「應用程式架構」。</p><p>接著，介紹一下關於「微服務」的基本組成要素，首先，在微服務架構中最主要的組成還是「服務群」本身。</p><p>而「服務群」基本是由眾多獨立且基於「單一職責」的小型服務所組成，每個小型服務都會是個完整且可以獨立部署的「系統」，在多數設計下，它們通常會擁有專屬的資料庫，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H0RCbS86fDAcINf7454bIw.png" /></figure><p>當然「服務群」可能還會根據性質不同區分為「業務服務類」、「功能服務類」⋯等，但這邊姑且不提，皆以「服務」視之。</p><p>這邊有一點要特別注意，微服務是允許多個同功能的服務同時存在，這是為了「分流」與「備援」的需求；因為每個服務可能會因為硬體限制有無法負載的情況，因此「分流」是必須的配置，至於在微服務中是如何調控資源則與它的另一個組成要件：「註冊中心」相關，這我們稍後再說。</p><p>而「備援」更是相對重要的概念，在探討微服務架構時，我們通常都會提到「<a href="https://zh.wikipedia.org/wiki/CAP%E5%AE%9A%E7%90%86">CAP</a>」的概念；「<a href="https://zh.wikipedia.org/wiki/CAP%E5%AE%9A%E7%90%86">CAP</a>」是評估微服務特性的重要指標之一，其完整的概念我們稍後在敘述，在此我們先談其中的「A」，它代表的是微服務的「<a href="https://zh.wikipedia.org/wiki/%E5%8F%AF%E7%94%A8%E6%80%A7">可用性</a>（Availability）」，意即，即使微服務中的某個小型服務發生異常，但整個微服務仍必須正常運作；而「備援」的機制就是為了讓微服務滿足「可用性」的設計。</p><p>接著來介紹微服務間的「溝通」方式。</p><p>在維基百科的介紹中，它說：「<a href="https://zh.wikipedia.org/wiki/%E5%BE%AE%E6%9C%8D%E5%8B%99">服務間『不應該』有所溝通，即使是有，也應該以『異步機制』來避免其相依問題</a>」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/679/1*pQT5NPSw_-DPP_Q3qyM1rg.png" /></figure><p>但現實是，服務與服務間幾乎不可能不相互溝通；甚至在部分的需求下，我們會需要以「同步機制」來達成服務間的溝通；對於這種相依性比較強的溝通方式，我們會稱為「直接溝通」。</p><p>在微服務的應用中，「直接溝通」最常使用的方式是符合「<a href="https://zh.wikipedia.org/wiki/%E8%A1%A8%E7%8E%B0%E5%B1%82%E7%8A%B6%E6%80%81%E8%BD%AC%E6%8D%A2">RESTful</a>」設計風格的「<a href="https://zh.wikipedia.org/wiki/%E8%B6%85%E6%96%87%E6%9C%AC%E4%BC%A0%E8%BE%93%E5%8D%8F%E8%AE%AE">HTTP</a>」協議，即「RESTful API」。</p><p>備註：「<a href="https://zh.wikipedia.org/wiki/%E8%B6%85%E6%96%87%E6%9C%AC%E4%BC%A0%E8%BE%93%E5%8D%8F%E8%AE%AE">HTTP</a>」協議僅是一種常見的「網路通訊協議」，其與「同步」或是「非同步」並沒有直接關係。</p><p>既然有直接溝通，那必然有「間接溝通」，「間接溝通」通常是藉由所謂的中間項目作為溝通的橋樑，如所謂的「<a href="https://zh.wikipedia.org/wiki/%E6%B6%88%E6%81%AF%E9%98%9F%E5%88%97">信息佇列</a>」機制、「事件儲存、廣播中心」；其兩者皆為「異步機制」；但「事件儲存、廣播中心」通常是「一對多」、「訂閱者模式」的實踐，而前者則依實作不同而可能有所差異，但通常支援「一對一」，也支援「一對多」。</p><p>關於微服務的通訊方式可以參考「<a href="https://docs.microsoft.com/zh-tw/dotnet/architecture/microservices/architect-microservice-container-applications/communication-in-microservice-architecture#communication-types">微服務架構中的通訊</a>」。</p><p>至此，架構圖如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*37fzZn16huN0TIcB7CG7EQ.png" /></figure><p>另外，由於小型服務間彼此是獨立的，所以彼此不能存在語言限制；這將與服務間的溝通方式有關，簡單的說，就是各個服務間傳遞的訊息要脫離語言框架。</p><p>關於「服務群」的特性還有一點就是：「服務間不能相互干擾」；也就是說假如倘若「服務 A」異常或無回應，那麼其它服務仍要正常運作，即使是其它的服務與異常的服務有「次序依賴」的關係，但它允許資料的不一致，例如，假設「獲取資料」的服務異常，那其相關功能可以顯示「暫時無法取得資料」，又或是顯示緩存服務中的數據資料；但不能因為其它服務的異常而跟著「異常」；這也是「<a href="https://zh.wikipedia.org/wiki/CAP%E5%AE%9A%E7%90%86">CAP</a>」定理中的「P」，即「分區容錯性（Partition tolerance）」。</p><p>在討論完「服務群」之後，接著是「資料儲存」的部分。</p><p>事實上，微服務的資料儲存架構的作法很多，但不論何種作法，都必須滿足資料的「可棄性」；也就是說，若某個服務內的資料丟失時，其不會影響整個微服務應用，常見的設計是除了每個小型服務中的獨立資料庫外，還會有共同資料庫，通常快取、緩存機制也都是必備的項目，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hAUQIDBYX4EDCWNBAhk9yw.png" /></figure><p>再接著是「微服務」管理的部分，像是與「資源調控」的有關的「註冊中心」，或是與系統設定有關「文件配置中心」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T9r3FYltEaIB0B-4S7xsIQ.png" /></figure><p>再然後是匯整接口信息的「網關閘道」；與負載保護、導分流相關的「熔斷器」、「負載平衡」；以及「日誌管理」、「鏈路追蹤」⋯等，煉成，圖如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TWf9XfWMR1AKbE7OU0JINQ.png" /></figure><p>呃，不是，是這個：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2p9opQKipGwyXzDy9kpFUA.png" /></figure><p>最後，有些書籍也會把「<a href="https://zh.wikipedia.org/wiki/CI/CD">CI/CD</a>」的部分視為微服務架構的一部分，那也是沒問題的。</p><p>但要特別注意的是，「微服務」是一種風格的概念，並不是真正的實現，因此，上述的圖僅是一個舉例，並不代表所有微服務的架構設計都該如此，例如先前多提到的「<a href="https://github.com/apache/dubbo">Dubbo</a>」框架，就與上述有些許差異，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vbreC5UDihbPwSHMbsR5GA.png" /></figure><p>講個古，「<a href="https://github.com/apache/dubbo">Dubbo</a>」是相當早期的框架，由「阿里巴巴」所研發，爾後開源給「Apache」，所以稱之「Apache Dubbo」。</p><p>在「<a href="https://github.com/apache/dubbo">Dubbo</a>」被開發的當時，微服務的概念並不如現在完善，因此，若拿之與現今的流行的「微服務」框架相比，會顯得比較不足；而「<a href="https://github.com/apache/dubbo">Dubbo</a>」的確是以「服務治理」為導向的架構，因此它是一種「SOA」。</p><p>那麼，是不是又回到稍早的問題了？</p><p>為什麼「<a href="https://github.com/apache/dubbo">Dubbo</a>」可以是「微服務架構」，又是「SOA」呢？</p><p>同樣地，這我們稍後再說。</p><p>言歸正傳，我們剛才說「<a href="https://github.com/apache/dubbo">Dubbo</a>」是一種「微服務架構」的實現，又說它略顯不足，那麼目前最夯的「微服務框架」是誰？</p><p>就撰文的當下，筆者認為非「<a href="https://spring.io/projects/spring-cloud">Spring Cloud</a>」莫屬，其圖如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_oC1sN05SP5S53BMmO5sCw.png" /></figure><p>事實上，「<a href="https://spring.io/projects/spring-cloud">Spring Cloud</a>」並非是種「單一技術或框架」，而是集合多項相關「開源項目」的技術棧，如「Eureka」、「Hystrix」、「Feign」⋯等，可以參考其「<a href="https://www.springcloud.cc/">中文網站</a>」，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T2MQLADqyC_xF-I3R9oWqg.png" /></figure><p>題外話，阿里巴巴基於「Spring Cloud」技術棧並整合「Dubbo」後，推出一套新的雲架構：「<a href="https://github.com/alibaba/spring-cloud-alibaba">Spring Cloud Alibaba</a>」；目前討論度相當高。</p><p>填個坑，為什麼「<a href="https://github.com/apache/dubbo">Dubbo</a>」可以是「微服務架構」，又是「SOA」呢？</p><p>在此之前，我們必須先來談談「微服務」與「SOA」的差別？事實上，這兩者的差異更多是在於「關注面向」的不同。</p><p>就如同「IBM」在「<a href="https://www.ibm.com/cloud/blog/soa-vs-microservices">SOA vs. Microservices: What’s the Difference?</a>」一文中所講描述的：「微服務」和「SOA」兩者所關注的「範圍」不同。</p><p>首先，「SOA」是「提供服務」的架構，以「客」為尊，面向的是「服務對象」；而「微服務」的本質是「應用」，它是個「程式架構」，所以面向自然是「應用本身」。</p><p>實際上，「SOA」可能由涉及一個或多個應用，如下圖：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J0Wt4dE096MSOzDtpAc51g.png" /></figure><p>介紹到這邊，懂了吧？由於「微服務」和「SOA」的關注面向不同，所以它們並非完全地對立，在某些關注點上，「微服務」和「SOA」可以說是不同層級的概念；而這就是為什麼「Dubbo」可以同時是「SOA」又是「微服務架構」的原因了。</p><p>不過雖說如此，但兩者間的確有不少相似可比較之處，例如在「治理」方面，「SOA」是仰賴「治理中心」的統一整合與調度，具有「中心管理」的概念，例如「ESB」⋯等，而「微服務」雖然也有「註冊中心」，但其目的只是控管資源而已，亦無中心的概念。</p><p>在「溝通信息」的方面，「微服務」為了保持簡單，通常會使用輕量級消息傳遞協議，如「RESTful API」；而「SOA」則是較具選擇彈性。</p><p>在「顆粒度」方面，「SOA」需要考量「服務範圍」，而「微服務」則更講究「單一職責區分」；因此，在理想情況下，「微服務」應該是「完全地鬆耦合」。</p><h4><a href="https://zh.wikipedia.org/wiki/CAP%E5%AE%9A%E7%90%86">「CAP」理論</a></h4><p>最後填個坑，談一下在討論「微服務架構」時，一定會被提到的「CAP」定理；它又被稱作「布魯爾定理」，內容是說「一『分布式計算系統』不可能同時滿足『一致性（Consistency）』、『可用性（Availability）』與『分區容錯性（Partition tolerance）』。」。</p><p><strong>可用性（Availability）</strong></p><p>接著，我們一一解釋「C」、「A」、「P」分別說代表的意義。</p><p>首先是「A」，根據維基上的描述，其定義是：「每次請求都能獲取到非錯的響應」。</p><p>下圖為一「請求-響應」的示例：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nC7bvgZb5iLmBJzuJrYBMw.png" /></figure><p>此時，倘若節點發生異常，是不是就意味著這個服務就失效了？圖如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9chMqcirqczbtrMe9Yt5YQ.png" /></figure><p>這樣的服務架構，就意味著缺乏可用性（Availability），因此，在散布式架構中，為了要讓服務具備可以性，我們通常會設置至少兩個以上的節點，如此一來，即使有一節點發生異常，那麼例外一個節點還是能夠正常提供服務，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9Tt7a_29Ff6IoBxKkgnsHg.png" /></figure><p><strong>一致性（Consistency）</strong></p><p>接著是「C」。</p><p>在微服務的架構中，每一節點都是獨立可部署的服務，意即它們都嘗試一個整體的服務，也擁有自己的數據副本，而一致性（Consistency），倘若兩節點是同樣服務，其數據副本的資料必須完全相同，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YyCUX3lmruCIjx0XbXz-0Q.png" /></figure><p><strong>分區容錯性（Partition tolerance）</strong></p><p>最後是「P」，「分區容錯性」，它的意思是說，不能因為某些節點消失或故障時，就停止提供服務。</p><p>在分別介紹「C」、「A」、「P」個別所代表的意思後，我們來探討它對微服務的意義。</p><p>首先，我們必須知道一個觀念：「微服務架構」是一種「分布式系統」；而「CAP」開宗就明講：完全符合「C」、「A」、「P」三個特性的「分布式系統」是不存在的，所以當我們在設計微服務架構時，我們僅能依照需求去選擇「CA」、「CP」或「AP」的相關技術，如下圖：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/671/1*g3JWFrU4QZYEl5ar00G-ug.png" /></figure><p>圖片來源為「<a href="https://www.w3resource.com/mongodb/nosql.php">w3resource</a>」。</p><p>事實上，在分布式系統中，零「P」，即「CA」，是幾乎不可能存在的，這是因為「分布式系統」的溝通通常是仰賴「網路通訊」的，而「網路傳輸」一詞也就意味著它不可能完全地穩定。</p><p>所以我們在評估技術時，通常只能在「AP」或「CP」中選擇，至於該如何考量，這就不是我們這篇文章的內容了，總之，我們要了解的是，「CAP」是一套用來評估的分布式系統的理論，其它關於「CAP」理論更多的資訊可以參考「<a href="https://medium.com/@thegiive/cap-%E7%90%86%E8%AB%96-19cd81c82658">CAP 理論</a>」。</p><h3>總結</h3><p>回顧網站架構的發展過程，也許現行的架構與網站初期時的架構已經大相徑庭；但我們可發現，其過程是有跡的，是循序的，所有的架構被提出都是有其淵源，或許是為了解決問題，也或許是為了特定目的；但除了其各自的關注點外，其幾乎都圍繞著一個共同的核心：「容易管理、高維護性」。</p><p>的確，好的架構與好的套件的確能夠有效的幫助我們撰寫出一套相對容易維護與管理的程式。</p><p>但別忘了，撰寫程式碼的始終是程式設計人員本身，我們不僅是程式的「開發者」，更是程式的「維護者」；倘若自己不刻意維持良好的撰寫習慣，那不論是多嚴謹地架構，又或是如何地規範，那也是無功用。</p><p>倘若如此，那麼既使我們從「單體式架構」換到「微服務架構」，也不過就是從「屎」變成「許多屎」而已，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*TLNWh1PF12ihrX1BN72kPA.png" /></figure><p>圖片來源：「<a href="https://weihanglo.tw/posts/2020/www-0x05/">WWW 0x05: 若單體服務是屎，微服務就是許多屎</a>」。</p><p>最後，於網站設計而言，架構本身並沒有高下之分，更沒有所謂的完美，有的只是合不合適，僅此而已；此外，既然沒有完美的架構存在，架構的發展必然不會停止。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bae068ea6e2d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[淺談「Hash」、「Hashtable」與「HashMap」]]></title>
            <link>https://rickbsr.medium.com/%E6%B7%BA%E8%AB%87-hash-hashtable-%E8%88%87-hashmap-4e5f5e5d36da?source=rss-4a9adf38ab9------2</link>
            <guid isPermaLink="false">https://medium.com/p/4e5f5e5d36da</guid>
            <category><![CDATA[programing-language]]></category>
            <category><![CDATA[java-basics]]></category>
            <dc:creator><![CDATA[Rick]]></dc:creator>
            <pubDate>Fri, 20 Aug 2021 17:35:21 GMT</pubDate>
            <atom:updated>2021-08-20T17:35:21.594Z</atom:updated>
            <content:encoded><![CDATA[<h4>Programing Language：Java Basics</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W6L7XfrReNky_O6QW-qPyQ.jpeg" /></figure><h3>概論</h3><p>本篇要討論的主題是「Hash」、「Hashtable」與「HashMap」；雖然它們都有「Hash」，但前者與後兩者是不一樣的兩件事。</p><p>更進一步的說，其實「Hash」是一種「演算法的概念」，而「Hashtable」與「HashMap」則是一種與「Hash」相關的資料結構實作。</p><p>由於筆者非本科出身，所以「演算法」與「資料結構」一直以來都是筆者相對比較不足的項目；但架不住重要啊，所以只能硬著頭皮上了，若各位發現本文有任何觀念不正確或解釋不清楚的地方，還請不吝賜教。</p><h3>正文</h3><h4>雜湊：「<a href="https://computersciencewiki.org/index.php/Hashing">Hash</a>」</h4><p>首先，我們先來介紹本文的主角：「Hash」，中譯為「雜湊」，其中文的是「切碎」、「拼湊」的意思；因此，「Hash」就是一個將東西切碎後再重新拼湊的過程。</p><p>就資料結構的來說就是：將原資料經過散列處理後，再拼湊成新的資料。</p><p>其中用來切碎資料的那把「菜刀」就是「<a href="https://zh.wikipedia.org/wiki/%E6%95%A3%E5%88%97%E5%87%BD%E6%95%B8">Hash Function</a>」，中譯為「雜湊函示」，它是一種「演法算」，常見的雜湊演算法例如「<a href="https://zh.wikipedia.org/wiki/MD5">MD5</a>」、「<a href="https://zh.wikipedia.org/wiki/SHA-1">SHA-1</a>」、「<a href="https://zh.wikipedia.org/wiki/SHA-2">SHA-2</a>」⋯等；要注意的是，關於「雜湊算法」的特性中，最重要的是它必須具備「不可逆」的特性。</p><p>最後，經過「雜湊算法」演算後所產生的值就被稱為「Hash Code」，中譯為「雜湊碼」，整體概念圖如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*pWQDmcIGtwv55SBT.png" /></figure><p>題外話，如果覺得文字不好理解的話，可以參考影片：「<a href="https://www.youtube.com/watch?v=vPvxEDyxI2w&amp;list=PLhxdaTcUMi3nRM5mtOdQgO4VEtAEsTiYd&amp;index=19&amp;t=304s">輕鬆搞懂資料結構: 雜湊(hash)</a>」，說明地還滿淺顯易懂的。</p><h4>雜湊的應用</h4><p>關於「雜湊」的應用，筆者想補充一個重要的觀念，就是「『雜湊』與『加密』是不同的兩件事情；其最大的差異在於『雜湊』必須具有不可逆的特性。」，這與其「目的」有關。</p><p>試想，「加密」的最終目的是什麼？</p><p>答案是「傳遞資料」，不論是「<a href="https://zh.wikipedia.org/wiki/%E5%B0%8D%E7%A8%B1%E5%AF%86%E9%91%B0%E5%8A%A0%E5%AF%86">對稱加密</a>」或是「<a href="https://zh.wikipedia.org/wiki/%E5%85%AC%E5%BC%80%E5%AF%86%E9%92%A5%E5%8A%A0%E5%AF%86">非對稱加密</a>」的目的都是為了要保護資料，避免資料在不小心外洩時能「不被讀懂」，但其最終的目的還是要讓目標對象能「讀懂」資料，所以它必須是「可逆」的。</p><p>但「雜湊」則不需要還原資料，其常的應用如「數位簽章」、「資料完整性的驗證」、「密碼的傳輸與保存」⋯等。</p><p><a href="https://zh.wikipedia.org/wiki/%E6%95%B8%E4%BD%8D%E7%B0%BD%E7%AB%A0"><strong>數位簽章</strong></a></p><p>「<a href="https://zh.wikipedia.org/wiki/%E6%95%B8%E4%BD%8D%E7%B0%BD%E7%AB%A0">數位簽章</a>」的目的是要驗證資料來源的正確性，就如同「防偽標籤」。</p><p>倘若我們今天要傳一份資料傳輸給遠端目標，那「目標對象」如何能知道其所接收到的資料是正確的呢？</p><p>其作法就是將要傳輸「數據資料」經過「Hash」，並將其產生的「Hash Code」作為「簽名憑證」並加密後與「數據資料」一併傳輸；而「接受者」只要將收到的「數據資料」經過同樣「Hash Function」處理，比將接收到並經過解密後的「簽名憑證」比對，就能分辨資料真偽，概念圖如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uGWdSautNeVGQhqoo8Sziw.png" /></figure><p>這樣的作法可以防止所謂的「<a href="https://zh.wikipedia.org/wiki/%E4%B8%AD%E9%97%B4%E4%BA%BA%E6%94%BB%E5%87%BB">中間人攻擊</a>」。</p><p>試想，倘若「Hash」是可逆的，這樣當中間人拿到「簽名檔」，只要將其逆向處理，那不就可以得到原資料？</p><p><a href="https://docs.microsoft.com/zh-tw/dotnet/standard/security/ensuring-data-integrity-with-hash-codes"><strong>資料完整性的驗證</strong></a></p><p>而「雜湊」用「驗證資料的完整性」的原理有些類似。</p><p>假如我們經網路傳輸獲取一「數據資料」，那我們要如何辨識該資料是否完整，是否有在傳輸過程中損毀？</p><p>其原理為「相同的數據」其經過相同的「Hash Function」運算後，其產生的「雜湊值」必為「相同」，且具有唯一性，意即「不同的數據」就算經過相同的「Hash Function」運算，也不可能產生相同的「雜湊值」。</p><p>為什麼要用雜湊值作為比對的依據？</p><p>這是因為，原則上，不論「數據資料」的大小，其經運算後的雜湊值都應為一固定長度的數值；也就是說，即使今天「數據資料」再大，但因為其經運算後的雜湊值為固定大小，所以當我們要驗證資料完整性時，僅需要比對「雜湊值」即可，能大幅減少比對成本。</p><p><strong>密碼的傳輸與保存</strong></p><p>在網路的世代，「密碼」經常是資安漏洞所在，事實上，我們幾乎不可能阻止密碼在網路傳遞時被竊取；即使現在的傳輸普遍都以「<a href="https://zh.wikipedia.org/wiki/%E8%B6%85%E6%96%87%E6%9C%AC%E4%BC%A0%E8%BE%93%E5%AE%89%E5%85%A8%E5%8D%8F%E8%AE%AE">HTTPS</a>」，也就是輔以「<a href="https://ithelp.ithome.com.tw/articles/10219106">TLS</a>」的「HTTP」協定。</p><p>因此，在一些資安規格要求比較高的系統，如金融系統；通常會將密碼先加密在進行「HTTPS」傳輸。</p><p>此外，關於密碼的規範還有一常見的原則：「密碼不落地」。</p><p>因為密碼不僅可能在「網路傳輸」時被竊取，也可能在「保存」時被盜取的，以手機登陸「行動銀行 APP」為例，密碼可能被存放於「手機」的儲存空間或是銀行端的資料庫；那麼當「手機」失竊時，是否有機會被破解呢？又或是有駭客攻破銀行系統時呢？</p><p>我們先來討論「Client」端，以會員登入為例子，在登入頁面時，應該有一個常見的功能為「自動登錄」吧？試想它密碼存於何處？</p><p>所以在「Client」端通常還是會以「加密」或「Hash」來處理，「加密」還容易理解，那為什麼「Hash」亦可以呢？</p><p>這跟「Server」端的所存放的密碼資料有關係，試想一下，當你在登入頁面選擇「忘記密碼」選項時，是不是通常有兩種處理方式，第一種方式是網站「直接」將密碼以「E-mail」的方式告知；這種情況就代表著「系統」必須儲存使用者的「密碼」。</p><p>其第二種，同樣是以「E-mail」寄送，只是內容不是直接告知密碼，而是需要我們根據信中連結自行修改密碼；在種情況下，「系統」僅須儲存使用者「密碼的 Hash 值」即可。</p><p>倘若有一天，網站系統被駭客攻破且系統資料庫外洩時；此時，如果外洩的資料只是「Hashed Text」，而非真實客戶資料，是不是就能降低其「資料外洩」所造成的損害？</p><p>實際上，即使是以「Hash Code」作為資料存放也並不是絕對的安全；當駭客竊取到「Hashed Text」後，他可以藉由「彩虹表」的方式來解譯；而其相對應的解法就是：「加鹽加密法」。</p><p>舉這個例子是想說，資安的議題可大可小，也可分為不同層級探討，至於資安等級要到何種程度，這端看網站設計的需求，不必無限上綱，造成不必要的效能損耗。</p><p><a href="https://zh.wikipedia.org/wiki/%E7%BC%96%E7%A0%81"><strong>編碼</strong></a><strong>的概念</strong></p><p>既然都講到這邊了，就額外再補充個「<a href="https://zh.wikipedia.org/wiki/%E7%BC%96%E7%A0%81">編碼</a>」的觀念吧。</p><p>事實上，「編碼」跟「加密」很類似，都是數據格式轉換的一個過程，更正確的說，「加密」也是一「編碼」過程，只是「編碼」的目的是為了保護資料。</p><p>但編碼的目的可能是為了任何需求，例如「<a href="https://zh.wikipedia.org/wiki/Base64">Base 64</a>」，其目的是為了「讓二進位資料能夠以 64 個基本字元來表示」，常用於資料的傳輸與保存，但因為其編譯的方式是公開的，因此不具任何加密功能；所以「<a href="https://zh.wikipedia.org/wiki/Base64">Base 64</a>」是一種「編碼」機制，而非是一種「加密」機制。</p><h4>雜湊表：「<a href="https://en.wikipedia.org/wiki/Hash_table">Hash Table</a>」</h4><p>其實關於「Hash」的應用，還有一項是目前尚未提到的，就是用於「資料結構」的演算上，這我們稍候再繼續介紹，但在此之前，我們先來一種資料結構的概念：「Hash Table」。</p><p>簡單的說，「Hash Table」其實就只是一種以「Hash」概念方式實作「映射機制（Key-Value）」的資料結構，更直白的說，就是一種以「Key-Vaule」機制存放資料的結構容器。</p><p>其作法是這樣的，首先我們會先將資料的「Key」經過「Hash Function」運算，並將運算後產生的「Hashed Text」作為索引，並將資料「Value」放入與「索引」連結的「Buckets」內，示意圖如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8pVPatPxs6fheqxH.png" /></figure><p>而上述機制中，存放對應資訊的表格，就稱為「映射表」。</p><p>因此，在該機制下，倘若我們在要獲取「Value」時，我們只要根據「映射表」就能夠輕易地根據「Hashed Key」找到相對應「Value」，因為是查表法，所以在理想的情況下，它的查找效率極佳，其擁有「O(1)」的時間複雜度。</p><p>但所謂的理想狀態是指未出現「雜湊碰撞」的情況下，所謂的雜湊衝突是指兩個不同的「Key」經「Hash Function」運算後產生相同的「Hash」值，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KonJLktOKSNjqU82.png" /></figure><p>當出現「雜湊碰撞」時，「Hash Table」的效能就可能會受到影響，若是衝突項目是以「<a href="https://en.wikipedia.org/wiki/Discrete_uniform_distribution">均勻分佈</a>」的情況散佈仍符合預期，但倘若「分佈不均」，甚至是出現極端「大象腳」的情況時，其效能就會顯著下降。</p><p>備註：「大象腳」即大多數的「Key」值經過運算後都產生相同的「雜湊值」，並導致多數的資料都存於同一個「桶子」中。</p><p>根據上述內容，我們不難推測，實際上影響「Hash Table」效能優劣的最主要因素是「Hash Function」。</p><p>雖然筆者在先前曾說過，在「Hash Code」必須是唯一值；但若「雜湊演算法」本身過於複雜，也容易使得在建立「Table」時的損耗過高，所以當我們在設計雜湊函示時，使用情境與需求也是相當重要的考量因素，例如在「資料容器」的「雜湊算法」設計時，假如我們的最終目的是要讓資料查找變得容易，也許我們只要讓資料經「Hash」再分配後，能夠被「均勻散佈」即可，並不一定需要做到「唯一」，此時，當我們在設計該算法時，就可以設計的相對簡單一些，只要能符合需求的即可，畢竟，「唯一」本身就是一種成本。</p><p>但在多數情況下，我們還是會期望「Hash」的結果會是唯一值，尤其當我們將其作為「數位簽章」用時，或者是用於「驗證資料的完整性」時。</p><p><strong>雜湊碰撞的處理</strong></p><p>講一個比較不相干的話題：「雜湊碰撞」的處理方式。</p><p>若當「雜湊碰撞」出現時，最常見的處理方式是「鏈結串列」，即發生碰撞時，新的元素串接在既有元素之後；這是屬於「Closed Addressing」的實作方式之一。</p><p>而「Closed Addressing」又稱為「Separate Chaining」，與之相異的是「<a href="https://en.wikipedia.org/wiki/Open_addressing">Open Addressing</a>」，其常見的實作方式有「<a href="https://en.wikipedia.org/wiki/Linear_probing">Linear Probing</a>」、「<a href="https://en.wikipedia.org/wiki/Quadratic_probing">Quadratic Probing</a>」以及「<a href="https://en.wikipedia.org/wiki/Double_hashing">Double Hashing</a>」，至於原理跟實作細節，讀者們可以自行點連結閱讀，在此就不多說了。</p><p>關於「開放尋址」與「閉鎖尋址」的差異可以參考「<a href="https://stackoverflow.com/questions/9124331/meaning-of-open-hashing-and-closed-hashing">Meaning of Open hashing and Closed hashing</a>」。</p><p>若覺得太複雜，不太明白也沒關係，總之，我們只需要知道 ：「『Hash Table』是一種『Key-Value』的資料結構即可」。</p><h4>「Java」中的「<a href="https://docs.oracle.com/javase/10/docs/api/java/util/Hashtable.html">Hashtable</a>」類</h4><p>就如同先前所介紹，「Hash Table」僅是一種資料結構的「概念」。</p><p>由於「Key-Value」是一種常見，且相當實用的資料結構，因此幾乎在各程式語言中都有實作，而其在「Java」中的實作就是「<a href="https://docs.oracle.com/javase/10/docs/api/java/util/Hashtable.html">Hashtable</a>」類；官方文件對其介紹如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UG0c3sBqv8p_ek7QC4q0Zg.png" /></figure><p>事實上，「Hashtable」類相當古老，從「JDK 1.0」開始就存在；在當時，連「<a href="https://docs.oracle.com/javase/10/docs/api/java/util/package-summary.html#CollectionsFramework">Java Collections Framework</a>」的概念都還未曾出現，「<a href="https://www.runoob.com/java/java-data-structures.html">數據結構</a>」還是由一群功能類別所負責，其中的「<a href="https://docs.oracle.com/javase/10/docs/api/java/util/Dictionary.html">Dictionary</a>」類就是屬於「Key-Value」的資料結構，而「Hashtable」就是繼承「<a href="https://docs.oracle.com/javase/10/docs/api/java/util/Dictionary.html">Dictionary</a>」的具體實現類。</p><p>直到「JDK 2.0」時，「Java」提出「<a href="https://docs.oracle.com/javase/10/docs/api/java/util/package-summary.html#CollectionsFramework">Java Collections Framework</a>」的概念與規範，而「Hashtable」被重構，實作「<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html">Map</a>」介面，並被歸類於之中。</p><p>而「Hashtable」最大的特性就是它是「Synchronized」，它支持「執行序安全」，並且「Key」與「Value」皆不允許為「null」。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/870/1*Xoxc1wUG2RMwt7qA2Ap4FA.png" /></figure><p>最後，事實上，「Hashtable」是一個不建議使用的類別，就如官方文件上所敘述，在「JDK 5.0」之後，若有「執行序安全」且屬於「Key-Value」資料結構的需求，建議以「<a href="https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ConcurrentHashMap.html">ConcurrentHashMap</a>」取代之。</p><h4>「<a href="https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ConcurrentHashMap.html">ConcurrentHashMap</a>」類</h4><p>「<a href="https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ConcurrentHashMap.html">ConcurrentHashMap</a>」的官方介紹如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*admA7XjYWN39GzMO-1x8Kg.png" /></figure><p>作為「Hashtable」的替代品，它的功能規範幾乎與「Hashtable」一致，我們可將之視為「Hashtable」的優化類別，並且同樣是屬於「<a href="https://docs.oracle.com/javase/10/docs/api/java/util/package-summary.html#CollectionsFramework">Java Collections Framework</a>」的成員。</p><h4>「<a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html">HashMap</a>」類</h4><p>最後是「<a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html">HashMap</a>」類，它是「Java」中，屬於「Key-Value」類型的資料結構中最常被使用的容器，沒有之一，官方介紹如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MfFQMjO2qFoftF8kaWHGyw.png" /></figure><p>事實上，它與「<a href="https://docs.oracle.com/javase/10/docs/api/java/util/Hashtable.html">Hashtable</a>」類似，並常被與之比較，如討論串：「<a href="https://stackoverflow.com/questions/40471/what-are-the-differences-between-a-hashmap-and-a-hashtable-in-java?rq=1">What are the differences between a HashMap and a Hashtable in Java?</a>」。</p><p>簡單地說，「<a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html">HashMap</a>」類不支持「執行序安全」，因此它具備更好的執行效率，同時也可以接受「null」值作為「Key」或「Value」。</p><p>題外話，「<a href="https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html">HashMap</a>」在「JDK 1.7」與「JDK 1.8」的實現原理略有不同，不過這會牽扯很多演算法的細節，考慮篇幅不足，筆者也相對不熟悉，故就不在此細談了。</p><h4><strong>「</strong><a href="https://docs.oracle.com/javase/tutorial/collections/interfaces/collection.html">Collection</a><strong>」與「</strong><a href="https://docs.oracle.com/javase/tutorial/collections/interfaces/map.html"><strong>Map</strong></a><strong>」的比較</strong></h4><p>因為筆者曾聽人說過：「Map」是「Collection」的一種。</p><p>錯，雖然「Map」與「Collection」同屬於「<a href="https://docs.oracle.com/javase/10/docs/api/java/util/package-summary.html#CollectionsFramework">Java Collections Framework</a>」的成員之一，但它們之間並沒有繼承關係，請參考討論串：「<a href="https://stackoverflow.com/questions/19550793/what-is-the-difference-between-a-collection-and-a-map">What is the difference between a Collection and a Map?</a>」的最佳回答，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/741/1*XHFADOYpMRX1F0_jyhincg.png" /></figure><p>另外，可以參考「<a href="https://zh.wikipedia.org/wiki/Java%E9%9B%86%E5%90%88%E6%A1%86%E6%9E%B6">Java集合框架</a>」中繼承樹圖，首先是「Collection」的繼承樹圖，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YpC8EizgJe2nJis1sD5feQ.png" /></figure><p>由上圖可知，繼承「Collection」的介面有「Set」、「List」和「Queue」，但並沒有「Map」，而「Map」的繼承樹圖，如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sH5Kz6-M8EhffRbwqpm83w.png" /></figure><h3>總結</h3><p>簡單整理一下，首先是「Hash」，它就是將數據資料經過「雜湊運算」並產生「雜湊碼」的過程。</p><p>然後是「Hash Table」，它其實就只是一種以「Hash」概念方式實作「映射機制（Key-Value）」的資料結構，而「Hashtable」類與「HashMap」類是「Hash Table」在「Java」中的實現類，且同為「<a href="https://docs.oracle.com/javase/10/docs/api/java/util/package-summary.html#CollectionsFramework">Java Collections Framework</a>」的一員，其最大的差別在於「Hashtable」類支持「執行緒安全」，「HashMap」類則無。</p><p>另外，「<a href="https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ConcurrentHashMap.html">ConcurrentHashMap</a>」是「Hash Table」的優化類，並建議以之作為替代。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4e5f5e5d36da" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>