原型（Archetype）是Maven的模板工具箱。利用原型，可以很容易的应用组织在软件实现方面的最佳实践，减轻搭建项目框架的负担。

原型机制支持“增量“方式，也就是说，你通过原型生成一个项目后，可以再次用另外一个原型来生成额外的内容到此项目中。这种增量机制允许将项目的不同方面/部分封装到多个原型中，增强可复用、可组合性。

从Maven原型创建项目，需要使用maven-archetype-plugin插件。

一般情况下Maven原型都存放在远程仓库中，Maven中心仓库默认可用，你也可以修改Maven的settings.xml添加别的原型仓库：

<repository>
  <id>archetype</id>
  <url>https://m2.gmem.cc/path/to/repo/</url>
</repository>

<!-- 如果需要身份验证 -->
<server>
  <id>archetype</id>
  <username>user.name</username>
  <password>s3cr3t</password>
</server>

交互式调用archetype:generate时，maven-archetype-plugin会提示你从某个仓库选择原型，输入对应的序号即可。

使用filter可以减少原型列表的长度：

mvn archetype:generate -Dfilter=org.apache:struts 

选择原型后，maven-archetype-plugin会提示你输入一系列属性的值，最终生成新项目。

生成项目时，你需要提供新项目的GAV、package，原型还可能规定了一系列其它必须属性，这些属性会用来：

1. 填充Velocity模板中的变量
2. 如果目录、文件名包含

   __property__

   ，则被替换为对应的属性值

3. __artifactId__

   被替换为项目的ArtifactId
4. 在多模块项目中，

   __rootArtifactId__

   被替换为根项目的ArtifactId

你可以从零开始，开发一个原型，也可以从现有的项目反向生成原型。

原型描述符用于存储原型的元数据，它存放在原型JAR的 META-INF/maven/archetype-metadata.xml中。下面是一个例子：

<archetype-descriptor xmlns="https://maven.apache.org/plugins/maven-archetype-plugin/archetype-descriptor/1.1.0" 
                      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="https://maven.apache.org/plugins/maven-archetype-plugin/archetype-descriptor/1.1.0 
                      http://maven.apache.org/xsd/archetype-descriptor-1.1.0.xsd"
  <!-- 原型的名称-->
          <!-- 是否偏原型 -->
  name=.. partial=.. >
  <!-- 用户必须提供的属性列表 -->
  <requiredProperties>
    <requiredProperty key=.. >
      <defaultValue/>
      <validationRegex/>
    </requiredProperty>
  </requiredProperties>
 
  <!-- 文件集定义 -->
  <fileSets>
    <!-- 文件集说明了在生成项目的过程中，如何使用原型JAR中的文件 -->
    <!-- filtered 此文件集是否可以被过滤，如果true，则意味着这些文件被用作Velocity模板。否则原样拷贝 -->
    <!-- packaged 此文件集是否应该被生成/拷贝到package属性所指定的目录层次中 -->
    <!-- encoding 文件的编码方式 -->
    <fileSet filtered=.. packaged=.. encoding=.. >
      <directory/> <!-- 此文件集位于的目录 -->
      <includes><include></include></includes>  <!-- 包含的文件列表，Ant语法 -->
      <excludes/> <!-- 排除的文件列表，Ant语法 -->
    </fileSet>
  </fileSets>
 
  <!-- 模块定义 -->
  <modules>
    <module id=.. dir=.. name=.. >
      <fileSets>
        <fileSet filtered=.. packaged=.. encoding=.. >
          <directory/>
          <includes/>
          <excludes/>
        </fileSet>
      </fileSets>
      <!-- 模块可以嵌套 -->
      <modules>
        <module>...recursion...<module>
      </modules>
    </module>
  </modules>
</archetype-descriptor> 

下面是原型描述符的最小化示例：

<?xml version="1.0" encoding="UTF-8"?>
<archetype-descriptor name="basic">
  <requiredProperties>
    <requiredProperty key="property-with-default">
      <defaultValue>default-value</defaultValue>
    </requiredProperty>
    <requiredProperty key="property-without-default"/>
  </requiredProperties>
  <fileSets>
    <fileSet filtered="true" packaged="true">
      <directory>src/main/java</directory>
      <includes>
        <include>**/*.java</include>
      </includes>
    </fileSet>
  </fileSets>
</archetype-descriptor>

本节我们演示一下，如何从一个现有的项目，反向生成原型。

首先创建一个空白的Maven项目：

mvn archetype:generate -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.0 \
    -DgroupId=cc.gmem.study.mvn -DartifactId=archetype-proto -DinteractiveMode=false

进入示例项目，生成原型：

cd JavaEE/projects/idea/archetype-study/archetype-proto/
mvn archetype:create-from-project

如果没有错误，生成的原型项目位于target/generated-sources/archetype目录：

.
└── archetype                                         # 原型项目的根目录
    ├── pom.xml                                       # 原型项目的POM
    ├── src
    │   ├── main
    │   │   └── resources
    │   │       ├── archetype-resources               # 原始项目的所有内容，亦即从此原型生成的项目的所有内容
    │   │       │   ├── __artifactId__.iml
    │   │       │   ├── .idea
    │   │       │   └── src
    │   │       │       └── main
    │   │       │           └── java
    │   │       │               └── App.java          # 注意包结构消失了
    │   │       │   └── pom.xml
    │   │       └── META-INF
    │   │           └── maven
    │   │               └── archetype-metadata.xml    # 原型元数据
    │   └── test
    │       └── resources
    │           └── projects
    │               └── basic
    │                   ├── archetype.properties      # 用于测试原型
    │                   └── goal.txt
    └── target

可以看到，上面的例子将原始项目的IDE元数据文件也放入到原型中了，这不是我们期望的，可以使用属性文件排除。

在原始项目中添加属性文件：

excludePatterns=.idea/**

然后重新生成原型：

mvn clean  archetype:create-from-project -Darchetype.properties=archetype.properties

可以看到.idea目录被排除掉了。

从上面的例子还可以看到，生成的原型项目中App.java的包消失了。

实际上消失的是包前缀，它的值等于传递给create-from-project的package属性，如果不传递，则使用原始项目的包前缀。

生成的原型元数据中有如下片段：

<fileSet filtered="true" packaged="true" encoding="UTF-8">
  <directory>src/main/java</directory>
  <includes>
    <include>**/*.java</include>
  </includes>
