1 、区别
 
dependencies即使在子项目中不写该依赖项，那么子项目仍然会从父项目中继承该依赖项（全部继承）
 dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom;另外如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。
 
2、Dependencies应用场景
 
相对于dependencyManagement，所有生命在dependencies里的依赖都会自动引入，并默认被所有的子项目继承。
 
3 、DepencyManagement应用场景
 
当我们的项目模块很多的时候，我们使用Maven管理项目非常方便，帮助我们管理构建、文档、报告、依赖、scms、发布、分发的方法。可以方便的编译代码、进行依赖管理、管理二进制库等等。
 
由于我们的模块很多，所以我们又抽象了一层，抽出一个itoo-base-parent来管理子项目的公共的依赖。为了项目的正确运行，必须让所有的子项目使用依赖项的统一版本，必须确保应用的各个项目的依赖项和版本一致，才能保证测试的和发布的是相同的结果。
 
在我们项目顶层的POM文件中，我们会看到dependencyManagement元素。通过它元素来管理jar包的版本，让子项目中引用一个依赖而不用显示的列出版本号。Maven会沿着父子层次向上走，直到找到一个拥有dependencyManagement元素的项目，然后它就会使用在这个dependencyManagement元素中指定的版本号。
 
父类–Itoo-base-parent(pom.xml)
 
<dependencyManagement>            
        <dependencies>  
            <dependency>  
                <groupId>org.eclipse.persistence</groupId>  
                <artifactId>org.eclipse.persistence.jpa</artifactId>  
                <version>${org.eclipse.persistence.jpa.version}</version>  
                <scope>provided</scope>  
            </dependency>  
              
            <dependency>  
                <groupId>javax</groupId>  
                <artifactId>javaee-api</artifactId>  
                <version>${javaee-api.version}</version>  
            </dependency>  
        </dependencies>  
    </dependencyManagement> 
 
子类—Itoo-base(pom.xml)
 
<project>
     <!--继承父类-->  
     <parent>  
        <artifactId>itoo-base-parent</artifactId>  
        <groupId>com.tgb</groupId>  
  
        <version>0.0.1-SNAPSHOT</version>  
        <relativePath>../itoo-base-parent/pom.xml</relativePath>  
    </parent>  
    <modelVersion>4.0.0</modelVersion>  
    <artifactId>itoo-base</artifactId>  
    <packaging>ejb</packaging>  
          
    <!--依赖关系-->  
    <dependencies>  
        <dependency>  
            <groupId>javax</groupId>  
            <artifactId>javaee-api</artifactId>  
        </dependency>  
          
        <dependency>  
            <groupId>com.fasterxml.jackson.core</groupId>  
            <artifactId>jackson-annotations</artifactId>  
        </dependency>  
          
        <dependency>  
            <groupId>org.eclipse.persistence</groupId>  
            <artifactId>org.eclipse.persistence.jpa</artifactId>  
            <scope>provided</scope>  
        </dependency>  
    </dependencies>  
</project>  
 
这样做的好处：统一管理项目的版本号，确保应用的各个项目的依赖和版本一致，才能保证测试的和发布的是相同的成果，因此，在顶层pom中定义共同的依赖关系。同时可以避免在每个使用的子项目中都声明一个版本号，这样想升级或者切换到另一个版本时，只需要在父类容器里更新，不需要任何一个子项目的修改；如果某个子项目需要另外一个版本号时，只需要在dependencies中声明一个版本号即可。子类就会使用子类声明的版本号，不继承于父类版本号。
 
总结区别：
 
中的jar直接加到项目中，管理的是依赖关系（如果有父pom,子pom,则子pom中只能被动接受父类的版本）；主要管理版本，对于子类继承同一个父类是很有用的，集中管理依赖版本不添加依赖关系，对于其中定义的版本，子pom不一定要继承父pom所定义的版本。

1、DepencyManagement应用场景
 当我们的项目模块很多的时候，我们使用Maven管理项目非常方便，帮助我们管理构建、文档、报告、依赖、scms、发布、分发的方法。可以方便的编译代码、进行依赖管理、管理二进制库等等。
 
     由于我们的模块很多，所以我们又抽象了一层，抽出一个itoo-base-parent来管理子项目的公共的依赖。为了项目的正确运行，必须让所有的子项目使用依赖项的统一版本，必须确保应用的各个项目的依赖项和版本一致，才能保证测试的和发布的是相同的结果。

    在我们项目顶层的POM文件中，我们会看到dependencyManagement元素。通过它元素来管理jar包的版本，让子项目中引用一个依赖而不用显示的列出版本号。Maven会沿着父子层次向上走，直到找到一个拥有dependencyManagement元素的项目，然后它就会使用在这个dependencyManagement元素中指定的版本号。
 
