Install the Java SDK

Since Spring is a Java framework to write and run Spring applications, you need to install the Java SDK. This project was written and built with JDK 14. To install JDK 14, download the JDK matching your operating system from www.oracle.com/java/ and install it. So, if you are building an application and intend to use it for financial gain, you might want to look at Oracle licensing or use an open source JDK.²

We recommend that you set the JAVA_HOME environment variable to point to the directory where Java 14 was installed (the directory in which the JDK was unpacked) and add $JAVA_HOME/bin (%JAVA_HOME%in for Windows users) to the general path of the system. The reason behind this is to ensure any other development application written in Java use this version of Java and prevent strange incompatibility errors during development. If you want to run the build from a terminal, you are certain that the expected version of Java is used.

Install Gradle

Gradle is an open source build automation tool designed to be flexible enough to build almost any type of software. It uses Groovy in its configuration files, which makes it customizable. The project attached to this book was successfully built with Gradle 6.x.

The sources attached to this book can be compiled and executed using the Gradle Wrapper, which is a batch script on Windows and a shell script on other operating systems.

When you start a Gradle build via the wrapper, Gradle is automatically downloaded inside your project to run the build; thus, you do not need to explicitly install it on your system. The recommended editor for development introduced next knows how to build code using Gradle Wrapper. Instructions on how to use the Gradle Wrapper are available in the public documentation at www.gradle.org/docs/current/userguide/gradle_wrapper.html.

A recommended practice is to keep the code and build tools separately. If you decide to install Gradle on your system, you can download the binaries from www.gradle.org, unpack it and copy the contents to the hard drive. (Or, if you are curious, you can download the full package containing binaries, sources, and documentation.) Create a GRADLE_HOME environment variable and point it to the location where you unpacked Gradle. Also, add $GRADLE_HOME/bin (%GRADLE_HOME%in for Windows users) to the system’s general path so that you can build the project in a terminal.

Gradle was chosen as a build tool for this book’s sources because of the easy setup, small configuration files, flexibility in defining execution tasks, and the Spring team currently uses it to build all Spring projects.

Running this command also verifies that Gradle is using the intended JDK version.

Install Apache Tomcat

Web applications are meant to be hosted by an application server unless they are built using Spring Boot, in which case it is more practical to rely on an embedded server. Apache Tomcat ⁵ is an open source implementation of the Java Servlet, JavaServer Pages, Java Expression Language, and WebSocket technologies.

The Spring MVC projects of this book were tested in Apache Tomcat 9.x. To install Apache Tomcat, go to the official site and get the version matching your operating system. Unpack it in a familiar location. On Unix-based systems, you might be able to install it using a package manager. If you install it manually, remember to go to the bin directory and make all files executable.

Recommended IDE

The IDE that we recommend you use with the code in this book is IntelliJ IDEA. It is the most intelligent Java IDE.

IntelliJ IDEA offers outstanding framework-specific coding assistance and productivity-boosting features for Java EE and Spring also includes very good support for Gradle. It is the perfect choice to help you focus on learning Spring (and not how to use an IDE). It can be downloaded from the JetBrains official site (www.jetbrains.com/idea/). It is also light on your operating system and easy to use.

IntelliJ IDEA also integrates well with Apache Tomcat, which allows you to deploy your projects to start and stop the server from the editor.

And now that the tools have been discussed, let’s talk about the project.

The Bookstore Project

Projects with names that contain -mvc- and chapter9-1-bookstore-no-boot are compiled and packed as a *.war can be run in Apache Tomcat. Except for chapter2-sample, all the other projects are built using Spring Boot and can be run by executing their main class. The chapter2-sample project has multiple main classes that you can run to test a specific scenario.

Building the Project

Once you’ve installed the recommended tools, the next step is getting the project sources from GitHub.

The GitHub project page is at https://github.com/Apress/spring-mvc-and-webflux.

You can download the repo page sources, clone the project using IntelliJ IDEA, or clone it using Git in the terminal. You can use HTTPS or Git protocol—whatever feels familiar and easy.

You can build the project using IntelliJ IDEA, but if you are opening it for the first time, it takes a while to figure out the project structure and index the files. We recommend that you open a terminal and build the project by executing the command in Listing 1-1. The output should be similar to that one, and it must certainly contain BUILD SUCCESSFUL.

