maven学习从0到创建一个maven项目(2)

maven 原型工程

第一篇中，主要是简单的介绍了一下maven，这一篇主要是围绕maven常用到的点进行，再就是用maven和eclipse来进行开发maven项目。

先从第一篇中的生成maven工程的那行maven命令说起:

mvn archetype:generate \
-DarchetypeGroupId=org.apache.maven.archetypes \
-DgroupId=com.maven.app \
-DartifactId=myapp

我把它生成的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/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion>
<groupId>com.maven.app</groupId>
<artifactId>myapp</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>myapp</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
validate
generate-sources
process-sources
generate-resources
process-resources
compile

pom.xml包含了这个工程的POM，即project object model,maven工程一切都是以project为单元进行工作的，pom.xml正是包含了这个工程的重要信息，这个pom.xml是最简单的POM，它包含了一个POM关键的的几个元素：project -----pom.xml的最顶层元素

modelVersion -------------------指示我们当前使用的POM的版本，一般不会变，如果有必要时才会改变

groupId----------------------------指组织的唯一标识，一般组织的简称什么的，是关键的元素,在我们生成工程的命令里可以看到，这个ID是我们自己取的，为的就是标识开发组织

artifactId-------------------标识我们工程的名字，将来会用到发行的包的最终名字的一部分,命令里我们给出的是"myapp"

packaging--------------说明要打包成什么类型的文件,有jar、war、ear等.

version-----------------版本的意思是由工程自动生成管理的，我们会看到SNAPSHOT的字样的时候，表示这个工程正在开发中

name---------------------表明工程要显示时用到的名字，在maven 生成文档的时候会用到

url-------------------------表明我们工程所在的site,生成文档时用

description-------------------工程的简要描述。

编译工程

mvn compile，命令十分简单，如上篇所说，却是经过了几个阶段，这篇我们不再细说，如果你是第一次使用maven，maven会从远程仓库下载jar包等需要的资源，可能会耗点时间，我们可以用mvn test来对工程中的测试类进行编译并进行执行，如果只是进行想进行编译的时候可以使用 ：

mvn test-compile

在对测试类进行单元测试的时候，maven也会下载一些相关的资源。

安装、文档

我们用mvn package 将工程打包之后，用mvn install就可以将打包的jar 包安装到本地的maven资源库中去，这样别人就可以pom.xml里进行配置后作用。

mvn idea和mvn eclipse

很多时候，我们都习惯了用idea 和eclipse来进行项目的开发，我们将maven转换成eclipse开发或者idea开发只需要执行以下命令：

mvn idea:idea 或者mvn eclipse:eclipse

这样就将工程转换成，我们可以将maven工程导入到eclipse里时行开发。

maven使用插件

很多时候，用maven时，我们也会用到很多的插件，比较jetty 插件，我们必须要让maven工程去识别它们，并自动管理它们，这样，我们需要在pom.xml里进行定义：

<!-- jetty插件 -->
<build>
<plugins>
<plugin>
<groupId>org.mortbay.jetty</groupId>
<artifactId>jetty-maven-plugin</artifactId>
<configuration>
<scanIntervalSeconds>10</scanIntervalSeconds>
<webApp>
<contextPath>/spsh</contextPath>
</webApp>
</configuration>
</plugin>
</plugins>

<finalName>spsh</finalName>
</build>

如代码中，plugin就是放置插件的地方，它们都放在build下边的plugins里,这样maven就会自动的对jetty进行管理了。

资源依赖

这里是体现maven优越的地方了，以前我们开发项目，都是手动的加入jar包，手动的解决jar包之间的依赖，而maven如今则替我们做了这一切，在maven的世界里，所有的jar包依赖都放在了里:

<dependencies>...</dependencies>

我们需要的依赖的jar包只需要在这里配置一下就可以,比如我配置了spring的jar如下:

<!-- spring4.1.4 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>3.1.4.RELEASE</version>
</dependency>

有的时候我们所依赖的jar包并不在本地，这个时候maven就会从远程的maven仓库进行下载:http://repo.maven.apache.org/maven2/，这个远程仓库的地址你也可以自己设置自己的仓库，在所有的依赖写完之后，maven会自动下载这些依赖jar所需要的其它的jar，不用我们手动解决了，可以说真的是大大的方便了我们的开发。

管理多个工程

maven可以同时管理多个工程，我们只需要加入一个父类的pom.xml，如我们有两个工程：project1,project2，每个工程里肯定有一个pom.xml吧，这样，我们在project1和project2同级的文件夹内建立这个父级别的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.maventest.app</groupId>
<artifactId>app</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>

<modules>
<module>project1</module>
<module>project2</module>
</modules>
</project>

然后在分别在project1和project2中的pom.xml文件里加上:

<parent>
<groupId>com.mycompany.app</groupId>
<artifactId>app</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>

