'Apache Maven 最全教程,看了就懂~'

Apache Java Gradle XML Eclipse 集成開發環境 編譯器 Java芋道源碼 2019-07-29
"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

Apache Maven 最全教程,看了就懂~

img

選擇Maven Project,點擊Next

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

Apache Maven 最全教程,看了就懂~

img

選擇Maven Project,點擊Next

Apache Maven 最全教程,看了就懂~

img

點擊Next

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

Apache Maven 最全教程,看了就懂~

img

選擇Maven Project,點擊Next

Apache Maven 最全教程,看了就懂~

img

點擊Next

Apache Maven 最全教程,看了就懂~

img

輸入webapp,選中第一項,點擊next

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

Apache Maven 最全教程,看了就懂~

img

選擇Maven Project,點擊Next

Apache Maven 最全教程,看了就懂~

img

點擊Next

Apache Maven 最全教程,看了就懂~

img

輸入webapp,選中第一項,點擊next

Apache Maven 最全教程,看了就懂~

img

項目就創建完成了,但是jdk的版本還有sevlet-api等jar包還沒有

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

Apache Maven 最全教程,看了就懂~

img

選擇Maven Project,點擊Next

Apache Maven 最全教程,看了就懂~

img

點擊Next

Apache Maven 最全教程,看了就懂~

img

輸入webapp,選中第一項,點擊next

Apache Maven 最全教程,看了就懂~

img

項目就創建完成了,但是jdk的版本還有sevlet-api等jar包還沒有

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Java Build Path,把jdk的版本選擇你電腦上的正確的jdk版本。

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

Apache Maven 最全教程,看了就懂~

img

選擇Maven Project,點擊Next

Apache Maven 最全教程,看了就懂~

img

點擊Next

Apache Maven 最全教程,看了就懂~

img

輸入webapp,選中第一項,點擊next

Apache Maven 最全教程,看了就懂~

img

項目就創建完成了,但是jdk的版本還有sevlet-api等jar包還沒有

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Java Build Path,把jdk的版本選擇你電腦上的正確的jdk版本。

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Project Facets,版本選擇3.1,下面的java版本選擇1.8,點擊Apply

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

Apache Maven 最全教程,看了就懂~

img

選擇Maven Project,點擊Next

Apache Maven 最全教程,看了就懂~

img

點擊Next

Apache Maven 最全教程,看了就懂~

img

輸入webapp,選中第一項,點擊next

Apache Maven 最全教程,看了就懂~

img

項目就創建完成了,但是jdk的版本還有sevlet-api等jar包還沒有

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Java Build Path,把jdk的版本選擇你電腦上的正確的jdk版本。

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Project Facets,版本選擇3.1,下面的java版本選擇1.8,點擊Apply

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,找到build path

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

Apache Maven 最全教程,看了就懂~

img

選擇Maven Project,點擊Next

Apache Maven 最全教程,看了就懂~

img

點擊Next

Apache Maven 最全教程,看了就懂~

img

輸入webapp,選中第一項,點擊next

Apache Maven 最全教程,看了就懂~

img

項目就創建完成了,但是jdk的版本還有sevlet-api等jar包還沒有

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Java Build Path,把jdk的版本選擇你電腦上的正確的jdk版本。

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Project Facets,版本選擇3.1,下面的java版本選擇1.8,點擊Apply

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,找到build path

Apache Maven 最全教程,看了就懂~

img

找到Libaries,添加Tomcat8.5的依賴庫,點擊OK

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

Apache Maven 最全教程,看了就懂~

img

選擇Maven Project,點擊Next

Apache Maven 最全教程,看了就懂~

img

點擊Next

Apache Maven 最全教程,看了就懂~

img

輸入webapp,選中第一項,點擊next

Apache Maven 最全教程,看了就懂~

img

項目就創建完成了,但是jdk的版本還有sevlet-api等jar包還沒有

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Java Build Path,把jdk的版本選擇你電腦上的正確的jdk版本。

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Project Facets,版本選擇3.1,下面的java版本選擇1.8,點擊Apply

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,找到build path

Apache Maven 最全教程,看了就懂~

img

找到Libaries,添加Tomcat8.5的依賴庫,點擊OK

Apache Maven 最全教程,看了就懂~

img

九、maven工程的依賴高級特性

① 依賴的傳遞性

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

Apache Maven 最全教程,看了就懂~

img

選擇Maven Project,點擊Next

Apache Maven 最全教程,看了就懂~

img

點擊Next

Apache Maven 最全教程,看了就懂~

img

輸入webapp,選中第一項,點擊next

