一、从Hello world说起

Maven是一个项目管理工具，在安装好并配置系统环境变量后，在终端执行：mvn -version，保证输出以下内容：

Apache Maven 3.5.4 (1edded0938998edf8bf061f1ceb3cfdeccf443fe; 2018-06-18T02:33:14+08:00)
Maven home: /usr/local/soft/maven
Java version: 1.8.0_191, vendor: Oracle Corporation, runtime: /usr/local/soft/jdk8/jre
Default locale: zh_CN, platform encoding: UTF-8
OS name: "linux", version: "4.15.0-29deepin-generic", arch: "amd64", family: "unix"

首先约定好开发工具为IDEA，在IDEA中配置好Maven，怎么配置就不多说了。

1. 创建项目

打开IDEA，点击菜单File -> New -> Project...，然后在左侧选择Maven后Next，填写好GAV，然后填写好项目路径等创建完成。

GAV：是groupId、artifactId、version的缩写。

groupId：一般是公司的域名倒置，artifactId：项目名称或模块名称，version：版本号

打开项目会在IDEA左侧看到Maven的目录结构，打开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.ajn</groupId>
    <artifactId>spring-boot</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</project>

2. 添加依赖

首先添加spring相关父pom配置，我个人不建议使用spring-boot-starter-parent而使用spring-boot-dependencies，我们只需要继承父pom的依赖，不需要其他配置，项目的掌控权要牢牢握在自己手里。然后添加spring-boot-starter-web依赖。

<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.0.4.RELEASE</version>
    </parent>
    <groupId>com.ajn</groupId>
    <artifactId>spring-boot</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>
3. 添加插件

3. 添加插件

添加完插件和部分配置属性，我们可以看到添加的插件有：

maven-compiler-plugin：编译
maven-jar-plugin：打包
maven-assembly-plugin：自定义打包
maven-source-plugin：打包源码
maven-release-plugin：版本发布

Maven是基于微核心插件化思想设计的，功能全部体现在插件上，我们在后面详细讲到。还添加的属性有：

project.build.sourceEncoding：编码
project.reporting.outputEncoding：编码
java.version：JDK版本
maven.test.skip：跳过测试
maven.install.skip：跳过安装到本地仓库
maven.deploy.skip：跳过发布到远程仓库（私服）

一般Web项目跳过 install 和 deploy，因为它不需要被别人依赖。需要被别人依赖的API项目，都应将 Jar 包和源码包发布到私服，供调用方使用。

Profile可以用来区分环境，具体用法以后说，添加的Profile有：

test：表示测试环境
prod：表示生产环境

到这差不多pom的配置就完成了，除了以后添加依赖。