这样就可以了。

以上就是mvn的基本的知识了，现在我要用maven来建立一个web 工程，并用到了jetty插件，spring的依赖等。

Eclipse中使用maven 插件工程

mvn 固定非常强大，可是直接拿来一个记事本来进行工程开发，写起代码来也不是那么的顺畅，eclipse 作为我们常的开发的IDE，当然很好的和maven结合在一起，不用不知道，用过才明白，原来，真的很值得用。

废话少说：打开eclipsewtp版，一般情况下，都会已经安装好了maven的eclipse插件。打开eclipse，新建一个工程:



点击"Next"进入下一步：选择默认的工作空间，点击“Next”，到下边的页面：



选择如图中选择的那个项目类型，Catalog代表的是maven内部原有的类型，在这里选择我们常用的webapp类型，点击"Next"，

在弹出的页面里，填写入我们的groupId为：com.spring.ts,artifactId为：spsh,点击“Finsih"， 这样，我们的maven web工程就建好了。

我们建好的工程结构是这样子的：



从图中可以看到，这是一个标准的maven工程的结构。

加入依赖

我们以测试spring官网的例子为主要目的，来完结这篇文章，我用到的是spring3.1.4，虽然spring现在已经到了4.0.1，可是好多特性是3.0以后才出来的，我选择3.1.4，算是比较靠近老版了，但老一点也有好处，就是它够稳定，又同时拥有了新的特性，由于这是一个web工程，要嘛和tomca联用，要嘛和jetty容器，这样，jetty我也没有怎么用过，所以这里就用eclipse的jetty插件，首先要安装jetty在eclipse中的插件，我们点击eclipse的help菜单中的eclipse
marketplace，在里边输入jetty,会有Run-Jetty-Run插件，安装它。

安装完成后在菜单中的Run里边进行配置运行，如图：



这样就配置好的eclipse的jetty插件,这节没有用，后来做到web开发就会用到了。

加入依赖

在pom.xml文件里加入我所需要的jar依赖说明，如：

<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.spring.ts</groupId>
<artifactId>spsh</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>spsh Maven Webapp</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>

<!-- spring4.1.4 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>3.1.4.RELEASE</version>
</dependency>

<!-- 运行spring需要的cglib -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>

<!-- asm工具类 -->
<dependency>
<groupId>asm</groupId>
<artifactId>asm-util</artifactId>
<version>2.1</version>
</dependency>

</dependencies>

<!-- jetty插件 -->
<build>
<plugins>
<plugin>
<groupId>org.mortbay.jetty</groupId>
<artifactId>jetty-maven-plugin</artifactId>
<configuration>
<scanIntervalSeconds>10</scanIntervalSeconds>
<webApp>
<contextPath>/spsh</contextPath>
</webApp>
</configuration>
</plugin>
</plugins>

<finalName>spsh</finalName>
</build>
</project>

里边加入了spring和 asm的jar，另外还加入了cglib的包，这个时候，maven会自动的将依赖的jar包加入到工程中来，如果没有自动引入，你需要右键“spsh"，点击"maven Dependencies"这个菜单，进行手动的将jar 引入到工程中来。

代码测试

建立hello包,写第一个接口，这里是spring官方的一些代码：

package hello;

public interface MessageService {

String getMessage();
}

package hello;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MessagePrinter {

@Autowired
private MessageService service;

public void printMessage() {
System.out.println(this.service.getMessage());
}
}

用@Componet对MessagePrinter进行注册，并将MessageService注入。

package hello;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages="hello")
public class Application {

public @Bean MessageService mockMessageService(){
return new MessageService() {
public String getMessage() {
return "hello world!";
}
};
}

public static void main(String[] args) {

ApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
MessagePrinter printer = context.getBean(MessagePrinter.class);
printer.printMessage();
}
}

在Application.java里进行测试，这个类是基于java配置的类，用于代替xml文件，@Bean一般与@Configuration联用，来对方法进行注解，好返回一个实体,其实也类似于xml中的<bean/>定义了,@ComponenScan须要加上至少一个包名，说明要在这个包和子包下边扫描所有@Component注解的类,说明一下， @Controllery就是另一种形式的@Component。

最终的入口程序里，用到了AnnotationConfigApplicationContext来完成对java配置类的所有注册。

以上就是整个工程的过程。

来解释为什么说maven帮我们完成了大部分的管理，在构建项目的过程中，我遇到了一个小麻烦，就是包冲突的问题，即两个不同的包可能都依赖asm-util,可是他们依赖的版本如果不同的话，maven是不识别的，这样就造成了包冲突。
不过一般的maven仓库应该都会有固定的jar引入，只要做好一个pom以后，在哪都可以用了，也即是:write once,run anywhere。

maven 很高深，还有待于细细研究，边走边学吧。