Maven 初学+http://mvnrepository.com/

maven是一款服务于java平台的自动化构建工具(项目管理工具)

构建:全方位、多角度、深层次地建立

项目构建是一个项目从：源代码、编译、测试、打包、部署、运行的过程

用来解决团队开发遇到的问题
如: 统一 jar包 统一配置文件,单元测试的代码位置即 目录结构的统一

传统的项目构建过程

1）在eclipse中创建一个java web工程
2）在工程中编写源代码及配置文件等
3）对源代码进行编译，java文件编译成class文件
4）执行Junit单元测试
5）将工程打成war包部署至tomcat运行

maven项目构建过程

maven将项目构建的过程进行标准化，每个阶段使用一个命令完成

优点:

一个命令完成构建、运行，方便快捷。
maven对每个构建阶段进行规范，非常有利于大型团队协作开发。

1.3 什么是依赖管理

什么是依赖？一个java项目可能要使用一些第三方的jar包才可以运行，那么我们说这个java项目依赖了这些第三方的jar包。

什么是依赖管理？就是对项目所有依赖的jar包进行规范化管理。

总结使用maven的好处

一步构建命令执行,标准化
依赖管理安全又方便
跨平台电脑手机都可用
团队开发有规程效率高,成本低大家都喜欢用它

核心文件pom.xml

<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.xrq.withmaven</groupId>
  <artifactId>withmaven</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <build/>
</project>

1、modelVersion

指定了当前Maven模型的版本号，对于Maven2和Maven3来说，它只能是4.0.0

2、groupId

顾名思义，这个应该是公司名或是组织名。一般来说groupId是由三个部分组成，每个部分之间以".“分隔，第一部分是项目用途，比如用于商业的就是"com”，用于非营利性组织的就　　是"org"；第二部分是公司名，如"tengxun"、“baidu”、“alibaba”；第三部分是你的项目名

3、artifactId

可以认为是Maven构建的项目名，比如你的项目中有子项目，就可以使用"项目名-子项目名"的命名方式

4、version

版本号，SNAPSHOT意为快照，说明该项目还在开发中，是不稳定的版本。在Maven中很重要的一点是，groupId、artifactId、version三个元素生成了一个Maven项目的基本坐标，这非常重要，我在使用和研究Maven的时候多次感受到了这点。

在上面的这些元素之外，还有一些元素，同样罗列一下：

1、packing

项目打包的类型，可以使jar、war、rar、ear、pom，默认是jar

2、dependencies和dependency

前者包含后者。前面说了，Maven的一个重要作用就是统一管理jar包，为了一个项目可以build或运行，项目中不可避免的，会依赖很多其他的jar包，在Maven中，这些依赖就被称为dependency。

本地仓库和远程仓库的概念 如下
* 本地仓库   
* 远程仓库
     * 中央仓库
     * 私服  //自己的架构包 放在上面
     * 其他公共库  //别人的

本地仓库执行maven命令时才创建

maven 本地储存的位置,有很多架构包

官方下载的本地仓库的配置在"%MAVEN_HOME%\conf\settings.xml"里面，找一下"localRepository"就可以了；

setting.xml:

改两个地方

确定本地仓库位置

<localRepository>E:\maven\repository</localRepository>

为了提高下载速度而配置的阿里云镜像

<mirrors>
    <mirror>
      <id>alimaven</id>
      <name>aliyun maven</name>
      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
      <mirrorOf>central</mirrorOf>        
    </mirror>
  </mirrors>

MyEclipse默认的本地仓库的地址在**"{user.home}/.m2/repository"路径下**，同样找一下"localRepository"就可以找到MyEclipse默认的本地仓库了。

安装配置环境

首先去Maven官网，下载Maven的包，地址为http://maven.apache.org/download.cgi，找到下面的部分，点击就可以下载

将maven解压到一个不含有中文和空格的目录中。

bin目录 mvn.bat （以run方式运行项目）、 mvnDebug.bat（以debug方式运行项目）
boot目录 maven运行需要类加载器
conf目录 settings.xml 整个maven工具核心配置文件
lib目录 maven运行依赖jar包
电脑上需安装java环境，安装JDK1.7 + 版本（将JAVA_HOME/bin 配置环境变量path ）
配置 MAVEN_HOME
%MAVEN_HOME%/bin 加入环境变量 path
mvn -v命令检查 maven是否安装成功

maven仓库的作用

本地仓库和远程仓库是这样的，Maven工程首先会从本地仓库中获取jar包，当无法获取指定jar包时，本地仓库会从远程仓库（中央仓库）中下载jar包，并放入本地仓库以备将来使用。