Apache Maven 最全教程,看了就懂~

img

項目就創建完成了,但是jdk的版本還有sevlet-api等jar包還沒有

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Java Build Path,把jdk的版本選擇你電腦上的正確的jdk版本。

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Project Facets,版本選擇3.1,下面的java版本選擇1.8,點擊Apply

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,找到build path

Apache Maven 最全教程,看了就懂~

img

找到Libaries,添加Tomcat8.5的依賴庫,點擊OK

Apache Maven 最全教程,看了就懂~

img

九、maven工程的依賴高級特性

① 依賴的傳遞性

Apache Maven 最全教程,看了就懂~

WebMavenDemo項目依賴JavaMavenService1 JavaMavenService1項目依賴JavaMavenService2

pom.xml文件配置好依賴關係後,必須首先mvn install後,依賴的jar包才能使用。

  • WebMavenDemo的pom.xml文件想能編譯通過,JavaMavenService1必須mvn install
  • JavaMavenService的pom.xml文件想能編譯通過,JavaMavenService2必須mvn install

傳遞性:

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

Apache Maven 最全教程,看了就懂~

img

選擇Maven Project,點擊Next

Apache Maven 最全教程,看了就懂~

img

點擊Next

Apache Maven 最全教程,看了就懂~

img

輸入webapp,選中第一項,點擊next

Apache Maven 最全教程,看了就懂~

img

項目就創建完成了,但是jdk的版本還有sevlet-api等jar包還沒有

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Java Build Path,把jdk的版本選擇你電腦上的正確的jdk版本。

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Project Facets,版本選擇3.1,下面的java版本選擇1.8,點擊Apply

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,找到build path

Apache Maven 最全教程,看了就懂~

img

找到Libaries,添加Tomcat8.5的依賴庫,點擊OK

Apache Maven 最全教程,看了就懂~

img

九、maven工程的依賴高級特性

① 依賴的傳遞性

Apache Maven 最全教程,看了就懂~

WebMavenDemo項目依賴JavaMavenService1 JavaMavenService1項目依賴JavaMavenService2

pom.xml文件配置好依賴關係後,必須首先mvn install後,依賴的jar包才能使用。

  • WebMavenDemo的pom.xml文件想能編譯通過,JavaMavenService1必須mvn install
  • JavaMavenService的pom.xml文件想能編譯通過,JavaMavenService2必須mvn install

傳遞性:

Apache Maven 最全教程,看了就懂~

在Eclipse中,為JavaMavenService2中增加了一個spring-core.jar包後,會驚喜的發現依賴的兩個項目都自動的增加了這個jar包,這就是依賴的傳遞性。

注意:非compile範圍的依賴是不能傳遞的。

② 依賴版本的原則:

1、路徑最短者優先原則

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

Apache Maven 最全教程,看了就懂~

img

選擇Maven Project,點擊Next

Apache Maven 最全教程,看了就懂~

img

點擊Next

Apache Maven 最全教程,看了就懂~

img

輸入webapp,選中第一項,點擊next

Apache Maven 最全教程,看了就懂~

img

項目就創建完成了,但是jdk的版本還有sevlet-api等jar包還沒有

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Java Build Path,把jdk的版本選擇你電腦上的正確的jdk版本。

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Project Facets,版本選擇3.1,下面的java版本選擇1.8,點擊Apply

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,找到build path

Apache Maven 最全教程,看了就懂~

img

找到Libaries,添加Tomcat8.5的依賴庫,點擊OK

Apache Maven 最全教程,看了就懂~

img

九、maven工程的依賴高級特性

① 依賴的傳遞性

Apache Maven 最全教程,看了就懂~

WebMavenDemo項目依賴JavaMavenService1 JavaMavenService1項目依賴JavaMavenService2

pom.xml文件配置好依賴關係後,必須首先mvn install後,依賴的jar包才能使用。

  • WebMavenDemo的pom.xml文件想能編譯通過,JavaMavenService1必須mvn install
  • JavaMavenService的pom.xml文件想能編譯通過,JavaMavenService2必須mvn install

傳遞性:

Apache Maven 最全教程,看了就懂~

在Eclipse中,為JavaMavenService2中增加了一個spring-core.jar包後,會驚喜的發現依賴的兩個項目都自動的增加了這個jar包,這就是依賴的傳遞性。

注意:非compile範圍的依賴是不能傳遞的。

② 依賴版本的原則:

1、路徑最短者優先原則

Apache Maven 最全教程,看了就懂~

Service2的log4j的版本是1.2.7版本,Service1排除了此包的依賴,自己加了一個Log4j的1.2.9的版本,那麼WebMavenDemo項目遵守路徑最短優先原則,Log4j的版本和Sercive1的版本一致。

