徹底理解maven

前言
最近解決jar包衝突問題時，很頭疼，發現自己對maven的理解太膚淺了，很多細節都一知半解，於是最近又學習了一把maven，總結如下：
基本概念
maven有兩個最基本的概念： pom和lifecycle， 這裏的pom不是maven構建過程中使用的pom文件，但他們之間有聯繫。 pom全稱爲Project Object Model, 簡單說就是要對構建的項目進行建模，將要構建的項目看成是一個對象Object，既然是一個對象，這個對象有哪些屬性呢？ 在maven中一個項目使用唯一的座標來表示，它包括groupId, artifactId， version， classifier, type（也叫packaging）這五部分，另外一個方面，一個項目肯定不是孤立存在的，可能會依賴其他項目，也就是說這個對象應該還有dependencies屬性，用PO表示構建對象，使用java代碼描述這個對象的話：

class PO{
    private String groupId;
    private String artifactId;
    private String version;
    private String classifier;
    private String type;
    private Set<PO> dependencies;
}

xml具有很強的表達能力，一個java對象可以用xml來描述，用xml表達上面這個java對象可以爲：

<PO>
    <groupId></groupId>
    <artifactId></artifactId>
    <version></version>
    <classifier><classifier>
    <type></type>
    <dependencies>
        <PO></PO>
        <PO></PO>
        ...
    </dependencies>
</PO>

這個是不是和pom.xml很類似？ 其實pom.xml就是PO對象的xml描述，上面這個PO定義還不完整，我們知道在java中類是可以繼承的，PO也有繼承關係，PO對象存在父類父類對象，用parent表示，它會繼承父類對象的所有屬性。 另一方面，一個項目可能根據不同職責分爲多個模塊（module），所有模塊其實也就是一個單獨的項目，只不過這些項目會使用其父對象的一些屬性來進行構建。我們將這些新的屬性加到PO的定義中去：

class PO{
    private String groupId;
    private String artifactId;
    private String version;
    private String classifier;
    private String type;
    private Set<PO> dependencies;
    private PO parent;
    private Set<PO> modules;
}

再將這個定義用XML語言表示一下：

<PO>
    <parent></parent>
    <groupId></groupId>
    <artifactId></artifactId>
    <version></version>
    <classifier><classifier>
    <type></type>
    <dependencies>
        <PO></PO>
        <PO></PO>
        ...
    </dependencies>
    <modules>
        ...
    </modules>
</PO>

是不是更像pom.xml了？ pom.xml其實就是對PO對象的xml描述！！
構建
項目的構建過程對應的是PO對象的build屬性，對應pom.xml中也就是<build>元素中的內容，這裏就有引入maven中第二個核心概念：Lifecycle。Lifecycle直譯過來就是生命週期。我們平常會接觸到哪些週期呢？一年中春夏秋冬就是一個週期。一個週期中可能分爲多個階段，比如這裏的春夏秋冬。在maven中一個構建過程就對應一個Lifecycle，這個Lifecycle也分爲多個階段，每個階段叫做phase。你可能會問，那這個Lifecycle中包含多少個phase呢？一個標準的構建Lifecycle包含了如下的phase:

validate： 用於驗證項目的有效性和其項目所需要的內容是否具備
initialize：初始化操作，比如創建一些構建所需要的目錄等。
generate-sources：用於生成一些源代碼，這些源代碼在compile phase中需要使用到
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：打包
pre-integration-test：集成測試前置操作   
integration-test：集成測試
post-integration-test：集成測試後置操作
install：將打包產物安裝到本地maven倉庫
deploy：將打包產物安裝到遠程倉庫

