Bummer! This is just a preview. You need to be signed in with a Basic account to view the entire video.

Preview

Start a free Basic trial
to watch this video

Sign up for Treehouse

Configuring Gradle for Spring Development

7:54 with Chris Ramacciotti

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'

}
  • 0:00

    So we've had a chance to see Spring from 30,000 feet,

  • 0:03

    and there might be some information there that's not entirely clear at this point.

  • 0:08

    No worries, though,

  • 0:09

    we'll shed more light on each of those areas as we work through the application.

  • 0:14

    What I'd like to do now is get Giflib fully set up to use Spring, and configure

  • 0:19

    our Gradle build file to allow us to run a web server with the application installed.

  • 0:24

    You should've already worked through our Java annotations course.

  • 0:28

    Because annotations are the primary means by which we'll configure our app,

  • 0:32

    it'll be useful to have some knowledge and experience in working with them.

  • 0:36

    Okay, let's get started with our configuration.

  • 0:40

    I'm back in IntelliJ with our giflib project open that we created in

  • 0:43

    the first stage.

  • 0:45

    The first take we'll tackle is setting up our Gradle build files that we not only

  • 0:48

    have the libraries necessary to compile our code, but

  • 0:51

    also the tools necessary to deploy or run our app in a web server.

  • 0:56

    So let's look at our Gradle build file and

  • 0:58

    remind ourselves of what we already have in place.

  • 1:02

    At the top, we have a group and version of the artifact that our build would create.

  • 1:07

    Just like how we imported a JAR file, we can also build a JAR file for export so

  • 1:12

    that others may use it.

  • 1:14

    The details of the JAR file we could generate as what we're seeing with

  • 1:17

    the group and the version.

  • 1:19

    Then we have this command to apply the Java plugin.

  • 1:23

    In Gradle, plugins are extensions of the Gradle tool itself and

  • 1:26

    add functionality to Gradle's built-in features, which

  • 1:30

    is exactly what a plugin for any piece of software would do, extend functionality.

  • 1:35

    Beyond dependency management, Gradle allows you to accomplish many more tasks.

  • 1:39

    For example, compiling your code, executing your code, testing your code or

  • 1:44

    building your project for deployment.

  • 1:46

    The Java plugin adds to Gradle the ability to compile different source sets.

  • 1:52

    For example, it can compile and run your main code or compile and

  • 1:55

    run your test code separately.

  • 1:58

    If you've taken our unit testing course, you know how useful and

  • 2:01

    important it is to write text code against your application code.

  • 2:05

    Gradle can assist in compiling and running only your test code, or

  • 2:09

    it can do the same thing for only your main application code.

  • 2:12

    This leads us to the next step we'll take in our application.

  • 2:15

    The Java plugin expects our main

  • 2:18

    application code to appear in a specific directory.

  • 2:21

    Namely, source main Java.

  • 2:24

    So let's go ahead and create that now.

  • 2:27

    To do that, we'll right-click on the project and choose New > Directory.

  • 2:33

    In the prompt that comes up,

  • 2:37

    we'll type src/main/java.

  • 2:42

    And there we see the directory popup in the directory tree of

  • 2:45

    our IntelliJ project.

  • 2:47

    We'll add a package and some code to this directory in just a bit.

  • 2:51

    What we'll do next is update our dependencies so that instead of simply

  • 2:55

    including a spring-webmvc library, we'll also include what's needed to start our

  • 3:00

    application and auto-configure it to run in a live web server.

  • 3:05

    To do this we're going to use another Spring library called Spring Boot.

  • 3:09

    Among other things, Spring Boot allows us to create a stand-alone,

  • 3:14

    runnable Spring application that has an embedded web server.

  • 3:18

    There's a handful of ways to set up the configuration of a Spring web app, but

  • 3:22

    this is the simplest way.

  • 3:24

    To leverage Spring Boot in our Java code, we'll need its JAR file.

  • 3:27

    So we'll replace the dependency we have with this one.

  • 3:31

    The group ID is org.springframework.boot,

  • 3:37

    the artifact ID is spring-boot-starter-web,

  • 3:43

    and the release is 1.2.6.RELEASE.

  • 3:47

    You might be wondering why I replaced the previous entry instead of just

  • 3:51

    adding another entry.

  • 3:53

    This is simply because the Spring Web MVC library is a dependency of

  • 3:57

    spring-boot-starter-web.

  • 3:58

    So Gradle will automatically download Spring Web MVC

  • 4:02

    anyway without us having to explicitly list it.

  • 4:05

    Let's save our build file and

  • 4:07

    refresh our dependencies to see all the libraries that get pulled in.

  • 4:10

    Remember, if you don't see the gradial tool window,

  • 4:14

    go to View > Tool windows > Gradial.

  • 4:16

    I'll click refresh here.

  • 4:19

    And then, when you check out the external libraries, you'll see that

  • 4:23

    quite a few have been added to your class path, once they all get downloaded.

  • 4:27

    Again, thanks to Gradle, we don't need to grab all of these libraries manually.

  • 4:34

    And there they are, look at how those grew.

  • 4:38

    Just to point out a couple additions, you'll see a bunch of

  • 4:41

    libraries from the Spring boot group, including spring-boot-starter-tomcat.

  • 4:46

    We scroll through here we should see that.

  • 4:49

    Here's spring-boot-starter-tomcat.

  • 4:53

    Tomcat is the name of the Apache web server that can run Java applications.

  • 4:58

    There is one more task we'll need to complete in the build.gradle file

  • 5:02

    before moving on to Java code.

  • 5:04

    We need the ability to deploy our web application during development.

  • 5:08

    Deployment refers to the process of taking all of our compiled code and

  • 5:11

    necessary libraries and launching our application in its target environment,

  • 5:15

    which in our case is a web server, tomcat, as we see here.

  • 5:19

    Guess what?

  • 5:20

    Gradle can help with this too.

  • 5:22

    Spring boot has its own Gradle plugin that can deploy a Spring application with

  • 5:26

    a web server.

  • 5:28

    But this plugin is not built into Gradle, so

  • 5:30

    we'll need to add it to what's called a buildscript in our file.

  • 5:34

    So we do this by typing the following, let me give myself more room to work here.

  • 5:41

    Above the applied plugin line I'm going to add a buildscript block.

  • 5:47

    Inside the buildscript block, I'll list the repository that we're going to use to

  • 5:51

    grab any plugins that we might need that aren't built in to Gradle itself.

  • 5:58

    MavenCentral is again the place where we're gonna grab this.

  • 6:02

    Now, to grab the actual dependency for this Spring boot plugin that we need,

  • 6:08

    I need to list that as a dependency in the build script.

  • 6:13

    So another dependencies block.

  • 6:14

    Again, this one is separate from the dependencies block of our

  • 6:17

    application code down here.

  • 6:19

    This is a dependencies block for the plugin that we wanna grab.

  • 6:22

    And on the classpath,

  • 6:25

    I wanna put org.springframework.boot:.

  • 6:31

    Again, the artifact id, spring-boot-gradle-plugin.

  • 6:38

    Intuitively named for us.

  • 6:39

    1.2.6.RELEASE.

  • 6:43

    And we'll save that.

  • 6:46

    Finally, in order to make use of the additional plugin functionality,

  • 6:50

    we need another apply plugin entry.

  • 6:54

    This time for the spring-boot plugin.

  • 6:56

    Apply plugin: spring-boot.

  • 6:59

    We'll save that.

  • 7:01

    This will allow us to run what's called the Gradle task that will compile and

  • 7:06

    deploy our application in an embedded web server.

  • 7:10

    If you expand the Tasks entry in the Gradle tool window,

  • 7:14

    you'll see a bunch of categorized tasks that you can run using Gradle.

  • 7:18

    For example, if you expand other, you'll see a task named compileJava.

  • 7:24

    Which, if you were to run,

  • 7:26

    would simply compile all of the code in your source/main/Java directory.

  • 7:30

    Now that we've applied the Spring Boot plugin, let's hit Refresh.

  • 7:35

    You should see this application item pop in there,

  • 7:38

    which comes from the Spring boot plugin.

  • 7:40

    There it is right there.

  • 7:42

    In a bit, we'll be using the boot run task to build and deploy our application.

  • 7:48

    Next, we'll create a Java class that will serve as our main configuration file for

  • 7:52

    this application.

You need to sign up for Treehouse in order to download course files.

Sign up