2、路徑相同先聲明優先原則

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

Apache Maven 最全教程,看了就懂~

img

選擇Maven Project,點擊Next

Apache Maven 最全教程,看了就懂~

img

點擊Next

Apache Maven 最全教程,看了就懂~

img

輸入webapp,選中第一項,點擊next

Apache Maven 最全教程,看了就懂~

img

項目就創建完成了,但是jdk的版本還有sevlet-api等jar包還沒有

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Java Build Path,把jdk的版本選擇你電腦上的正確的jdk版本。

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Project Facets,版本選擇3.1,下面的java版本選擇1.8,點擊Apply

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,找到build path

Apache Maven 最全教程,看了就懂~

img

找到Libaries,添加Tomcat8.5的依賴庫,點擊OK

Apache Maven 最全教程,看了就懂~

img

九、maven工程的依賴高級特性

① 依賴的傳遞性

Apache Maven 最全教程,看了就懂~

WebMavenDemo項目依賴JavaMavenService1 JavaMavenService1項目依賴JavaMavenService2

pom.xml文件配置好依賴關係後,必須首先mvn install後,依賴的jar包才能使用。

  • WebMavenDemo的pom.xml文件想能編譯通過,JavaMavenService1必須mvn install
  • JavaMavenService的pom.xml文件想能編譯通過,JavaMavenService2必須mvn install

傳遞性:

Apache Maven 最全教程,看了就懂~

在Eclipse中,為JavaMavenService2中增加了一個spring-core.jar包後,會驚喜的發現依賴的兩個項目都自動的增加了這個jar包,這就是依賴的傳遞性。

注意:非compile範圍的依賴是不能傳遞的。

② 依賴版本的原則:

1、路徑最短者優先原則

Apache Maven 最全教程,看了就懂~

Service2的log4j的版本是1.2.7版本,Service1排除了此包的依賴,自己加了一個Log4j的1.2.9的版本,那麼WebMavenDemo項目遵守路徑最短優先原則,Log4j的版本和Sercive1的版本一致。

2、路徑相同先聲明優先原則

Apache Maven 最全教程,看了就懂~

這種場景依賴關係發生了變化,WebMavenDemo項目依賴Sercive1和Service2,它倆是同一個路徑,那麼誰在WebMavenDemo的pom.xml中先聲明的依賴就用誰的版本。

③ 統一管理依賴的版本:

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

Apache Maven 最全教程,看了就懂~

img

選擇Maven Project,點擊Next

Apache Maven 最全教程,看了就懂~

img

點擊Next

Apache Maven 最全教程,看了就懂~

img

輸入webapp,選中第一項,點擊next

Apache Maven 最全教程,看了就懂~

img

項目就創建完成了,但是jdk的版本還有sevlet-api等jar包還沒有

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Java Build Path,把jdk的版本選擇你電腦上的正確的jdk版本。

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Project Facets,版本選擇3.1,下面的java版本選擇1.8,點擊Apply

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,找到build path

Apache Maven 最全教程,看了就懂~

img

找到Libaries,添加Tomcat8.5的依賴庫,點擊OK

Apache Maven 最全教程,看了就懂~

img

九、maven工程的依賴高級特性

① 依賴的傳遞性

Apache Maven 最全教程,看了就懂~

WebMavenDemo項目依賴JavaMavenService1 JavaMavenService1項目依賴JavaMavenService2

pom.xml文件配置好依賴關係後,必須首先mvn install後,依賴的jar包才能使用。

  • WebMavenDemo的pom.xml文件想能編譯通過,JavaMavenService1必須mvn install
  • JavaMavenService的pom.xml文件想能編譯通過,JavaMavenService2必須mvn install

傳遞性:

Apache Maven 最全教程,看了就懂~

在Eclipse中,為JavaMavenService2中增加了一個spring-core.jar包後,會驚喜的發現依賴的兩個項目都自動的增加了這個jar包,這就是依賴的傳遞性。

注意:非compile範圍的依賴是不能傳遞的。

② 依賴版本的原則:

1、路徑最短者優先原則

Apache Maven 最全教程,看了就懂~

Service2的log4j的版本是1.2.7版本,Service1排除了此包的依賴,自己加了一個Log4j的1.2.9的版本,那麼WebMavenDemo項目遵守路徑最短優先原則,Log4j的版本和Sercive1的版本一致。

2、路徑相同先聲明優先原則

Apache Maven 最全教程,看了就懂~

