學習一下 SpringCloud （一）-- 從單體架構到微服務架構、代碼拆分（maven 聚合）

本文轉載自查看原文 2020-12-08 21:09 2889 SpringCloud

一、架構演變

1、系統架構、集群、分布式系統簡單理解

（1）什么是系統架構？

【什么是系統架構？】
    系統架構 描述了 在應用程序內部，如何根據 業務、技術、靈活性、可擴展性、可維護性 等因素，將系統划分成不同的部分並使這些部分相互分工、協作，從而提高系統的性能。
    
【簡單的理解：】
    系統架構是 程序運行 的基石、其決定了程序是否能正確、有效的構建 以及 穩定的運行。

（2）集群

【什么是集群？】
    計算機集群簡稱集群，是一種計算機系統，它通過一組松散集成的計算機軟件或硬件連接起來、高度緊密地協作完成計算工作。
    在某種意義上，他們可以被看作是一台計算機。
    集群系統中的單個計算機通常稱為節點，通常通過局域網連接（或者其它的連接方式）。
    集群計算機通常用來改進單個計算機的計算速度或可靠性。

【簡單的理解：】
    通過多台計算機完成同一個工作，達到更高的效率。
    兩機或多機內容、工作過程等完全一樣。如果一台死機，另一台可以起作用。
    同一個業務，部署在多個服務器上(不同的服務器運行同樣的代碼，干同一件事)。

（3）分布式系統

【什么是分布式系統？】
    分布式系統是一組計算機，通過網絡相互連接，傳遞消息與通信后，協調它們的行為而形成的系統。
    組件之間彼此進行交互從而實現一個共同的目標。

【簡單的理解：】
    通過多台計算機相互作用完成一個工作，每個計算機負責一個功能模塊，將多個計算機組合起來從而完成一個大任務。
    一個業務拆分為多個子業務，部署在不同的服務器上(不同的服務器，運行不同的代碼，為了同一個目的)。
注：
    分布式與集群不沖突，可以存在分布式集群，即將一個項目拆分為不同的功能模塊后，對各個不同的功能模塊實現集群。

（4）架構演變
　　Dubbo 官網將系統架構分為單體架構、垂直架構、分布式服務架構、流計算架構。
　　可參考：http://dubbo.apache.org/docs/v2.7/user/preface/background/
注：
　　下面的系統演變過程以此為基礎進行展開，有不對的地方還望不吝賜教。

2、系統架構需要考慮的因素（高可用、高並發、高性能）

（1）高可用性（High Availability）

【高可用性：】
    高可用性 指的是 盡量縮短 維護操作（計划內）以及 系統故障（非計划內）而導致的停機時間，從而保證 系統 正常運行。
    高可用性 具有高度 的容錯性、恢復性。
注：
    容錯性 指的是 軟件發生故障時 仍能正常運行的 能力。
    恢復性 指的是 軟件發生故障時 恢復到故障之前狀態的 能力。

（2）高並發（High Concurrency）

【高並發性：】
    高並發性 指的是 保證系統能夠同時並行處理 很多請求。
    通過 水平拓展 或者 垂直拓展的方式 可以提高系統高並發能力。
 
【垂直拓展：】
    垂直拓展，提高當前系統的能力 以適應 需求。
又可分為兩種：
    1、提升硬件能力，強化 服務器硬件，比如：機械硬盤 更換為 固態硬盤，增加 CPU 核數、拓展系統內存 等。
    2、提升軟件能力，優化 軟件性能，比如：使用緩存 減少磁盤 I/O 次數，優化代碼使用的數據結構 從而減少響應時間等。
注：
    單機性能提升還是有限的，成本充足情況下，增加服務器的使用還是比較合適的。
 
【水平拓展：】
    水平拓展，也即 橫向拓展，增加系統個數 以適應 需求，只需要增加服務器 的數量，就可以線性的增加系統的並發能力。
    當然也不能一直增加服務器，服務器數量增多，維護、成本的壓力也就上來了。
              
【高並發相關指標：】
    響應時間（Response Time）：指的是 系統對 用戶輸入或者請求 進行處理並響應請求的時間。
    吞吐量（Throughput）：指的是 系統單位時間內 處理請求的數量（吞吐量一般與響應時間成反比，即吞吐量越大，響應時間越短）。
    每秒查詢率（Query Per Second，QPS）：指的是 系統 每秒響應的請求數。
    並發用戶數：指的是 系統 某時刻支持 正常使用系統的用戶數。

（3）高性能（High Performance）

【高性能：】
    高性能 指的是 程序處理速度快、占用內存少、CPU 占用率低。
    也即系統性能強悍、運算能力強、響應時間短。

3、架構演變 -- 單體應用架構（傳統架構、三層架構、集群）

（1）傳統架構

【背景：】
    互聯網開發早期，所有的 業務、功能模塊 代碼都寫在一個項目中，然后 編譯、打包並部署到容器（比如：Tomcat）中運行。
    此時稱為 All in One，即 所有模塊代碼均寫在一起（比如：Servlet、JSP 等代碼）、技術上不分層。

【優點：】
    所有功能均在同一個應用程序中，所以只需要部署 一個應用程序即可，減少了 部署節點、以及成本。

【缺點（出現的問題）：】
    代碼可維護性差（所有代碼均寫在一個項目中，沒有層次，相互調用復雜，不易修改）。
    容錯性差（代碼寫在 JSP 中，發生錯誤時 服務器可能直接宕機 且 用戶可以直接看到 錯誤信息）。
    並發量小。

