Spring Boot Architecture: Overview

Spring Boot is a framework that simplifies the development of Spring applications

by providing default configurations and a set of tools for fast development. It
aims to make it easier to set up and run Spring applications by removing much of
the boilerplate configuration. The architecture of Spring Boot is based on Spring's
core features, but with a focus on convention over configuration and the use of
embedded servers for easier deployment.
Key Concepts of Spring Boot Architecture
1. Spring Boot Starter Projects:
○ Spring Boot provides several "starters" (pre-configured templates for
common tasks) to make it easier to set up various functionalities like web
applications, data access, messaging, etc. For example, spring-boot-starter-web for
web applications, spring-boot-starter-data-jpa for JPA support, and spring-boot-
starter-actuator for monitoring.
2. Auto Configuration:
○ One of the key features of Spring Boot is auto-configuration. Spring
Boot automatically configures beans based on the project's dependencies. If a
particular dependency is found in the classpath, Spring Boot will try to
automatically configure related beans.
○ For example, if Spring Boot detects that you have spring-boot-
starter-data-jpa in the classpath, it automatically configures the necessary JPA
components (like EntityManager, DataSource, etc.).
3. Embedded Web Server:
○ Spring Boot uses embedded web servers (like Tomcat, Jetty, or
Undertow), meaning you don't need to deploy your application to an external server.
The embedded server is included as part of the application, and the application can
be run independently.
○ This is one of the main advantages of Spring Boot: you don’t need to
worry about deploying to an external application server.
4. Spring Boot Application Class:
○ Every Spring Boot application has a main class that contains the
@SpringBootApplication annotation, which is used to launch the application. This
annotation combines @Configuration, @EnableAutoConfiguration, and @ComponentScan,
making the class a central configuration point.
○ The main method in this class runs the application using
SpringApplication.run(), which bootstraps the application and initializes the
Spring context.
5. Spring Boot Properties File (application.properties or application.yml):
○ Spring Boot allows you to configure application properties using
application.properties or application.yml files. This configuration file is where
you can customize your application (such as database connection settings, server
configurations, etc.) in a convenient and standard way.
○ These properties can also be overridden with command-line arguments
or environment variables.
6. Actuator:
○ Spring Boot Actuator provides a set of built-in endpoints for
monitoring and managing Spring Boot applications in production. These endpoints
expose useful information, such as application health, metrics, and environment
properties, making it easy to monitor the application's status.
○ Actuator integrates seamlessly with Spring Boot, making it easy to
add production-ready features with minimal configuration.

Components of Spring Boot Architecture

Let's break down the architecture into its key components:
1. Spring Boot Application:
○ The entry point of a Spring Boot application is a Java class
annotated with @SpringBootApplication. This class has the main() method, which runs
the application by calling SpringApplication.run().
Example:
java
Copy code
@SpringBootApplication
public class MySpringBootApplication {
public static void main(String[] args) {
SpringApplication.run(MySpringBootApplication.class, args);
}
}
2. Auto Configuration:
○ Spring Boot's auto-configuration mechanism automatically configures
Spring beans based on the dependencies present in the classpath.
○ For example, if Spring Boot detects that you have a database-related
dependency (e.g., H2 or MySQL), it will automatically configure a DataSource,
EntityManagerFactory, and JpaTransactionManager.
3. Embedded Web Server:
○ Spring Boot can run a web application with an embedded web server,
such as Tomcat, Jetty, or Undertow. This means the application can be packaged into
a self-contained executable JAR/WAR file.
○ The embedded server is configured automatically depending on which
dependencies you include in your project.
4. Spring Boot Starters:
○ Spring Boot starters are predefined sets of configurations that
simplify setting up common functionality. For example:
§ spring-boot-starter-web: Configures everything needed to create
a web application with RESTful APIs.
§ spring-boot-starter-data-jpa: Configures JPA support for
database operations.
§ spring-boot-starter-thymeleaf: Configures Thymeleaf for
rendering web pages.
5. Spring Boot Configuration:
○ You configure Spring Boot applications using application.properties
or application.yml files. This file can define custom properties for various
aspects of your application like:
§ Server settings: Port, context path, etc.
§ Database settings: JDBC URL, username, password, etc.
§ Logging configuration: Levels, log patterns, etc.
Example (application.properties):

properties
Copy code
server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=rootpassword
logging.level.org.springframework=INFO
6. Spring Boot Actuator:
○ Spring Boot Actuator provides a set of production-ready features,
such as health checks, metrics, and monitoring, which can be easily added to your
Spring Boot application.
○ It exposes built-in endpoints like /health, /metrics, /info, etc.,
which provide information about the application's status, performance, and
configuration.
7. Spring Boot DevTools:
○ DevTools is a set of tools that helps improve the developer
experience by providing features such as automatic restarts, live reload, and
enhanced debugging support.
○ It is often used during development to speed up the development
process.
 8. Spring Boot CLI (Command Line Interface):