</fileSet>

其中package=true含义是，从原型生成项目时，archetype-resources/src/main/java中的内容会被包裹在$package指定的目录结构中。

在文件中添加一个配置：

application=App

它的含义是，搜索原始项目的路径、文件中的文本，将App都更换为Application变量。对于本示例项目来说，其效果是：

1. App.java的文件名替换为

   __application__.java

2. App.java中的类名被替换为

   ${application} 

这是一种简单粗暴的查找替换，使用时务必小心。 

仍然使用上个例子，首先，构建并安装原型：

mvn clean  archetype:create-from-project \
    -Darchetype.properties=archetype.properties -Darchetype.postPhase=install

本地原型目录会自动更新。

基于该原型创建一个新项目：

mvn archetype:generate -B -DarchetypeGroupId=cc.gmem.study.mvn \
    -DarchetypeArtifactId=archetype-proto-archetype -DarchetypeVersion=1.0-SNAPSHOT \
    -DgroupId=cc.gmem -DartifactId=project -Dversion=1.0-SNAPSHOT \
                              # 传递自定义属性
    -Dpackage=cc.gmem.project -Dapplication=ProjectApp

检查生成的项目， 可以看到目录结构如下：

.
└── project
    ├── archetype-metadata.yaml
    ├── pom.xml
    └── src
        └── main
            └── java
                └── cc
                    └── gmem
                        └── project
                            ├── ProjectApp.java
                            └── service
                                └── ProjectAppService.java 

要在Maven中使用原型来生成项目骨架，必须依赖于maven-archetype-plugin。此插件依赖Java 7+版本，主流IDE内置了该插件。

maven-archetype-plugin使用Velocity作为模板引擎。

这是Maven原型项目的packaging，这种打包方式的生命周期绑定以下目标

1. archetype:jar，绑定到package阶段，生成原型的JAR包
2. archetype:integration-test，绑定到integration-test阶段
3. archetype:update-local-catalog，绑定到install阶段，更新本地原型目录

从原型生成项目骨架：

1. 如果从原型创建新的Maven项目，则输出到名为项目artifactId的目录
2. 如果使用一个偏原型（partial archetype）更新已有项目，则输出到当前目录

用户需要从原型目录中选择一个原型，从远程仓库将原型拉取下来，然后生成项目。调用示例：

# -B表示批处理模式，等价于-DinteractiveMode=false
mvn archetype:generate -B -DarchetypeGroupId=org.apache.maven.archetypes \
    -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.1 \
    -DgroupId=com.company -DartifactId=project -Dversion=1.0-SNAPSHOT \
    -Dpackage=com.company.project

其中通过-D传递的，是目标的参数。

可用参数包括：

该目标用于从现有的项目（以下称原始项目）反向生成原型。它会读取项目中的源文件、资源文件，你通过.property指定的原型属性文件，并产生一个原型项目。原始项目中的文本文件会被转换为Velocity模板。

爬取文件系统中的Maven仓库，产生一个Maven原型目录文件。

The post Maven原型系统 appeared first on 绿色记忆.

<!-- 使用Log4J2-->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.8.2</version>
</dependency>
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.8.2</version>
</dependency>
<!-- 让commons logging使用Log4j2 -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-jcl</artifactId>
    <version>2.8.2</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.21</version>
</dependency>
<!-- 让Slf4j使用Log4j2 -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j-impl</artifactId>
    <version>2.8.2</version>
</dependency> 

<dependency>
    <groupId>axis</groupId>
    <artifactId>axis</artifactId>
    <version>1.4</version>
</dependency>
    <dependency>
    <groupId>axis</groupId>
    <artifactId>axis-jaxrpc</artifactId>
    <version>1.4</version>
</dependency>

<dependency>
  <groupId>org.apache.velocity</groupId>
  <artifactId>velocity</artifactId>
  <version>1.7</version>
</dependency>

<dependency>
    <groupId>javax.annotation</groupId>
    <artifactId>jsr250-api</artifactId>
    <version>1.0</version>
</dependency>
<dependency>
    <groupId>javax.inject</groupId>
    <artifactId>javax.inject</artifactId>
    <version>1</version>
</dependency>

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.0.4</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.0.4</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.0.4</version>
</dependency>

<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-rt-frontend-jaxws</artifactId>
    <version>2.5.0</version>
</dependency>
<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-rt-transports-http</artifactId>
    <version>2.5.0</version>
</dependency>
<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-rt-transports-http-jetty</artifactId>
    <version>2.5.0</version>
</dependency>
<dependency>
    <groupId>javax.xml.ws</groupId>
    <artifactId>jaxws-api</artifactId>
    <version>2.2.6</version>
</dependency>
<dependency>
    <groupId>javax.xml</groupId>
    <artifactId>jaxb-api</artifactId>
    <version>2.1</version>
</dependency>

<dependency>
    <groupId>org.apache.axis2</groupId>
    <artifactId>axis2-adb</artifactId>
    <version>1.6.2</version>
</dependency>
<dependency>
    <groupId>org.apache.axis2</groupId>
    <artifactId>axis2-transport-local</artifactId>
    <version>1.6.2</version>
</dependency>
<dependency>
    <groupId>org.apache.axis2</groupId>
    <artifactId>axis2-transport-http</artifactId>
    <version>1.6.2</version>
</dependency>

<dependency>
    <groupId>com.atomikos</groupId>
    <artifactId>transactions</artifactId>
    <version>3.8.0</version>
</dependency>
<dependency>
    <groupId>com.atomikos</groupId>
    <artifactId>transactions-api</artifactId>
    <version>3.8.0</version>
</dependency>
<dependency>
    <groupId>com.atomikos</groupId>
    <artifactId>transactions-hibernate3</artifactId>
    <version>3.8.0</version>
</dependency>
<dependency>
    <groupId>com.atomikos</groupId>
    <artifactId>transactions-jdbc</artifactId>
    <version>3.8.0</version>
</dependency>
<dependency>
    <groupId>com.atomikos</groupId>
    <artifactId>transactions-jms</artifactId>
    <version>3.8.0</version>
</dependency>
<dependency>
    <groupId>com.atomikos</groupId>
    <artifactId>transactions-jta</artifactId>
    <version>3.8.0</version>
