Maven实战-第四篇（Maven的依赖配置）

在之前文章中，我们已经介绍过了，如果要在Maven中添加新的依赖则需要使用dependencies标签来配置Maven的依赖，并且我们已经介绍过了很多有关依赖元素的配置。例如：groupId、artifactId、version等。但上面的内容只是我们比较常见的配置，实际上Maven为了满足我们很多需求场景，提供了很多额外的配置，具体的配置如下：

＜dependencies＞
    ＜dependency＞
        ＜groupId＞……＜/groupId＞
        ＜artifactId＞……＜/artifactId＞
        ＜version＞……＜/version＞
        ＜type＞……＜/type＞
        ＜scope＞……＜/scope＞
        ＜optional＞……＜/optional＞
        ＜exclusions＞
            ＜exclusion＞……＜/exclusion＞
        ＜/exclusions＞
    ＜/dependency＞
＜/dependencies＞

上面的部分标签我们在之前的文章中已经介绍过了，下面我们重点介绍一下没有介绍过的标签的作用：

一、type

依赖的类型，也就是引入其它依赖组件packaging指定的类型。所以该标签可以选择的参数为jar、war、pom。且在Maven中默认的type类型为jar。也就是将改依赖的jar包引入到项目中，war参数也是如些。下面我们验证一下。

首先我们先创建一个Maven的项目，因为之前的内容已经详细介绍过怎么创建了，所以我们这里就不做过多的介绍了。我们直接创建一个midai-mazhe-maven项目。

Maven实战-第四篇（Maven的依赖配置）

然后我们写一个测试类测试一下项目。

MaZheMaven

public class MaZheMaven {
    public static void main(String[] args) {
        System.out.println("Hello World MaZhe Maven");
    }
}

输出

Hello World MaZhe Maven

Maven实战-第四篇（Maven的依赖配置）

通过上图证明了我们刚刚创建的项目是没有任何问题的。下面我们还是和之前一样创建一个对象然后使用fastjson工具类转成json。

Userinfo

public class Userinfo {
    private String username;
    private String password;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "Userinfo{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

MaZheMaven

import com.alibaba.fastjson.JSONObject;

public class MaZheMaven {
    public static void main(String[] args) {
        System.out.println(JSONObject.toJSONString("Hello World MaZhe Maven"));
        printJson();
    }

    public static void printJson(){
        Userinfo userinfo = new Userinfo();
        userinfo.setUsername("mazhe");
        userinfo.setPassword("maven");
        System.out.println(JSONObject.toJSONString(userinfo));
    }
}

由于上面的代码非常的简单，我们就不详细介绍了。下面我们将上面的项目打成包。也就是使用Maven中的install命令。下面我们在项目的根目录中执行下面的命令：

mvn clean install

上面实际上是两个命令，install命令我们介绍过，就是将依赖包安装到达本地仓库中。而clean命令的作用就是清理的意思。我们知道当执行Maven命令编译或者打包时，当执行完成后，会在项目的根目录中创建一个target目录，然后Maven将相应的jar包生成到这个目录中。而clean命令的作用就是删除这个目录。如果我们不执行clean命令，而直接执行install命令而Maven并不会自动删除之前target目录下生成的内容。所以为了方便，也为了我们不会使用错jar包。我们实际的工作中基本上会联合使用上面的命令。

Maven实战-第四篇（Maven的依赖配置）

我们之前也介绍过，当使用install命令安装成功后，会将这个依赖包安装到本地的仓库中，这样的好处是其它项目也可以通过Maven依赖的配置引入到自己的项目中。下面我们在创建一个新的项目，来测试一下。

Maven实战-第四篇（Maven的依赖配置）

这次我们添加一个测试类测试一下代码。为了我们可以使用测试用例，所以我们需要添加junit依赖包，具体配置如下：

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>cn.ma-zhe</groupId>
    <artifactId>mazhe-maven</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>
    </dependencies>

</project>

下面我们创建一个测试类，简单输出一句话，来验证，我们引入的依赖包，没有任何问题。

MazheMaveTest

import org.junit.Test;

public class MazheMavenTest {
    @Test
    public void test(){
        System.out.println("Hello World Mazhe Maven");
    }
}

输出

Hello World Mazhe Maven

Maven实战-第四篇（Maven的依赖配置）

看上图所示，我们成功引入了junit依赖了。下面我们引入我们上一个项目的依赖，看一下能否直接使用。具体配置如下：

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>cn.ma-zhe</groupId>
    <artifactId>mazhe-maven</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>
        <dependency>
            <groupId>cn.ma-zhe</groupId>
            <artifactId>midai-mazhe-maven</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

下面我们直接在测试类中使用上一个项目的代码，看一下是否能直接使用。

MazheMavenTest

import org.junit.Test;

public class MazheMavenTest {
    @Test
    public void test(){
        MaZheMaven.printJson();
    }
}

输出

{"password":"maven","username":"mazhe"}

Maven实战-第四篇（Maven的依赖配置）

我们看上图所示，我们成功了引入了上个项目的依赖。因为默认type的参数的值为jar。所以我们上述的配置实际上就是验证了引入外部依赖包的功能。那么对于war的参数配置也是一样。下面我们验证一下如果将type的参数设置为pom，然后我们在从另外的项目中引入会有什么效果呢？下面我们尝试一下。首先在midai-mazhe-maven项目中将packaging参数设置为pom。配置如下：

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>cn.ma-zhe</groupId>
    <artifactId>midai-mazhe-maven</artifactId>
    <version>1.0-SNAPSHOT</version>