○ Spring Boot CLI is a command-line tool that allows developers to run
Spring Boot applications from the command line using Groovy scripts. It’s often
used for quick prototyping and development.

Key Features of Spring Boot Architecture

1. Convention Over Configuration:
○ Spring Boot follows the "convention over configuration" principle,
meaning it provides sensible default configurations, and you don’t need to
configure common aspects like view resolvers, database configurations, or data
sources unless you need to customize them.
2. Standalone Applications:
○ Spring Boot allows you to build standalone applications that don't
require a traditional web server like Tomcat or Jetty. With embedded servers, you
package everything into a self-contained executable JAR or WAR file.
3. Microservice-Friendly:
○ Spring Boot is commonly used to build microservices due to its
lightweight, minimal configuration approach. It integrates well with Spring Cloud
for building distributed systems.
4. Rapid Development:
○ Spring Boot simplifies development by using embedded servers, auto-
configuration, and extensive default settings. It eliminates the need for complex
configurations, allowing developers to focus on writing business logic.
5. Production-Ready:
○ Spring Boot provides production-ready features out-of-the-box, such
as health checks, metrics, and centralized logging. This makes it easier to deploy
and manage applications in production.
6. Testability:
○ Spring Boot simplifies unit testing with built-in support for Spring
Test and testing annotations like @SpringBootTest. This helps developers to test
applications in isolation or with an embedded application context.

Spring Boot Architecture Diagram

The architecture of a Spring Boot application can be represented as follows:

sql
Copy code
+-------------------------------------------+
| Spring Boot Application |
| (Entry Point with main() method) |
+-------------------------------------------+
|
v
+-------------------------------------------+
| Spring Boot Auto Configuration |
| (Configures beans automatically) |
+-------------------------------------------+
|
v
+-------------------------------------------+
| Embedded Web Server (Tomcat, etc.) |
| (Handles HTTP requests) |
+-------------------------------------------+
|
v
+-------------------------------------------+
| Spring Boot Starters (e.g., Web, |
| Data JPA, Security, etc.) |
+-------------------------------------------+
 |
v
+-------------------------------------------+
| Spring Boot Configuration |
| (application.properties / YAML) |
+-------------------------------------------+
|
v
+-------------------------------------------+
| Spring Boot Actuator (Metrics, |
| Health Checks, Monitoring, etc.) |
+-------------------------------------------+
|
v
+-------------------------------------------+
| Spring Boot DevTools (Development |
| Tools: Auto-restart, Live Reload) |
+-------------------------------------------+
Summary of Spring Boot Architecture
• Simplified Configuration: Spring Boot reduces the need for complex
configurations by using auto-configuration and sensible defaults.
• Embedded Servers: Spring Boot allows you to run web applications with
embedded servers, eliminating the need for external servers like Tomcat.
• Starters: Predefined starter templates make it easier to add functionality
(e.g., web support, database access) to your application.
• Production-Ready: Built-in features like health checks, metrics, and
monitoring make it easy to deploy and manage your application in production.
• Microservices: Spring Boot is a popular choice for building microservices
because of its minimal configuration and ease of deployment.
Spring Boot simplifies the development of Spring applications, making it easier to
get started and be productive with minimal configuration. Whether you're building a
monolithic application or a microservice, Spring Boot's architecture provides the
necessary tools to help you succeed.

Spring Boot Layers: An Overview

In Spring Boot, like in any other enterprise application, the architecture is often
divided into multiple layers to achieve separation of concerns, modularity, and
maintainability. The four layers you mentioned represent a commonly used layered
architecture approach for building scalable and maintainable applications. Below is
a detailed explanation of each layer and its responsibilities:
1. Presentation Layer (Web Layer)
• Responsibilities: The presentation layer is responsible for interacting
with the client or user interface. It handles HTTP requests, provides the API (such
as RESTful services), manages authentication, and converts data formats (such as
JSON).
• Components:
○ Controllers: The main role of controllers is to handle incoming
requests, process them, and return responses. In Spring Boot, controllers are
typically annotated with @RestController (for REST APIs) or @Controller (for
traditional web applications).
○ Authentication & Authorization: This layer is also responsible for
ensuring that users are authenticated and authorized to access specific resources.
Spring Security often handles these tasks, including managing login sessions, JWT
tokens, OAuth2 authentication, etc.
○ Response Formatting (JSON Translation): Spring Boot uses message
converters like Jackson or Gson to automatically convert Java objects to JSON
responses and vice versa.
• Key Annotations:
 ○ @RestController: For creating REST API controllers.
○ @Controller: For traditional web applications, used with
@RequestMapping or @GetMapping for request handling.
○ @RequestMapping, @GetMapping, @PostMapping: To map HTTP requests to
methods.
Example:

java
Copy code
@RestController
public class UserController {

@Autowired
private UserService userService;
@GetMapping("/users/{id}")
public ResponseEntity<User> getUser(@PathVariable Long id) {
User user = userService.getUserById(id);
return ResponseEntity.ok(user);
}
}
2. Business Layer (Service Layer)
• Responsibilities: The business layer contains the core business logic and
validations. It acts as an intermediary between the presentation and persistence
layers. It should not directly deal with database operations but instead focus on
business rules, validation, and transactions.
• Components:
○ Service Layer: In Spring Boot, the service layer is typically a
@Service annotated class. It holds the business logic and validation for the
application.
○ Validation: This layer is responsible for ensuring that the input
data is correct and meets business requirements. Validation can be done using Java
validation annotations (@NotNull, @Size, etc.) or custom validation logic.
○ Authorization: Some authorization logic may be placed here, although
a lot of it is often handled by the presentation layer (e.g., via Spring Security).
• Key Annotations:
○ @Service: Used to define a service class, where business logic
resides.
○ @Transactional: Ensures that methods in the service layer are
executed within a transactional context, providing rollback capabilities in case of
failure.
Example:

java
Copy code
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
public User getUserById(Long id) {
return userRepository.findById(id).orElseThrow(() -> new
ResourceNotFoundException("User not found"));
}
public User createUser(User user) {
// Business validation logic
return userRepository.save(user);
}
}
3. Persistence Layer (Data Access Layer)
• Responsibilities: The persistence layer is responsible for data access and
storage logic. This layer communicates with the database and ensures that data is
saved, retrieved, updated, or deleted. It abstracts away the details of data
storage and management from the rest of the application.
• Components:
○ Repositories: The persistence layer is often represented by the
repository pattern in Spring Boot. Spring Data JPA (or other Spring Data projects)
allows you to define repositories that interact with the database. The @Repository
annotation is used here to mark classes responsible for database operations.
○ Entities: These are Java objects (POJOs) that represent the tables in
the database. They are annotated with @Entity and often include mapping annotations
like @Id, @Column, etc.
• Key Annotations:
○ @Repository: Marks the class as a Spring Data repository, allowing it
to interact with the database.
○ @Entity: Marks a class as a JPA entity, which is mapped to a database
table.
○ @Id: Marks the primary key of the entity.
○ @Query: Allows custom SQL queries to be defined in repositories.
Example:

java
Copy code
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String username;
private String email;
// Getters and setters
}
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
Optional<User> findByUsername(String username);
}
4. Database Layer (Actual Database)
• Responsibilities: This layer represents the actual database where data is
stored. It could be any relational (e.g., MySQL, PostgreSQL) or NoSQL database
(e.g., MongoDB, Cassandra).
• Components:
○ Database Management System (DBMS): The DBMS handles the storage,
retrieval, and manipulation of data. Spring Boot can easily integrate with most
popular DBMS systems through JDBC or JPA.
○ Database Tables & Relationships: These are the actual tables and
relationships in the database that store data. Entities in the application
correspond to these tables.
• Key Aspects:
○ Spring Boot allows you to configure the database using the
application.properties or application.yml files for settings like the database URL,
username, password, and other connection details.
○ Spring Data JPA makes database interaction easier by abstracting much
of the underlying complexity of database operations (such as CRUD operations) and
providing automatic query generation.
Example (Database Configuration in application.properties):

properties
Copy code
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

How These Layers Interact

Here’s how the layers typically interact in a Spring Boot application:
1. User Request: A client (e.g., a web browser, mobile app, or external
system) sends an HTTP request to the Presentation Layer (e.g., @RestController).
2. Processing in Business Layer: The controller delegates the request to the
Business Layer (e.g., @Service), where the business logic and validation occur.
3. Data Handling in Persistence Layer: If data needs to be fetched or saved,
the Business Layer calls the Persistence Layer (e.g., @Repository).
4. Database Interaction: The Persistence Layer interacts with the Database
Layer (e.g., through JPA/Hibernate), performing the necessary data operations.
5. Response: The Business Layer sends the response back to the Presentation
Layer, which formats the data (e.g., as JSON) and sends it back to the client.
Diagram of the Layered Architecture

sql
Copy code
+--------------------------------------------------+
| Presentation Layer (Web Layer) |
| (Handles HTTP requests, JSON conversion, etc.) |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| Business Layer (Service Layer) |
| (Business Logic, Validation, Authorization) |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| Persistence Layer (Data Access Layer) |
| (Repository, JPA, DAO, etc.) |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| Database Layer (DB) |
| (Database such as MySQL, PostgreSQL, etc.) |
+--------------------------------------------------+

Benefits of Layered Architecture in Spring Boot

• Separation of Concerns: Each layer has a clear responsibility. This
separation makes the application easier to maintain, extend, and test.
• Modularity: By dividing the application into layers, developers can work on
different components without affecting others, leading to easier collaboration and
code management.
• Testability: Each layer can be tested independently. For example, you can
write unit tests for your business logic without worrying about the database.
• Flexibility: Changes in one layer (e.g., switching from one database to
another) don’t require changes in other layers.
This layered architecture is one of the most common patterns used in Spring Boot
and other enterprise-level Java applications. It promotes clean, maintainable, and
scalable code.