在maven中，你執行任何一個phase時，maven會將其之前的phase都執行。例如 mvn install，那麼maven會將deploy之外的所有phase按照他們出現的順序一次執行。
Lifecycle還牽涉到另外一個非常重要的概念：goal。注意上面Lifecycle的定義，也就是說maven爲程序的構建定義了一套規範流程：第一步需要validate，第二步需要initialize... ... compile，test，package，... ... install，deploy，但是並沒有定義每一個phase具體應該如何操作。這裏的phase的作用有點類似於Java語言中的接口，只協商了一個契約，但並沒有定義具體的動作。比如說compile這個phase定義了在構建流程中需要經過編譯這個階段，但沒有定義應該怎麼編譯（編譯的輸入是什麼？用什麼編譯javac/gcc?）。這裏具體的動作就是由goal來定義，一個goal在maven中就是一個Mojo（Maven old java object）。Mojo抽象類中定義了一個execute()方法，一個goal的具體動作就是在execute()方法中實現。實現的Mojo類應該放在哪裏呢？答案是maven plugin裏，所謂的plugin其實也就是一個maven項目，只不過這個項目會引用maven的一些API，plugin項目也具備maven座標。
在執行具體的構建時，我們需要爲lifecycle的每個phase都綁定一個goal，這樣才能夠在每個步驟執行一些具體的動作。比如在lifecycle中有個compile phase規定了構建的流程需要經過編譯這個步驟，而maven-compile-plugin這個plugin有個compile goal就是用javac來將源文件編譯爲class文件的，我們需要做的就是將compile這個phase和maven-compile-plugin中的compile這個goal進行綁定，這樣就可以實現Java源代碼的編譯了。那麼有人就會問，在哪裏綁定呢？答案是在pom.xml<build>元素中配置即可。例如:

<build>
<plugins>
  <plugin>
    <artifactId>maven-myquery-plugin</artifactId>
    <version>1.0</version>
    <executions>
      <execution>
        <id>execution1</id>
        <phase>test</phase>
        <configuration>
          <url>http://www.foo.com/query</url>
          <timeout>10</timeout>
          <options>
            <option>one</option>
            <option>two</option>
            <option>three</option>
          </options>
        </configuration>
        <goals>
          <goal>query</goal>
        </goals>
      </execution>
    </executions>
  </plugin>
</plugins>
</build>

就將maven-myquery-plugin中的query這個goal綁定到了test這個phase，後續在maven執行到test phase時就會執行query goal。還有有人可能會問，我都沒有指定Java源文件的位置，編譯啥？這就引出了maven的design principle。在maven中，有一個非常著名的principle就是convention over configuration（約定優於配置）。這一點和ant有非常大的區別，例如使用ant來進行編譯時，我們需要指定源文件的位置，輸出文件的位置，javac的位置，classpath... ...在maven中這些都是不需要，若沒有手動配置，maven默認從<項目根目錄>/src/main/java這個目錄去查找Java源文件，編譯後的class文件會保存在<項目根目錄>/target/classes目錄。在maven中，所有的PO都有一個根對象，就是Super POM。Super POM中定義了所有的默認的配置項,Super POM對應的pom.xml文件可以在maven安裝目錄下lib/maven-model-builder-3.0.3.jar:org/apache/maven/model/pom-4.0.0.xml中找到。用一張圖來表示maven Lifecycle，phase，goal之間的關係：

插件
上面我們提到，Maven 將所有項目的構建過程統一抽象成一套生命週期: 項目的清理、初始化、編譯、測試、打包、集成測試、驗證、部署和站點生成 … 幾乎所有項目的構建,都能映射到這一組生命週期上. 但生命週期是抽象的(Maven的生命週期本身是不做任何實際工作), 任務執行(如編譯源代碼)均交由插件完成. 其中每個構建步驟都可以綁定一個或多個插件的目標,而且Maven爲大多數構建步驟都編寫並綁定了默認插件.當用戶有特殊需要的時候, 也可以配置插件定製構建行爲, 甚至自己編寫插件.
再說生命週期
Maven 擁有三套相互獨立的生命週期: clean、default 和 site, 而每個生命週期包含一些phase階段, 階段是有順序的, 並且後面的階段依賴於前面的階段. 而三套生命週期相互之間卻並沒有前後依賴關係, 即調用site週期內的某個phase階段並不會對clean產生任何影響.
clean
clean生命週期的目的是清理項目:
執行如$ mvn clean;
default
default生命週期定義了真正構建時所需要執行的所有步驟:
執行如$ mvn clean install;
site
site生命週期的目的是建立和發佈項目站點: Maven能夠基於POM所包含的信息,自動生成一個友好的站點,方便團隊交流和發佈項目信息
執行命令如$ mvn clean deploy site-deploy;
這三個lifecycle定義了其包含的phase。maven會在這三個lifecycle中匹配對應的phase。當執行某個phase時，maven會依次執行在這個phase之前的phase。
插件
生命週期的階段phase與插件的目標goal相互綁定, 用以完成實際的構建任務. 而對於插件本身, 爲了能夠複用代碼,它往往能夠完成多個任務, 這些功能聚集在一個插件裏,每個功能就是一個目標.
如:$ mvn compiler:compile: 冒號前是插件前綴, 後面是該插件目標(即: maven-compiler-plugin的compile目標).
而該目標綁定了default生命週期的compile階段: 他們的綁定能夠實現項目編譯的目的.
內置綁定
爲了能讓用戶幾乎不用任何配置就能使用Maven構建項目, Maven 默認爲一些核心的生命週期綁定了插件目標, 當用戶通過命令調用生命週期階段時, 對應的插件目標就會執行相應的邏輯.

