Maven依賴管理項目構建工具

目錄

一、Maven簡介

1、為什么學習Maven

1.1、Maven是一個依賴管理工具

①jar 包的規模

隨著我們使用越來越多的框架，或者框架封裝程度越來越高，項目中使用的jar包也越來越多。項目中，一個模塊里面用到上百個jar包是非常正常的。

比如下面的例子，我們只用到 SpringBoot、SpringCloud 框架中的三個功能：

• Nacos 服務注冊發現
• Web 框架環境
• 視圖模板技術 Thymeleaf

最終卻導入了 106 個 jar 包：

org.springframework.security:spring-security-rsa:jar:1.0.9.RELEASE:compile
com.netflix.ribbon: ribbon:jar:2.3.0:compile
org.springframework.boot:spring-boot-starter-thymeleaf:jar:2.3.6.RELEASE:compile
commons-configuration:commons-configuration:jar:1.8:compile
org.apache.logging.log4j:log4j-api:jar:2.13.3:compile
org.springframework:spring-beans:jar:5.2.11.RELEASE:compile
org.springframework.cloud:spring-cloud-starter-netflix-ribbon:jar:2.2.6.RELEASE:compile
org.apache.tomcat.embed:tomcat-embed-websocket:jar:9.0.39:compile
com.alibaba.cloud:spring-cloud-alibaba-commons:jar:2.2.6.RELEASE:compile
org.bouncycastle:bcprov-jdk15on:jar:1.64:compile
org.springframework.security:spring-security-crypto:jar:5.3.5.RELEASE:compile
org.apache.httpcomponents:httpasyncclient:jar:4.1.4:compile
com.google.j2objc:j2objc-annotations:jar:1.3:compile
com.fasterxml.jackson.core:jackson-databind:jar:2.11.3:compile
io.reactivex:rxjava:jar:1.3.8:compile
ch.qos.logback:logback-classic:jar:1.2.3:compile
org.springframework:spring-web:jar:5.2.11.RELEASE:compile
io.reactivex:rxnetty-servo:jar:0.4.9:runtime
org.springframework:spring-core:jar:5.2.11.RELEASE:compile
io.github.openfeign.form:feign-form-spring:jar:3.8.0:compile
io.github.openfeign.form:feign-form:jar:3.8.0:compile
com.netflix.ribbon:ribbon-loadbalancer:jar:2.3.0:compile
org.apache.httpcomponents:httpcore:jar:4.4.13:compile
org.thymeleaf.extras:thymeleaf-extras-java8time:jar:3.0.4.RELEASE:compile
org.slf4j:jul-to-slf4j:jar:1.7.30:compile
com.atguigu.demo:demo09-base-entity:jar:1.0-SNAPSHOT:compile
org.yaml:snakeyaml:jar:1.26:compile
org.springframework.boot:spring-boot-starter-logging:jar:2.3.6.RELEASE:compile
io.reactivex:rxnetty-contexts:jar:0.4.9:runtime
org.apache.httpcomponents:httpclient:jar:4.5.13:compile
io.github.openfeign:feign-core:jar:10.10.1:compile
org.springframework.boot:spring-boot-starter-aop:jar:2.3.6.RELEASE:compile
org.hdrhistogram:HdrHistogram:jar:2.1.9:compile
org.springframework:spring-context:jar:5.2.11.RELEASE:compile
commons-lang:commons-lang:jar:2.6:compile
io.prometheus:simpleclient:jar:0.5.0:compile
ch.qos.logback:logback-core:jar:1.2.3:compile
org.springframework:spring-webmvc:jar:5.2.11.RELEASE:compile
com.sun.jersey:jersey-core:jar:1.19.1:runtime
javax.ws.rs:jsr311-api:jar:1.1.1:runtime
javax.inject:javax.inject:jar:1:runtime
org.springframework.cloud:spring-cloud-openfeign-core:jar:2.2.6.RELEASE:compile
com.netflix.ribbon:ribbon-core:jar:2.3.0:compile
com.netflix.hystrix:hystrix-core:jar:1.5.18:compile
com.netflix.ribbon:ribbon-transport:jar:2.3.0:runtime
org.springframework.boot:spring-boot-starter-json:jar:2.3.6.RELEASE:compile
org.springframework.cloud:spring-cloud-starter-openfeign:jar:2.2.6.RELEASE:compile
com.fasterxml.jackson.module:jackson-module-parameter-names:jar:2.11.3:compile
com.sun.jersey.contribs:jersey-apache-client4:jar:1.19.1:runtime
io.github.openfeign:feign-hystrix:jar:10.10.1:compile
io.github.openfeign:feign-slf4j:jar:10.10.1:compile
com.alibaba.nacos:nacos-client:jar:1.4.2:compile
org.apache.httpcomponents:httpcore-nio:jar:4.4.13:compile
com.sun.jersey:jersey-client:jar:1.19.1:runtime
org.springframework.cloud:spring-cloud-context:jar:2.2.6.RELEASE:compile
org.glassfish:jakarta.el:jar:3.0.3:compile
org.apache.logging.log4j:log4j-to-slf4j:jar:2.13.3:compile
com.fasterxml.jackson.datatype:jackson-datatype-jsr310:jar:2.11.3:compile
org.springframework.cloud:spring-cloud-commons:jar:2.2.6.RELEASE:compile
org.aspectj:aspectjweaver:jar:1.9.6:compile
com.alibaba.cloud:spring-cloud-starter-alibaba-nacos-discovery:jar:2.2.6.RELEASE:compile
com.google.guava:listenablefuture:jar:9999.0-empty-to-avoid-conflict-with-guava:compile
com.alibaba.spring:spring-context-support:jar:1.0.10:compile
jakarta.annotation:jakarta.annotation-api:jar:1.3.5:compile
org.bouncycastle:bcpkix-jdk15on:jar:1.64:compile
com.netflix.netflix-commons:netflix-commons-util:jar:0.3.0:runtime
com.fasterxml.jackson.core:jackson-annotations:jar:2.11.3:compile
com.google.guava:guava:jar:29.0-jre:compile
com.google.guava:failureaccess:jar:1.0.1:compile
org.springframework.boot:spring-boot:jar:2.3.6.RELEASE:compile
com.fasterxml.jackson.datatype:jackson-datatype-jdk8:jar:2.11.3:compile
com.atguigu.demo:demo08-base-api:jar:1.0-SNAPSHOT:compile
org.springframework.cloud:spring-cloud-starter-netflix-archaius:jar:2.2.6.RELEASE:compile
org.springframework.boot:spring-boot-autoconfigure:jar:2.3.6.RELEASE:compile
org.slf4j:slf4j-api:jar:1.7.30:compile
commons-io:commons-io:jar:2.7:compile
org.springframework.cloud:spring-cloud-starter:jar:2.2.6.RELEASE:compile
org.apache.tomcat.embed:tomcat-embed-core:jar:9.0.39:compile
io.reactivex:rxnetty:jar:0.4.9:runtime
com.fasterxml.jackson.core:jackson-core:jar:2.11.3:compile
com.google.code.findbugs:jsr305:jar:3.0.2:compile
com.netflix.archaius:archaius-core:jar:0.7.6:compile
org.springframework.boot:spring-boot-starter-web:jar:2.3.6.RELEASE:compile
commons-codec:commons-codec:jar:1.14:compile
com.netflix.servo:servo-core:jar:0.12.21:runtime
com.google.errorprone:error_prone_annotations:jar:2.3.4:compile
org.attoparser:attoparser:jar:2.0.5.RELEASE:compile
com.atguigu.demo:demo10-base-util:jar:1.0-SNAPSHOT:compile
org.checkerframework:checker-qual:jar:2.11.1:compile
org.thymeleaf:thymeleaf-spring5:jar:3.0.11.RELEASE:compile
commons-fileupload:commons-fileupload:jar:1.4:compile
com.netflix.ribbon:ribbon-httpclient:jar:2.3.0:compile
com.netflix.netflix-commons:netflix-statistics:jar:0.1.1:runtime
org.unbescape:unbescape:jar:1.1.6.RELEASE:compile
org.springframework:spring-jcl:jar:5.2.11.RELEASE:compile
com.alibaba.nacos:nacos-common:jar:1.4.2:compile
commons-collections:commons-collections:jar:3.2.2:runtime
javax.persistence:persistence-api:jar:1.0:compile
com.alibaba.nacos:nacos-api:jar:1.4.2:compile
org.thymeleaf:thymeleaf:jar:3.0.11.RELEASE:compile
org.springframework:spring-aop:jar:5.2.11.RELEASE:compile
org.springframework.boot:spring-boot-starter:jar:2.3.6.RELEASE:compile
org.springframework.boot:spring-boot-starter-tomcat:jar:2.3.6.RELEASE:compile
org.springframework.cloud:spring-cloud-netflix-ribbon:jar:2.2.6.RELEASE:compile
org.springframework:spring-expression:jar:5.2.11.RELEASE:compile
org.springframework.cloud:spring-cloud-netflix-archaius:jar:2.2.6.RELEASE:compile