這種場景依賴關係發生了變化,WebMavenDemo項目依賴Sercive1和Service2,它倆是同一個路徑,那麼誰在WebMavenDemo的pom.xml中先聲明的依賴就用誰的版本。

③ 統一管理依賴的版本:

Apache Maven 最全教程,看了就懂~

為了統一管理版本號,可以使用properties標籤,裡面可以自定義版本的標籤名。在使用的地方使用${自定義標籤名}

十、build配置

<build>
  <!-- 項目的名字 -->
  <finalName>WebMavenDemo</finalName>
  <!-- 描述項目中資源的位置 -->
  <resources>
    <!-- 自定義資源1 -->
    <resource>
      <!-- 資源目錄 -->
      <directory>src/main/java</directory>
      <!-- 包括哪些文件參與打包 -->
      <includes>
        <include>**/*.xml</include>
      </includes>
      <!-- 排除哪些文件不參與打包 -->
      <excludes>
        <exclude>**/*.txt</exclude>
          <exclude>**/*.doc</exclude>
      </excludes>
    </resource>
  </resources>
  <!-- 設置構建時候的插件 -->
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>2.1</version>
      <configuration>
        <!-- 源代碼編譯版本 -->
        <source>1.8</source>
        <!-- 目標平臺編譯版本 -->
        <target>1.8</target>
      </configuration>
    </plugin>
    <!-- 資源插件(資源的插件) -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-resources-plugin</artifactId>
      <version>2.1</version>
      <executions>
        <execution>
          <phase>compile</phase>
        </execution>
      </executions>
      <configuration>
        <encoding>UTF-8</encoding>
      </configuration>
    </plugin>
    <!-- war插件(將項目打成war包) -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-war-plugin</artifactId>
      <version>2.1</version>
      <configuration>
        <!-- war包名字 -->
        <warName>WebMavenDemo1</warName>
      </configuration>
    </plugin>
  </plugins>
</build>

配置好build後,執行mvn package之後,在maven工程指定的target目錄裡war包和文件都按照配置的生成了

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

Apache Maven 最全教程,看了就懂~

img

選擇Maven Project,點擊Next

Apache Maven 最全教程,看了就懂~

img

點擊Next

Apache Maven 最全教程,看了就懂~

img

輸入webapp,選中第一項,點擊next

Apache Maven 最全教程,看了就懂~

img

項目就創建完成了,但是jdk的版本還有sevlet-api等jar包還沒有

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Java Build Path,把jdk的版本選擇你電腦上的正確的jdk版本。

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Project Facets,版本選擇3.1,下面的java版本選擇1.8,點擊Apply

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,找到build path

Apache Maven 最全教程,看了就懂~

img

找到Libaries,添加Tomcat8.5的依賴庫,點擊OK

Apache Maven 最全教程,看了就懂~

img

九、maven工程的依賴高級特性

① 依賴的傳遞性

Apache Maven 最全教程,看了就懂~

WebMavenDemo項目依賴JavaMavenService1 JavaMavenService1項目依賴JavaMavenService2

pom.xml文件配置好依賴關係後,必須首先mvn install後,依賴的jar包才能使用。

  • WebMavenDemo的pom.xml文件想能編譯通過,JavaMavenService1必須mvn install
  • JavaMavenService的pom.xml文件想能編譯通過,JavaMavenService2必須mvn install

傳遞性:

Apache Maven 最全教程,看了就懂~

在Eclipse中,為JavaMavenService2中增加了一個spring-core.jar包後,會驚喜的發現依賴的兩個項目都自動的增加了這個jar包,這就是依賴的傳遞性。

注意:非compile範圍的依賴是不能傳遞的。

② 依賴版本的原則:

1、路徑最短者優先原則

Apache Maven 最全教程,看了就懂~

Service2的log4j的版本是1.2.7版本,Service1排除了此包的依賴,自己加了一個Log4j的1.2.9的版本,那麼WebMavenDemo項目遵守路徑最短優先原則,Log4j的版本和Sercive1的版本一致。

2、路徑相同先聲明優先原則

Apache Maven 最全教程,看了就懂~

這種場景依賴關係發生了變化,WebMavenDemo項目依賴Sercive1和Service2,它倆是同一個路徑,那麼誰在WebMavenDemo的pom.xml中先聲明的依賴就用誰的版本。

③ 統一管理依賴的版本:

Apache Maven 最全教程,看了就懂~

為了統一管理版本號,可以使用properties標籤,裡面可以自定義版本的標籤名。在使用的地方使用${自定義標籤名}

十、build配置

<build>
  <!-- 項目的名字 -->
  <finalName>WebMavenDemo</finalName>
  <!-- 描述項目中資源的位置 -->
  <resources>
    <!-- 自定義資源1 -->
    <resource>
      <!-- 資源目錄 -->
      <directory>src/main/java</directory>
      <!-- 包括哪些文件參與打包 -->
      <includes>
        <include>**/*.xml</include>
      </includes>
      <!-- 排除哪些文件不參與打包 -->
      <excludes>
        <exclude>**/*.txt</exclude>
          <exclude>**/*.doc</exclude>
      </excludes>
    </resource>
  </resources>
  <!-- 設置構建時候的插件 -->
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>2.1</version>
      <configuration>
        <!-- 源代碼編譯版本 -->
        <source>1.8</source>
        <!-- 目標平臺編譯版本 -->
        <target>1.8</target>
      </configuration>
    </plugin>
    <!-- 資源插件(資源的插件) -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-resources-plugin</artifactId>
      <version>2.1</version>
      <executions>
        <execution>
          <phase>compile</phase>
        </execution>
      </executions>
      <configuration>
        <encoding>UTF-8</encoding>
      </configuration>
    </plugin>
    <!-- war插件(將項目打成war包) -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-war-plugin</artifactId>
      <version>2.1</version>
      <configuration>
        <!-- war包名字 -->
        <warName>WebMavenDemo1</warName>
      </configuration>
    </plugin>
  </plugins>