优先从本地仓库查找
默认本地仓库位置在 ${user.dir}/.m2/repository，$

远程仓库

如果本地需要插件或者jar包，本地仓库没有，默认去远程仓库下载。
远程仓库可以在互联网内也可以在局域网内。

中央仓库

在maven软件中内置一个远程仓库地址http://repo1.maven.org/maven2 ，它是中央仓库，服务于整个互联网，它是由Maven团队自己维护，里面存储了非常全的jar包，它包含了世界上大部分流行的开源项目构件。

定义maven坐标

每个maven工程都需要定义本工程的坐标，坐标是maven对jar包的身份定义，比如：入门程序的坐标定义如下：

<!--项目名称，定义为组织名+项目名，类似包名-->
<groupId>cn.atcast.maven</groupId>

<!-- 模块名称 -->
<artifactId>maven-first</artifactId>
<!-- 当前项目版本号，snapshot为快照版本即非正式版本，release为正式发布版本 -->
<version>0.0.1-SNAPSHOT</version>
<packaging > ：打包类型
	jar：执行package会打成jar包
	war：执行package会打成war包
	pom ：用于maven工程的继承，通常父工程设置为pom

第一个maven

需求

创建一个web工程，实现入门程序的功能。
1）添加index.jsp，输出hello world
2）添加一个servlet转发到jsp页面。

① 创建约定的目录结构（maven工程必须按照约定的目录结构创建）

根目录：工程名
|—src：源码
|—|---main:存放主程序
|—|---|—java：java源码文件
|—|---|—resource：存放框架的配置文件
|—|---test：存放测试程序
|—pop.xml：maven的核心配置文件
我们按照上面的文件夹目录结构手动创建一下，不用任何IDE环境（手动的其实最有助于我们理解maven）

出错:

项目的结构也不对检查配置和setting.xml 是否出错

pom.xml报错

缺少 web.xml----aa\src\main\webapp\WEB-INF

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
  </welcome-file-list>
    <servlet>
    <description></description>
    <display-name>HelloServlet</display-name>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>cn.atcast.web.HelloServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>HelloServlet</servlet-name>
    <url-pattern>/HelloServlet</url-pattern>
  </servlet-mapping>
   
</web-app>

NewFile.xml报错 (新建一个xml 显示123123)

解决:
1.

2.

3. pom.xml 包配置+ 添加servelt/jsp的包

<dependencies>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet.jsp</groupId>
			<artifactId>jsp-api</artifactId>
			<version>2.0</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.9</version>
			<scope>test</scope>
		</dependency>

	</dependencies>

案例二:

①、配置

选择菜单windows–>preferences（参数）–>maven

选择Installations（安装），添加你自己下载并解压好的maven目录。并打上对勾 √，点击Apply（应用）

再选择User Settings目录，在User Settings中选择Browse（浏览），选择你自己maven里的conf下的settings.xml文件。

插一句：settings.xml这个配置文件，主要是配置你本地仓库的路径的。不想使用默认路径，就打开文件，加上自己的路径配置。

**<localRepository>C:Program FilesJavarepository</localRepository>
到此，maven整个的设置就OK了。**

项目就创建完成后，但是jdk的版本还有sevlet-api等jar包还没有

选择创建好的工程单击右键，选择properties 并找到 Java Build Path，把jdk的版本选择你电脑上的正确的jdk版本。

选择创建好的工程单击右键，选择properties 并找到 Project Facets，版本选择3.1，下面的java版本选择1.8，点击Apply

选择创建好的工程单击右键，找到build path

找到Libaries，添加Tomcat8.5的依赖库，点击OK

错误解决

1.手动安装Eclipse maven-archetype-quickstart
下载
C:\Users\DELL
然后从CMD里手动安装。

mvn install:install-file -DgroupId=org.apache.maven.archetypes -DartifactId=maven-archetype-quickstart -Dversion=X.X -Dpackaging=jar -Dfile=maven-archetype-quickstart-1.1.jar

2

解决一:

解决二:

案例三(创建一个service)

我们在之前(案例一)的基础上在web.xml文件配置一下

    <servlet>
    <description></description>
    <display-name>HelloServlet</display-name>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>cn.atcast.web.HelloServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>HelloServlet</servlet-name>
    <url-pattern>/HelloServlet</url-pattern>
  </servlet-mapping>

Run As---->Maven build

POM文件内容：(重点)

定义:

pom: 项目对象模型 ,是一个 XML 文件包含了对象是使用maven来构建 ,每个项目只有一个pom.xml文件

