<?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 Evan Chen on Medium]]></title>
        <description><![CDATA[Stories by Evan Chen on Medium]]></description>
        <link>https://medium.com/@evanchen76?source=rss-cdd80585381e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*0xWbwS8RvSdALOSRXlOUHg.jpeg</url>
            <title>Stories by Evan Chen on Medium</title>
            <link>https://medium.com/@evanchen76?source=rss-cdd80585381e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 19:01:58 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@evanchen76/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[用 OKF 打造 PM、RD、QA 共用的 AI 知識庫]]></title>
            <link>https://evanchen76.medium.com/%E7%94%A8-okf-%E6%89%93%E9%80%A0-pm-rd-qa-%E5%85%B1%E7%94%A8%E7%9A%84-ai-%E7%9F%A5%E8%AD%98%E5%BA%AB-3bc374313479?source=rss-cdd80585381e------2</link>
            <guid isPermaLink="false">https://medium.com/p/3bc374313479</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[okf]]></category>
            <dc:creator><![CDATA[Evan Chen]]></dc:creator>
            <pubDate>Wed, 11 Nov 2026 02:38:39 GMT</pubDate>
            <atom:updated>2026-11-11T02:38:39.784Z</atom:updated>
            <content:encoded><![CDATA[<p>這篇文章要介紹怎麼做一個需求知識庫：PM、RD、QA 對需求有任何問題都能來查，AI agent 寫需求、寫 code、產生測試案例時也參考同一份。在我們團隊，同一個功能的需求原本散在 Confluence 的好幾個版本、Jira 留言和 Slack 訊息裡，人要自己拼湊出目前的規則，AI 則要靠每個人在 prompt 裡補。</p><p>講到知識庫，很多人會先想到 RAG：把現有文件切塊、建向量索引，問題進來再檢索相關段落交給模型回答。這篇要介紹另一種做法：由 LLM 把散落的需求整理成一組 OKF（Open Knowledge Format）格式的 Markdown 檔案，經過 PM 確認後當作唯一的事實來源，AI agent 直接讀這些檔案和檔案之間的連結。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o9lXOWxXSErusomrggBCCw.png" /></figure><h4>檢索不出哪一版才是現在的需求</h4><p>RAG 檢索的是現有文件，但一份需求通常會隨著變更累積成好幾份文件：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H7wHfxPer85tMtY-NvA_JQ.png" /></figure><p>第一版寫了完整的需求描述，7 月 8 日的修改只寫差異，7 月 20 日又出了第二版。使用者問「現在的規則是什麼」，AI 檢索到三份文件，但哪些舊內容被取代了，文件裡沒有寫。檢索做得再準，拿到的也是三份互相矛盾的片段。</p><p>理想的情況是每次需求變更後，有人把新內容合併回一份「目前有效」的文件。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aVxqpaXNnHKyXBhHUOVYLA.png" /></figure><p>這件事需要持續整理知識，很吃力，也不是每個 PM 都有時間做。而且真實情況通常更複雜，知識不只在 Confluence：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WLu4iKcPeHn8EpDtjBzROQ.png" /></figure><p>QA 在 Jira 問了一個情境怎麼處理，PM 回覆「改成以 B 案為準」；Slack 私訊裡有口頭確認的細節，群組裡有臨時決定的規則；還有一部分只存在資深工程師的腦中。這些來源各自都可能是對的，也可能已經過期。RAG 會把它們一起檢索出來，但不會告訴你誰是對的。</p><h4>LLM Knowledge Base：讓 LLM 把原始資料編譯成 wiki</h4><p>2026 年 4 月，Andrej Karpathy 分享了他的 <a href="https://x.com/karpathy/status/2039805659525644595">LLM Knowledge Base</a> 做法。他把 LLM 當成編譯器：原始資料進來之後，LLM 不只建索引，而是讀懂、摘要、分類、交叉連結，把知識整理成一座結構化的 Markdown wiki。下次查詢時直接從 wiki 找，不必每次從原始資料重新推導。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iv7e1_SbXVQdX1hykhO_dA.png" /></figure><p>這個做法有三個組成：</p><ul><li><strong>原始來源（raw sources）</strong>：文章、論文、repo、資料集、圖片等，收到時的原貌。</li><li><strong>Wiki</strong>：一個由 LLM 產生與維護的 Markdown 檔案目錄。</li><li><strong>Schema</strong>：一份告訴 LLM 怎麼整理 wiki 的文件，例如 Claude Code 的 CLAUDE.md 或 Codex 的 AGENTS.md。</li></ul><p>LLM 編譯出來的內容包括每份來源的摘要、文件之間的反向連結、把資料歸納出的概念、針對每個概念寫的文章，以及一份 index.md 索引。wiki 裡的所有內容都由 LLM 撰寫與維護。</p><p>回到前面需求合併的問題：新需求進來後，要有人把它和既有文件合併成最新的一份。這正是 LLM 編譯在做的事 — — 讀懂新舊內容、整合、更新連結，再維護索引。散落在 Confluence、Jira、Slack 的內容也能當成原始來源，由 LLM 整理進同一份知識。人的工作從「自己合併文件」變成「確認 LLM 合併的結果」。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UTrrR-t9XvNy3Y9a_8TWrA.png" /></figure><h4>OKF 定義知識檔案的格式</h4><p>Karpathy 的做法說明了流程，但沒有規定檔案該長什麼樣子。<a href="https://github.com/GoogleCloudPlatform/open-knowledge-format">OKF</a> 是 Google Cloud 在 2026 年 6 月推出的開放規格，用來表示人和 agent 都能讀的知識。它的設計目標是：</p><ul><li>人類不需要工具就能閱讀。</li><li>agent 不需要客製化 SDK 就能解析。</li><li>可以在版本控制裡比對差異。</li><li>可以跨工具、跨組織、跨時間移植。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ijzOVq1QPNt7UkLoDqBQCw.png" /></figure><p>OKF 的「開放」指的是它只定義格式：沒有綁定平台、沒有規定架構，也沒有規定什麼時候用什麼 skill。只要能讀寫檔案、能用 git，就能管理一份 OKF 知識庫。</p><h4>每份檔案是 frontmatter 加 Markdown 本文</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j4i6KYF-KMMLghTUfNF1xA.png" /></figure><p>OKF 的一份檔案描述一個概念。檔案開頭是 YAML frontmatter，用來描述這份文件本身：</p><pre>---<br>type: &lt;Type name&gt;                  # 必填<br>title: &lt;Optional display name&gt;<br>description: &lt;Optional one-line summary&gt;<br>resource: &lt;Optional canonical URI for the underlying asset&gt;<br>tags: [&lt;tag&gt;, &lt;tag&gt;, ...]          # 選用<br>---</pre><ul><li>type：概念的種類，是唯一的必填欄位。讀取的程式用它來路由、過濾與呈現。</li><li>title：給人看的顯示名稱，省略時可以從檔名推導。</li><li>description：一句話總結這個概念，產生 index.md、搜尋摘要和預覽時會用到。</li><li>resource：這個概念描述的底層資產的 URI，例如一張 BigQuery 資料表。描述抽象概念時就不填。</li><li>tags：跨領域分類用的標籤。</li></ul><p>本文用 Markdown 的標題、清單、表格和程式碼區塊來寫，而不是自由散文。結構化的本文讓人容易掃讀，也讓 agent 可以依標題找到要的段落。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3TB6CzFdWrHeknXpAGCRRA.png" /></figure><h4>用 index.md 與 log.md 串起整個目錄</h4><p>每一層目錄可以有一份 index.md，依區塊列出底下的文件與一句描述：</p><pre># Section / Group Heading</pre><pre>* [Title 1](relative-url-1) - short description of item 1<br>* [Title 2](relative-url-2) - short description of item 2</pre><pre># Another Section</pre><pre>* [Subdirectory](subdir/) - short description of the subdirectory</pre><p>log.md 記錄該範圍的變更歷史，依日期分組，最新的在前：</p><pre># Directory Update Log</pre><pre>## 2026-05-22<br>* **Update**: Added a BigQuery table reference for [Customer Metrics](/tables/customer-metrics.md).<br>* **Creation**: Established the [Dataplex Playbook](/playbooks/dataplex.md).</pre><pre>## 2026-05-15<br>* **Initialization**: Created foundational directory structure.</pre><p>因為整份知識庫就是 Markdown 檔案加上連結，用 Obsidian 打開就能看到文件之間的關聯圖：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sHViHbCRvMWkdXesOlnlKw.png" /></figure><h4>一份電商需求知識庫的結構</h4><p>我用一個電商系統做了範例：<a href="https://github.com/evanchen76/okf-example">evanchen76/okf-example</a>。系統有營運人員用的後台和消費者用的商城，在 demo/ 底下用靜態伺服器就能開起來：</p><pre>cd demo<br>python3 -m http.server 8000</pre><p>後台在 http://localhost:8000/admin/，商城在 http://localhost:8000/web-store/。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6oWhMCYnLk08zalG6WTaeA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2uBRc7OIXxBWCVNRmK4ohw.png" /></figure><p>知識庫的目錄長這樣：</p><pre>okf-sample/<br>├── CLAUDE.md        # 根入口<br>├── raw/             # 原始需求<br>└── requirements/    # 需求知識<br>    ├── index.md<br>    ├── admin/       #   後台<br>    ├── web-store/   #   商城<br>    └── domain/      #   業務規則</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S9KdjuyZnWkQV1-sq5rFoQ.png" /></figure><p>raw/ 放 PM 交來的原始需求，保持收到時的原貌；requirements/ 是 LLM 從 raw/ 編譯出來的需求知識，依後台、商城和跨系統的業務規則分目錄。</p><h4>依系統要描述的內容決定知識的 type</h4><p>OKF 只規定要有 type，type 有哪些由你自己定義。我先看這個系統的需求要描述哪些東西：某個頁面長什麼樣、使用者在頁面上做了某個操作會發生什麼、跨頁面共用的業務規則、資料的欄位定義。於是定了四種 type：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IonhU6cX2OQmyheDxnJMcw.png" /></figure><p><strong>Page</strong> 描述一個頁面有哪些區塊、能做哪些操作、有哪些狀態：</p><pre>---<br>type: Page<br>title: 購物車頁<br>description: 消費者檢視購物車內的商品，可調整數量、移除，並看到小計與合計。<br>module: cart<br>system: web-store<br>timestamp: 2026-10-09T00:00:00Z<br>---<br># 頁面區塊<br>## 商品清單<br>## 合計<br># 頁面操作<br># 頁面狀態<br></pre><p><strong>Action</strong> 描述一個操作的觸發條件、驗證與結果：</p><pre>---<br>type: Action<br>title: 加入購物車<br>description: 消費者在商品頁把商品放進購物車，每次加 1 件；超過數量規則時不加入並提示原因。<br>module: cart<br>timestamp: 2026-10-09T00:00:00Z<br>---<br><br># 觸發條件<br># 驗證<br># 結果</pre><p><strong>Domain</strong> 描述跨頁面共用的業務規則：</p><pre>---<br>type: Domain<br>title: 購物車規則<br>description: 購物車項目的組成、數量與種類上限、失效商品的處理，以及購物車的保存方式。<br>module: cart<br>timestamp: 2026-10-09T00:00:00Z<br>---</pre><pre>## 數量規則</pre><pre>## 失效商品</pre><pre>## 保存</pre><p><strong>Entity</strong> 描述資料的業務欄位：</p><pre>---<br>type: Entity<br>title: 商品模型<br>description: 商品主檔的欄位定義（一個商品一個售價），後台表單填寫、商城商品頁顯示皆參照此模型。<br>module: product<br>timestamp: 2026-10-08T00:00:00Z<br>---</pre><pre>| 業務名稱 | 說明 |<br>| ---- | ---- |<br>| 商品名稱 | 營運填寫，最多 60 字 |<br>| 售價 | 消費者實際付款的單價 |<br>| 可售數量 | 歸零後不可加入購物車 |</pre><pre>## 商品分類</pre><p>LLM 編譯的重點，就是把一份原始需求拆進這四種 type。PM 的需求裡常把頁面、操作和規則寫在同一段，編譯時把「原價不得低於售價」這種會被多個頁面引用的規則抽出來放進 Domain，頁面和操作再連結過去。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NT0Kb630BhPK20xyIzDfFQ.png" /></figure><h4>AI 用 index 與連結找資料</h4><p>Claude Code 這類 agent 讀知識庫的方式和人在終端機找資料一樣：用 ls 看有哪些檔案、用 grep 找含關鍵字的行、用 cat 讀整份檔案。每下一個命令就看輸出，資訊不夠就再下一個，夠了就回答。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uhx0USbbmzga5fc2kDIpCw.png" /></figure><p>問「商品上架會做哪些檢查」，Claude Code 的讀取紀錄是：</p><pre>⏺ Read(okf-sample/requirements/index.md)<br>Read 57 lines</pre><pre>⏺ Read(okf-sample/requirements/admin/listing/publish.action.md)<br>Read 35 lines</pre><pre>⏺ Read(okf-sample/requirements/domain/pricing-rule.md)<br>Read 28 lines</pre><p>它先讀 index.md，從每份文件的一句描述判斷「商品上架」對應 publish.action.md，打開後看到售價欄位連結到定價規則，再讀 pricing-rule.md。這條路徑不靠關鍵字比對，而是靠 index 的描述和文件之間的連結。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C4g0RBayRlM3Q9sI34rKTw.png" /></figure><p>因為是依意思選連結，問題換成別的語言也找得到。「商品を公開するとき、どんなチェックがありますか？」裡沒有任何一個字和檔名或中文標題相同，AI 讀 index.md 時仍然能判斷這是在問商品上架。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q7OEibqwegOaD9fpd0zP5Q.png" /></figure><h4>導入知識庫後的開發流程</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TZECmILVVu-ES96-HfIftg.png" /></figure><p>導入知識庫時，我刻意不改變各角色原本的工作流程。PM 照樣寫需求，RD 照樣寫 code，QA 照樣寫測試案例；改變的是每個人和 AI 協作時，參考的是同一份知識庫。</p><h4>PM 用三個 skill 把需求編進知識庫</h4><p>PM 收到新需求時，原文放進 raw/，接著由三個 skill 處理：</p><ul><li>analyze-raw：編譯前先評估這份需求對既有知識庫的影響。</li><li>compile-raw：把需求編進 requirements/。</li><li>review-requirement：編完之後依檢核規則審查。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ic-vOx20NDuxE4kJhFaeqQ.png" /></figure><p>analyze-raw 只評估、不產生文件，結果直接回報在對話裡。它要找出三種問題：和既有規則不一致的衝突；漏提的影響，例如改了 A，引用 A 的頁面、Domain 和測試案例也會受影響，需求裡卻沒提；以及知識庫已經有類似內容，應該修改既有文件而不是新增。需求沒寫的地方它不補答案，可以列出選項，由 PM 決定。PM 看完評估結果，沒問題才往下，有問題先回頭補 raw。</p><p>compile-raw 的 skill 只管流程，寫法的標準放在 guidelines/，要寫哪種 type 就讀對應的那份規範。流程分四步：確認這份 raw 已經評估過；讀通用規範和該 type 的規範；寫文件，改既有文件時先看它連到哪些文件、被哪些文件引用；寫完逐項檢查並更新索引。規範裡最常用到的幾條判斷是：</p><ul><li>這是系統對使用者承諾的行為嗎？內部實作細節就不記。</li><li>一份文件只涵蓋一件連貫的動作，跨到其他主題就改成連結。</li><li>提到某個概念就連結到它的文件，不手抄「被哪些文件引用」的清單。</li></ul><p>最後一條讓連結成為唯一的關聯紀錄。想知道哪些文件跟商品類型有關，直接搜尋誰連結了它：</p><pre>grep -rl &quot;product-type.md&quot; . --include=&#39;*.md&#39;</pre><h4>寫需求的 AI 和 review 的 AI 依據不同</h4><p>用 AI 寫需求，再用 AI review，常被問到是否該用不同模型。兩者的差別在依據，不在模型。</p><p>compile-raw 只能依 raw 轉寫，raw 沒講的不能補，補了就是猜。所以來源沒講的，文件裡也不會有，這種缺口從來源和結果的 diff 看不出來。</p><p>review-requirement 拿檢核規則去量文件，例如「有輸入限制的欄位，必須寫明超出時怎麼處理」。規則要求必須寫、文件裡卻沒有，就是一個缺口。review 只提問題，不改需求、不猜答案，答案由 PM 決定。寫需求負責忠於來源，review 負責對照規則找出來源沒說的地方。</p><h4>QA 從需求推導測試案例</h4><p>QA 用 write-tests skill 從 requirements/ 的規則推導測試案例。skill 同樣只管流程，推導方法放在 guidelines/tests.md：需求裡的每一種內容對應一種案例，驗證規則寫一個通過、一個不通過，欄位限制測邊界值，狀態流轉測每一條合法流轉。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mwnwn2h4djsSQybQamhCmQ.png" /></figure><p>流程是先讀規範，再讀要測的需求，連同它連結到的 Domain 和 Entity；推不出來的案例列進「待確認問題」，不猜；寫完更新 tests/index.md。產生的檔案長這樣：</p><pre>---<br>type: TestCase<br>title: 定價檢查<br>description: 售價、原價與折扣下限的邊界值；規則只在這裡測一次，上架與修改上架中商品的價格都適用同一組規則。<br>module: product<br>covers:<br>  - /requirements/domain/pricing-rule.md<br>  - /requirements/admin/listing/publish.action.md<br>status: draft<br>timestamp: 2026-10-12T00:00:00Z<br>---</pre><pre>判斷依據一律是[定價規則](/requirements/domain/pricing-rule.md)。</pre><pre># 原價</pre><pre>## TC-017 原價不得低於售價</pre><pre>- **優先級**：P1<br>- **前置條件**：一個其他必填欄位皆齊全的商品草稿<br>- **步驟**：售價 `500`，原價分別填 `500`、`499`<br>- **預期結果**：原價 `500`（等於售價）通過；`499` 不通過，欄位提示「原價不得低於售價」。依據：[定價規則](/requirements/domain/pricing-rule.md#規則)</pre><p>covers 和每個案例的「依據」都連回來源需求。需求改了，從連結就查得到哪些測試案例要複查。status: draft 表示這是 AI 產出、尚未審閱的案例，QA 確認後改成 reviewed。</p><p>如果沒有知識庫，只拿新需求叫 AI 產生測試案例，就算有 CLAUDE.md、有產生測案的 guideline 和 skill，AI 仍然只看得到這一份需求。缺的是既有需求的知識，不知道的規則它就會自己編。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CNhPmsFeQuJ_ugFZmbYKZA.png" /></figure><p>測試案例本身也會累積。AI 產生新案例時會參考 tests/ 裡既有的案例，新案例再寫回 tests/。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4vPDZtSYbtZwWJJYL-FSpQ.png" /></figure><p>write-tests 的 skill 和 guideline 是從 QA 的範例來的。先請 QA 寫出自己想要的測試案例格式，一兩個範例就夠；再請 AI 依範例產生 guideline（檔案怎麼切、案例格式、預期結果怎麼寫）和 skill（怎麼從需求推導案例）。之後的測試案例都照這份格式產生。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g1mkV6m3CNdoYU2Os-igKA.png" /></figure><p>有了測試案例，AI 也能接著寫自動測試，但我們先不做。原本沒有自動測試的團隊，不因為導入知識庫就被要求要有；知識庫要解決的是需求和測試案例的來源，不是順便加上新的要求。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FtFIX_994iqEiR4xMTXdhQ.png" /></figure><h4>RD 透過 plugin 讀知識庫</h4><p>RD 不直接操作知識庫，而是在自己的後端或前端專案裡寫 code。我們用 Claude Code plugin 把知識庫 sync 進專案，讓 AI 寫 code 時參考：</p><ul><li>sync 進來的是唯讀鏡像，下次 sync 會覆蓋；要改需求，回知識庫改。</li><li>鏡像不進 git，做 code review、找 bug 時也排除它。</li><li>開 session 時，plugin 的 hook 會把知識庫路徑告訴 AI。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JKZkpNr5I9VYjoeslbh-Bw.png" /></figure><p>後端 plugin 提供 sync、generate-schema、generate-api 和 code-review；前端 plugin 提供 sync 和 code-review。</p><p>generate-schema 從 Entity 和 Domain 產生資料表，generate-api 從 Page 和 Action 產生 API 規格。以前 RD 叫 AI 寫 CREATE TABLE，要自己從需求文件擷取 AI 需要知道的部分，再補上團隊的 DB guideline；現在需求來自知識庫，AI 照團隊的 DB guideline 產生。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JoPa1anN6h83UpoinTNmAQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gbH28UZ9u9XB6F4Sl7HLHA.png" /></figure><h4>把 RD 的判斷回饋進 skill</h4><p>後端同事看一份需求文件，有時會說「這份需求，我感覺要跟 PM 對好幾天」。這個「感覺」來自他的工作經驗和對系統的了解，他看得出這份需求哪裡有問題。我希望 AI 也能學到這種判斷。做法是把它回饋回去：後端、前端或 QA 發現需求或知識庫有問題時，不只修這一份文件，而是把「怎樣的需求才算完整」更新進寫需求用的 guideline，以及 review-requirement 的檢核規則。下一次 PM 寫需求、AI review 時，就能檢查出同一類問題。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VHIfEYiLjJqBlyPIeQ6KvQ.png" /></figure><h4>用聊天機器人查詢與更新知識庫</h4><p>不是每個人都會開 Claude Code。我用 LangGraph 寫了一個 agent 接在 Lark 上，用來做這幾件事：問知識庫問題，例如「商品列表會顯示什麼」；更新知識庫；把 Jira bug 上的結論分享給 AI；在 Confluence 上 @agent 評估一份需求的影響。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qD2AYrysL6mr_TaDSz6NPA.png" /></figure><p>查詢的流程是一張 graph，每一步是一個節點：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TwxeKFc2YeZI4uaGSX4mZQ.png" /></figure><ul><li>guard 先判斷問題在不在知識庫範圍內，範圍清單來自知識庫的 index.md。</li><li>agent 決定要讀什麼，需要時呼叫 tools 讀檔、搜尋，可以來回好幾輪。</li><li>sources 列出這一輪實際讀過的檔案作為參考來源，format 把答案轉成卡片格式。</li></ul><p>更新知識庫只在使用者明確要求時才會進行：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XkDCG8lyq_8tDKjlEe1HBA.png" /></figure><ul><li>用 git worktree 建一份隔離的副本並開新分支，主目錄不動。</li><li>用 claude_code_sdk 啟動 Claude Code，在副本裡決定改哪個檔案、怎麼改，改完 commit。</li><li>訊息顯示摘要和 diff，等使用者按「確認」或「取消」。</li><li>確認才 push 並開 MR；取消則保留分支，不推送。</li></ul><p>session 以聊天軟體傳入的對話 ID 作為 LangGraph 的 thread_id，同一個 ID 的訊息接續同一段對話；輸入 /clear 或超過 1 小時沒對話就開新的 thread_id。長期記憶目前只記使用者的語言偏好。對話歷史、對話 ID 與 thread_id 的對照、語言偏好都存在 Postgres，服務重啟後對話可以接續。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jhw5sYm6ildF0bKfp_Y0bw.png" /></figure><h4>沒有文件時從程式碼產生第一份</h4><p>很多專案沒有可用的需求文件，但一定有程式碼。第一份知識可以請 AI 從程式碼產生，再交給 PM 確認。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jpPMHqxnrZ72-AcHcysPbg.png" /></figure><p>這裡要經過 PM，是因為程式碼是系統的現況，不一定是正確的需求：先有需求才有程式碼，而且一個需求是由前後端、資料庫、設定和環境變數組合起來的，程式碼裡的行為也可能是 bug。PM 確認過的內容才放進知識庫當作事實。</p><p>這也是為什麼不直接讓 AI 讀程式碼回答需求問題。讀程式碼只能知道系統現在怎麼做，不知道它應該怎麼做。</p><h4>知識庫與 RAG 的適用範圍</h4><p>AI 讀這份知識庫靠的是 index、連結和 grep，沒有用到向量資料庫。grep 吃的是高訊號的關鍵字，語料是中小型的純文字、查詢以字面關鍵字為主、agent 又能反覆迭代時，它是成本較低的起點，可以省掉一整層基礎設施。</p><p>但 grep 搜不了 PDF、圖片和 Office 檔，處理不了同義詞和概念查詢，語料變大時延遲也會跟著上升。下面這些情況，知識庫的做法撐不住，要考慮 RAG：</p><ul><li>文件數量龐大，index.md 放不進上下文，分層也撐不住。</li><li>內容是長篇的，無法一份文件一個主題，例如逐字稿、聊天紀錄、厚重的手冊，答案藏在段落裡。</li><li>來源太多太雜，沒有人能確認整理的結果，只能直接檢索原始資料。</li></ul><h4>時間從操作程式碼移到操作知識</h4><p>導入知識庫之前，我和 AI 協作的時間大多花在操作程式碼：下 prompt 叫 AI 改，再補上它不知道的既有做法。導入之後，我希望把更多時間花在操作知識：整理、檢查、補強，再把發現的問題回饋回去。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Dar26l7eofhzzCDsYqhEyw.png" /></figure><p>程式碼還是要寫，也還是重要。差別在於程式碼寫完是一次的結果，知識累積下來，下一次、下一個人、下一個 AI 都用得到。</p><p>這套做法目前的重點不是加快開發速度，而是讓知識累積：</p><ul><li>PM、RD、QA 和 AI 讀的是同一份知識。</li><li>各角色對系統的判斷補強回知識庫與 skill，下次 AI 就能檢查出同樣的問題。</li><li>人仍然會下 prompt，但不必每次都用 prompt 補足系統的既有狀況。</li><li>需求的缺口由 AI review 提出，不必等到 RD 開發時才發現要跟 PM 對好幾天。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NTDBwk4JOnElFReQ-uwmzw.png" /></figure><p>範例專案：<a href="https://github.com/evanchen76/okf-example">https://github.com/evanchen76/okf-example</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3bc374313479" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[使用 @DataJpaTest 測試 Spring Data JPA]]></title>
            <link>https://evanchen76.medium.com/%E4%BD%BF%E7%94%A8-datajpatest-%E6%B8%AC%E8%A9%A6-spring-data-jpa-a8338bcf377a?source=rss-cdd80585381e------2</link>
            <guid isPermaLink="false">https://medium.com/p/a8338bcf377a</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[unit-testing]]></category>
            <dc:creator><![CDATA[Evan Chen]]></dc:creator>
            <pubDate>Wed, 13 Nov 2024 08:24:05 GMT</pubDate>
            <atom:updated>2024-11-13T08:24:05.617Z</atom:updated>
            <content:encoded><![CDATA[<p>這篇將介紹如何為 Spring Data JPA 的 Repository 撰寫單元測試。我們會使用 H2 作為測試用的資料庫，並說明哪些情況需要寫測試，哪些不需要。</p><p>首先讓我們看看要測試的 Repository：</p><pre>@Repository<br>public interface UserRepository extends JpaRepository&lt;User, Long&gt; {<br>    // 根據名稱查詢使用者<br>    List&lt;User&gt; findByName(String name);<br><br>    // 自定義查詢：搜尋名稱或 email 開頭符合關鍵字的使用者<br>    @Query(&quot;SELECT u FROM User u WHERE u.name LIKE :keyword% OR u.email LIKE :keyword%&quot;)<br>    List&lt;User&gt; searchByKeyword(@Param(&quot;keyword&quot;) String keyword);<br>}<br><br>@Entity<br>@Table(name = &quot;users&quot;)<br>public class User {<br>    @Id<br>    @GeneratedValue(strategy = GenerationType.IDENTITY)<br>    private Long id;<br>    private String name;<br>    private String email;<br>}</pre><p>在這個 Repository 中，我們定義了兩個查詢方法。其中 searchByKeyword 是個較為複雜的自定義查詢，我們會想要確保它的查詢邏輯正確。為了方便測試這類查詢，又不想依賴實際的資料庫，我們可以使用 Spring Boot 提供的 @DataJpaTest。</p><p>@DataJpaTest 是一個專門用於測試 JPA 相關功能的註解。它會幫我們：</p><ul><li>自動配置測試用的資料庫環境（預設使用 H2 記憶體資料庫）</li><li>每個測試結束後自動還原資料</li><li>只載入測試必要的 Spring 元件，讓測試執行更快速</li></ul><h4>開始撰寫單元測試</h4><p>新增測試類別UserRepositoryTest 並加上 @DataJpaTest ，這樣可以確保測試不會影響到實際的資料庫。每個測試方法結束後都會自動還原，確保測試之間互不影響。</p><pre>@DataJpaTest<br>class UserRepositoryTest {<br>    @Autowired<br>    private UserRepository userRepository;<br>    @Autowired<br>    private TestEntityManager entityManager;<br>}</pre><p>接下來我們要測試自定義的searchByKeyword搜尋功能。這個方法需要能找出名稱或 email 開頭符合關鍵字的使用者。 為了測試這個方法，我們會用 TestEntityManager 來準備測試資料。TestEntityManager 是 Spring Boot 提供的測試用工具，讓我們能在測試時方便地操作資料：</p><pre>@Test<br>void searchByKeyword_WhenMatchingNamePrefix_ShouldReturnUsers() {<br>    // 準備測試資料<br>    User user1 = createUser(&quot;John Doe&quot;, &quot;john@example.com&quot;);<br>    User user2 = createUser(&quot;Johnny Smith&quot;, &quot;johnny@example.com&quot;);<br>    User user3 = createUser(&quot;Bob Wilson&quot;, &quot;bob@example.com&quot;);<br><br>    // 預先將資料寫入資料庫<br>    entityManager.persist(user1);<br>    entityManager.persist(user2);<br>    entityManager.persist(user3);<br>    entityManager.flush();<br><br>    // 呼叫被測試方法<br>    List&lt;User&gt; results = userRepository.searchByKeyword(&quot;John&quot;);<br><br>    // 驗證結果<br>    assertThat(results)<br>            .hasSize(2)<br>            .extracting(User::getName)<br>            .containsExactlyInAnyOrder(&quot;John Doe&quot;, &quot;Johnny Smith&quot;);<br>}</pre><p>在撰寫完基本的測試後，我們可能會想：是不是有用到的 Repository 的方法都需要測試？</p><h4>不需要測試的情況</h4><p>在我們的 Repository 中，以下方法是不需要寫測試的：</p><ol><li>findByName 方法：這是 Spring Data JPA 自動實作的方法</li></ol><pre>@Repository<br>public interface UserRepository extends JpaRepository&lt;User, Long&gt; {<br>    List&lt;User&gt; findByName(String name);<br>}</pre><p>基本的 CRUD 操作也不需要</p><pre>save(User user);<br>findById(Long id);<br>delete(User user);</pre><p>這些基本操作不需要測試的原因是：</p><ol><li>它們都是由 Spring Data JPA 實作的標準功能</li><li>Spring Data JPA本身已經有完整的測試覆蓋</li><li>測試這些基本功能等於是在測試框架本身</li></ol><p>接著我們再來想一個問題：當實體有欄位長度限制時，是否就需要寫測試驗證「當輸入長度超過 50 時會被攔截」？例如：</p><pre>@Column(length = 50, nullable = false)<br>private String name;</pre><p>答案是不需要在 Repository 層級測試這個限制。原因是：</p><ol><li>資料驗證不應該只依賴於資料庫層級的限制</li><li>這類的驗證通常應該在更上層處理：</li></ol><ul><li>在 Controller 層進行輸入驗證</li><li>或在 Service 層作為業務邏輯的一部分處理</li></ul><p>如果您需要測試長度驗證，應該在實際進行驗證的那一層（如 Controller）撰寫對應的測試。</p><h4>Recap</h4><p>在這篇文章中，我們介紹了如何使用 @DataJpaTest 進行 Repository 的單元測試。@DataJpaTest 使用 H2 這類內存資料庫來模擬資料庫行為，主要優點有：</p><ol><li>測試環境隔離：使用獨立的記憶體資料庫，不會影響到實際的資料庫</li><li>執行速度快：因為是在記憶體中執行，所以測試執行效率高</li><li>專注於測試重點：只需要測試自定義的查詢邏輯，不用測試框架本身提供的基本功能</li></ol><p>而當需要驗證特定資料庫功能，或要確保在實際資料庫環境下的行為時，則可以考慮使用 Testcontainers 進行完整的整合測試。Testcontainers 可以在測試時自動啟動一個實際的資料庫容器（如 MySQL），讓我們能夠在與線上環境相同的資料庫上進行測試。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a8338bcf377a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spring Boot 使用WireMock模擬外部API測試]]></title>
            <link>https://evanchen76.medium.com/spring-boot-%E4%BD%BF%E7%94%A8wiremock%E6%A8%A1%E6%93%AC%E5%A4%96%E9%83%A8api%E6%B8%AC%E8%A9%A6-7d9b1fdb366c?source=rss-cdd80585381e------2</link>
            <guid isPermaLink="false">https://medium.com/p/7d9b1fdb366c</guid>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[spring-boot]]></category>
            <dc:creator><![CDATA[Evan Chen]]></dc:creator>
            <pubDate>Mon, 11 Nov 2024 08:10:43 GMT</pubDate>
            <atom:updated>2024-11-11T08:10:43.969Z</atom:updated>
            <content:encoded><![CDATA[<p>在開發時常常會需要串接外部 API，像是金流服務、簡訊發送或是其他外部服務。但在測試時就會遇到一些麻煩，因為:</p><ul><li>測試環境可能連不到外部API</li><li>錯誤情境不容易模擬</li></ul><p>這時候就可以用 WireMock 來模擬外部 API：</p><ul><li>決定 API 要回什麼</li><li>模擬各種錯誤情況</li><li>測試系統的錯誤處理邏輯</li></ul><p>這篇就來介紹在Spring boot中 怎麼用 WireMock 來測試外部 API 整合</p><p>範例請參考：<a href="https://github.com/evanchen76/WireMockSample">https://github.com/evanchen76/WireMockSample</a></p><p>Gradle 依賴配置</p><pre>dependencies {<br>    implementation &#39;org.springframework.boot:spring-boot-starter-web&#39;<br>    implementation &#39;org.springframework.retry:spring-retry&#39;<br>    implementation &#39;org.springframework.boot:spring-boot-starter-aop&#39;<br>    testImplementation &#39;org.springframework.boot:spring-boot-starter-test&#39;<br>    testImplementation &#39;org.wiremock:wiremock:3.0.0-beta-10&#39;<br>    testImplementation &#39;org.assertj:assertj-core:3.24.2&#39;<br>}</pre><h4>實作呼叫外部API</h4><p>假設外部API是：http://localhost:8089/api/orders</p><p>需求是成立訂單時，將訂單資料傳給外部API，成功會回覆200。</p><pre>{<br>    &quot;status&quot;: &quot;SUCCESS&quot;,<br>    &quot;message&quot;: &quot;Order processed&quot;<br>}</pre><p>我們有一個OrderService用來將訂單資料，使用RestTemplate傳給對方API</p><pre>@Service<br>public class OrderServiceImpl implements OrderService {<br>  //將訂單資料傳給第三方API<br>  public OrderResponse sendOrder(Order order) {<br>     HttpHeaders headers = new HttpHeaders();<br>     headers.setContentType(MediaType.APPLICATION_JSON);<br>     <br>     HttpEntity&lt;Order&gt; request = new HttpEntity&lt;&gt;(order, headers);<br>     <br>     ResponseEntity&lt;OrderResponse&gt; response = restTemplate.postForEntity(thirdPartyApiUrl, request, OrderResponse.class);<br>     return response.getBody();<br>  }<br>}</pre><p>在與外部API整合時，需要考慮錯誤處理、Timeout的處理與重試機制。</p><h4>增加重試機制</h4><pre>@Service<br>public class OrderServiceImpl implements OrderService {<br>    @Override<br>    @Retryable(<br>            value = {ResourceAccessException.class, HttpServerErrorException.class},<br>            maxAttempts = 3,<br>            backoff = @Backoff(delay = 1000, multiplier = 2)<br>    )<br>    public OrderResponse sendOrder(Order order) {<br>       <br>    }<br>}</pre><h4>錯誤處理</h4><p>接著我們定義一個OrderProcessingException，將不同類型的Exception指定不同的ErrorCode</p><pre>public OrderResponse sendOrder(Order order) {<br>    HttpHeaders headers = new HttpHeaders();<br>    headers.setContentType(MediaType.APPLICATION_JSON);<br>    HttpEntity&lt;Order&gt; request = new HttpEntity&lt;&gt;(order, headers);<br>    <br>    try {<br>        var entity = restTemplate.postForEntity(thirdPartyApiUrl, request, OrderResponse.class);<br>        return entity.getBody();<br>    } catch (HttpClientErrorException e) {<br>        throw new OrderProcessingException(&quot;SERVER_ERROR&quot;, e);<br>    } catch (HttpServerErrorException e) {<br>        throw new OrderProcessingException(&quot;THIRD_PARTY_ERROR&quot;, e);<br>    } catch (ResourceAccessException e) {<br>        throw new OrderProcessingException(&quot;TIMEOUT&quot;, e);<br>    } catch (Exception e) {<br>        throw new OrderProcessingException(&quot;UNKNOWN_ERROR&quot;, e);<br>    }<br>}</pre><h4>撰寫測試</h4><p>先建立測試類別 OrderServiceTest。這裡最重要的是設定 WireMock Server 來模擬外部 API - 我們要模擬的 API 是 http://localhost:8089/api/orders。</p><pre>@SpringBootTest<br>class OrderServiceTest {<br>    private WireMockServer wireMockServer;<br>    <br>    @BeforeEach<br>    void setup() {<br>        wireMockServer = new WireMockServer(new WireMockConfiguration()<br>                .port(8089)<br>                .jettyStopTimeout(2000L)<br>                .jettyIdleTimeout(2000L));<br>        wireMockServer.start();<br>        <br>        WireMock.configureFor(&quot;localhost&quot;, 8089);<br>    }<br><br>    @AfterEach<br>    void teardown() {<br>        wireMockServer.stop();<br>    }<br>}</pre><p>設定好後，每當我們的程式呼叫 http://localhost:8089/api/orders 時，請求就會被導到 WireMock Server，我們就可以自由控制要回傳什麼資料，模擬各種 HTTP 狀況，像是正常回應、錯誤、逾時等等。</p><p>先來測試最基本的情況 — 當外部 API 正常回傳 200 時：</p><pre>@Test<br>void whenSendOrder_thenSuccess() {<br>    //模擬第三方回傳 200<br>    stubFor(post(urlEqualTo(&quot;/api/orders&quot;))<br>            .willReturn(aResponse()<br>                    .withStatus(200)<br>                    .withHeader(&quot;Content-Type&quot;, &quot;application/json&quot;)<br>                    .withBody(&quot;&quot;&quot;<br>                            {<br>                                &quot;status&quot;: &quot;SUCCESS&quot;,<br>                                &quot;message&quot;: &quot;Order processed&quot;<br>                            }<br>                            &quot;&quot;&quot;)<br>            ));<br>    //呼叫外部API<br>    OrderResponse response = orderService.sendOrder(order);<br>    //驗證<br>    assertThat(response.status()).isEqualTo(&quot;SUCCESS&quot;);<br>}</pre><h4>測試錯誤處理</h4><p>接著測試各種可能的錯誤情況：</p><p>API 回傳錯誤的 JSON 格式</p><pre>@Test<br>void whenSendOrderWrongJson_thenThrowException() {<br>    stubFor(post(urlEqualTo(&quot;/api/orders&quot;))<br>            .willReturn(aResponse()<br>                    .withStatus(200)<br>                    .withHeader(&quot;Content-Type&quot;, &quot;application/json&quot;)<br>                    .withBody(&quot;{\\&quot;wrong json\\&quot;:\\&quot;&quot;)<br>            ));<br>    var exception = assertThrows(OrderProcessingException.class, () -&gt; {<br>        orderService.sendOrder(order);<br>    });<br>    assertThat(exception).hasFieldOrPropertyWithValue(&quot;errorCode&quot;, &quot;UNKNOWN_ERROR&quot;);<br>}</pre><p>API 回傳錯誤狀態碼</p><pre>@Test<br>void whenThirdPartyReturns500_thenThrowException() {<br>    stubFor(post(urlEqualTo(&quot;/api/orders&quot;))<br>            .willReturn(aResponse()<br>                    .withStatus(500)<br>                    .withHeader(&quot;Content-Type&quot;, &quot;application/json&quot;)<br>            ));<br>    var exception = assertThrows(OrderProcessingException.class, () -&gt; orderService.sendOrder(order));<br>    assertThat(exception)<br>            .hasFieldOrPropertyWithValue(&quot;errorCode&quot;, &quot;THIRD_PARTY_ERROR&quot;);<br>}<br><br>@Test<br>void whenThirdPartyReturns503_thenThrowException() {<br>    stubFor(post(urlEqualTo(&quot;/api/orders&quot;))<br>            .willReturn(aResponse()<br>                    .withStatus(503)<br>                    .withHeader(&quot;Content-Type&quot;, &quot;application/json&quot;)<br>            ));<br>    var exception = assertThrows(OrderProcessingException.class, () -&gt; {<br>        orderService.sendOrder(order);<br>    });<br>    assertThat(exception)<br>            .hasFieldOrPropertyWithValue(&quot;errorCode&quot;, &quot;THIRD_PARTY_ERROR&quot;);<br>}<br><br>@Test<br>void whenThirdPartyReturns400_thenThrowException() {<br>    stubFor(post(urlEqualTo(&quot;/api/orders&quot;))<br>            .willReturn(aResponse()<br>                    .withStatus(400)<br>                    .withHeader(&quot;Content-Type&quot;, &quot;application/json&quot;)<br>            ));<br>    var exception = assertThrows(OrderProcessingException.class, () -&gt; {<br>        orderService.sendOrder(order);<br>    });<br>    assertThat(exception)<br>            .hasFieldOrPropertyWithValue(&quot;errorCode&quot;, &quot;SERVER_ERROR&quot;);<br>}</pre><p>驗證當 API 回傳 503 時，會自動重試：</p><pre>@Test<br>void whenThirdPartySystemTimeout_retry() {<br>    stubFor(post(urlEqualTo(&quot;/api/orders&quot;))<br>            .willReturn(aResponse()<br>                    .withStatus(503)<br>                    .withHeader(&quot;Content-Type&quot;, &quot;application/json&quot;)<br>                    .withFixedDelay(1000)<br>            ));<br>    OrderProcessingException exception = assertThrows(<br>            OrderProcessingException.class,<br>            () -&gt; orderService.sendOrder(order)<br>    );<br>    //驗證exception<br>    assertThat(exception)<br>            .hasFieldOrPropertyWithValue(&quot;errorCode&quot;, &quot;THIRD_PARTY_ERROR&quot;);<br>    //驗證retry<br>    verify(exactly(3), postRequestedFor(urlEqualTo(&quot;/api/orders&quot;)));<br>}</pre><h4>測試超時處理</h4><p>最後測試當 API 回應時間超過我們的 timeout 設定：</p><pre>@Test<br>void whenClientTimeout_thenHandleRetry() {<br>    stubFor(post(urlEqualTo(&quot;/api/orders&quot;))<br>            .willReturn(aResponse()<br>                    .withStatus(200)<br>                    .withHeader(&quot;Content-Type&quot;, &quot;application/json&quot;)<br>                    .withBody(&quot;&quot;&quot;<br>                            {<br>                                &quot;status&quot;: &quot;SUCCESS&quot;,<br>                                &quot;message&quot;: &quot;Order processed successfully&quot;<br>                            }<br>                            &quot;&quot;&quot;)<br>                    .withFixedDelay(6000)<br>            ));<br>    OrderProcessingException exception = assertThrows(<br>            OrderProcessingException.class,<br>            () -&gt; orderService.sendOrder(order)<br>    );<br>    assertThat(exception) .hasFieldOrPropertyWithValue(&quot;errorCode&quot;, &quot;TIMEOUT&quot;);<br>    verify(3, postRequestedFor(urlEqualTo(&quot;/api/orders&quot;)));<br>}</pre><p>透過 WireMock，我們輕鬆測試了各種 API 整合的情境：</p><ul><li>正常呼叫的情況</li><li>API 回傳錯誤（錯誤的 JSON、400/500 錯誤）</li><li>重試機制是否正常運作</li><li>Timeout處理是否正確</li></ul><p>這樣就能確保我們的系統在各種狀況下都能正確處理，提高系統的穩定性！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7d9b1fdb366c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spring Boot 後端筆記]]></title>
            <link>https://evanchen76.medium.com/spring-boot-%E5%BE%8C%E7%AB%AF%E7%AD%86%E8%A8%98-d819d756a340?source=rss-cdd80585381e------2</link>
            <guid isPermaLink="false">https://medium.com/p/d819d756a340</guid>
            <dc:creator><![CDATA[Evan Chen]]></dc:creator>
            <pubDate>Mon, 04 Nov 2024 00:25:41 GMT</pubDate>
            <atom:updated>2024-11-13T08:25:02.120Z</atom:updated>
            <content:encoded><![CDATA[<p>從事Android工程師多年後，最近準備回後端開發，在此分享一些學習筆記。</p><p>重構系列文：</p><ul><li><a href="https://evanchen76.medium.com/%E9%87%8D%E6%A7%8B-if-else-%E7%9A%84%E5%B7%A2%E7%8B%80%E7%A8%8B%E5%BC%8F%E7%A2%BC-ded4c1378cad">重構: if else 的巢狀程式碼</a></li><li><a href="https://medium.com/@evanchen76/%E5%9C%A8%E9%9C%80%E6%B1%82%E8%AE%8A%E6%9B%B4%E6%99%82%E9%87%8D%E6%A7%8B%E7%A8%8B%E5%BC%8F%E7%A2%BC-c831c89bbb89">在需求變更時重構程式碼</a></li><li><a href="https://evanchen76.medium.com/spring-boot%E9%87%8D%E6%A7%8B%E6%8A%80%E5%B7%A7-1-9a3d50439e55">Spring Boot 重構技巧 (1)</a></li><li><a href="https://evanchen76.medium.com/spring-boot%E9%87%8D%E6%A7%8B%E6%8A%80%E5%B7%A7-2-069ac1ac17f7">Spring Boot 重構技巧 (2)</a></li><li><a href="https://evanchen76.medium.com/spring-boot%E9%87%8D%E6%A7%8B%E6%8A%80%E5%B7%A7-3-78cc1a5f18b1">Spring Boot 重構技巧 (3)</a></li></ul><p>TDD系列文：</p><ul><li><a href="https://evanchen76.medium.com/spring-boot-%E5%96%AE%E5%85%83%E6%B8%AC%E8%A9%A6-795a41176a40">Spring Boot 單元測試</a></li><li><a href="https://evanchen76.medium.com/spring-boot-%E5%96%AE%E5%85%83%E6%B8%AC%E8%A9%A6-2-e65b1d261c12">Spring Boot 單元測試 2</a></li><li><a href="https://evanchen76.medium.com/spring-boot-tdd-%E6%B8%AC%E8%A9%A6%E9%A9%85%E5%8B%95%E9%96%8B%E7%99%BC-989de21363ea">Spring Boot TDD 測試驅動開發</a></li><li><a href="https://evanchen76.medium.com/spring-boot-tdd-%E6%B8%AC%E8%A9%A6%E9%A9%85%E5%8B%95%E9%96%8B%E7%99%BC2-58a426c50d01">Spring Boot TDD 測試驅動開發 2</a></li><li><a href="https://evanchen76.medium.com/spring-boot-%E4%BD%BF%E7%94%A8wiremock%E6%A8%A1%E6%93%AC%E5%A4%96%E9%83%A8api%E6%B8%AC%E8%A9%A6-7d9b1fdb366c">Spring Boot 使用WireMock模擬外部API測試</a></li><li><a href="https://evanchen76.medium.com/%E4%BD%BF%E7%94%A8-datajpatest-%E6%B8%AC%E8%A9%A6-spring-data-jpa-a8338bcf377a">使用 @DataJpaTest 測試 Spring Data JPA</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d819d756a340" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[在需求變更時重構程式碼]]></title>
            <link>https://evanchen76.medium.com/%E5%9C%A8%E9%9C%80%E6%B1%82%E8%AE%8A%E6%9B%B4%E6%99%82%E9%87%8D%E6%A7%8B%E7%A8%8B%E5%BC%8F%E7%A2%BC-c831c89bbb89?source=rss-cdd80585381e------2</link>
            <guid isPermaLink="false">https://medium.com/p/c831c89bbb89</guid>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[refactoring]]></category>
            <dc:creator><![CDATA[Evan Chen]]></dc:creator>
            <pubDate>Sat, 02 Nov 2024 07:34:50 GMT</pubDate>
            <atom:updated>2024-11-02T07:34:50.176Z</atom:updated>
            <content:encoded><![CDATA[<p>需求變更是程式開發中的常態，但如何在變更時保持程式碼的品質？本文將探討重構的最佳時機，並通過實例說明如何避免程式碼品質隨著需求變更而逐漸下降。</p><p>之前我們討論過 if-else 的巢狀程式碼問題（參考：<a href="https://medium.com/@evanchen76/%E9%87%8D%E6%A7%8B-if-else-%E7%9A%84%E5%B7%A2%E7%8B%80%E7%A8%8B%E5%BC%8F%E7%A2%BC-ded4c1378cad">重構 if-else 的巢狀程式碼</a>）。</p><pre>if (lastSessionProduct) {<br>    if (memberType == MemberType.SILVER) {<br>        if (promoCode.equals(&quot;SPECIAL_DISCOUNT&quot;)) {<br>            updateDiscountPrice(true);<br>        } else {<br>            updateDiscountPrice(false);<br>        }<br>    } else if (memberType == MemberType.GOLD) {<br>        if (promoCode.equals(&quot;SPECIAL_DISCOUNT&quot;)) {<br>            // 更多巢狀判斷...<br>        }<br>    }<br>}</pre><p>可能會有人想說，怎麼可能有人把程式碼寫成這樣。事實上，這是我在某份工作實際遇到的案例，只是參數被我修改了。這樣的程式碼通常不是一開始就寫成這樣。它往往是經過了不斷的需求變更，也經手多位開發者，甚至原開發者可能也已離職，所以最終程式碼才會被修改成這樣。</p><p>那麼，我們該如何避免程式碼隨著需求變更而變得越來越難維護呢？我們透過一個案例來說明。</p><p>有一個Order類別，用來處理付款。一開始，我們的系統只需要支援 Apple Pay：</p><pre>public class Order {<br>    <br>    ApplePay applePay = new ApplePay();<br><br>    //付款<br>    public void pay(BigDecimal amount, String orderId) {<br>        applePay.pay(orderId, amount);<br>    }<br>    <br>    //退款<br>    public void refund(BigDecimal amount, String orderId) {<br>        applePay.refund(orderId, amount);<br>    }<br>}<br><br>public class ApplePay {<br>    public void pay(String orderId, BigDecimal amount) {<br>       //pay<br>    }<br>    public void refund(String orderId, BigDecimal amount) {<br>       //refund<br>    }<br>}</pre><p>過了一段時間，我們的系統要增加可以使用 GooglePay付款。一個常見但不好的作法是直接加入 flag 判斷是ApplePay還是GooglePay。</p><pre>public class Order  {<br>    <br>    //加一個flag來控制用哪一種Pay<br>    boolean isApplePay = true;<br>    <br>    ApplePay applePay = new ApplePay();<br>    GooglePay googlePay = new GooglePay();<br><br>    public void pay(BigDecimal amount, String orderId) {<br>        //判斷是不是ApplePay<br>        if (isApplePay) {<br>            applePay.pay(orderId, amount);<br>        }else{<br>            googlePay.pay(orderId, amount);<br>        }<br>    }<br><br>    public void refund(BigDecimal amount, String orderId) {<br>        //判斷是不是ApplePay<br>        if (isApplePay) {<br>            applePay.refund(orderId, amount);<br>        }else{<br>            googlePay.refund(orderId, amount);<br>        }<br>    }<br>}</pre><p>這種作法的問題是：</p><ul><li>違反開放封閉原則</li><li>每次增加新的付款方式都需要修改現有程式碼</li><li>容易產生更多的 if-else 巢狀判斷</li></ul><p><strong>正確的重構方式</strong></p><p>當需求從原本的只有ApplePay增加為GooglePay也需要時，代表我們需要將ApplePay抽象化為Pay這個interface，讓Order不再相依ApplePay。</p><pre>public interface Pay {<br>    void pay(String orderId, BigDecimal amount);<br>    void refund(String orderId, BigDecimal amount);<br>}</pre><p>首先，使用 IDE 的重構功能（右鍵 → Refactor → Extract Interface）從 ApplePay 提出Interface：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eFHVcRPNR6PJhmbBp4oiRQ.png" /></figure><p>接著輸入Interface的名稱為Pay，勾選下方的pay與refund方法也都要抽象。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wcZxXhbhwebdiJgBSvzRAA.png" /></figure><p>重構完成就可以看到產生了一個interface Pay，而ApplePay去實作這個Pay。</p><pre>public interface Pay {<br>    void pay(String orderId, BigDecimal amount);<br>    void refund(String orderId, BigDecimal amount);<br>}<br><br>public class ApplePay implements Pay {<br>    @Override<br>    public void pay(String orderId, BigDecimal amount) {<br>    }<br><br>    @Override<br>    public void refund(String orderId, BigDecimal amount) {<br>    }<br>}</pre><p>在Order 原本的ApplePay也會被重構為Pay。</p><pre>public class Order {<br>    private BigDecimal amount;<br>    private String orderId;<br>    <br>    //型別也被重構為Pay<br>    Pay pay = new ApplePay();<br>    <br>    public void pay(BigDecimal amount, String orderId) {<br>        pay.pay(orderId, amount);<br>    }<br><br>    public void refund(BigDecimal amount, String orderId) {<br>        pay.refund(orderId, amount);<br>    }<br>}</pre><p>使用依賴注入：</p><p>接著使用 IDE 的 “Introduce Parameter” 重構功能，將具體實作改為通過建構子注入：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/926/1*cOCwJkkWZW9z_csUwmA4ew.png" /></figure><p>重構完程式如下，Pay將在constructor實體化。</p><pre>public class Order {<br>    Pay pay;<br>    <br>    public Order() {<br>        this.pay = new ApplePay();<br>    }<br>}</pre><p>接著要再把new ApplePay()提出為參數，由Client注入。右鍵 → Refactor → Introduce Parameter。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*muyWtNeM3WCRvHA77Mr6NA.png" /></figure><p>就完成將Pay在建構子注入。</p><pre>public class Order {<br>    Pay pay;<br>    <br>    public Order(Pay pay) {<br>        this.pay = pay;<br>    }<br>}</pre><p>重構完之後，可以看到Order裡不再相依ApplePay了。只要你傳入有實作Pay這個Interface的實體即可。</p><pre>public class Order {<br>    Pay pay;<br><br>    public Order(Pay pay) {<br>        this.pay = pay;<br>    }<br><br>    public void pay(BigDecimal amount, String orderId) {<br>        pay.pay(orderId, amount);<br>    }<br><br>    public void refund(BigDecimal amount, String orderId) {<br>        pay.refund(orderId, amount);<br>    }<br>}</pre><p><strong>需求變更就是重構的最佳時機</strong>。</p><p>在我們的例子中：</p><p>當系統需要支援新的付款方式時，這就是告訴我們需要將付款邏輯抽象化的信號。如果錯過這個時機，程式碼可能會逐漸演變成難以維護的巢狀判斷。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c831c89bbb89" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spring Boot TDD 測試驅動開發2]]></title>
            <link>https://evanchen76.medium.com/spring-boot-tdd-%E6%B8%AC%E8%A9%A6%E9%A9%85%E5%8B%95%E9%96%8B%E7%99%BC2-58a426c50d01?source=rss-cdd80585381e------2</link>
            <guid isPermaLink="false">https://medium.com/p/58a426c50d01</guid>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[tdd]]></category>
            <dc:creator><![CDATA[Evan Chen]]></dc:creator>
            <pubDate>Fri, 01 Nov 2024 11:08:00 GMT</pubDate>
            <atom:updated>2024-11-01T11:08:00.417Z</atom:updated>
            <content:encoded><![CDATA[<h3>Service</h3><p>延續上一篇的<a href="https://evanchen76.medium.com/spring-boot-tdd-%E6%B8%AC%E8%A9%A6%E9%A9%85%E5%8B%95%E9%96%8B%E7%99%BC-989de21363ea">Spring Boot TDD 測試驅動開發</a>完成 Controller 。接著實作 Service 層。Service 層負責處理核心業務邏輯，在這個範例中主要處理三個任務：</p><ol><li>檢查帳號、密碼格式</li><li>檢查帳號是否存在</li><li>新增帳號</li></ol><h4>初始重構</h4><p>在開始新功能開發前，先重構 Service 的介面設計。原本 Service 的signup參數直接使用 SignupRequest：</p><pre>@Service<br>public class UserService implements IUserService {<br>    @Override<br>    //參數是SignupRequest與Controller的參數共用<br>    public SignupResult signup(SignupRequest request) {<br>        throw new UnsupportedOperationException(&quot;Not implemented yet&quot;);<br>    }<br>}</pre><p>為了避免 Service 與 Controller 共用 Request 物件，我們改為使用基本參數：</p><pre>@Service<br>public class UserService implements IUserService {<br>    @Override<br>    //改成傳2個參數，也可建立新的model<br>    public SignupResult signup(String userId, String password) {<br>        throw new UnsupportedOperationException(&quot;Not implemented yet&quot;);<br>    }<br>}</pre><p>注意：在進行任何重構後，都要重新執行之前的 Controller 測試，確保功能正常。</p><h4>開始撰寫測試案例</h4><p><strong>測試案例 1：輸入格式驗證</strong></p><p>首先建立 UserServiceTest，驗證輸入格式錯誤時的處理：</p><pre>@ExtendWith(MockitoExtension.class)<br>public class UserServiceTest {<br>    private UserService userService;<br>    @BeforeEach<br>    void setUp() {<br>        userService = new UserService();<br>    }<br>    @Test<br>    void signup_ShouldFailWithInvalidInput() {<br>        var result = userService.signup(&quot;ab&quot;, &quot;short&quot;);<br>        assertThat(result.isSuccess()).isFalse();<br>        assertThat(result.error()).hasSize(2);<br>    }<br>}</pre><p>執行測試，得到紅燈。</p><pre>Not implemented yet<br>java.lang.UnsupportedOperationException: Not implemented yet</pre><p>實作 Service 的驗證邏輯後通過測試。</p><pre>@Service<br>public class UserService implements IUserService {<br>    @Override<br>    public SignupResult signup(String userId, String password) {<br>        //格式檢查<br>        List&lt;String&gt; signupValidations = new ArrayList&lt;&gt;();<br>        if (userId == null || userId.length() &lt; 3 || userId.length() &gt; 20) {<br>            signupValidations.add(&quot;User id must be between 3 and 20 characters long&quot;);<br>        }<br>        if (password == null || password.length() &lt; 8 || password.length() &gt; 30) {<br>            signupValidations.add(&quot;Password must be between 8 and 30 characters long&quot;);<br>        }<br>        if (!signupValidations.isEmpty()){<br>            return new SignupResult(null, signupValidations);<br>        }else{<br>            throw new UnsupportedOperationException(&quot;Not implemented yet&quot;);<br>        }<br>    }<br>}</pre><p>接著我們要加更多案例來驗證錯誤，所以我們改成用參數化的方式。</p><pre>@ParameterizedTest<br>    @MethodSource(&quot;invalidSignupRequests&quot;)<br>    void signup_ShouldFailWithInvalidInput(String userId, String password, int expectedErrorCount) {<br>        var result = userService.signup(userId, password);<br>        assertThat(result.isSuccess()).isFalse();<br>        assertThat(result.error()).hasSize(expectedErrorCount);<br>    }<br><br>    private static Stream&lt;Arguments&gt; invalidSignupRequests() {<br>        return Stream.of(<br>                // 測試無效的userId - 預期1個錯誤<br>                Arguments.of(null, PASSWORD, 1),<br>                Arguments.of(&quot;&quot;, PASSWORD, 1),<br>                Arguments.of(&quot;ab&quot;, PASSWORD, 1),<br>                Arguments.of(&quot;a&quot;.repeat(21), PASSWORD, 1),<br>                // 測試無效的password - 預期1個錯誤<br>                Arguments.of(USER_ID, null, 1),<br>                Arguments.of(USER_ID, &quot;&quot;, 1),<br>                Arguments.of(USER_ID, &quot;short&quot;, 1),<br>                Arguments.of(USER_ID, &quot;a&quot;.repeat(31), 1),<br>                // 測試userId和password同時無效 - 預期2個錯誤<br>                Arguments.of(&quot;ab&quot;, &quot;short&quot;, 2)<br>        );<br>    }</pre><p>執行測試後，通過測試。</p><h4>測試案例 2：帳號重複檢查</h4><p>測試帳號已存在的情況：</p><pre>@Test<br>void signup_UsernameExists() {<br>    when(userRepository.existsByUserId(USER_ID)).thenReturn(true);<br>    var result = userService.signup(USER_ID, PASSWORD);<br>    assertFalse(result.isSuccess());<br>    assertThat(result.error()).hasSize(1);<br>}</pre><p>注入userRepository</p><pre>@ExtendWith(MockitoExtension.class)<br>public class UserServiceTest {<br>private UserService userService;<br>    @Mock<br>    private UserRepository userRepository;<br>    @BeforeEach<br>    void setUp() {<br>        userService = new UserService(userRepository);<br>    }<br>}</pre><p>建立 UserRepository，在這裡不需實作，直接throw UnsupportedOperationException;</p><pre>public class UserRepository {<br>    public Boolean existsByUserId(String userId) {<br>        throw new UnsupportedOperationException(&quot;Not implemented yet&quot;);<br>    }<br>}</pre><p>執行測試會是紅燈</p><pre>Not implemented yet<br>java.lang.UnsupportedOperationException: Not implemented yet</pre><h4>實作 Service 功能</h4><p>在UserService 加上檢查帳號是否存在的邏輯，通過測試。</p><pre>@Service<br>public class UserService implements IUserService {<br>    private final UserRepository userRepository;<br>    public UserService(UserRepository userRepository) {<br>        this.userRepository = userRepository;<br>    }<br><br>    @Override<br>    public SignupResult signup(String userId, String password) {<br>    //格式檢查<br>    ...<br>    <br>        //檢查帳號是否存在<br>        boolean exists = userRepository.existsByUserId(userId);<br>        if (exists) {<br>            return new SignupResult(null, List.of(&quot;User already exists&quot;));<br>        }<br>    <br>    ..<br>        if (!signupValidations.isEmpty()){<br>            return new SignupResult(null, signupValidations);<br>        }else{<br>            throw new UnsupportedOperationException(&quot;Not implemented yet&quot;);<br>        }<br>    }<br>}</pre><h4>測試案例 3：註冊成功</h4><p>這裡要模擬Repository新增帳號成功。</p><pre>@Mock<br>private PasswordEncoder passwordEncoder;<br>    <br>@Test<br>void signup_Success() {<br>    when(userRepository.existsByUserId(USER_ID)).thenReturn(false);<br>    when(userRepository.insert(any(UserAccount.class))).thenReturn(createdUser);<br>    var result = userService.signup(USER_ID, PASSWORD);<br>    assertThat(result.isSuccess()).isTrue();<br>    assertThat(result.createdUser()).isEqualTo(createdUser);<br>}</pre><p>UserRepository 加入insert方法。</p><pre>public class UserRepository {<br>    public CreatedUser insert(UserAccount user) {<br>        throw new UnsupportedOperationException(&quot;Not implemented yet&quot;);<br>    }<br>}</pre><p>同時產生表示資料庫UserAccount的DTO。</p><pre>public record UserAccount(<br>        Long id,<br>        UUID uuid,<br>        @Field(&quot;user_id&quot;)<br>        String userId,<br>        String passwordHash<br>) {}</pre><p>接著執行測試：</p><pre>Not implemented yet<br>java.lang.UnsupportedOperationException: Not implemented yet</pre><p><strong>完成 Service 實作：</strong></p><p>新增PasswordEncoderConfig</p><pre>@Configuration<br>public class PasswordEncoderConfig {<br>    @Bean<br>    public PasswordEncoder passwordEncoder() {<br>        return new BCryptPasswordEncoder();<br>    }<br>}</pre><p>在 signup 加上呼叫userRepository.insert及處理</p><pre>public SignupResult signup(String userId, String password) {<br>	if (!signupValidations.isEmpty()){<br>	    return new SignupResult(null, signupValidations);<br>	}else{<br>	    //新增帳號<br>	    CreatedUser savedUser = userRepository.insert(<br>	            new UserAccount(null, UUID.randomUUID(), userId, passwordEncoder.encode(password))<br>	    );<br>	    return new SignupResult(savedUser, null);<br>	}<br>}</pre><p>至此，Service 層的 TDD 開發完成，實現了所有必要的業務邏輯。每個功能都有對應的測試案例保護，確保程式碼品質。</p><h3>Repository</h3><p>最後，我們要來處理Repository。Repository 層是應用程式中負責資料持久化的重要元件。在這個範例中，我們使用JdbcTemplate與 MySQL 資料庫互動，並提供兩個主要功能：</p><ul><li>檢查使用者是否存在</li><li>新增帳號</li></ul><h4>測試環境準備</h4><p>首先建立測試環境，使用 Testcontainers 來管理測試用的 MySQL 容器：</p><pre>@SpringBootTest<br>@Testcontainers<br>class UserRepositoryTest {<br>    @Autowired<br>    private UserRepository userRepository;<br>    @Autowired<br>    private TestHelper testHelper;<br>    @BeforeAll<br>    static void setUp() {<br>        TestDatabaseConfig.startContainer();<br>    }<br>    @BeforeEach<br>    void setUpEach() {<br>        testHelper.createTestTable();<br>        testHelper.clearDatabase();<br>    }<br>    @AfterAll<br>    static void tearDown(@Autowired TestHelper testHelper) {<br>        testHelper.clearDatabase();<br>    }<br>}</pre><h4>測試環境設定檔</h4><p>建立測試資料庫配置：</p><pre>public class TestDatabaseConfig {<br>    public static final MySQLContainer&lt;?&gt; mysqlContainer = new MySQLContainer&lt;&gt;(&quot;mysql:8.0&quot;)<br>            .withDatabaseName(&quot;testdb&quot;)<br>            .withUsername(&quot;test&quot;)<br>            .withPassword(&quot;test&quot;);<br>    public static void startContainer() {<br>        mysqlContainer.start();<br>    }<br>    public static class Initializer implements ApplicationContextInitializer&lt;ConfigurableApplicationContext&gt; {<br>        @Override<br>        public void initialize(ConfigurableApplicationContext applicationContext) {<br>            TestPropertySourceUtils.addInlinedPropertiesToEnvironment(<br>                    applicationContext,<br>                    &quot;spring.datasource.url=&quot; + mysqlContainer.getJdbcUrl(),<br>                    &quot;spring.datasource.username=&quot; + mysqlContainer.getUsername(),<br>                    &quot;spring.datasource.password=&quot; + mysqlContainer.getPassword()<br>            );<br>        }<br>    }<br>}</pre><h4>測試輔助類別</h4><p>建立測試用的資料庫操作輔助類別：</p><pre>@Component<br>public class TestHelper {<br>    @Autowired<br>    private JdbcTemplate jdbcTemplate;<br>    @Autowired<br>    private DataSource dataSource;<br>    public void clearDatabase() {<br>        jdbcTemplate.execute(&quot;DELETE FROM user_account&quot;);<br>    }<br>    public void createTestTable() {<br>        ResourceDatabasePopulator populator = new ResourceDatabasePopulator();<br>        populator.addScript(new ClassPathResource(&quot;schema.sql&quot;));<br>        populator.execute(dataSource);<br>    }<br>}</pre><h4>資料表結構</h4><p>在 resources/schema.sql 中定義資料表結構：</p><pre>-- Create user_account table<br>CREATE TABLE IF NOT EXISTS `user_account` (<br>    `id` bigint NOT NULL AUTO_INCREMENT,<br>    `uuid` varchar(36) NOT NULL,<br>    `user_id` varchar(255) DEFAULT NULL,<br>    `password_hash` varchar(255) DEFAULT NULL,<br>    PRIMARY KEY (`id`),<br>    UNIQUE KEY `uuid` (`uuid`)<br>    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;</pre><h4>測試案例開發</h4><p><strong>測試案例 1：新增帳號</strong></p><p>驗證新增帳號的功能：</p><pre>@SpringBootTest<br>@Testcontainers<br>class UserRepositoryTest {<br>    @Test<br>    void testInsert() {<br>        var userCreatedResponse = userRepository.insert(fakeUserAccount);<br>        assertThat(userCreatedResponse)<br>                .isNotNull()<br>                .satisfies(inserted -&gt; {<br>                    assertThat(inserted.uuid()).isEqualTo(fakeUserAccount.uuid());<br>                    assertThat(inserted.userId()).isEqualTo(fakeUserAccount.userId());<br>                });<br>    }<br>}</pre><p>實作 Repository 的新增功能：</p><pre>@Component<br>public class UserRepository {<br>    private final JdbcTemplate jdbcTemplate;<br>    @Autowired<br>    public UserRepository(JdbcTemplate jdbcTemplate) {<br>        this.jdbcTemplate = jdbcTemplate;<br>    }<br>    public CreatedUser insert(UserAccount user) {<br>        String sql = &quot;INSERT INTO user_account (uuid, user_id, password_hash) VALUES (?, ?, ?)&quot;;<br>        int rowsAffected = jdbcTemplate.update(sql,<br>                user.uuid().toString(),<br>                user.userId(),<br>                user.passwordHash());<br>        if (rowsAffected != 1) {<br>            throw new RuntimeException(&quot;Failed to insert user account&quot;);<br>        }<br>        return new CreatedUser(user.uuid(), user.userId());<br>    }<br>}</pre><h4>測試案例 2：檢查帳號不存在</h4><p>驗證查詢不存在帳號的情況：</p><pre>@Test<br>void testFindByUserIdNotFound() {<br>    boolean exist = userRepository.existsByUserId(&quot;nonexistent&quot;);<br>    assertThat(exist).isFalse();<br>}</pre><p>執行測試</p><pre>Not implemented yet<br>java.lang.UnsupportedOperationException: Not implemented yet</pre><p>實作檢查帳號存在的功能：</p><pre>public Boolean existsByUserId(String userId) {<br>    String sql = &quot;SELECT EXISTS(SELECT 1 FROM user_account WHERE user_id = ?)&quot;;<br>    return Boolean.TRUE.equals(jdbcTemplate.queryForObject(sql, Boolean.class, userId));<br>}</pre><h4>測試案例 3：檢查帳號存在</h4><p>驗證查詢存在帳號的情況：</p><pre>@Test<br>void testFindByUserIdFound() {<br>    userRepository.insert(fakeUserAccount);<br>    assertThat(userRepository.existsByUserId(USER_ID)).isTrue();<br>}</pre><p>由於之前的實作已經完整處理了帳號查詢邏輯，這個測試案例可以直接通過。這驗證了我們的實作可以正確處理不同的使用情境。</p><h4>小結</h4><p>TDD 的步驟紅燈、綠燈、重構循環：</p><ol><li>紅燈:撰寫失敗的測試案例。</li><li>綠燈:快速實作功能讓測試案例通過。</li><li>重構:在不改變功能的前提下，修改程式碼來改善可維護性。</li></ol><p>而這個循環，不是先完成一層的所有功能，而是按照 API 需求進行垂直切分。例如註冊帳號API從Controller、Service、Repository都完成，才會進行下一登入API。而不是先完成Controller的每一個功能。</p><p>而每個 TDD 循環包含：</p><ol><li>一個 Controller API 端點</li><li>對應的 Service 業務邏輯</li><li>必要的 Repository 資料存取</li></ol><p>這種垂直切分的方式有助於我們：</p><ul><li>快速驗證完整功能</li><li>及早發現各層整合問題</li><li>避免開發方向偏離需求</li></ul><p>最後，TDD的好處：</p><ul><li>開發前必須先清楚理解需求。</li><li>增量式開發，每次只處理一個小功能，可以避免過度設計和不必要的複雜性。</li><li>減少後期除錯和維護的時間成本。</li><li>提升開發效率，雖然需要撰寫測試，但實際開發速度並不會變慢。</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=58a426c50d01" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spring Boot TDD 測試驅動開發]]></title>
            <link>https://evanchen76.medium.com/spring-boot-tdd-%E6%B8%AC%E8%A9%A6%E9%A9%85%E5%8B%95%E9%96%8B%E7%99%BC-989de21363ea?source=rss-cdd80585381e------2</link>
            <guid isPermaLink="false">https://medium.com/p/989de21363ea</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[tdd]]></category>
            <dc:creator><![CDATA[Evan Chen]]></dc:creator>
            <pubDate>Fri, 01 Nov 2024 11:01:56 GMT</pubDate>
            <atom:updated>2024-11-01T11:08:45.909Z</atom:updated>
            <content:encoded><![CDATA[<p>TDD 測試驅動開發 (Test-driven development)，是一種先寫測試再寫產品程式碼的開發方式。先寫測試有助於先想清楚需求是什麼。</p><p>TDD 的步驟紅燈、綠燈、重構循環：</p><ol><li>紅燈：撰寫失敗的測試案例。</li><li>綠燈：快速實作功能讓測試案例通過。</li><li>重構：在不改變功能的前提下，修改程式碼來改善可維護性。</li></ol><p>這裡我們要以之前介紹的註冊會員API範例來用TDD的方式開發，開始之前請先參考這篇單元測試及範例的需求說明：</p><p><a href="https://evanchen76.medium.com/spring-boot-%E5%96%AE%E5%85%83%E6%B8%AC%E8%A9%A6-795a41176a40">https://evanchen76.medium.com/spring-boot-單元測試-795a41176a40</a></p><p>範例Github連結：</p><p><a href="https://github.com/evanchen76/SpringTDDSample">GitHub - evanchen76/SpringTDDSample</a></p><h3>Controller</h3><p>為什麼從 Controller 開始？</p><p>從需求來看，我們需要一個 API 來接收請求並回應。當有了這個 API 需求，如果其中包含業務邏輯就需要 Service，如果需要資料儲存就需要 Repository。因此，我們應該從需求出發，依序開發對應的元件。本案例從 Controller 開始開發是因為我們的第一個需求是處理 API 請求。</p><p>Controller 層的職責：</p><ol><li>帳號密碼欄位的基本檢查</li><li>呼叫Service註冊</li><li>回應Service建立帳號的結果</li></ol><p>請開啟SpringTDDSample，可對照裡面的commit。</p><p><strong>測試案例 1：輸入驗證失敗</strong></p><p>預期行為</p><p>Request</p><pre>{<br>    &quot;userId&quot;: &quot;&quot;,<br>    &quot;password&quot;: &quot;&quot;<br>}</pre><p>Response</p><pre>HTTP Status: 400 Bad Request<br>{<br>    &quot;success&quot;: false,<br>    &quot;error&quot;: &quot;password: Password cannot be empty, userId: UserId cannot be empty&quot;<br>}</pre><p>測試重點：</p><ul><li>使用帳號密碼為空字串建立請求</li><li>驗證 HTTP 狀態碼為 400 Bad Request</li><li>驗證回應中的success為false</li><li>驗證回應中包含錯誤訊息</li></ul><p><strong>實作步驟</strong></p><p>首先建立AuthControllerTest</p><pre>@WebMvcTest(AuthController.class)<br>@Import(SecurityConfig.class)<br>public class AuthControllerTest {<br>    @Autowired<br>    private MockMvc mockMvc;<br>    @Autowired<br>    private ObjectMapper objectMapper;<br><br>    @Test<br>    void signup_WhenAllFieldsEmpty_ShouldFailValidation() throws Exception {<br>        <br>    }<br>}</pre><p>接著建立 SignupRequest。在 IDE 中可以使用 Option + Enter 快捷鍵，選擇 Create record ‘SignupRequest’ 自動生成：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/954/1*apajAPpwN-NxU-AMSsibog.png" /></figure><p>Target destination directory 記得改到main</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VNr5-EiRqTSHJdOqHjVaiw.png" /></figure><p>就可以看到產生SignupRequest</p><pre>public record SignupRequest() {<br>}</pre><p>再回到AuthControllerTest</p><p>一樣Option + Enter：Change signature of SignupRequest 就可以產生兩個欄位。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*614hkQ8SIdZoAcXnHcfKig.png" /></figure><pre>public record SignupRequest(String userId, String password) {<br>}</pre><p>接著使用mockMvc來呼叫auth/signup，並驗證結果。</p><pre>@WebMvcTest(AuthController.class)<br>@Import(SecurityConfig.class)<br>class AuthControllerTest {<br><br>@Autowired<br>    private MockMvc mockMvc;<br>    @Autowired<br>    private ObjectMapper objectMapper;<br>    @Test<br>    void signup_WhenAllFieldsEmpty_ShouldFailValidation() throws Exception {<br>        SignupRequest request = new SignupRequest(&quot;&quot;, &quot;&quot;);<br>        mockMvc.perform(post(&quot;/auth/signup&quot;)<br>                        .contentType(MediaType.APPLICATION_JSON)<br>                        .content(objectMapper.writeValueAsString(request)))<br>                .andExpect(status().isBadRequest())<br>                .andExpect(jsonPath(&quot;$.success&quot;).value(false))<br>                .andExpect(jsonPath(&quot;$.error&quot;).exists());<br>    }<br>}</pre><p>執行測試獲得第一個紅燈（測試失敗），這是正常的，因為我們還沒有實作 Controller。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TJPIKa4pW5mz6CTKcUJbcQ.png" /></figure><pre>Status<br>Expected :400<br>Actual   :404</pre><p>接著新增AuthController，完成signup的檢核邏輯。</p><pre>@RestController<br>@RequestMapping(&quot;/auth&quot;)<br>public class AuthController {<br>    @PostMapping(&quot;/signup&quot;)<br>    public ApiResponse&lt;SignupResponse&gt; signup(@Valid @RequestBody SignupRequest request) {<br>        throw new UnsupportedOperationException(&quot;Not implemented yet&quot;);<br>    }<br>}<br><br>public record SignupResponse() {}</pre><p>在上Request加上@NotBlank</p><pre>public record SignupRequest(<br>        @NotBlank(message = &quot;UserId cannot be empty&quot;)<br>        String userId,<br>        @NotBlank(message = &quot;Password cannot be empty&quot;)<br>        String password) {<br>}</pre><p>再重新執行測試後通過測試。</p><h4>測試案例 2：註冊成功</h4><p>這個測試案例驗證透過 Service 註冊成功時，Controller 是否正確返回成功回應。</p><p>Request</p><pre>{<br>    &quot;userId&quot;: &quot;EvanChen&quot;,<br>    &quot;password&quot;: &quot;password01&quot;<br>}</pre><p>Response</p><pre>{<br>    &quot;success&quot;: true,<br>    &quot;data&quot;: {<br>        &quot;uuid&quot;: &quot;c261758b-b1f0-4998-812a-14c601e4d71d&quot;,<br>        &quot;userId&quot;: &quot;EvanChen&quot;<br>    }<br>}</pre><p>測試重點</p><ul><li>使用可通過驗證的userId與password</li><li>Mock Service 層返回成功結果</li><li>驗證回應內容</li></ul><p>在這個測試案例，Service出現了，我們要開始處理 Service回應註冊成功時，Controller應該怎麼回應。</p><p>首先新增測試案例，SignupRequest使用正常的帳號密碼，接著需要模擬Service 的回應。接著在這些紅字上面，Option + Enter 依序產生IUserService這個Interface及其方法。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C6FB0sZjyiQ_ErN31i3M_w.png" /></figure><p>完成後如下：</p><pre>@WebMvcTest(AuthController.class)<br>@Import(SecurityConfig.class)<br>class AuthControllerTest {<br><br>@MockBean<br>    private IUserService userService;<br>    <br>  @Test<br>  void signup_WhenSuccessful_ShouldReturnOkResponse() throws Exception {<br>     SignupRequest request = new SignupRequest(&quot;userId&quot;, &quot;password&quot;);<br>     when(userService.signup(request)).thenReturn(<br>            new SignupResult(new CreatedUser(&quot;uuid&quot;, &quot;userId&quot;))<br>     );<br>  }<br>}<br>public interface IUserService {<br>    CreatedUser signup(SignupRequest request);<br>}<br>@Service<br>public class UserService implements IUserService {<br>    @Override<br>    public CreatedUser signup(SignupRequest request) {<br>        throw new UnsupportedOperationException(&quot;Not supported yet.&quot;);<br>    }<br>}<br>public record CreatedUser(String uuid, String userId) { }</pre><p>這邊要注意雖然我們建立了Service。但還沒有要實作Service。我們目前仍在處理Controller，只是需要模擬Service的行為。所以這裡可以使用 throw new UnsupportedOperationException(“Not supported yet.”); 來表示未實作。不要回傳null或暫時的CreateUser物件。</p><pre>@Service<br>public class UserService implements IUserService {<br>    @Override<br>    public CreatedUser signup(SignupRequest request) {<br>        throw new UnsupportedOperationException(&quot;Not supported yet.&quot;);<br>    }<br>}</pre><p>接著用mockMvc 模擬API請求及驗證結果</p><pre>@Test<br>void signup_WhenSuccessful_ShouldReturnOkResponse() throws Exception {<br>    SignupRequest request = new SignupRequest(&quot;userId&quot;, &quot;password&quot;);<br>    when(userService.signup(request)).thenReturn(<br>            new SignupResult(new CreatedUser(&quot;uuid&quot;, &quot;userId&quot;))<br>    );<br>    mockMvc.perform(post(&quot;/auth/signup&quot;)<br>                    .contentType(MediaType.APPLICATION_JSON)<br>                    .content(objectMapper.writeValueAsString(request)))<br>            .andExpect(status().isOk())<br>            .andExpect(jsonPath(&quot;$.success&quot;).value(true))<br>            .andExpect(jsonPath(&quot;$.data.uuid&quot;).value(&quot;uuid&quot;))<br>            .andExpect(jsonPath(&quot;$.data.userId&quot;).value(&quot;userId&quot;));<br>}</pre><p>執行測試失敗(紅燈)。</p><pre>Status<br>Expected :200<br>Actual   :501</pre><p>這裡會是501是因為我們在signup是寫UnsupportedOperationException，所以GlobalException也要記得變處理UnsupportedOperationException為501。這跟一般500要區分，就是這個紅燈雖然要失敗，但也不能是500的錯誤，因為500代表你有地方沒處理好，用501來表示未實作。</p><p><strong>實作AuthController</strong></p><p>要通過這個測試，需要在AuthController開始處理Service，所以我們加上注入UserService，並呼叫userService.signup。接著執行測試，通過測試。</p><pre>@RestController<br>@RequestMapping(&quot;/auth&quot;)<br>public class AuthController {<br><br>private final IUserService userService;<br>    public AuthController(IUserService userService) {<br>        this.userService = userService;<br>    }<br>    @PostMapping(&quot;/signup&quot;)<br>    public ApiResponse&lt;SignupResponse&gt; signup(@Valid @RequestBody SignupRequest request) {<br>        var signupResult = userService.signup(request);<br>        var uuid = signupResult.createdUser().uuid();<br>        var userId = signupResult.createdUser().userId();<br>        return ApiResponse.success(new SignupResponse(uuid, userId));<br>    }<br>}<br><br>public record SignupResponse(String uuid, String userId) {<br>}</pre><p>在通過測試後，記得在git commit，如果有錯，我們可以快速的回到上一個版本。</p><p><strong>重構</strong></p><p>TDD的第3步驗：重構，在第二步驟通過測試時。用最快速簡單的方式來通過測試。接著在測試保護的情況下進行重構。</p><p>用重構工具 Refactor → Introduce Constant，將 userId與password重構提出為常數。</p><pre>@Test<br>void signup_WhenSuccessful_ShouldReturnOkResponse() throws Exception {<br>    SignupRequest request = new SignupRequest(&quot;userId&quot;, &quot;password&quot;);<br>    ...    <br>}</pre><p>重構完再重新測試一次</p><pre>public class AuthControllerTest {<br>public static final String USER_ID = &quot;userId&quot;;<br>    public static final String PASSWORD = &quot;password&quot;;<br>    <br>    @Test<br>    void signup_WhenSuccessful_ShouldReturnOkResponse() throws Exception {<br>        SignupRequest request = new SignupRequest(USER_ID, PASSWORD);<br>    }<br>}</pre><p>接著再Commit。</p><h4>測試案例 3：註冊失敗</h4><p>這個測試驗證當 Service 層返回驗證錯誤時，Controller 是否正確處理失敗情況。</p><p>新增測試案例：</p><pre>@Test<br>void signup_WhenServiceReturnsFails_ShouldReturnBadRequest() throws Exception {<br>    SignupRequest request = new SignupRequest(USER_ID, PASSWORD);<br>    List&lt;String&gt; validationErrors = List.of(&quot;error1&quot;, &quot;error2&quot;);<br>    when(userService.signup(request)).thenReturn(<br>            new SignupResult(null, validationErrors)<br>    );<br>    mockMvc.perform(post(&quot;/auth/signup&quot;)<br>                    .contentType(MediaType.APPLICATION_JSON)<br>                    .content(objectMapper.writeValueAsString(request)))<br>            .andExpect(status().isBadRequest())<br>            .andExpect(jsonPath(&quot;$.success&quot;).value(false))<br>            .andExpect(jsonPath(&quot;$.error&quot;).value(validationErrors.toString()));<br>}</pre><p>在這個案例，Controller要處理Service所回傳的錯誤訊息，也就是SignupResult這個類別，需要增加錯誤訊息。在new SignupResult 初始化直接加上一個預期的錯誤訊息。</p><p>同樣在紅字上按 Option + Enter 就可以插入新的欄位。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-DKKwhXoLlk_hAAXp7GWMQ.png" /></figure><p>另外我們加一個isSuccess來判斷是否成功。</p><pre>public record SignupResult(CreatedUser createdUser, List&lt;String&gt; error) {<br>	 public boolean isSuccess() {<br>        return error == null || error.isEmpty();<br>    }<br>}</pre><p>原本的signup也要修改一下判斷isSuccess才回傳。在isSuccess=false時，我們先不處理，先加上throw new UnsupportedOperationException(“Not supported yet.”);。</p><pre>@PostMapping(&quot;/signup&quot;)<br>public ApiResponse&lt;SignupResponse&gt; signup(@Valid @RequestBody SignupRequest request) {<br>    var signupResult = userService.signup(request);<br>    if (signupResult.isSuccess()) {<br>        var uuid = signupResult.createdUser().uuid();<br>        var userId = signupResult.createdUser().userId();<br>        return ApiResponse.success(new SignupResponse(uuid, userId));<br>    }else{<br>		    //先不要處理，先產生一個紅色<br>        throw new UnsupportedOperationException(&quot;Not supported yet.&quot;);<br>    }<br>}</pre><p>執行測試失敗(紅燈)。這邊記得所以的測試記得都要執行，因為改了signup 有可能會改壞之前的。</p><p><strong>實作AuthController</strong></p><p>在AuthController，原本的UnsupportedOperationException 改成 Controller補上error處理</p><pre>if (signUpResult.isSuccess()) {<br>        ...<br>    }else{<br>        return ApiResponse.fail(HttpStatus.BAD_REQUEST, signUpResult.error().toString());<br>    }</pre><p>再執行測試就通過。這樣就透過TDD完成Controller了。這樣我們就完成Controller。如果這時候執行應用程式。在postman測試，輸入帳號錯誤的已經可以正常運作。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*byinhTJhwyDwDZGewuxJgQ.png" /></figure><p>而輸入正常的的帳號密碼會是501，因為我們Service還沒實作。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DWmOdAmDH9Z9qxrrGLa6Zw.png" /></figure><p>下一篇接著介紹Service</p><p><a href="https://evanchen76.medium.com/spring-boot-tdd-%E6%B8%AC%E8%A9%A6%E9%A9%85%E5%8B%95%E9%96%8B%E7%99%BC2-58a426c50d01">https://evanchen76.medium.com/spring-boot-tdd-%E6%B8%AC%E8%A9%A6%E9%A9%85%E5%8B%95%E9%96%8B%E7%99%BC2-58a426c50d01</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=989de21363ea" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spring Boot 單元測試 (2)]]></title>
            <link>https://evanchen76.medium.com/spring-boot-%E5%96%AE%E5%85%83%E6%B8%AC%E8%A9%A6-2-e65b1d261c12?source=rss-cdd80585381e------2</link>
            <guid isPermaLink="false">https://medium.com/p/e65b1d261c12</guid>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Evan Chen]]></dc:creator>
            <pubDate>Fri, 01 Nov 2024 08:19:46 GMT</pubDate>
            <atom:updated>2024-11-01T11:11:00.871Z</atom:updated>
            <content:encoded><![CDATA[<h3>撰寫Service的單元測試</h3><p>延續上一篇的<a href="https://evanchen76.medium.com/spring-boot-%E5%96%AE%E5%85%83%E6%B8%AC%E8%A9%A6-795a41176a40">Spring Boot 單元測試</a>。接下來我們要進行Service層的單元測試。由於Service負責處理核心業務邏輯，且通常會依賴Repository進行資料存取，因此測試時我們需要使用Mock技術來模擬Repository的行為，以確保測試的隔離性與穩定性。這樣可以專注於驗證Service的業務邏輯是否正確，而不受資料庫等外部因素影響。</p><p>回到 Service 層，Service 主要負責處理商業邏輯。在這個範例中，我們的 Service 主要處理三個任務：</p><ol><li>檢查帳號、密碼格式</li><li>檢查帳號是否存在</li><li>新增帳號</li></ol><p>讓我們看看實際的程式碼，請開啟service/UserService</p><pre>public SignupResult signup(String userId, String password) {<br>    //1.格式檢查<br>    List&lt;String&gt; signupValidations = new ArrayList&lt;&gt;();<br>    if (userId == null || userId.length() &lt; 3 || userId.length() &gt; 20) {<br>        signupValidations.add(&quot;User id must be between 3 and 20 characters long&quot;);<br>    }<br>    if (password == null || password.length() &lt; 8 || password.length() &gt; 30) {<br>        signupValidations.add(&quot;Password must be between 8 and 30 characters long&quot;);<br>    }<br>    //2.檢查帳號是否存在<br>    if (userRepository.existsByUserId(userId)) {<br>        return new SignupResult(null, List.of(&quot;User already exists&quot;));<br>    }<br>    if (!signupValidations.isEmpty()) {<br>        return new SignupResult(null, signupValidations);<br>    }<br>    //3.新增帳號<br>    CreatedUser savedUser = userRepository.insert(<br>            new UserAccount(null, UUID.randomUUID(), userId, passwordEncoder.encode(password))<br>    );<br>    return new SignupResult(savedUser, signupValidations);<br>}</pre><h4>開始撰寫測試</h4><p>請開啟UserServiceTest。在開始撰寫測試之前，需要注意的是：Service 的單元測試不應該使用 @Autowired 來注入 UserService。我們應該手動建立 UserService 實體，這樣能確保 Service 可以被獨立測試，不需依賴 Spring 框架。</p><pre>private UserService userService;<br><br>@BeforeEach<br>void setUp() {<br>     userService = new UserService(userRepository);<br>}</pre><p><strong>基本格式驗證測試：</strong></p><p>正確格式userId與password可通過檢查</p><pre>@Test<br>void signup_ShouldFailWithInvalidInput(){<br>    String userId = &quot;userId&quot;;<br>    String password = &quot;password123&quot;;<br>    var result = userService.signup(userId, password);<br>    assertThat(result.error()).isEmpty();<br>}</pre><p><strong>參數化測試：無效輸入處理</strong></p><p>接下來，我們使用參數化測試來驗證各種無效輸入的情況。這種測試方法可以透過多組測試資料驗證，有效的驗證 signup 方法對各種無效輸入的處理能力。</p><pre>@ParameterizedTest<br>@MethodSource(&quot;invalidSignupRequests&quot;)<br>void signup_ShouldFailWithInvalidInput(String userId, String password, int expectedErrorCount) {<br>    var result = userService.signup(userId, password);<br>    assertThat(result.isSuccess()).isFalse();<br>    assertThat(result.error()).hasSize(expectedErrorCount);<br>}<br><br>private static Stream&lt;Arguments&gt; invalidSignupRequests() {<br>    return Stream.of(<br>            // 測試無效的userId - 預期1個錯誤<br>            Arguments.of(null, PASSWORD, 1),<br>            Arguments.of(&quot;&quot;, PASSWORD, 1),<br>            Arguments.of(&quot;ab&quot;, PASSWORD, 1),<br>            Arguments.of(&quot;a&quot;.repeat(21), PASSWORD, 1),<br>            // 測試無效的password - 預期1個錯誤<br>            Arguments.of(USER_ID, null, 1),<br>            Arguments.of(USER_ID, &quot;&quot;, 1),<br>            Arguments.of(USER_ID, &quot;short&quot;, 1),<br>            Arguments.of(USER_ID, &quot;a&quot;.repeat(31), 1),<br>            // 測試userId和password同時無效 - 預期2個錯誤<br>            Arguments.of(&quot;ab&quot;, &quot;short&quot;, 2)<br>    );<br>}</pre><p><strong>測試重複帳號註冊</strong></p><p>這個測試的重點是驗證當帳號已存在時，signup 方法的行為：</p><pre>@Mock<br>private UserRepository userRepository;<br><br>@Test<br>void signup_UserExists() {<br>  //模擬帳號已存在<br>    when(userRepository.existsByUserId(USER_ID)).thenReturn(true);<br>    <br>    var result = userService.signup(USER_ID, PASSWORD);<br>    <br>    assertFalse(result.isSuccess());<br>    assertThat(result.error()).hasSize(1);<br>}</pre><p><strong>測試成功註冊流程</strong></p><p>最後，成功註冊的情況：</p><pre>private final CreatedUser createdUser = new CreatedUser(USER_UUID, USER_ID);<br><br>@Mock<br>private UserRepository userRepository;<br>@Mock<br>private PasswordEncoder passwordEncoder;<br>@Test<br>void signup_Success() {<br>  //模擬沒有已存在的帳號<br>    when(userRepository.existsByUserId(USER_ID)).thenReturn(false);<br>    //模擬Repository新增帳號成功<br>    when(userRepository.insert(any(UserAccount.class))).thenReturn(createdUser);<br>    <br>    var result = userService.signup(USER_ID, PASSWORD);<br>    assertThat(result.isSuccess()).isTrue();<br>    assertThat(result.createdUser()).isEqualTo(createdUser);<br>}</pre><h3>撰寫Repository的測試</h3><p>Repository 層是應用程式中負責資料持久化的重要元件。在這個範例中，我們的 Repository使用JdbcTemplate與 MySQL 資料庫的直接互動，並提供兩個主要功能：</p><ul><li>檢查使用者是否存在</li><li>新增帳號</li></ul><p>請開啟repository/UserRepository，被測試程式碼如下：</p><pre>@Repository<br>public class UserRepository {<br>    private final JdbcTemplate jdbcTemplate;<br><br>    public Boolean existsByUserId(String userId) {<br>        String sql = &quot;SELECT EXISTS(SELECT 1 FROM user_account WHERE user_id = ?)&quot;;<br>        return Boolean.TRUE.equals(jdbcTemplate.queryForObject(sql, Boolean.class, userId));<br>    }<br><br>    public CreatedUser insert(UserAccount user) {<br>        String sql = &quot;INSERT INTO user_account (uuid, user_id, password_hash) VALUES (?, ?, ?)&quot;;<br>        int rowsAffected = jdbcTemplate.update(sql,<br>                user.uuid().toString(),<br>                user.userId(),<br>                user.passwordHash());<br>        if (rowsAffected != 1) {<br>            throw new RuntimeException(&quot;Failed to insert user account&quot;);<br>        }<br>        return new CreatedUser(user.uuid(), user.userId());<br>    }<br>}</pre><h4>設定測試環境</h4><p>在開始撰寫測試之前，我們需要一個獨立的測試環境，避免影響到正式資料庫。這裡使用 Testcontainers 來建立測試用的 MySQL 容器。</p><p>首先建立測試類別並加上@Testcontainers</p><pre>@SpringBootTest<br>@Testcontainers<br>class UserRepositoryTest {<br>}</pre><h4>資料庫初始化</h4><p><strong>建立資料表結構</strong></p><p>在 test/resources 目錄下建立 schema.sql：</p><pre>-- Create user_account table<br>CREATE TABLE IF NOT EXISTS `user_account` (<br>    `id` bigint NOT NULL AUTO_INCREMENT,<br>    `uuid` varchar(36) NOT NULL,<br>    `user_id` varchar(255) DEFAULT NULL,<br>    `password_hash` varchar(255) DEFAULT NULL,<br>    PRIMARY KEY (`id`),<br>    UNIQUE KEY `uuid` (`uuid`)<br>    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;</pre><p><strong>建立測試輔助類別</strong></p><p>建立 TestHelper 類別來管理測試資料庫：</p><pre>@Component<br>public class TestHelper {<br><br>@Autowired<br>    private JdbcTemplate jdbcTemplate;<br>    @Autowired<br>    private DataSource dataSource;<br>    public void clearDatabase() {<br>        jdbcTemplate.execute(&quot;DELETE FROM user_account&quot;);<br>    }<br>    public void createTestTable() {<br>        ResourceDatabasePopulator populator = new ResourceDatabasePopulator();<br>        populator.addScript(new ClassPathResource(&quot;schema.sql&quot;));<br>        populator.execute(dataSource);<br>    }<br>}</pre><h4>撰寫測試案例</h4><p><strong>設定測試環境</strong></p><p>回到UserRepositoryTest 在測試類別中加入初始化設定：</p><ul><li>在setup確認資料庫建立成功</li><li>在setUpEach每次刪除資料</li></ul><pre>@SpringBootTest<br>@Testcontainers<br>class UserRepositoryTest {<br>    @BeforeAll<br>    static void setUp() {<br>        TestDatabaseConfig.startContainer();<br>    }<br><br>    @BeforeEach<br>    void setUpEach() {<br>        testHelper.createTestTable();<br>        testHelper.clearDatabase();<br>    }<br>}</pre><p>測試新增帳號功能</p><pre>@Test<br>void testInsert() {<br>    var userCreatedResponse = userRepository.insert(fakeUserAccount);<br>    <br>    assertThat(userCreatedResponse)<br>            .isNotNull()<br>            .satisfies(inserted -&gt; {<br>                assertThat(inserted.uuid()).isEqualTo(fakeUserAccount.uuid());<br>                assertThat(inserted.userId()).isEqualTo(fakeUserAccount.userId());<br>            });<br>}</pre><p>測試帳號不存在</p><pre>@Test<br>void testFindByUserIdNotFound() {<br>    boolean exist = userRepository.existsByUserId(&quot;nonexistent&quot;);<br>    assertThat(exist).isFalse();<br>}</pre><p>測試帳號已存在，在驗證前需先在資料庫新增一筆資料</p><pre>@Test<br>void testFindByUserIdFound() {<br>    //在資料庫新增資料<br>    userRepository.insert(fakeUserAccount);<br>    assertThat(userRepository.existsByUserId(USER_ID)).isTrue();<br>}</pre><p>這個範例展示了如何使用 Testcontainers 進行資料庫整合測試：</p><ol><li>使用容器建立獨立的測試環境</li><li>透過 schema.sql 維護資料表結構</li><li>使用 TestHelper 管理測試資料</li><li>撰寫完整的測試案例驗證功能</li></ol><p>通過這種方式，我們可以確保資料庫操作的正確性，同時不會影響到正式環境的資料。</p><p>以上，介紹了在Spring boot ，以註冊會員為範例的API功能，撰寫Controller、Service、Repository的測試。</p><p>接著介紹如何使用TDD來開發。</p><p><a href="https://evanchen76.medium.com/spring-boot-tdd-%E6%B8%AC%E8%A9%A6%E9%A9%85%E5%8B%95%E9%96%8B%E7%99%BC-989de21363ea">Spring Boot TDD 測試驅動開發</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e65b1d261c12" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spring Boot 單元測試]]></title>
            <link>https://evanchen76.medium.com/spring-boot-%E5%96%AE%E5%85%83%E6%B8%AC%E8%A9%A6-795a41176a40?source=rss-cdd80585381e------2</link>
            <guid isPermaLink="false">https://medium.com/p/795a41176a40</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[spring-boot]]></category>
            <dc:creator><![CDATA[Evan Chen]]></dc:creator>
            <pubDate>Fri, 01 Nov 2024 08:17:46 GMT</pubDate>
            <atom:updated>2024-11-01T11:15:03.196Z</atom:updated>
            <content:encoded><![CDATA[<p>Spring Boot TDD系列</p><ul><li><a href="https://evanchen76.medium.com/spring-boot-%E5%96%AE%E5%85%83%E6%B8%AC%E8%A9%A6-795a41176a40">Spring Boot 單元測試</a></li><li><a href="https://evanchen76.medium.com/spring-boot-%E5%96%AE%E5%85%83%E6%B8%AC%E8%A9%A6-2-e65b1d261c12">Spring Boot 單元測試 2</a></li><li><a href="https://evanchen76.medium.com/spring-boot-tdd-%E6%B8%AC%E8%A9%A6%E9%A9%85%E5%8B%95%E9%96%8B%E7%99%BC-989de21363ea">Spring Boot TDD 測試驅動開發</a></li><li><a href="https://evanchen76.medium.com/spring-boot-tdd-%E6%B8%AC%E8%A9%A6%E9%A9%85%E5%8B%95%E9%96%8B%E7%99%BC2-58a426c50d01">Spring Boot TDD 測試驅動開發 2</a></li></ul><p>本文將介紹如何為 Spring Boot 專案撰寫單元測試，以會員註冊功能為例。</p><p>功能說明：實作一個會員註冊的 API，允許使用者透過帳號密碼進行註冊，並將資料儲存至 MySQL 資料庫。</p><p>完整程式碼可參考 <a href="https://github.com/evanchen76/SpringTDDSample">https://github.com/evanchen76/SpringTDDSample</a></p><h4>API 規格</h4><p>註冊帳號API</p><ul><li><strong>URL</strong>: /auth/signup</li><li><strong>方法</strong>: POST</li><li><strong>Content-Type</strong>: application/json</li></ul><h4>請求參數</h4><p><strong>userId</strong></p><ul><li>類型：string</li><li>必填：是</li><li>描述：使用者Id</li></ul><p><strong>password</strong></p><ul><li>類型：string</li><li>必填：是</li><li>描述：使用者密碼</li></ul><h4>請求範例</h4><pre>{<br>    &quot;userId&quot;: &quot;EvanChen10&quot;,<br>    &quot;password&quot;: &quot;Aaaaaaaa1&quot;<br>}</pre><p>成功回應</p><p>狀態碼: 200 OK</p><pre>{<br>    &quot;success&quot;: true,<br>    &quot;data&quot;: {<br>        &quot;uuid&quot;: &quot;c261758b-b1f0-4998-812a-14c601e4d71d&quot;,<br>        &quot;userId&quot;: &quot;EvanChen10&quot;<br>    }<br>}</pre><p>錯誤回應</p><p>狀態碼: 400 Bad Request</p><pre>{<br>    &quot;success&quot;: false,<br>    &quot;error&quot;: &quot;User already exists&quot;<br>}</pre><p>另外這個註冊功能會檢查帳號格式</p><p>帳號長度為3–20、密碼長度為8–30</p><p>錯誤回應</p><p>狀態碼: 400 Bad Request</p><pre>{<br>    &quot;success&quot;: false,<br>    &quot;error&quot;: &quot;User id must be between 3 and 20 characters long&quot;<br>}</pre><h4>資料庫：</h4><p>使用MySQL</p><p>user_account Table：</p><ol><li>id: bigint (主鍵) (NN)</li><li>uuid: varchar(36) (NN)</li><li>user_id: varchar(255)</li><li>password_hash: varchar(255)</li></ol><p>資料庫，你可以在MySQL執行以下指令匯入。</p><pre>-- MySQL dump 10.13  Distrib 8.0.38, for macos14 (arm64)<br>--<br>-- Host: localhost    Database: mydb<br>-- ------------------------------------------------------<br>-- Server version 9.0.1<br><br>/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;<br>/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;<br>/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;<br>/*!50503 SET NAMES utf8 */;<br>/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;<br>/*!40103 SET TIME_ZONE=&#39;+00:00&#39; */;<br>/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;<br>/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;<br>/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE=&#39;NO_AUTO_VALUE_ON_ZERO&#39; */;<br>/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;<br><br>--<br>-- Table structure for table `user_account`<br>--<br><br>DROP TABLE IF EXISTS `user_account`;<br>/*!40101 SET @saved_cs_client     = @@character_set_client */;<br>/*!50503 SET character_set_client = utf8mb4 */;<br>CREATE TABLE `user_account` (<br>  `id` bigint NOT NULL AUTO_INCREMENT,<br>  `uuid` varchar(36) NOT NULL,<br>  `user_id` varchar(255) NOT NULL,<br>  `password_hash` varchar(255) DEFAULT NULL,<br>  PRIMARY KEY (`id`),<br>  UNIQUE KEY `uuid` (`uuid`),<br>  UNIQUE KEY `user_id_UNIQUE` (`user_id`)<br>) ENGINE=InnoDB AUTO_INCREMENT=33 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;<br>/*!40101 SET character_set_client = @saved_cs_client */;<br><br>--<br>-- Dumping data for table `user_account`<br>--<br>/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;<br><br>/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;<br>/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;<br>/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;<br>/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;<br>/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;<br>/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;<br>/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;<br><br>-- Dump completed on 2024-10-30 18:28:26</pre><h3>撰寫Controller 測試</h3><p>請開啟SpringTDDSample，首先讓我們看看要測試的 AuthController：</p><pre>@RestController<br>@RequestMapping(&quot;/auth&quot;)<br>public class AuthController {<br><br>    private final IUserService userService;<br><br>    public AuthController(IUserService userService) {<br>        this.userService = userService;<br>    }<br><br>    @PostMapping(&quot;/signup&quot;)<br>    public ApiResponse&lt;SignupResponse&gt; signup(@Valid @RequestBody SignupRequest request) {<br>        SignupResult result = userService.signup(request.userId(), request.password());<br>        if (result.isSuccess()) {<br>            return ApiResponse.success(new SignupResponse(result.getCreatedUser().uuid().toString(), result.getCreatedUser().userId()));<br>        } else {<br>            return ApiResponse.badRequest(result.getValidationErrors().toString());<br>        }<br>    }<br>}</pre><p>相關的 Request/Response 類別</p><pre>public record SignupRequest(<br>        @NotBlank(message = &quot;UserId cannot be empty&quot;)<br>        String userId,<br>        @NotBlank(message = &quot;Password cannot be empty&quot;)<br>        String password) {<br>}<br><br>public record SignupResponse(String uuid, String userId) { }</pre><h4>測試策略</h4><p>對於註冊API，我們需要測試以下三個主要場景：</p><ol><li>輸入驗證失敗：當請求的欄位不符合要求時</li><li>註冊成功：當 Service 層成功創建用戶時</li><li>註冊失敗：當 Service 層返回驗證錯誤時</li></ol><p><strong>測試案例 1：輸入驗證失敗</strong></p><p>Request</p><pre>{<br>    &quot;userId&quot;: &quot;&quot;,<br>    &quot;password&quot;: &quot;&quot;<br>}</pre><p>Response</p><pre>{<br>    &quot;success&quot;: false,<br>    &quot;error&quot;: &quot;password: Password cannot be empty, userId: UserId cannot be empty&quot;<br>}</pre><p>測試重點：</p><ul><li>使用帳號密碼為空字串建立請求</li><li>驗證 HTTP 狀態碼為 400 Bad Request</li><li>驗證回應中的success為false</li><li>驗證回應中包含錯誤訊息</li></ul><pre>@Test<br>void signup_WhenAllFieldsEmpty_ShouldFailValidation() throws Exception {<br>    //使用帳號密碼為空字串建立請求<br>    SignupRequest request = new SignupRequest(&quot;&quot;, &quot;&quot;);<br>    //請求API<br>    mockMvc.perform(post(SIGNUP_URL)<br>                    .contentType(MediaType.APPLICATION_JSON)<br>                    .content(objectMapper.writeValueAsString(request)))<br>            //驗證 HTTP 狀態碼為 400 Bad Request<br>            .andExpect(status().isBadRequest())<br>            //驗證回應中的success為false<br>            .andExpect(jsonPath(&quot;$.success&quot;).value(false))<br>            //驗證回應中包含錯誤訊息<br>            .andExpect(jsonPath(&quot;$.error&quot;).isNotEmpty());<br>}</pre><h4>測試案例 2：註冊成功</h4><p>驗證 Service 成功處理請求時，Controller 是否正確返回成功回應。</p><p>Request</p><pre>{<br>    &quot;userId&quot;: &quot;EvanChen&quot;,<br>    &quot;password&quot;: &quot;password01&quot;<br>}</pre><p>Response</p><pre>{<br>    &quot;success&quot;: true,<br>    &quot;data&quot;: {<br>        &quot;uuid&quot;: &quot;c261758b-b1f0-4998-812a-14c601e4d71d&quot;,<br>        &quot;userId&quot;: &quot;EvanChen&quot;<br>    }<br>}</pre><p>測試重點</p><ul><li>使用可通過驗證的userId與password</li><li>Mock Service 層返回成功結果</li><li>驗證回應內容</li></ul><pre>@WebMvcTest(AuthController.class)<br>@Import(SecurityConfig.class)<br>class AuthControllerTest {<br>     public static final String USER_ID = &quot;userId&quot;;<br> <br>     @Test<br>     void signup_WhenSuccessful_ShouldReturnOkResponse() throws Exception {<br>	<br>       SignupRequest request = new SignupRequest(USER_ID, PASSWORD);<br>       CreatedUser createdUser = new CreatedUser(UUID.randomUUID(), USER_ID);<br>     <br>       //mock 呼叫userService傳入userId及password，回傳UserId及UserID<br>       when(userService.signup(request.userId(), request.password())).thenReturn(<br>               new SignupResult(createdUser, new ArrayList&lt;&gt;())<br>       );<br>       <br>       mockMvc.perform(post(&quot;/auth/signup&quot;)<br>                       .contentType(MediaType.APPLICATION_JSON)<br>                       .content(objectMapper.writeValueAsString(request)))<br>               //驗證status是200<br>               .andExpect(status().isOk())<br>               //success = true<br>               .andExpect(jsonPath(&quot;$.success&quot;).value(true))<br>               //uuid<br>               .andExpect(jsonPath(&quot;$.data.uuid&quot;).value(&quot;uuid&quot;))<br>               //userId<br>               .andExpect(jsonPath(&quot;$.data.userId&quot;).value(&quot;userId&quot;));<br>   }<br>}</pre><h4>測試案例 3：註冊失敗</h4><p>這個測試驗證當 Service 層返回驗證錯誤時，Controller 是否正確處理失敗情況。</p><ul><li>Mock Service 層返回失敗結果</li><li>驗證錯誤回應的內容</li></ul><pre>@Test<br>void signup_WhenServiceReturnsFails_ShouldReturnBadRequest() throws Exception {<br>    SignupRequest request = new SignupRequest(USER_ID, PASSWORD);<br>    List&lt;String&gt; validationErrors = List.of(&quot;error1&quot;, &quot;error2&quot;);<br>    when(userService.signup(request.userId(), request.password())).thenReturn(<br>            new SignupResult(null, validationErrors)<br>    );<br>    mockMvc.perform(post(&quot;/auth/signup&quot;)<br>                    .contentType(MediaType.APPLICATION_JSON)<br>                    .content(objectMapper.writeValueAsString(request)))<br>            .andExpect(status().isBadRequest())<br>            .andExpect(jsonPath(&quot;$.success&quot;).value(false))<br>            .andExpect(jsonPath(&quot;$.error&quot;).value(validationErrors.toString()));<br>}</pre><h4>測試資料管理</h4><p>在進行 Controller 測試時，有幾個重要的實踐原則需要特別注意。首先是測試資料的管理策略。建議將常用的測試資料，如 userId、password 等，定義為類別級別的Constant。這樣不僅可以提高程式碼的可維護性，也能確保測試資料的一致性。例如：</p><pre>class AuthControllerTest {<br>    public static final String USER_ID = &quot;userId&quot;;<br>    public static final String PASSWORD = &quot;password&quot;;<br>}</pre><h4>避免使用過於具體的資料</h4><p>在選擇測試資料時，應該使用有意義但不過度具體的值。舉例來說，在測試案例3中，當測試驗證錯誤時，不應該使用具體的業務相關錯誤訊息：</p><pre>// 較好的做法<br>List&lt;String&gt; validationErrors = List.of(&quot;error1&quot;, &quot;error2&quot;);<br><br>// 避免使用<br>List&lt;String&gt; validationErrors = List.of(&quot;User id must be between 3 and 20 characters long&quot;);</pre><p>使用較為中性的錯誤訊息可以降低測試的維護成本，因為具體的錯誤訊息可能會隨著業務規則的變化而改變。</p><h4>選擇適當的驗證程度</h4><p>在驗證策略方面，我們需要根據測試的重點來決定驗證的深度。對於容易變動的內容，比如錯誤訊息，我們通常只需要驗證其存在性：</p><pre>.andExpect(jsonPath(&quot;$.error&quot;).isNotEmpty());</pre><p>但對於關鍵的業務資料，如 userId 或 uuid，則應該進行完整的值比對：</p><pre>.andExpect(jsonPath(&quot;$.data.userId&quot;).value(USER_ID));</pre><h4>互動測試</h4><p>在測試範圍的選擇上，Controller 測試主要關注的是 HTTP 請求處理流程。不需要過度關注 Service 層的呼叫細節，例如驗證 Service 方法被呼叫的次數。另外以這個例子，如果沒有正確的呼叫service.signup，mock也會失敗，所以某種程度也是驗證了呼叫service這件事。</p><pre>//不需要用這方式驗證<br>verify(userService, times(1)).signup(userId, password);<br><br>//在mock時，如果userId及password傳遞錯誤，測試也會失敗<br>when(userService.signup(request.userId(), request.password())).thenReturn(<br>        new SignupResult(createdUser, new ArrayList&lt;&gt;())<br>);</pre><h4>避免撰寫與被測試物件無關的案例</h4><p>在設計 API 時，我將帳號密碼的格式驗證視為業務邏輯，因此這些驗證規則是在 Service 層級處理，而不是在 Controller 層級。(一般格式應在Controller檢查，但這裡我把帳號密碼的規則試為業務邏輯)。依據單元測試的原則，我們應該專注在被測試物件（在這裡是 AuthController）的核心職責上：</p><p>以下是一個不好的範例</p><ul><li>依賴了實際的驗證邏輯（Service層的業務規則）</li><li>透過輸入無效的資料來觸發錯誤，這屬於整合測試的範疇</li><li>測試結果會受到 Service 層驗證規則改變的影響</li></ul><pre>@Test<br>void signup_WhenServiceReturnsFails_ShouldReturnBadRequest() throws Exception {<br>		//不好的寫法：用帳號a密碼a來表示無法通過service的註冊流程<br>    SignupRequest request = new SignupRequest(&quot;a&quot;, &quot;a&quot;);<br>    <br>    mockMvc.perform(post(&quot;/auth/signup&quot;)<br>                    .contentType(MediaType.APPLICATION_JSON)<br>                    .content(objectMapper.writeValueAsString(request)))<br>            .andExpect(status().isBadRequest())<br>            .andExpect(jsonPath(&quot;$.success&quot;).value(false))<br>            .andExpect(jsonPath(&quot;$.error&quot;).value(validationErrors.toString()));<br>}</pre><p>格式驗證這類的端對端行為測試，應該要在整合測試中進行，而且是在多個層級（Controller、Service、Repository）都整合在一起的情況下測試。</p><h4>單元測試 或 整合測試</h4><p>這個Controller測試，其實算是整合測試。單元測試應該會如下方程式碼這樣，直接呼叫Controller的方法並驗證回傳值。但這樣的測試會有幾個問題。例如不容易驗證@Valid、url的mapping、Interceptor等。</p><pre>@Test<br>void signup_WhenSuccessful_ShouldReturnOkResponse() {<br>    CreatedUser response = new CreatedUser(UUID.randomUUID(), USER_ID);<br>		SignupResult successResult = SignupResult.success(response);<br>		when(userService.signup(USER_ID, PASSWORD)).thenReturn(successResult);<br>    //直接呼叫authController.signup<br>    var response = authController.signup(new SignupRequest(USER_ID, PASSWORD));<br>    assertThat(response)<br>            .extracting(ApiResponse::getBody)<br>            .extracting(ApiResponse.Body::getData)<br>            .extracting(SignupResponse::userId)<br>            .isEqualTo(USER_ID);<br>}</pre><p>所以關於單元測試和整合測試的選擇，需要考慮 Controller 的主要職責。一般來說，Controller 主要負責：</p><ul><li>接收請求和返回回應</li><li>進行基本的參數驗證</li><li>呼叫適當的 Service 方法</li></ul><p>基於這些職責，使用 MockMvc 進行整合測試是較為合適的選擇。這種方式可以測試完整的請求處理流程，同時也能驗證 Spring 相關的配置。雖然與純單元測試相比，整合測試的執行時間可能較長，但 MockMvc 提供了一個很好的平衡點，它不需要啟動完整的服務，同時又能覆蓋到包括 @Valid 等 Spring 功能。</p><p>如果 Controller 中包含了較為複雜的業務邏輯（雖然這種情況應該盡量避免），那麼可以考慮額外寫單元測試。但在一般情況下，建議將複雜的業務邏輯放在 Service 層處理，保持 Controller 的簡潔性。這樣不僅可以使程式碼結構更清晰，也能讓測試更加聚焦和有效。</p><p>下一篇繼續介紹Service單元測試</p><p><a href="https://evanchen76.medium.com/spring-boot-%E5%96%AE%E5%85%83%E6%B8%AC%E8%A9%A6-2-e65b1d261c12">Spring Boot 單元測試 (2)</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=795a41176a40" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[重構: if else 的巢狀程式碼]]></title>
            <link>https://evanchen76.medium.com/%E9%87%8D%E6%A7%8B-if-else-%E7%9A%84%E5%B7%A2%E7%8B%80%E7%A8%8B%E5%BC%8F%E7%A2%BC-ded4c1378cad?source=rss-cdd80585381e------2</link>
            <guid isPermaLink="false">https://medium.com/p/ded4c1378cad</guid>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[refactoring]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Evan Chen]]></dc:creator>
            <pubDate>Tue, 29 Oct 2024 02:04:08 GMT</pubDate>
            <atom:updated>2024-10-29T02:04:35.931Z</atom:updated>
            <content:encoded><![CDATA[<h4>什麼是巢狀程式碼</h4><p>巢狀程式碼(Nested Code)指的是在控制結構（如if-else、while、for等) 內部還包含其他控制結構的程式碼，形成多層縮排的結構。例如：</p><pre>if (a) {                   <br>    if (b) { <br>        if (c) { <br>            doSomething();<br>        } else {<br>            doAnotherThing();<br>        }<br>    } else {<br>        doSomethingElse();<br>    }<br>} else {<br>    handleError();<br>}</pre><p>巢狀程式碼雖然在功能上可能正確，但存在以下問題：</p><ul><li>可讀性差：多層巢狀結構使程式碼難以理解。</li><li>可維護性低：修改時容易出錯，需要仔細追蹤邏輯分支。</li><li>重複程式碼多：常見相同的邏輯散落在不同層級中。</li><li>需求不明確：商業邏輯被埋在多層條件中，難以對應到實際需求。</li></ul><h4>案例需求說明</h4><p>本文將重構一個折扣價格判斷的程式，其需求為：</p><ol><li>必須是<strong>過季商品</strong>(lastsessionProduct) 或 <strong>促銷商品</strong>(promotionProduct)</li><li>必須是<strong>金卡會員</strong>或<strong>銀卡會員</strong></li><li>需要輸入折扣碼”<strong>SPECIAL_DISCOUN</strong>T”</li></ol><p>符合以上三個條件才能享有折扣價格。</p><p>原始程式碼：</p><pre>void discountPrice(boolean lastSessionProduct, MemberType memberType, boolean promotionProduct, String promoCode) {<br>    if (lastSessionProduct) {<br>        if (memberType == MemberType.SILVER) {<br>            if (promoCode.equals(&quot;SPECIAL_DISCOUNT&quot;)) {<br>                updateDiscountPrice(true);<br>            } else {<br>                updateDiscountPrice(false);<br>            }<br>        } else if (memberType == MemberType.GOLD) {<br>            if (promoCode.equals(&quot;SPECIAL_DISCOUNT&quot;)) {<br>                updateDiscountPrice(true);<br>            } else {<br>                updateDiscountPrice(false);<br>            }<br>        }else{<br>            updateDiscountPrice(false);<br>        }<br>    } else {<br>        if (memberType == MemberType.SILVER &amp;&amp; promotionProduct) {<br>            if (promoCode.equals(&quot;SPECIAL_DISCOUNT&quot;)) {<br>                updateDiscountPrice(true);<br>            } else {<br>                updateDiscountPrice(false);<br>            }<br>        } else {<br>            if (memberType == MemberType.GOLD &amp;&amp; promotionProduct ) {<br>                if (promoCode.equals(&quot;SPECIAL_DISCOUNT&quot;)) {<br>                    updateDiscountPrice(true);<br>                } else {<br>                    updateDiscountPrice(false);<br>                }<br>            }else{<br>                updateDiscountPrice(false);<br>            }<br>        }<br>    }<br>}</pre><h4>常見重構技巧</h4><p>在開始之前，我們先介紹幾個要處理這個需求的 if else 相關重構技巧。</p><p><strong>條件合併</strong></p><p>當多個 if-else 中執行相同邏輯時，可以合併條件：</p><pre>// 重構前<br>if (a == true) {<br>    hello();<br>} else if (b == true) {<br>    hello();<br>}<br><br>// 重構後<br>if (a || b) {<br>    hello();<br>}</pre><p>這樣的重構，可以透過工具完成。按下Optional + Enter 選擇Merge sequential ‘if’ statements 就可以了。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/650/1*OkCbLVwuFCHiXxymS18mFA.png" /></figure><p>接著可以再簡化為</p><pre>if (a || b) {<br>    hello();<br>}</pre><p><strong>提取共同條件</strong></p><p>當多個分支包含相同條件時,可以提取到外層：</p><pre>// 重構前<br>if (a == true &amp;&amp; b == true) {<br>    hello();<br>} else {<br>    if (b == true) {<br>        world();<br>    }<br>}<br><br>// 重構後<br>if (b == true) {<br>    if (a == true) {<br>        hello();<br>    } else {<br>        world();<br>    }<br>}</pre><p>重構方式：在 b == true 按下Option + Enter後Extract if (b == true)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/964/1*UzsbDWJBS_kbS09mQnDcvw.png" /></figure><p><strong>移除多餘的 else 分支</strong></p><p>當 else 中只包含一個 if 時，可以合併：</p><pre>// 重構前<br>if (a){<br>    hello();<br>}else{<br>    //這個if 可以往上合併<br>    if (b){<br>        world();<br>    }<br>}<br><br>//重構後<br>if (a){<br>    hello();<br>}else if (b) {<br>    world();<br>}</pre><p>重構方式：在else 上執行Merge else if</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/648/1*A_YJjryvh8nSRvOiwgSQpg.png" /></figure><p><strong>合併遠距離的相同邏輯</strong></p><p>當相同的程式碼邏輯被分散在不同層級的巢狀結構中時，可以先把它們拉近再合併：</p><pre>// 重構前：相同邏輯(hello)被分散<br>if (a){<br>    //相同點1<br>    hello();<br>}else{<br>    if (b){<br>	//相同點2<br>        hello();<br>    }else{<br>        world();<br>    }<br>}</pre><p>第一步：使用 Remove braces from ‘else’ statement 將內層的 if 上提</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/656/1*FEynxNe49ETN4NVcfp86GA.png" /></figure><p>完成後如下</p><pre>if (a){<br>    //相同點1<br>    hello();<br>}else if (b) {<br>    //相同點2<br>    hello();<br>} else {<br>    world();<br>}</pre><p>第二步：使用 Merge sequential ‘if’ statements 合併條件，消除了重複的hello()。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/610/1*iQwaIZcn4so8VNmmLC3lZA.png" /></figure><pre>if (a || b) {<br>    hello();<br>} else {<br>    world();<br>}</pre><p>這種技巧特別適用於：</p><ul><li>相同邏輯被埋在不同層級的巢狀結構中</li><li>需要逐步重構來保持程式碼的可讀性</li><li>想要合併條件但目前結構不易直接合併的情況</li></ul><p><strong>條件反轉</strong></p><p>有時候反轉條件可以讓邏輯更清晰：</p><pre>// 重構前<br>if (!a) {<br>    hello();<br>} else {<br>    world();<br>}<br><br>// 重構後<br>if (a) {<br>    world();<br>} else {<br>    hello();<br>}</pre><p>重構方式：在if 執行Invert ‘if’ condition</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/566/1*H9RDUA9Wc43bb8Gl-WTdFQ.png" /></figure><h4>實際重構案例</h4><p>再回來看需求：</p><p>它的需求是這樣，這是一段提供是否有折扣價的判斷，符合的情況是：</p><ol><li>必須是過季商品(lastsessionProduct) 或 促銷商品(promotionProduct)</li><li>必須是金卡會員 或 銀卡會員</li><li>需要輸入折扣碼”SPECIAL_DISCOUNT”</li></ol><p>符合這3個條件，就會是折扣價。</p><pre>void discountPrice(boolean lastSessionProduct, MemberType memberType, boolean promotionProduct, String promoCode) {<br>    if (lastSessionProduct) {<br>        if (memberType == MemberType.SILVER) {<br>            if (promoCode.equals(&quot;SPECIAL_DISCOUNT&quot;)) {<br>                updateDiscountPrice(true);<br>            } else {<br>                updateDiscountPrice(false);<br>            }<br>        } else if (memberType == MemberType.GOLD) {<br>            if (promoCode.equals(&quot;SPECIAL_DISCOUNT&quot;)) {<br>                updateDiscountPrice(true);<br>            } else {<br>                updateDiscountPrice(false);<br>            }<br>        }else{<br>            updateDiscountPrice(false);<br>        }<br>    } else {<br>        if (memberType == MemberType.SILVER &amp;&amp; promotionProduct) {<br>            if (promoCode.equals(&quot;SPECIAL_DISCOUNT&quot;)) {<br>                updateDiscountPrice(true);<br>            } else {<br>                updateDiscountPrice(false);<br>            }<br>        } else {<br>            if (memberType == MemberType.GOLD &amp;&amp; promotionProduct ) {<br>                if (promoCode.equals(&quot;SPECIAL_DISCOUNT&quot;)) {<br>                    updateDiscountPrice(true);<br>                } else {<br>                    updateDiscountPrice(false);<br>                }<br>            }else{<br>                updateDiscountPrice(false);<br>            }<br>        }<br>    }<br>}</pre><p>我們希望重構完的程式碼應該能表達出這3條件都符合就能有折扣。</p><p>條件1：是否為過季商品 || 是否為促銷商品 <br>條件2：是否為金卡會員 || 是否為銀卡會員 <br>條件3：折扣碼是否符合</p><p><strong>提取重複邏輯</strong></p><p>首先提取重複的折扣碼檢查邏輯：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q6MVYpP3j0QYmXc8_uOJBA.png" /></figure><p>選取重覆的程式碼中的其中一段，右鍵 → Refactor → Extract Method</p><pre>if (promoCode.equals(&quot;SPECIAL_DISCOUNT&quot;)) {<br>    updateDiscountPrice(true);<br>} else {<br>    updateDiscountPrice(false);<br>}</pre><p>就可以提出一個共用的方法：checkPromoCode。</p><pre>void price(boolean lastSessionProduct, MemberType memberType, boolean promotionProduct, String promoCode) {<br>    if (lastSessionProduct) {<br>        if (memberType == MemberType.SILVER) {<br>            checkPromoCode(promoCode);<br>        } else if (memberType == MemberType.GOLD) {<br>            checkPromoCode(promoCode);<br>        }else{<br>            updateDiscountPrice(false);<br>        }<br>    } else {<br>        if (memberType == MemberType.SILVER &amp;&amp; promotionProduct) {<br>            checkPromoCode(promoCode);<br>        } else {<br>            if (memberType == MemberType.GOLD &amp;&amp; promotionProduct ) {<br>                checkPromoCode(promoCode);<br>            }else{<br>                updateDiscountPrice(false);<br>            }<br>        }<br>    }<br>}<br><br>//提出共用function<br>private void checkPromoCode(String promoCode) {<br>    if (promoCode.equals(&quot;SPECIAL_DISCOUNT&quot;)) {<br>        updateDiscountPrice(true);<br>    } else {<br>        updateDiscountPrice(false);<br>    }<br>}</pre><p>接著首先找到第1個相同點 checkPromoCode(promoCode);</p><pre>if (lastSessionProduct) {<br>    if (memberType == MemberType.SILVER) {<br>        //相同點1<br>        checkPromoCode(promoCode);<br>    } else if (memberType == MemberType.GOLD) {<br>        //相同點2<br>        checkPromoCode(promoCode);<br>    }else{<br>        updateDiscountPrice(false);<br>    }<br>}</pre><p>在相同點2上的else if ，Merge sequential ‘if’ statements</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/790/1*YhJ9nFX4k6MSAX7B_MH52Q.png" /></figure><p>完成後銀卡會員及金卡會員 就被合併為一個條件了</p><pre>if (lastSessionProduct) {<br>    //合併了金卡會員及銀卡會員<br>    if (memberType == MemberType.SILVER || memberType == MemberType.GOLD) {<br>        checkPromoCode(promoCode);<br>    } else {<br>        updateDiscountPrice(false);<br>    }<br>}</pre><p>接著在看else 裡，相同點1與2的距離太遠，無法直接合併，我們就先想辦法讓這兩個相同點的距離近一點來合併。把相同點2上的if往上移即可。</p><pre>if (lastSessionProduct) {<br>    if (memberType == MemberType.SILVER || memberType == MemberType.GOLD) {<br>        checkPromoCode(promoCode);<br>    } else {<br>        updateDiscountPrice(false);<br>    }<br>} else {<br>    //接著看這個else裡<br>    if (memberType == MemberType.SILVER &amp;&amp; promotionProduct) {<br>        //相同點1<br>        checkPromoCode(promoCode);<br>    } else {<br>        if (memberType == MemberType.GOLD &amp;&amp; promotionProduct ) {<br>            //相同點2<br>            checkPromoCode(promoCode);<br>        }else{<br>            updateDiscountPrice(false);<br>        }<br>    }<br>}</pre><p>在if上 執行Remove braces from ‘else’ statement。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/992/1*n_jOTASyYhtFm9Wr9YuggA.png" /></figure><p>就可以看到相同點1與2在鄰近if else條件了。</p><pre>if (memberType == MemberType.SILVER &amp;&amp; promotionProduct) {<br>    //相同點1<br>    checkPromoCode(promoCode);<br>} else if (memberType == MemberType.GOLD &amp;&amp; promotionProduct) {<br>    //相同點2<br>    checkPromoCode(promoCode);<br>} else {<br>    updateDiscountPrice(false);<br>}</pre><p>接著在if 裡else if 都有promotionProduct這個條件，我們可以再提出來。這是為了接下來可以把SILVER與GOLD再合併。</p><pre>if (memberType == MemberType.SILVER &amp;&amp; promotionProduct) {<br>    checkPromoCode(promoCode);<br>} else if (memberType == MemberType.GOLD &amp;&amp; promotionProduct) {<br>    checkPromoCode(promoCode);<br>} else {<br>    updateDiscountPrice(false);<br>}</pre><p>在promotionProduct 執行 Extract if (promotionProduct)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hxk0nDrZa7Q0W-NYSaFb5Q.png" /></figure><p>就可以看到promotionProduct被提到最上面了。接著處理相同點1與2。</p><pre>if (promotionProduct) {<br>    if (memberType == MemberType.SILVER) {<br>	//相同點1<br>        checkPromoCode(promoCode);<br>    } else if (memberType == MemberType.GOLD) {<br>	//相同點2<br>        checkPromoCode(promoCode);<br>    } else {<br>        updateDiscountPrice(false);<br>    }<br>} else {<br>    updateDiscountPrice(false);<br>}</pre><p>在else if 上執行Merge sequential ‘if’ statements</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/754/1*e2IMApdhCUmdl758FDLdUg.png" /></figure><p>完成後，下方程式碼同樣出現了 else 裡只有一個 if，所以我們可以再往上移。</p><pre>if (lastSessionProduct) {<br>    if (memberType == MemberType.SILVER || memberType == MemberType.GOLD) {<br>        checkPromoCode(promoCode);<br>    } else {<br>        updateDiscountPrice(false);<br>    }<br>} else {<br>    //同樣用Remove brace from &#39;if&#39; statement 把這個if 移上去else<br>    if (promotionProduct) {<br>        if (memberType == MemberType.SILVER || memberType == MemberType.GOLD) {<br>            checkPromoCode(promoCode);<br>        } else {<br>            updateDiscountPrice(false);<br>        }<br>    } else {<br>        updateDiscountPrice(false);<br>    }<br>}</pre><p>接著看到下方程式碼的兩個區塊一樣，就知道 lastSessionProduct 判斷與 promotionProduct 可以放一起了，所以在else if (promotionProduct) {這裡按 Merge sequential ‘if’ statement</p><pre>if (lastSessionProduct) {<br>    // 相同點1 (整個if else)<br>    if (memberType == MemberType.SILVER || memberType == MemberType.GOLD) {<br>        checkPromoCode(promoCode);<br>    } else {<br>        updateDiscountPrice(false);<br>    }<br>} else if (promotionProduct) {<br>    // 相同點2 (整個if else)<br>    if (memberType == MemberType.SILVER || memberType == MemberType.GOLD) {<br>        checkPromoCode(promoCode);<br>    } else {<br>        updateDiscountPrice(false);<br>    }<br>} else {<br>    updateDiscountPrice(false);<br>}</pre><p>接著下方又看到相同的 updateDiscountPrice(false); 我們要想辦法讓這兩個點靠近一點來合併</p><p>在重覆點2上面的else 按Invert ‘if’ condition，</p><pre>//上一步合併了這個if (lastSessionProduct || promotionProduct) <br>if (lastSessionProduct || promotionProduct) {<br>    if (memberType == MemberType.SILVER || memberType == MemberType.GOLD) {<br>        checkPromoCode(promoCode);<br>    } else {<br>        //相同點1<br>        updateDiscountPrice(false);<br>    }<br>} else {<br>    //相同點2<br>    updateDiscountPrice(false);<br>}</pre><p>接著我們準備把相同點1上面的else按Invert ‘if’ condition再往上移</p><pre>if (!lastSessionProduct &amp;&amp; !promotionProduct) {<br>    //相同點2<br>    updateDiscountPrice(false);<br>} else {<br>    if (memberType == MemberType.SILVER || memberType == MemberType.GOLD) {<br>        checkPromoCode(promoCode);<br>    } else {<br>	//相同點1<br>        updateDiscountPrice(false);<br>    }<br>}</pre><p>移完看到這裡就應該知道相同點1上面的if 可以再往上合併到else裡 Remove brace from ‘if’ statement.</p><pre>if (!lastSessionProduct &amp;&amp; !promotionProduct) {<br>    //相同點2<br>    updateDiscountPrice(false);<br>} else {<br>    if (memberType != MemberType.SILVER &amp;&amp; memberType != MemberType.GOLD) {<br>        //相同點1<br>        updateDiscountPrice(false);<br>    } else {<br>        checkPromoCode(promoCode);<br>    }<br>}</pre><p>移完後就可以把 if 跟else if裡再合併了，在else if 按Merge sequential ‘if’ statements</p><pre>if (!lastSessionProduct &amp;&amp; !promotionProduct) {<br>    updateDiscountPrice(false);<br>} else if (memberType != MemberType.SILVER &amp;&amp; memberType != MemberType.GOLD) {<br>    updateDiscountPrice(false);<br>} else {<br>    checkPromoCode(promoCode);<br>}</pre><p>合併完就會看到這樣，看到上面有一堆的! (not) 就知道應該在revert if 才會正常一點。</p><pre>if (!lastSessionProduct &amp;&amp; !promotionProduct || memberType != MemberType.SILVER &amp;&amp; memberType != MemberType.GOLD) {<br>    updateDiscountPrice(false);<br>} else {<br>    checkPromoCode(promoCode);<br>}</pre><p>invert 後程式碼條件式已經變的很簡化了。接著從需求面再重構一下，這裡的 lastSessionProduct 是過季商品，promotionProduct是促銷商品，兩個都是指商品。</p><p>選取lastSessionProduct || promotionProduct 再Extract variable提出為折扣商品變數，表示這兩類商品都是有折扣的。</p><pre>//重構前<br>if ((lastSessionProduct || promotionProduct) &amp;&amp; (memberType == MemberType.SILVER || memberType == MemberType.GOLD)) <br>    checkPromoCode(promoCode);<br>} else {<br>    updateDiscountPrice(false);<br>}</pre><p>重構後符合了我們的需求條件1：是否為過季商品 || 是否為促銷商品。</p><pre>// 條件1：是否為過季商品 || 是否為促銷商品<br>boolean discountProduct = lastSessionProduct || promotionProduct;<br><br>//這裡的 MemberType.SILVER || MemberType.GOLD 也可提出<br>if (discountProduct &amp;&amp; (memberType == MemberType.SILVER || memberType == MemberType.GOLD)) {<br>    checkPromoCode(promoCode);<br>} else {<br>    updateDiscountPrice(false);<br>}</pre><p>接著把會員也可以Extract variable。提出後vip表示是金卡會員或銀卡會員。</p><p>接著這裡還有個較奇怪的地方是checkPromoCode這個在最早我們就提出的方法，這時候可以再inline回來處理。</p><pre>// 條件1：是否為過季商品 || 是否為促銷商品<br>boolean discountProduct = lastSessionProduct || promotionProduct;<br>// 條件2：是否為金卡會員 || 是否為銀卡會員<br>boolean vip = memberType == MemberType.SILVER || memberType == MemberType.GOLD;<br><br>if (discountProduct &amp;&amp; vip) {<br>  //在這裡右鍵 -&gt; Refactor -&gt; Inline method<br>    checkPromoCode(promoCode);<br>} else {<br>    updateDiscountPrice(false);<br>}</pre><p>Inline後可以看到原本提出的方法被收回來了。我們又看到了同樣的結構，有著重複程式碼。</p><pre>boolean discountProduct = lastSessionProduct || promotionProduct;<br>boolean vip = memberType == MemberType.SILVER || memberType == MemberType.GOLD;<br><br>if (discountProduct &amp;&amp; vip) {<br>    if (promoCode.equals(&quot;SPECIAL_DISCOUNT&quot;)) {<br>        updateDiscountPrice(true);<br>    } else {<br>        updateDiscountPrice(false);<br>    }<br>} else {<br>    updateDiscountPrice(false);<br>}</pre><p>同樣步驟重構：</p><pre>if (discountProduct &amp;&amp; vip &amp;&amp; promoCode.equals(&quot;SPECIAL_DISCOUNT&quot;)) {<br>    updateDiscountPrice(true);<br>} else {<br>    updateDiscountPrice(false);<br>}</pre><p>接著選取promoCode.equals(“SPECIAL_DISCOUNT”)，extract variable再提出。</p><p>重構後的程式碼：</p><pre>// 條件1：是否為過季商品 || 是否為促銷商品<br>boolean discountProduct = lastSessionProduct || promotionProduct;<br>// 條件2：是否為金卡會員 || 是否為銀卡會員<br>boolean vip = memberType == MemberType.SILVER || memberType == MemberType.GOLD;<br>// 條件3：折扣碼是否符合<br>boolean validCoupon = promoCode.equals(&quot;SPECIAL_DISCOUNT&quot;);<br><br>//符合3個條件<br>if (discountProduct &amp;&amp; vip &amp;&amp; validCoupon) {<br>    updateDiscountPrice(true);<br>} else {<br>    updateDiscountPrice(false);<br>}</pre><p>這樣就完成了重構，我們改善了：</p><ul><li>減少了巢狀層級</li><li>商業邏輯更清晰，直接對應需求的三個條件</li><li>變數命名具有商業意義，提高可讀性。</li></ul><p>保持以下幾個重構原則：</p><ul><li>漸進式修改</li><li>充分利用IDE工具</li><li>注重商業邏輯的表達</li><li>重視命名的商業含義</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ded4c1378cad" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>