（2）三層架構

【背景：】
    為了解決 傳統架構 可維護性差、容錯性差、並發量小 等問題，引入了 分層的概念。
    分層 即 將代碼 划分出 幾個層級，每個層級 干不同的事，從而提高代碼的可維護性。

那么如何分層呢？分幾層呢？
    在開發早期，所有的邏輯代碼沒有明顯的區分，代碼間相互調用、職責不清，頁面邏輯、業務邏輯、數據庫訪問邏輯 等混合在一起，即一層架構，此時的代碼維護、迭代工作肯定無比麻煩。
    隨着時代的發展，數據庫訪問邏輯 被逐步的划分出來，但頁面邏輯、業務邏輯 仍然混合在一起，即二層架構，此時簡化了數據訪問的操作，提高了系統的可維護性。
    繼續發展，從功能、代碼組織的角度進行划分，將三種邏輯分開，也即三層架構出現。

【三層架構（MVC）：】
從功能、代碼組織的角度出發，按系統不同職責進行划分成三個層次：
    表示層：關注 數據顯示 以及 用戶交互。
    業務邏輯層：關注 業務邏輯處理。
    數據訪問層：關注 數據的存儲與訪問。   
注：
    此處的三層架構並非 物理分層，而是邏輯上的分層（所有代碼仍然在一個項目中進行 開發、編譯、部署，仍是單體架構）。

【優點：】
    提高了可維護性。每一層的功能具體化，解決了系統間 相互調用復雜、職責不清的問題，有效降低了層與層間的依賴關系，降低了維護、迭代的成本。
    MVC 分層開發，提高了系統的容錯性。
    服務器分離部署。數據庫 以及 應用程序 可以部署在 不同的服務器 上。 
   
【缺點（出現的問題）：】
    並發量仍然不高（隨着用戶訪問量增加，單台應用服務器無法滿足需求）。

（3）集群

【背景：】
    為了解決 三層架構 的並發量問題，引入了 集群的概念。
    單台服務器不能滿足需求，那么就使用 多台 服務器構成 集群 提供服務。
    
【優點：】
    使用 多台服務器 構成集群 同時提供服務，提高了並發量。
    提高了容錯性（一台服務器掛了，還有其他服務器可以提供服務，保證程序的正常運行）。

【缺點（出現的問題）：】
    用戶的請求 發送給 哪台服務器？
    如何保證請求可以 平均的發送給 各個服務器？
    數據如何進行共享、緩存？
    數據需要模糊查詢時，如何提高數據庫查詢效率？
    數據庫訪問壓力如何解決？
    數據量過大時，應該如何存儲？
    
【解決：】
    可以通過 Nginx 解決 請求的發送 以及 分發（負載均衡） 問題。
    可以通過 Redis 解決 數據共享 以及 緩存 問題。
    可以通過 ElacticSearch 解決 數據搜索 問題。
    可以通過 MyCat 使用主從復制、讀寫分離，減輕數據庫壓力，通過分庫分表 的方式，按照指定的方式存儲數據。

（4）解決集群出現的問題

【問題一：】
    用戶 登錄並訪問 服務器時，會產生一個 session，且伴隨着用戶訪問的全過程 直至 用戶關閉瀏覽器結束此次訪問。
    當一個服務器突然宕機，若不對 session 進行處理，那么其 session 必定丟失，也即 用戶需要重新 進行登錄等 一系列操作，用戶體驗感將極差。
    
    那么 session 如何共享？也即 數據共享問題？    

【解決：】
方式一：
    使用 Tomcat 廣播 session，從而實現 session 共享。
    每個 tomcat 會在局域網中廣播自己的 session 信息並監聽其他 tomcat 廣播的 session 信息，一旦 session 發生變化，其他的 tomcat 就能監聽並同步 session。
注：
    此方式只適用於 並發量小的 小項目。
    並發量大時，比如用戶量為 1000 萬，那每個服務器都需要廣播、維護 session，那么將會導致服務器大量資源都用來處理 session，這樣肯定不適合大型項目。
    
方式二：
    使用 Redis 存儲 session，從而實現 session 共享。
    使用 Redis 存儲 session，當服務器需要使用 session 時，直接從 Redis 中獲取，這樣只需要關心 Redis 的維護即可，減輕了 服務器的壓力。
    同時，Redis 還可以用來進行 數據緩存，減少數據庫訪問次數（提高響應時間）。 
注：
    此方式適合於 大型的項目。
    SpringBoot 整合 Redis 可參考：https://www.cnblogs.com/l-y-h/p/13163653.html#_label0

【問題二：】
    使用集群，即存在多個服務器，一個用戶請求 肯定會被某一個服務器進行處理，此時就需要考慮 服務器 處理請求的問題了。
    
    那么 用戶的請求 發送給 哪台服務器處理？如何保證請求可以 平均的發送給 集群中的各個服務器？
    
【解決：】
    可以通過 Nginx 解決 請求的發送 以及 分發（負載均衡） 問題。
注：
    Nginx 反向代理、負載均衡等基本概念可參考：https://www.cnblogs.com/l-y-h/p/12844824.html#_label0

【問題三：】
    通過上面介紹的 Nginx + Redis 的方式，提高了應用層的性能。
    應用層問題解決了，數據庫的訪問壓力怎么解決？如何提高數據庫的負載能力？數據庫數據量大時如何存儲？
    
