DZone
Thanks for visiting DZone today,
Edit Profile
  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
Sign Out View Profile
  • Post an Article
  • Manage My Drafts
Newsletter
Log In / Join
Refcards Trend Reports
Events Video Library
Refcards
Trend Reports

Events

View Events Video Library

Related

  • How to Build Your Own AI SRE From Scratch
  • Stop Preparing for Audits — Build the Pipeline That Audits Itself
  • Multi-Agent Software Engineering: Can AI Teams Build Production Systems?
  • Arm64 Is No Longer the Edge Case

Trending

  • Chaos Engineering and Kafka In Action: Topic Level Idempotence and Retry Check
  • Controller and Data Access: Understanding Two-Layer Architecture Through Abstraction and Encapsulation
  • The Rise of the Unsanctioned Agent Swarm
  • From Database Changes to Real-Time Actions at Scale: Oracle GoldenGate and Java

Draft This article hasn't been published, so readers can't see it.

In moderation This article is waiting for review, so readers can't see it yet.

Deleted This article has been deleted, so readers can't see it.

Gradle Multi-Project Builds: Parent Pom Structure

Want to learn how to use a parent pom structure in Gradle? Check out this post on how to use multi-project builds in Gradle with the parent pom structure.

By 
Emmanouil Gkatziouras
DZone Core CORE ·
Jul. 27, 18 · Tutorial
Post on X (opens in a new tab) Share on LinkedIn (opens in a new tab)
28.8K Views

Join the DZone community Save articles, join the discussion, and download Refcards and Trend Reports with a free account.

Join for free Already a member? Log in

When you come from a Maven background, most likely, you have been used to the parent pom structure. Now, when it comes to Gradle, things are a little bit different.

Imagine the scenario of having a project with the interfaces and various other implementations. This is going to be our project structure.

multi-project-gradle
-- specification
-- core
-- implementation-a
-- implementation-b


The specification project contains the interfaces, which the implementations will be based upon. The core project will contain functionality that needs to be shared among implementations.

The next step is to create each project inside the multi-project-gradle. Each project is actually a directory with the builde.gradle file.

plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'
}


Once this is done, you need to create a link between the parent project and the child project.
To do so, you create the multi-project-gradle/settings.gradle and include the other projects.

rootProject.name = 'com.gkatzioura'
include 'specification'
include 'core'
include 'implementation-a'
include 'implementation- b'


Now, if you set the build.gradle file for every sub project, you’ve just included the JUnit dependency and the Maven central repository everywhere.

One of the main benefits on using multi-project builds is removing duplication. To do so, we shall create the multi-project-gradle/build.gradle file and add the JUnit dependency and the Maven central reference.

subprojects {
    apply plugin: 'java'

    repositories {
        mavenCentral()
    }

    dependencies {
        testCompile group: 'junit', name: 'junit', version: '4.12'
    }

}


Now, we can add our dependencies to each project and even specify the dependencies needed from the sub-projects.

For example, the core project uses the specification project.

dependencies {
  compile project(':specification')
}


And, each implementation project uses the core project.

dependencies {
    compile project(':core')
}


You can find the project on GitHub.

Build (game engine) Gradle

Published at DZone with permission of Emmanouil Gkatziouras. See the original article here.

Opinions expressed by DZone contributors are their own.

Related

  • How to Build Your Own AI SRE From Scratch
  • Stop Preparing for Audits — Build the Pipeline That Audits Itself
  • Multi-Agent Software Engineering: Can AI Teams Build Production Systems?
  • Arm64 Is No Longer the Edge Case

Partner Resources

×

Comments

Loading comments

The comments didn't load

Please try again in a moment.

Likes

Loading

The next likes didn't load. Please try again.

The likes didn't load

Please try again in a moment.

See who liked this

Log in or join DZone for free to see who liked this article.

Log in Join for free
  • RSS
  • X
  • Facebook

ABOUT US

  • About DZone
  • Support and feedback
  • Community research

ADVERTISE

  • Advertise with DZone

CONTRIBUTE ON DZONE

  • Article Submission Guidelines
  • Become a Contributor
  • Core Program
  • Visit the Writers' Zone

LEGAL

  • Terms of Service
  • Privacy Policy

CONTACT US

  • 3343 Perimeter Hill Drive
  • Suite 215
  • Nashville, TN 37211
  • [email protected]

Let's be friends:

  • RSS
  • X
  • Facebook