上圖只列出了打包方式爲jar且擁有插件綁定關係的階段（packaging 定義了Maven項目打包方式, 通常打包方式與所生成構件擴展名對應，有jar(默認)、war、pom、maven-plugin等., 其他打包類型生命週期的默認綁定關係可參考: Built-in Lifecycle Bindings、Plugin Bindings for default Lifecycle Reference.

自定義綁定
除了內置綁定以外, 用戶還能夠自定義將某個插件目標綁定到生命週期的某個階段上. 如創建項目的源碼包, maven-source-plugin插件的jar-no-fork目標能夠將項目的主代碼打包成jar文件, 可以將其綁定到verify階段上:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-source-plugin</artifactId>
            <version>3.0.0</version>
            <executions>
                <execution>
                    <id>attach-sources</id>
                    <phase>verify</phase>
                    <goals>
                        <goal>jar-no-fork</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

executions下每個execution子元素可以用來配置執行一個任務.
聚合與繼承
Maven的聚合特性(aggregation)能夠使項目的多個模塊聚合在一起構建, 而繼承特性(inheritance)能夠幫助抽取各模塊相同的依賴、插件等配置,在簡化模塊配置的同時, 保持各模塊一致.
模塊聚合
隨着項目越來越複雜(需要解決的問題越來越多、功能越來越重), 我們更傾向於將一個項目劃分幾個模塊並行開發, 如: 將feedcenter-push項目劃分爲client、core和web三個模塊, 而我們又想一次構建所有模塊, 而不是針對各模塊分別執行$ mvn命令. 於是就有了Maven的模塊聚合 -> 將feedcenter-push作爲聚合模塊將其他模塊聚集到一起構建:
聚合POM
聚合模塊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>com.vdian.feedcenter</groupId>
    <artifactId>feedcenter-push</artifactId>
    <packaging>pom</packaging>
    <version>1.0.0.SNAPSHOT</version>

    <modules>
        <module>feedcenter-push-client</module>
        <module>feedcenter-push-core</module>
        <module>feedcenter-push-web</module>
    </modules>

</project>

通過在一個打包方式爲pom的Maven項目中聲明任意數量的module以實現模塊聚合:

packaging: pom, 否則無法聚合構建.
modules: 實現聚合的核心,module值爲被聚合模塊相對於聚合POM的相對路徑, 每個被聚合模塊下還各自包含有pom.xml、src/main/java、src/test/java等內容, 離開聚合POM也能夠獨立構建

若<packaging>元素的內容是jar，那麼我們很好理解，也就是說這個項目最終會被打包成一個jar包，那<packaging>元素爲pom又是什麼意思呢？從字面上的意思來看，這個項目將打包成一個pom。我們不妨去maven倉庫裏去瞧瞧（前提是已經在項目下運行了mvn install命令）。可以發現這個文件其實和項目中的pom.xml是同一個文件，這樣做的目的是什麼呢？上面我們說過PO對象也是有繼承關係的，<packaging>pom</packaging>的作用就在這裏，這就是maven中project inheritance的概念。當實際執行maven命令的時候，會根據project inheritance關係對項目的pom.xml進行轉化，得到真正執行時所用到的pom.xml，即所謂的effective pom，因此可以得到一個結論：所有<packaging>元素爲pom的項目其實並不會輸出一個可供外部使用，類似於jar包的東西。這類項目的作用有兩個：
管理子項目