【解決：】
    采用讀寫分離、主從復制的方式，提高數據庫負載能力。
    采用 master-slave 方式，master 負責 進行增刪改 等寫操作，slave 進行 讀操作，並通過主從復制的方式 將 master 數據同步到 slave 中。
    設置多個 slave，從而提高數據庫查詢、負載能力。
    
    采用分庫分表的方式，進行數據存儲。
注：
    垂直拆分數據表：根據常用字段 以及 不常用字段 將數據表划分為多個表，從而減少單個表的數據大小。
    水平拆分數據表：根據時間、地區 或者 業務邏輯進行拆分。
    垂直拆分仍有局限性，水平拆分便於業務拓展。

【問題四：】
    雖然進行了讀寫分離，數據量過大時，執行 模糊查詢 的效率低。對於大型的網站（電商等），搜索是其核心模塊，若一個查詢執行半天才能返回結果，那么用戶體驗將是極差的。
    
    那么如何提高查詢的效率？
    
【解決：】
    使用 搜索引擎技術，比如：ElacticSearch、solr。

（5）單體架構總結

【單體架構：】
    單體架構，就是將所有 業務、功能模塊 都寫在一個項目中，編譯、打包並部署到容器（比如：Tomcat）中運行。
    應用程序、數據庫 可以分開部署，可以通過部署 應用程序集群、數據庫集群 的方式提高系統性能。
    能簡化 增刪改查 工作的 數據訪問框架（ORM） 也是提高系統性能的關鍵。
注：
    隨着業務擴大、需求增加，單體架構將會變得臃腫、耦合性高，可維護性、可擴展性、靈活性都在逐步降低，
    難以滿足業務快速迭代的需求，且成本不斷攀升，單體架構的時代已成為過去。
    
【優點：】
    開發、測試、部署簡單，維護成本低。適用於 用戶、數據 規模小的 項目。
    通過拓展集群的方式 可以保證 高並發、高可用。

【缺點：】
    可維護性、可拓展性差。（隨着業務增加、功能迭代，代碼會變得臃腫、耦合）
    技術棧受限，且只能通過 拓展集群 的方式提高系統性能（維護成本高）。
    協同開發不方便（存在修改相同業務代碼的情況、導致沖突）。

4、架構演變 -- 垂直應用架構（水平拆分、垂直拆分）

（1）背景

　　上面介紹的單體架構已不能滿足實際場景（拓展能力有限、代碼臃腫），那么需要進行代碼重構，對單體架構代碼進行拆分，那么如何進行拆分能保證高可用、高並發、高性能呢？
　　前面也提到了高並發可以通過垂直拓展、水平拓展來實現，此處不妨也對單體架構的代碼進行水平拆分以及垂直拆分。

注：
　　拓展與拆分是兩種概念。拓展是對外部改造，拆分是對內部改造。

　　　　垂直拓展：增加服務器硬件性能，提高服務器執行應用的能力。
　　　　水平拓展：增加服務器數量，多節點部署應用。

　　　　垂直拆分：根據業務對系統進行划分。
　　　　水平拆分：根據邏輯分層對系統進行划分（比如：前后端分離、MVC 分層）。

（2）水平拆分
　　水平拆分根據邏輯分層對系統進行划分，將一個大的單體應用程序拆分成多個小應用程序，每個小應用程序作為單獨的 jar 包，需要使用時，引入相關 jar 包即可。

【單體應用舉例：】
    現有一個 SSM 單體應用，如何進行水平拆分？
    
【水平拆分思路：】
    按照邏輯分層對代碼進行拆分，將 controller、service、dao 層分別抽取出來，並打成 jar 包，需要使用時 直接引入 jar 包即可。
    
【使用 Maven 聚合的方式可以演示：】
Step1：構建一個 ssm_parent 工程（父工程，聚合下面的子工程，pom）
Step2：構建一個 ssm_bean 工程（子工程，存放 實體類，jar）
Step3：構建一個 ssm_mapper 工程（子工程，存放持久層類以及接口，jar）
Step4：構建一個 ssm_service 工程（子工程，存放 業務邏輯層類以及接口，jar）
Step5：構建一個 ssm_controller 工程（子工程，存放 控制層類，war）

也即目錄結構如下：
ssm_parent（pom）
    ssm_bean（jar）  或者 ssm_pojo  名稱隨意取，見名知意 即可。
    ssm_mapper（jar） 或者 ssm_dao
    ssm_service（jar）
    ssm_controller（war） 或者 ssm_web
注：
    ssm_mapper 需要引入 ssm_bean.jar。
    ssm_service 需要引入 ssm_mapper.jar。
    ssm_controller 需要引入 ssm_service.jar。
    可以通過 ssm_controller 或者 ssm_parent 啟動項目。
    
【水平拆分優點：】
    模塊可以復用，減少代碼冗余度。
    代碼分離部署，可以根據實際情況，增加 或者 減少 某些業務層的部署量。（比如：dao 層訪問量過大，可以多部署幾個 dao 服務減輕壓力。單體應用則是整體部署，增大了服務器部署容量。）
    
【水平拆分缺點：】
    各個模塊業務仍然交互在一起，修改某個模塊業務時，整個 jar 包（非修改模塊）需要重新 測試 、部署，增加了 測試 與 維護 的壓力。

（3）垂直拆分：
　　垂直拆分是根據業務對系統進行划分，將一個大的單體應用程序拆分成若干個互不相干的小應用程序（也即垂直應用架構）。

　　每個小應用程序就是一個單獨的 web 項目。

【單體應用舉例：】
    現有一個 SSM 單體應用，如何進行垂直拆分？
    
