Favoring composition over inheritance is one of the main principles I’ve been applying throughout my oo programming career. But this principle can not only be applied to programs but also to the dependency management in maven. This post examines ehe import scope for dependencies to use composition rather than inheritance in maven dependency management.
When trying to properly configure dependencies in maven up until now I have been using parent poms that declare dependencies and child poms that then use theses dependencies. Recently I stumbled across the import scope in the dependency management section that let’s you include dependencies through composition rather then inheritance.
As explained in the maven guide above: “the imported POM is be replaced with the dependencies in that POM’s <dependencyManagement> section.”. That is, if you can add dependencies by importing a pom which you then can use later.
I’ve made a little example here that contains a pom that declares some spring boot dependencies:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
<dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot</artifactId> <version>${spring.boot.version}</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-autoconfigure</artifactId> <version>${spring.boot.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>${spring.framework.version}</version> </dependency> </dependencies> </dependencyManagement> |
Where the name of the spring version to use has been put into properties of the same pom.
In another maven project, which is not a child of the project above, I imported the project above:
|
1 2 3 4 5 6 7 8 9 10 11 |
<dependencyManagement> <dependencies> <dependency> <groupId>com.jeeatwork.maven.examples</groupId> <artifactId>spring-libs</artifactId> <version>${project.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> |
Now I can use any of the dependencies in the project:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-autoconfigure</artifactId> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> </dependency> </dependencies> |
The output of the command
|
1 |
mvn dependency:tree |
shows that the dependency to the imported project have been replaced by the onces declared in that imported project:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
[INFO] --- maven-dependency-plugin:2.8:tree (default-cli) @ spring-user --- [INFO] com.jeeatwork.maven.examples:spring-user:jar:0.0.1-SNAPSHOT [INFO] +- org.springframework.boot:spring-boot:jar:1.2.3.RELEASE:compile [INFO] | +- org.springframework:spring-core:jar:4.1.6.RELEASE:compile [INFO] | | \- commons-logging:commons-logging:jar:1.2:compile [INFO] | \- org.springframework:spring-context:jar:4.1.6.RELEASE:compile [INFO] | \- org.springframework:spring-expression:jar:4.1.6.RELEASE:compile [INFO] +- org.springframework.boot:spring-boot-autoconfigure:jar:1.2.3.RELEASE:compile [INFO] | \- org.yaml:snakeyaml:jar:1.14:compile [INFO] \- org.springframework:spring-web:jar:4.1.5.RELEASE:compile [INFO] +- org.springframework:spring-aop:jar:4.1.5.RELEASE:compile [INFO] | \- aopalliance:aopalliance:jar:1.0:compile [INFO] \- org.springframework:spring-beans:jar:4.1.5.RELEASE:compile |
Possible application
Now what is so special about this type of reusing dependencies declared in other maven project ?
The most obvious benefit is, that you can reuse the dependencies without creating a parent child relationship:
Using the import scope enable dependency management through composition rather than through inheritance.
This enable the reuse of dependencies over projects that are otherwise not related.
In my current project for example I have an application which is made up of three parts that are independently build. All three use spring. So I created a maven project which declares all the spring dependencies and versions to use. I can use this pom in all the other parts without inheriting other parts.
Cool 