Maven基础入门与核心知识

时间 2019-12-04

标签 maven 基础入门核心知识栏目 Maven 繁體版

原文原文链接

Apache Maven是一个软件项目管理和综合工具。基于项目对象模型（POM）的概念，Maven能够从一个中心资料片管理项目构建，报告和文件。

Maven是一个项目管理和综合工具。Maven提供了开发人员构建一个完整的生命周期框架。开发团队能够自动完成项目的基础工具建设，Maven使用标准的目录结构和默认构建生命周期。html

在多个开发团队环境时，Maven能够设置按标准在很是短的时间里完成配置工做。因为大部分项目的设置都很简单，而且可重复使用，Maven让开发人员的工做更轻松，同时建立报表，检查，构建和测试自动化设置。java

归纳地说，Maven简化和标准化项目建设过程。处理编译，分配，文档，团队协做和其余任务的无缝链接。 Maven增长可重用性并负责创建相关的任务。web

安装配置

安装须要Java支持（JDK >= 1.7）。apache

下载压缩包

官方下载地址：http://maven.apache.org/download.cgitomcat

解压安装

解压压缩包至目录，个人安装位置：D:\apache-maven-3.5.4app

bin：mvn的运行脚本
boot：mvn类加载器框架
conf：配置文件目录
lib：依赖类库

配置环境变量

『计算机』-->『右键属性』-->『高级系统设置』-->『环境变量』-->『系统变量』框架

MAVEN_HOME

PATH

依次肯定，退出配置。yii

配置Maven

打开Maven目录，./conf/settings.xmlwebapp

配置本地存储库

添加配置maven

<localRepository>D:/mavenRepository/repository</localRepository>

localRepository 标签包含的就是本地存储库的地址。

配置镜像仓库

因为中央存储库在国外，国内可能打不开，因此在 mirrors 标签中添加阿里云镜像仓库配置。

<mirror>
    <id>alimaven</id>
    <name>aliyun maven</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    <mirrorOf>central</mirrorOf>
</mirror>

测试安装

打开CMD窗口，输入命令： mvn -v

出现如下内容，说明Maven安装成功。

建立Maven项目

首先说明Maven约定的目录结构：

├─ src
│ ├─ main          存放主程序
│ │ ├─ java        存放Java源文件
│ │ ├─ resources   存放框架或其余工具的配置文件
│ ├─ test          存放测试程序
│ │ ├─ java        存放Java测试的源文件
│ │ ├─ resources   存放测试的配置文件
├─pom.xml          Maven工程的核心配置

这里我直接使用IntelliJ IDEA建立Maven项目。

这里能够不勾选 create from archetype 直接建立，使用标准的模板（初始不作web测试，不须要使用此模板），这里我选择使用webapp模板（初始文件建立，能够参考我下面的构建WEB项目）。

这里在Properties中添加一个参数archetypeCatalog=internal

信息输入完后点击Finish，至此Maven项目就建立完了，由于咱们选择的是webapp，全部有些Maven约定的目录须要咱们手动建立补全。

经常使用构建命令

maven01 - 编译/测试

建立Maven项目maven01

配置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.maven01</groupId>
  <artifactId>maven01</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>maven01 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

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

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <finalName>maven01</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.7.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.20.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

View Code

在maven01/src/main/java建立包 com.maven01.model

建立HelloWorld.java

package com.maven01.model;

public class HelloWorld {
    public String sayHello() {
        return "Hello World !!";
    }
}

View Code

在maven01/src/test/java建立包 com.maven01.model

建立HelloWorldTest.java

package com.maven01.model;

import org.junit.*;
import org.junit.Assert.*;

public class HelloWorldTest {
    @Test
    public void testHello() {
        Assert.assertEquals("Hello World !!", new HelloWorld().sayHello());
    }
}

View Code

mvn compile - 编译

打开CMD，跳转当前位置至项目目录。

运行命令： mvn compile

第一次运行会下载不少资源。

出现BUILD SUCCESS说明编译成功：

mvn test - 测试

运行命令： mvn test

第一次运行一样会下载依赖资源。

出现BUILD SUCCESS说明运行成功：

maven02 - 安装/依赖

建立Maven项目maven02

配置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.maven02</groupId>
  <artifactId>maven02</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>maven02 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

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

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <finalName>maven02</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.7.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.20.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

View Code

在maven02/src/main/java建立包 com.maven02.util

建立Speak.java

package com.maven02.util;

import com.maven01.model.HelloWorld;

public class Speak {
    public String sayHi() {
        return new HelloWorld().sayHello();
    }
}

View Code

在maven02/src/test/java建立包 com.maven01.util

建立SpeakTest.java