</dependency>

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.1.6</version>
</dependency>

The post Maven依赖速查表 appeared first on 绿色记忆.

<dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-rt-transports-http</artifactId>
    <version>2.5.0</version>
    <exclusions>
        <exclusion>
            <!-- CXF对Spring-web的依赖被排除 -->
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<build>
    <directory>target</directory>
    <outputDirectory>target/classes</outputDirectory>
    <testOutputDirectory>target/test-classes</testOutputDirectory>
    <sourceDirectory>src/main/java</sourceDirectory>
    <testSourceDirectory>src/test/java</testSourceDirectory>
    <resources>
        <resource>
            <!-- 在这里可以指定多个资源文件目录 -->
            <directory>src/main/java</directory>
            <excludes>
                <!--注意该配置从本应当是源代码的目录中过滤掉Java文件，其他文件作为资源文件 -->
                <exclude>**/*.java</exclude>
            </excludes>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
        </resource>
    </resources>
    <testResources>
        <testResource>
            <directory>src/test/resources</directory>
        </testResource>
    </testResources>
</build>

<plugin>
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>build-helper-maven-plugin</artifactId>
  <version>1.7</version>
  <executions>
    <execution>
      <phase>generate-sources</phase>
      <goals>
        <goal>add-source</goal>
      </goals>
      <configuration>
        <sources>
          <source>src/birt/java</source>
          <source>src/cms/java</source>
        </sources>
      </configuration>
    </execution>
  </executions>
</plugin>

<build>
    <resources>
        <resource>
            <!-- 启用src/main/resources的资源过滤 -->
            <filtering>true</filtering>
            <directory>src/main/resources</directory>
            <excludes>
                <!-- 排除资源文件 -->
                <exclude>application-${environment}.properties</exclude>
            </excludes>
        </resource>
    </resources>
</build>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-eclipse-plugin</artifactId>
    <version>2.10</version>
    <configuration>
        <linkedResources>
            <linkedResource>
                <name>src/main/webapp</name>
                <type>2</type>
                <location>D:/www</location>
            </linkedResource>
        </linkedResources>
    </configuration>
</plugin>

<plugin>
    <artifactId>maven-source-plugin</artifactId>
    <version>2.2.1</version>
    <configuration>
        <attach>true</attach>
    </configuration>
    <executions>
        <execution>
            <phase>compile</phase>
            <goals>
                <goal>jar</goal>
            </goals>
        </execution>
    </executions>
</plugin>

<plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-javadoc-plugin</artifactId>
     <executions>
         <execution>
              <id>attach-javadocs</id>
               <goals>
                   <goal>jar</goal>
                </goals>
          </execution>
       </executions>
 </plugin>

<plugin>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.4</version>
    <configuration>
        <encoding>${project.build.sourceEncoding}</encoding>
        <source>1.5</source>
        <target>1.5</target>
        <debug>true</debug>
    </configuration>
</plugin>

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>aspectj-maven-plugin</artifactId>
    <version>1.4</version>
    <executions>
        <execution>
            <id>compile</id>
            <configuration>
                <XnoInline>true</XnoInline>
                <forceAjcCompile>true</forceAjcCompile>
                <showWeaveInfo>true</showWeaveInfo>
                <source>1.5</source>
                <target>1.5</target>
                <encoding>UTF-8</encoding>
                <verbose>true</verbose>
                <outxml>true</outxml>
                <aspectLibraries>
                    <aspectLibrary>
                        <!--下面的构件同时需要在dependency里面配置-->
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-aspects</artifactId>
                    </aspectLibrary>
                </aspectLibraries>
            </configuration>
            <goals>
                <goal>compile</goal>
                <goal>test-compile</goal>
            </goals>
        </execution>
    </executions>
</plugin>

<plugin>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.4</version>
    <configuration>
        <encoding>${project.build.sourceEncoding}</encoding>
    </configuration>
</plugin>
<plugin>
    <artifactId>maven-resources-plugin</artifactId>
    <version>2.6</version>
    <configuration>
        <encoding>${project.build.sourceEncoding}</encoding>
    </configuration>
</plugin>

<plugin>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>2.8</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>
                <outputDirectory>${project.build.directory}/lib</outputDirectory>
            </configuration>
        </execution>
    </executions>
</plugin> 

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.6</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>cc.gmem.common.Application</mainClass>
                    </manifest>
                </archive>
                <appendAssemblyId>true</appendAssemblyId>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
        </execution>
    </executions>
</plugin>

maven-shade-plugin也支持将依赖打包进JAR，这类似于maven-assembly-plugin。但是后者存在BUG，会导致Unable to locate Spring NamespaceHandler for XML schema namespace这样的错误。

除了打包指外，maven-shade-plugin还具有重命名（Shade）功能 —— 修改某些包名。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>3.1.1</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <!-- 禁止生成dependency-reduced-pom.xml -->
                <createDependencyReducedPom>false</createDependencyReducedPom>
                <transformers>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.handlers</resource>
                    </transformer>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.schemas</resource>
                    </transformer>
                </transformers>
                <filters>
                    <!-- 解决报错：Invalid signature file digest for Manifest main attributes -->
                    <filter>
                        <artifact>*:*</artifact>
                        <excludes>
                            <exclude>META-INF/*.SF</exclude>
                            <exclude>META-INF/*.DSA</exclude>
                            <exclude>META-INF/*.RSA</exclude>
                        </excludes>
                    </filter>
                </filters>
            </configuration>
        </execution>
    </executions>
</plugin>

#分类器打包命令示例
mvn clean jar -P jdk15

<!-- 引用带分类器的构件 -->
<dependency>
  <groupId>cc.gmem.tools</groupId>
  <artifactId>cmd-tools</artifactId>
  <version>1.0</version>
  <classifier>jdk15</classifier>
</dependency>

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <encoding>UTF-8</encoding>
                    <source>${jar.source}</source>
                    <target>${jar.target}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <!-- 执行mvn命令时，使用-P参数激活某个profile -->
    <profiles>
        <profile>
            <id>default</id>
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
            <properties>
                <jar.source>1.6</jar.source>
                <jar.target>1.6</jar.target>
            </properties>
        </profile>
        <profile>
            <id>jdk15</id>
            <build>
                <plugins>
                    <plugin>
                        <artifactId>maven-jar-plugin</artifactId>
                        <executions>
                            <execution>
                                <phase>package</phase>
                                <goals>
                                    <goal>jar</goal>
                                </goals>
                                <configuration>
                                    <classifier>jdk15</classifier>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
            <properties>
                <jar.source>1.5</jar.source>
                <jar.target>1.5</jar.target>
            </properties>
        </profile>
        <profile>
            <id>jdk14</id>
            <build>
                <plugins>
                    <plugin>
                        <artifactId>maven-jar-plugin</artifactId>
                        <executions>
                            <execution>
                                <phase>package</phase>
                                <goals>
                                    <goal>jar</goal>
                                </goals>
                                <configuration>
                                    <classifier>jdk14</classifier>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
            <properties>
                <jar.source>1.4</jar.source>
                <jar.target>1.4</jar.target>
            </properties>
        </profile>
    </profiles>
</project>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.15</version>
    <dependencies>
        <dependency>
            <groupId> org.apache.maven.surefire</groupId>
            <artifactId> surefire-junit47</artifactId>
            <version> 2.15</ version>
        </dependency>
    </dependencies>
    <configuration>
        <argLine> -Dfile.encoding=UTF-8</argLine>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.4</version>
    <configuration>
        <!-- 下面的配置参数导致所有Java类被打包到一个JAR文件，并嵌入在WEB-INF/LIB下 -->
        <archiveClasses>true</archiveClasses>
        <!-- 
        下面的配置参数导致所有Java类被导报到一个JAR文件，并作为额外的构件看待
        该构件的名称为[groupId].[artifactId].[version]-classes.jar
        其它项目可以通过分类器classes来引用此JAR:
             <groupId>myGroup</groupId>
             <artifactId>myArtifact</artifactId>
             <version>myVersion</myVersion>
             <classifier>classes</classifier>
        -->
        <attachClasses>true</attachClasses>
        <!-- 上述额外构件的分类器字段的名称，默认classes -->
        <classesClassifier>classes</classesClassifier>
    </configuration>
</plugin>

<dependencies>
    <dependency>
        <groupId>cc.gmem.secmon</groupId>
        <artifactId>map</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <type>war</type>
        <scope>runtime</scope>
        <!-- 以这种方式声明war依赖后，当前项目打包后，该war包的全部内容都会叠加进去-->
    </dependency>
</dependencies>
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.4</version>
    <configuration>
        <overlays>
            <!-- 使用下面的配置，可以指定war运行时依赖中，哪些内容需要被排除出去 -->
            <!--下面的构件同时需要在dependency里面配置-->
            <overlay>
                <groupId>cc.gmem.secmon</groupId>
                <artifactId>map</artifactId>
                <excludes>
                    <exclude>WEB-INF/lib/sshe-*.jar</exclude><!-- 通配单个目录或者文件的一部分 -->
                    <exclude>WEB-INF/classes/**/*.class</exclude> <!-- 双星号通配任意层目录 -->
                </excludes>
            </overlay>
            <overlay>
                <groupId>cc.gmem.secmon</groupId>
                <artifactId>intelli</artifactId>
                <excludes>
                    <exclude>WEB-INF/lib/comm-tools-*.jar</exclude>
                </excludes>
            </overlay>
        </overlays>
    </configuration>
