maven学习

参考：http://www.sonatype.com/books/maven-book/reference_zh/public-book.html

1.建立一个工程用如下命令就可以：
mvn archetype:create -DgroupId=demo -DartifactId=simple -DpackageName=testpackage -Dversion=1.0
groupId为标识，作为本地命名空间的唯一名称；
artifactId为工程名，执行之后的文件夹名称为simple
packageName为包名，执行之后生成的目录名是C:\maven\simple1\src\main\java\testpackage

version是版本号，默认的是1.0-SNAPSHOT
packaging 打包的类型，默认是jar，war为一个web应用

2.创建web工程
mvn archetype:create -DgroupId=testweb -DartifactId=testweb -DpackageName=cn.canofy.com -DarchetypeArtifactId=maven-archetype-webapp
创建你的 web 应用程序项目，运行 mvn archetype:create ，加上参数 artifactId 和 groupId。 指定 archetypeArtifactId 为 maven-archetype-webapp。


3.mvn install
mvn clean install
这个命令用于编译，打包等执行动作，如果成功会在C:\maven\simple\target目录下生成simple-1.0-SNAPSHOT.jar文件

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.1.2</version>
</dependency>
<dependency>
<groupId>org.sonatype.mavenbook</groupId>
<artifactId>project-a</artifactId>
<version>1.0</version>
<exclusions>
<exclusion>
<groupId>org.sonatype.mavenbook</groupId>
<artifactId>project-b</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>

包依赖，groupId，artifactId，version和上面的意思一样，这里需要依赖的包基本上都已经定义好了，需要什么包可以在网上搜索一下相应的东西就行了～～～
scope则是依赖范围
exclusions 排除一个传递性依赖

compile（编译范围）

compile是默认的范围；如果没有提供一个范围，那该依赖的范围就是编译范围。编译范围依赖在所有的classpath中可用，同时它们也会被打包。
provided（已提供范围）

provided依赖只有在当JDK或者一个容器已提供该依赖之后才使用。例如，如果你开发了一个web应用，你可能在编译classpath中需要可用的Servlet API来编译一个servlet，但是你不会想要在打包好的WAR中包含这个Servlet API；这个Servlet API JAR由你的应用服务器或者servlet容器提供。已提供范围的依赖在编译classpath（不是运行时）可用。它们不是传递性的，也不会被打包。
runtime（运行时范围）

runtime依赖在运行和测试系统的时候需要，但在编译的时候不需要。比如，你可能在编译的时候只需要JDBC API JAR，而只有在运行的时候才需要JDBC驱动实现。
test（测试范围）

test范围依赖 在一般的 编译和运行时都不需要，它们只有在测试编译和测试运行阶段可用。测试范围依赖在之前的???中介绍过。
system（系统范围）

system范围依赖与provided类似，但是你必须显式的提供一个对于本地系统中JAR文件的路径。这么做是为了允许基于本地对象编译，而这些对象是系统类库的一部分。这样的构件应该是一直可用的，Maven也不会在仓库中去寻找它。如果你将一个依赖范围设置成系统范围，你必须同时提供一个systemPath元素。注意该范围是不推荐使用的（你应该一直尽量去从公共或定制的Maven仓库中引用依赖）。


4.mvn test
执行项目的单元测试


5.<project>
[...]
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<testFailureIgnore>true</testFailureIgnore>
</configuration>
</plugin>
</plugins>
</build>
[...]
</project>
忽略测试失败
通常，你会开发一个带有很多失败单元测试的系统。 如果你正在实践测试驱动开发(TDD)，你可能会使用测试失败来衡量你离项目完成有多远。 如果你有失败的单元测试，但你仍然希望产生构建输出，你就必须告诉 Maven 让它忽略测试失败。 当 Maven 遇到一个测试失败，它默认的行为是停止当前的构建。 如果你希望继续构建项目，即使 Surefire 插件遇到了失败的单元测试，你就需要设置 Surefire 的 testFailureIgnore 这个配置属性为 true。
也可以通过mven 参数来指定:mvn test -Dmaven.test.failure.ignore=true


6.<project>
[...]
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<skip>true</skip>
</configuration>
</plugin>
</plugins>
</build>
[...]
</project>
你可能想要配置 Maven 使其完全跳过单元测试。 可能你有一个很大的系统，单元测试需要花好多分钟来完成，而你不想在生成最终输出前等单元测试完成。 你可能正工作在一个遗留系统上面，这个系统有一系列的失败的单元测试，你可能仅仅想要生成一个 JAR 而不是去修复所有的单元测试。 Maven 提供了跳过单元测试的能力，只需要使用 Surefire 插件的 skip 参数。 在命令行，只要简单的给任何目标添加 maven.test.skip 属性就能跳过测试：mvn install -Dmaven.test.skip=true


7.
<project>
...
<properties>
<hibernate.annotations.version>3.3.0.ga</hibernate.annotations.version>
</properties>

