Chapter 7.  Multi-project Builds

When applications and projects get bigger, we usually split up several parts of the application into separate projects. Gradle has great support for multi-project builds. We can configure multiple projects in an easy way. Gradle is also able to resolve dependencies between projects and can build the necessary projects in the right order, so we don't have to switch to a specific directory to build the code; Gradle will resolve the correct project order for us.

In this chapter, we will discuss about multi-project configuration and dependencies. First, we will look at how to configure projects and tasks. Then we will use a multi-project Java application to learn how to have inter-project dependencies and how Gradle resolves them for us.

Working with multi-project builds

Let's start with a simple multi-project structure. We have a root project called garden with two other projects, tree and flower. The project structure is as follows:

└── garden
    ├── flower 
    └── tree 

We learn how we can invoke tasks in a multi-project build as follows:

1. We will add a new printInfo task to each of these projects. The task will print the name of the project to System.out. We must add a build.gradle file to each project with the following contents:

           task printInfo << { 
               println "This is ${project.name}" 
          } 
   

2. To execute the task for each project, we must first enter the correct directory and then invoke the task with Gradle. We can also run build.gradle for a specific project with the -b argument of Gradle. We will get the following output if we run the printInfo task for each project:

   garden $ gradle -q printInfo
   This is garden
   garden $ cd tree
   tree $ gradle -q printInfo
   This tree
   tree $ cd ..
   garden $ gradle...

Working with Java multi-project builds

In a Java project, we usually have compile or runtime dependencies between projects. For example, the output of one project is a compile dependency for another project. This is very common in Java projects. Let's create a Java project with a common project that contains a Java class used by other projects. We will add a services project that references the class in the common project. Finally, we will add a web project with a Java servlet class that uses classes from the services project.

We have the following directory structure for our project:

.
├── build.gradle
├── common
│   └── src
│       └── main
│           └── java
│               └── sample
│                   └── gradle
│                       └── util
│                           └── Logger.java
├── services
│   └── sample
│       └── src
│           ├── main
│           │   └── java
│           │       └── sample
│           │           └── gradle
│           │               ├── api
│   ...

Using the Jetty plugin

In the previous section, we created a Java project with a web subproject. The web project has a simple servlet. To execute the servlet, we must create a WAR file and deploy the WAR file to a servlet container, such as Tomcat or Jetty. You can learn more about Jetty at http://www.eclipse.org/jetty/. With the Jetty plugin, we can run our web project from the command line in a Jetty web container. We don't have to install Jetty on our computer, we only need to apply the Jetty plugin to our project. The plugin will take care of configuring Jetty and starting the web container. If everything is okay, we can open a web browser and access our servlet.

To add the Jetty plugin to our web project, let's create a new build.gradle file in the web directory. Here, we will use the apply() method to add the Jetty plugin to the project:

apply plugin: 'jetty' 

The plugin adds the following tasks to our project: jettyRun, jettyRunWar, and jettyStop. The following table shows the different...

Summary

Multi-project builds are very common in software projects. Gradle has great support for multi-project builds. We can use a hierarchical layout as the project structure, but we can easily customize this and use other layouts.

Configuring projects is easy and can be done in one place—”at the root of the projects. We can also add project configurations at the project level itself. Not only can we define the dependencies between projects on a project-library level, but we can also do so via configuration or task dependencies. Gradle will resolve the correct way to build the complete project so that we don't have to worry too much about that.

As Gradle knows the projects that will be involved before a task is executed, we can do partial multi-project builds. Gradle will automatically build project dependencies, which are necessary for our current project, and we can use a single task to build the projects that depend on our current project.

We also saw how to run our web application code...