Spring BOOT

Using REST
API
Introduction
Spring Boot is a project that is built on top of the Spring Framework.
It provides an easier and faster way to set up, configure, and run
both simple and web-based applications.
It is a Spring module that provides the RAD (Rapid Application
Development) feature to the Spring Framework used to create a
stand-alone Spring-based application that you can just run because it
needs minimal Spring configuration.
As summarized in the below figure, Spring Boot is the
combination of Spring Framework and Embedded
Servers.
Spring Boot Architecture

In Spring Boot, there is no requirement for XML configuration (deployment

descriptor). It uses convention over configuration software design paradigm
which means that it decreases the effort of the developer.
The main goal of Spring Boot is to reduce development, unit test, and
integration test time and leveraging the following features:
•Create stand-alone Spring applications
•Embed Tomcat, Jetty, or Undertow directly (no need to deploy WAR files)
Spring Boot Architecture

•Automatically configure Spring whenever possible

•Provide production-ready features such as metrics, health checks, and
externalized configuration
•Absolutely no code generation and no requirement for XML configuration
•Provide opinionated ‘starter’ POMs to simplify your Maven configuration
Spring Boot Architecture
Spring Boot Architecture

Presentation Layer: The presentation layer handles the HTTP requests,

translates the JSON parameter to object, and authenticates the request, and
transfer it to the business layer. In short, it consists of views.
Business Layer: The business layer handles all the business logic. It consists of
service classes and uses services provided by data access layers. It also performs
authorization and validation.
Persistence Layer: The persistence layer contains all the storage logic and
translates business objects from and to database rows.
Database Layer: In the database layer, CRUD (create, retrieve, update, delete)
operations are performed.
 Spring Boot Architecture

Spring Boot uses all the modules of Spring-like Spring MVC, Spring Data, etc. The architecture of Spring
Boot is the same as the architecture of Spring MVC, except for one thing: there is no need for DAO and
DAOImpl classes in Spring boot. As a summary, in a simple spring boot flow:
•Data access layer gets created and CRUD operations are performed.
•The client makes the HTTP requests.
•The request goes to the controller, and the controller maps that request and handles it. After that, it calls
the service logic if required.
•In the service layer, all the business logic performs. It performs the logic on the data that is mapped to JPA
with model classes.
•A response page is returned to the user if no error occurs.
Spring Boot Architecture
Spring Boot Annotations

Spring Boot Annotations is a form of metadata that provides data about a

program. Spring Boot Annotations are mostly placed in the following packages:
•org.springframework.boot.autoconfigure
•org.springframework.boot.autoconfigure.condition
Springboot code Structure App Name

Source Main class

package

Properties file

Pom file for

dependencies
Spring Boot Runners
In Spring Boot, runners are components used to execute code when the application is started.
They are typically implemented using Spring's ApplicationRunner or CommandLineRunner
interfaces. These runners allow you to perform tasks such as database initialization, data loading,
or any custom startup logic.
Application Runner
The ApplicationRunner
interface in Spring Boot
provides a way to execute
code after the application
context is initialized and
before Spring Boot starts
servicing incoming requests
CommandLine Runner
Similar to
import org.springframework.boot.CommandLineRunner;
ApplicationRunner, import org.springframework.stereotype.Component;
CommandLineRunner is an
alternative interface that @Component
provides a run method with public class MyCommandLineRunner implements
an array of String CommandLineRunner {
arguments. These
@Override
arguments are passed public void run(String... args) throws Exception {
directly to the application // Code to execute on application startup
when it is started from the System.out.println("CommandLineRunner is running...");
command line. }
}
 Example Use Cases
•Database Initialization: Load initial data or perform schema setup.

•External Service Initialization: Connect to external services or APIs.

•Cache Warming: Preload caches on application startup.

•Logging: Output informational messages or logs about application state.

Springboot Logger
In Spring Boot applications, logging is an essential aspect of monitoring and debugging. Spring Boot integrates with
popular logging frameworks like Logback, Log4j2, and Java Util Logging (JUL). Here’s a guide on how to use logging
in a Spring Boot application with an example using Logback.

Steps to add Logger in Springboot App

Step1: Add dependency in POM.XML File
<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>2.0.13</version>
</dependency>
Step2: import relevant package in either Controller , Service or repositories etc.
Rest API

REpresentational State Transfer (REST) is a software architectural style that

developers apply to web application programming interfaces (APIs).
REST APIs are the most common APIs used across the web today because the
REST pattern provides simple, uniform interfaces. These can be used to make
data, content, algorithms, media, and other digital resources available through
web URLs, so that they can be consumed within web, mobile, and device
applications.
Rest API
let’s consider my own personal Facebook presence, where I am a resource. I can view an HTML
representation of my resource at:

•GET https://www.facebook.com/prashant.tomer.946/

My profile is a single resource available on Facebook. I can view a representation of that resource in
HTML using that URL in my web browser. I can also view another representation of it using the
Facebook Graph API.

•GET https://graph.facebook.com/v7.0/me
Rest API
This is just one resource Facebook provides, offering up a buffet of digital resources for me to
consume as a developer.

•Comments: GET https://graph.facebook.com/v7.0/comments

•Friends: GET https://graph.facebook.com/v7.0/friends

•Images: GET https://graph.facebook.com/v7.0/images

•Links: GET https://graph.facebook.com/v7.0/links

•Likes: GET https://graph.facebook.com/v7.0/likes

Rest API
This allows for a handful of operations on each resource using HTTP methods:
•GET: https://graph.facebook.com/v7.0/images
•POST: https://graph.facebook.com/v7.0/images
•PUT: https://graph.facebook.com/v7.0/images
•DELETE: https://graph.facebook.com/v7.0/images
Create Spring boot App using Rest
API
Tools Required in this Soring Boot Application:

➢Eclipse IDE: For project development

➢Postman Application: Rest API Testing

➢Spring Boot API: For Spring boot libraries

➢JDK 8: base of java core development

 Steps to Create SpringBoot project
and use RestAPI

Step1: Download springboot skeleton from spring initializer.

Step 2: import step1 project in eclipse IDE.
Step3: Open main file where you get main method and run that class as usual
do in eclipse to run the normal class.
➢ Step4: Observe the output.
Project Skeleton
 Create a Rest Controller

Create a new package as com.example.demo.controller and create a new class as SampleController ,

now make this class as RestController using @RestController annotation

Now, Apply @GetMapping annotation to create an end point to access this controller, given below is
code:
Run Application
To test your REST end point, need to run your springboot application and check on which port your
application is running (check console and analyse the output , port number is also there), now go
to browser and access using your end point name:
Other endPoint
RequestMapping and
ResponseBody
In Spring Boot, @RequestMapping is a core annotation used to map HTTP requests to handler
methods in your application's controllers. It allows you to define how incoming requests should be
handled based on the request URL, HTTP method, request parameters, headers, and more.
Here’s a detailed guide on using @RequestMapping in Spring Boot:
PathVariable
You can capture parts of the URL as variables using curly braces {}:

@RequestMapping(value = "/user/{id}", method = RequestMethod.GET)

@ResponseBody

public String getUserById(@PathVariable Long id) {

// Logic to fetch user details based on id

return "User details for id: " + id;

}
Request Param
In Spring Boot, handling request parameters involves retrieving data sent by the client as part of
the URL query string or as form data in a POST request. Spring provides several ways to access
request parameters in your controller methods. Let's explore how you can work with request
parameters using @RequestParam, HttpServletRequest, and @PathVariable.
Thank You