10

Web Application Quickstart

This chapter is a work in progress.

This chapter introduces some of the Gradle's support for web applications. Gradle provides tw plugins for web application development: the War plugin and the Jetty plugin. The War plugin extends the Java plugin to build a WAR file for your project. The Jetty plugin extends the War plugin to allow you to deploy your web application to an embedded Jetty web container.

10.1. Building a WAR file

To build a WAR file, you apply the War plugin to your project:

Example 10.1. War plugin

build.gradle

apply plugin: 'war'

Note: The code for this example can be found at samples/webApplication/quickstart which is in both the binary and source distributions of Gradle.

This also applies the Java plugin to your project. Running gradle build will compile, test and WAR your project. Gradle will look for the source files to include in the WAR file in src/main/web

. Your compiled classes, and their runtime dependencies are also included in the WAR file.

10.2. Running your web application

To run your web application, you apply the Jetty plugin to your project:

Groovy web applications

You can combine multiple plugins in a single project, so you can use the War and Groovy plugins together to build a Groovy based web

Page 53 of 343

	Example 10.2. Running web application with Jetty plugin	application. The appropriate
	build.gradle	groovy libraries will be added
		to the WAR file for you.
	apply plugin: 'jetty'

This also applies the War plugin to your project. Running gradle jettyRun will run your web application in an embedded Jetty web container. Running gradle jettyRunWar will build the WAR file, and then run it in an embedded web container.

TODO: which url, configure port, uses source files in place and can edit your files and reload.

10.3. Summary

You can find out more about the War plugin in Chapter 26, The War Plugin and the Jetty plugin in Chapter 28, The Jetty Plugin. You can find more sample Java projects in the samples/webAppli directory in the Gradle distribution.

Page 54 of 343

11

Using the Gradle Command-Line

This chapter introduces the basics of the Gradle command-line. You run a build using the gradle command, which you have already seen in action in previous chapters.

11.1. Executing multiple tasks

You can execute multiple tasks in a single build by listing each of the tasks on the command-line. For example, the command gradle compile test will execute the compile and test tasks. Gradle will execute the tasks in the order that they are listed on the command-line, and will also execute the dependencies for each task. Each task is executed once only, regardless of how it came to be included in the build: whether it was specified on the command-line, or it a dependency of another task, or both. Let's look at an example.

Below four tasks are defined. Both dist and test depend on the compile task. Running gradle for this build script results in the compile task being executed only once.

Figure 11.1. Task dependencies

Page 55 of 343

Example 11.1. Executing multiple tasks

build.gradle

task compile << {

println 'compiling source'

}

task compileTest(dependsOn: compile) << { println 'compiling unit tests'

}

task test(dependsOn: [compile, compileTest]) << { println 'running unit tests'

}

task dist(dependsOn: [compile, test]) << { println 'building the distribution'

}

Output of gradle dist test

> gradle dist test :compile

compiling source :compileTest compiling unit tests :test

running unit tests :dist

building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

Because each task is executed once only, executing gradle test test is exactly the same as executing gradle test.

11.2. Excluding tasks

You can exclude a task from being executed using the -x name of the task to exclude. Let's try this with the sample

command-line option and providing the build file above.

Page 56 of 343