package com.maven02.util;

import org.junit.Assert;
import org.junit.Test;

public class SpeakTest {
    @Test
    public void testsayHi() {
        Assert.assertEquals("Hello World !!", new Speak().sayHi());
    }
}

View Code

这时咱们使用编译命令，尝试编译maven02会发现报错：

mvn install - 安装

跳转盘符至maven01目录

运行命令： mvn install

将maven01的jar包安装到本地仓库中

从新配置maven02的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.maven02</groupId>
  <artifactId>maven02</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>maven02 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

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

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.maven01</groupId>
      <artifactId>maven01</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>

  <build>
    <finalName>maven02</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.7.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.20.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

View Code

从新编译maven02

mvn dependency:tree - 查看依赖

运行命令： mvn dependency:tree

自动构建目录

maven03 - 自动构建目录

mvn archetype:generate - 按照提示进行选择构建

建立文件夹maven03

跳转盘符至maven03目录

运行命令： mvn archetype:generate

运行成功后会发现，目录已经自动构建了出来：

├─maven0301-service
│  │  pom.xml
│  │
│  └─src
│      ├─main
│      │  └─java
│      │      └─com
│      │          └─maven0301
│      │              └─service
│      │                      App.java
│      │
│      └─test
│          └─java
│              └─com
│                  └─maven0301
│                      └─service
│                              AppTest.java

mvn archetype:generate - 带参构建

跳转盘符至maven03目录

运行命令： mvn archetype:generate -DgroupId=com.maven0302 -DartifactId=maven0302-demo -Dversion=1.0-SNAPSHOT -Dpackage=com.maven0302.demo

DgroupId：组织名
DartifactId：项目名-模块名
Dversion：版本号
Dpackage：代码所存在的包名

└─maven0302-demo
    │  pom.xml
    │
    └─src
        ├─main
        │  └─java
        │      └─com
        │          └─maven0302
        │              └─demo
        │                      App.java
        │
        └─test
            └─java
                └─com
                    └─maven0302
                        └─demo
                                AppTest.java

坐标和仓库

坐标

在Maven中，任何一个依赖、插件或者项目构建的输出，均可以称之为构件。

每一个构建的位置，表明了一个坐标。

pom.xml的依赖配置 groupId 、 artifactId 、 version 便可标识一个坐标。

仓库

关于仓库的详解你们能够参考此博文，介绍的很详细！

仓库默认配置位置：%MAVEN_HOME%\lib\maven-model-builder-x.x.x.jar\org\apache\maven\model\pom-4.0.0.xml

生命周期和插件

关于生命周期和插件的详解你们能够参考此博文，介绍的很详细！

依赖范围

maven 项目不一样的阶段引入到classpath中的依赖是不一样的，例如，编译时，maven 会将与编译相关的依赖引入classpath中，测试时，maven会将测试相关的的依赖引入到classpath中，运行时，maven会将与运行相关的依赖引入classpath中，而依赖范围就是用来控制依赖于这三种classpath的关系。

在pom.xml依赖管理 dependency 有个设置依赖范围的标签 scope

关于依赖范围的设置，官方文档有详细说明。

compile：默认的范围，编译测试运行都有效
provided：测试和编译时有效
runtime：测试和运行时有效
test：测试时有效
system：测试和编译时有效，与本机系统相关联，可移植性差
import：导入的范围，它只使用在dependencyManagement中，表示从其它的pom中导入dependecy的配置

依赖传递

我新建了三个项目分别为：dependA、dependB、dependC

它们的依赖关系为：dependC ----> dependB ----> dependA

dependA的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.maven.dependA</groupId>
    <artifactId>dependA</artifactId>
    <version>1.0-SNAPSHOT</version>

</project>

View Code

dependB的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.maven.dependB</groupId>
    <artifactId>dependB</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>com.maven.dependA</groupId>
            <artifactId>dependA</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
    
</project>

View Code

dependC的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.maven.dependC</groupId>
    <artifactId>dependC</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>com.maven.dependB</groupId>
            <artifactId>dependB</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
    
</project>

View Code

我分别编译安装了它们，能够看到间接依赖是传递的。

dependA的依赖：

dependB的依赖：

dependC的依赖：

所依赖工程中pom.xml能够传递下去。

当第二依赖的范围scope 为compile 的时候, 依赖得以传递,传递性依赖的范围与第一直接依赖的范围一致。

当第二依赖的范围scope 为test 的时候, 依赖不会得以传递。

当第二依赖的范围是provided的时候，只传递第一直接依赖范围也为provided的依赖，且传递性依赖的范围一样为 provided。