</plugin>

<distributionManagement>
    <repository>
        <id>nexus</id>
        <url>http://192.168.0.200:8801/nexus/content/repositories/releases</url>
    </repository>
    <snapshotRepository>
        <id>nexus</id>
        <url>http://192.168.0.200:8801/nexus/content/repositories/snapshots</url>
    </snapshotRepository>
</distributionManagement>

注：在org.apache.maven.plugins:maven-deploy-plugin:2.8.2版本之后，不配置distributionManagement也可以mvn deploy，可以通过命令行指定远程仓库的信息。使用如下系统属性即可：

#            id::layout::url
-DaltReleaseDeploymentRepository=pa-releases::default::https://nexus.pacloud.io/repository/maven-releases/ 
-DaltSnapshotDeploymentRepository=pa-snapshots::default::https://nexus.pacloud.io/repository/maven-snapshots/

<plugin>
    <groupId>net.alchim31.maven</groupId>
    <artifactId>yuicompressor-maven-plugin</artifactId>
    <version>1.5.1</version>
    <executions>
        <execution>
            <phase>process-resources</phase><!-- 注意，该阶段在Emvn package -Pproclipse中会自动运行，一旦你保存源码，就会执行压缩 -->
            <goals>
                <goal>compress</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <nosuffix>true</nosuffix> <!-- 输出js是否不带-min.js后缀 -->
        <!-- 压缩文件存放目录 -->
        <webappDirectory>${project.build.directory}/compressed</webappDirectory>
        <jswarn>false</jswarn> <!-- 是否显示警告信息 -->
        <nocompress>false</nocompress><!-- 是否压缩 -->
        <nomunge>false</nomunge><!-- 是否进行代码混淆 -->
    </configuration>
</plugin>
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.4</version>
    <configuration>
        <webResources>
            <resource>
                <!-- 这里必须引用压缩文件存放目录 -->
                <directory>${project.build.directory}/compressed</directory>
            </resource>
        </webResources>
    </configuration>
</plugin>

上面的配置，在Eclipse中会导致每次保存JavaScript文件都执行压缩，这会影响性能，因此可以使用Maven的Profile机制，仅在打包时启用压缩，下面是一个例子：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-war-plugin</artifactId>
            <version>2.4</version>
            <configuration>
                <overlays>
                    <overlay>
                        <groupId>cc.gmem.study</groupId>
                        <artifactId>obfuscate-module</artifactId>
                        <excludes>
                            <exclude>WEB-INF/classes/**/*.class</exclude>
                        </excludes>
                    </overlay>
                </overlays>
            </configuration>
        </plugin>
    </plugins>