</build>

配置好build後,執行mvn package之後,在maven工程指定的target目錄裡war包和文件都按照配置的生成了

Apache Maven 最全教程,看了就懂~

img

好了,maven的所有的內容就整理完了。

最後推薦個最新最全的maven依賴項版本查詢網站:

http://mvnrepository.com/

來源:https://dwz.cn/zWjb9sfU


:-D 搜索微信號(ID:芋道源碼),可以獲得各種 Java 源碼解析、原理講解、面試題、學習指南。

:-D 並且,回覆【書籍】後,可以領取筆者推薦的各種 Java 從入門到架構的 100 本書籍。

:-D 並且,回覆【技術群】後,可以加入專門討論 Java、後端、架構的技術群。

"
  • 一、為什麼使用Maven這樣的構建工具【why】
  • 二、maven是什麼【what】
  • 三、安裝maven
  • 四、第一個maven
  • 五、倉庫和座標
  • 六、依賴
  • 七、生命週期
  • 八、Eclipse中使用maven
  • 九、maven工程的依賴高級特性
  • 十、build配置

前言:目前所有的項目都在使用maven,可是一直沒有時間去整理學習,這兩天正好有時間,好好的整理一下。

一、為什麼使用Maven這樣的構建工具【why】

① 一個項目就是一個工程

如果項目非常龐大,就不適合使用package來劃分模塊,最好是每一個模塊對應一個工程,利於分工協作。藉助於maven就可以將一個項目拆分成多個工程

② 項目中使用jar包,需要“複製”、“粘貼”項目的lib中

同樣的jar包重複的出現在不同的項目工程中,你需要做不停的複製粘貼的重複工作。藉助於maven,可以將jar包保存在“倉庫”中,不管在哪個項目只要使用引用即可就行。

③ jar包需要的時候每次都要自己準備好或到官網下載

藉助於maven我們可以使用統一的規範方式下載jar包,規範

④ jar包版本不一致的風險

不同的項目在使用jar包的時候,有可能會導致各個項目的jar包版本不一致,導致未執行錯誤。藉助於maven,所有的jar包都放在“倉庫”中,所有的項目都使用倉庫的一份jar包。

⑤ 一個jar包依賴其他的jar包需要自己手動的加入到項目中

FileUpload組件->IO組件,commons-fileupload-1.3.jar依賴於commons-io-2.0.1.jar

極大的浪費了我們導入包的時間成本,也極大的增加了學習成本。藉助於maven,它會自動的將依賴的jar包導入進來。

二、maven是什麼【what】

① maven是一款服務於java平臺的自動化構建工具

make->Ant->Maven->Gradle

名字叫法:我們可以叫妹文也可以叫麥文,但是沒有叫媽文的。

② 構建

構建定義:把動態的Web工程經過編譯得到的編譯結果部署到服務器上的整個過程。

編譯:java源文件[.java]->編譯->Classz字節碼文件[.class]

部署:最終在sevlet容器中部署的不是動態web工程,而是編譯後的文件

Apache Maven 最全教程,看了就懂~

img

