maven核心配置(就近原則/配置優先)

概要：

1. maven 基本概念
2. maven 核心配置

 

一、maven  安裝與核心概念

概要：

1. maven 安裝
2. maven 編譯(compile)
3. 執行測試用例(test)
4. maven 打包
5. maven  依懶管理

1、安裝：

1. 官網下載 Maven （http://maven.apache.org/download.cgi）
2. 解壓指定目錄
3. 配置環境變量MAVEN_HOME   PATH
4. 檢查安裝是否成功 （mvn -version）

maven 是什么？它的基本功能是什么？ 編譯、打包、測試、依賴管理直觀感受一下maven編譯打包的過程。

 

http://maven.apache.org/pom.html

2、maven 編譯

maven 編譯過程演示

l  創建maven項目。

l  創建src 文件

l  編寫 pom 文件

l  執行編譯命令

 

編寫pom 文件基礎配置

<project xmlns="http://maven.apache.org/POM/4.0.0"

  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0

                      http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

 

  <groupId>org.codehaus.mojo</groupId>

  <artifactId>my-project</artifactId>

  <version>1.0.SNAPSHOT</version>

</project>

 

#mvn 編譯命令

mvn compile

 

---------------------------

[INFO] No sources to compile

[INFO] ---------------------------------------------------------------

[INFO] BUILD SUCCESS

[INFO] ---------------------------------------------------------------

[INFO] Total time: 0.473 s

[INFO] Finished at: 2018-08-05T15:55:44+08:00

[INFO] Final Memory: 6M/153M

[INFO] ---------------------------------------------------------------

 

 

請注意，在上述配置和命令當中，我們並沒有指定源碼文件在哪里？最后編譯到哪里去？在這里

maven 采用了約定的方式從指項目結構中獲取源碼與資源文件進行編譯打包。

1. 主源碼文件：${project}/src/main/java
2. 主資源文件：${project}/src/main/resources
3. 測試源碼文件：${project}/src/test/java
4. 測試資源文件：${project}/src/test/resources

將java 文件移至 src/main/java 目錄，重新執行編譯.

mv src/hello.java /src/main/java/hello.java

mvn compile;

3、Maven打包

maven 打包演示

#mvn 打包命令

mvn package

4、maven 單元測試演示

l  編寫測試類

l  執行測試命令

 

 

 

編譯測試類

# 創建測試目錄

mkdir -p /src/test/java

# 編寫 測試類

vim TestHello.java

#測試類代碼------------------------

package com.test.tuling;

public class TestHello{

        public void sayHelloTest(){

                System.out.println("run test .....");

        }

}

執行測試指令:

#執行測試

mvn test

執行完指令發現沒有執行我們的測試方法，這是為何？原因在於maven 當中的測試類又做了約定，約定必須是Test開頭的類名與test 開頭的方法才會執行。

重新修改方法名后 在執行mvn test 即可正常執行。

package com.test.tuling;

public class TestHello{

        public void testsayHelloTest(){

                System.out.println("run test .....");

        }

}

 

通常測試我們是通過junit 來編譯測試用例，這時就就需添加junit 的依賴。

5、maven 依賴管理

l   在pom 文件中添加junit 依賴

l  修改測試類，加入junit 代碼

l  執行測試命令

加入依懶配置

<dependencies>

<dependency>

  <groupId>junit</groupId>

  <artifactId>junit</artifactId>

  <version>4.0</version>

  <scope>test</scope>

</dependency>

</dependencies>

 

修改測試類引入junit 類.

//引入junit 類

import org.junit.Assert;

import org.junit.Test;

Assert.assertEquals("","hi");

注意：當我們在classPath 當中加入 junit ，原來以test 開頭的方法不會被執行，必須加入 @Test注解才能被執行。

 

提問：

在剛才的演示過程當中 ，junit jar包在哪里？是怎么加入到classPath 當中去的？maven 是在執行test 命令的時間 動態從本地倉庫中去引入junit jar 包，如果找不到就會去遠程倉庫下載，然后在引入。

 

 

 

 

 

默認遠程倉庫：

默認遠程倉庫 maven central 其配置在 

maven-model-builder-3.2.1.jar\org\apache\maven\model\pom-4.0.0.xml 位置

本地倉庫位置：

本地倉庫位置默認在 ~/.m2/respository 下

要修改 ${M2_HOME}/conf/settings.xml  來指定倉庫目錄

<!-- 指定本地倉庫目錄-->

 <localRepository>G:\.m2\repository</localRepository>

 

maven 核心功能總結：

1. maven 核心作用是編譯、測試、打包。
2. 根目錄下的pom.xml 文件設置分組ID與artifactId。
3. maven 基於約定的方式從項目中獲取源碼與資源文件進行編譯打包。
4. 對於項目所依懶的組件與會本地倉庫引用，如果本地倉庫不存在則會從中央倉庫下載。