</build>
<profiles>
    <profile>
        <id>production</id>
        <properties>
            <yui.compressed.dir>${project.build.directory}/compressed</yui.compressed.dir>
        </properties>
        <build>
            <plugins>
                <plugin>
                    <groupId>net.alchim31.maven</groupId>
                    <artifactId>yuicompressor-maven-plugin</artifactId>
                    <version>1.5.1</version>
                    <executions>
                        <execution>
                            <phase>process-resources</phase>
                            <goals>
                                <goal>compress</goal>
                            </goals>
                        </execution>
                    </executions>
                    <configuration>
                        <nosuffix>true</nosuffix> <!-- 输出js是否不带-min.js后缀 -->
                        <!-- 压缩文件存放目录 -->
                        <webappDirectory>${yui.compressed.dir}</webappDirectory>
                        <jswarn>false</jswarn> <!-- 是否显示警告信息 -->
                        <nocompress>false</nocompress><!-- 是否压缩 -->
                        <nomunge>false</nomunge><!-- 是否进行代码混淆 -->
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>2.4</version>
                    <configuration>
                        <!-- overlays的配置会从默认Profile继承，不需要再次声明 -->
                        <webResources>
                            <resource>
                                <!-- 这里必须引用压缩文件存放目录 -->
                                <directory>${yui.compressed.dir}</directory>
                            </resource>
                        </webResources>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