    <packaging>pom</packaging>

    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.6</version>
        </dependency>
    </dependencies>

</project>

下面我们在修改一下mazhe-maven项目的pom.xml文件。将刚刚引入的midai-mazhe-maven项目的依赖配置的type参数配置成pom。
然后我们在观察一下测试类的代码，看看有啥不同。

Maven实战-第四篇（Maven的依赖配置）

我们看midai-mazhe-maven项目中的MaZheMaven显示报错了，这就表明了，我们这个项目中并没有成功的引入这个类的依赖。这个就是type参数配置成pom的左右。当然这样配置时，Maven并不会引入这个项目本身的任何依赖类，所以我们这个项目中也就引入不到MaZheMaven类了。那这时可能有人想问了，那这样我还引入这个依赖包干什么呢？当这样配置时，虽然Maven不会引入这个依赖包项目本身的代码，但是它将这个项目的配置依赖引入到新项目中，可以简单的理解为将这个项目的pom.xml中的配置引入过来。因为midai-mazhe-maven项目的pom.xml中引入了fastjson依赖，下面我们看一下，我们直接在mazhe-maven项目中是否可以直接使用这个依赖呢？如果可以则说明了，当将type参数配置成pom时，确实会引入依赖配置。下面我们尝试一下。

MazheMavenTest

import com.alibaba.fastjson.JSONObject;
import org.junit.Test;

public class MazheMavenTest {
    @Test
    public void test(){
//        MaZheMaven.printJson();
        System.out.println(JSONObject.toJSONString("Hello World Mazhe Maven"));
    }
}

输出

"Hello World Mazhe Maven"

Maven实战-第四篇（Maven的依赖配置）

我们看上图所示，成功的使用了fastjson的工具类了，虽然我们项目本身没有引入fastjson的依赖，但是因为我们引入了midai-mazhe-maven项目，该项目配置了fastjson的依赖。所以本项目可以直接使用。这就是type参数的作用。

二、scope

依赖的范围。通过此标签可以指定Maven的打包行为。下面我们介绍一下，scope参数都有哪些配置参数：

compile

编译的依赖范围。该依赖访问是一个比较强的依赖，配置此依赖的依赖包，将参与项目的编译、测试、运行等操作，并且在项目打包时，会将此依赖包部署到打包文件中。该依赖也是Maven中scope参数的默认配置。

下面我们通过示例验证一下，上面说的内容。首先我们引入一个依赖包也就是之前介绍过的fastjson依赖包，具体配置如下：

<?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>cn.ma-zhe</groupId>
    <artifactId>midai-mazhe-maven</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.6</version>
        </dependency>
    </dependencies>

</project>

按照上面介绍的，当我们什么都不指定的时候，scope参数的默认配置为：compile。下面我们创建两个类，一个在项目的主代码目录中，一个在项目的测试目录中。

MaZheMaven

import com.alibaba.fastjson.JSONObject;

public class MaZheMaven {
    public static void main(String[] args) {
        System.out.println(JSONObject.toJSONString("Hello World MaZhe Maven"));
    }
}

Maven实战-第四篇（Maven的依赖配置）

MaZheMavenTest

import com.alibaba.fastjson.JSONObject;

public class MaZheMavenTest {
    public static void main(String[] args) {
        System.out.println(JSONObject.toJSONString("Hello World MaZhe Maven Test"));
    }
}

Maven实战-第四篇（Maven的依赖配置）

由于compile依赖范围的是针对编译、测试和运行都是有效的，所以上面的代码均可运行，都可以引入fastjson的依赖包。

test

测试的依赖范围。顾名思义，该依赖只对测试环境有效，所以当配置为此依赖时，并不会参与项目的编译和运行，打包时也不会将此依赖部署到打包文件中。该依赖最常使用的场景就是测试用例的依赖。

同样样我们也验证一下test的配置范围。我们将之前引入的fastjson依赖包的scope的参数修改为test。

<?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>cn.ma-zhe</groupId>
    <artifactId>midai-mazhe-maven</artifactId>
    <version>1.0-SNAPSHOT</version>