概念:父POM 类似Object类

<?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>
   <url>http://maven.apache.org</url>

project:工程的根标签
modelVersion:pom模板版本
groupId:组织标识 (一般唯一)
artifactId:工程名称
packaging:打包方式:JAR ,WAR ,EAR 三种

//依赖配置信息
 <dependencies>
            <dependency>
                         <groupId>junit</groupId>
                         <artifactId>junit</artifactId>
                         <version>4.0</version>
                         <scope>test</scope>
            </dependency>
        </dependencies>
    </project>
<build>
    <finalName>WebMavenDem</finalName>
</build>
</project>

parnt 父项目的信息

modules 模块

properties 定义pom变量类似 int a;

dependencyManageMent 有多模块时,统一子项目使用依赖项的同一版本 ,同时有了父模块后 ,子模块就不会优先引用对应依赖 .同时修改时也只要改父类就可以了.

常用maven命令

执行maven命令必须进入到pom.xml的目录中进行执行

进入到项目的pom.xml目录之后，就可以执行啦。

1、运行 mvn compile

OK，运行完毕，你在pom.xml配置的依赖的包已经导入到仓库了，问题来了，仓库默认的位置在哪？

仓库的默认位置：c:Usrs[登录当前系统的用户名].m2repository

刚才执行完compile之后，之前的文件夹发生了变化

我们发现Hello项目里里多了一个target文件夹。文件夹的内容为：

发现target里主要存放的就是编译后的字节码文件

2、运行mvn test-compile，target文件夹下面除了classes之外多了test-classes文件夹

3、运行mvn package，target文件夹下面又多了一个打好的jar包

在这里插入图片描述
4、运行mvn clean，发现整个target文件夹都没了。又回到了编译之前我们手动创建的文件夹

五、仓库和坐标

① pom.xml：Project Object Model 项目对象模型。它是maven的核心配置文件，所有的构建的配置都在这里设置。

② 坐标：使用下面的三个向量在仓库中唯一的定位一个maven工程

< packaging > ：打包类型
jar：执行package会打成jar包
war：执行package会打成war包
pom ：用于maven工程的继承，通常父工程设置为pom

③ maven工程的坐标与仓库中路径的关系：

maven坐标和仓库对应的映射关系：[ groupId ] [ artifactId ][version][artifactId]-[version].jar

去本地仓库看一下此目录：orgspringframeworkspring-core4.3.4.RELEASEspring-core-4.3.4.RELEASE.jar
果然是完全对应的

<project > ：文件的根节点 .
<modelversion > ： pom.xml使用的对象模型版本
<groupId > ：项目名称，一般写项目的域名
<artifactId > ：模块名称，子项目名或模块名称
<version > ：产品的版本号 . 
<packaging > ：打包类型，一般有jar、war、pom 等 
<name > ：项目的显示名，常用于 Maven 生成的文档。  
<description > ：项目描述，常用于 Maven 生成的文档
<dependencies> ：项目依赖构件配置，配置项目依赖构件的坐标
<build> ：项目构建配置，配置编译、运行插件等。

六、依赖

① 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命令的时候，可以成功编译

③ 依赖范围

scope就是依赖的范围

七、生命周期

Maven有三套相互独立的生命周期，请注意这里说的是“三套”，而且“相互独立”，初学者容易将Maven的生命周期看成一个整体，其实不然。这三套生命周期分别是：

① Clean Lifecycle 在进行真正的构建之前进行一些清理工作。Clean生命周期一共包含了三个阶段：

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

② Default Lifecycle 构建的核心部分，编译，测试，打包，部署等等。

validate	验证工程是否正确(编译)
generate-sources
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
verify	运行所有检查,验证包是否有效
install	将包安装至本地仓库，以让其它项目依赖。
deploy	将最终的包复制到远程的仓库，以让其它开发人员与项目共享

那我们在Hello的项目中执行 mvn install 命令，通过日志看看中间经历了什么？

Maven 初学+http://mvnrepository.com/
通过日志我们发现，其实执行mvn install，其中已经执行了compile 和 test 。

总结：不论你要执行生命周期的哪一个阶段，maven都是从这个生命周期的开始执行
插件：每个阶段都有插件（plugin），看上面标红的。插件的职责就是执行它对应的命令。

③ Site Lifecycle 生成项目报告，站点，发布站点。

pre-site	执行一些需要在生成站点文档之前完成的工作
site	生成项目的站点文档
post-site	执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
site-deploy	将生成的站点文档部署到特定的服务器上

九、maven工程的依赖高级特性