<plugin>
    <groupId>com.github.wvengen</groupId>
    <artifactId>proguard-maven-plugin</artifactId>
    <version>2.0.8</version>
    <dependencies>
        <dependency>
            <groupId>net.sf.proguard</groupId>
            <artifactId>proguard-base</artifactId>
            <version>5.2</version>
            <scope>runtime</scope>
        </dependency>
    </dependencies>
    <executions>
        <execution>
            <!-- 注意，不会对maven-war-plugin通过overlay得到的类进行任何处理，此时war已经打包完毕 -->
            <phase>package</phase>
            <goals>
                <goal>proguard</goal>
            </goals>
            <configuration>
                <!-- 从文件读取ProGuard配置选项 -->
                <proguardInclude>${project.basedir}/.proguard</proguardInclude>
                <!-- 直接指定ProGuard配置选项 -->
                <options>
                    <option>-keep public class * { public protected *; }</option>
                    <option>-dontoptimize</option>
                </options>
                <!-- 
                    以下ProGuard选项自动设置：
                    -dontobfuscate，如果配置obfuscate
                    -verbose，如果以-X运行Maven
                -->
                
                <!-- JVM库一般不在Maven依赖列表中 -->
                <libs>
                    <lib>${java.home}/lib/rt.jar</lib>
                    <lib>${java.home}/lib/jsse.jar</lib>
                </libs>
                <!-- 是否把Maven依赖作为库看待，默认true -->
                <includeDependency>true</includeDependency>
                <!-- 当启用includeDependency时，进行细粒度的过滤控制 -->
                <exclusions>
                    <exclusion>
                        <groupId>javax.inject</groupId>
                        <artifactId>javax.inject</artifactId>
                    </exclusion>
                </exclusions>
                <!-- 执行代码混淆-->
                <obfuscate>true</obfuscate>
                
                <!-- START
                    下面的配置，将把编译阶段得出的classes拷贝daoclasses_proguard_base，
                    然后把daoclasses_proguard_base作为输入目录；把classes作为输出目录
                -->
                <!-- 输入文件设置为编译好的target/classes目录 -->
                <injar>classes</injar>
                <!-- 不匹配下面过滤器的文件，不会被处理，也不会进入classes -->
                <inFilter>!cc/gmem/study/obfuscate/keep/**</inFilter>
                <!-- END -->
                
                <!-- START 
                    如上配置，如果加上下面这行设置，则classes保持编译阶段的原样，
                    处理后的结果存放到processed-classes
                -->
                <outjar>processed-classes</outjar>
                <!-- END -->
                
            </configuration>
        </execution>
    </executions>
</plugin>

使用Spring、Hibernate的工程，混淆配置如下：

<execution>
    <phase>process-classes</phase>
    <goals>
        <goal>proguard</goal>
    </goals>
    <configuration>
        <injar>classes</injar>
        <options>
            <option>
                -libraryjars ${java.home}/lib/rt.jar
                -keep public class * { public protected *; }
                -keepparameternames  #例如SpringMVC，可能依赖于方法参数的名称
                -keepattributes Exceptions,InnerClasses,Signature,*Annotation*,EnclosingMethod
                -keepclassmembers class * implements java.io.Serializable {
                    static final long serialVersionUID;
                    private static final java.io.ObjectStreamField[] serialPersistentFields;
                    private void writeObject(java.io.ObjectOutputStream);
                    private void readObject(java.io.ObjectInputStream);
                    java.lang.Object writeReplace();
                    java.lang.Object readResolve();
                }
                -keepclassmembers class * {
                    @javax.annotation.Resource *;
                }
                -keepclassmembers class * {
                    @javax.inject.Inject *;
                }
                -keepclassmembers class * {
                    @org.springframework.beans.factory.annotation.Autowired *;
                }
            </option>
        </options>
    </configuration>
</execution>

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <version>2.0.0.RELEASE</version>
    <configuration>
        <!-- 指定入口点 -->
        <mainClass>com.dangdang.digital.spring.data.redis.Application</mainClass>
        <layout>JAR</layout>
        <!-- 将主资源文件目录加入到classpath中 -->
        <addResources>true</addResources>
    </configuration>
    <executions>
        <execution>
            <goals>
                <goal>repackage</goal>
            </goals>
        </execution>
    </executions>
</plugin>
<!--
    打自包含包
    mvn clean package -P boot
    运行程序
    mvn spring-boot:run -P boot
-->

<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>dockerfile-maven-plugin</artifactId>
    <version>1.4.7</version>
    <executions>
        <execution>
            <id>default</id>
            <goals>
                <goal>build</goal>
                <goal>push</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <!-- Docker上下文目录，寻找其中的Dockerfile文件，不支持非Dockerfile的文件名 -->
        <contextDirectory>.</contextDirectory>
        <!-- 打包的Docker镜像名称 -->
        <repository>docker.gmem.cc/prometheus/dubbo_exporter</repository>
        <tag>${project.version}</tag>
        <!-- 构建时参数，必须在Dockerfile中声明对应的ARG -->
        <buildArgs>
            <JAR_FILE>target/${project.build.finalName}.jar</JAR_FILE>
        </buildArgs>
    </configuration>
</plugin>

该插件支持打包、部署、删除，不支持和Chart仓库交互。 

<plugin>
    <groupId>org.microbean</groupId>
    <artifactId>helm-maven-plugin</artifactId>
    <version>2.8.2.1.1.1</version>
    <executions>
        <execution>
            <id>default</id>
            <phase>package</phase>
            <goals>
                <goal>package</goal>
            </goals>
            <configuration>
                <!-- Chart定义存在的目录 -->
                <chartContentsUri>file:${project.basedir}/.chart</chartContentsUri>
                <!-- 打包后的Chart存放位置 -->
                <chartTargetUri>file:${project.build.directory}/charts/${project.artifactId}.tgz</chartTargetUri>
            </configuration>
        </execution>
    </executions>
</plugin>

<plugin>
    <groupId>com.atlassian.maven.plugins</groupId>
    <artifactId>bash-maven-plugin</artifactId>
    <version>1.0-SNAPSHOT</version>
    <configuration>
        <script>
            helm delete dubbo-exporter --purge
            helm install target/charts/dubbo_exporter.tgz --name=dubbo-exporter
        </script>
    </configuration>
</plugin>

添加插件仓库：

<pluginRepository>
    <id>bintray</id>
    <name>Groovy Bintray</name>
    <url>https://dl.bintray.com/groovy/maven</url>
    <releases>
        <updatePolicy>never</updatePolicy>
    </releases>
    <snapshots>
        <enabled>false</enabled>
    </snapshots>
</pluginRepository>

 添加插件：

<plugin>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.8.1</version>
    <configuration>
        <compilerId>groovy-eclipse-compiler</compilerId>
    </configuration>
    <dependencies>
        <dependency>
            <groupId>org.codehaus.groovy</groupId>
            <artifactId>groovy-eclipse-compiler</artifactId>
            <version>3.3.0-01</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.groovy</groupId>
            <artifactId>groovy-eclipse-batch</artifactId>
            <version>2.5.6-01</version>
        </dependency>
    </dependencies>
</plugin>

Groovy的依赖仍然需要添加：

<dependency>
  <groupId>org.codehaus.groovy</groupId>
  <artifactId>groovy</artifactId>
  <classifier>indy</classifier>
  <version>2.5.6</version>
</dependency>

关于源码目录结构：

1. 默认情况下，可以把所有Groovy代码都放到src/main/java目录
2. 如果src/main/java下至少有一个文件，则可以将Groovy代码放到src/main/groovy目录 

The post Maven POM文件配置示例 appeared first on 绿色记忆.

1. 项目对象模型（Project Object Model,POM）：描述项目的基本信息：声明构件的坐标、如何进行构建、声明项目的依赖存放在项目根目录下的pom.xml中。POM包含了项目的一切元数据——具体IDE相关的元数据，例如.project、.classpth、.settings，均不再需要，IDE的Maven插件可以根据POM自动生成
2. 构件（Artifact）：每个项目都抽象为一个构件。多模块项目（父子项目）包含多个构件构件主要有三类：普通包、插件、原型
3. 坐标：每个构件使用坐标来唯一识别，坐标主要包括3个维：组标识（groupId）、构件标识（artifactId）、版本号（version），另外两个次要维度为：打包方式（packaging）和分类器（classifer）。构件的字符串表示通常为：groupId:artifactId:version。构件的文件命名格式：artifactId-version-classifer.packaging，例如spring-jdbc-3.0.6.RELEASE.jar
   开发中的版本，version往往有SNAPSHOT后缀，例如0.0.1-SNAPSHOT
   打包方式为可选字段，包括pom、jar、war、ear、maven-plugin、maven-archetype等，默认为jar
   分类器为可选字段，通常可用于区分构件对应的jdk版本
4. 依赖（Dependency）：描述当前构件的生命周期的某个范围（Scope）内依赖的其他构件，有效的范围取值包括：
   1. compile：默认值，适用于所有阶段，随项目发布
   2. provided：期望容器或者jdk提供的类，例如对servlet-api的依赖
   3. runtime：仅仅在运行时使用，例如具体的jdbc驱动，可用于单元测试
   4. test：仅仅在单元测试时使用
   5. system：不在Repository中查找，需要指定本地路径，一般不用
5. 传递性依赖（Transitive dependencies）：由于每个构件都可以依赖于其他构件，因此可以形成依赖的传递链
6. 可选依赖（optional）：标记为可选的依赖，不构成依赖传递链条
7. 插件（Plugin）：Maven本身是一个框架，一切具体的工作都由插件完成，每个插件包含多个目标。插件本身也是一种构件，存放于仓库（Repository）中，即用即下载
8. 目标（Goal）：目标是明确定义的工作单元，可以被Maven单独调用完成特定的操作，或者作为生命周期某阶段的一个步骤，与其他目标一起被调用。
   目标的字符串表示为：pluginId:goalId
9. Mojo：即“Maven plain Old Java Object”，就是插件的目标的另外一个称呼
10. Maven生命周期（Lifecycle）：生命周期是包含在一个项目构建中的一系列有序的阶段。Maven支持多种生命周期，包括清理生命周期、默认生命周期、站点生命周期。主要被使用的是默认生命周期
11. 阶段（Phase）：生命周期包含一系列的阶段（Phase），下图展示运行mvn clean install时，包含的阶段：
    对于不同项目类型，同一阶段的行为可以不同，例如，一般项目的package阶段是打jar包，web项目则是打war包。
    插件的目标可以附在特定Maven生命周期阶段上，并随着生命周期的推进而被调用。例如对于jar项目：jar:jar目标就默认附在package阶段， surefire:test则附在test阶段。位于后面的阶段被运行时，前置阶段自动被运行，例如对于

    mvn package

     命令，不仅仅运行打包阶段，编译、测试阶段都会执行（clean不会执行，因为clean不属于默认生命周期的组成部分）。如果某个阶段运行失败，后续默认阶段不会运行
12. 仓库（Repository）：首次添加依赖包，或者首次运行某个Maven命令（即调用插件），会看到控制台上显示正在下载各种组件，下载都是从仓库获得构件的。安装Maven时，仅安装2M左右的核心框架，所有构件（依赖包、插件），均在需要时到“仓库”下载。构件相对于仓库的根目录的文件路径的形式为：
    

    /groupId/artifactId/version/artifactId-version.packaging

     
    其中，如果groupId有点号，则分解为多级目录，例如：
    

    /cn/com/sparknet/hibernate-tools/0.0.1/hibernate-tools-0.0.1.jar

     
    构件所在目录，还包括构件的pom文件、构件源码文件、javadoc文件等内容
13. 本地仓库：本地仓库存放已经下载的构件，避免重复下载；也存放本地构建的构件默认位置为

    ~/.m2/repository

     
14. 索引：仓库，特别是中央仓库非常大，索引用于加快构件查询的速度。仓库的管理者（软件，例如nexus）负责生成和维护索引，使用者下载索引
15. 原型（Archtype）：原型是预定义的模板，可以用来生成项目的骨架。一般的，新建Maven项目均要指定其原型。原型也是构件的一种，可以自己开发原型，满足不同项目的需要
16. 构件版本的命名规则：主版本、次版本、增量版本之间使用点号.间隔，如果有里程碑版本号，则与前者使用-间隔。例如：

    1.1.1-beta-1

     
    主版本，一般表示重大架构的变更，比如Spring2与Spring3
    次版本，表示大范围功能的增加和变化，比如Spring2.5比2.0增加注解功能
    增量版本，一般表示重大缺陷的修复
    里程碑版本，一般表示一个里程碑，比如alpha、beta等
    通常增量版本、里程碑版本是可选的
17. 快照（SNAPSHOT）版本：是一种特殊的里程碑版本，表示开发的最新状态，快照版本不指向一个特定的构件，而是指向其最新发布的引用。在仓库中，快照版本具有特殊的命名规则，例如：

    mom-tools-0.0.1-20111028.003655-3.jar

     表示mom-tools构件的0.0.1的快照版本，此版本在2011年10月28日发布，是0.01快照的第3次发布。如果快照仓库的updatePolicy设置为always，那么每次构建都会自动从快照仓库下载最新的发布。使用

    mvn -U

     参数，也可以强制从仓库下载最新发布

下面是一个简单的示例：

<settings>
    <localRepository>D:\JavaEE\maven\maven_repository</localRepository>
    <pluginGroups></pluginGroups>
    <offline>false</offline>
    <servers>
        <server>
            <id>spkntNexus</id>
            <username>wangzhen</username>
            <password>lavender</password>
        </server>
    </servers>
    <proxies /><mirrors />
    <profiles>
        <profile>
            <id>spkntDev</id>
            <activation>
                <activeByDefault>false</activeByDefault>
                <jdk>1.5</jdk>
                <os><name>Windows XP</name></os>
            </activation>
            <repositories>
                <repository>
                    <id>nexus</id>
                    <url>http://192.168.1.15:28080/nexus/content/groups/public/</url>
                    <releases><enabled>true</enabled></releases>
                    <snapshots><enabled>true</enabled></snapshots>
                </repository>
            </repositories>
            <pluginRepositories></pluginRepositories>
        </profile>
    </profiles>
    <activeProfiles>
        <activeProfile>spkntDev</activeProfile>
    </activeProfiles>
</settings>

各元素说明如下：

1. settings是固定的根元素
2. localRepository指定本地仓库的文件系统路径
3. pluginGroups 使用某插件时，如果不指定groupId，使用此元素下面定义的值
4. proxies 联网时的代理设置
5. servers 服务器设置，主要是用户名密码，与pom的distributionManagement配合使用，可完成构件的远程发布
6. mirrors 为某些仓库配置镜像
7. profiles 包含可选参数的配置，通过激活/禁用特定的profile，灵活的切换配置
8. profile/activation 设置profile自动激活规则，比如运行于WindowsXp则激活
9. profile/repositories 定义远程仓库
10. profile/pluginRepositories 定义远程插件仓库
11. activeProfiles 设置启用的profile

下面是一个简单的示例：

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>sparknet.training</groupId>
    <artifactId>mockito</artifactId>
    <version>0.0.1</version>
    <packaging>jar</packaging>
    <name>mockito</name>
    <parent>mockito-parent</parent>
    <modules/>
    <properties>
        <spring-version>3.0.6</spring-version>
    </properties>
    <dependencies></dependencies>
    <build>
        <directory/>
        <sourceDirectory/>
        <resources/>
        <plugins></plugins>
        <pluginManagement></pluginManagement>
    </build>
    <profiles></profiles>
    <distributionManagement/>
</project>

各元素说明如下：

1. project元素是pom固定的根元素
2. groupId、artifactId、version、packaging定义了构件坐标
3. parent、modules元素用于多maven模块的项目：parent在模块中使用，指向其父项目；modules在父项目中使用，声明其包含的模块列表
4. properties用于自定义属性，或者覆盖系统属性。自定义的属性可以在pom中以

   ${propertyName}

    的形式引用
5. dependencies用于管理当前构件的依赖
6. build 与构建过程相关：
   1. directory用于指定输出目录，类似有outputDirectory、testOutputDirectory
   2. sourceDirectory用于指定源码目录，默认src/main/java
   3. testSourceDirectory用于指定测试源码目录，默认src/test/java
   4. resources用于指定资源目录，默认src/main/resources。资源目录可以指定排除/包含规则，比如排除：**/*.java
   5. testResources用于指定测试资源目录，默认src/test/resources
   6. plugins用于指定/覆盖插件配置、定义新的插件调用，比如指定源码级别、指定源码编码方式。注意，如果profiles覆盖外面（即build/plugins/plugin/...）的某个插件的配置属性，必须明确声明新的属性值，否则，会从外面带入属性值
   7. pluginManagement 用于在父子项目中，指定默认的插件配置
   8. profiles用于定义可选的配置信息，可以定义上述大部分内容，通过

      mvn -P

       参数可以激活profile
   9. distributionManagement 定义构件的发布管理