【垂直拆分思路：】
    按照業務對代碼進行拆分，比如：現在 SSM 中存在 后台管理業務、用戶業務、菜單業務 等。
    則將 這些業務 分別抽取出來，各自構成 web 工程。
    
【使用 Maven 聚合的方式可以演示：】
Step1：構建一個 ssm_parent 工程（父工程，聚合下面的子模塊，pom）
Step2：構建一個 ssm_admin 模塊（子模塊，后台管理模塊）
Step3：構建一個 ssm_user 模塊（子模塊，用戶模塊）
Step4：構建一個 ssm_menu 模塊（子模塊，菜單模塊） 

也即目錄結構如下：
ssm_parent（pom）
    ssm_admin 
    ssm_user 
    ssm_menu 

【垂直拆分優點：】
    提高了可維護性（需求變更時，修改對應的模塊即可）。
    提高了可拓展性（拓展業務時，增加新的模塊即可，可以針對訪問量 增大、減少 某個模塊的部署量）。
    提高了協同開發能力（不同的團隊可以開發 不同的模塊）。
    
【垂直拆分缺點：】
    某個模塊修改時（比如：頁面頻繁更換），需要對整個模塊進行重新部署，增大了維護的難度。
    隨着業務模塊增加，各模塊間必然需要進行業務交互，模塊交互問題又是一個頭疼的問題。

（4）垂直應用架構總結

【垂直應用架構：】
    垂直應用架構，按照業務將原來的 大單體應用 拆分成 若干個互不想干的 小單體應用。
    用於加速前端頁面開發的 web 框架（MVC）也是提高開發效率的關鍵。
    
【優點：】
    系統間相互獨立，極大地解決了 耦合問題。
    可以針對不同的業務進行 優化、可以針對不同的業務搭建集群。

【缺點：】
    使用集群時，負載均衡相對而言比較復雜，且拓展成本高、有瓶頸。
    隨着功能增加，模塊隨之增多，一些通用的服務、模塊也會增多，代碼冗余。
    隨着業務增加，應用之間難免會進行 數據交互，若某個應用端口、IP 變更，需要手動進行代碼更改（增加維護成本）。

5、架構演變 -- 分布式服務架構、SOA 架構、微服務架構

（1）分布式服務架構
　　隨着垂直應用架構模塊增多，模塊之間的交互不可避免，為了解決這個問題，引出了分布式服務架構，將核心業務抽取出來並獨立部署，各服務之間通過遠程調用框架（PRC）進行通信。

【分布式服務架構：】
    分布式服務架構，按照業務 拆分成不同的子業務，並獨立部署在不同的服務器上。

【垂直應用架構問題一：】
    客戶對頁面要求變化大，每次修改后，都需要對應用重新部署，是比較麻煩的事情。
    
【解決：】
    采用 前后端分離開發，將 界面 與 業務邏輯分開（水平拆分），此時只需關心界面的修改即可。
    
【垂直應用架構問題二：】
    隨着業務模塊增加，各個模塊必然會進行交互，如何交互？業務部署在不同服務器上，該如何交互？
    
【解決：】
   采用 RPC/HTTP/HttpClient 框架進行遠程服務調用。
   
【分布式架構問題：】
    新架構的改變必然帶來新的技術問題。比如： 分布式事務、分布式鎖、分布式日志管理 等。
    隨之而來的就是 分布式服務治理中間件： Dubbo（RPC） 以及 SpringCloud（HTTP）。

（2）SOA 架構
　　隨着服務的增多，若不對服務進行管理，那么容易導致服務資源浪費（比如：用戶模塊訪問量大只部署了 10 台服務器，而菜單模塊訪問量小，卻部署了 20 台服務器）、且服務間調用混亂（100 個服務相互調用若沒有條理，那將是一件非常頭疼的事情）。
　　為了提高機器利用率並對服務進行管理，引出了 SOA 的概念。

注：

　　此處只是簡單的介紹了下概念，詳情請自行谷歌、百度了解（有時間再詳細研究研究）。

【SOA：】
    SOA 是 Service-Oriented Architecture 的簡寫，即 面向服務架構。
    指的是 根據實際業務，將系統拆分成合適的、獨立部署的服務，各服務相互獨立，通過 調用中心 完成 各服務之間的 調用 以及 管理。

【缺點：】
    依賴於 中心化服務發現機制。
    SOA 采用 SOAP 協議（HTTP + XML），而 XML 報文存在大量冗余數據，影響傳輸效率。

（3）微服務
　　微服務是基於 SOA 架構演變而來，去除了 SOA 架構中 ESB 消息總線，采用 HTTP + JSON（RESTful ）進行傳輸。其划分粒度比 SOA 更精細。

【微服務架構：】
    微服務架構 指的是 將單個應用程序 划分為 若干個互不相干的小應用，每個小應用都是一個服務，服務之間相互協調、配合，從而為用戶提供最終價值。
    每個服務運行在獨立的進程中，服務之間通常采用 輕量級的通信機制（通常是基於 HTTP 的 RESTful API）,每個服務均是基於 具體業務進行構建，並可以獨立的 部署到生產環境中。
    
【本質：】
    微服務的目的是有效的拆分應用（將功能分散到各個服務中，降低系統耦合度），實現敏捷開發 與 部署。
    微服務關鍵點在於 系統要提供一套基礎的架構，使得微服務可以獨立部署、運行、升級，且各個服務 在結構 上松耦合，在功能上為一個統一的整體。
