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.
Creating a project
To create our project using Spring Initalizr, complete the following steps:
- Open Spring Initializr by navigating to https://start.spring.io using your web browser. You should then see the following page:
Figure 1.3 – Spring Initializr
- We will generate a Maven Project with Java and the latest stable Spring Boot version. In the Group field, we will define our group ID (
com.packt) that will also become a base package in our Java project. In the Artifact field, we will define an artifact ID (cardatabase) that will also be the name of our project in Eclipse.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.
- By clicking the ADD DEPENDENCIES… button, we will select the starters and dependencies that are needed in our project. Spring Boot provides starter packages that simplify your Maven configuration. Spring Boot starters are actually a set of dependencies that you can include in your project. You can add dependencies by clicking the ADD DEPENDENCIES… button in Spring Initializr. We will start our project by selecting two dependencies—Spring Web and Spring Boot DevTools. You can type the dependencies into the search field or select from a list that appears, as illustrated in the following screenshot:
Figure 1.4 – Adding dependencies
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:
Figure 1.5 – Spring Initializr dependencies
- Finally, you have to click on the Generate button, which generates a project starter ZIP package for us.
Next, we will learn how to run our project using the Eclipse IDE.
Running the project
Perform the following steps to run the Maven project in the Eclipse IDE:
- Extract the project ZIP package that we created in the previous topic and open Eclipse.
- We are going to import our project into the Eclipse IDE. To start the import process, select the File | Import menu and the import wizard will be opened. The following screenshot shows the first page of the wizard:
Figure 1.6 – Import wizard (Step 1)
- In the first phase, you should select Existing Maven Projects from the list under the
Maven folder, and then go to the next phase by pressing the Next > button. The following screenshot shows the second step of the import wizard:
Figure 1.7 – Import wizard (Step 2)
- In this phase, select the extracted project folder by pressing the Browse... button. Then, Eclipse will find the
pom.xml file from the root of your project folder and show it inside the Projects section of the window.
- Press the Finish button to finalize the import. If everything ran correctly, you should see the
cardatabase project in the Eclipse IDE Project Explorer. It takes a while before the project is ready because all the dependencies will be downloaded by Maven after importing them. You can see the progress of the dependency download in the bottom-right corner of Eclipse. The following screenshot shows the Eclipse IDE Project Explorer after a successful import:
Figure 1.8 – Project Explorer
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.
- Now, we don't have any functionality in our application, but we can run it and see whether everything has started successfully. To run the project, open the main class by double-clicking on it, as shown in the following screenshot, and then press the Run button in the Eclipse toolbar. Alternatively, you can select the Run menu and press Run as | Java Application:
Figure 1.9 – Cardatabase project
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:
Figure 1.10 – Eclipse console
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:
Table 1.1 – SpringBootApplication annotations
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
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.
Logs and problem solving
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:
Figure 1.11 – Logging message
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:
Figure 1.12 – Application properties file
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:
Figure 1.13 – Port already in use
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.
United States
Great Britain
India
Germany
France
Canada
Russia
Spain
Brazil
Australia
Singapore
Hungary
Ukraine
Luxembourg
Estonia
Lithuania
South Korea
Turkey
Switzerland
Colombia
Taiwan
Chile
Norway
Ecuador
Indonesia
New Zealand
Cyprus
Denmark
Finland
Poland
Malta
Czechia
Austria
Sweden
Italy
Egypt
Belgium
Portugal
Slovenia
Ireland
Romania
Greece
Argentina
Netherlands
Bulgaria
Latvia
South Africa
Malaysia
Japan
Slovakia
Philippines
Mexico
Thailand
Filter