目标都可以附着到其支持的Maven生命周期阶段，在插件配置中声明类似下面的片段：

<execution>
    <phase>package</phase>
    <goals>
        <goal>single</goal>
    </goals>
    ...

即可指定目标在哪个阶段执行，这样，早期阶段中的目标自然先执行。

如果两个目标在声明在同一阶段执行，那么，它们在POM中声明的顺序，决定了它们执行的顺序，先声明的先执行。

自己编写的插件，调用时需要提供完成的插件坐标：

# 插件坐标                                          # 目标名称
mvn cc.gmem.yun.maven.plugins:maven-archetype-plugin:create-from-project

同时，也需要在build/plugins中声明自己编写的插件版本。

下面的例子示意如何将create-from-project目标绑定到install阶段：

<build>
    <plugins>
        <plugin>
            <groupId>cc.gmem.yun.maven.plugins</groupId>
            <artifactId>maven-archetype-plugin</artifactId>
            <version>3.1.1</version>
            <configuration>
                <propertyFile>archetype.properties</propertyFile>
                <archetypePostPhase>install</archetypePostPhase>
            </configuration>
            <executions>
                <execution>
                    <phase>install</phase>
                    <goals>
                        <goal>create-from-project</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build> 

例如要分析构件spring-data-mongodb的冲突，执行：