例如這裏的api和biz就是echo項目的兩個module。若沒有echo這個父項目，我們需要到api和biz兩個項目下分別執行mvn install命令才能完成整個構建過程，而有了echo這個父項目之後，我們只需在echo項目中執行mvn install即可，maven會解析pom.xml，發現該項目有api和biz兩個module，它會分別到這兩個項目下去執行mvn install命令。當module數量比較多的時候，能大大提高構建的效率。
管理繼承屬性

比如A和B都需要某個依賴，那麼在父類項目的pom.xml中聲明即可，因爲根據PO對象的繼承關係，A和B項目會繼承父類項目的依賴，這樣就可以減少一些重複的輸入。

effective pom包含了當前項目的PO對象，直到Super POM對應的PO對象中的信息。要看一個項目的effective pom，只需在項目中執行
mvn help:effective-pom
命令即可查看。這裏順帶說一句，有的同學可能不理解上面這個命令是什麼意思。maven命令的語法爲
mvn [options] [goal(s)] [phase(s)]
goal和phase。maven允許你執行一個或者多個goals/phases。很明顯這面的命令help:effective-pom並不是一個phase，那麼也就是說它是一個goal。對這個goal只不過是採用了縮寫的形式，其全稱是這樣的：

org.apache.maven.plugins:maven-help-plugin:2.2:effective-pom

以分號爲分隔符，包含了groupId，artifactId，version，goal四部分。若groupId爲org.apache.maven.plugins則可以使用上述的簡寫形式。也就是說

mvn help:effective-pom
mvn org.apache.maven.plugins:maven-help-plugin:2.2:effective-pom

是等價的，都是執行了maven-help-plugin這個plugin中的effective-pom這個goal。
我們知道一個plugin中可以包含多個goal，goal可以綁定到lifecycle中的某一個phase，這樣在執行這個phase的時候就會調用該goal。那那些沒有綁定到phase上的goal應該如何執行呢？這就是 mvn [goal(s)]
這裏的goal也就是官方文檔中所說的standalone goal，也就是說若一個plugin中的某個goal沒有和一個phase進行綁定，可以通過這種方式來執行。可能有的讀者使用過

mvn dependency:tree

這條命令，這裏其實就是單獨執行一個goal，這個goal的作用是分析該工程的依賴並使用樹狀的形式打印出來。這裏的dependency:tree其實是一個簡寫的形式，其完×××式是：

mvn org.apache.maven.plugins:maven-dependency-plugin:<版本號信息>:tree

也就是說單獨執行一個goal的方式是：
mvn <groupId>:<artifactId>:<version>:<goal>
每次都要敲這麼長一串命令是很繁瑣的，因此纔有了上述的簡寫的形式。maven規定了對於plugin的artifactId是如下兩種形式：
maven-{prefix}-maven-plugin
的可以使用簡寫的方式${prefix}來表示一個plugin.
模塊繼承
在面向對象中, 可以通過類繼承實現複用. 在Maven中同樣也可以創建POM的父子結構, 通過在父POM中聲明一些配置供子POM繼承來實現複用與消除重複
父pom
與聚合類似, 父POM的打包方式也是pom, 因此可以繼續複用聚合模塊的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>com.vdian.feedcenter</groupId>
    <artifactId>feedcenter-push</artifactId>
    <packaging>pom</packaging>
    <version>1.0.0.SNAPSHOT</version>

    <modules>
        <module>feedcenter-push-client</module>
        <module>feedcenter-push-core</module>
        <module>feedcenter-push-web</module>
    </modules>

    <properties>
        <finalName>feedcenter-push</finalName>
        <warName>${finalName}.war</warName>
        <spring.version>4.0.6.RELEASE</spring.version>
        <junit.version>4.12</junit.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <warExplodedDirectory>exploded/${warName}</warExplodedDirectory>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>

           <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-source-plugin</artifactId>
                    <version>3.0.0</version>
                    <executions>
                        <execution>
                            <id>attach-sources</id>
                            <phase>verify</phase>
                            <goals>
                                <goal>jar-no-fork</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