① 依赖的传递性

WebMavenDemo项目依赖JavaMavenService1 JavaMavenService1项目依赖JavaMavenService2

pom.xml文件配置好依赖关系后，必须首先mvn install后，依赖的jar包才能使用。

WebMavenDemo的pom.xml文件想能编译通过，JavaMavenService1必须mvn install
JavaMavenService的pom.xml文件想能编译通过，JavaMavenService2必须mvn install
传递性：

在Eclipse中，为JavaMavenService2中增加了一个spring-core.jar包后，会惊喜的发现依赖的两个项目都自动的增加了这个jar包，这就是依赖的传递性。

注意：非compile范围的依赖是不能传递的。
② 依赖版本的原则：

1、路径最短者优先原则

Service2的log4j的版本是1.2.7版本，Service1排除了此包的依赖，自己加了一个Log4j的1.2.9的版本，那么WebMavenDemo项目遵守路径最短优先原则，Log4j的版本和Sercive1的版本一致。

2、路径相同先声明优先原则

这种场景依赖关系发生了变化，WebMavenDemo项目依赖Sercive1和Service2，它俩是同一个路径，那么谁在WebMavenDemo的pom.xml中先声明的依赖就用谁的版本。

③ 统一管理依赖的版本：

为了统一管理版本号，可以使用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私服

问题：项目组编写了一个通用的工具类，其它项目组将类拷贝过去使用，当工具类修改bug后通过邮件发送给各各项目组，这种分发机制不规范可能导致工具类版本不统一。

解决方案：项目组将写的工具类通过maven构建，打成jar，将jar包发布到公司的maven仓库中（私服），公司其它项目通过maven依赖管理从仓库自动下载jar包。

私服(用于jar的发布和下载)

公司在自己的局域网内搭建自己的远程仓库服务器，称为私服私服服务器即是公司内部的maven远程仓库，每个员工的电脑上安装maven软件并且连接私服服务器，员工将自己开发的项目打成jar并发布到私服服务器，其它项目组从私服服务器下载所依赖的构件（jar）。
私服还充当一个代理服务器，当私服上没有jar包会从互联网中央仓库自动下载

依赖版本冲突

依赖版本冲突：当一个项目依赖的构件比较多时，它们相互之前存在依赖，当你需要对依赖版本统一管理时如果让maven自动来处理可能并不能如你所愿，如下例子：
（传递依赖：当A 依赖B、B依赖C，在A中导入B后会自动导入C，C是A的传递依赖，如果C依赖D则D也可能是A的传递依赖。）

<!-- struts2-spring-plugin依赖spirng-beans-3.0.5 -->
  	<dependency>
  		<groupId>org.apache.struts</groupId>
  		<artifactId>struts2-spring-plugin</artifactId>
  		<version>2.3.24</version>
  	</dependency>
<!-- spring-context依赖spring-beans-4.2.4 -->
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-context</artifactId>
  		<version>4.2.4.RELEASE</version>
  	</dependency>

org.apache.struts依赖spirng-beans-3.0.5，spring-context依赖spring-beans-4.2.4，但是发现spirng-beans-3.0.5加入到工程中，而我们希望spring-beans-4.2.4加入工程。

依赖调解原则

maven自动按照下边的原则调解：

声明者优先原则
在pom文件定义依赖，先声明的依赖为准。

测试：
如果将上边struts-spring-plugins和spring-context顺序颠倒，系统将导入spring-beans-4.2.4。
分析：
由于spring-context在前边，以spring-context依赖的spring-beans-4.2.4为准，所以最终spring-beans-4.2.4添加到了工程中。

排除依赖

上边的问题也可以通过排除依赖方法辅助依赖调解，如下：
比如在依赖struts2-spring-plugin的设置中添加排除依赖，排除spring-beans，
下边的配置表示：依赖struts2-spring-plugin，但排除struts2-spring-plugin所依赖的

spring-beans。

<!-- struts2-spring-plugin依赖spirng-beans-3.0.5 -->
<dependency>
	<groupId>org.apache.struts</groupId>
	<artifactId>struts2-spring-plugin</artifactId>
	<version>2.3.24</version>
	<!-- 排除 spring-beans-->
	<exclusions>
		<exclusion>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
		</exclusion>
		<exclusion>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
		</exclusion>
	</exclusions>
</dependency>

锁定版本

面对众多的依赖，有一种方法不用考虑依赖路径、声明优化等因素可以采用直接锁定版本的方法确定依赖构件的版本，版本锁定后则不考虑依赖的声明顺序或依赖的路径，以锁定的版本的为准添加到工程中，此方法在企业开发中常用。
首先父工程中pom.xml文件添加
如下的配置是锁定了spring-beans和spring-context的版本：

