zoukankan      html  css  js  c++  java

  • Maven核心概念之依赖，聚合与继承

     

                               

    一、依赖

            我们项目中依赖的jar包可以通过依赖的方式(dependencies元素下添加dependency子元素)引入。       

    [html] view plain copy print?
    1. <dependency>  
    2.   
    3.    <groupId>junit</groupId>  
    4.   
    5.    <artifactId>junit</artifactId>  
    6.   
    7.    <version>4.10</version>  
    8.   
    9.  </dependency>  
       <dependency>

      <groupId>junit</groupId>

      <artifactId>junit</artifactId>

      <version>4.10</version>

    </dependency>

    1.依赖范围

            通过控制依赖的范围，可以指定该依赖在什么阶段有效。         

    [html] view plain copy print?
    1. <dependency>  
    2.   
    3.      <groupId>junit</groupId>  
    4.   
    5.      <artifactId>junit</artifactId>  
    6.   
    7.      <version>4.10</version>  
    8.   
    9.      <scope>test</scope>  
    10.   
    11.    </dependency>  
     <dependency>

      <groupId>junit</groupId>

      <artifactId>junit</artifactId>

      <version>4.10</version>

      <scope>test</scope>

    </dependency>

               maven的几种依赖范围(<scope></scope>)

    名称

    有效范围

    Compile

    编译，测试，运行。默认的依赖范围

    Test

    测试，如Junit

    Runtime

    运行，如JDBC

    Provided

    编译，测试，如ServletAPI 

    System

    编译，侧四，依赖于系统变量

    2.依赖具有传递性

    2.1依赖传递的规则

           

                规则-级别一样，就先用第一个，级别不一样，就用级别最少的

                解释：级别（依赖的层次）一样的，就按照顺序，依赖第一个（层次为0）；如果出现层次（层次>0），就先依赖层次最少的；

    2.2去除依赖的两种方式

    选择性依赖

             在依赖中用<optional>直接去除这种依赖传递的特性，也就是说，如果别的项目引用设置了此依赖的项目，这个commons-longging不会被依赖到。例如在项目A中配置commons-logging的依赖，如果项目B依赖项目A，那么，此时项目B中不会依赖commons-logging了。

     
    1. <!-- 排除依赖 -->   
    2.   
    3.  <dependency>  
    4.   
    5.  <groupId>commons-logging</groupId>  
    6.   
    7.  <artifactId>commons-logging</artifactId>  
    8.   
    9.  <version>1.1.1</version>  
    10.   
    11.  <optional>true<optional>  
    12.   
    13.  </dependency>  
    <!-- 排除依赖 --> 

 <dependency>

 <groupId>commons-logging</groupId>

 <artifactId>commons-logging</artifactId>

 <version>1.1.1</version>

 <optional>true<optional>

 </dependency>

    排除依赖

             如果第三方的jar包没有用<optional>去除依赖的传递性，那么我们可以在当前的项目中使用<exclusion>元素声明排除依赖。例如，项目A中配置了spring-core的依赖，如果项目B需要引用项目A，但是同时又不需要commons-logging的包，这个时候使用<exclusion>元素排除即可，这种用法可以刻解决包版本冲突的问题。

    1. <!-- 排除依赖 -->  
    2.   
    3.  <dependency>     
    4.   
    5.          <groupId>org.springframework</groupId>   
    6.   
    7.          <artifactId>spring-core</artifactId>   
    8.   
    9.             <exclusions>  
    10.   
    11.                     <exclusion>  
    12.   
    13.                             <groupId>commons-logging</groupId>  
    14.   
    15.                             <artifactId>commons-logging</artifactId>  
    16.   
    17.                     </exclusion>  
    18.   
    19.             </exclusions>  
    20.   
    21. </dependency>  
    <!-- 排除依赖 -->

 <dependency>   

         <groupId>org.springframework</groupId> 

         <artifactId>spring-core</artifactId> 

            <exclusions>

                    <exclusion>

                            <groupId>commons-logging</groupId>

                            <artifactId>commons-logging</artifactId>

                    </exclusion>

            </exclusions>

</dependency>

     二、聚合

             一个项目往往由多个模块构成的，在进行构建时，针对每个模块都进行构建命令是一件非常繁琐又容易出错的事情，所以Maven的聚合功能能够替我们完成进行一次构建命令完成全部模块的构建。

              Maven的聚合功能可以通过一个父模块将所有的要构建模块整合起来，将父模块的打包类型声明为POM，通过<modules>将各模块集中到父POM中。

    1. <!-- 把这三个模块聚合在一起， <module></module> 中间的内容为子模块工程名的相对路径 -->  
    2.   
    3. <modules>  
    4.   
    5.         <module>../user-core</module>  
    6.   
    7.         <module>../user-log</module>  
    8.   
    9.         <module>../user-service</module>  
    10.   
    11. </modules>  
      <!-- 把这三个模块聚合在一起， <module></module> 中间的内容为子模块工程名的相对路径 -->

  <modules>

          <module>../user-core</module>

          <module>../user-log</module>

          <module>../user-service</module>

  </modules>

              原理：父类型的模块，不需要有源代码和资源文件，也就是说，没有 src/main/Java 和 src/test/java 目录。Maven会首先解析聚合模块的 POM 文件，分析要构建的模块，并通过各模块的依赖关系计算出模块的执行顺序，根据这个潜在的关系依次构建模块。

    三、继承

             Maven中继承的概念与面向对象的继承概念是一致的，通过继承消除重复编码的行为。在这里，我们也可以用一个父模块来完成父模块与子模块共用依赖的继承关系。父模块

             父模块的POM文件声明与平常一样，提取公共地方，子模块需要继承父模块。

    [html] view plain copy print?
    1. <!--继承user-parent的父模块-->  
    2.   
    3. lt;parent>  
    4.   
    5.          <groupId>com.tgb.bobo</groupId>  
    6.   
    7.          <artifactId>user-parent</artifactId>  
    8.   
    9.          <version>0.0.1-SNAPSHOT</version>  
    10.   
    11.          <!-- 继承的绝对路径是pom文件 -->  
    12.   
    13.          <relativePath>../user-parent/pom.xml</relativePath>  
    14.   
    15.  </parent>  
    16.   
    17. <!--本模块的声明-->  
    18.   
    19.  <artifactId>user-service</artifactId>   
    20.   
    21.  <packaging>jar</packaging>  
     <!--继承user-parent的父模块-->

<parent>

          <groupId>com.tgb.bobo</groupId>

          <artifactId>user-parent</artifactId>

          <version>0.0.1-SNAPSHOT</version>

          <!-- 继承的绝对路径是pom文件 -->

          <relativePath>../user-parent/pom.xml</relativePath>

  </parent>

 <!--本模块的声明-->

  <artifactId>user-service</artifactId> 

  <packaging>jar</packaging>

             并不是所有的POM元素都可以被继承，如图表3是一个可继承的元素列表：

                

              聚合和继承存在一些共性和潜在的联系，在实际应用中，经常将聚合模块的父模块和继承的父模块定义为同一个。
  • 相关阅读:
    【第四周】四则运算图形化
    【第四周】【小组项目】【第二次】新蜂小组站会
    【第四周】【小组项目】【第一次】新蜂小组站会
    【第三周】站会和燃尽图
    【第三周】每周psp
    【第三周】四人小组项目
    【第三周】【】cppunit！
    【第二周】【作业一】读构建之法
    【第二周】【作业二】每周例行报告
    词频统计效能测试---------第二版
  • 原文地址：https://www.cnblogs.com/hoobey/p/6080290.html
Copyright © 2011-2022 走看看