来看看我们项目中的应用：
 
                                                                                          pom继承关系图：
 
 
父项目的dependencyManagement
 
<dependencyManagement>
		
		<dependencies>
			<dependency>
				<groupId>org.eclipse.persistence</groupId>
				<artifactId>org.eclipse.persistence.jpa</artifactId>
				<version>${org.eclipse.persistence.jpa.version}</version>
				<scope>provided</scope>
			</dependency>
			
			<dependency>
				<groupId>javax</groupId>
				<artifactId>javaee-api</artifactId>
				<version>${javaee-api.version}</version>
			</dependency>
		</dependencies>
	</dependencyManagement>
 
子项目：dependencies
 
<!--继承父类-->
<parent>
		<artifactId>itoo-base-parent</artifactId>
		<groupId>com.tgb</groupId>
 
		<version>0.0.1-SNAPSHOT</version>
		<relativePath>../itoo-base-parent/pom.xml</relativePath>
	</parent>
		<modelVersion>4.0.0</modelVersion>
		<artifactId>itoo-base</artifactId>
		<packaging>ejb</packaging>
		
		<!--依赖关系-->
		<dependencies>
		<dependency>
			<groupId>javax</groupId>
			<artifactId>javaee-api</artifactId>
		</dependency>
		
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-annotations</artifactId>
		</dependency>
		
		<dependency>
			<groupId>org.eclipse.persistence</groupId>
			<artifactId>org.eclipse.persistence.jpa</artifactId>
			<scope>provided</scope>
		</dependency>
	</dependencies>
</project>
 
这样做的好处：统一管理项目的版本号，确保应用的各个项目的依赖和版本一致，才能保证测试的和发布的是相同的成果，因此，在顶层pom中定义共同的依赖关系。同时可以避免在每个使用的子项目中都声明一个版本号，这样想升级或者切换到另一个版本时，只需要在父类容器里更新，不需要任何一个子项目的修改；如果某个子项目需要另外一个版本号时，只需要在dependencies中声明一个版本号即可。子类就会使用子类声明的版本号，不继承于父类版本号。
 
2、Dependencies
 相对于dependencyManagement，所有生命在dependencies里的依赖都会自动引入，并默认被所有的子项目继承
 
3、区别
 dependencies即使在子项目中不写该依赖项，那么子项目仍然会从父项目中继承该依赖项（全部继承）
 dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom;另外如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。
 
4、Maven约定优于配置
 它提出这一概念，为项目提供合理的默认行为，无需不必要的配置。提供了默认的目录
 src ——> 源代码和测试代码的根目录
 
main 应用代码的源目录
 
java 源代码
 
resources 项目的资源文件
 
test 测试代码的源目录
 
java 测试代码
 
resources 测试的资源文件
 
target 编译后的类文件、jar文件等
 对于Maven约定优于配置的理解，一方面对于小型项目基本满足我们的需要基本不需要自己配置东西，使用Maven已经配置好的，快速上手，学习成本降低；另一方面，对于不满足我们需要的还可以自定义设置，体现了灵活性。配置大量减少了，随着项目变的越复杂，这种优势就越明显。

Maven简介
 
Maven是什么
 
Maven翻译为“专家、行家”。Maven是Apache下一个纯Java语言开发 开源项目。
 
是Apache的顶级项目
 
下载地址： http://maven.apache.org/
 
是一个项目管理工具，使用Maven对Java项目进行构建（打包）、依赖管理（jar）。
 
目前使用Maven管理的项目持续增长。
 
使用Maven有什么好处
 
依赖管理
 
就是对Jar包的统一管理，可以节省空间。
 
什么是依赖？
 
一个Java项目可能要使用到一些第三方的Jar包才可以运行，那么我们说这个Java项目依赖于这些第三方的Jar包。
 
举一个例子：一个CRM（客户关系管理系统）项目，它的系统架构师SSM，该CRM项目依赖于SSM框架，具有依赖Spring，SpringMvc,Mybatis.
 
         什么是依赖管理：就是对项目中 所有依赖的Jar包 进行规范化管理
 
一键构建
 
编码编译测试（Junit）、运行打包部署
 
普通java项目：jar包
 
Java web项目：war包
 
Method ->class ->.java->jar ->war
 
War可以直接丢在Tomcat的webapp目录
 
可以跨平台
 
在window，linux都可以运行
 
Java语言本身就是跨平台的。
 
