Maven教程2：Maven项目构建过程练习

作者：孤傲苍狼 

 

 

上一篇只是简单介绍了一下maven入门的一些相关知识，这一篇主要是体验一下Maven高度自动化构建项目的过程

一、创建Maven项目

1.1、建立Hello项目

　　1、首先建立Hello项目，同时建立Maven约定的目录结构和pom.xml文件

　　　　Hello
　　　　　　| --src
　　　　　　| -----main
　　　　　　| ----------java
　　　　　　| ----------resources
　　　　　　| -----test
　　　　　　| ---------java
　　　　　　| ---------resources
　　　　　　| --pom.xml

　　

　　2、编辑项目Hello根目录下的pom.xml，添加如下的代码：

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

2. 2 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

3. 3<modelVersion>4.0.0</modelVersion>

4. 4<groupId>me.gacl.maven</groupId>

5. 5<artifactId>Hello</artifactId>

6. 6<version>0.0.1-SNAPSHOT</version>

7. 7<name>Hello</name>

8. 8

9. 9<!--添加依赖的jar包-->

10. 10<dependencies>

11. 11<!--项目要使用到junit的jar包，所以在这里添加junit的jar包的依赖-->

12. 12<dependency>

13. 13<groupId>junit</groupId>

14. 14<artifactId>junit</artifactId>

15. 15<version>4.9</version>

16. 16<scope>test</scope>

17. 17</dependency>

18. 18

19. 19</dependencies>

20. 20</project>

　　3、在src/main/java/me/gacl/maven目录下新建文件Hello.java

　　

　　Hello.java的代码如下：

1. 1package me.gacl.maven;

2. 2

3. 3publicclassHello{

4. 4

5. 5publicString sayHello(String name){

6. 6return"Hello "+name+"!";

7. 7}

8. 8}

　　4、在/src/test/java/me/gacl/maven目录下新建测试文件HelloTest.java　　

　　

　　HelloTest.java的代码如下：

1. 1package me.gacl.maven;

2. 2//导入junit的包

3. 3import org.junit.Test;

4. 4importstatic junit.framework.Assert.*;

5. 5

6. 6publicclassHelloTest{

7. 7

8. 8@Test

9. 9publicvoid testHello(){

10. 10Hello hello = newHello();

11. 11String results = hello.sayHello("gacl");

12. 12 assertEquals("Hello gacl!",results);

13. 13}

14. 14}

1.2、使用Maven编译、清理、测试、打包项目

1、使用Maven编译项目，编译项目的命令是："mvn compile"

　　打开cmd命令行，

　　

　　进入Hello项目根目录执行"mvn compile"命令编译项目的java类

　　

　　编译成功之后，可以看到hello项目的根目录下多了一个【target】文件夹，这个文件夹就是编译成功之后Maven帮我们生成的文件夹，如下图所示：

　　

　　打开【target】文件夹，可以看到里面有一个【classes】文件夹，如下图所示：

　　

　　【classes】文件夹中存放的就是Maven我们编译好的java类，如下图所示：

　　

　　这就是使用Maven自动编译项目的过程。

2、使用Maven清理项目，清理项目的命令是："mvn clean"

*　　进入Hello项目根目录执行"mvn clean"命令清理项目，清理项目的过程就是把执行"mvn compile*"命令编译项目时生成的target文件夹删掉，如下图所示：

　　

3、使用Maven测试项目，测试项目的命令是："mvn test"

　　进入Hello项目根目录执行"mvn test"命令测试项目，如下图所示：

　　

　　测试成功之后，可以看到hello项目的根目录下多了一个【target】文件夹，这个文件夹就是测试成功之后Maven帮我们生成的文件夹，如下图所示：

　　

　　打开【target】文件夹，可以看到里面有一个【classes】和【test-classes】文件夹，如下图所示：

　　

　　也就是说，我们执行执行"mvn test"命令测试项目时，Maven先帮我们编译项目，然后再执行测试代码。

4、使用Maven打包项目，打包项目的命令是："mvn package"

*　　进入Hello项目根目录执行"mvn* package"命令测试项目，如下图所示：

　　

　　

　　打包成功之后，可以看到hello项目的根目录下的【target】文件夹中多了一个Hello-0.0.1-SNAPSHOT.jar，这个Hello-0.0.1-SNAPSHOT.jar就是打包成功之后Maven帮我们生成的jar文件，如下图所示：

　　

5*、使用Maven部署项目，部署项目的命令是："mvn install"*

*　　进入Hello项目根目录执行"mvn* install"命令测试项目，如下图所示：

　　

　　

　　安装成功之后，首先会在hello项目的根目录下生成【target】文件夹，打开【target】文件夹，可以看到里面会有Hello-0.0.1-SNAPSHOT.jar，这个Hello-0.0.1-SNAPSHOT.jar就是安装成功之后Maven帮我们生成的jar文件，如下图所示：

　　