而如果使用 Maven 來引入這些 jar 包只需要配置三個『依賴』：

<!-- Nacos 服務注冊發現啟動器 -->
<dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency><!-- web啟動器依賴 -->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId>
</dependency><!-- 視圖模板技術 thymeleaf -->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

②jar包的來源問題

• 這個jar包所屬技術的官網。官網通常是英文界面，網站的結構又不盡相同，甚至找到下載鏈接還發現需要通過特殊的工具下載。
• 第三方網站提供下載。問題是不規范，在使用過程中會出現各種問題。
  • jar包的名稱
  • jar包的版本
  • jar包內的具體細節
• 而使用 Maven 后，依賴對應的 jar 包能夠自動下載，方便、快捷又規范。

③jar包的導入問題

在web工程中，jar包必須存放在指定位置：

在使用Maven之后，通過配置依賴(jar包)的坐標，查找本地倉庫中相應jar包，若本地倉庫沒有，則統一從鏡像網站或中央倉庫中下載：

④jar包之間的依賴

框架中使用的 jar 包，不僅數量龐大，而且彼此之間存在錯綜復雜的依賴關系。依賴關系的復雜程度，已經上升到了完全不能靠人力手動解決的程度。另外，jar 包之間有可能產生沖突。進一步增加了我們在 jar 包使用過程中的難度。

下面是前面例子中 jar 包之間的依賴關系：

而實際上 jar 包之間的依賴關系是普遍存在的，如果要由程序員手動梳理無疑會增加極高的學習成本，而這些工作又對實現業務功能毫無幫助。

而使用 Maven 則幾乎不需要管理這些關系，極個別的地方調整一下即可，極大的減輕了我們的工作量。

1.2、Maven是一個構建工具

①你沒有注意過的構建

你可以不使用 Maven，但是構建必須要做。當我們使用 IDEA 進行開發時，構建是 IDEA 替我們做的。

②脫離 IDE 環境仍需構建

1.3、結論

• 管理規模龐大的 jar 包，需要專門工具。
• 脫離 IDE 環境執行構建操作，需要專門工具。

2. Maven介紹

https://maven.apache.org/what-is-maven.html

Maven 是一款為 Java 項目管理構建、依賴管理的工具（軟件），使用 Maven 可以自動化構建、測試、打包和發布項目，大大提高了開發效率和質量。

Maven就是一個軟件，掌握安裝、配置、以及基本功能 （項目構建、依賴管理） 的理解和使用即可！

1. 依賴管理：

   Maven 可以管理項目的依賴，包括自動下載所需依賴庫、自動下載依賴需要的依賴并且保證版本沒有沖突、依賴版本管理等。通過 Maven，我們可以方便地維護項目所依賴的外部庫，避免版本沖突和轉換錯誤等，而我們僅僅需要編寫配置即可。

2. 構建管理：

   項目構建是指將源代碼、配置文件、資源文件等轉化為能夠運行或部署的應用程序或庫的過程

   Maven 可以管理項目的編譯、測試、打包、部署等構建過程。通過實現標準的構建生命周期，Maven 可以確保每一個構建過程都遵循同樣的規則和最佳實踐。同時，Maven 的插件機制也使得開發者可以對構建過程進行擴展和定制。主動觸發構建，只需要簡單的命令操作即可。

   

場景1： 例如我們項目需要第三方依賴如：Druid連接池、MySQL數據庫驅動和Jackson JSON等處理。那么我們可以將想要的依賴項的信息編寫到Maven工程的配置文件，Maven就會自動下載并復制這些依賴項到項目中，無需自己導入jar包，管理jar!

場景2： 項目完成開發，我們想要打成war部署到服務器中，使用maven的構建命令可以快速打包！節省大量時間！

3. Maven軟件工作原理模型圖（了解）

二、Maven安裝和配置

1. Maven安裝

https://maven.apache.org/docs/history.html

各個工具選用版本：

工具	版本
Maven	3.8.8
JDK	17
IDEA	2022.2

安裝條件： maven需要本機安裝java環境、必需包含java_home環境變量！

軟件安裝： 右鍵解壓即可（綠色免安裝）

軟件結構：

bin：含有Maven的運行腳本

boot：含有plexus-classworlds類加載器框架

conf：含有Maven的核心配置文件

lib：含有Maven運行時所需要的Java類庫

LICENSE、NOTICE、README.txt：針對Maven版本，第三方軟件等簡要介紹

2. Maven環境配置

1. 配置MAVEN_HOME

   

2. 配置Path

   

