背景： 之前使用maven都是基于IDE并且对maven本身也很少究其过程和原理，当出现问题也不知道如何解决，后续想使用命令行来进行操作，并通过文档记录一下学习的内容加深理解以防止忘记。

一、简要介绍

maven是通过插件来增强功能，而它本身有其生命周期，而生命周期与插件的目标进行了绑定，当我们执行某个生命周期时候内部就是在执行某个插件的目标。

例如下面，你可以使用生命周期来执行，也可以使用插件:目标来执行。

$ mvn compile                             // 通过使用 生命周期 进行操作

 它会调用 maven-resources-plugin:2.6:resources和maven-compiler-plugin:3.1:compile这两个插件来完成编译

$ mvn archetype:generate          // 通过插件:目标来执行

 插件目录为： Maven – Available Plugins

二、经常使用的插件

第一个是

The Archetype Plugin : 用于从一个archetype模板中生成一个项目骨架，一般都会选择 quickstart archetype做为模板进行生成，如下图所示：

交互式生成一个项目骨架：

// 表示我们要执行 archetype插件的 generate目标(goal)
$ mvn archetype:generate

 同时也可以输入更多的参数：

$ mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -Dversion=1.0-SNAPSHOT

最后进行打包运行:

$ mvn package
$ java -cp target/my-app-1.0-SNAPSHOT.jar com.mycompany.app.App

这样就可以输出 Hello World了。

第二个是

Maven Dependency Plugin 用于分析项目的依赖关系

mvn dependency:list   列出项目最终的依赖列表

mvn dependency:tree  列出项目的依赖树

第三个是

Maven Help Plugin获取项目上的各种工作环境等信息

mvn help:system  列出系统属性和环境变量

mvn help:effective-pom  显示有效的pom文件

mvn help:effective-settings​​​​​​ 显示有效的settings文件

第四个是

Maven Assembly Plugin 将项目的所有文件，包括依赖，模块，网页文件等。

mvn assembly:single

三、将普通maven项目设置为可执行Jar

有好几种方式可以让一个普通的maven工程转变为可执行Jar，我一般使用其中的两种方法。

1. 基于maven-dependency-plugin + maven-jar-plugin

dependency插件用于将项目的各种依赖包复制到指定路径下

jar插件用于将项目进行打包，需要设置主类和classpath前缀

优点：在于你的依赖和你的程序是分离的，不是一个jar包，你的依赖在target/libs下，你的程序jar包在target目录下 

缺点： jar的运行严格依赖于libs的，删除libs你的程序将无法执行

将下面build配置 粘贴到你的pom.xml文件中

<build>
        <plugins>
           <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                        <execution>
                                <id>copy-dependencies</id>
                                <phase>prepare-package</phase>
                                <goals>
                                        <goal>copy-dependencies</goal>
                                </goals>
                                <configuration>
                                        <outputDirectory>
                                                ${project.build.directory}/libs
                                        </outputDirectory>
                                </configuration>
                        </execution>
                </executions>
          </plugin>
          <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <classpathPrefix>libs/</classpathPrefix>
                            <mainClass>
                                com.mycompany.app.App
                            </mainClass>
                        </manifest>
                    </archive>
                </configuration>
         </plugin>
      </plugins>
</build>

再执行打包，运行jar即可，如下所示：

$ mvn clean package

$ java -jar target/my-app-1.0-SNAPSHOT.jar
Hello World

2. 基于maven-assembly-plugin

assembly插件用于将项目的各种依赖包、模块、网络文档等文件进行打包，也用于构建一个可执行jar。 它会生成两个jar，一个是单独的jar，另一个是包括了依赖的jar

优点：所有依赖都被打包到一个文件中

缺点：没有重新定位class的支持

将下面的build配置复制粘贴到你的pom.xml中

<build>
      <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                    <configuration>
                    <archive>
                        <manifest>
                        <mainClass>
                            com.mycompany.app.App
                        </mainClass>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    </configuration>
                </execution>
            </executions>
         </plugin>
    </plugins>
</build>

再执行打包，运行jar即可，如下所示：

$ mvn clean package

java -jar target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar
Hello World!

四、使用maven创建springboot应用

请大家注意在cmd中无法直接使用archetype模板创建springboot应用，但是 springboot有一种SpringBoot CLI是可以的但是我没有使用过，所以这种SpringBoot CLI这种不进行展开。

那如何快速的创建基于maven的一个springboot的应用呢？

第一：先使用cmd来创建一个普通的maven项目

           可以使用 $ mvn archetype:generate 进入交互式命令行，输入各项配置

第二：在新建的项目中，添加springboot的依赖

            例如我们添加 spring-boot-starter-parent父项目和 spring-boot-starter-web依赖，不用添加任意插件，如下图所示：

<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.mycompany.app</groupId>
  <artifactId>my-app</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>my-app</name>
  <url>http://maven.apache.org</url>
  <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.5.RELEASE</version>
  </parent>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
  </dependencies>
  <build>
      <plugins>
      </plugins>
    </build>
</project>

第三： 修改代码main方法，有原来的maven的main方法修改为springboot的main方法，都是Hello world程序。

package com.mycompany.app;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
 * Hello world!
 *
 */
@RestController
@SpringBootApplication
public class App {

    @RequestMapping("/")
    String home() {
        return "Hello World!";
    }

    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }

}

@RestController 标识被SpringMVC用于处理web请求，它是 @Controller and @ResponseBody组合的注解，这样将返回数据而不是视图对象

@RequestMapping  标识请求 "/"将会被映射到 home方法

@SpringBootApplication 包括@Configuration、@EnableAutoConfiguration、@ComponentScan这三个注解，分别是配置、自动配置、组件自动扫描

第四：在命令行中执行 ，然后在浏览器访问127.0.0.1:8080查看是否有输出。

           $ mvn spring-boot:run

这时候无需要任何插件，不需要在pom.xml中添加插件，一个springboot的程序就跑起来了。

第五： 添加spring-boot-maven-plugin插件

 Spring Boot Maven Plugin这个插件提供了在maven中对spring-boot的支持，允许原地打包可执行Jar或War包。

spring-boot:run 可以运行springboot应用

spring-boot:repackage 重新打包jar/war为可执行文件

spring-boot:start 和spring-boot:stop用于管理应用的生命周期，例如集成测试

spring-boot:build-info 产生构建的信息

可执行Jar(也称作 胖Jar)，它包含编译好的类及其相关的依赖包

为了生成一个springboot可执行Jar，需要在pom.xml新增 spring-boot-maven-plugin插件

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

在target目录下生成了jar包，例如：

my-app-1.0-SNAPSHOT.jar

$ jar -tvf target/my-app-1.0-SNAPSHOT.jar   //  可以查看jar包中包含了什么内容

$ java -jar target/my-app-1.0-SNAPSHOT.jar   // 可以启动spingboot应用