    <packaging>pom</packaging>

    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.6</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

然后我们什么不都修改，在看一下上面的两具类的代码有啥变化。

MaZheMaven

Maven实战-第四篇（Maven的依赖配置）

MaZheMavenTest

Maven实战-第四篇（Maven的依赖配置）

如上图所示，我们看到MaZheMaven类报错了。这是因为上面所说的，test的依赖范围只对测试环境有效，其它环境均是无效的。因为MaZheMaven类在主代码目录中，所以报错了。下面我们打包一下这个项目，看一下test范围的依赖包会不会生成在打包文件中。在执行打包命令前，需要将MaZheMaven类的代码注释，否则会报编译失败错误。

runntime

运行时依赖范围。该依赖范围适用于运行和测试范围。在编译的环境下不会被使用。最常使用的场景就是数据库的驱动依赖，因为只有项目运行时才会被使用。

我们继续将scope参数修改为runntime看一下代码的效果。

1、pom.xml

Maven实战-第四篇（Maven的依赖配置）

2、MaZheMaven

Maven实战-第四篇（Maven的依赖配置）

3、MaZheMavenTest

Maven实战-第四篇（Maven的依赖配置）

我们看上图所示，因为runntime依赖范围是对运行和测试有效的，所以主代码中的依赖依赖报错了，而测试目录中代码则没有任何问题。

provided

此依赖范围适用于编译和测试范围。项目打包时并不会打包此依赖范围的依赖。最常用的使用场景是servlet相应的依赖。因为该依赖范围，必须在容器中运行，容器中已经有了相关的jar包所以不需要额外添加了。

我们继续将scope参数修改为provided看一下代码的效果。

1、pom.xml

Maven实战-第四篇（Maven的依赖配置）

2、MaZheMaven

Maven实战-第四篇（Maven的依赖配置）

3、MaZheMavenTest

Maven实战-第四篇（Maven的依赖配置）

还是如图所示，我们看这次主代码的和测试代码都没有报错。这是因为provided参数的依赖范围是针对编译和测试环境的，所以主代码报错的问题也就不存在了。

system

此依赖范围适用于编译和测试范围。和provided参数一致，不同的地方在于，此依赖配置需要添加额外的配置，因为此依赖配置不是从Maven中获取依赖的，于是通过系统中配置的路径获取依赖的。具体的配置如下：

<scope>system</scope>
<systemPath>../fastjson-2.0.6.jar</systemPath>

我们继续将scope参数修改为system看一下代码的效果。

1、pom.xml

Maven实战-第四篇（Maven的依赖配置）

2、MaZheMaven

Maven实战-第四篇（Maven的依赖配置）

3、MaZheMavenTest

Maven实战-第四篇（Maven的依赖配置）

三、optional

下面我们介绍一下optional参数，该参数的作用是标记依赖是否可选。当参数设置为true时，则表示子项目不会依赖此组件。也可以理解为子项目并不会继承这个依赖。由于我们后续的内容中会详细的介绍这个参数的作用，所以这里就不在做过多的介绍和项目演示了了。

四、exclusions

exclusions参数的目的是排除传递性依赖。由于传递性依赖的内容，我们也将在后续的内容中在做详细介绍，所以本篇也不在做项目演示了。

{{userData.name}}已认证

一、type

二、scope

三、optional

四、exclusions

Maven实战-第三篇（Maven中的坐标）

Maven实战-第五篇（Maven的传递性依赖）

Maven实战-第一篇（Maven的基本信息）

Maven实战-第十八篇（Maven中的默认约定）

Maven实战-第十七篇（Maven中的依赖管理）

Maven实战-第二十一篇（Nexus中的仓库）

Maven实战-第二十三篇（用Maven进行代码测试）

Maven实战-第十一篇（Maven中的镜像）