注：
    統一指的是：統一的安全策略、統一的權限管理、統一的日志處理 等。
    
【優點：】
    微服務每個模塊就等同於一個獨立的項目，可以使用不同的開發技術，使開發模式更靈活。
    每個模塊都有獨立的數據庫，可以選擇不同的存儲方式。比如：redis、mysql。
    微服務的拆分粒度 比 SOA 更精細，復用性更強（提高開發效率）。

【缺點：】
    微服務過多，服務的管理成本將隨之提高。
    技術要求變高（分布式事務、分布式鎖、分布式日志、SpringCloud、Dubbo 等一系列知識都需要學習）。

6、什么是 SpringCloud？

（1）相關地址：

【SpringCloud 官網地址：】
    https://spring.io/projects/spring-cloud

【SpringCloud 中文文檔：】
    https://www.bookstack.cn/read/spring-cloud-docs/docs-index.md

（2）基本認識
　　Spring Cloud 是分布式微服務架構下的一站式解決方案，是各個微服務架構技術實現的集合體。
注：
　　Spring Boot 可以快速構建單個微服務。
　　Spring Cloud 將多個 Spring Boot 構建的微服務整合並管理起來，並提供一系列處理（比如：服務發現、配置管理、消息總線、負載均衡、斷路器、數據監控等）。

7、微服務問題以及技術實現

（1）背景
　　SpringCloud 是解決微服務架構而存在的，其針對微服務架構一系列技術問題都做出了相關實現，當然隨着技術的進步，有些技術已經停止更新、維護了，逐步被新技術替代（學無止境）。
　　此處從整體上了解一下 SpringCloud 有哪些技術，后續再逐步深入。

（2）微服務問題

【微服務相關問題：】
    服務注冊與發現、服務配置中心
    服務調用、服務負載均衡
    服務網關
    服務熔斷、服務降級
    服務總線
    ...

（3）技術實現

【技術實現：】
    服務注冊與發現：
        Eureka     停止維護了，不推薦使用。
        ZooKeeper
        Consul
        Nacos      阿里開源的產品，推薦使用
        
    服務配置中心：
        Config
        Nacos      推薦使用
        
    服務調用、負載均衡:
         Ribbon        停止更新了（維護狀態），不推薦使用。
        Loadbalancer  作為 Ribbon 的替代產品。
        Feign          停止更新了（維護狀態），不推薦使用
        OpenFeign      Spring 推出的 Feign 的替代產品（推薦使用）。

    服務網關：
        Zuul          停止維護了，不推薦使用。
        Zuul2         還沒出來（已經涼涼了）。
        Gateway       Spring 推出的替代產品（推薦使用）。 
        
    服務降級：
        Hystrix       停止維護了，不推薦使用。
        Resilience4j  替代產品，國外使用多。
        Sentienl      替代產品，國內使用多（推薦使用）。
        
    服務總線：
        Bus
        Nacos          推薦使用。
    
注：
    Nacos 功能還是比較強大的（可以替換多個組件），重點關注。
    各個組件具體功能后續介紹，此處暫時略過。。。

（4）SpringCloud 版本選擇
　　進入官網，可以查看到當前最新版本的 SpringCloud。

　　SpringCloud 是基於 SpringBoot 開發的，其歷史版本與 SpringBoot 對應版本如下。

當然，還是需要進入不同版本的 SpringCloud （Reference Doc.）查看官方推薦配置。

二、代碼拆分演示（maven 聚合）

1、構建普通的 web 項目

（1）基本說明

【項目基本說明：】
    此項目僅供參考，不與數據庫進行交互。
    創建 ControllerA、ServiceA 表示業務 A。
    創建 ControllerB、ServiceB 表示業務 B。   

使用 IDEA 利用 maven 構建 SSM 項目 可參考：
    https://www.cnblogs.com/l-y-h/p/12030104.html
    或者 https://www.cnblogs.com/l-y-h/p/14010034.html#_label0_3

（2）使用 IDEA 利用 maven 構建一個普通的 web 工程
　　可參考：https://www.cnblogs.com/l-y-h/p/11454933.html
Step1：創建一個 web 工程（選擇 maven-archetype-webapp 模板，會自動生成 webapp 文件夾）

Step2：引入依賴（Spring MVC）

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>5.2.8.RELEASE</version>
</dependency>

【pom.xml（注意：<packaging>war</packaging> 是 war、非 pom）】
<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>ssm</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>ssm Maven Webapp</name>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.8.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

Step3：配置基本 web 環境（Spring、SpringMVC）