dependencyManagement: 能讓子POM繼承父POM的配置的同時, 又能夠保證子模塊的靈活性: 在父POMdependencyManagement元素配置的依賴聲明不會實際引入子模塊中, 但能夠約束子模塊dependencies下的依賴的使用(子模塊只需配置groupId與artifactId, 見下).
pluginManagement: 與dependencyManagement類似, 配置的插件不會造成實際插件的調用行爲, 只有當子POM中配置了相關plugin元素, 纔會影響實際的插件行爲.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <parent>
        <groupId>com.vdian.feedcenter</groupId>
        <artifactId>feedcenter-push</artifactId>
        <version>1.0.0.SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>feedcenter-push-client</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

元素繼承
可以看到, 子POM中並未定義模塊groupId與version, 這是因爲子POM默認會從父POM繼承瞭如下元素:

groupId、version
dependencies
developers and contributors
plugin lists (including reports)
plugin executions with matching ids
plugin configuration
resources 

因此所有的springframework都省去了version、junit還省去了scope, 而且插件還省去了executions與configuration配置, 因爲完整的聲明已經包含在父POM中.
優勢: 當依賴、插件的版本、配置等信息在父POM中聲明之後, 子模塊在使用時就無須聲明這些信息, 也就不會出現多個子模塊使用的依賴版本不一致的情況, 也就降低了依賴衝突的機率. 另外如果子模塊不顯式聲明依賴與插件的使用, 即使已經在父POM的dependencyManagement、pluginManagement中配置了, 也不會產生實際的效果.
推薦: 模塊繼承與模塊聚合同時進行,這意味着, 你可以爲你的所有模塊指定一個父工程, 同時父工程中可以指定其餘的Maven模塊作爲它的聚合模塊. 但需要遵循以下三條規則:

在所有子POM中指定它們的父POM;
將父POM的packaging值設爲pom;
在父POM中指定子模塊/子POM的目錄.

parent元素內還包含一個relativePath元素, 用於指定父POM的相對路徑, 默認../pom.xml
超級pom-約定優先於配置
任何一個Maven項目都隱式地繼承自超級POM, 因此超級POM的大量配置都會被所有的Maven項目繼承, 這些配置也成爲了Maven所提倡的約定.

<!-- START SNIPPET: superpom -->
<project>
  <modelVersion>4.0.0</modelVersion>

  <!-- 定義了中央倉庫以及插件倉庫, 均爲:https://repo.maven.apache.org/maven2 -->
  <repositories>
    <repository>
      <id>central</id>
      <name>Central Repository</name>
      <url>https://repo.maven.apache.org/maven2</url>
      <layout>default</layout>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>

  <pluginRepositories>
    <pluginRepository>
      <id>central</id>
      <name>Central Repository</name>
      <url>https://repo.maven.apache.org/maven2</url>
      <layout>default</layout>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
      <releases>
        <updatePolicy>never</updatePolicy>
      </releases>
    </pluginRepository>
  </pluginRepositories>

  <!-- 依次定義了各類代碼、資源、輸出目錄及最終構件名稱格式, 這就是Maven項目結構的約定 -->
  <build>
    <directory>${project.basedir}/target</directory>
    <outputDirectory>${project.build.directory}/classes</outputDirectory>
    <finalName>${project.artifactId}-${project.version}</finalName>
    <testOutputDirectory>${project.build.directory}/test-classes</testOutputDirectory>
    <sourceDirectory>${project.basedir}/src/main/java</sourceDirectory>
    <scriptSourceDirectory>${project.basedir}/src/main/scripts</scriptSourceDirectory>
    <testSourceDirectory>${project.basedir}/src/test/java</testSourceDirectory>
    <resources>
      <resource>
        <directory>${project.basedir}/src/main/resources</directory>
      </resource>
    </resources>
    <testResources>
      <testResource>
        <directory>${project.basedir}/src/test/resources</directory>
      </testResource>
    </testResources>

    <!-- 爲核心插件設定版本 -->
    <pluginManagement>
      <!-- NOTE: These plugins will be removed from future versions of the super POM -->
      <!-- They are kept for the moment as they are very unlikely to conflict with lifecycle mappings (MNG-4453) -->
      <plugins>
        <plugin>
          <artifactId>maven-antrun-plugin</artifactId>
          <version>1.3</version>
        </plugin>
        <plugin>
          <artifactId>maven-assembly-plugin</artifactId>
          <version>2.2-beta-5</version>
        </plugin>
        <plugin>
          <artifactId>maven-dependency-plugin</artifactId>
          <version>2.8</version>
        </plugin>
        <plugin>
          <artifactId>maven-release-plugin</artifactId>
          <version>2.3.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>

  <!-- 定義項目報告輸出路徑 -->
  <reporting>
    <outputDirectory>${project.build.directory}/site</outputDirectory>
  </reporting>

  <!-- 定義release-profile, 爲構件附上源碼與文檔 -->
  <profiles>
    <!-- NOTE: The release profile will be removed from future versions of the super POM -->
    <profile>
      <id>release-profile</id>

      <activation>
        <property>
          <name>performRelease</name>
          <value>true</value>
        </property>
      </activation>

      <build>
        <plugins>
          <plugin>
            <inherited>true</inherited>
            <artifactId>maven-source-plugin</artifactId>
            <executions>
              <execution>
                <id>attach-sources</id>
                <goals>
                  <goal>jar</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <inherited>true</inherited>
            <artifactId>maven-javadoc-plugin</artifactId>
            <executions>
              <execution>
                <id>attach-javadocs</id>
                <goals>
                  <goal>jar</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <inherited>true</inherited>
            <artifactId>maven-deploy-plugin</artifactId>
            <configuration>
              <updateReleaseInfo>true</updateReleaseInfo>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>