二、maven核心配置

概要：

1. 項目依懶(內部、外部)
2. 項目聚合與繼承
3. 項目構建配置

項目依懶

項目依賴是指maven 通過依賴傳播、依賴優先原則、可選依賴、排除依賴、依賴范圍等特性來管理項目ClassPath。

 

1、依賴傳播特性:

我們的項目通常需要依賴第三方組件，而第三方組件又會依賴其它組件遇到這種情況Maven會將依賴網絡中的所有節點都會加入ClassPath當中，這就是Maven的依賴傳播特性。

n  舉例演示Spring MVC的依賴網絡

<!-- 添加spring web mvc演示 -->

<dependency>

    <groupId>org.springframework</groupId>

    <artifactId>spring-webmvc</artifactId>

    <version>4.0.4.RELEASE</version>

</dependency>

 

在剛剛的演示當中，項目直接依賴了spring-webmvc 叫直接依賴，而對commons-logging 依賴是通過webmvc傳遞的所以叫間接依賴。

2、依賴優先原則

基於依賴傳播特性，導致整個依賴網絡會很復雜，難免會出現相同組件不同版本的情況。Maven此時會基於依賴優先原則選擇其中一個版本。

第一原則：最短路徑優先。

第二原則：相同路徑下配置在前的優先。

n  第一原則演示

<!-- 直接添加commons-logging -->

<dependency>

    <groupId>commons-logging</groupId>

    <artifactId>commons-logging</artifactId>

    <version>1.2</version>

</dependency>

上述例子中commons-logging 通過spring-webmvc 依賴了1.1.3，而項目中直接依賴了1.2，基於最短路徑原則項目最終引入的是1.2 版本。

n  第二原則演示：

步驟：

1. 添加一個新工程Project B
2. 配置Project B 依賴 spring-web.3.2.9.RELEASE
3. 當前工程直接依賴 Project B

 配置完之后，當前工程 project A 有兩條路徑可以依賴 spring-web,選擇哪一條 就取決於 對 webmvc 和 Project B的配置先后順序。

  Project A==> spring-webmvc.4.0.0.RELEASE ==> spring-web.4.0.0.RELEASE

  Project A==>   Project B 1.0.SNAPSHOT ==>spring-web.3.2.9.RELEASE

 

 

注意：在同一pom文件，第二原則不在適應。如下配置，最終引用的是1.2 版本，而不是配置在前面的1.1.1版本.

 <!--  在1.2 之前添加 commons-logging -->

<dependency>

    <groupId>commons-logging</groupId>

    <artifactId>commons-logging</artifactId>

    <version>1.1.1</version>

</dependency>

 

<dependency>

    <groupId>commons-logging</groupId>

    <artifactId>commons-logging</artifactId>

    <version>1.2</version>

</dependency>

3、可選依賴

可選依賴表示這個依賴不是必須的。通過在 <dependency> 添  <optional>true</optional> 表示，默認是不可選的。可選依賴不會被傳遞。

l  演示可選依賴的效果。

 

 

4、排除依賴

即排除指定的間接依賴。通過配置 <exclusions> 配置排除指定組件。

 

 

 

<!-- 排除指定項目 -->

<exclusions>

    <exclusion>

       <groupId>org.springframework</groupId>

       <artifactId>spring-web</artifactId>

    </exclusion>

</exclusions>

l  演示排除依賴

5、依賴范圍(SCOPE)

像junit 這個組件 我們只有在運行測試用例的時候去要用到，這就沒有必要在打包的時候把junit.jar 包過構建進去

可以通過Mave 的依賴范圍配置<scope>來達到這種目的。maven 總共支持以下四種依賴范圍：

compile(默認): 編譯范圍，編譯和打包都會依賴。

provided：提供范圍，編譯時依賴，但不會打包進去。如：servlet-api.jar 

 

 

runtime：運行時范圍，打包時依賴，編譯不會。如：mysql-connector-java.jar

test：測試范圍，編譯運行測試用例依賴，不會打包進去。如：junit.jar

system：表示由系統中CLASSPATH指定。編譯時依賴，不會打包進去。配合<systemPath> 一起使用。示例：java.home下的tool.jar

system 除了可以用於引入系統classpath 中包，也可以用於引入系統非maven  收錄的第三方Jar，做法是將第三方Jar放置在 項目的 lib 目錄下，然后配置 相對路徑，但因system 不會打包進去所以需要配合 maven-dependency-plugin 插件配合使用。當然推薦大家還是通過 將第三方Jar手動install 到倉庫。

 

<!-- system 的通常使用方式-->

<dependency>

          <groupId>com.sun</groupId>

          <artifactId>tools</artifactId>

          <version>${java.version}</version>

          <scope>system</scope>

          <optional>true</optional>

          <systemPath>${java.home}/../lib/tools.jar</systemPath>

</dependency>

 

