Java开发环境搭建-Maven（二）手动搭建一个Maven工程

在实际工作中，通常都是将Maven集成到IDE工具中使用的。为了更好的理解Maven背后的原理，本次讲解我们手动搭建一个符合Maven规范的项目，然后完成构建及打包工作。

Maven对项目结构的定义

Maven是如何定义项目结构的呢？我们先看一下超级pom的内容

什么是超级pom可以理解为：
Maven项目是支持分层结构的，可以将当前项目作为子项目定义一个父项目。父子项目之间是继承关系，子项目可以从父项目中继承依赖以及相关的配置信息，类似于Java中继承的概念。与Java中的Object对象类似，所有的maven项目都会继承自一个根pom，这个pom就是超级pom

找到maven的安装目录，找到maven-model-builder-×××.jar文件，我本机的路径如下

使用压缩软件打开这个jar包，进入maven-model-builder-3.9.9.jar\org\apache\maven\model，找到pom-4.0.0.xml，这个文件就是超级pom

我们来看一下，这个文件中关于构建的配置，看到这里大家就应该有思路了

超级pom中，对于项目结构的定义为：

1. 构建根路径：项目根目录/target
2. 源码编译后的class：项目根目录/target/classes
3. 打包后的文件名称：artifactId-version
4. 测试类编译后的class：项目根目录/target/test-classes
5. 源码存放路径：项目根目录/src/main/java
6. 脚本存放路径：项目根目录/src/main/scripts
7. 测试源码存放路径：项目根目录/src/test/java
8. 源码资源文件路径：项目根目录/src/main/resources
9. 测试资源文件路径：项目根目录/src/test/resources

我们只要按照这个规范创建的项目就是符合Maven要求的项目

创建项目

打开vscode，按照超级pom中定义的结构手动创建一个项目。

我们为项目添加一个类HelloWorld.java作为主类，它内部包含main方法

package com.cainiao.study;
public class HelloWorld{
    public static void main(String[] args){
        System.out.println("Hello World");
    }
}

同时，在项目的根目录下定义了一个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.cainiao.study</groupId>
    <artifactId>maven-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

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

    <dependencies>
        <!-- 添加JUnit依赖 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.2.0</version>
                <configuration>
                <archive>
                    <manifest>
                    <addClasspath>true</addClasspath>
                    <mainClass>com.cainiao.study.HelloWorld</mainClass>
                    </manifest>
                </archive>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

构建项目

打开终端，进入项目的根路径下，使用Maven命令进行项目的构建

编译

执行mvn compile。执行成功提示，编译了一个源码文件，并且输出到了D:\workspace\vscodeWorkSpace\mywork\maven-study\maven-demo\target\classes路径下

打包

执行mvn package命令，将我们的项目打成jar包。
可以看到打包成功，输出了一个名字为maven-demo-1.0-SNAPSHOT.jar的文件，在目录D:\workspace\vscodeWorkSpace\mywork\blog-demo\maven-demo\target下

这和上面提到的超级pom中定义的规则完全是一致的：
打包后的文件名称：artifactId-project.version
构建根路径：项目根目录/target

在项目的target目录下生成了该jar包

运行项目

接下来，我们使用java -jar命令，来执行我们的程序。首先，进入项目根目录下的target目录，然后执行命令

坏了，报错了。为啥呢？别慌，我们分析一下原因。

从报错的信息来看，java在运行jar包的时候，没有找到主类，也就是说没有找到这个jar包从哪个入口类开始运行。我们知道，一个java程序想要运行，是必须要有main方法的。因此，我们要告诉java，在我们的jar包中，哪个类是具备main方法的主类。

怎么告诉呢？这里就涉及到一个知识点，我们可以通过MANIFEST.MF文件来描述我们的jar包的信息，在这个文件中写明该jar包的主类是哪个。

java在运行一个jar包的时候，会到jar包的META-INF路径下找这个文件，并且获取主类信息，然后才能够正常的运行jar。

因此我们要创建MANIFEST.MF文件，说明jar包的主类。怎么做呢？我们可以通过maven的maven-jar-plugin插件轻松的处理这件事情。

修改pom.xml文件，添加maven-jar-plugin插件

<?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.cainiao.study</groupId>
    <artifactId>maven-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

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

    <dependencies>
        <!-- 添加JUnit依赖 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.2.0</version>
                <configuration>
                <archive>
                    <manifest>
                    <addClasspath>true</addClasspath>
                    <!-- 在这里说明应用的主类 -->
                    <mainClass>com.cainiao.study.HelloWorld</mainClass>
                    </manifest>
                </archive>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

回到项目根目录，执行mvn clean命令，清理我们的构建目录

执行mvn package命令，重新打包

进入项目根目录下的target目录，再次执行java -jar命令，可以看到项目正常运行了

我们打开生成的maven-demo-1.0-SNAPSHOT.jar，查看内部的结构。可以看到确实在META-INF目录下生成了一个MAINIFEST.MF文件

在文件内部指定了jar包的主程序的位置

总结

以上为大家介绍了手工搭建maven项目的过程，我们要掌握以下一些知识点：
1、为什么maven项目的结构是这么定义的
2、java运行jar包的时候，如何制定主类
3、Maven生命周期中的一些命令，比如clean、package等

后续Maven系列文章，我会给大家详细介绍Maven更细节的东西，欢迎大家关注于交流。