　　除此之外，在我们存放Maven下载下来的jar包的仓库也会有一个Hello-0.0.1-SNAPSHOT.jar，所以Maven安装项目的过程，实际上就是把项目进行【清理】→【编译】→【测试】→【打包】，再把打包好的jar放到我们指定的存放jar包的Maven仓库中，如下图所示：

　　

　　所以使用"mvn install"命令，就把maven构建项目的【清理】→【编译】→【测试】→【打包】的这几个过程都做了，同时将打包好的jar包发布到本地的Maven仓库中，所以maven最常用的命令还是"mvn install"，这个命令能够做的事情最多。

1.2、组合使用Maven的命令

　　maven的编译，清理，测试，打包，部署命令是可以几个命令同时组合起来使用的，常用的命令组合如下：

　　1、先清理再编译："mvn clean compile"，如下所示：

　　

　　还有的就是"mvn clean test"，"mvn clean package"，"mvn clean install"，这些组合命令都比较常用。

　　以上就是关于Maven构建项目的各个个过程演示。

二、在别的项目中使用通过Maven安装生成的项目的jar包

　　在上面，我们使用mvn install命令将hello这个项目打包成了Hello-0.0.1-SNAPSHOT.jar包并且发布到本地的maven仓库E:\repository\me\gacl\maven\Hello\0.0.1-SNAPSHOT中，下面我们来看看如何在别的项目中使用Hello-0.0.1-SNAPSHOT.jar

　　1、新建HelloFriend项目，同时建立Maven约定的目录结构和pom.xml文件
　　　　HelloFriend
　　　　　 | --src
　　　　　　| -----main
　　　　　　| ----------java
　　　　　　| ----------resources
　　　　　　| -----test
　　　　　　| ---------java
　　　　　　| ---------resources
　　　　　　| --pom.xml

　　如下图所示：

　　

　　2、编辑项目HelloFriend根目录下的pom.xml，添加如下的代码：

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

2. 2 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

3. 3<modelVersion>4.0.0</modelVersion>

4. 4<groupId>me.gacl.maven</groupId>

5. 5<artifactId>HelloFriend</artifactId>

6. 6<version>0.0.1-SNAPSHOT</version>

7. 7<name>HelloFriend</name>

8. 8

9. 9<!--添加依赖的jar包-->

10. 10<dependencies>

11. 11<!--项目要使用到junit的jar包，所以在这里添加junit的jar包的依赖-->

12. 12<dependency>

13. 13<groupId>junit</groupId>

14. 14<artifactId>junit</artifactId>

15. 15<version>4.9</version>

16. 16<scope>test</scope>

17. 17</dependency>

18. 18<!--项目要使用到Hello的jar包，所以在这里添加Hello的jar包的依赖-->

19. 19<dependency>

20. 20<groupId>me.gacl.maven</groupId>

21. 21<artifactId>Hello</artifactId>

22. 22<version>0.0.1-SNAPSHOT</version>

23. 23<scope>compile</scope>

24. 24</dependency>

25. 25</dependencies>

26. 26</project>

　　3、在src/main/java/me/gacl/maven目录下新建文件HelloFriend.java，如下图所示：

　　

　　HelloFriend.java的代码如下：

1. 1package me.gacl.maven;

2. 2

3. 3import me.gacl.maven.Hello;

4. 4

5. 5publicclassHelloFriend{

6. 6

7. 7publicString sayHelloToFriend(String name){

8. 8

9. 9Hello hello = newHello();

10. 10String str = hello.sayHello(name)+" I am "+this.getMyName();

11. 11System.out.println(str);

12. 12return str;

13. 13}

14. 14

15. 15publicString getMyName(){

16. 16return"John";

17. 17}

18. 18}

　　4、在/src/test/java/me/gacl/maven目录下新建测试文件HelloFriendTest.java，如下图所示：

　　

　　HelloFriendTest.java的代码如下：

1. 1package me.gacl.maven;

2. 2

3. 3importstatic junit.framework.Assert.assertEquals;

4. 4import org.junit.Test;

5. 5import me.gacl.maven.Hello;

6. 6

7. 7publicclassHelloFriendTest{

8. 8

9. 9@Test

10. 10publicvoid tesHelloFriend(){

11. 11

12. 12HelloFriend helloFriend = newHelloFriend();

13. 13String results = helloFriend.sayHelloToFriend("gacl");

14. 14 assertEquals("Hello gacl! I am John",results);

15. 15}

16. 16}

　　5、在HelloFriend目录下执行命令"mvn package"测试Hello-0.0.1-SNAPSHOT.jar里面的类是否引用成功，如下所示：

　　

END