应用在大型项目可以提交开发效率
 
分析：
 
         商品模块、用户模块、订单模块、地址模块、支付模块。
 
Maven的分模块开发（父子工程）
 
         互联网项目：业务来划分模块
 
         传统项目：按照层来划分，entity，dao,service,web
 
Maven的安装部署
 
可以分为三个步骤
 
第一步：下载Maven的安装包
 
第二步：解压Maven的安装包，注意，存放Maven安装包的路径不要有中文存在
 
第三步：配置环境变量，当环境变量配置好以后，可以在cmd命令提示符窗口下输入 mvn -v 检查安装好的maven的版本
 
              如果提示错误信息，没有正确显示，则说明配置错误。
 
可以参考百度经验提供的详细步骤：https://jingyan.baidu.com/article/2f9b480ddc1c5d41cb6cc217.html
 
maven仓库
 
是什么
 
仓库：存储东西的地方。
 
maven仓库：存储Jar包的地方，存储jar包的目录。
 
maven有3种仓库
 
本地仓库
 
每台使用Maven的机器就是一个本地仓库，你自己电脑上放Jar包的位置。
 
需要自己维护
 
修改本地仓库地址
 
Conf/settings.xml
 
 
 
远程仓库（私服）
 
公司维护
 
一个公司有一个远程仓库，公司开发团队共用，局域网中。
 
中央仓库
 
Maven团队维护的，
 
所有人共享
 
比如：想开源一个jar包，给别人用，告诉别人配置文件怎么写即可。
 
Maven目录结构
 
 
如何建立一个Maven项目
 
首先打开IDEA，新建项目
 
 
然后选择Maven项目，此处先不选择模板架构
 
 
然后点击下一步，输入新建项目信息，点击下一步
 
 
会出现如下图所示信息，点击完成
 
 
这样一个简单的Java的Maven项目就配置好了
 
配置Maven
 
maven项目建立好以后，还要对项目进行maven设置，步骤如下
 
第一步
 
 
第二步：
 
 
第三步：
 
 
这样Maven就配置好了。
 
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>




    <!--项目名称：组织名+项目名，和包名类似-->
    <groupId>com.hyx</groupId>
    <!--模块名称-->
    <artifactId>Maven-learning</artifactId>
    <!--版本-->
    <version>1.0-SNAPSHOT</version>
    <!--打包方式：
       jar:执行package会打成jar包，一般是Java项目
       war:执行Package会打成war包，一般是JavaWeb项目
       pom:用于父子工程，将父工程设置为pom
       -->
    <packaging>jar</packaging>


</project>
 
如何建立一个JaveWeb项目
 
方法一：将建立好的Java项目改成JavaWeb项目
 