<?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>
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-dependencies</artifactId>
       <version>2.0.4.RELEASE</version>
   </parent>
   <groupId>com.ajn</groupId>
   <artifactId>spring-boot</artifactId>
   <version>1.0.0-SNAPSHOT</version>
   <properties>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
       <java.version>1.8</java.version>
       <maven.test.skip>true</maven.test.skip>
   </properties>
   <dependencies>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
   </dependencies>
   <build>
       <finalName>${project.name}</finalName>
       <resources>
           <resource>
               <directory>src/main/java</directory>
               <includes>
                   <include>**/*.xml</include>
               </includes>
           </resource>
           <resource>
               <directory>src/main/resources</directory>
               <includes>
                   <include>*</include>
               </includes>
               <filtering>true</filtering>
           </resource>
       </resources>
       <plugins>
           <plugin>
               <artifactId>maven-compiler-plugin</artifactId>
               <configuration>
                   <source>${java.version}</source>
                   <target>${java.version}</target>
               </configuration>
           </plugin>
           <plugin>
               <artifactId>maven-jar-plugin</artifactId>
               <configuration>
                   <archive>
                       <addMavenDescriptor>false</addMavenDescriptor>
                       <manifest>
                           <addClasspath>true</addClasspath>
                           <classpathPrefix>lib/</classpathPrefix>
                           <mainClass>com.ajn.spring.boot.Application</mainClass>
                       </manifest>
                   </archive>
               </configuration>
           </plugin>
           <plugin>
               <artifactId>maven-assembly-plugin</artifactId>
               <configuration>
                   <descriptors>
                       <descriptor>src/main/config/package.xml</descriptor>
                   </descriptors>
               </configuration>
               <executions>
                   <execution>
                       <id>mvn-assembly</id>
                       <phase>package</phase>
                       <goals>
                           <goal>single</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
           <plugin>
               <artifactId>maven-source-plugin</artifactId>
               <executions>
                   <execution>
                       <id>attach-sources</id>
                       <goals>
                           <goal>jar-no-fork</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-release-plugin</artifactId>
           </plugin>
       </plugins>
   </build>
   <profiles>
       <profile>
           <id>test</id>
           <properties>
               <profile.active>test</profile.active>
           </properties>
       </profile>
       <profile>
           <id>prod</id>
           <properties>
               <profile.active>prod</profile.active>
           </properties>
       </profile>
   </profiles>
</project>

添加assembly插件打包配置，根据maven-assembly-plugin插件配置的文件路径，在main下新建文件夹config，然后新建文件package.xml，插件配置用法后面会说到。

package com.ajn.spring.boot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args); 
    }
}

每个项目都可以有自己定制的打包方式，并不拘泥于某类插件。

4. 添加代码

到这里我们项目已经搭建好了并添加Springboot的依赖，就可以直接写代码启动测试。在java目录下创建包com.ajn.spring.boot，在包下新建类Application.java：

package com.ajn.spring.boot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args); 
    }
}

在包com.ajn.spring.boot下新建包controller，在包下新建类HelloController.java：

package com.ajn.spring.boot.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("hello")
public class HelloController {
    @GetMapping
    public String hello() {
        return "Hello world";
    } 
}

运行主方法来启动项目，输出日志中最后一行如下表示启动成功。

2018-11-28 20:23:00.754 INFO 22671 --- [main] com.ajn.spring.boot.Application: Started Application in 1.296 seconds (JVM running for 1.64)

然后用浏览器访问 http://localhost:8080/hello，返回：

Hello world

到这里我们只是先把项目跑起来，在Maven中配置的插件也似乎没有用到，后面会深入讲解Maven是如何管理和构建项目的。

二、Maven

Apache Maven的定义：Maven是一个项目管理工具，它包含了一个项目对象模型 (Project Object Model)，一组标准集合，一个项目生命周期(Project Lifecycle)，一个依赖管理系统(Dependency Management System)，和用来运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑。当你使用Maven的时候，你用一个明确定义的项目对象模型来描述你的项目，然后Maven可以应用横切的逻辑，这些逻辑来自一组共享的(或者自定义的)插件。

它运用的设计思想：

继承思想：子pom可以继承父pom的配置和属性。
仓库思想：本地仓库、远程仓库（私服）
约定大于配置：功能配置和指令约定俗成
微核心插件化：本身安装包核心不大，插件也像依赖一样可由仓库管理

1. 目录结构

Maven的基本目录结构，不管是自动生成，还是自己手动创建，都需按照这种格式，当然你可以自定义，但不建议这样做，会增加更多没必要的配置。

spring-boot
├── pom.xml
├── src
│   ├── main
│   │   ├── java
│   │   └── resources
│   └── test
│       └── java
│       └── resources
└── target

spring-boot：项目根目录
src/main/java：源代码目录
src/main/resources：资源文件目录，默认打包至类路径(classpath)下
src/test/java：测试源代码目录
src/test/resources：测试资源文件目录
pom.xml：(Project Object Model)，项目对象模型配置文件

2. pom

Maven把Java项目抽象成一个项目对象模型(Project Object Model)，而pom.xml配置就是这抽象过程的体现。它不仅能把源代码编译成字节码，这些配置还包含：项目的描述信息，项目唯一的坐标，描述项目的属性，依赖的其他项目等等。

2.1 配置详解

2.1.1 基本配置

modelVersion：pom模型版本，maven2只能为4.0.0
groupId：项目组编号
artifactId：项目编号
version：版本号

packaging：打包方式，有pom,jar,war,maven-plugin等等，缺省值：jar
properties：定义常量属性，可以在pom其他地方通过${}来引用
name：项目名，Maven产生的文档使用
description：项目描述
url：主页URL，maven文档中保存
developers：开发人员
contributors：其他贡献人员

2.1.2 依赖配置

parent：项目继承中指定父项目，子节点为GAV1
modules：项目聚合中指定子模块项目，子节点为module
dependencies：依赖配置，需提供引用的依赖的GAV，可以从父项目继承
dependencyManagement：依赖管理配置，子节点配置dependencies，管理子项目依赖

2.1.3 构建配置

build：构建配置

finalName：build目标文件的名称，缺省值：${artifactId}-${version}
resources：资源拷贝插件配置
plugins：插件配置
filters：定义过滤的.properties文件，该文件的配置会应用到resources中

reporting：发布配置
profiles：配置文件组，可以配置多种配置，按需激活其中一种

2.1.4 仓库配置

repositories：配置获取依赖的仓库，一般配置私服中的中央仓库，缺省值：Maven中央仓库
pluginRepositories：配置获取插件的仓库，和repositories意思一样
distributionManagement：发布管理，可以配置依赖发布的仓库
scm：软件配置管理，可以配置web站点和CVS

3. 依赖

3.1 依赖范围(scope)

3.1.1 compile

编译范围：scope配置的缺省值，编译范围依赖在所有的classpath中可用，同时也会被打包。

3.1.2 provided

已提供范围：该类型依赖只有在当JDK或者一个容器已提供该依赖之后才使用，已提供范围的依赖在编译classpath（不是运行时）可用，它们不是传递性的，也不会被打包。

3.1.3 runtime

运行时范围：该类型依赖在运行和测试系统的时候需要，但在编译的时候不需要。比如：你可能在编译的时候只需要JDBC API jar，而只有在运行的时候才需要JDBC驱动实现。

3.1.4 test

测试范围：该类型依赖在一般的编译和运行时都不需要，只有在测试编译和测试运行阶段可用。

3.1.5 system

系统范围：该依赖范围与provided类似，但是必须显式的提供一个对于本地系统中jar文件的路径。这么做是为了允许基于本地对象编译，而这些对象是系统类库的一部分。

3.2 传递性依赖

一个传递性依赖就是对于一个依赖的依赖。如果project-a依赖于project-b，后者接着依赖于project-c，那么project-c就被认为是project-a的传递性依赖。如果project-c依赖于project-d，那么project-d就也被认为是project-a的传递性依赖。

3.3 冲突解决(exclusions)

有很多时候你需要排除一个传递性依赖，比如当你依赖于一个项目，后者又继而依赖于另外一个项目，但你的希望是，要么整个的排除这个传递性依赖，要么用另外一个提供同样功能的依赖来替代这个传递性依赖。比如：

<dependency>
    <groupId>org.sonatype.mavenbook</groupId>
    <artifactId>project-a</artifactId>
    <version>1.0</version>
    <exclusions>
        <exclusion>
            <groupId>org.sonatype.mavenbook</groupId>
            <artifactId>project-b</artifactId>
        </exclusion>
    </exclusions>
</dependency>

3.4 依赖管理(dependencyManagement)

在一个系统中有很多相互关联个Maven项目，如果每一个使用如MySQL数据库驱动依赖的项目都需要独立的列出该依赖的版本，在你需要升级到一个新版本的时候你就会遇到问题。由于这些版本号分散在你的项目树中，你需要手工的编写每一个引用该依赖的pom.xml，确保每个地方的版本号都更改了。此时我们可以在父项目中使用dependencyManagement来集中管理依赖。比如：

<!-- 父项目 -->
<project>
    [...]
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.2</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    [...]
</project>
<!-- 子项目 -->
<project>
    [...]
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>
    [...]
</project>

4. 生命周期

在前面Maven的定义中我们说到它是运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑，一个生命周期是一些阶段的序列，一个生命周期阶绑定了零个或多个目标(goal)。我们可以使用mvn指令直接运行生命周期和目标。

运行生命周期：mvn clean, mvn package, mvn clean package等等
运行插件目标：mvn clean:clean, mvn resources:resources等等

在项目根目录下我们可以直接在终端运行mvn clean，如果一个项目自己配置了多个pom.xml文件，需要指定执行的pom，使用mvn clean -f pomTest.xml

4.1 clean

phases: clean
goals: clean:clean

该生命周期用于移除你项目构建的文件，默认是删除 project.build.directory, project.build.outputDirectory, project.build.testOutputDirectory 和 project.reporting.outputDirectory目录。

4.2 compile

phases: process-resources -> compile
goals: resources:resources -> compiler:compile

该生命周期用于编译源码和测试源码，默认编译source和target的JDK配置是1.6，如果想使用更高版本，需要自己手动配置。

4.3 package

phases: process-resources -> compile -> process-classes -> process-test-resources -> test-compile -> test -> prepare-package -> package
goals: resources:resources -> compiler:compile -> resources:testResources -> compiler:testCompile -> surefire:test ->jar:jar

该生命周期用于项目打包，默认打的是jar类型。

4.4 install

phases: process-resources -> compile -> process-classes -> process-test-resources -> test-compile -> test -> prepare-package -> package -> pre-integration-test -> integration-test -> post-integration-test -> verify -> install
goals: resources:resources -> compiler:compile -> resources:testResources -> compiler:testCompile -> surefire:test -> jar:jar -> install:install

该生命周期用于将你打好的包安装到本地仓库，会根据项目的GAV来确定它在仓库中的路径。本地仓库目录可以在Maven的配置文件setting.xml中的节点配置，缺省值：~/.m2/repository。

打包执行顺序图：

微信图片1.jpg

打包日志分析：

[INFO] Scanning for projects...
[INFO]
[INFO] ----------------< com.ajn.springboot:study-springboot >-----------------
[INFO] Building study-springboot 1.0.1-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-resources-plugin:3.0.2:resources (default-resources) @ study-springboot ---
[INFO] Using 'UTF-8'encoding to copy filtered resources.
[INFO] Copying 2resources
[INFO] Copying 3resources
[INFO] Copying 1resource
[INFO]
[INFO] --- maven-compiler-plugin:3.7.0:compile (default-compile) @ study-springboot ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 32source files to /home/ajn/Code/study/study-springboot/target/classes
[INFO]
[INFO] --- maven-resources-plugin:3.0.2:testResources (default-testResources) @ study-springboot ---
[INFO] Not copying test resources
[INFO]
[INFO] --- maven-compiler-plugin:3.7.0:testCompile (default-testCompile) @ study-springboot ---
[INFO] Not compiling test sources
[INFO]
[INFO] --- maven-surefire-plugin:2.21.0:test (default-test) @ study-springboot ---
[INFO] Tests are skipped.
[INFO]
[INFO] --- maven-jar-plugin:3.0.2:jar (default-jar) @ study-springboot ---
[INFO] Building jar: /home/ajn/Code/study/study-springboot/target/study-springboot.jar
[INFO]
[INFO] --- maven-assembly-plugin:3.1.0:single (mvn-assembly) @ study-springboot ---
[INFO] Reading assembly descriptor: src/main/config/package.xml
[INFO] Building zip: /home/ajn/Code/study/study-springboot/target/study-springboot-bin.zip
[INFO]
[INFO] --- maven-source-plugin:3.0.1:jar-no-fork (attach-sources) @ study-springboot ---
[INFO] Building jar: /home/ajn/Code/study/study-springboot/target/study-springboot-sources.jar
[INFO]
[INFO] --- maven-install-plugin:2.5.2:install (default-install) @ study-springboot ---
[INFO] Installing /home/ajn/Code/study/study-springboot/target/study-springboot.jar to /home/ajn/.m2/repository/com/ajn/springboot/study-springboot/1.0.1-SNAPSHOT/study-springboot-1.0.1-SNAPSHOT.jar
[INFO] Installing /home/ajn/Code/study/study-springboot/pom.xml to /home/ajn/.m2/repository/com/ajn/springboot/study-springboot/1.0.1-SNAPSHOT/study-springboot-1.0.1-SNAPSHOT.pom
[INFO] Installing /home/ajn/Code/study/study-springboot/target/study-springboot-bin.zip to /home/ajn/.m2/repository/com/ajn/springboot/study-springboot/1.0.1-SNAPSHOT/study-springboot-1.0.1-SNAPSHOT-bin.zip
[INFO] Installing /home/ajn/Code/study/study-springboot/target/study-springboot-sources.jar to /home/ajn/.m2/repository/com/ajn/springboot/study-springboot/1.0.1-SNAPSHOT/study-springboot-1.0.1-SNAPSHOT-sources.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 7.022s
[INFO] Finished at: 2018-12-02T22:50:31+08:00
[INFO] ------------------------------------------------------------------------

上面为我们前面搭建好的项目执行mvn install时打印的日志，从日志中可以看出执行的goal，完全是按照默认或者我们配置的生命周期阶段的顺序，比如：配置的maven-assembly-plugin打包插件，执行的目标(goal)是single，绑定的生命周期阶段(phase)是package，所以在执行目标jar:jar的后面。在pom中配置跳过测试true。

Maven高效实践（上）

一、从Hello world说起

1. 创建项目

2. 添加依赖

3. 添加插件

4. 添加代码

二、Maven

1. 目录结构

2. pom

2.1 配置详解

2.1.1 基本配置

2.1.2 依赖配置

2.1.3 构建配置

2.1.4 仓库配置

3. 依赖

3.1 依赖范围(scope)

3.1.1 compile

3.1.2 provided

3.1.3 runtime

3.1.4 test

3.1.5 system

3.2 传递性依赖

3.3 冲突解决(exclusions)

3.4 依赖管理(dependencyManagement)

4. 生命周期

4.1 clean

4.2 compile

4.3 package

4.4 install

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Maven高效实践（上）

一、从Hello world说起

1. 创建项目

2. 添加依赖

3. 添加插件

4. 添加代码

二、Maven

1. 目录结构

2. pom

2.1 配置详解

2.1.1 基本配置

2.1.2 依赖配置

2.1.3 构建配置

2.1.4 仓库配置

3. 依赖

3.1 依赖范围(scope)

3.1.1 compile

3.1.2 provided

3.1.3 runtime

3.1.4 test

3.1.5 system

3.2 传递性依赖

3.3 冲突解决(exclusions)

3.4 依赖管理(dependencyManagement)

4. 生命周期

4.1 clean

4.2 compile

4.3 package

4.4 install

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像