Building Java Projects with Gradle
This guide walks your through using gradle to build a simple Java project.
1, what is the construction. -What ' ll build
' ll create a simple app and then build it using Gradle.
2. What is needed. -What you ' ll need
About minutes
A Favorite text editor or IDE
JDK 6 or later
3, how complete this guide-how to complete this guide
Like most Spring Getting Started guides, you can start with scratch and complete each step, or you can bypass basic setup Steps that are already familiar. Either way with working code.
To start in scratch, move on to Set up the project.
To Skip the basicsand do the following:
Download and unzip the source repository for this guide, or clone it usinggit:git CLONEHTTPS://GITHUB.COM/SPRING-GUIDES/GS -gradle.git
CD into Gs-gradle/initial
Jump ahead to Install Gradle.
When you ' re finished, you can check your results against the code ings-gradle/complete.
4, the establishment of the project-set up the project
The set up a Java project for Gradle to build. To keep the focus on Gradle and make the project as simple as possible for now. Create the directory structure
In a project directory of your choosing, create the following subdirectory structure; For example, Withmkdir-p Src/main/java/hello on *nix systems:
(using commands under Windows: mkdir Src\main\java\hello)
└──SRC
└──main
└──java
└──hello
Within The Src/main/java/hello directory, you can create any Java classes for you want. For simplicity ' s sake and for consistency with the rest of this guide, Spring recommends that you create two Classes:hello World.java Andgreeter.java.
Src/main/java/hello/helloworld.java
Package Hello;
public class HelloWorld {public
static void Main (string[] args) {
Greeter Greeter = new Greeter ();
System.out.println (Greeter.sayhello ());
}
Src/main/java/hello/greeter.java
Package Hello;
public class Greeter {public
String SayHello () {return
"Hello world!";
}
}
5, installation Gradle-install Gradle
Now so you have a project this can build with Gradle, can install Gradle.
Gradle is downloadable as a zip file at http://www.gradle.org/downloads. Only the "binaries are required, so" for "link to gradle-version-bin.zip. (You can also choose Gradle-version-all.zip to get the sources and documentation as as.)
Unzip the file to your computer, and add the Bin folder to your path.
To test the Gradle installation, run Gradle from the command-line:
Gradle
If everything is OK, you will see the following welcome message:
: Help
Welcome to Gradle 2.1.
To run a build, run Gradle <task> ...
To a list of available tasks, run Gradle tasks
To a list of command-line options, run Gradle--help
Build successful
Total time:12.281 secs
By now, you have installed the Gradle.
6, Discover Gradle can do what-find out what gradle can do
Now, the Gradle is installed, the what it can do. Before you even create a build.gradle file for the project, your can ask it what tasks are available:
Gradle Tasks
You should a list of available tasks. Assuming you run gradle into a folder that doesn ' t already have abuild.gradle file, and you'll be here some very elementary tasks Su Ch as this:
: Tasks = All tasks runnable from root project = Build Setup tasks setupbuild-initializes a new gradle build. [incubating] wrapper-generates gradle wrapper files.
[incubating] = = Help tasks dependencies-displays all dependencies declared in root project ' Gs-gradle '.
Dependencyinsight-displays the insight into a specific dependency in root project ' Gs-gradle '.
Help-displays a Help message projects-displays the sub-projects of root project ' Gs-gradle '.
Properties-displays the properties of root project ' Gs-gradle '.
Tasks-displays the tasks runnable from root project ' Gs-gradle '.
To the All tasks and more detail, run with--all. Build successful total time:3.077 secs
Even though these tasks are available, they don ' t offer much value without a project build configuration. As you flesh out Thebuild.gradle file, some tasks would be more useful. The list of tasks would grow as you add plugins tobuild.gradle and so I ll occasionally want to run tasks again to What tasks are available.
Speaking of adding plugins, next you add a plugin This enables basic Java build functionality.
7. Build Java code
Starting simple, create a very basic Build.gradle file this has only one line in it:
Apply plugin: ' java '
This configuration brings a significant amount to power. Rungradle Tasks again, and you are the new tasks added to the list, including tasks for building the project, Creatin G JavaDoc, and running tests.
You'll use the gradle build task frequently. This task compiles, tests, and assembles the code into a JAR file. Can run it like this:
Gradle Build
After a few seconds, "build successful" indicates this build has completed.
D:\Java\Spring\Guides\Building Java Projects with Gradle\gs-gradle>gradle build
: Compilejava
:p rocessresources Up-to-date
: Classes
: Jar
: Assemble
: Compiletestjava Up-to-date
:p rocesstestresources Up-to-date
: testclasses Up-to-date
: Test up-to-date
: Check Up-to-date
: Build
Build successful
Total time:11.39 secs
To the results of the "build" effort, take a look into the build folder. Therein you'll find several directories, including these three notable:
Classes. The project ' s compiled. class files.
Reports. Reports produced by the build (such as Test Reports).
Libs. Assembled project libraries (usually JAR and/or WAR files).
The classes folder has. class files that are generated from compiling the Java code. Specifically, should find Helloworld.class and Greeter.class.
At I, the project doesn ' t have any library dependencies, so there ' s nothing in thedependency_cache Folde R.
The Reports folder should contain a of running unit tests on the project. Because the project doesn ' t yet have any of the unit tests, which would be uninteresting.
The Libs folder should contain a JAR file is named after the project ' s folder. Further down, you'll be in the can specify the name of the JAR and its version.
8, declaration of dependence-Declare dependencies
The simple Hello World sample is completely self-contained and does not depend on any additional libraries. Most applications, however, depend on external libraries to handle common, and/or complex.
For example, suppose, addition to saying "Hello world!", you want the application to print the current date and Tim E. You could use the "date and time" facilities in the native Java libraries, but your can make things more interesting by us ing the Joda time libraries.
The "a", change Helloworld.java-look like this:
Package Hello;
Import Org.joda.time.LocalTime;
public class HelloWorld {public
static void Main (string[] args) {
localtime currenttime = new LocalTime ();
System.out.println ("The current local time is:" + currenttime);
Greeter Greeter = new Greeter ();
System.out.println (Greeter.sayhello ());
}
Here's HelloWorld uses Joda TIME's localtime class to get and print.
If you ran Gradle builds to builds the project now, the builds would fail because you have don't declared Joda time as a Compil e dependency in the build.
For starters, your need to add a source for 3rd party libraries in Build.gradle.
In ' Build.gradle '
repositories {
mavenlocal ()
mavencentral ()
}
The repositories block indicates this build is should resolve its dependencies from the Maven. Gradle leans heavily on many conventions and facilities established by the Maven build tool, including the option of using Maven, as a source of library dependencies.
Now so we ' re ready for the 3rd party libraries, let ' s declare some.
In ' Build.gradle '
dependencies {
compile "joda-time:joda-time:2.2"
}
With the dependencies blocks, you are declare a single dependency for Joda time. Specifically, you ' re asking for (reading right to left) version 2.2 of the Joda-time library, in the Joda-time group.
Another thing to "about this" dependency is "it is" a compile dependency, indicating that it should be available dur ing compile-time (and if you are were building a war file, included in The/web-inf/libs folder of the war). Other notable types of dependencies include:
Providedcompile. Required dependencies for compiling the project code, but that'll be provided at runtime by a container running the code (for example, the Java Servlet API).
Testcompile. Dependencies used for compiling and running tests, but don't required for building or running the project ' s runtime code.
Finally, let ' s specify the name of our JAR artifact.
In Build.gradle
jar {
baseName = ' Gs-gradle '
version = ' 0.1.0 '
}
The jar block specifies how the jar file would be named. In this case, it would render Gs-gradle-0.1.0.jar.
Now if you run Gradle builds, Gradle should resolve the Joda time dependency from the Maven, the repository and the Buil D would succeed.
9, use Gradle wrapper to build the project-builds your project with Gradle wrapper
The Gradle wrapper is the preferred way of starting a gradle build. It consists of a batch script for Windows and a shell script for OS X and Linux. These scripts allow the You-run a gradle build without requiring that Gradle is installed on your system. To make this possible, add the following blocks to the bottom of your build.gradle.
In Build.gradle
task Wrapper (type:wrapper) {
gradleversion = ' 1.11 '
}
Run the following command to download and initialize the wrapper scripts:
Gradle Wrapper
After this task completes, you'll notice a few new files. The two scripts are in the folder where the wrapper jar and properties files have been to a added Rapper folder.
└──initial
└──gradlew
└──gradlew.bat
└──gradle
└──wrapper
└──gradle-wrapper.jar Gradle-wrapper.properties
The Gradle wrapper is now available for building your project. ADD it to your version control system, and everyone this clones your project can build it just the same. It can be used in the exact same way as a installed version of Gradle. Run the wrapper script to perform the builds task, just like you did previously:
./gradlew Build
The wrapper for a specified version of Gradle, it downloads and caches the Gradle Version. The Gradle wrapper files are designed to is committed to source control so this anyone can build the project without Havin G To install and configure a specific version of Gradle.
At this stage, you'll have built your code. You can be results here:
Build
├──classes
│└──main
│ └──hello
│ ├──greeter.class
│ └──helloworld.clas s
├──dependency-cache
├──libs
│└──gs-gradle-0.1.0.jar
└──tmp
└──jar └──manifest
. Mf
Included are the two expected class files for Greeter and HelloWorld, as as a JAR file. Take A quick peek:
For Windows
D:\Java\Spring\Guides\Building Java Projects with Gradle\gs-gradle>jar TVF Build/libs/gs-gradle-0.1.0.jar
0 Wed Sep 10:16:36 CST 2014 meta-inf/
Wed Sep 10:16:36 CST 2014 meta-inf/manifest. Mf
0 Wed Sep 10:04:22 CST 2014 hello/
369 Wed Sep 10:16:36 CST 2014 Hello/greeter.class
987 Wed Sep 10:16:36 CST 2014 Hello/helloworld.class
For Linux
$ jar TVF Build/libs/gs-gradle-0.1.0.jar
0 Fri May 16:02:32 CDT 2014 meta-inf/-May
Fri CDT 2014 Meta-inf/manifest. MF
0 Fri May 16:02:32 CDT 2014 hello/
369 FRI could 16:02:32 CDT 2014 Hello/greeter.class 988 Fri may
30 1 6:02:32 CDT 2014 Hello/helloworld.class
The class files are bundled up. It ' s important to note, which even though you declared Joda-time as a dependency, the library isn ' t included. And the JAR file isn ' t runnable either.
To make this code runnable, we can use Gradle ' s application plugin. Add this to Yourbuild.gradle file.
Apply plugin: ' Application '
mainclassname = ' Hello. HelloWorld '
Then You can run the app!
For Windows
D:\Java\Spring\Guides\Building Java Projects with Gradle\gs-gradle>gradlew run
: Compilejava Up-to-date
:p rocessresources Up-to-date
: Classes Up-to-date
: Run
The current local time is:10:39:09.687
Hello world!
Build successful
Total time:24.859 secs
For Linux
$./gradlew Run
: Compilejava up-to-date
:p rocessresources up-to-date
: Classes up-to-date
: Run
The current local time is:16:16:20.544
Hello world!
Build successful total
time:3.798 secs
To bundle up dependencies requires more thought. For example, if we were building a WAR file, a format commonly associated with packing at 3rd party dependencies, we could Use Gradle ' SWAR plugin. If you are are using Spring Boot and want a runnable JAR file, the Spring-boot-gradle-plugin is quite handy. At this stage, Gradle doesn ' t know enough about your system to make a choice. But for now, the This should is enough to get started using Gradle.
To wrap things up for this guide, which is the completed Build.gradle file:
Build.gradle
Apply plugin: ' java '
apply plugin: ' Eclipse '
Apply plugin: ' Application '
mainclassname = ' Hello. HelloWorld '
//tag::repositories[]
repositories {
mavenlocal ()
mavencentral ()
}
//end:: Repositories[]
//tag::jar[]
jar {
baseName = ' Gs-gradle '
version = ' 0.1.0 '
}
// End::jar[]
//tag::d ependencies[]
dependencies {
compile "joda-time:joda-time:2.2"
}
// End::d ependencies[]
//tag::wrapper[]
task Wrapper (type:wrapper) {
gradleversion = ' 1.11 '
}
//end::wrapper[]
There are many start/end comments embedded here. This is makes it possible to extract bits of the ' Build ' to ' guide for the detailed explanations. You don ' t need them the your production build file.
10, summary-Summary
Congratulations to you. You have been able to create a simple and efficient Gradle compilation file for compiling Java projects.
Original link: http://spring.io/guides/gs/gradle/