Normally an IDE like eclipse can be used to easily create maven projects. But in this artice I will be running the commands from the command line so that the steps are clearly understood.
Archetype in the above command is nothing but a sample project template. groupdId tells what group your project comes under and artifactId is the project name.
4.0.0 com.first.app first-maven-app jar 1.0-SNAPSHOT first-maven-app http://maven.apache.org junit junit 3.8.1 test
groupdId and artifactId are the same values we gave in the command line.
groupdId和artifactId是我们在命令行中提供的相同值。
packaging is the package format of the artifact. Default value is jar. It can have other values as well like ear, war, tar and so on.
包装是工件的包装格式。 默认值为jar 。 它可以具有其他值，例如ear，war，tar等。
version indicates the version number of the artifact. If SNAPSHOT is present, then it indicates the version is still in dev and may not be stable. If the version number does not have SNAPSHOT, then it’s the actual release version.
I will explain about dependencies and plugins in Maven below.
我将在下面解释有关Maven中的依赖项和插件的信息。
超级POM (Super POM)
pom.xml as you can see is pretty small. The reason for this is that a lot of the configuration is present in something called Super POM which is maintained internally by Maven.
如您所见，pom.xml很小。 这是因为Maven内部维护了称为Super POM的许多配置。
pom.xml extends Super Pom to get all the config present in super Pom.
pom.xml扩展了Super Pom，以获取super Pom中存在的所有配置。
One of the config present in Super Pom indicates the following:
Super Pom中存在的一种配置指示以下内容：
All java source code is present inside src/main/java
所有Java源代码都位于src / main / java内部
All java test code is present inside src/test/java
所有Java测试代码都位于src / test / java内部
I mention only this config here, since we will be dealing with both source code as well as test code in this article.
我在这里仅提及此配置，因为在本文中我们将同时处理源代码和测试代码。
码 (Code)
The entire code discussed here is available in this repo:
此仓库中提供了此处讨论的整个代码： :
Let’s add some simple Java code. Create the following folder structure:
让我们添加一些简单的Java代码。 创建以下文件夹结构：
src/main/java/com/test/app/App.java
src / main / java / com / test / app / App.java
App.java is the Java code we will be adding.
App.java是我们将添加的Java代码。
Copy the following code into App.java:
将以下代码复制到App.java中：
package com.first.app;import java.util.List;import java.util.ArrayList;public class App { public static void main( String[] args ) { List items = new ArrayList (); items.add(1); items.add(2); items.add(3); printVals(items); System.out.println("Sum: "+getSum(items)); } public static void printVals(List items){ items.forEach( item ->{ System.out.println(item); }); } public static int getSum(List items){ int sum = 0; for(int item:items){ sum += item; } return sum; }}
This is simple code which has 2 functions.
这是简单的代码，具有2个功能。
But one thing to observe is, the code is using lambda expressions inside the forEach loop in printVals function.
但是要观察的一件事是，代码在printVals函数的forEach循环内使用了lambda表达式。
Lambda expressions need at minimum Java 8 to run. But by default Maven 3.8.0 runs using Java version 1.6.
You can see that the Java source and target versions are set to 1.8.
您可以看到Java 源版本和目标版本设置为1.8 。
Plugins basically get some action done in maven. The compiler plugin compiles the source files.
插件基本上可以在Maven中完成一些操作。编译器插件编译源文件。
The full pom.xml is available .
完整的pom.xml 可用。
There are a lot of maven plugins available. By knowing how to use plugins well, Maven can be used to do amazing things. ?
有很多可用的Maven插件。通过了解如何很好地使用插件，Maven可以用来做令人惊奇的事情。 ？
Maven依赖 (Maven Dependencies)
Normally while writing code, we will be using a lot of existing libraries. These existing libraries are nothing but dependencies. Maven can be used to manage dependencies easily.
In the pom.xml of our project you can see the following dependency:
在我们项目的pom.xml中，您可以看到以下依赖关系：
junit junit 3.8.1 test
This dependency is telling that we will be needing junit. Junit is used to write Unit Tests for Java code. Similarly a lot of other dependencies can be added.
Let’s say you want to handle JSON in the code. Then you can add the gson dependency as shown below:
假设您要在代码中处理JSON。 然后，您可以添加gson依赖项，如下所示：
com.google.code.gson gson 2.8.5
You can search for Maven artifacts in
您可以在搜索Maven工件。
传递依存关系 (Transitive Dependencies)
Let’s say you add a dependency A to the Project. Now A depends on a dependency called B. B depends on a dependency called C.
假设您向项目添加了依赖项A。 现在A依赖于称为B的依赖项。 B依赖于称为C的依赖项。
Since you are using A in the project, you will also need B and C.
由于您在项目中使用A ，因此您还将需要B和C。
But fortunately, it is enough if you add only A in pom.xml. Because Maven can figure out that A depends on B and that B depends on C. So internally Maven will automatically download B and C.
All these dependencies are available in a Public Maven Central Repository
所有这些依赖项都可以在Public Maven中央存储库中找到，网址为
It is possible that there are some artifacts which are private to your company. In this case, you can maintain a private maven repository within your organization. I won’t be covering this portion in this tutorial.
Since the junit dependency is present in the project, we can add test Classes.
由于junit依赖项存在于项目中，因此我们可以添加测试类。
Create the following folder structure:
创建以下文件夹结构：
src/test/java/com/test/app/AppTest.java
src / test / java / com / test / app / AppTest.java
AppTest.java is the Test Class.
AppTest.java是测试类。
Copy the following code into AppTest.java:
将以下代码复制到AppTest.java中：
package com.first.app;import junit.framework.TestCase;import java.util.List;import java.util.ArrayList;public class AppTest extends TestCase{ public AppTest( String testName ) { super( testName ); } public void testGetSum() { List items = new ArrayList (); items.add(1); items.add(2); items.add(3); assertEquals( 6, App.getSum(items) ); }}
This class tests the getSum() function present in the App Class.
此类测试App类中存在的getSum()函数。
Maven构建生命周期和阶段 (Maven Build Lifecycle and Phases)
Maven follows a build lifecycle to build and distribute artifacts. There are three main lifecycles:
Maven遵循构建生命周期来构建和分发工件。 有三个主要生命周期：
Default lifecycle: This deals with building and deploying the artifact.
默认生命周期 ：这涉及构建和部署工件。
Clean lifecycle: This deals with project cleaning
清洁生命周期 ：涉及项目清洁
Site lifecycle: This deals with Site documentation. Will cover this in a different article.
网站生命周期 ：这涉及网站文档。 将在另一篇文章中介绍。
A Lifecycle is made up of phases. Here are some of the important phases in the default lifecycle:
生命周期由阶段组成。 以下是默认生命周期中的一些重要阶段：
validate: Checks if all necessary information is available for the project
validate ：检查项目是否需要所有必要信息
compile: Used to compile the source files. Run the following command to compile:
compile ：用于编译源文件。 运行以下命令进行编译：
mvn compile
After running this command, a folder called target is created with all the compiled files. 运行此命令后，将使用所有编译文件创建一个名为target的文件夹。
test: Used to run all the unit tests present in the project. This is why the Junit dependency was needed. Using Junit, unit tests can be written. Test classes can be run using the command
package: This will run all the above phases and then package the artifact. Here it will package it into a jar file since pom indicates a jar is needed. Run the following command for this:
verify: This will ensure that quality criteria is met in the project
验证 ：这将确保项目符合质量标准
install: This will install the package in a local repository. The local repository location is usually ${user.home}/.m2/repository. Use the following command for this:
deploy: This is used to deploy the package to a remote repository
deploy ：用于将程序包部署到远程存储库
One more command which is commonly used is the clean command which is given below:
另一个常用的命令是clean命令，如下所示：
mvn clean
This command cleans up everything inside the target folder
此命令清除目标文件夹中的所有内容
参考文献 (References)
Maven’s Offical Guide:
Maven的官方指南： :
More about POM :
有关POM的更多信息： :
More about Build Lifecycle :
有关构建生命周期的更多信息： :
恭喜😄 (Congrats 😄)
You know how to use Maven now. This article covered just the basics of pom, plugins, dependencies and build lifecycle. To know more about Maven check the links I have given above.