3. 命令測試（cmd窗口）

   mvn -v 
   # 輸出版本信息即可，如果錯誤，請仔細檢查環境變量即可！
   

3. Maven功能配置

我們需要需改maven/conf/settings.xml配置文件，來修改maven的一些默認配置。我們主要休要修改的有三個配置：

1.依賴本地緩存位置（本地倉庫位置）

2.maven下載鏡像

3.maven選用編譯項目的jdk版本

1. 配置本地倉庫地址

     <!-- localRepository| The path to the local repository maven will use to store artifacts.|| Default: ${user.home}/.m2/repository<localRepository>/path/to/local/repo</localRepository>--><!-- conf/settings.xml 55行 --><localRepository>D:\maven-repository</localRepository>
   

2. 配置國內阿里鏡像

   <!--在mirrors節點(標簽)下添加中央倉庫鏡像 160行附近-->
   <mirror><id>alimaven</id><name>aliyun maven</name><url>http://maven.aliyun.com/nexus/content/groups/public/</url><mirrorOf>central</mirrorOf>
   </mirror>
   

3. 配置jdk17版本項目構建

   <!--在profiles節點(標簽)下添加jdk編譯版本 268行附近-->
   <profile><id>jdk-17</id><activation><activeByDefault>true</activeByDefault><jdk>17</jdk></activation><properties><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><maven.compiler.compilerVersion>17</maven.compiler.compilerVersion></properties>
   </profile>
   

4. IDEA配置本地Maven軟件

我們需要將配置好的maven軟件，配置到idea開發工具中即可！ 注意：idea工具默認自帶maven配置軟件，但是因為沒有修改配置，建議替換成本地配置好的maven！

選擇本地maven軟件

注意：

1、如果本地倉庫地址不變化，只有一個原因，就是maven/conf/settings.xml配置文件編寫錯誤！仔細檢查即可！

2、一定保證User settings file對應之前修改的settings.xml的路徑，若 不一致，選中Override復選框，手動選擇配置文件

三、基于IDEA創建Maven工程

1. 概念梳理Maven工程的GAVP

Maven工程相對之前的項目，多出一組gavp屬性，gav需要我們在創建項目的時候指定，p有默認值，我們先行了解下這組屬性的含義：

Maven 中的 GAVP 是指 GroupId、ArtifactId、Version、Packaging 等四個屬性的縮寫，其中前三個是必要的，而 Packaging 屬性為可選項。這四個屬性主要為每個項目在maven倉庫中做一個標識，類似人的姓-名！有了具體標識，方便后期項目之間相互引用依賴等！

GAV遵循一下規則：

? 1） GroupID 格式：com.{公司/BU }.業務線.[子業務線]，最多 4 級。

? 說明：{公司/BU} 例如：alibaba/taobao/tmall/aliexpress 等 BU 一級；子業務線可選。

? 正例：com.taobao.tddl 或 com.alibaba.sourcing.multilang

? 2） ArtifactID 格式：產品線名-模塊名。語義不重復不遺漏，先到倉庫中心去查證一下。

? 正例：tc-client / uic-api / tair-tool / bookstore

? 3） Version版本號格式推薦：主版本號.次版本號.修訂號

? 1） 主版本號：當做了不兼容的 API 修改，或者增加了能改變產品方向的新功能。

? 2） 次版本號：當做了向下兼容的功能性新增（新增類、接口等）。

? 3） 修訂號：修復 bug，沒有修改方法簽名的功能加強，保持 API 兼容性。

? 例如： 初始→1.0.0 修改bug → 1.0.1 功能調整 → 1.1.1等

Packaging定義規則：

? 指示將項目打包為什么類型的文件，idea根據packaging值，識別maven項目類型！

? packaging 屬性為 jar（默認值），代表普通的Java工程，打包以后是.jar結尾的文件。

? packaging 屬性為 war，代表Java的web工程，打包以后.war結尾的文件。

? packaging 屬性為 pom，代表不會打包，用來做繼承的父工程。

2. Idea構建Maven Java SE工程

注意：此處省略了version，直接給了一個默認值：1.0-SNAPSHOT

自己后期可以在項目中隨意修改！

創建工程之后，若第一次使用maven，或者使用的是新的本地倉庫，idea右下角會出現以下進度條，表示maven正在下載相關插件，等待下載完畢，進度條消失即可

驗證maven工程是否創建成功，當創建完畢maven工程之后，idea中會自動打開Maven視圖，如下圖：

3. Idea構建Maven Java Web工程

1. 手動創建

   1. 創建一個maven的javase工程

      

   2. 修改pom.xml文件打包方式

      修改位置：項目下/pom.xml

      <groupId>com.atguigu</groupId>
      <artifactId>maven_web</artifactId>
      <version>1.0-SNAPSHOT</version>
      <!-- 新增一列打包方式packaging -->
      <packaging>war</packaging>
      

   3. 設置web資源路徑和web.xml路徑

      點擊File–>Project Structure

      

      

      

   4. 刷新和校驗

      

      

2. 插件創建

   1. 安裝插件JBLJavaToWeb

      file / settings / plugins / marketplace

      

   2. 創建一個javasemaven工程

   3. 右鍵、使用插件快速補全web項目

      

4. Maven工程項目結構說明

Maven 是一個強大的構建工具，它提供一種標準化的項目結構，可以幫助開發者更容易地管理項目的依賴、構建、測試和發布等任務。以下是 Maven Web 程序的文件結構及每個文件的作用：

|-- pom.xml                               # Maven 項目管理文件 
|-- src|-- main                              # 項目主要代碼|   |-- java                          # Java 源代碼目錄|   |   `-- com/example/myapp         # 開發者代碼主目錄|   |       |-- controller            # 存放 Controller 層代碼的目錄|   |       |-- service               # 存放 Service 層代碼的目錄|   |       |-- dao                   # 存放 DAO 層代碼的目錄|   |       `-- model                 # 存放數據模型的目錄|   |-- resources                     # 資源目錄，存放配置文件、靜態資源等|   |   |-- log4j.properties          # 日志配置文件|   |   |-- spring-mybatis.xml        # Spring Mybatis 配置文件|   |   `-- static                    # 存放靜態資源的目錄|   |       |-- css                   # 存放 CSS 文件的目錄|   |       |-- js                    # 存放 JavaScript 文件的目錄|   |       `-- images                # 存放圖片資源的目錄|   `-- webapp                        # 存放 WEB 相關配置和資源|       |-- WEB-INF                   # 存放 WEB 應用配置文件|       |   |-- web.xml               # Web 應用的部署描述文件|       |   `-- classes               # 存放編譯后的 class 文件|       `-- index.html                # Web 應用入口頁面`-- test                              # 項目測試代碼|-- java                          # 單元測試目錄`-- resources                     # 測試資源目錄

