精华内容
下载资源
问答
  • 依赖倒转原则

    2014-08-25 10:27:29
    依赖倒置原则(Dependence Inversion Principle,简称DIP)这个名字看着有点别扭,“依赖”还“倒置”,这到底是什么意思?依赖倒置原则的原始定义是:High level modules should not depend upon low level modules...
  • Maven 依赖范围及依赖原则

    千次阅读 2018-04-14 01:03:36
    1.依赖范围 想必大家在maven的pom.xml文件中 定义依赖 除了 groupId ,artifactId,version三个必要的标签外,还见过 另外一个标签scope(如下)。没错这个标签就是我下面要说的依赖范围。 <...

    1.依赖范围

    想必大家在maven的pom.xml文件中 定义依赖 除了 groupId ,artifactId,version三个必要的标签外,还见过 另外一个标签scope(如下)。没错这个标签就是我下面要说的依赖范围。

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

    其实maven中的依赖范围有很多种,但是我们常用的只有以下三种,我们掌握这三种就够用了。他们分别是 compile (编译)范围依赖,test(测试)依赖,provided依赖。那问题来了我们在定义依赖的时候 这个scope 该怎么填呢?我们先讲一下判定规则:

    • 是否对main主程序有效

    • 是否对test测试程序有效

    • 是否参与打包

    • 是否参与部署
      其实可以把这三个依赖分为两种情况

    • 针对程序结构(分主程序和测试程序)的依赖
      我们在前面就讲过 maven project 遵循着一定目录结构
      这里写图片描述
      complie 编译范围的依赖 (典型例子 spring-core 对main和test都有效,参与打包参与部署)

    <dependency>
      <groupId>org.springframework</groupId>
       <artifactId>spring-core</artifactId>
       <version>4.2.6.RELEASE</version>
    </dependency>
    

    这里写图片描述

    test 测试范围的依赖 (典型例子junit 只对test有效,不参与打包参与部署)

    <dependency>
    	<groupId>junit</groupId>
    	<artifactId>junit</artifactId>
    	<version>4.12</version>
    	<scope>test</scope>
    </dependency>
    
    • 针对开发过程的依赖
      provided 范围的依赖(典型例子servlet-api 在开发过程中必须提供(添加tomcat运行时环境/添加maven依赖),打包过程中忽略,运行时有servlet容器提供)
    <dependency>
        <groupId>org.apache.tomcat</groupId>
        <artifactId>servlet-api</artifactId>
        <version>6.0.32</version>
    </dependency>
    

    这里写图片描述

    2.依赖传递

    为了证明依赖会传递我分别建了一个A模块 依赖junit 和spring-core;B模块依赖junit和A模块如下:
    这里写图片描述
    这里写图片描述
    我们用idea的依赖树来看下 A模块,B模块这两个模块的依赖关系树:
    先是A模块的 dependency tree
    这里写图片描述
    再是B模块的关系树 dependcy tree
    这里写图片描述
    从B的pom.xml 代码中,我们可以看出 B模块在pom.xml文件中并没有直接的配置Spring-core的依赖,但是从B的依赖关系树种我们可以看出B也依赖了spring-core,只是这个依赖关系是因为 A依赖了spring-core ,而B又依赖了A所以 B也间接的依赖了spring-core因此可以得出一个结论:
    依赖可以相互之间传递

    3.依赖排除

    在某些情况下我们可能需要依赖某个a.jar,但又不想间接依赖这个a.jar所依赖的jar包,这时我们可以采用exclusion 来排除某个依赖。 如下:

    <dependency>
      <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.2.6.RELEASE</version>
        <exclusions>
            <exclusion>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    

    4.依赖原则

    我们在工作中的项目都是分模块的,而且模块之间又互相依赖,这个时候我们可能会引入相同的依赖 ,这时maven取那个依赖呢?这就是maven依赖的原则:

    • 路径不同间接依赖中maven采用的是路径最短者优先
    • 路径相同间接依赖中maven 采用的是依赖定义顺序从上到下
      我们可以通过以下来验证这两个依赖原则的正确性,定义一个A模块分别依赖junit 与spring-core-4.2.7; 定义一个B模块 依赖与junit与A模块 与spring-core-4.3.7;定义一个C模块分别依赖junit与B;定义一个D模块 分别依赖A模块与C模块。然后根据
      C模块与D模块最后依赖的spring-core的版本来验证上述两个依赖原则。
      A模块
      这里写图片描述
      B模块
      这里写图片描述
      C模块
      这里写图片描述
      根据C模块的依赖关系树 如下
      这里写图片描述

    D模块则分两种情况:
    1.B模块先定义与

    <dependencies>
        <dependency>
            <groupId>com.javxuam.maven</groupId>
            <artifactId>B</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    
        <dependency>
            <groupId>com.javxuam.maven</groupId>
            <artifactId>A</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    
    </dependencies>
    

    这里写图片描述
    A依赖定义优先B依赖

    <dependencies>
       <dependency>
            <groupId>com.javxuam.maven</groupId>
            <artifactId>A</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    
        <dependency>
            <groupId>com.javxuam.maven</groupId>
            <artifactId>B</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    
    </dependencies>
    

    这里写图片描述

    展开全文
  • 介绍一下RobertC.Martin提出的面向对象的设计原则中的稳定依赖原则。参考文档(http://www.objectmentor.com/resources/articles/Principles_and_Patterns.pdf )。 稳定依赖原则(SDP):The Stable Dependencies ...

    介绍一下RobertC.Martin提出的面向对象的设计原则中的稳定依赖原则。参考文档(http://www.objectmentor.com/resources/articles/Principles_and_Patterns.pdf )。   

        稳定依赖原则(SDP):The Stable Dependencies Principle 。是为了解决包设计的依存问题的。

        包之间的依赖关系都应该是稳定方向依赖的,包要依赖的包要比自己更具有稳定性。(The dependencies between packages in a design should be in the direction of the stability of the packages. A package should only depend upon packages that are more stable that it is.)。


         包的依赖定义 :包A中的类利用包B中的类的场合,就称包A依赖于包B。

         稳定依赖原则 :稳定就是没有变化。

            稳定包 :

                 1.自己没有依赖其他包,也就是自己一个完全独立的。

                 2.其他有很多包依赖于自己。依赖的包越多,自己的责任越大。

            不稳定包 :

                 1.自己依赖其他多个包,也就是自己不是独立的。

                 2.没有依赖于自己的其他包。也就是自己对其他包没有责任。

         不稳定度的计算公式:I=Ce/(Ce+Ca)。

         例子:
             Ce: Efferent Coupling。自己依赖的外部包的数量(outgoing dependencies)。
             Ca: Afferent Coupling。自己被其他包依赖的外部包数量(incoming dependencies)。
              I: Instability。不稳定度。I∈[0, 1]。

          Ce=0(自己依赖的外部包没有)的时候,不稳定度I为0、表示该包是最为稳定的包。
          Ca=0(自己被外部包依赖的外部包没有)的时候,不稳定度I为1.表示该包是最不稳定的包。

          SDP稳定依赖原则“Depend upon packages whose I metric is lower than yours.”

         例:A依赖B的时候
               I(A) > I(B)
            说明B比A稳定。

           如果B还不如A稳定的话,就不应该让A依赖B。

     

    展开全文
  • maven依赖原则

    千次阅读 2016-05-18 11:11:54
    使用maven的程序员都会遇到一个问题,那就是maven依赖冲突的问题,这会导致...一、maven依赖原则 1.间接依赖路径最短优先  一个项目test依赖了a和b两个jar。其中a-b-c1.0 , d-e-f-c1.1 。由于c1.0路径最短,

    使用maven的程序员都会遇到一个问题,那就是maven依赖冲突的问题,这会导致ClassNotFound或者MethodNotFound这样的异常。其实只要明白maven依赖的根本性的原则就不怕这样的问题了。

    一、maven依赖原则

    1.间接依赖路径最短优先

     一个项目test依赖了a和b两个jar包。其中a-b-c1.0   , d-e-f-c1.1   。由于c1.0路径最短,所以项目test最后使用的是c1.0。

    2.pom文件中申明顺序优先

    有人就问了如果 a-b-c1.0   , d-e-c1.1  这样路径都一样怎么办?其实maven的作者也没那么傻,会以在pom文件中申明的顺序那选,如果pom文件中先申明了d再申明了a,test项目最后依赖的会是c1.1

    所以maven依赖原则总结起来就两条:路径最短,申明顺序其次

    二、如何解决Jar冲突

    遇到冲突的时候第一步要找到maven加载的到时是什么版本的jar包。通过dependency:tree查看依赖树。

    [INFO] --- maven-dependency-plugin:2.1:tree (default-cli) @ web-hsf ---
    [INFO] com.lubby:web-hsf:war:0.0.1-SNAPSHOT
    [INFO] +- org.apache.geronimo.specs:geronimo-servlet_3.0_spec:jar:1.0:compile
    [INFO] +- org.springframework:spring:jar:2.5.6:compile
    [INFO] |  \- commons-logging:commons-logging:jar:1.1.1:compile
    [INFO] +- com.taobao.hsf:hsf.dubbo.schema:jar:2.1.1.1:provided
    [INFO] +- com.taobao.hsf:hsf.service.dubbo:jar:2.0.1.9:provided
    [INFO] |  +- com.taobao.hsf:hsf.services:jar:2.0.1.9:provided
    [INFO] |  |  +- org.slf4j:slf4j-api:jar:1.7.2:provided
    [INFO] |  |  +- groovy:groovy-all:jar:1.1-rc-1:provided
    [INFO] |  |  \- com.taobao.noah:noah-log:jar:0.0.1-SNAPSHOT:provided
    [INFO] |  \- com.taobao.hsf:hsf.app.spring:jar:2.0.1.9:provided
    [INFO] |     +- org.slf4j:slf4j-log4j12:jar:1.7.2:provided
    [INFO] |     +- log4j:log4j:jar:1.2.17:provided
    [INFO] |     +- commons-cli:commons-cli:jar:1.0:provided
    [INFO] +- com.taobao.hsf:hsf-standalone:jar:2.0.4-SNAPSHOT:provided
    [INFO] |  \- javax.servlet:servlet-api:jar:2.5:provided
    [INFO] \- com.ali.unit.rule:unitrouter:jar:1.0.0:provided
    [INFO]    \- com.taobao.diamond:diamond-client:jar:3.6.0:provided
    [INFO]       \- com.taobao.diamond:diamond-utils:jar:3.1.2:provided
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------
    [INFO] Total time: 5.407s
    [INFO] Finished at: Thu May 12 20:20:00 CST 2016
    [INFO] Final Memory: 9M/265M
    [INFO] ------------------------------------------------------------------------

    遇到冲突的时候通过maven的依赖原则来调整坐标在pom文件的申明顺序是最好的办法。

    三、如何隔离一个Jar包

    如何隔离一个jar包?有两个方法。

    第一个很常用的exclusion来隔离jar包

                        <exclusions>
                                    <exclusion>
                                            <groupId>com.ibm.icu</groupId>
                                            <artifactId>icu4j</artifactId>
                                    </exclusion>
                            </exclusions>

    第二个不常用的方法就是创建一个空包空包的坐标和你需要隔离的Jar包坐标一样,deploy的公司的私服上面。项目中这个空包申明在pom文件靠前的地方,这样依据maven依赖原则,这个空包会优先被使用,后面所有无论是直接依赖还是间接依赖的相同坐标的jar包都不会被使用了。空包比exclusion的好处就是不用在所有间接依赖的地方去exclusion

    展开全文
  • 依赖倒置原则

    2016-11-17 11:59:10
    依赖倒置原则包含三层含义: 高层模块不应该依赖低层模块,两者都应该依赖其抽象;抽象不应该依赖细节;细节应该依赖抽象。 依赖倒置原则在Java语言中的表现就是: 模块间的依赖是通过抽象发生,实现类之间不...

    <仅限有知识层面的知识理解,错误之处请指正>

    依赖倒置的基本思想:面向接口编程,将类之间的耦合交付给高层的接口或者抽象类来实现

    依赖倒置原则包含三层含义:

    • 高层模块不应该依赖低层模块,两者都应该依赖其抽象;
    • 抽象不应该依赖细节;
    • 细节应该依赖抽象。

    依赖倒置原则在Java语言中的表现就是:

    • 模块间的依赖是通过抽象发生,实现类之间不发生直接的依赖关系,其依赖关系是通过接口或抽象类产生的;
    • 接口或抽象类不依赖于实现类;
    • 实现类依赖接口或抽象类。

    在实际编程中,我们一般需要做到如下3点:

    • 低层模块尽量都要有抽象类或接口,或者两者都有。
    • 变量的声明类型尽量是抽象类或接口。
    • 使用继承时遵循里氏替换原则。

            依赖倒置原则的核心就是要我们面向接口编程,理解了面向接口编程,也就理解了依赖倒置。


    名词解释:
    高层模块:高层标准的定义层,比如接口和抽象类等方式
    底层模块:具体细节的实现类,比如多个类实现同一个接口,最终这些类就会借助这个接口而产生关系
    抽象:指接口与抽象类
    细节:接口与抽象类的实现类或者直接的类
    展开全文
  • maven的依赖原则

    千次阅读 2019-05-08 21:12:07
    网上针对maven的依赖原则主要给出了两个原则,即最短路径原则和优先声明原则。实际使用中,发现其实有如下三种原则 当一个项目中出现重复引用依赖jar时,maven一般有如下三种原则处理jar 1.最短路径原则 A -&...
  • 1、Maven依赖原则 ①最短路径优先 ②同路径声明顺序优先 2、查找依赖树 ①mvn dependency:tree ②idea查看,maven project,选择模块,右键show dependencies ③eclipse 打开pom.xml,切换到Dependency ...
  • Maven传递性依赖原则

    2017-02-05 07:17:01
    在Maven中jar包依赖冲突解决  1、路径最近者估先,c->b->a c依赖b,b依赖a,c会优先用b的jar包。 2、路径相同配置最前者优先,c->b,c->a,c依赖b,c也依赖a,必须要看b、a在c中哪个先声明,优先使用先声明的jar包。
  • gradle第三方Jar包依赖统一管理

    千次阅读 2019-08-06 11:28:51
    一个gradle的工程中往往包含很多的子工程,每个子工程都有其自己的Jar包依赖。现实情况是各个子工程对jar包的引入都是比较随意的,版本号各式各样,如何统一各个子工程的版本号?统一管理第三方依赖? 版本号统一后...
  • 在我们学习面向对象编程的时候,总会出现一些问题,好比以前刚刚写好的代码,上线...我们一个一个来学习,今天来学习7大面向对象设计原则之一,依赖倒置原则依赖倒置原则依赖倒置原则(Dependence Inversion...
  • 3.依赖倒置原则

    2017-04-17 17:26:11
    目录目录 3依赖倒置原则 1依赖倒置原则的定义 2 言而无信你太需要契约 3依赖的三种写法 构造函数传递依赖对象 ...浏览器兼容3依赖倒置原则3.1依赖倒置原则的定义依赖倒置原则(Dependence Inversion Principle,
  • 面向对象六大原则——依赖倒置原则

    万次阅读 多人点赞 2018-08-13 10:56:49
    什么是依赖倒置原则(Dependence Inversion Principle, DIP)  依赖倒置原则的包含如下的三层含义: - 高层模块不应该依赖低层模块,两者都应该依赖其抽象 - 抽象不应该依赖细节 - 细节应该依赖抽象  每一个...
  • Maven解决jar包依赖冲突

    千次阅读 2017-04-30 09:33:16
    Maven解决jar包依赖冲突
  • 面向对象设计原则之4-依赖倒置原则

    万次阅读 2018-07-15 12:27:05
    依赖倒置原则(Dependence Inversion Principle DIP ) 高层模块不应该依赖低层模块,他们都应该依赖于抽象;抽象不应该依赖于细节,细节应该依赖于抽象。 简单的定义为:面向接口(抽象)编程,不要面向实现编程...
  • 依赖倒置原则的包含如下的三层含义: 1. 高层模块不应该依赖低层模块,两者都应该依赖其抽象 2. 抽象不应该依赖细节 3. 细节应该依赖抽象 就是面向接口编程,采用依赖倒置原则可以减少类间的耦合性...
  • 设计模式--依赖倒转原则

    千次阅读 2015-07-06 09:37:44
    依赖倒转原则又称依赖倒置原则: 抽象不应该依赖细节,细节应该依赖于抽象。说白了,就是针对接口编程,不要针对实现编程。 依赖倒置原则包含三层含义: 1)高层模块不应该依赖低层模块,两者都应该依赖其抽象...
  • 依赖倒置原则(Dependency Inversion Principle,DIP)也称依赖反转原则,是面向对象设计(OOD)中比较重要、常见的一种,总结知识点包括:1、什么是依赖倒置原则?2、为什么需要遵守依赖倒置原则?3、在面向对象...
  • 依赖倒置原则和接口隔离原则的记录。 依赖倒置原则:高层模块不应该依赖低层模块,两者都应该依赖其抽象;抽象不应该依赖细节;细节应该依赖抽象; 接口隔离原则:建立单一接口,不要建立臃肿庞大的接口;
  • 一、依赖倒置原则  1.1 定义  高层次的模块不应该依赖于低层次的模块,他们都应该依赖于抽象。抽象不应该依赖于具体实现,具体实现应该依赖于抽象。  1.2 代码示例  开学第一天,早上小毛驴吃完...
  • 详述 Maven 依赖范围及依赖调节原则

    千次阅读 2017-09-23 17:49:44
    当在我们 POM 文件中配置 Maven 依赖的时候,常见的格式如下: ... <groupId>... <artifactId>... <version>...</versio
  • maven依赖性具有传递性:A.jar -> B.jar -> C.jar (当且仅当B.jar -> C.jar 的范围是compile(<scope>compile</scope>)) 程序示例: if(A.jar 依赖 B.jar){ if(B.jar 依赖 C.jar &&...
  • 依赖倒置原则

    千次阅读 2007-09-06 22:12:00
    依赖倒置原则,应该从两个方面来理解,一是OOD(面向对象的设计),一是软件结构。 对于OOD,我想我们很容易理解为什么要使用它。首先,接口和实现分离给我们使用该原则提供了前提条件;为什么这么说呢?接口和实现...
  • 设计模式六大原则依赖倒置原则

    千次阅读 2013-08-18 00:19:42
    3.1 依赖倒置原则的定义  依赖倒置原则(Dependence Inversion Principle,简称DIP)这个名字看着有点别扭,“依赖”还“倒置”,这到底是什么意思?依赖倒置原则的原始定义是:High level modules should not ...
  • 之间的依赖结构必须是一个直接的无环图形,也就是说,在依赖结构中不允许出现环(循环依赖)。如果依赖形成了环状结构,怎么样打破这种循环依赖呢?...第二种方法是使用DIP(依赖倒置原则)和ISP(接口分隔原
  • 设计模式6大原则依赖倒置原则

    千次阅读 2011-12-11 20:14:24
    依赖倒置原则 定义:  a. 高层模块不应该依赖于低层模块。二者都应该依赖于抽象。  b. 抽象不应该依赖于细节。细节应该依赖于抽象。   抽象:就是指接口或者抽象类。  细节:实现类,可以被new出来的类。...
  • 面向对象:稳定依赖原则(SDP)

    千次阅读 2009-09-28 22:10:00
    介绍一下RobertC.Martin提出的面向对象的设计原则中的稳定依赖原则。参考文档(http://www.objectmentor.com/resources/articles/Principles_and_Patterns.pdf)。 稳定依赖原则(SDP):The Stable Dependencies ...
  • (1)依赖倒转原则(强内聚,低耦合): 高层模块不应该依赖低层模块。两个都应该依赖抽象。抽象不应该依赖细节。细节应该依赖抽象【ASD】。----也就是说要指针接口编程,不要对实现编程。 (2)里氏代换原则(LSP...
  • java专题——依赖倒置原则

    千次阅读 2014-09-14 12:41:31
    依赖倒置原则 3.1 依赖倒置原则的定义  依赖倒置原则(Dependence Inversion Principle,简称DIP)这个名字看着有点别扭,“依赖”还“倒置”,这到底是什么意思?依赖倒置原则的原始定义是:High level ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 223,769
精华内容 89,507
关键字:

包的依赖原则