Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Preview
Start a free Courses trial
to watch this video
We've seen that Gradle is used for managing our dependencies, or the libraries that our application will depend on. In this video, we'll utilize a Gradle plugin that will allow us to launch our application on a running web server.
Dependency Management with Gradle
For more information on getting up & running with Gradle, check out our workshop at teamtreehouse.com/library/dependency-management-with-gradle.
Gradle Version 3 and up
Current versions of Gradle no longer use the buildscript syntax. The Spring Boot plugin syntax has also changed. Here is a working Gradle build script for more recent versions of Gradle:
plugins {
id 'java'
id 'idea'
id 'eclipse'
id 'org.springframework.boot' version '1.4.3.RELEASE'
}
group 'com.teamtreehouse'
version '1.0-SNAPSHOT'
sourceCompatibility = 1.8
repositories {
mavenCentral()
}
dependencies {
compile 'org.springframework.boot:spring-boot-starter-web'
}
So we've had a chance to see
Spring from 30,000 feet,
0:00
and there might be some information there
that's not entirely clear at this point.
0:03
No worries, though,
0:08
we'll shed more light on each of those
areas as we work through the application.
0:09
What I'd like to do now is get Giflib
fully set up to use Spring, and configure
0:14
our Gradle build file to allow us to run a
web server with the application installed.
0:19
You should've already worked through
our Java annotations course.
0:24
Because annotations are the primary
means by which we'll configure our app,
0:28
it'll be useful to have some knowledge and
experience in working with them.
0:32
Okay, let's get started
with our configuration.
0:36
I'm back in IntelliJ with our giflib
project open that we created in
0:40
the first stage.
0:43
The first take we'll tackle is setting up
our Gradle build files that we not only
0:45
have the libraries necessary
to compile our code, but
0:48
also the tools necessary to deploy or
run our app in a web server.
0:51
So let's look at our Gradle build file and
0:56
remind ourselves of what
we already have in place.
0:58
At the top, we have a group and version of
the artifact that our build would create.
1:02
Just like how we imported a JAR file,
we can also build a JAR file for export so
1:07
that others may use it.
1:12
The details of the JAR file we could
generate as what we're seeing with
1:14
the group and the version.
1:17
Then we have this command
to apply the Java plugin.
1:19
In Gradle, plugins are extensions
of the Gradle tool itself and
1:23
add functionality to Gradle's
built-in features, which
1:26
is exactly what a plugin for any piece of
software would do, extend functionality.
1:30
Beyond dependency management, Gradle
allows you to accomplish many more tasks.
1:35
For example, compiling your code,
executing your code, testing your code or
1:39
building your project for deployment.
1:44
The Java plugin adds to Gradle the ability
to compile different source sets.
1:46
For example, it can compile and
run your main code or compile and
1:52
run your test code separately.
1:55
If you've taken our unit testing course,
you know how useful and
1:58
important it is to write text code
against your application code.
2:01
Gradle can assist in compiling and
running only your test code, or
2:05
it can do the same thing for
only your main application code.
2:09
This leads us to the next step
we'll take in our application.
2:12
The Java plugin expects our main
2:15
application code to appear
in a specific directory.
2:18
Namely, source main Java.
2:21
So let's go ahead and create that now.
2:24
To do that, we'll right-click on
the project and choose New > Directory.
2:27
In the prompt that comes up,
2:33
we'll type src/main/java.
2:37
And there we see the directory
popup in the directory tree of
2:42
our IntelliJ project.
2:45
We'll add a package and
some code to this directory in just a bit.
2:47
What we'll do next is update our
dependencies so that instead of simply
2:51
including a spring-webmvc library, we'll
also include what's needed to start our
2:55
application and auto-configure
it to run in a live web server.
3:00
To do this we're going to use another
Spring library called Spring Boot.
3:05
Among other things, Spring Boot
allows us to create a stand-alone,
3:09
runnable Spring application that
has an embedded web server.
3:14
There's a handful of ways to set up
the configuration of a Spring web app, but
3:18
this is the simplest way.
3:22
To leverage Spring Boot in our Java code,
we'll need its JAR file.
3:24
So we'll replace the dependency
we have with this one.
3:27
The group ID is org.springframework.boot,
3:31
the artifact ID is
spring-boot-starter-web,
3:37
and the release is 1.2.6.RELEASE.
3:43
You might be wondering why I replaced
the previous entry instead of just
3:47
adding another entry.
3:51
This is simply because the Spring Web MVC
library is a dependency of
3:53
spring-boot-starter-web.
3:57
So Gradle will automatically
download Spring Web MVC
3:58
anyway without us having
to explicitly list it.
4:02
Let's save our build file and
4:05
refresh our dependencies to see all
the libraries that get pulled in.
4:07
Remember, if you don't see
the gradial tool window,
4:10
go to View > Tool windows > Gradial.
4:14
I'll click refresh here.
4:16
And then, when you check out
the external libraries, you'll see that
4:19
quite a few have been added to your class
path, once they all get downloaded.
4:23
Again, thanks to Gradle, we don't need
to grab all of these libraries manually.
4:27
And there they are,
look at how those grew.
4:34
Just to point out a couple additions,
you'll see a bunch of
4:38
libraries from the Spring boot group,
including spring-boot-starter-tomcat.
4:41
We scroll through here we should see that.
4:46
Here's spring-boot-starter-tomcat.
4:49
Tomcat is the name of the Apache web
server that can run Java applications.
4:53
There is one more task we'll need to
complete in the build.gradle file
4:58
before moving on to Java code.
5:02
We need the ability to deploy our
web application during development.
5:04
Deployment refers to the process of
taking all of our compiled code and
5:08
necessary libraries and launching our
application in its target environment,
5:11
which in our case is a web server,
tomcat, as we see here.
5:15
Guess what?
5:19
Gradle can help with this too.
5:20
Spring boot has its own Gradle plugin
that can deploy a Spring application with
5:22
a web server.
5:26
But this plugin is not built into Gradle,
so
5:28
we'll need to add it to what's
called a buildscript in our file.
5:30
So we do this by typing the following,
let me give myself more room to work here.
5:34
Above the applied plugin line I'm
going to add a buildscript block.
5:41
Inside the buildscript block, I'll list
the repository that we're going to use to
5:47
grab any plugins that we might need
that aren't built in to Gradle itself.
5:51
MavenCentral is again the place
where we're gonna grab this.
5:58
Now, to grab the actual dependency for
this Spring boot plugin that we need,
6:02
I need to list that as
a dependency in the build script.
6:08
So another dependencies block.
6:13
Again, this one is separate from
the dependencies block of our
6:14
application code down here.
6:17
This is a dependencies block for
the plugin that we wanna grab.
6:19
And on the classpath,
6:22
I wanna put org.springframework.boot:.
6:25
Again, the artifact id,
spring-boot-gradle-plugin.
6:31
Intuitively named for us.
6:38
1.2.6.RELEASE.
6:39
And we'll save that.
6:43
Finally, in order to make use of
the additional plugin functionality,
6:46
we need another apply plugin entry.
6:50
This time for the spring-boot plugin.
6:54
Apply plugin: spring-boot.
6:56
We'll save that.
6:59
This will allow us to run what's called the Gradle task that will compile and
7:01
deploy our application in
an embedded web server.
7:06
If you expand the Tasks entry
in the Gradle tool window,
7:10
you'll see a bunch of categorized
tasks that you can run using Gradle.
7:14
For example, if you expand other,
you'll see a task named compileJava.
7:18
Which, if you were to run,
7:24
would simply compile all of the code
in your source/main/Java directory.
7:26
Now that we've applied the Spring Boot
plugin, let's hit Refresh.
7:30
You should see this
application item pop in there,
7:35
which comes from the Spring boot plugin.
7:38
There it is right there.
7:40
In a bit, we'll be using the boot run
task to build and deploy our application.
7:42
Next, we'll create a Java class that will
serve as our main configuration file for
7:48
this application.
7:52
You need to sign up for Treehouse in order to download course files.
Sign up