<dependencyManagement>
...
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-annotations</artifactId>
<version>${hibernate.annotations.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-commons-annotations</artifactId>
<version>${hibernate.annotations.version}</version>
</dependency>
...
</dependencyManagement>
...
</project >
在多模块开发过程中, 针对依赖管理, 最重要的措施就是减少依赖配置的重复, 也就是将相同的依赖都提到parent层上, 而版本的重复可以通过定义property来处理


8.<project>
[...]
<build>
<finalName>simple-webapp</finalName>
<plugins>
<plugin>
<groupId>org.mortbay.jetty</groupId>
<artifactId>maven-jetty-plugin</artifactId>
</plugin>
</plugins>
</build>
[...]
</project>
配置 Jetty 插件.
在你已经编译，测试并且打包了你的 web 应用之后，你会想要将它部署到一个 servlet 容器中，然后测试一下由 Maven Archetype 插件创建的 index.jsp 。通常情况下，你需要下载 Jetty 或者 Apache Tomcat，解压分发包，复制你的应用程序 WAR 文件至 webapps/ 目录，然后启动你的容器。 现在，实现同样的目的，你不再需要做这些事情。 取而代之的是，你可以使用 Maven Jetty 插件在 Maven 中运行你的 web 应用。为此，你需要在项目的 pom.xml 中配置 Maven Jetty 插件.
最后运行mvn jetty:run命令启动Jetty


9.添加J2EE依赖
<project>
[...]
<dependencies>
[...]
<dependency>
<groupId>org.apache.geronimo.specs</groupId>
<artifactId>geronimo-servlet_2.4_spec</artifactId>
<version>1.1.1</version>
<scope>provided</scope>
</dependency>
</dependencies>
[...]
</project>
添加 Servlet 2.4 规格说明作为依赖

<project>
[...]
<dependencies>
[...]
<dependency>
<groupId>org.apache.geronimo.specs</groupId>
<artifactId>geronimo-jsp_2.0_spec</artifactId>
<version>1.1</version>
<scope>provided</scope>
</dependency>
</dependencies>
[...]
</project>
添加 JSP 2.0 规格说明作为依赖

src/main/java/org/sonatype/mavenbook/web 在这个目录下面写selvlet类


10.多模块企业级项目
子模块
<modules>
<module>simple-command</module>
<module>simple-model</module>
<module>simple-weather</module>
<module>simple-persist</module>
<module>simple-webapp</module>
</modules>
它引用了五个子模块：simple-command，simple-model，simple-weather，simple-persist，和simple-webapp。
<parent>
<groupId>org.sonatype.mavenbook.ch07</groupId>
<artifactId>simple-parent</artifactId>
<version>1.0</version>
</parent>
子模块中的定义
大部分复杂的Maven多模块项目倾向于在顶层POM中定义所有的版本。这个顶层POM就成了影响整个项目的更改焦点。
<project>
...
<properties>
<hibernate.annotations.version>3.3.0.ga</hibernate.annotations.version>
<hsqldb.version>1.8.0.7</hsqldb.version>
</properties>
...
</project>


需要使用Hibernate3插件构造数据库。
mvn hibernate3:hbm2ddl


mvn dependency:analyze
目标分析这个项目，查看是否有直接依赖，或者一些引用了但不是直接声明的依赖。
mvn dependency:tree
dependency:tree目标，该目标会列出项目中所有的直接和传递性依赖。


11.在使用多模块的时候, 父模块的打包类型必须为pom
子模块的pom不需要设置groupId和version, 它直接公用了父模块的groupId和version
当Maven执行一个带有子模块的项目的时候，Maven首先载入父POM，然后定位所有的子模块POM。Maven然后将所有这些项目的POM放入到一个称为Maven 反应堆（Reactor）的东西中，由它负责分析模块之间的依赖关系。这个反应堆处理组件的排序，以确保相互独立的模块能以适当的顺序被编译和安装。

12.POM最佳实践（特别重要的功能，只需在一处声明一组依赖，其它工程则只需调用这个pom就可以了，达到重用的功能）
如果你有一组逻辑上归类在一起的依赖。你可以创建一个打包方式为pom项目来将这些依赖归在一起。
例如，让我们假设你的应用程序使用Hibernate，一种流行的对象关系映射框架。所有使用Hibernate的项目可能同时依赖于Spring Framework和MySQL JDBC驱动。你可以创建一个特殊的POM，它除了声明一组通用依赖之外什么也不做。这样你就不需要在每个使用Hibernate，Spring和MySQL的项目中包含所有这些依赖。你可以创建一个项目叫做persistence-deps（持久化依赖的简称），然后让每个需要持久化的项目依赖于这个提供便利的项目。
在一个单独的POM项目中巩固依赖
<project>
<groupId>org.sonatype.mavenbook</groupId>
<artifactId>persistence-deps</artifactId>
<version>1.0</version>
<packaging>pom</packaging>
<dependencies>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate</artifactId>
<version>${hibernateVersion}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-annotations</artifactId>
<version>${hibernateAnnotationsVersion}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-hibernate3</artifactId>
<version>${springVersion}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysqlVersion}</version>
</dependency>
</dependencies>
<properties>
<mysqlVersion>(5.1,)</mysqlVersion>
<springVersion>(2.0.6,)</springVersion>
<hibernateVersion>3.2.5.ga</hibernateVersion>
<hibernateAnnotationsVersion>3.3.0.ga</hibernateAnnotationsVersion>
</properties>
</project>


声明一个对于POM的依赖
<project>
<description>This is a project requiring JDBC</description>
...
<dependencies>
...
<dependency>
<groupId>org.sonatype.mavenbook</groupId>
<artifactId>persistence-deps</artifactId>
<version>1.0</version>
<type>pom</type>
</dependency>
</dependencies>
</project>


13.安装 m2eclipse 插件
a.安装 Subclipse Subclipse 1.2: http://subclipse.tigris.org/update_1.2.x
b.安装 Mylyn Mylyn (Eclipse 3.3): http://download.eclipse.org/tools/mylyn/update/e3.3
Mylyn (Eclipse 3.4): http://download.eclipse.org/tools/mylyn/update/e3.4
c安装 AspectJ Tools Platform (AJDT) AJDT (Eclipse 3.3): http://download.eclipse.org/tools/ajdt/33/update
AJDT (Eclipse 3.4): http://download.eclipse.org/tools/ajdt/34/dev/update
d安装 Web Tools Platform (WTP) WTP: http://download.eclipse.org/webtools/updates/