③ 構建的各個環節

  • 清理clean:將以前編譯得到的舊文件class字節碼文件刪除
  • 編譯compile:將java源程序編譯成class字節碼文件
  • 測試test:自動測試,自動調用junit程序
  • 報告report:測試程序執行的結果
  • 打包package:動態Web工程打War包,java工程打jar包
  • 安裝install:Maven特定的概念-----將打包得到的文件複製到“倉庫”中的指定位置
  • 部署deploy:將動態Web工程生成的war包複製到Servlet容器下,使其可以運行

三、安裝maven

① 當前系統是否配置JAVA_HOME的環境變量

② 下載maven,解壓maven放在一個非中文無空格的路徑下

③ 配置maven的相關環境變量

  • 在環境變量增加M2_HOME,路徑是maven解壓後的根目錄
  • 在環境變量裡的path中增加maven/bin的目錄

④ 驗證:maven -v 查看maven版本

看到版本信息,恭喜你已經OK了。

Apache Maven 最全教程,看了就懂~

img

四、第一個maven

① 創建約定的目錄結構(maven工程必須按照約定的目錄結構創建)

根目錄:工程名 |---src:源碼 |---|---main:存放主程序 |---|---|---java:java源碼文件 |---|---|---resource:存放框架的配置文件 |---|---test:存放測試程序 |---pop.xml:maven的核心配置文件

我們按照上面的文件夾目錄結構手動創建一下,不用任何IDE環境(手動的其實最有助於我們理解maven)

Apache Maven 最全教程,看了就懂~

img

文件內容如下

在src/main/java/com/hzg/maven目錄下新建文件Hello.java,內容如下

package com.hzg.maven;
public class Hello {
  public String sayHello(String name){
    return "Hello "+name+"!";
  }
}

POM文件內容:

<?xml version="1.0" ?>
<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.hzg.maven</groupId>
<artifactId>Hello</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Hello</name>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

② 常用maven命令

  • mvn clean:清理
  • mvn compile:編譯主程序
  • mvn test-compile:編譯測試程序
  • mvn test:執行測試
  • mvn package:打包
  • mvn install:安裝

執行maven命令必須進入到pom.xml的目錄中進行執行

Apache Maven 最全教程,看了就懂~

進入到項目的pom.xml目錄之後,就可以執行啦。

1、運行 mvn compile

Apache Maven 最全教程,看了就懂~

img

OK,運行完畢,你在pom.xml配置的依賴的包已經導入到倉庫了,問題來了,倉庫默認的位置在哪?

**倉庫的默認位置:**c:\\Usrs[登錄當前系統的用戶名].m2\\repository

剛才執行完compile之後,之前的文件夾發生了變化

Apache Maven 最全教程,看了就懂~

img

我們發現Hello項目裡裡多了一個target文件夾。文件夾的內容為:

Apache Maven 最全教程,看了就懂~

img

發現target裡主要存放的就是編譯後的字節碼文件

2、運行mvn test-compile,target文件夾下面除了classes之外多了test-classes文件夾

3、運行mvn package,target文件夾下面又多了一個打好的jar包

Apache Maven 最全教程,看了就懂~

img

4、運行mvn clean,發現整個target文件夾都沒了。又回到了編譯之前我們手動創建的文件夾

Apache Maven 最全教程,看了就懂~

img

五、倉庫和座標

**① pom.xml:**Project Object Model 項目對象模型。它是maven的核心配置文件,所有的構建的配置都在這裡設置。

**② 座標:**使用下面的三個向量在倉庫中唯一的定位一個maven工程

Apache Maven 最全教程,看了就懂~

img

③ maven工程的座標與倉庫中路徑的關係:

Apache Maven 最全教程,看了就懂~

maven座標和倉庫對應的映射關係:[groupId][artifactId][version][artifactId]-[version].jar

去本地倉庫看一下此目錄:org\\springframework\\spring-core\\4.3.4.RELEASE\\spring-core-4.3.4.RELEASE.jar

果然是完全對應的(默認倉庫地址上面說過了哦,不要說不知道在哪,沒事下面我們再說一下倉庫)

④ 倉庫

倉庫的分類:

**1、本地倉庫:**當前電腦上的倉庫,路徑上已經說過了哦

2、遠程倉庫:

  • 私服:搭建在局域網中,一般公司都會有私服,私服一般使用nexus來搭建。具體搭建過程可以查詢其他資料
  • 中央倉庫:架設在Internet上,像剛才的springframework就是在中央倉庫上

六、依賴

① maven解析依賴信息時會到本地倉庫中取查找被依賴的jar包

  • 對於本地倉庫中沒有的會去中央倉庫去查找maven座標來獲取jar包,獲取到jar之後會下載到本地倉庫
  • 對於中央倉庫也找不到依賴的jar包的時候,就會編譯失敗了