当第二直接依赖的范围是runtime的时候，传递性依赖的范围与第一直接依赖的范围一致，但compile例外，此时传递的依赖范围为runtime。

依赖排除

若是dependC只依赖dependB而不须要依赖dependA，那么就须要进行依赖排除配置 exclusion

dependC的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.maven.dependC</groupId>
    <artifactId>dependC</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>com.maven.dependB</groupId>
            <artifactId>dependB</artifactId>
            <version>1.0-SNAPSHOT</version>
            <exclusions>
                <exclusion>
                    <groupId>com.maven.dependA</groupId>
                    <artifactId>dependA</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

</project>

View Code

依赖冲突

依赖冲突有两个原则：

短路优先

依赖关系：

dependA的依赖commons-io的版本为2.0

dependB的依赖commons-io的版本为2.1

dependC根据依赖所得到依赖commons-io的版本为2.1，由于dependC得到commons-io最近为dependB的依赖，因此使用dependB的版本2.1

声明优先

依赖关系：

若是dependC同时依赖dependA、dependB，也就是dependC获取依赖的路径长度相同了，则谁先在pom.xml中声明就优先获取谁的依赖。

聚合和继承

聚合

如何咱们的项目包含多个模块咱们一个一个编译，会太麻烦，咱们能够建一个聚合项目，经过modules来统一操做。

新建一个Maven项目aggreationABC，这里我使用 maven-archetype-quickstart

修改aggreationABC的pom.xml配置：

修改 packaging 标签的值为pom
添加 modules 标签，增长聚合配置

<?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.maven.aggreation</groupId>
  <artifactId>aggreationABC</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>

  <name>aggreationABC</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <modules>
    <module>../dependA</module>
    <module>../dependB</module>
    <module>../dependC</module>
  </modules>

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

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.7.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.20.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

View Code

对aggreationABC进行编译，发现已经完成聚合了。

继承

继承能够复用父类的pom，能够为咱们提升pom复用，子模块能够经过 parent 标签来导入要继承的pom。

依赖继承采用 dependencyManagement 用来统一管理，在子模块中须要那个依赖，只须要写groupId和artifactId就能够，采用依赖管理既能够有效的控制依赖，有能在必定程度上避免依赖冲突。

新建一个Maven项目mavenParent：

packaging 设置为pom
properties 增长字段属性 junit.version
dependencyManagement 管理依赖

<?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.maven.parent</groupId>
    <artifactId>mavenParent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <junit.version>4.11</junit.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

View Code

使用dependA来继承mavenParent，修改dependA的pom.xml添加 parent 标签来管理继承：

<?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.maven.dependA</groupId>
    <artifactId>dependA</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>com.maven.parent</groupId>
        <artifactId>mavenParent</artifactId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../mavenParent/pom.xml</relativePath>
    </parent>

</project>

View Code

至此dependA已继承mavenParent。

构建WEB项目

项目的建立能够参考上面的方式，这里我说明下具体过程，建立Maven项目，模板使用： maven-archetype-webapp

初始文件结构：

右键项目进行设置：

而后OK退出，开始配置tomcat

OK退出，启动tomcat

经常使用命令

mvn -v ：查看maven版本

mvn compile ：编译

mvn test ：测试

mvn package ：打包

mvn clean ：删除target

mvn install ：安装jar包到本地仓库中

mvn archetype:generate ：自动构建目录

mvn dependency:tree ：查看依赖

参考资料

https://maven.apache.org/index.html

https://www.imooc.com/learn/443

https://www.yiibai.com/maven/

https://www.cnblogs.com/1446358788-qq/articles/9597877.html

https://blog.csdn.net/shycx/article/details/7726600

https://blog.csdn.net/double_sweet1/article/details/79780308

https://www.cnblogs.com/bffc/p/3690993.html

http://how2j.cn/k/idea/idea-maven-web/1356.html

https://blog.csdn.net/wzx735481897/article/details/78158337

https://stackoverflow.com/questions/7600028/maven-error-in-opening-zip-file-when-running-maven

https://www.cnblogs.com/duanxz/p/5210189.html

https://www.cnblogs.com/luotaoyeah/p/3819001.html

1. Maven核心知识
2. Java基础核心之入门知识一
3. Kafka基础知识及核心概念入门
4. MySql入门基础知识
5. JSON入门基础知识
6. Lucene入门——基础知识
7. MySQL入门基础知识
8. c++基础知识入门
9. CodeMix入门基础知识
10. Angular基础知识入门
更多相关文章...
• 与传输层有关的基本知识 - TCP/IP教程
• Memcached入门教程 - NoSQL教程
• YAML 入门教程
• Java Agent入门实战（一）-Instrumentation介绍与使用