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