</project>
<!-- END SNIPPET: superpom -->

Maven Plugin 開發
詳細代碼在maven plugin demo

創建plugin項目

mvn archetype:generate 
    -DgroupId=com.fq.plugins -DartifactId=lc-maven-plugin -Dversion=0.0.1-SNAPSHOT
    -DarchetypeArtifactId=maven-archetype-plugin 
    -DinteractiveMode=false 
    -DarchetypeCatalog=internal

使用maven-archetype-plugin Archetype可以快速創建一個Maven插件項目。
pom.xml
插件本身也是Maven項目, 特殊之處在於packaging方式爲maven-plugin:

<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/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.fq.plugins</groupId>
    <artifactId>lc-maven-plugins</artifactId>
    <packaging>maven-plugin</packaging>
    <version>0.0.1-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>19.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.maven</groupId>
            <artifactId>maven-plugin-api</artifactId>
            <version>3.3.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.maven.plugin-tools</groupId>
            <artifactId>maven-plugin-annotations</artifactId>
            <version>3.3</version>
        </dependency>
    </dependencies>

</project>

maven-plugin 打包方式能控制Maven爲其在生命週期階段綁定插件處理的相關目標.

編寫目標Mojo

@Mojo(name = "lc", defaultPhase = LifecyclePhase.VERIFY)
public class LCMavenMojo extends AbstractMojo {

    private static final List<String> DEFAULT_FILES = Arrays.asList("java", "xml", "properties");

    @Parameter(defaultValue = "${project.basedir}", readonly = true)
    private File baseDir;

    @Parameter(defaultValue = "${project.build.sourceDirectory}", readonly = true)
    private File srcDir;

    @Parameter(defaultValue = "${project.build.testSourceDirectory}", readonly = true)
    private File testSrcDir;

    @Parameter(defaultValue = "${project.build.resources}", readonly = true)
    private List<Resource> resources;

    @Parameter(defaultValue = "${project.build.testResources}", readonly = true)
    private List<Resource> testResources;

    @Parameter(property = "lc.file.includes")
    private Set<String> includes = new HashSet<>();

    private Log logger = getLog();

    @Override
    public void execute() throws MojoExecutionException, MojoFailureException {
        if (includes.isEmpty()) {
            logger.debug("includes/lc.file.includes is empty!");
            includes.addAll(DEFAULT_FILES);
        }
        logger.info("includes: " + includes);

        try {
            long lines = 0;
            lines += countDir(srcDir);
            lines += countDir(testSrcDir);

            for (Resource resource : resources) {
                lines += countDir(new File(resource.getDirectory()));
            }
            for (Resource resource : testResources) {
                lines += countDir(new File(resource.getDirectory()));
            }

            logger.info("total lines: " + lines);
        } catch (IOException e) {
            logger.error("error: ", e);
            throw new MojoFailureException("execute failure: ", e);
        }
    }