最后推荐个最新最全的maven依赖项版本查询网站：

http://mvnrepository.com/

创建 maven maven-archetype-quickstart 项目抱错问题解决方法
Archetype，骨架的意思。
文章出处：http://m.blog.csdn.net/blog/FireOfStar/42526027
Archetype是什么？
简单的说，Archetype是Maven工程的模板工具包。一个Archetype定义了要做的相同类型事情的初始样式或模型。这个名称给我们提供来了一个一致的生成Maven工程的方式。Archetype会帮助作者给用户创建Maven工程模板，并给用户提供生成相关工程模板版本的参数化方法。
使用Archetype提供的好的方法，是开发者能够使用最佳实践来快速的构建和组织一致化的工程。在Maven工程中，我们努力使用Archetype来尽可能快的给用户提供示例工程，同时也会把Maven的最佳实践介绍给新的用户。一个新的用户可以使用工作中的Maven工作作为跳板来研究更过的Maven中功能。我们也可以使用Archetype的添加机制，这样就意味着允许我们抓取Archetype中项目片段，并把它们添加到既存的工程中。Maven网站的Archetype就是很好的例子。例如，你可以使用“quick start archetype”来生成一个工程，然后就可以通过其中既存的“site archetype”来快速的创建一个网址工程。你能够使用Archetype来做很多这样的事情。
在你的团队中可能想要标准化的J2EE开发，这需要你提供EJBs、或者是WARs、或者是Web services的原型。一旦在你团队资源库中创建和部署这些原型，它们就可以在你团队内共享使用。
如何使用Archetype
要基于Archetype来创建一个新的工程，需要像下面示例这样来调用：

mvn archetype:generate

已有的Archetypes

Archetype ID

说明

maven-archetype-archetype

一个样例原型

maven-archetype-j2ee-simple

简单的J2EE应用程序样例

maven-archetype-mojo

Maven插件样本的示例

maven-archetype-plugin

Maven插件样本

maven-archetype-plugin-site

Mave插件网站的样例

maven-archetype-portlet

JSR-268门户样例

maven-archetype-quickstart

Maven工程样例

maven-archetype-simple

一个简单的Maven工程

maven-archetype-site

Maven网站的样例，它演示了对诸如APT、XDoc和FML等文档类型的支持，并演示了如果把网站国际化（i18n）

maven-archetype-site-simple

Maven网站样例

maven-archetype-webapp

Maven的Webapp工程样例

常用Archetype
1，maven-archetype-quickstart
默认的Archetype,基本内容包括：
一个包含junit依赖声明的pom.xml
src/main/java主代码目录及一个名为App的类
src/test/java测试代码目录及一个名为AppTest的测试用例

2，maven-archetype-webapp
一个最简单的Maven war项目模板，当需要快速创建一个Web应用的时候可以使用它。生成的项目内容包括：
一个packaging为war且带有junit依赖声明的pom.xml
src/main/webapp/目录
src/main/webapp/index.jsp文件
src/main/webapp/WEB-INF/web.xml文件

pom.xml 配置文件如果第一次的话可以复制下来帮助你下载完整插件最后检查对不对标志(目录结构是否正确)

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.alipay.test</groupId>
  <artifactId>test</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>test</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.2</version>
    </dependency>

    <dependency>
      <groupId>com.alipay.sdk</groupId>
      <artifactId>alipay-sdk-java</artifactId>
      <version>3.0.0</version>
      <exclusions>
        <exclusion>
          <artifactId>commons-logging</artifactId>
          <groupId>commons-logging</groupId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>commons-lang</groupId>
      <artifactId>commons-lang</artifactId>
      <version>2.6</version>
    </dependency>
    <dependency>
      <groupId>commons-configuration</groupId>
      <artifactId>commons-configuration</artifactId>
      <version>1.10</version>
      <exclusions>
        <exclusion>
          <artifactId>commons-logging</artifactId>
          <groupId>commons-logging</groupId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>commons-codec</groupId>
      <artifactId>commons-codec</artifactId>
      <version>1.11</version>
    </dependency>
    <dependency>
      <groupId>com.google.zxing</groupId>
      <artifactId>core</artifactId>
      <version>3.2.1</version>
    </dependency>
    <dependency>
      <groupId>org.hamcrest</groupId>
      <artifactId>hamcrest-core</artifactId>
      <version>1.3</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.8.5</version>
    </dependency>


  </dependencies>

  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>