• pom.xml：Maven 項目管理文件，用于描述項目的依賴和構建配置等信息。
• src/main/java：存放項目的 Java 源代碼。
• src/main/resources：存放項目的資源文件，如配置文件、靜態資源等。
• src/main/webapp/WEB-INF：存放 Web 應用的配置文件。
• src/main/webapp/index.jsp：Web 應用的入口頁面。
• src/test/java：存放項目的測試代碼。
• src/test/resources：存放測試相關的資源文件，如測試配置文件等。

四、基于IDEA進行Maven工程構建

1. 構建概念和構建過程

項目構建是指將源代碼、依賴庫和資源文件等轉換成可執行或可部署的應用程序的過程，在這個過程中包括編譯源代碼、鏈接依賴庫、打包和部署等多個步驟。

項目構建是軟件開發過程中至關重要的一部分，它能夠大大提高軟件開發效率，使得開發人員能夠更加專注于應用程序的開發和維護，而不必關心應用程序的構建細節。

同時，項目構建還能夠將多個開發人員的代碼匯合到一起，并能夠自動化項目的構建和部署，大大降低了項目的出錯風險和提高開發效率。常見的構建工具包括 Maven、Gradle、Ant 等。

2. 命令方式項目構建

命令	描述
mvn compile	編譯項目，生成target文件 （如果是test下測試用的則需要mvn test-compile命令或直接下面的mvn test）
mvn package	打包項目，生成jar或war文件
mvn clean	清理編譯或打包后的項目結構
mvn install	打包后上傳到maven本地倉庫
mvn deploy	只打包，上傳到maven私服倉庫
mvn site	生成站點
mvn test	執行測試源碼 （測試類以test結尾或開頭，方法名最好以test開頭）

（web工程打成war包，java工程打成jar包，如果報錯通常是版本所致解決如下）

war包打包插件和jdk版本不匹配：pom.xml 添加以下代碼即可

<build><!-- jdk17 和 war包版本插件不匹配 --><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-war-plugin</artifactId><version>3.2.2</version></plugin></plugins>
</build>

命令觸發練習：

mvn 命令 命令#清理
mvn clean
#清理，并重新打包
mvn clean package
#執行測試代碼
mvn test          通常是測試完后在進行的打包

3. 可視化方式項目構建

注意：打包（package）和安裝（install）的區別是什么

打包是將工程打成jar或war文件，保存在target目錄下

安裝是將當前工程所生成的jar或war文件，安裝到本地倉庫，會按照坐標保存到指定位置

4. 構建插件、命令、生命周期命令之間關系