【web.xml】
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">

  <!-- step1: 配置全局的參數，啟動Spring容器 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <!-- 若沒有提供值，默認會去找/WEB-INF/applicationContext.xml。 -->
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <!-- step2: 配置SpringMVC的前端控制器，用於攔截所有的請求  -->
  <servlet>
    <servlet-name>springmvcDispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <init-param>
      <param-name>contextConfigLocation</param-name>
      <!-- 若沒有提供值，默認會去找WEB-INF/*-servlet.xml。 -->
      <param-value>classpath:dispatcher-servlet.xml</param-value>
    </init-param>
    <!-- 啟動優先級，數值越小優先級越大 -->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvcDispatcherServlet</servlet-name>
    <!-- 將DispatcherServlet請求映射配置為"/"，則Spring MVC將捕獲Web容器所有的請求，包括靜態資源的請求 -->
    <url-pattern>/</url-pattern>
  </servlet-mapping>

  <!-- step3: characterEncodingFilter字符編碼過濾器，放在所有過濾器的前面 -->
  <filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <!--要使用的字符集，一般我們使用UTF-8(保險起見UTF-8最好)-->
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
      <!--是否強制設置request的編碼為encoding，默認false，不建議更改-->
      <param-name>forceRequestEncoding</param-name>
      <param-value>false</param-value>
    </init-param>
    <init-param>
      <!--是否強制設置response的編碼為encoding，建議設置為true-->
      <param-name>forceResponseEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <!--這里不能留空或者直接寫 ' / ' ，否則可能不起作用-->
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- step4: 配置過濾器，將post請求轉為delete，put -->
  <filter>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
</web-app>

【applicationContext.xml】
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
       http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

    <!-- step1: 配置包掃描方式。掃描所有包，但是排除Controller層 -->
    <context:component-scan base-package="com.lyh.ssm">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
</beans>

【dispatcher-servlet.xml】
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- step1: 配置Controller掃描方式 -->
    <!-- 使用組件掃描的方式可以一次掃描多個Controller,只需指定包路徑即可 -->
    <context:component-scan base-package="com.lyh.ssm" use-default-filters="false">
        <!-- 一般在SpringMVC的配置里，只掃描Controller層，Spring配置中掃描所有包，但是排除Controller層。
        context:include-filter要注意，如果base-package掃描的不是最終包，那么其他包還是會掃描、加載，如果在SpringMVC的配置中這么做，會導致Spring不能處理事務，
        所以此時需要在<context:component-scan>標簽上，增加use-default-filters="false"，就是真的只掃描context:include-filter包括的內容-->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" />
    </context:component-scan>

    <!-- step2: 配置視圖解析器 -->
    <bean id="defaultViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/"/><!--設置JSP文件的目錄位置-->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- step3: 標准配置 -->
    <!-- 將springmvc不能處理的請求交給 spring 容器處理 -->
    <mvc:default-servlet-handler/>
    <!-- 簡化注解配置，並提供更高級的功能 -->
    <mvc:annotation-driven />
</beans>

Step4：編寫基本業務代碼。

【ControllerA】
package com.lyh.ssm.controller;

import com.lyh.ssm.service.ServiceA;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ControllerA {
    @Autowired
    private ServiceA serviceA;

    @GetMapping("/testA")
    public String testContollerA() {
        return serviceA.testA();
    }
}

【ControllerB】
package com.lyh.ssm.controller;

import com.lyh.ssm.service.ServiceB;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ControllerB {
    @Autowired
    private ServiceB serviceB;

    @GetMapping("/testB")
    public String testControllerB() {
        return serviceB.testB();
    }
}

【ServiceA】
package com.lyh.ssm.service;

import org.springframework.stereotype.Service;

@Service
public class ServiceA {
    public String testA() {
        return "test serviceA";
    }
}

【ServiceB】
package com.lyh.ssm.service;

import org.springframework.stereotype.Service;

@Service
public class ServiceB {
    public String testB() {
        return "test serviceB";
    }
}

Step5：配置、啟動 tomcat。

Step6：訪問 testA()、testB()。正常訪問也即基本 web 工程已搭建完成。

2、水平拆分 web 項目

（1）基本說明

【水平拆分說明：】
    將上面簡單的 web 工程 做水平拆分，按照邏輯分層對代碼進行拆分，
    將 controller、service 層分別抽取出來，並做成 war 包或者 jar 包，需要時引入依賴即可。
    
【使用 Maven 聚合的方式可以演示：】
Step1：構建一個 ssm_parent 工程（父工程，聚合下面的子工程，pom）
Step2：構建一個 ssm_service 工程（子工程，存放 業務邏輯層類以及接口，jar）
Step3：構建一個 ssm_controller 工程（子工程，存放 控制層類，war）

也即目錄結構如下：
ssm_parent（pom）
    ssm_service（jar）
    ssm_controller（war）

（2）使用 maven 聚合的方式進行水平拆分
Step1：使用 maven 創建一個父工程（maven-archetype-site-simple）。
　　刪除 src 文件夾（無用文件夾），選擇 maven-archetype-site-simple 目的是使 pom.xml 中 packaging 為 <packaging>pom</packaging>。
注：
　　模板隨意選擇，選擇 maven-archetype-quickstart 亦可，保證 <packaging>pom</packaging>。

Step2：在 ssm_parent 上右鍵選擇創建 Module。
　　並使用 maven 模板（maven-archetype-quickstart）創建一個模塊（ssm_service）。

Step3：將普通 web 工程中 service 代碼抽取出來，並放入 ssm_service 中。

【ServiceA】
package com.lyh.ssm.service;

import org.springframework.stereotype.Service;

@Service
public class ServiceA {
    public String testA() {
        return "test serviceA";
    }
}

【ServiceB】
package com.lyh.ssm.service;

import org.springframework.stereotype.Service;

@Service
public class ServiceB {
    public String testB() {
        return "test serviceB";
    }
}

Step4：在父工程（ssm_parent）或者當前工程（ssm_service）中引入 SpringMVC 依賴包。

【SpringMVC 依賴:】
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>5.2.8.RELEASE</version>
</dependency>

Step5：在 ssm_parent 上右鍵選擇創建 Module。
　　並使用 maven 模板（maven-archetype-webapp）創建一個模塊（ssm_controller）。

Step6：將普通 web 工程中相關代碼（controller、配置文件）抽取出來，放入 ssm_controller 中。

【ControllerA】
package com.lyh.ssm.controller;

import com.lyh.ssm.service.ServiceA;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ControllerA {
    @Autowired
    private ServiceA serviceA;

    @GetMapping("/testA")
    public String testContollerA() {
        return serviceA.testA();
    }
}

【ControllerB】
package com.lyh.ssm.controller;

import com.lyh.ssm.service.ServiceB;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ControllerB {
    @Autowired
    private ServiceB serviceB;

    @GetMapping("/testB")
    public String testControllerB() {
        return serviceB.testB();
    }
}

【applicationContext.xml】
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
       http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

    <!-- step1: 配置包掃描方式。掃描所有包，但是排除Controller層 -->
    <context:component-scan base-package="com.lyh.ssm">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
</beans>

【dispatcher-servlet.xml】
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- step1: 配置Controller掃描方式 -->
    <!-- 使用組件掃描的方式可以一次掃描多個Controller,只需指定包路徑即可 -->
    <context:component-scan base-package="com.lyh.ssm" use-default-filters="false">
        <!-- 一般在SpringMVC的配置里，只掃描Controller層，Spring配置中掃描所有包，但是排除Controller層。
        context:include-filter要注意，如果base-package掃描的不是最終包，那么其他包還是會掃描、加載，如果在SpringMVC的配置中這么做，會導致Spring不能處理事務，
        所以此時需要在<context:component-scan>標簽上，增加use-default-filters="false"，就是真的只掃描context:include-filter包括的內容-->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" />
    </context:component-scan>

    <!-- step2: 配置視圖解析器 -->
    <bean id="defaultViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/"/><!--設置JSP文件的目錄位置-->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- step3: 標准配置 -->
    <!-- 將springmvc不能處理的請求交給 spring 容器處理 -->
    <mvc:default-servlet-handler/>
    <!-- 簡化注解配置，並提供更高級的功能 -->
    <mvc:annotation-driven />
</beans>

【web.xml】
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">

  <!-- step1: 配置全局的參數，啟動Spring容器 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <!-- 若沒有提供值，默認會去找/WEB-INF/applicationContext.xml。 -->
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <!-- step2: 配置SpringMVC的前端控制器，用於攔截所有的請求  -->
  <servlet>
    <servlet-name>springmvcDispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <init-param>
      <param-name>contextConfigLocation</param-name>
      <!-- 若沒有提供值，默認會去找WEB-INF/*-servlet.xml。 -->
      <param-value>classpath:dispatcher-servlet.xml</param-value>
    </init-param>
    <!-- 啟動優先級，數值越小優先級越大 -->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvcDispatcherServlet</servlet-name>
    <!-- 將DispatcherServlet請求映射配置為"/"，則Spring MVC將捕獲Web容器所有的請求，包括靜態資源的請求 -->
    <url-pattern>/</url-pattern>
  </servlet-mapping>

  <!-- step3: characterEncodingFilter字符編碼過濾器，放在所有過濾器的前面 -->
  <filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <!--要使用的字符集，一般我們使用UTF-8(保險起見UTF-8最好)-->
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
      <!--是否強制設置request的編碼為encoding，默認false，不建議更改-->
      <param-name>forceRequestEncoding</param-name>
      <param-value>false</param-value>
    </init-param>
    <init-param>
      <!--是否強制設置response的編碼為encoding，建議設置為true-->
      <param-name>forceResponseEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <!--這里不能留空或者直接寫 ' / ' ，否則可能不起作用-->
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- step4: 配置過濾器，將post請求轉為delete，put -->
  <filter>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
</web-app>

Step7：在 ssm_controller 中引入 ssm_service.jar 包。

<dependency>
  <groupId>com.lyh.ssm</groupId>
  <artifactId>ssm_service</artifactId>
  <version>1.0-SNAPSHOT</version>
</dependency>

Step8：使用 tomcat 啟動 ssm_controller 工程，即可訪問項目。

Step9：使用 tomcat7 插件來啟動 maven 聚合工程。

【在父工程 pom.xml 中引入 tomcat7 插件】
<build>
  <plugins>
    <plugin>
      <groupId>org.apache.tomcat.maven</groupId>
      <artifactId>tomcat7-maven-plugin</artifactId>
      <version>2.2</version>
    </plugin>
  </plugins>
</build>

3、垂直拆分 web 項目

（1）基本說明

【垂直拆分說明：】
    將上面簡單的 web 工程 做垂直拆分，按照業務對代碼進行拆分，
    將 業務A、業務 B 分別抽取出來，並做成獨立的 war 包。
注：
    若拆分后仍使用配置文件的方式進行項目構建，那么代碼冗余將非常多。
    所以一般均使用 SpringBoot 簡化開發（約定 > 配置）。
    
【使用 Maven 聚合的方式可以演示：】
Step1：構建一個 ssm_parent 工程（父工程，聚合下面的子工程，pom）
Step2：構建一個 ssm_serviceA 工程（子工程，存放 業務A，war）
Step3：構建一個 ssm_serviceB 工程（子工程，存放 業務B，war）

也即目錄結構如下：
ssm_parent（pom）
    ssm_serviceA（war）
    ssm_serviceB（war）

（2）使用 maven 聚合的方式進行垂直拆分
　　此處以 SpringBoot 作為項目構建的基礎。

Step1：使用 maven 構建一個父工程 ssm_parent。

Step2：ssm_parent 項目上右鍵選擇 New -> Module 並選擇 Spirng Initializr。
　　使用 SpringBoot 創建 serviceA 項目。

Step3：從普通 web 工程中抽取出業務A 的代碼放入 ssm_serviceA 中。

【ControllerA】
 package com.lyh.ssm.aservice.controller;

import com.lyh.ssm.aservice.service.ServiceA;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ControllerA {
    @Autowired
    private ServiceA serviceA;

    @GetMapping("/testA")
    public String testContollerA() {
        return serviceA.testA();
    }
} 

【ServiceA】
package com.lyh.ssm.aservice.service;

import org.springframework.stereotype.Service;

@Service
public class ServiceA {
    public String testA() {
        return "test serviceA";
    }
}

Step4：修改父工程（ssm_parent）以及當前工程（ssm_serviceA）pom.xml 並引入依賴。
　　修改 ssm_serviceA 的 <parent>，使其指向父工程（ssm_parent）。
　　在父工程中通過 <module> 管理子工程。
　　在父工程中通過 <dependencyManagement> 聲明依賴、管理版本。
　　在子工程中通過 <dependency> 引入需要的依賴。

【ssm_parent 的 pom.xml 為：】
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lyh.ssm</groupId>
    <artifactId>ssm_parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <modules>
        <module>ssm_serviceA</module>
    </modules>

    <properties>
        <java.version>1.8</java.version>
        <web.version>2.4.0</web.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>${web.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <version>${web.version}</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

【ssm_serviceA 的 pom.xml 為：】
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.lyh.ssm</groupId>
        <artifactId>ssm_parent</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>aservice</artifactId>
    <name>ssm_serviceA</name>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

Step5：修改 ssm_serviceA 的配置文件（端口號、服務名等）
　　修改 application.properties 或者 application.yml 文件。

【application.yml】
server:
  port: 9000

spring:
  application:
    name: ssm_serviceA

Step6：同理，創建 SpingBoot 項目 ssm_serviceB，並從普通 web 工程中抽取業務B 代碼放入其中。同樣修改 pom.xml（指向父工程，引入 web 依賴）以及配置文件。

【ControllerB】
package com.lyh.ssm.bservice.controller;

import com.lyh.ssm.bservice.service.ServiceB;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ControllerB {
    @Autowired
    private ServiceB serviceB;

    @GetMapping("/testB")
    public String testContollerB() {
        return serviceB.testB();
    }
}

【ServiceB】
package com.lyh.ssm.bservice.service;

import org.springframework.stereotype.Service;

@Service
public class ServiceB {
    public String testB() {
        return "test serviceB";
    }
}

【ssm_serviceB 的 pom.xml 為：】
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.lyh.ssm</groupId>
        <artifactId>ssm_parent</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactId>bservice</artifactId>
    <name>bservice</name>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

【application.yml】
server:
  port: 9010

spring:
  application:
    name: ssm_serviceB
    
【ssm_parent 的 pom.xml 為：】
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lyh.ssm</groupId>
    <artifactId>ssm_parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <modules>
        <module>ssm_serviceA</module>
        <module>ssm_serviceB</module>
    </modules>

    <properties>
        <java.version>1.8</java.version>
        <web.version>2.4.0</web.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>${web.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <version>${web.version}</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

Step7：通過兩個項目的啟動類可以分別啟動兩個項目。
　　或者直接 mvn install 父工程（ssm_parent），然后執行打包好的 jar 包。

4、使用 maven 聚合的注意事項

（1）父工程的 pom.xml 文件

【聚合項目 父工程：】
    使用 maven 創建聚合工程時，父工程中 使用 <packaging>pom</packaging> 指定類型為 pom。
    父工程一般 用於進行 依賴聲明 以及 版本控制。
注：
    通過 <properties> 標簽 以及 ${} 可以進行依賴（jar）版本的管理。
    使用 <dependencyManagement> 標簽可以進行依賴聲明。
    使用 <modules> 標簽管理 子模塊。
    
【父工程 pom.xml 舉例：】
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lyh.ssm</groupId>
    <artifactId>ssm_parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <modules>
        <module>ssm_serviceA</module>
        <module>ssm_serviceB</module>
    </modules>

    <properties>
        <java.version>1.8</java.version>
        <web.version>2.4.0</web.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>${web.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <version>${web.version}</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

（2）子工程的 pom.xml 文件

【聚合項目 子工程：】
    使用 maven 創建子工程時，使用 <parent> 標簽指定 父工程。
    使用 <dependencies> 標簽按需引入依賴，若父工程使用 <dependencyManagement> 進行版本控制，則子工程引入依賴時可以不指定版本 <version>（便於統一管理）。

【子工程 pom.xml 舉例：】
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.lyh.ssm</groupId>
        <artifactId>ssm_parent</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactId>bservice</artifactId>
    <name>bservice</name>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

（3）<dependencyManagement> 與 <dependencies> 區別
　　<dependencyManagement> 一般出現在父工程中，用於聲明依賴以及版本控制，但是並沒有真正引入依賴。
　　<dependencies> 是真正的引入依賴。
　　父工程中使用 <dependencyManagement> 進行了版本控制，若子工程中 <dependencies> 引入依賴時使用 <version> 指定了版本，則以子工程的版本為主。若子工程中沒有使用 <version>，則以父工程定義的 version 為主。

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 單體架構、SOA、微服務單體架構和微服務比較微服務和單體架構的區別如何拆分微服務架構？從單體架構到微服務架構演進微服務架構特征及與單體架構的對比從單體架構到微服務架構的演化歷程單體架構還是微服務架構，這是個問題？單體架構&微服務架構&中台服務架構架構之:微服務和單體服務之爭