第一步：添加文件夹与文件，web.xml可以从已有的JavaWeb项目中复制
 
 
第二步：修改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>




    <!--项目名称：组织名+项目名，和包名类似-->
    <groupId>com.hyx</groupId>
    <!--模块名称-->
    <artifactId>Maven-learning</artifactId>
    <!--版本-->
    <version>1.0-SNAPSHOT</version>
    <!--打包方式：
       jar:执行package会打成jar包，一般是Java项目
       war:执行Package会打成war包，一般是JavaWeb项目
       pom:用于父子工程，将父工程设置为pom
       -->
   <packaging>war</packaging>

    <properties>
        <servlet-api.version>2.5</servlet-api.version>
    </properties>
    
    //为项目添加依赖
    <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>${servlet-api.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>


</project>
 
告诉Maven我是一个Web项目
 
第一步：
 
 
第二步：
 
 
第三步：
 
 
第四步：设置成打包为jar包
 
 
 第五步：配置Tomcat
 
 
给配置的Tomcat起一个名字，并选择版本
 
 
之后配置Deployment
 
 
这些工作完成后，可以在IDEA中使用控制台执行打包命令，就可以看到一个JavaWeb 的war包打包成功
 
点击运行也可以在网页中看到Hello World 的字样
 
 
Maven常用命令
 
Maven常用命令
 
Clean:清除编译之后的文件
 
删除target目录
 
 
 
Compile:编译主目录的文件
 
编译之后，在target目录下会有编译之后的文件.class
 
Package打包
 
普通项目：.jar
 
Javaweb项目：war
 
Test:编译并运行test目录的代码
 
编译、运行Test目录的代码
 
Install把项目部署到本地仓库
 
将你负责的这一块功能，打车Jar包给团队其他人使用。
 
tomcat:run 一键启动
 
javaweb项目才使用。
 
如何导入一个Maven项目
 
第一步：
 
 
第二步：
 
 
第三步：
 
.
 
第四步：
 
 
第五步：
 
 
第六步：
 
 
第七步：
 
 
这样就导入了一个Maven项目

事情的背景是这样的，部门有一个maven聚合项目需要做架构调整，正好是由我来负责。由于项目比较大，子项目比较多，子项目之间的依赖关系复杂等等，所以调整起来也比较麻烦，遇到问题也是在所难免。
 
下面就来讲述一下，子项目引用父项目中properties属性导致编译报错问题，我是怎么遇到的，又是如何解决的。
 
 
 
1、遇到问题
 
一开始遇到这个问题，我是懵的，我无非就是对各个子项目执行maven compile操作来验证编译是否通过，当某个子项目编译报错时，我完全不知道问题的源头在哪里，因此我只能查看控制台信息，如下图所示。
 
 
我找到了上图中被红色框框住的那行关键的Error日志。
 
[ERROR] Failed to execute goal on project skpd-api-system:
 
    Could not resolve dependencies for project com.skpd:skpd-api-system:jar:2.2.0:
 
        Failed to collect dependencies at com.skpd:skpd-commons:jar:2.2.0:
 
            Failed to read artifact descriptor for com.skpd:skpd-commons:jar:2.2.0:
 
                Could not find artifact com.skpd:skpd-cloud:pom:${skpd.version} in user-central (http://192.168.83.161:8081/nexus/content/groups/public/) 
  
 
这行日志告诉我们，在编译skpd-api-system，其依赖关系是这样的com.skpd:skpd-api-system:jar:2.2.0->com.skpd:skpd-commons:jar:2.2.0-> com.skpd:skpd-cloud:pom:${skpd.version}
 
问题就出在最后那个${skpd.version}，为什么前面的pom都能将${skpd.version}成功解析为2.2.0，而最后一个不能呢？
 
 
 
2、回显问题
 
因此，我新建了一个用于测试的maven聚合项目，来回显部门项目的问题。项目结构如下。
 
 
 
 
父项目parent-test的pom.xml如下。
 
<groupId>com.bobo</groupId>
    <artifactId>parent-test</artifactId>
    <version>${my.version}</version>
    <modules>
        <module>child-1</module>
        <module>child-2</module>
    </modules>
    <packaging>pom</packaging>
    <properties>
        <my.version>1.0</my.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.bobo</groupId>
                <artifactId>child-2</artifactId>
                <version>${my.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
 
子项目child-1的pom.xml如下。
 
<parent>
        <groupId>com.bobo</groupId>
        <artifactId>parent-test</artifactId>
        <version>${my.version}</version>
    </parent>
    <artifactId>child-1</artifactId>
    <dependencies>
        <dependency>
            <groupId>com.bobo</groupId>
            <artifactId>child-2</artifactId>
        </dependency>
    </dependencies>
 
子项目child-2的pom.xml如下。
 
<parent>
        <groupId>com.bobo</groupId>
        <artifactId>parent-test</artifactId>
        <version>${my.version}</version>
    </parent>
    <artifactId>child-2</artifactId>
 
 
 
当对child-1项目进行编译时，就会报出同样的问题。关键的Error日志如下所示。
 
[ERROR] Failed to execute goal on project child-1:
 
    Could not resolve dependencies for project com.bobo:child-1:jar:1.0:
 
        Failed to collect dependencies at com.bobo:child-2:jar:1.0:
 
            Failed to read artifact descriptor for com.bobo:child-2:jar:1.0:
 
                Failure to find com.bobo:parent-test:pom:${my.version} in https://maven.aliyun.com/repository/public 
 
 
 
3、解决问题
 
最终我发现，在编译聚合项目时，有时候不能对子项目单独进行编译，为什么是有时候呢？像上面的child-2项目，单独编译它就没问题，而child-1项目单独编译就有问题了，这是因为child-1项目还依赖了child-2项目。
 
因为当出现此类问题时，要针对父项目进行编译，比如上面例子中的parent-test，编译父项目会连同它的所有子项目一起编译了，这样就不会出现类似上面的问题了。
 
 
 
但是，由于编译父项目会连同它的所有子项目一起编译，如果某个子项目是有问题的呢？这样就会导致整个聚合项目都编译失败。
 
假设我们有一个子项目叫child-3，child-3是有问题的，我们可以在父项目的modules标签中移除child-3从而保证除child之外的项目编译成功，最后再单独解决child-3项目的问题，如下图所示。
 
 
 
 
好了，今天的问题就总结到这了，归根结底还是由于对maven理解不深导致的，希望这篇文章对你有帮助。