② 如果依賴的是自己或者團隊開發的maven工程,需要先使用install命令把被依賴的maven工程的jar包導入到本地倉庫中

舉例:現在我再創建第二個maven工程HelloFriend,其中用到了第一個Hello工程裡類的sayHello(String name)方法。我們在給HelloFriend項目使用 mvn compile命令進行編譯的時候,會提示缺少依賴Hello的jar包。怎麼辦呢?

到第一個maven工程中執行 mvn install後,你再去看一下本地倉庫,你會發現有了Hello項目的jar包。一旦本地倉庫有了依賴的maven工程的jar包後,你再到HelloFriend項目中使用 mvn compile命令的時候,可以成功編譯

③ 依賴範圍

Apache Maven 最全教程,看了就懂~

scope就是依賴的範圍

**1、compile,**默認值,適用於所有階段(開發、測試、部署、運行),本jar會一直存在所有階段。

**2、provided,**只在開發、測試階段使用,目的是不讓Servlet容器和你本地倉庫的jar包衝突 。如servlet.jar。

**3、runtime,**只在運行時使用,如JDBC驅動,適用運行和測試階段。

**4、test,**只在測試時使用,用於編譯和運行測試代碼。不會隨項目發佈。

**5、system,**類似provided,需要顯式提供包含依賴的jar,Maven不會在Repository中查找它。

七、生命週期

Maven有三套相互獨立的生命週期,請注意這裡說的是“三套”,而且“相互獨立”,初學者容易將Maven的生命週期看成一個整體,其實不然。這三套生命週期分別是:

**① Clean Lifecycle 在進行真正的構建之前進行一些清理工作。**Clean生命週期一共包含了三個階段:

  • pre-clean 執行一些需要在clean之前完成的工作
  • clean 移除所有上一次構建生成的文件
  • post-clean 執行一些需要在clean之後立刻完成的工作

② Default Lifecycle 構建的核心部分,編譯,測試,打包,部署等等。

  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 複製並處理資源文件,至目標目錄,準備打包
  • compile 編譯項目的源代碼
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 複製並處理資源文件,至目標測試目錄
  • test-compile 編譯測試源代碼
  • process-test-classes
  • test 使用合適的單元測試框架運行測試。這些測試代碼不會被打包或部署
  • prepare-package
  • package 接受編譯好的代碼,打包成可發佈的格式,如 JAR
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 將包安裝至本地倉庫,以讓其它項目依賴。
  • deploy 將最終的包複製到遠程的倉庫,以讓其它開發人員與項目共享

那我們在Hello的項目中執行 mvn install 命令,通過日誌看看中間經歷了什麼?

Apache Maven 最全教程,看了就懂~

img

通過日誌我們發現,其實執行mvn install,其中已經執行了compile 和 test 。

**總結:**不論你要執行生命週期的哪一個階段,maven都是從這個生命週期的開始執行

**插件:**每個階段都有插件(plugin),看上面標紅的。插件的職責就是執行它對應的命令。

③ Site Lifecycle 生成項目報告,站點,發佈站點。

  • pre-site 執行一些需要在生成站點文檔之前完成的工作
  • site 生成項目的站點文檔
  • post-site 執行一些需要在生成站點文檔之後完成的工作,並且為部署做準備
  • site-deploy 將生成的站點文檔部署到特定的服務器上

八、Eclipse中使用maven

①、配置

選擇菜單windows-->preferences(參數)-->maven

選擇Installations(安裝),添加你自己下載並解壓好的maven目錄。並打上對勾 √,點擊Apply(應用)

Apache Maven 最全教程,看了就懂~

img

再選擇User Settings目錄,在User Settings中選擇Browse(瀏覽),選擇你自己maven裡的conf下的settings.xml文件。

Apache Maven 最全教程,看了就懂~

img

插一句:settings.xml這個配置文件,主要是配置你本地倉庫的路徑的。不想使用默認路徑,就打開文件,加上自己的路徑配置。

<localRepository>C:\\Program Files\\Java\\repository</localRepository>

到此,maven整個的設置就OK了。

② 使用Eclipse創建maven的Web工程

1、選擇菜單File-->new -->project,輸入maven

Apache Maven 最全教程,看了就懂~

img

選擇Maven Project,點擊Next

Apache Maven 最全教程,看了就懂~

img

點擊Next

Apache Maven 最全教程,看了就懂~

img

輸入webapp,選中第一項,點擊next

Apache Maven 最全教程,看了就懂~

img