> gradle clean build

...

BUILD SUCCESSFUL in 3m 1s

150 actionable tasks: 148 executed, 2 up-to-date

Listing 1-1

Building the Project for This Book

Once the project builds in the terminal, you can verify that you have the right project and the right tools. It is now time to open it in IntelliJ IDEA.

The first thing you notice is that IntelliJ IDEA is trying to decide the Gradle and the JDK versions. And it doesn’t always work, especially if you have multiple versions of each on your system. In the right corner, you might see notifications like the one in Figure 1-5.

To fix that, you must do the following.

1. 1.
   First, if you want to use Gradle Wrapper, skip this step. Otherwise, go to the Gradle view, click the little wrench button (the one labeled Build Tool Settings), and a window appears to allow you to choose the Gradle version. If you have Gradle installed on your system, and the GRADLE_HOME environment variable is set up, IntelliJ IDEA finds it. Still, it does not use it if the project contains a Gradle Wrapper configuration. To use Gradle on your system, choose Specified location in the section of the window marked in Figure 1-6.

   

   And, while you’re at it, make sure the Gradle JVM is set to JDK 14 as well.

    

1. 2.
   In the IntelliJ IDEA main menu, select File > Project structure…​. The Project Structure window allows you to configure the project SDK and the project language level. Make sure it is JDK 14 for both, as depicted in Figure 1-7.

   

    

If all goes well, IntelliJ IDEA uses Gradle and JDK to build your project and execute tests. If you want to build your project in IntelliJ IDEA, use the Gradle View. When the project is loaded correctly, all modules should be listed together with a set of Gradle tasks grouped by their purpose. Under the build group, a task named build is the equivalent of the Gradle command in Listing 1-1. Figure 1-8 shows a successful Gradle build run in IntelliJ IDEA.

Running the Projects

The projects that are not built using Spring Boot need to be deployed to an Apache Tomcat server. After a successful Gradle build, the artifacts should be already generated for all projects. To deploy your project on your local Apache server, you must do the following.

1. 1.

   Click the list of project launchers in the upper-right corner.

    
2. 2.

   Select Edit Configurations…​.

    
3. 3.

   In the Edit Configurations window, select the type of launcher that you want to create.

    
4. 4.
   In the upper-left corner, click the + button. In the list of launcher types, select Tomcat Server > Local (see Figure 1-9).

   

    

1. 5.

   In the Run/Debug Configurations window, a form needs to be populated with the location of the Apache server and the project to deploy. First, name the configuration. Choose a name related to your project.

    
2. 6.

   Click the Configure button.

    
3. 7.

   Select your Apache Tomcat server directory.

    
4. 8.

   Click the OK button.

    
5. 9.
   Click the Fix button. You are warned that you must select something to deploy (see Figure 1-10).

   

    

1. 10.

   In the list, select the project that you want to deploy.

    
2. 11.

   Next, in the Deployment tab, you can edit the context path because the autogenerated one is weird.

    
3. 12.
   Click the OK button, and you are done (see Figure 1-11).

   

    

Now, the name of your launcher appears in the list mentioned in the first step. You can start Apache Tomcat by clicking the Run button (the green triangle next to the Launcher list). If all goes well, IntelliJ opens a browser tab to the main page of the project.

The log console of the Apache Tomcat in IntelliJ IDEA can give you more information in case the deployment failed. Figure 1-12 shows the page for the chapter1-mvc-bookstore project (after it has been successfully deployed) and the Apache Tomcat log console.

Running the Spring Boot projects is even easier. Find the main class, right-click it, and choose Run. If the project was built successfully, the application should start and should appear in the Services view, as depicted in Figure 1-13.

It seems IntelliJ IDEA has some difficulties with Gradle multi-module project because, for Spring Boot Web applications, it cannot detect the working directory, which means it cannot build an application context correctly. To fix this, open the project launcher generated for the Spring Boot application and select the directory of the project you want to run as a value for the Working directory option, as depicted in Figure 1-14.

Summary

Hopefully, the instructions in this chapter are enough to help you get started. If anything is missing or unclear, feel free to first ask Google. If that does not work, create an issue on GitHub.

Happy coding!