In this book, we will learn about full stack development using Spring Boot in the backend and React in the frontend. The first half of this book focuses on backend development, and in the second half of the book, we will implement the frontend.
In this chapter, we will set up the environment and tools needed for backend programming with Spring Boot. Spring Boot is a modern Java-based backend framework that makes development faster than with traditional Java-based frameworks. With Spring Boot, you can make a standalone web application that has an embedded application server.
There are a lot of different integrated development environment (IDE) tools that you can use to develop Spring Boot applications. In this chapter, we will install Eclipse, which is an open source IDE for multiple programming languages. We will create our first Spring Boot project by using the Spring Initializr project starter page. The project is then imported into Eclipse and executed. Reading the console log is a crucial skill when developing Spring Boot applications, which we will also cover.
In this chapter, we will look into the following topics:
The Java software development kit (SDK), version 8 or higher, is necessary to use the Eclipse IDE. In this book, we are using the Windows operating system, but all tools are available for Linux and macOS as well.
Download the code for this chapter from GitHub, at https://github.com/PacktPublishing/Full-Stack-Development-with-Spring-Boot-and-React/tree/main/Chapter01.
Check out the following video to see the Code in Action: https://bit.ly/3t32Fx6
Eclipse is an open source programming IDE developed by the Eclipse Foundation. An installation package or installer can be downloaded from https://www.eclipse.org/downloads. Eclipse is available for Windows, Linux, and macOS.
You can either download a ZIP package of Eclipse or an installer package that executes the installation wizard. In the installer, you should select Eclipse IDE for Enterprise Java and Web Developers, as shown in the following screenshot:
If using the ZIP package, you just have to extract the package to your local disk, and it will contain an executable eclipse.exe file that you can run by double-clicking on the file. You should download the Eclipse IDE for Enterprise Java and Web Developers package.
Eclipse is an IDE for multiple programming languages, such as Java, C++, and Python. Eclipse contains different perspectives for your needs, which are a set of views and editors in the Eclipse workbench. The following screenshot shows common perspectives for Java development:
On the left-hand side, we have Project Explorer, where we can see our project structure and resources. Project Explorer is also used to open files by double-clicking on them. The files will be opened in the editor, which is located in the middle of the workbench. The Console view can be found in the lower section of the workbench. This view is really important because it shows application logging messages.
Important Note
You can get Spring Tool Suite (STS) for Eclipse if you want, but we are not going to use it in this book because the plain Eclipse installation is enough for our purposes. STS is a set of plugins that makes Spring application development simple, and you can find more information about it here: https://spring.io/tools.
Now that we have installed Eclipse, let's take a quick look at what Maven is and how it helps us.
Apache Maven is a software project management tool that makes the software development process simpler and also unifies the development process.
Important Note
You can also use another project management tool called Gradle with Spring Boot, but in this book, we will focus on using Maven.
The basis of Maven is the Project Object Model (POM). The POM is a pom.xml file that contains basic information about a project. There are also all the dependencies that Maven should download to be able to build a project.
Basic information about a particular project can be found at the beginning of the pom.xml file, which defines—for example—the version of the application, the packaging format, and so on. The minimum version of the pom.xml file should contain the following:
Dependencies are defined in the dependencies section, as shown in the following pom.xml code:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent
</artifactId>
<version>2.5.2</version>
<relativePath/> <!-- lookup parent from
repository -->
</parent>
<groupId>com.packt</groupId>
<artifactId>cardatabase</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>cardatabase</name>
<description>Demo project for Spring Boot
</description>
<properties>
<java.version>11</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web
</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools
</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test
</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin
</artifactId>
</plugin>
</plugins>
</build>
</project>
Maven is normally used from the command line, but Eclipse contains embedded Maven, and that handles all the Maven operations we need. Therefore, we are not focusing on Maven command-line usage here. The most important thing is to understand the structure of the pom.xml file and how to add new dependencies to it. We will learn how to add dependencies using Spring Initializr in the next section. Later in this book, we will also add new dependencies manually to the pom.xml file.
In the next section, we will create our first Spring Boot project and see how we can run it using the Eclipse IDE.
We will create our backend project using Spring Initializr, which is a web-based tool that's used to create Spring Boot projects. Then, we will learn how to run our Spring Boot project using the Eclipse IDE. At the end of this section, we will also look at how you can utilize Spring Boot logging.
To create our project using Spring Initalizr, complete the following steps:
Important Note
Select the correct Java version in Spring Initializr. In this book, we are using Java version 11. You should select the same version that you are using in your Eclipse IDE.
In the upcoming Spring Boot 3 version, the Java baseline is Java 17. But in this book, we are using Spring Boot 2.
The Spring Boot DevTools dependency provides us with the Spring Boot developer tools, which provide automatic restart functionality. It makes development much faster because the application is automatically restarted when changes have been saved. The web starter pack is a base for full stack development and provides an embedded Tomcat server. After you have added dependencies, your Dependencies section in Spring Initializr should look like this:
Next, we will learn how to run our project using the Eclipse IDE.
Perform the following steps to run the Maven project in the Eclipse IDE:
Project Explorer also shows the package structure of our project. In the beginning, there is only one package called com.packt.cardatabase. Under that package is our main application class, called CardatabaseApplication.java.
You can see the Console view open in Eclipse, and that contains important information about the execution of the project. This is the view where all log texts and error messages appear, so it is really important to check the content of the view when something goes wrong.
Now, if the project was executed correctly, you should see the started CardatabaseApplication class in the text at the end of the console. The following screenshot shows the content of the Eclipse console after our Spring Boot project has been started:
In the root of our project, there is the pom.xml file, which is the Maven configuration file for our project. If you look at the dependencies inside the file, you can see that there are now dependencies that we selected on the Spring Initializr page. There is also a test dependency included automatically without any selection, as illustrated in the following code snippet:
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web
</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test
</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
In the following chapters, we are going to add more functionality to our application, and then we will add more dependencies manually to the pom.xml file.
Let's look at the Spring Boot main class more carefully. At the beginning of the class, there is the @SpringBootApplication annotation, which is actually a combination of multiple annotations, such as the following:
The following code snippet shows the Spring Boot application's main class:
package com.packt.cardatabase;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.
SpringBootApplication;
@SpringBootApplication
public class CardatabaseApplication {
public static void main(String[] args) {
SpringApplication.run
(CardatabaseApplication.class, args);
}
}
The execution of the application starts from the main method, as in standard Java applications.
Important Note
It is recommended that you locate the main application class in the root package above other classes. A common reason for an application not working correctly is due to Spring Boot being unable to find some critical classes.
Spring Boot development tools make the application development process simpler. The most important feature of the development tools is automatic restart whenever files on classpath are modified. Projects will include the developer tools if the following dependency is added to the Maven pom.xml file:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
Development tools are disabled when you create a fully-packed production version of your application. The application is automatically restarted when you make changes to your project's classpath files. You can test that by adding one comment line to your main class, as follows:
package com.packt.cardatabase;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.
SpringBootApplication;
@SpringBootApplication
public class CardatabaseApplication {
public static void main(String[] args) {
// After adding this comment the application is restarted
SpringApplication.run
(CardatabaseApplication.class, args);
}
}
After saving the file, you can see in the console that the application has restarted.
Logging can be used to monitor your application flow, and it is a good way to capture unexpected errors in your program code. Spring Boot starter packages provide a logback that we can use for logging without any configuration. The following sample code shows how you can use logging:
package com.packt.cardatabase;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.
SpringBootApplication;
@SpringBootApplication
public class CardatabaseApplication {
private static final Logger logger =
LoggerFactory.getLogger
(CardatabaseApplication.class);
public static void main(String[] args) {
SpringApplication.run
(CardatabaseApplication.class, args);
logger.info("Application started");
}
}
The logger.info method prints a logging message in the console. Logging messages can be seen in the console after you run a project, as shown in the following screenshot:
There are seven different levels of logging: TRACE, DEBUG, INFO, WARN, ERROR, FATAL, and OFF. You can configure the level of logging in your Spring Boot application.properties file. The file can be found in the resources folder inside your project, as illustrated in the following screenshot:
If we set the logging level to DEBUG, we can see log messages from levels that are log level DEBUG or higher (that is DEBUG, INFO, WARN, and ERROR). In the following example, we set the log level for the root, but you can also set it at the package level:
logging.level.root=DEBUG
Now, when you run the project, you can't see the TRACE messages anymore. That might be a good setting for a development version of your application. The default logging level is INFO if you don't define anything else.
There is one common failure that you might encounter when running a Spring Boot application. Spring Boot uses Apache Tomcat (http://tomcat.apache.org/) as an application server by default. As a default, Tomcat is running on port 8080. You can change the port in the application.properties file. The following setting will start Tomcat on port 8081:
server.port=8081
If the port is occupied, the application won't start, and you will see the following message in the console:
If this happens, you will have to stop the process that is listening on port 8080 or use another port in your Spring Boot application.
In the next section, we will install a MariaDB database to use as a database in our backend.
In Chapter 3, Using JPA to Create and Access a Database, we are going to use MariaDB, so you will need to install it locally on your computer. MariaDB is a widely used open source relational database. MariaDB is available for Windows and Linux, and you can download the latest stable community version from https://mariadb.com/downloads/. MariaDB is developed under a GNU's Not UNIX (GNU) General Public License version 2 (GPLv2) license. The following steps guides you to install MariaDB:
We now have everything needed to start the implementation of the backend.
In this chapter, we installed the tools that are needed for backend development with Spring Boot. For Java development, we used the Eclipse IDE, which is a widely used programming IDE. We created a new Spring Boot project by using the Spring Initializr page. After creating the project, it was imported to Eclipse and—finally—executed. We also covered how to solve common problems with Spring Boot and how to find important error and log messages. Finally, we installed a MariaDB database that we are going to use in the following chapters.
In the next chapter, we will understand what dependency injection (DI) is and how it can be used with the Spring Boot framework.
Packt Publishing has other great resources for learning about Spring Boot, as listed here:
18.118.186.202