• 構建生命周期

  我們發現一個情況！當我們執行package命令也會自動執行compile命令！

  [INFO] --------------------------------[ jar ]---------------------------------
  [INFO] 
  [INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ mybatis-base-curd ---
  [INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ mybatis-base-curd ---
  [INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ mybatis-base-curd ---
  [INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ mybatis-base-curd ---
  [INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ mybatis-base-curd ---
  [INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ mybatis-base-curd ---
  [INFO] Building jar: D:\javaprojects\backend-engineering\part03-mybatis\mybatis-base-curd\target\mybatis-base-curd-1.0-SNAPSHOT.jar
  [INFO] ------------------------------------------------------------------------
  [INFO] BUILD SUCCESS
  [INFO] ------------------------------------------------------------------------
  [INFO] Total time:  5.013 s
  [INFO] Finished at: 2023-06-05T10:03:47+08:00
  [INFO] ------------------------------------------------------------------------
  

  這種行為就是因為構建生命周期產生的！構建生命周期可以理解成是一組固定構建命令的有序集合，觸發周期后的命令，會自動觸發周期前的命令！！！

  構建周期作用：會簡化構建過程

  例如：項目打包 mvn clean package即可。

  主要兩個構建生命周期：

  • 清理周期：主要是對項目編譯生成文件進行清理

    包含命令：clean

• 默認周期：定義了真正構件時所需要執行的所有步驟，它是生命周期中最核心的部分

  包含命令：compile -  test - package - install - deploy
  

• 插件、命令、周期三者關系（了解）

  周期→包含若干命令→包含若干插件

  使用周期命令構建，簡化構建過程！

  最終進行構建的是插件！

五、基于IDEA 進行Maven依賴管理

1. 依賴管理概念

Maven 依賴管理是 Maven 軟件中最重要的功能之一。Maven 的依賴管理能夠幫助開發人員自動解決軟件包依賴問題，使得開發人員能夠輕松地將其他開發人員開發的模塊或第三方框架集成到自己的應用程序或模塊中，避免出現版本沖突和依賴缺失等問題。

我們通過定義 POM 文件，Maven 能夠自動解析項目的依賴關系，并通過 Maven 倉庫自動下載和管理依賴，從而避免了手動下載和管理依賴的繁瑣工作和可能引發的版本沖突問題。

總之，Maven 的依賴管理是 Maven 軟件的一個核心功能之一，使得軟件包依賴的管理和使用更加智能和方便，簡化了開發過程中的工作，并提高了軟件質量和可維護性。

2. Maven工程核心信息配置和解讀（GAVP）

位置：pom.xml

<!-- 模型版本 -->
<modelVersion>4.0.0</modelVersion>
<!-- 公司或者組織的唯一標志，并且配置時生成的路徑也是由此生成， 如com.companyname.project-group，maven會將該項目打成的jar包放本地路徑：/com/companyname/project-group -->
<groupId>com.companyname.project-group</groupId>
<!-- 項目的唯一ID，一個groupId下面可能多個項目，就是靠artifactId來區分的 -->
<artifactId>project</artifactId>
<!-- 版本號 -->
<version>1.0.0</version><!--打包方式默認：jarjar指的是普通的java項目打包方式！ 項目打成jar包！war指的是web項目打包方式！項目打成war包！pom不會講項目打包！這個項目作為父工程，被其他工程聚合或者繼承！后面會講解兩個概念
-->
<packaging>jar/pom/war</packaging>

3. Maven工程依賴管理配置

位置：pom.xml

依賴管理和依賴添加

<!-- 通過編寫依賴jar包的gav必要屬性，引入第三方依賴！scope屬性是可選的，可以指定依賴生效范圍！依賴信息查詢方式：1. maven倉庫信息官網 https://mvnrepository.com/2. mavensearch插件搜索-->
<dependencies><!-- 引入具體的依賴包 --><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version><!-- 依賴范圍 --><scope>runtime</scope></dependency></dependencies>

依賴版本統一提取和維護

<!--聲明版本-->
<properties><!--命名隨便,內部制定版本號即可！--><junit.version>4.12</junit.version><!-- 也可以通過 maven規定的固定的key，配置maven的參數！如下配置編碼格式！--><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><!--引用properties聲明版本 --><version>${junit.version}</version></dependency>
</dependencies>

4. 依賴范圍

通過設置坐標的依賴范圍(scope)，可以設置 對應jar包的作用范圍：編譯環境、測試環境、運行環境

依賴范圍	描述
compile	編譯依賴范圍，scope 元素的缺省值。使用此依賴范圍的 Maven 依賴，對于三種 classpath (即三種環境)均有效，即該 Maven 依賴在上述三種 classpath 均會被引入。例如，log4j 在編譯、測試、運行過程都是必須的。
test	測試依賴范圍。使用此依賴范圍的 Maven 依賴，只對測試 classpath 有效。例如，Junit 依賴只有在測試階段才需要。
provided	已提供依賴范圍。使用此依賴范圍的 Maven 依賴，只對編譯 classpath 和測試 classpath 有效。例如，servlet-api 依賴對于編譯、測試階段而言是需要的，但是運行階段，由于外部容器已經提供，故不需要 Maven 重復引入該依賴。
runtime	運行時依賴范圍。使用此依賴范圍的 Maven 依賴，只對測試 classpath、運行 classpath 有效。例如，JDBC 驅動實現依賴，其在編譯時只需 JDK 提供的 JDBC 接口即可，只有測試、運行階段才需要實現了 JDBC 接口的驅動。
system	系統依賴范圍，其效果與 provided 的依賴范圍一致。其用于添加非 Maven 倉庫的本地依賴，通過依賴元素 dependency 中的 systemPath 元素指定本地依賴的路徑。鑒于使用其會導致項目的可移植性降低，一般不推薦使用。
import	導入依賴范圍，該依賴范圍只能與 dependencyManagement 元素配合使用，其功能是將目標 pom.xml 文件中 dependencyManagement 的配置導入合并到當前 pom.xml 的 dependencyManagement 中。

5. Maven工程依賴下載失敗錯誤解決（重點）

在使用 Maven 構建項目時，可能會發生依賴項下載錯誤的情況，主要原因有以下幾種：

1. 下載依賴時出現網絡故障或倉庫服務器宕機等原因，導致無法連接至 Maven 倉庫，從而無法下載依賴。
2. 依賴項的版本號或配置文件中的版本號錯誤，或者依賴項沒有正確定義，導致 Maven 下載的依賴項與實際需要的不一致，從而引發錯誤。
3. 本地 Maven 倉庫或緩存被污染或損壞，導致 Maven 無法正確地使用現有的依賴項。

解決方案：

1. 檢查網絡連接和 Maven 倉庫服務器狀態。

2. 確保依賴項的版本號與項目對應的版本號匹配，并檢查 POM 文件中的依賴項是否正確。

3. 清除本地 Maven 倉庫緩存（lastUpdated 文件），因為只要存在lastupdated緩存文件，刷新也不會重新下載。本地倉庫中，根據依賴的gav屬性依次向下查找文件夾，最終刪除內部的文件，刷新重新下載即可！

   例如： pom.xml依賴

   <dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.2.8</version>
   </dependency>
   

   文件：

   

4. 或者可以將清除lastUpdated文件的操作寫在一個腳本文件中，手動創建文件"clearLastUpdated.bat"，名字任意，但是后綴必須是bat，將以下內容復制到文件中

   cls 
   @ECHO OFF 
   SET CLEAR_PATH=D: 
   SET CLEAR_DIR=D:\maven-repository(本地倉庫路徑)
   color 0a 
   TITLE ClearLastUpdated For Windows 
   GOTO MENU 
   :MENU 
   CLS
   ECHO. 
   ECHO. * * * *  ClearLastUpdated For Windows  * * * * 
   ECHO. * * 
   ECHO. * 1 清理*.lastUpdated * 
   ECHO. * * 
   ECHO. * 2 查看*.lastUpdated * 
   ECHO. * * 
   ECHO. * 3 退 出 * 
   ECHO. * * 
   ECHO. * * * * * * * * * * * * * * * * * * * * * * * * 
   ECHO. 
   ECHO.請輸入選擇項目的序號： 
   set /p ID= 
   IF "%id%"=="1" GOTO cmd1 
   IF "%id%"=="2" GOTO cmd2 
   IF "%id%"=="3" EXIT 
   PAUSE 
   :cmd1 
   ECHO. 開始清理
   %CLEAR_PATH%
   cd %CLEAR_DIR%
   for /r %%i in (*.lastUpdated) do del %%i
   ECHO.OK 
   PAUSE 
   GOTO MENU 
   :cmd2 
   ECHO. 查看*.lastUpdated文件
   %CLEAR_PATH%
   cd %CLEAR_DIR%
   for /r %%i in (*.lastUpdated) do echo %%i
   ECHO.OK 
   PAUSE 
   GOTO MENU 
   

   

6. Maven工程Build構建配置

項目構建是指將源代碼、依賴庫和資源文件等轉換成可執行或可部署的應用程序的過程，在這個過程中包括編譯源代碼、鏈接依賴庫、打包和部署等多個步驟。

默認情況下，構建不需要額外配置，都有對應的缺省配置。當然了，我們也可以在pom.xml定制一些配置，來修改默認構建的行為和產物！

例如：

1. 指定構建打包文件的名稱，非默認名稱
2. 制定構建打包時，指定包含文件格式和排除文件
3. 打包插件版本過低，配置更高版本插件

構建配置是在pom.xml / build標簽中指定！

指定打包命名

<!-- 默認的打包名稱：artifactid+verson.打包方式 -->
<build><finalName>定義打包名稱</finalName>
</build>  

指定打包文件

如果在java文件夾中添加java類，會自動打包編譯到classes文件夾下！

但是在java文件夾中添加xml文件，默認不會被打包！

默認情況下，按照maven工程結構放置的文件會默認被編譯和打包！

除此之外、我們可以使用resources標簽，指定要打包資源的文件夾要把哪些靜態資源打包到 classes根目錄下！

應用場景：mybatis中有時會將用于編寫SQL語句的映射文件和mapper接口都寫在src/main/java下的某個包中，此時映射文件就不會被打包，如何解決

<build><!--設置要打包的資源位置--><resources><resource><!--設置資源所在目錄--><directory>src/main/java</directory><includes><!--設置包含的資源類型--><include>**/*.xml</include></includes></resource></resources>
</build>

配置依賴插件

dependencies標簽下引入開發需要的jar包！我們可以在build/plugins/plugin標簽引入插件！

常用的插件：修改jdk版本、tomcat插件、mybatis分頁插件、mybatis逆向工程插件等等！

<build><plugins><!-- java編譯插件，配jdk的編譯版本 --><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><configuration><source>1.8</source><target>1.8</target><encoding>UTF-8</encoding></configuration></plugin><!-- tomcat插件 --><plugin><groupId>org.apache.tomcat.maven</groupId><artifactId>tomcat7-maven-plugin</artifactId><version>2.2</version><configuration><port>8090</port><path>/</path><uriEncoding>UTF-8</uriEncoding><server>tomcat7</server></configuration></plugin></plugins>
</build>

六、Maven依賴傳遞和依賴沖突

1. Maven依賴傳遞特性

概念

假如有Maven項目A，項目B依賴A，項目C依賴B。那么我們可以說 C依賴A。也就是說，依賴的關系為：C—>B—>A， 那么我們執行項目C時，會自動把B、A都下載導入到C項目的jar包文件夾中，這就是依賴的傳遞性。

作用

• 簡化依賴導入過程
• 確保依賴版本正確

傳遞的原則

在 A 依賴 B，B 依賴 C 的前提下，C 是否能夠傳遞到 A，取決于 B 依賴 C 時使用的依賴范圍以及配置

• B 依賴 C 時使用 compile 范圍：可以傳遞

• B 依賴 C 時使用 test 或 provided 范圍：不能傳遞，所以需要這樣的 jar 包時，就必須在需要的地方明確配置依賴才可以。

• B 依賴 C 時，若配置了以下標簽，則不能傳遞

  <dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.2.15</version><optional>true</optional>
  </dependency>
  

依賴傳遞終止

• 非compile范圍進行依賴傳遞
• 使用optional配置終止傳遞
• 依賴沖突（傳遞的依賴已經存在）

案例：導入jackson依賴

分析：jackson需要三個依賴

依賴傳遞關系：data-bind中，依賴其他兩個依賴

最佳導入：直接可以導入data-bind，自動依賴傳遞需要的依賴

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>2.10.0</version>
</dependency>

2. Maven依賴沖突特性

當直接引用或者間接引用出現了相同的jar包! 這時呢，一個項目就會出現相同的重復jar包，這就算作沖突！依賴沖突避免出現重復依賴，并且終止依賴傳遞！

maven自動解決依賴沖突問題能力，會按照自己的原則，進行重復依賴選擇。同時也提供了手動解決的沖突的方式，不過不推薦！

解決依賴沖突（如何選擇重復依賴）方式：

1. 自動選擇原則

   • 短路優先原則（第一原則）

     A—>B—>C—>D—>E—>X(version 0.0.1)

     A—>F—>X(version 0.0.2)

     則A依賴于X(version 0.0.2)。

   • 依賴路徑長度相同情況下，則“先聲明優先”（第二原則）

     A—>E—>X(version 0.0.1)

     A—>F—>X(version 0.0.2)

     在<depencies></depencies>中，先聲明的，路徑相同，會優先選擇！

2. 手動排除

   <dependency><groupId>com.atguigu.maven</groupId><artifactId>pro01-maven-java</artifactId><version>1.0-SNAPSHOT</version><scope>compile</scope><!-- 使用excludes標簽配置依賴的排除  --><exclusions><!-- 在exclude標簽中配置一個具體的排除 --><exclusion><!-- 指定要排除的依賴的坐標（不需要寫version） --><groupId>commons-logging</groupId><artifactId>commons-logging</artifactId></exclusion></exclusions>
   </dependency>
   

3. 小案例

   偽代碼如下：

   前提：A 1.1 -> B 1.1 -> C 1.1 F 2.2 -> B 2.2 pom聲明：F 2.2A 1.1 
   

   請問最終會導入哪些依賴和對應版本？

七、Maven工程繼承和聚合關系

1. Maven工程繼承關系

1. 繼承概念

   Maven 繼承是指在 Maven 的項目中，讓一個項目從另一個項目中繼承配置信息的機制。繼承可以讓我們在多個項目中共享同一配置信息，簡化項目的管理和維護工作。

2. 繼承作用

   在父工程中統一管理項目中的依賴信息。

   它的背景是：

   • 對一個比較大型的項目進行了模塊拆分。
   • 一個 project 下面，創建了很多個 module。
   • 每一個 module 都需要配置自己的依賴信息。

   它背后的需求是：

   • 在每一個 module 中各自維護各自的依賴信息很容易發生出入，不易統一管理。
   • 使用同一個框架內的不同 jar 包，它們應該是同一個版本，所以整個項目中使用的框架版本需要統一。
   • 使用框架時所需要的 jar 包組合（或者說依賴信息組合）需要經過長期摸索和反復調試，最終確定一個可用組合。這個耗費很大精力總結出來的方案不應該在新的項目中重新摸索。
     通過在父工程中為整個項目維護依賴信息的組合既保證了整個項目使用規范、準確的 jar 包；又能夠將以往的經驗沉淀下來，節約時間和精力。

3. 繼承語法

   • 父工程

       <groupId>com.atguigu.maven</groupId><artifactId>pro03-maven-parent</artifactId><version>1.0-SNAPSHOT</version><!-- 當前工程作為父工程，它要去管理子工程，所以打包方式必須是 pom --><packaging>pom</packaging>

   • 子工程

     <!-- 使用parent標簽指定當前工程的父工程 -->
     <parent><!-- 父工程的坐標 --><groupId>com.atguigu.maven</groupId><artifactId>pro03-maven-parent</artifactId><version>1.0-SNAPSHOT</version>
     </parent><!-- 子工程的坐標 -->
     <!-- 如果子工程坐標中的groupId和version與父工程一致，那么可以省略 -->
     <!-- <groupId>com.atguigu.maven</groupId> -->
     <artifactId>pro04-maven-module</artifactId>
     <!-- <version>1.0-SNAPSHOT</version> -->
     

4. 父工程依賴統一管理

   • 父工程聲明版本

     <!-- 使用dependencyManagement標簽配置對依賴的管理 -->
     <!-- 被管理的依賴并沒有真正被引入到工程 -->
     <dependencyManagement><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>6.0.10</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId><version>6.0.10</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.0.10</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-expression</artifactId><version>6.0.10</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>6.0.10</version></dependency></dependencies>
     </dependencyManagement>
     

   • 子工程引用版本

     <!-- 子工程引用父工程中的依賴信息時，可以把版本號去掉。  -->
     <!-- 把版本號去掉就表示子工程中這個依賴的版本由父工程決定。 -->
     <!-- 具體來說是由父工程的dependencyManagement來決定。 -->
     <dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-expression</artifactId></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId></dependency>
     </dependencies>
     

2. Maven工程聚合關系

1. 聚合概念

   Maven 聚合是指將多個項目組織到一個父級項目中，以便一起構建和管理的機制。聚合可以幫助我們更好地管理一組相關的子項目，同時簡化它們的構建和部署過程。

2. 聚合作用

   1. 管理多個子項目：通過聚合，可以將多個子項目組織在一起，方便管理和維護。
   2. 構建和發布一組相關的項目：通過聚合，可以在一個命令中構建和發布多個相關的項目，簡化了部署和維護工作。
   3. 優化構建順序：通過聚合，可以對多個項目進行順序控制，避免出現構建依賴混亂導致構建失敗的情況。
   4. 統一管理依賴項：通過聚合，可以在父項目中管理公共依賴項和插件，避免重復定義。

3. 聚合語法

   父項目中包含的子項目列表。

   <project><groupId>com.example</groupId><artifactId>parent-project</artifactId><packaging>pom</packaging><version>1.0.0</version><modules><module>child-project1</module>  //注意這里不是工程名而是路徑，如果你引用其他模塊，則需要寫路徑<module>child-project2</module></modules>
   </project>
   

4. 聚合演示

   通過觸發父工程構建命令、引發所有子模塊構建！產生反應堆！

八、Maven私服

1. Maven私服簡介

①私服簡介

Maven 私服是一種特殊的Maven遠程倉庫，它是架設在局域網內的倉庫服務，用來代理位于外部的遠程倉庫（中央倉庫、其他遠程公共倉庫）。

當然也并不是說私服只能建立在局域網，也有很多公司會直接把私服部署到公網，具體還是得看公司業務的性質是否是保密的等等，因為局域網的話只能在公司用，部署到公網的話員工在家里也可以辦公使用。

建立了 Maven 私服后，當局域網內的用戶需要某個構件時，會按照如下順序進行請求和下載。

請求本地倉庫，若本地倉庫不存在所需構件，則跳轉到第 2 步；
請求 Maven 私服，將所需構件下載到本地倉庫，若私服中不存在所需構件，則跳轉到第 3 步。
請求外部的遠程倉庫，將所需構件下載并緩存到 Maven 私服，若外部遠程倉庫不存在所需構件，則 Maven 直接報錯。

此外，一些無法從外部倉庫下載到的構件，也能從本地上傳到私服供其他人使用。

②Maven私服的優勢

1. 節省外網帶寬
   消除對外部遠程倉庫的大量重復請求（會消耗很大量的帶寬），降低外網帶寬壓力。

2. 下載速度更快
   Maven私服位于局域網內，從私服下載構建更快更穩定。

3. 便于部署第三方構件
   有些構件無法從任何一個遠程倉庫中獲得（如：公司或組織內部的私有構件、Oracle的JDBC驅動等），建立私服之后，就可以將這些構件部署到私服中，供內部Maven項目使用。

4. 提高項目的穩定性，增強對項目的控制
   如果不建立私服，那么Maven項目的構件就高度依賴外部的遠程倉庫，若外部網絡不穩定，則項目的構建過程也會變得不穩定。建立私服后，即使外部網絡狀況不佳甚至中斷，只要私服中已經緩存了所需的構件，Maven也能夠正常運行。私服軟件（如：Nexus）提供了很多控制功能（如：權限管理、RELEASE/SNAPSHOT版本控制等），可以對倉庫進行一些更加高級的控制。

5. 降低中央倉庫得負荷壓力
   由于私服會緩存中央倉庫得構件，避免了很多對中央倉庫的重復下載，降低了中央倉庫的負荷。

③常見的Maven私服產品

1. Apache的Archiva
2. JFrog的Artifactory
3. Sonatype的Nexus（[?neks?s]）（當前最流行、使用最廣泛）

2. Nexus下載安裝

下載地址：https://help.sonatype.com/repomanager3/product-information/download

解壓，以管理員身份打開CMD，進入bin目錄下，執行./nexus /run命令啟動

訪問 Nexus 首頁

首頁地址：http://localhost:8081/，8081為默認端口號

3. 初始設置

這里參考提示：

• 用戶名：admin
• 密碼：查看 E:\Server\nexus-3.61.0-02-win64\sonatype-work\nexus3\admin.password 文件

繼續執行初始化：

匿名登錄，啟用還是禁用？由于啟用匿名登錄后，后續操作比較簡單，這里我們演示禁用匿名登錄的操作：

初始化完畢：

4. Nexus上的各種倉庫

倉庫類型	說明
proxy	某個遠程倉庫的代理
group	存放：通過 Nexus 獲取的第三方 jar 包
hosted	存放：本團隊其他開發人員部署到 Nexus 的 jar 包

倉庫名稱	說明
maven-central	Nexus 對 Maven 中央倉庫的代理
maven-public	Nexus 默認創建，供開發人員下載使用的組倉庫
maven-releases	Nexus 默認創建，供開發人員部署自己 jar 包的宿主倉庫 要求 releases 版本
maven-snapshots	Nexus 默認創建，供開發人員部署自己 jar 包的宿主倉庫 要求 snapshots 版本

初始狀態下，這幾個倉庫都沒有內容：

5. 通過 Nexus 下載 jar 包

修改本地maven的核心配置文件settings.xml，設置新的本地倉庫地址

<!-- 配置一個新的 Maven 本地倉庫 -->
<localRepository>D:/maven-repository-new</localRepository>

把我們原來配置阿里云倉庫地址的 mirror 標簽改成下面這樣：

<mirror><id>nexus-mine</id><mirrorOf>central</mirrorOf><name>Nexus mine</name><url>http://localhost:8081/repository/maven-public/</url>
</mirror>

這里的 url 標簽是這么來的：

把上圖中看到的地址復制出來即可。如果我們在前面允許了匿名訪問，到這里就夠了。但如果我們禁用了匿名訪問，那么接下來我們還要繼續配置 settings.xml：

<server><id>nexus-mine</id><username>admin</username><password>atguigu</password>
</server>

這里需要格外注意：server 標簽內的 id 標簽值必須和 mirror 標簽中的 id 值一樣。

找一個用到框架的 Maven 工程，執行命令：

mvn clean compile

下載過程日志：

Downloading from nexus-mine: http://localhost:8081/repository/maven-public/com/jayway/jsonpath/json-path/2.4.0/json-path-2.4.0.pom
Downloaded from nexus-mine: http://localhost:8081/repository/maven-public/com/jayway/jsonpath/json-path/2.4.0/json-path-2.4.0.pom (2.6 kB at 110 kB/s)
Downloading from nexus-mine: http://localhost:8081/repository/maven-public/net/minidev/json-smart/2.3/json-smart-2.3.pom
Downloaded from nexus-mine: http://localhost:8081/repository/maven-public/net/minidev/json-smart/2.3/json-smart-2.3.pom (9.0 kB at 376 kB/s)
Downloading from nexus-mine: http://localhost:8081/repository/maven-public/net/minidev/minidev-parent/2.3/minidev-parent-2.3.pom
Downloaded from nexus-mine: http://localhost:8081/repository/maven-public/net/minidev/minidev-parent/2.3/minidev-parent-2.3.pom (8.5 kB at 404 kB/s)
Downloading from nexus-mine: http://localhost:8081/repository/maven-public/net/minidev/accessors-smart/1.2/accessors-smart-1.2.pom
Downloaded from nexus-mine: http://localhost:8081/repository/maven-public/net/minidev/accessors-smart/1.2/accessors-smart-1.2.pom (12 kB at 463 kB/s)

下載后，Nexus 服務器上就有了 jar 包：

若下載速度太慢，可以設置私服中中央倉庫的地址為阿里云倉庫地址

修改為：http://maven.aliyun.com/nexus/content/groups/public/

6. 將 jar 包部署到 Nexus

maven工程中配置：

<distributionManagement><snapshotRepository><id>nexus-mine</id><name>Nexus Snapshot</name><url>http://localhost:8081/repository/maven-snapshots/</url></snapshotRepository>
</distributionManagement>

注意：這里 snapshotRepository 的 id 標簽必須和 settings.xml 中指定的 mirror 標簽的 id 屬性一致。

執行部署命令：

mvn deploy

Uploading to nexus-mine: http://localhost:8081/repository/maven-snapshots/com/atguigu/demo/demo07-redis-data-provider/1.0-SNAPSHOT/maven-metadata.xml
Uploaded to nexus-mine: http://localhost:8081/repository/maven-snapshots/com/atguigu/demo/demo07-redis-data-provider/1.0-SNAPSHOT/maven-metadata.xml (786 B at 19 kB/s)
Uploading to nexus-mine: http://localhost:8081/repository/maven-snapshots/com/atguigu/demo/demo07-redis-data-provider/maven-metadata.xml
Uploaded to nexus-mine: http://localhost:8081/repository/maven-snapshots/com/atguigu/demo/demo07-redis-data-provider/maven-metadata.xml (300 B at 6.5 kB/s)
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary:
[INFO]
[INFO] demo-imperial-court-ms-show 1.0-SNAPSHOT … SUCCESS [ 1.875 s]
[INFO] demo09-base-entity … SUCCESS [ 21.883 s]
[INFO] demo10-base-util … SUCCESS [ 0.324 s]
[INFO] demo08-base-api … SUCCESS [ 1.171 s]
[INFO] demo01-imperial-court-gateway … SUCCESS [ 0.403 s]
[INFO] demo02-user-auth-center … SUCCESS [ 2.932 s]
[INFO] demo03-emp-manager-center … SUCCESS [ 0.312 s]
[INFO] demo04-memorials-manager-center … SUCCESS [ 0.362 s]
[INFO] demo05-working-manager-center … SUCCESS [ 0.371 s]
[INFO] demo06-mysql-data-provider … SUCCESS [ 6.779 s]
[INFO] demo07-redis-data-provider 1.0-SNAPSHOT … SUCCESS [ 0.273 s]

7. 引用別人部署的 jar 包

maven工程中配置：

<repositories><repository><id>nexus-mine</id><name>nexus-mine</name><url>http://localhost:8081/repository/maven-snapshots/</url><snapshots><enabled>true</enabled></snapshots><releases><enabled>true</enabled></releases></repository>
</repositories>

九、Maven綜合案例

1. 項目需求和結構分析

需求案例：搭建一個電商平臺項目，該平臺包括用戶服務、訂單服務、通用工具模塊等。

項目架構：

1. 用戶服務：負責處理用戶相關的邏輯，例如用戶信息的管理、用戶注冊、登錄等。
   • spring-context 6.0.6
   • spring-core 6.0.6
   • spring-beans 6.0.6
   • common-service
2. 訂單服務：負責處理訂單相關的邏輯，例如訂單的創建、訂單支付、退貨、訂單查看等。
   • spring-context 6.0.6
   • spring-core 6.0.6
   • spring-beans 6.0.6
   • spring-security 6.0.6
   • common-service
3. 通用模塊：負責存儲其他服務需要通用工具類，其他服務依賴此模塊。
   • commons-io 2.11.0
   • junit 5.9.2

2. 項目搭建和統一構建

①父模塊 (micro-shop)

創建工程：

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.atguigu</groupId><artifactId>micro-shop</artifactId><version>1.0-SNAPSHOT</version><!--知識點：父工程的打包方式為pom--><packaging>pom</packaging><properties><spring.version>6.0.6</spring.version><jackson.version>2.15.0</jackson.version><commons.version>2.11.0</commons.version><junit.version>5.9.2</junit.version><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><!-- 依賴管理 --><dependencyManagement><dependencies><!-- spring-context會依賴傳遞core/beans --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>${spring.version}</version></dependency><!-- jackson-databind會依賴傳遞core/annotations --><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>${jackson.version}</version></dependency><!-- commons-io --><dependency><groupId>commons-io</groupId><artifactId>commons-io</artifactId><version>${commons.version}</version></dependency><!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api --><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter-api</artifactId><version>${junit.version}</version><scope>test</scope></dependency></dependencies></dependencyManagement><!-- 統一更新子工程打包插件--><build><!-- jdk17 和 war包版本插件不匹配 --><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-war-plugin</artifactId><version>3.2.2</version></plugin></plugins></build></project>

可選操作：刪除src目錄

②通用模塊 (common-service)

創建工程：

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"><parent><artifactId>micro-shop</artifactId><groupId>com.atguigu</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>common-service</artifactId><!--知識點：打包方式默認就是jar，因此可以省略--><packaging>jar</packaging><properties><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><!-- 配置spring-context，繼承父工程版本，自動傳遞 core / beans --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId></dependency><!-- 配置jackson-databind，繼承父工程版本，自動傳遞 core / annotations --><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId></dependency><!-- 配置commons-io，繼承父工程版本 --><dependency><groupId>commons-io</groupId><artifactId>commons-io</artifactId></dependency><!-- 配置junit，繼承父工程版本 --><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter-api</artifactId><scope>test</scope></dependency></dependencies></project>

③用戶模塊 (user-service)

創建工程：

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"><parent><artifactId>micro-shop</artifactId><groupId>com.atguigu</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>user-service</artifactId><!-- web工程打包方式為war --><packaging>war</packaging><properties><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><!-- 配置common-service，所需依賴會傳遞到當前工程（僅限compile范圍） --><dependency><groupId>com.atguigu</groupId><artifactId>common-service</artifactId><version>1.0-SNAPSHOT</version></dependency></dependencies></project>

依賴傳遞結果：

④訂單模塊 (order-service)

創建工程，并使用插件轉為web工程：

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"><parent><artifactId>micro-shop</artifactId><groupId>com.atguigu</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>order-service</artifactId><!-- web工程打包方式為war --><packaging>war</packaging><properties><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><!-- 配置common-service，所需依賴會傳遞到當前工程（僅限compile范圍） --><dependency><groupId>com.atguigu</groupId><artifactId>common-service</artifactId><version>1.0-SNAPSHOT</version></dependency></dependencies></project>

此時，查看父工程的pom.xml，會發現其中已經自動聚合了子工程：

<modules><module>common-service</module><module>user-service</module><module>order-service</module>
</modules>