Spring Boot: Building Java Applications

Overview

The Spring framework, which is a popular tool to create Java online applications, includes Spring Boot. The fastest productivity is what makes Spring the most appreciated Java framework. Simply put, we can say that it offers a quicker and easier way to create uncomplicated web apps. Currently, I’m serving an opportunity to gain knowledge in Prilient Technologies as a Java developer.

Mandatory for Spring Boot Application

1. Java
2. Maven or Gradle build tool (for building the project, In which we have the metadata of the project like dependencies, java version, Spring version)
3. An IDE (Intellij, STS)

In Maven, there is a file called pom.xml in which we put the dependencies, and in the same way, in Gradle, we have gradle.build.For creating projects we mostly use Spring Initializer (It is an inbuilt API that is used for creating Java Virtual Machine projects.)If we use STS (Spring Tool Suit) which is a recommended IDE for making applications in Spring, it has a predefined feature for injecting dependencies.

Take a look below for a better understanding of how to generate projects in Spring Initializer

• Group: In this, we define the package name in which we are creating the project.

• Artifact: In this, we define our application name.

• Package Name: It is a combination of group and artifact

• Java: We can select the JVM version according to your preference. (11 or 8 is recommended because they are stable)

• Dependencies: At last, we choose dependencies for our project according to application requirements.

• Then we generate the project in a zip file, extract it and open it in your preferred IDE.

How to code Java Spring Boot, i.g:

Let’s break it down for understanding:

1. public static void main(String[] args):- This is the starting or execution point of your program.

2. SpringBootApplication.run(YourClassName.class, args):  - This line starts the code or runs the code, the “run” is a static method of SpringBootApplication which is a parameterized method that is taking two parameters one is ‘YourClassName.class’ and second one is ‘args’ as an array(passed to the main method).

3. @SpringBootApplication:- This annotation is one that Spring Boot offers.

The main functions of the Spring framework are dependency injection and inversion of control (IOC).

Dependency Injection: 

It converts the simple Java classes into objects and injects them into another object. In the project, we add dependencies in the pom.xml file if the project is built in Maven, otherwise in Gradle.

Inversion of Control(IOC):

We achieve the IOC method by injecting dependencies. We can say that it is used for the flexibility and reusability of the application component.

Before understanding the architecture of this framework, it is mandatory to know about the different classes and layers present in it. They are as follows:

1. Presentation layer or Client side: This layer is responsible for handling the HTTP requests, it converts the JavaScript Object Notation(JSON) into objects. In simple words, we use it as a frontend that is convenient for the user.

2. Business Layer or Logic handle: In this layer, we write the logic and create methods for validation and authorization. For this, we create a service class that is autowired with @Service annotation.

3. Persistence Layer or Controller: This is the layer or class through which we call the logic and validation methods that we have created in the business layer. By doing so, we implement the approach of storing the data in database rows. For this, we have to create a controller class that is annotated with @Controller or @RestController.

4. Database Layer: It is responsible for handling and performing the CRUD operations which are (create, get, update, and delete). For this, we create a repository class with annotations @Repository. Actually, this is not a class, this is an interface that extends JpaRepository.

There are two important files that we have to use in our application that are built into the project when we create it. You can find them in the src/main/resources folder: application.properties and application. YML.

application.properties:

It is a key-value pair file in which we can configure different properties like database connection pieces of information (username, password, database name), server port number, and other URLs that we require in our application. So we can update according to our needs in a common place whenever we want without changing the code.

application.YAML: 

This is also used for the same purposes as above; the difference is that it has a YAML/YML format.

Note: The main difference between these two files is that they both have different syntax.

Connection with Database

SB JPA: Spring’s JPA (Java Persistence API) helps to interact with relational databases. It allows us to connect with databases with the help of object-oriented programming, such as by using entities (models)  and repositories. By using it, we don’t have to write the code for the required database operations.It automatically creates a table in the database with the help of the entity class.

ORM:ORM is provided by JPA, also known as object-relational mapping.The ORM makes connections between the database and the application.

To approach the JPA, we have to add a dependency:

For pom.xml

For Gradle

JDBC: 

It stands for Java Database Connectivity, JDBC is a low-level API (application programming interface) that gives us a standard way to interact with databases. JPA and JDBC are not the same, on the other hand, JPA is a higher-level API that builds on top of JDBC.

Conclusion:

Overall, the concepts of the Spring Framework are dependency injection and inversion of control to promote loose coupling. The different layers present the separation between methods, so the architecture can be easily understood. Spring’s integration with the database using JPA makes it easier to access data and automates the table creation in the database based on the data column's name, which we provided. It allows developers to create efficient Java applications.