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

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

在多个开发团队环境时，Maven可以设置按标准在非常短的时间里完成配置工作。由于大部分项目的设置都很简单，并且可重复使用，Maven让开发人员的工作更轻松，同时创建报表，检查，构建和测试自动化设置。

概括地说，Maven简化和标准化项目建设过程。处理编译，分配，文档，团队协作和其他任务的无缝连接。 Maven增加可重用性并负责建立相关的任务。

安装配置

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

下载压缩包

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

解压安装

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

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

配置环境变量

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

MAVEN_HOME

PATH

依次确定，退出配置。

配置Maven

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

配置本地存储库

添加配置

<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>

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

创建HelloWorld.java

package com.maven01.model;

public class HelloWorld {

    public String sayHello() {

        return "Hello World !!";

    }

}

在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());

    }

}

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>

在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();

    }

}

在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());

    }

}

这时我们使用编译命令，尝试编译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>

重新编译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>

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>

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>

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

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>

依赖冲突

依赖冲突有两个原则：

短路优先

依赖关系：

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>

对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>

使用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>

至此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

Maven基础入门与核心知识的更多相关文章

搭建 Maven ---基础入门
这篇随笔从最基础的控制台搭建maven讲,后面再升入的讲解IDEA搭建Maven. 一,Maven是什么?作用是什么? Maven是一个项目管理工具,它包含了一个项目对象模型 (Project O ...
[转载]maven基础入门
用 Maven 做项目构建本文转载自:https://www.ibm.com/developerworks/cn/java/j-lo-maven/ 本文将介绍基于 Apache Maven 3 的项 ...
【Maven基础入门】02 了解POM文件构建
温故上一节我们说过:Maven 是一个基于POM文件的构建工具,当然离不开POM文件 POM文件是一个XML标记语言表示的文件,文件就是:pom.xml 一个POM文件包含了项目的基本信息,用于描述 ...
【Maven基础入门】01 Maven的安装与环境变量的配置
写在前面: Mavne,作为一个优秀的项目构建工具,虽说我们平时在使用的时候或多或少的会使用到它,但了解仅限于它能构建项目,然后其他的就不知道了. 以及仓库.POM父类文件.等等. 工欲善其事,必先利 ...
1.0 Android基础入门教程
1.0 Android基础入门教程分类 Android 基础入门教程本教程于2015年7月开始撰写,耗时半年,总共148节,涵盖了Android基础入门的大部分知识,由于当时能力局限,虽已竭尽全力 ...
Python知识（1）----基础入门和进阶总结。
今天把Python的语法过了一遍,学习了慕课网上的教程,简单易懂,1个小时就可以入门Python了.Python有两个主要的版本,Python2.7,Python3.5,后面的版本,改动较大,编写的程 ...
《Maven实战》关联实际工作的核心知识
通读了<Maven实战>这本书,由于在实际的工作中,对其有一定的操作上的经验.因此,再回头去通读这本书,就能够更加精准的把握里面的核心知识了. 以下我主要从两点去介绍之—— 1> m ...
Linux（1）- 服务器核心知识、Linux入门、VMware与centeos安装、远程连接linux、linux基本命令使用
一.服务器核心知识 1.电脑和电脑的硬件组成现在的人们几乎无时无刻不在使用着电脑!不管是桌上型电脑(桌机).笔记型电脑(笔电).平板电脑,还是智慧型手机等等,这些东西都算是电脑.虽然接触这么多,但是 ...
零基础的学习者应该怎么开始学习呢？Python核心知识学习思维分享
近几年,Python一路高歌猛进,成为最受欢迎的编程语言之一,受到无数编程工作者的青睐. 据悉,Python已经入驻部分小学生教材,可以预见学习Python将成为一项提高自身职业竞争力的必修课.那么零 ...

随机推荐

Mysql免安装版配置教程和常用命令图
Mysql免安装版配置教程图文版配置环境变量新建一个my.ini文件,添加下面内容 [mysqld] basedir=C:\\software\Mysql\mysql-5.7.14-winx64 ...
[十四]基础类型之StringBuffer 与 StringBuilder对比
StringBuilder 和 StringBuffer是高度类似的两个类 StringBuilder是StringBuffer的版本改写,下面从几个方面简单的对比下他们的区别类继承关系上文中,我 ...
记一次vue长列表的内存性能分析和优化
好久没写东西,博客又长草了,这段时间身心放松了好久,都没什么主题可以写了上周接到一个需求,优化vue的一个长列表页面,忙活了很久也到尾声了,内存使用和卡顿都做了一点点优化,还算有点收获写的有点啰嗦 ...
Docker网络（五）--技术流ken
本章内容 1.dokcer默认自带的几种网络介绍 2. 自定义网络 3. 容器间通信 4. 容器与外界交互 docker网络分为单个主机上的容器网络和多个主机上的哇网络,本文主要讲解单个主机上的容器网 ...
【响应式编程的思维艺术】（1）Rxjs专题学习计划
目录一. 响应式编程二. 学习路径规划一. 响应式编程响应式编程,也称为流式编程,对于非前端工程师来说,可能并不是一个陌生的名词,它是函数式编程在软件开发中应用的延伸,如果你对函数式编程还没有 ...
接口测试之深入理解HTTPS
前言随着网络安全问题越来越被重视,HTTPS协议的使用已经逐渐主流化.目前的主流站点均已使用了HTTPS协议:比如:百度.淘宝.京东等一二线主站都已经迁移到HTTPS服务之上.而作为测试人员来讲,也 ...
Java开发笔记（三十）大小数BigDecimal
前面介绍的BigInteger只能表达任意整数,但不能表达小数,要想表达任意小数,还需专门的大小数类型BigDecimal.如果说设计BigInteger的目的是替代int和long类型,那么设计Bi ...
ueditor笔记
一.ueditor是什么 UEditor 是由百度「FEX前端研发团队」开发的所见即所得富文本web编辑器,具有轻量,可定制,注重用户体验等特点,开源基于MIT协议,允许自由使用和修改代码. 二.ue ...
javaweb中上传图片并显示图片，用我要上传课程信息（里面包括照片）这个例子说明
原理: 从客户端上传到服务器照片——文件夹——数据库例如:桌面一张照片,在tomacat里创建upload文件夹,把桌面照片上传到upload文件夹里,并且把照片的 ...
nginx系列2：搭建nginx环境
我们选择编译安装nginx. 1,下载nginx 进入nginx的官网下载页面:http://nginx.org/en/download.html 找到稳定版本Stable version的下载入口开 ...

Maven基础入门与核心知识