項目就創建完成了,但是jdk的版本還有sevlet-api等jar包還沒有

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Java Build Path,把jdk的版本選擇你電腦上的正確的jdk版本。

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,選擇properties 並找到 Project Facets,版本選擇3.1,下面的java版本選擇1.8,點擊Apply

Apache Maven 最全教程,看了就懂~

img

選擇創建好的工程單擊右鍵,找到build path

Apache Maven 最全教程,看了就懂~

img

找到Libaries,添加Tomcat8.5的依賴庫,點擊OK

Apache Maven 最全教程,看了就懂~

img

九、maven工程的依賴高級特性

① 依賴的傳遞性

Apache Maven 最全教程,看了就懂~

WebMavenDemo項目依賴JavaMavenService1 JavaMavenService1項目依賴JavaMavenService2

pom.xml文件配置好依賴關係後,必須首先mvn install後,依賴的jar包才能使用。

  • WebMavenDemo的pom.xml文件想能編譯通過,JavaMavenService1必須mvn install
  • JavaMavenService的pom.xml文件想能編譯通過,JavaMavenService2必須mvn install

傳遞性:

Apache Maven 最全教程,看了就懂~

在Eclipse中,為JavaMavenService2中增加了一個spring-core.jar包後,會驚喜的發現依賴的兩個項目都自動的增加了這個jar包,這就是依賴的傳遞性。

注意:非compile範圍的依賴是不能傳遞的。

② 依賴版本的原則:

1、路徑最短者優先原則

Apache Maven 最全教程,看了就懂~

Service2的log4j的版本是1.2.7版本,Service1排除了此包的依賴,自己加了一個Log4j的1.2.9的版本,那麼WebMavenDemo項目遵守路徑最短優先原則,Log4j的版本和Sercive1的版本一致。

2、路徑相同先聲明優先原則

Apache Maven 最全教程,看了就懂~

這種場景依賴關係發生了變化,WebMavenDemo項目依賴Sercive1和Service2,它倆是同一個路徑,那麼誰在WebMavenDemo的pom.xml中先聲明的依賴就用誰的版本。

③ 統一管理依賴的版本:

Apache Maven 最全教程,看了就懂~

為了統一管理版本號,可以使用properties標籤,裡面可以自定義版本的標籤名。在使用的地方使用${自定義標籤名}

十、build配置

<build>
  <!-- 項目的名字 -->
  <finalName>WebMavenDemo</finalName>
  <!-- 描述項目中資源的位置 -->
  <resources>
    <!-- 自定義資源1 -->
    <resource>
      <!-- 資源目錄 -->
      <directory>src/main/java</directory>
      <!-- 包括哪些文件參與打包 -->
      <includes>
        <include>**/*.xml</include>
      </includes>
      <!-- 排除哪些文件不參與打包 -->
      <excludes>
        <exclude>**/*.txt</exclude>
          <exclude>**/*.doc</exclude>
      </excludes>
    </resource>
  </resources>
  <!-- 設置構建時候的插件 -->
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>2.1</version>
      <configuration>
        <!-- 源代碼編譯版本 -->
        <source>1.8</source>
        <!-- 目標平臺編譯版本 -->
        <target>1.8</target>
      </configuration>
    </plugin>
    <!-- 資源插件(資源的插件) -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-resources-plugin</artifactId>
      <version>2.1</version>
      <executions>
        <execution>
          <phase>compile</phase>
        </execution>
      </executions>
      <configuration>
        <encoding>UTF-8</encoding>
      </configuration>
    </plugin>
    <!-- war插件(將項目打成war包) -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-war-plugin</artifactId>
      <version>2.1</version>
      <configuration>
        <!-- war包名字 -->
        <warName>WebMavenDemo1</warName>
      </configuration>
    </plugin>
  </plugins>
</build>

配置好build後,執行mvn package之後,在maven工程指定的target目錄裡war包和文件都按照配置的生成了

Apache Maven 最全教程,看了就懂~

img

好了,maven的所有的內容就整理完了。

最後推薦個最新最全的maven依賴項版本查詢網站:

http://mvnrepository.com/

來源:https://dwz.cn/zWjb9sfU


:-D 搜索微信號(ID:芋道源碼),可以獲得各種 Java 源碼解析、原理講解、面試題、學習指南。

:-D 並且,回覆【書籍】後,可以領取筆者推薦的各種 Java 從入門到架構的 100 本書籍。

:-D 並且,回覆【技術群】後,可以加入專門討論 Java、後端、架構的技術群。

Apache Maven 最全教程,看了就懂~

來吧,騷年~

"

相關推薦

推薦中...