#显示从解析后依赖树中忽略的冲突    # 包含在结果里的构件
                                                  # [groupId]:[artifactId]:[type]:[version]
                                                  # 支持通配符，:::*-SNAPSHOT 表示所有快照构件                   
mvn dependency:tree -Dverbose  -P dang -Dincludes=*:spring-data-mongodb

# 输出示例：
# [INFO] com.dangdang.digital.read:media-cms:war:1.0.0
# [INFO] +- com.dangdang.base:account-api:jar:1.1.0:compile
# [INFO] |  \- com.dangdang.base:framework:jar:1.0.5:compile
# [INFO] |     \- org.springframework:spring-data-mongodb:jar:1.0.0.M5:compile
# [INFO] \- org.springframework.data:spring-data-mongodb:jar:1.1.1.RELEASE:compile

# 可以看到通过account-api获得的传递依赖，和直接指定的1.1.1版本依赖冲突

传递性依赖导致的版本冲突，如下面的例子，出现cglib包的冲突，如何调解？

自动调解规则：

1. 最近路径优先原则，即从当前构件到冲突构件的路径长度短者优先
2. 最先声明原则，即在POM中声明顺序靠前者优先（2.0.9+）

手工调解：在POM中声明传递性依赖的排除。通常开源的工具包向后兼容（Backwards compatibility），我们倾向于排除低版本的依赖

可以使用镜像解决，把公司私有仓库设置为其它所有仓库的镜像：

<mirrors>
    <mirror>
        <!-- 创建一个名为maven的镜像，它是central仓库的镜像，对central的访问自动 转给它-->
        <id>maven</id>
        <mirrorOf>central</mirrorOf><!-- 可以使用通配符 * -->
        <url>http://repo1.maven.org/maven2</url>
    </mirror>
</mirrors>

设置环境变量：set MAVEN_OPTS=-Xms128m -Xmx512m
或者修改mvn.bat。
在Eclipse中运行时，可以修改Run Configurations，增加JVM参数

在Run Configuration中勾选“Resolve Workspace artifacts”

报错：Unable to update index for...解决步骤：

1. Nexus修复索引
2. Nexus配置计划任务，定期发布索引：
   
3. 客户端：删除%MAVEN_REPO_PATH%/.cache目录。重新尝试更新索引

先创建容器项目：创建简单项目，packaging设置为pom
容器项目点击右键：Maven - New Maven Module Project

修改Maven设置，添加速度较快的镜像：

<mirrors>
    <mirror>
        <id>google-maven-central</id>
        <name>Google Maven Central</name>
        <url>https://maven-central.storage.googleapis.com</url>
        <mirrorOf>central</mirrorOf>
    </mirror>
    <mirror>
        <id>oschina</id>
        <mirrorOf>central</mirrorOf>
        <name>OSChina</name>
        <url>http://maven.oschina.net/content/groups/public/</url>
    </mirror>
</mirrors>

如果你的机器无法连接到Maven仓库，可以使用网络代理：

<proxies>
    <proxy>
        <id>zircon</id>
        <active>true</active>
        <protocol>http</protocol>
        <host>127.0.0.1</host>
        <port>8087</port>
        <nonProxyHosts>127.0.0.1|192.168.0.*</nonProxyHosts>
    </proxy>
</proxies>

代理类型一般使用http，我尝试了socks5，发现无法连通，不知道什么原因。 

[ERROR] Missing message: configure.incompatibleComplianceForSource in: org.aspectj.ajdt.ajc.messages
<unknown source file>:<no line information>

升级AspectJ到1.8.8，aspectj-maven-plugin到1.8，然后修改后者的插件配置：

<configuration>
    <source>${java.version}</source>
    <target>${java.version}</target>
    <!-- 添加下面这个配置项 -->
    <complianceLevel>${java.version}</complianceLevel>
</configuration>

[ERROR] Failed to execute goal org.apache.maven.plugins:maven-war-plugin:2.1.1:war (default-war) on project ***: Failed to copy file for artifact [***:jar:0.0.1-SNAPSHOT:compile]: /home/alex/JavaEE/projects/idea/pems-trunk/comm-tools/target/classes (Is a directory) -> [Help 1]

maven-war-plugin版本过低，需要在POM中明确的声明使用新版：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.6</version>
</plugin>

无法找到依赖，会显示依赖的名字，其中的占位符${}应该已经被替换为实际值。

需要配置扩展，否则此属性不可用。

<build>
    <extensions>
        <extension>
            <groupId>kr.motd.maven</groupId>
            <artifactId>os-maven-plugin</artifactId>
            <version>1.6.1</version>
        </extension>
    </extensions>
</build>

mvn archetype:create 
  -DgroupId=? -DartifactId=? -Dpackaging=jar 
  -DarchetypeArtifactId=maven-archetype-webapp 

eclipse:eclipse生成Eclipse项目结构，包括.classpath等元数据，例如：

mvn eclipse:eclipse –Dwtpversion=1.0 

help:describe描述一个插件，打印其用法，例如：

mvn help:describe -Dplugin=help 

mvn archetype:generate -DarchetypeGroupId=org.codehaus.mojo.archetypes -DarchetypeArtifactId=pom-root
     -DarchetypeVersion=RELEASE 
# 根据提示输入组、构件标识符以及版本号
# 注意packaging要设置为pom，表示创建一个多模块容器工程

# 进入容器工程所在目录，创建模块
cd parent-artifact-name
mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-webapp
     -DarchetypeVersion=RELEASE  

mvn -X | grep 'Reading.*settings\s'
# [DEBUG] Reading global settings from /Users/Alex/JavaEE/maven/3.3.9/conf/settings.xml
# [DEBUG] Reading user settings from /Users/Alex/.m2/settings.xml

The post Maven知识集锦 appeared first on 绿色记忆.