Spring Boot

A Complete Developer Guide

MVC Pattern Spring Architecture AOP Dependency Injection REST API

Comprehensive Guide to Enterprise Java Development with Spring Boot

What is Spring Boot?

Spring Boot is an opinionated framework built on top of Your First Spring Boot App
the Spring Framework that simplifies application setup by
@SpringBootApplication
providing:
public class MyApp {

Auto-configuration — Sets up Spring beans automatically public static void main(String[] args) {
based on classpath SpringApplication
.run([Link], args);
}
Embedded server — Tomcat/Jetty runs inside your JAR —
no WAR files needed
}

Starter dependencies — 'spring-boot-starter-web' adds

everything for a web app

Production-ready — Health checks, metrics, and

monitoring out of the box
 The MVC Pattern Model — View — Controller: Separation of Concerns

Browser Controller Service Repository

Database
(Client) @Controller @Service @Repository

HTTP Request Routes request, Business logic, Data access, MySQL /

HTTP Response returns View/JSON transactions JPA/JDBC Postgres

Controller Example
@Controller
public class UserController {
Model View Controller
@GetMapping("/users/{id}")
public String getUser(
@PathVariable
Long id, Model model) { Represents data and Renders UI. Handles HTTP
[Link]("user", business logic. Java Thymeleaf templates, requests. Maps URLs
[Link](id)); POJOs, JPA entities, JSPs, or JSON for REST to methods.
return "user-detail"; DTOs. clients. Delegates to services.
}
}
Spring Framework Architecture
spring-core spring-context
Web Layer (Spring MVC, WebFlux, REST)
Beans, IoC container, ApplicationContext, events,
resource loading messaging

Service Layer (Business Logic, @Service)

spring-aop spring-data

Data Access Layer (JPA, JDBC, Spring Data) Aspect-oriented

Repositories, JPA integration
programming support

Spring Core (IoC Container, DI, AOP, Events)

spring-security spring-web

Auth, authorization, OAuth2 HTTP client, MVC framework

Infrastructure (Spring Boot Auto-config, Actuator, Security)

Spring ApplicationContext is the central IoC container that manages the lifecycle of all beans and their dependencies
 Dependency Injection (DI)
Constructor Injection Setter Injection Field Injection

Recommended Optional deps Avoid in prod

@Service @Service @Service

public class OrderService { public class ProductService { public class ReportService {
private final private
UserRepo repo; EmailService email; @Autowired // ⚠️ Avoid
private
// Spring auto-injects @Autowired UserRepo repo;
public public void
OrderService( setEmailService( // Harder to test;
// hides dependencies
UserRepo repo) { EmailService e) { }
[Link] = repo; [Link] = e;
} }
} }

IoC Container: Spring creates and manages bean instances. You declare what you need, Spring figures out how to provide it. Beans are
singletons by default — one shared instance per ApplicationContext.
Aspect-Oriented Programming (AOP)
What is AOP? Logging Aspect Example
@Aspect
AOP separates cross-cutting concerns (logging, security, @Component
public class LoggingAspect {
transactions) from business logic. Instead of duplicating
code across classes, you define an Aspect that runs // Matches all methods in service package
automatically at join points. @Pointcut("execution(* [Link].*.*(..))")
public void serviceMethods() {}

Aspect A module encapsulating a cross-cutting concern @Before("serviceMethods()")

(@Aspect) public void logBefore(JoinPoint jp) {
[Link](
"Calling: " +
Join Point A point in execution (method call, exception throw) [Link]());
}

Pointcut Expression that matches join points — where to apply @Around("serviceMethods()")

public Object measureTime(

Advice Code that runs at a join point (Before/After/Around) ProceedingJoinPoint pjp) throws Throwable {
long start = [Link]();

Weaving Linking aspects to target objects Object result = [Link]();

(compile/load/runtime) long ms = [Link]() - start;
[Link](
"Took: " + ms + "ms");
return result;
 Building a REST API with Spring Boot
GET /api/users Retrieve all users [Link]
@RestController
@RequestMapping("/api/users")
GET /api/users/{id} Retrieve user by ID public class UserController {

private final UserService svc;

POST /api/users Create a new user
public UserController(UserService svc) {
[Link] = svc;
PUT /api/users/{id} Update existing user }

@GetMapping
DELETE /api/users/{id} Delete a user public List<User> getAllUsers() {
return [Link]();
}
@RestController @RequestMapping
= @Controller + @ResponseBody. Auto- Maps URL prefix. Combine with @PostMapping
serializes return to JSON. @GetMapping, @PostMapping... @ResponseStatus(CREATED)
public
@PathVariable
@RequestBody User create(
Binds URL segment {id} to method
Deserializes JSON body to Java object. @RequestBody @Valid
parameter.
UserDTO dto) {
return [Link](dto);
}

@DeleteMapping("/{id}")
public void
 Complete Project Structure & Stack
Project Layout [Link] [Link] — Starters
src/main/java/com/app/ spring:
[Link] datasource: spring-boot-starter-web
controller/ url: jdbc:mysql://localhost/db MVC + embedded Tomcat + Jackson
[Link] username: root
service/ jpa: spring-boot-starter-data-jpa
[Link] ddl-auto: update JPA + Hibernate + DataSource
[Link] show-sql: true
repository/ server: spring-boot-starter-validation
[Link] port: 8080 @Valid + Bean Validation
model/
[Link]
spring-boot-starter-security
[Link] Auth & authorization layer
exception/ [Link] (JPA Entity)
[Link] @Entity
src/main/resources/ spring-boot-starter-test
@Table(name="users") JUnit 5 + Mockito + MockMvc
[Link] public class User {
[Link] @Id
spring-boot-starter-actuator
@GeneratedValue
Health, metrics, endpoints
private
Long id;
spring-boot-devtools
@Column(nullable=false) Auto-restart on changes
private
String name;
 Exception Handling & Validation
[Link] Bean Validation ([Link])
@RestControllerAdvice public class UserDTO {
public class GlobalExceptionHandler {
@NotBlank(message="Name required")
@ExceptionHandler([Link]) @Size(min=2, max=50)
@ResponseStatus private
(NOT_FOUND) String name;
public
ErrorResponse handleNotFound( @Email
@NotNull
ResourceNotFoundException ex) { private
return new ErrorResponse( String email;
[Link](), 404);
} // getters / setters
}Common HTTP Status Codes
@ExceptionHandler([Link])
public
200 OK Request succeeded
Map<String,String> handleValidation(
201
Resource created (POST)
MethodArgumentNotValidException ex) { Created
return [Link]() 400 Bad
Invalid input / validation failed
.getFieldErrors().stream() Request
.collect( 404 Not
Resource does not exist
toMap( Found
500
FieldError::getField, Interna Unexpected server error
FieldError::getDefaultMessage)); l Error
}
Summary & Key Takeaways

Spring Boot MVC Pattern Architecture

Auto-configuration Model = Data & Logic Layered: Web→Service→Repo

Embedded Tomcat server View = Presentation ApplicationContext = IoC
Starter dependencies Controller = HTTP handler Module-based (Core, AOP, Data...)
Rapid app bootstrapping Clean separation of concerns Spring Security integration

DI (IoC) AOP REST API

Beans managed by container Cross-cutting concerns @RestController + mappings

Constructor DI preferred @Before / @After / @Around @RequestBody / @PathVariable
@Autowired / @Component Pointcut expression lang @Valid for validation
Promotes testability No boilerplate in services @ControllerAdvice for errors

Build production-ready Java applications — fast. Spring Boot = less config, more productivity.