<!-- system 另外使用方式 ,將工程內的jar直接引入 -->

<dependency>

    <groupId>jsr</groupId>

    <artifactId>jsr</artifactId>

    <version>3.5</version>

    <scope>system</scope>

    <optional>true</optional>

    <systemPath>${basedir}/lib/jsr305.jar</systemPath>

</dependency>

<!-- 通過插件 將system 的jar 打包進去。 -->

<plugin>

    <groupId>org.apache.maven.plugins</groupId>

    <artifactId>maven-dependency-plugin</artifactId>

    <version>2.10</version>

    <executions>

        <execution>

            <id>copy-dependencies</id>

            <phase>compile</phase>

            <goals>

                <goal>copy-dependencies</goal>

            </goals>

            <configuration>

<outputDirectory>${project.build.directory}/${project.build.finalName}/WEB-INF/lib</outputDirectory>

                <includeScope>system</includeScope>

                <excludeGroupIds>com.sun</excludeGroupIds>

            </configuration>

        </execution>

    </executions>

</plugin>

 

#手動加入本地倉庫

mvn install:install-file -Dfile=abc_client_v1.20.jar -DgroupId=tuling  -DartifactId=tuling-client -Dversion=1.20 -Dpackaging=jar

 

項目聚合與繼承

1、聚合

 是指將多個模塊整合在一起，統一構建，避免一個一個的構建。聚合需要個父工程，然后使用 <modules> 進行配置其中對應的是子工程的相對路徑

<modules>

    <module>tuling-client</module>

    <module>tuling-server</module>

</modules>

n  演示聚合的配置

 2、繼承

繼承是指子工程直接繼承父工程 當中的屬性、依賴、插件等配置，避免重復配置。

1. 屬性繼承：
2. 依賴繼承：
3. 插件繼承：

上面的三個配置子工程都可以進行重寫，重寫之后以子工程的為准。

 3、依賴管理

通過繼承的特性，子工程是可以間接依賴父工程的依賴，但多個子工程依賴有時並不一至，這時就可以在父工程中加入 <dependencyManagement> 聲明該功程需要的JAR包，然后在子工程中引入。

 

<！-- 父工程中聲明 junit 4.12 -->

<dependencyManagement>

    <dependencies>

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>4.12</version>

        </dependency>

    </dependencies>

</dependencyManagement>

<!-- 子工程中引入 -->

<dependency>

    <groupId>junit</groupId>

    <artifactId>junit</artifactId>

</dependency>

4、項目屬性：

通過 <properties> 配置 屬性參數，可以簡化配置。

<!-- 配置proName屬性 -->

<properties>

    <proName>ddd</proName>

</properties>

<!-- 引用方式 -->

${proName}

maven 默認的屬性

${basedir} 項目根目錄 

${version}表示項目版本; 

${project.basedir}同${basedir}; 

${project.version}表示項目版本,與${version}相同; 

${project.build.directory} 構建目錄，缺省為target 

${project.build.sourceEncoding}表示主源碼的編碼格式; 

${project.build.sourceDirectory}表示主源碼路徑; 

${project.build.finalName}表示輸出文件名稱; 

${project.build.outputDirectory} 構建過程輸出目錄，缺省為target/classes

 

項目構建配置

1. 構建資源配置
2. 編譯插件
3. profile 指定編譯環境

 

構建資源配置

基本配置示例：

<defaultGoal>package</defaultGoal>

<directory>${basedir}/target2</directory>

<finalName>${artifactId}-${version}</finalName>

說明：

defaultGoal，執行構建時默認的goal或phase，如jar:jar或者package等

directory，構建的結果所在的路徑，默認為${basedir}/target目錄

finalName，構建的最終結果的名字，該名字可能在其他plugin中被改變

 

 

<resources>  配置示例

<resources>

   <resource>

      <directory>src/main/java</directory>

      <includes>

         <include>**/*.MF</include>

         <include>**/*.XML</include>

      </includes>

      <filtering>true</filtering>

   </resource>

   <resource>

      <directory>src/main/resources</directory>

      <includes>

         <include>**/*</include>

         <include>*</include>

      </includes>

      <filtering>true</filtering>

   </resource>

  </resources>

說明：

l  resources，build過程中涉及的資源文件

¡  targetPath，資源文件的目標路徑

¡  directory，資源文件的路徑，默認位於${basedir}/src/main/resources/目錄下

¡  includes，一組文件名的匹配模式，被匹配的資源文件將被構建過程處理

¡  excludes，一組文件名的匹配模式，被匹配的資源文件將被構建過程忽略。同時被includes和excludes匹配的資源文件，將被忽略。

¡  filtering： 默認false ，true 表示 通過參數 對 資源文件中 的${key} 在編譯時進行動態變更。替換源可 緊 -Dkey 和pom 中的<properties> 值 或  <filters> 中指定的properties 文件。