    private LineProcessor<Long> lp = new LineProcessor<Long>() {

        private long line = 0;

        @Override
        public boolean processLine(String fileLine) throws IOException {
            if (!Strings.isNullOrEmpty(fileLine)) {
                ++this.line;
            }
            return true;
        }

        @Override
        public Long getResult() {
            long result = line;
            this.line = 0;
            return result;
        }
    };

    private long countDir(File directory) throws IOException {
        long lines = 0;
        if (directory.exists()) {
            Set<File> files = new HashSet<>();
            collectFiles(files, directory);

            for (File file : files) {
                lines += CharStreams.readLines(new FileReader(file), lp);
            }

            String path = directory.getAbsolutePath().substring(baseDir.getAbsolutePath().length());
            logger.info("path: " + path + ", file count: " + files.size() + ", total line: " + lines);
            logger.info("\t-> files: " + files.toString());
        }

        return lines;
    }

    private void collectFiles(Set<File> files, File file) {
        if (file.isFile()) {
            String fileName = file.getName();
            int index = fileName.lastIndexOf(".");
            if (index != -1 && includes.contains(fileName.substring(index + 1))) {
                files.add(file);
            }
        } else {
            File[] subFiles = file.listFiles();
            for (int i = 0; subFiles != null && i < subFiles.length; ++i) {
                collectFiles(files, subFiles[i]);
            }
        }
    }
}

@Parameter: 配置點, 提供Mojo的可配置參數. 大部分Maven插件及其目標都是可配置的, 通過配置點, 用戶可以自定義插件行爲

<plugin>
    <groupId>com.fq.plugins</groupId>
    <artifactId>lc-maven-plugins</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <executions>
        <execution>
            <id>lc</id>
            <phase>verify</phase>
            <goals>
                <goal>lc</goal>
            </goals>
            <configuration>
                <includes>
                    <include>java</include>
                    <include>lua</include>
                    <include>json</include>
                    <include>xml</include>
                    <include>properties</include>
                </includes>
            </configuration>
        </execution>
    </executions>
</plugin>

execute(): 實際插件功能;
異常: execute()方法可以拋出以下兩種異常:
MojoExecutionException: Maven執行目標遇到該異常會顯示 BUILD FAILURE 錯誤信息, 表示在運行期間發生了預期的錯誤;
MojoFailureException: 表示運行期間遇到了未預期的錯誤, 顯示 BUILD ERROR 信息

測試&執行

通過mvn clean install將插件安裝到倉庫後, 就可將其配置到實際Maven項目中, 用於統計項目代碼了:

$ mvn com.fq.plugins:lc-maven-plugins:0.0.1-SNAPSHOT:lc 

你可能注意到爲了調用該插件的goal，我們需要給出該插件的所有座標信息，包裹groupId, artifactId，version號，你可能之前已經執行過"mvn eclipase:eclipase"或"mvn idea:idea"這樣簡潔的命令，讓我們也來將自己的插件調用變簡單一點。要通過簡單別名的方式調用Maven插件，我們需要做到以下兩點：

插件的artifactId應該遵循-maven-plugin或maven--plugin命名規則，對於本文中的插件，我們已經遵循了。
需要將插件的groupId放在Maven默認的插件搜尋範圍之內，默認情況下Maven只會在org.apache.maven.plugins和org.codehaus.mojo兩個groupId下搜索插件，要讓Maven同時搜索我們自己的groupId，我們需要在~/.m2/settings.xml中加入：

<pluginGroups>  
       <pluginGroup>com.fq.plugins</pluginGroup>  
</pluginGroups>

在達到以上兩點之後，我們便可以通過以下命令來調用自己的插件了：
mvn lc:lc

要在別的項目中應用插件也是簡單的，我們只需要在該項目的pom.xml文件中使用上面<plugin>標籤聲明該插件即可。