Unit 5: Spring Boot

Introduction to Spring Boot

Spring Boot is an extension of the Spring Framework that simplifies the development of stand-alone, production-ready Spring applications.

Why Spring Boot?

• Eliminates complex XML configuration
• Provides auto-configuration
• Embedded servers (Tomcat, Jetty)
• Faster development and deployment

Spring Boot Configuration

Spring Boot configuration defines how an application behaves at runtime.

Configuration Files

File	Purpose
application.properties	Key-value configuration
application.yml	YAML-based configuration

Example (application.properties)

server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/testdb

Types of Configuration

1. External Configuration – Properties/YAML
2. Java-based Configuration – @Configuration
3. Auto Configuration – Provided by Spring Boot

Spring Boot Annotations

Spring Boot uses annotations to reduce boilerplate code.

Core Spring Boot Annotations

@SpringBootApplication

Combination of:

• @Configuration
• @EnableAutoConfiguration
• @ComponentScan

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

Common Annotations

Annotation	Purpose
@RestController	REST APIs
@RequestMapping	URL mapping
@GetMapping	GET request
@PostMapping	POST request
@Autowired	Dependency Injection
@Value	Inject property value

Spring Boot Actuator

Spring Boot Actuator provides production-ready features to monitor and manage applications.

Actuator Features

• Health checks
• Metrics
• Environment info
• Application status

Common Actuator Endpoints

Endpoint	Description
/actuator/health	Application health
/actuator/info	App info
/actuator/metrics	Performance metrics
/actuator/env	Environment details

Example Dependency (Maven)

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Spring Boot Build Systems

Spring Boot supports build automation tools.

Common Build Systems

Tool	Description
Maven	XML-based
Gradle	Groovy/Kotlin-based

Maven vs Gradle

Maven	Gradle
pom.xml	build.gradle
Slower builds	Faster builds
XML syntax	Script syntax

Spring Boot Starter Parent (Maven)

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
</parent>

Spring Boot Code Structure

Spring Boot follows a standard project structure.

Typical Spring Boot Project Layout

src/main/java
 └── com.example.demo
     ├── controller
     ├── service
     ├── repository
     └── DemoApplication.java

src/main/resources
 ├── application.properties
 └── static / templates

Layered Architecture

Layer	Responsibility
Controller	Handles requests
Service	Business logic
Repository	Database access
Model	Data objects

Spring Boot Runners

Runners are used to execute code after application startup.

Types of Runners

1. CommandLineRunner

@Component
public class MyRunner implements CommandLineRunner {
    public void run(String... args) {
        System.out.println("Application Started");
    }
}

2. ApplicationRunner

@Component
public class AppRunner implements ApplicationRunner {
    public void run(ApplicationArguments args) {
        System.out.println("Application Running");
    }
}

Difference Between Runners

CommandLineRunner	ApplicationRunner
Uses String[] args	Uses ApplicationArguments
Simple	More flexible

Summary Table

Topic	Key Concept
Spring Boot	Simplified Spring
Configuration	Properties/YAML
Annotations	Reduce code
Actuator	Monitoring
Build Systems	Maven/Gradle
Runners	Startup logic

Exam Tips

• Always define Spring Boot clearly
• Write @SpringBootApplication components
• List Actuator endpoints
• Draw project structure diagram

Logger (Logging in Spring Boot)

A Logger is used to record application events, such as errors, warnings, and informational messages. Logging helps in debugging, monitoring, and maintenance of applications.

Logging Frameworks in Spring Boot

• SLF4J (default)
• Logback
• Log4j2

Common Log Levels

Level	Use
TRACE	Detailed debugging
DEBUG	Debugging
INFO	General information
WARN	Warning
ERROR	Error

Example: Logger in Spring Boot

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@RestController
public class TestController {

    Logger logger = LoggerFactory.getLogger(TestController.class);

    @GetMapping("/test")
    public String test() {
        logger.info("Test API called");
        return "Logging Example";
    }
}

Building RESTful Web Services

A RESTful Web Service is a web service that follows REST (Representational State Transfer) architecture principles and uses HTTP methods to perform operations.

REST Principles

• Stateless communication
• Resource-based URLs
• Uses standard HTTP methods
• Supports multiple data formats (JSON, XML)

Advantages of REST

• Lightweight
• Scalable
• Platform independent
• Widely used in APIs

REST Controller

@RestController

@RestController is a Spring Boot annotation used to create REST APIs.
It combines:

• @Controller
• @ResponseBody

Example

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello REST";
    }
}

Request Mapping

@RequestMapping

Used to map HTTP requests to handler methods.

Example

@RequestMapping(value="/users", method=RequestMethod.GET)
public String getUsers() {
    return "User List";
}

Shortcut Annotations

Annotation	HTTP Method
@GetMapping	GET
@PostMapping	POST
@PutMapping	PUT
@DeleteMapping	DELETE

Request Body

@RequestBody

Used to read JSON data from the request body and convert it into a Java object.

Example

@PostMapping("/user")
public User addUser(@RequestBody User user) {
    return user;
}

Use Case

• Sending form or JSON data from frontend to backend

Path Variable

@PathVariable

Used to extract values from the URL path.

Example

@GetMapping("/user/{id}")
public String getUser(@PathVariable int id) {
    return "User ID: " + id;
}

Request Parameter

@RequestParam

Used to read query parameters from URL.

Example

@GetMapping("/search")
public String search(@RequestParam String keyword) {
    return "Searching for " + keyword;
}

URL Example

/search?keyword=java

HTTP Methods (CRUD APIs)

GET API

• Fetch data

@GetMapping("/users")
public List<User> getAllUsers() {
    return userService.getUsers();
}

POST API

• Create new data

@PostMapping("/users")
public User createUser(@RequestBody User user) {
    return userService.save(user);
}

PUT API

• Update existing data

@PutMapping("/users/{id}")
public User updateUser(@PathVariable int id, @RequestBody User user) {
    return userService.update(id, user);
}

DELETE API

• Delete data

@DeleteMapping("/users/{id}")
public String deleteUser(@PathVariable int id) {
    userService.delete(id);
    return "User Deleted";
}

Build Web Applications using Spring Boot

Spring Boot helps in building complete web applications using:

• Spring MVC
• REST APIs
• Thymeleaf / Frontend integration
• Embedded server

Application Flow

Client → Controller → Service → Repository → Database

Benefits

• Rapid development
• Easy deployment
• Scalable architecture

Comparison Table

Concept	Purpose
Logger	Application monitoring
REST Controller	Build APIs
Request Mapping	URL handling
@RequestBody	Read JSON
@PathVariable	URL data
@RequestParam	Query data

Exam Tips

• Always define REST and Logger clearly
• Write HTTP methods in CRUD format
• Mention annotations with examples
• Draw architecture flow if required