7️⃣ Spring Boot Profiles → 

Please visit  on if you wish shortcut study →https://niteshsynergy.com/spring-boot-profile

Else→

7️⃣ Spring Boot Profiles — In Depth

What are Profiles?

• Profiles in Spring Boot allow you to group configuration and beans that should only be active in specific environments or contexts.

• They help you switch between configurations easily for Dev, Test, UAT, Production, etc.

• Avoids hardcoding environment-specific settings in the app.

• Makes your app flexible and environment aware.

How Spring Profiles Work

• You create multiple config files named like application-{profile}.properties or .yml.

• You can annotate beans with @Profile("profileName") so those beans only load when that profile is active.

• You activate profiles using:

  • JVM argument: -Dspring.profiles.active=profileName

  • Environment variable: SPRING_PROFILES_ACTIVE=profileName

  • Programmatically via code or config files

Example Scenario: Multiple DB Configs

• Test: Use MySQL

• Production: Use MongoDB

• UAT (User Acceptance Test): Use H2 (In-memory DB)

Step 1: Define Profiles and Config Files

Create separate config files for each profile:

application-test.yml (MySQL)

spring:
 datasource:
   url: jdbc:mysql://localhost:3306/testdb
   username: testuser
   password: testpass
 jpa:
   hibernate:
     ddl-auto: update
   show-sql: true
 

application-prod.yml (MongoDB)

application-uat.yml (H2 In-memory DB)

spring:
 datasource:
   url: jdbc:h2:mem:uatdb;DB_CLOSE_DELAY=-1
   driverClassName: org.h2.Driver
   username: sa
   password: password
 jpa:
   hibernate:
     ddl-auto: create-drop
   show-sql: true
 

Step 2: Create Beans with @Profile

If you want to define separate beans depending on profile, annotate them:

@Configuration
public class DataSourceConfig {

   @Bean
   @Profile("test")
   public DataSource mysqlDataSource() {
       // configure and return MySQL DataSource
   }

   @Bean
   @Profile("prod")
   public MongoClient mongoClient() {
       // configure and return MongoDB client
   }

   @Bean
   @Profile("uat")
   public DataSource h2DataSource() {
       // configure and return H2 DataSource
   }
}
 

Step 3: Activate Profiles

You can activate profiles in multiple ways:

• CLI or JVM args

java -jar app.jar --spring.profiles.active=test
# or
java -jar app.jar -Dspring.profiles.active=prod
 

application.properties (default profile)

spring.profiles.active=uat
 

Environment variable

export SPRING_PROFILES_ACTIVE=prod
 

Step 4: Example: Banking Application Fetching Transactions (with Profiles)

You want your banking app to fetch transactions from different databases depending on environment.

• On test, transactions come from MySQL

• On prod, transactions come from MongoDB

• On uat, use H2 for fast testing

The service layer can stay the same, Spring injects the correct datasource/bean based on profile.

Code Example: Repository Interface

public interface TransactionRepository {
   List<Transaction> findByUserIdAndDateRange(String userId, LocalDate start, LocalDate end);
}
 

MySQL Implementation (Test Profile)

@Repository
@Profile("test")
public class MysqlTransactionRepository implements TransactionRepository {
   // Use JdbcTemplate or JPA with MySQL connection
}
 

MongoDB Implementation (Prod Profile)

@Repository
@Profile("prod")
public class MongoTransactionRepository implements TransactionRepository {
   // Use MongoTemplate or MongoRepository here
}
 

H2 Implementation (UAT Profile)

@Repository
@Profile("uat")
public class H2TransactionRepository implements TransactionRepository {
   // Use JdbcTemplate or JPA with H2 DB
}
 

Complete Spring Boot Example: Banking Transactions with Profiles & Multiple DBs

Project Structure:

src/main/java/com/example/banking
├─ controller
│    └─ TransactionController.java
├─ service
│    └─ TransactionService.java
├─ repository
│    ├─ TransactionRepository.java  (interface)
│    ├─ MysqlTransactionRepository.java (@Profile test)
│    ├─ MongoTransactionRepository.java (@Profile prod)
│    └─ H2TransactionRepository.java (@Profile uat)
├─ model
│    └─ Transaction.java
├─ config
│    └─ DataSourceConfig.java
└─ BankingApplication.java
 

1. Model - Transaction.java

package com.example.banking.model;

import java.time.LocalDate;

public class Transaction {
   private String id;
   private String userId;
   private LocalDate date;
   private double amount;
   private String description;

   // getters and setters

   public Transaction() {}

   public Transaction(String id, String userId, LocalDate date, double amount, String description) {
       this.id = id;
       this.userId = userId;
       this.date = date;
       this.amount = amount;
       this.description = description;
   }

   // Getters and setters below
}
 

2. Repository Interface

package com.example.banking.repository;

import com.example.banking.model.Transaction;

import java.time.LocalDate;
import java.util.List;

public interface TransactionRepository {
   List<Transaction> findByUserIdAndDateRange(String userId, LocalDate start, LocalDate end);
}
 

3. MySQL Implementation (test profile)

package com.example.banking.repository;

import com.example.banking.model.Transaction;
import org.springframework.context.annotation.Profile;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.sql.ResultSet;
import java.time.LocalDate;
import java.util.List;

@Repository
@Profile("test")
public class MysqlTransactionRepository implements TransactionRepository {

   private final JdbcTemplate jdbcTemplate;

   public MysqlTransactionRepository(JdbcTemplate jdbcTemplate) {
       this.jdbcTemplate = jdbcTemplate;
   }

   @Override
   public List<Transaction> findByUserIdAndDateRange(String userId, LocalDate start, LocalDate end) {
       String sql = "SELECT id, user_id, date, amount, description FROM transactions WHERE user_id = ? AND date BETWEEN ? AND ?";
       return jdbcTemplate.query(sql, (ResultSet rs, int rowNum) -> new Transaction(
               rs.getString("id"),
               rs.getString("user_id"),
               rs.getDate("date").toLocalDate(),
               rs.getDouble("amount"),
               rs.getString("description")
       ), userId, java.sql.Date.valueOf(start), java.sql.Date.valueOf(end));
   }
}
 

4. MongoDB Implementation (prod profile)

package com.example.banking.repository;

import com.example.banking.model.Transaction;
import org.springframework.context.annotation.Profile;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Repository;

import java.time.LocalDate;
import java.util.List;

@Repository
@Profile("prod")
public class MongoTransactionRepository implements TransactionRepository {

   private final MongoTemplate mongoTemplate;

   public MongoTransactionRepository(MongoTemplate mongoTemplate) {
       this.mongoTemplate = mongoTemplate;
   }

   @Override
   public List<Transaction> findByUserIdAndDateRange(String userId, LocalDate start, LocalDate end) {
       Query query = new Query();
       query.addCriteria(Criteria.where("userId").is(userId)
               .andOperator(Criteria.where("date").gte(start), Criteria.where("date").lte(end)));
       return mongoTemplate.find(query, Transaction.class);
   }
}
 

5. H2 Implementation (uat profile)

package com.example.banking.repository;

import com.example.banking.model.Transaction;
import org.springframework.context.annotation.Profile;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.sql.ResultSet;
import java.time.LocalDate;
import java.util.List;

@Repository
@Profile("uat")
public class H2TransactionRepository implements TransactionRepository {

   private final JdbcTemplate jdbcTemplate;

   public H2TransactionRepository(JdbcTemplate jdbcTemplate) {
       this.jdbcTemplate = jdbcTemplate;
   }

   @Override
   public List<Transaction> findByUserIdAndDateRange(String userId, LocalDate start, LocalDate end) {
       String sql = "SELECT id, user_id, date, amount, description FROM transactions WHERE user_id = ? AND date BETWEEN ? AND ?";
       return jdbcTemplate.query(sql, (ResultSet rs, int rowNum) -> new Transaction(
               rs.getString("id"),
               rs.getString("user_id"),
               rs.getDate("date").toLocalDate(),
               rs.getDouble("amount"),
               rs.getString("description")
       ), userId, java.sql.Date.valueOf(start), java.sql.Date.valueOf(end));
   }
}
 

6. Service Layer

package com.example.banking.service;

import com.example.banking.model.Transaction;
import com.example.banking.repository.TransactionRepository;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.util.List;

@Service
public class TransactionService {

   private final TransactionRepository transactionRepository;

   public TransactionService(TransactionRepository transactionRepository) {
       this.transactionRepository = transactionRepository;
   }

   public List<Transaction> getTransactionsByUserAndDateRange(String userId, LocalDate start, LocalDate end) {
       return transactionRepository.findByUserIdAndDateRange(userId, start, end);
   }
}
 

7. Controller

package com.example.banking.controller;

import com.example.banking.model.Transaction;
import com.example.banking.service.TransactionService;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDate;
import java.util.List;

@RestController
@RequestMapping("/api/transactions")
public class TransactionController {

   private final TransactionService transactionService;

   public TransactionController(TransactionService transactionService) {
       this.transactionService = transactionService;
   }

   // 1. Fetch transactions by month (year-month format)
   @GetMapping("/month")
   public List<Transaction> getTransactionsByMonth(
           @RequestParam String userId,
           @RequestParam int year,
           @RequestParam int month) {
       LocalDate start = LocalDate.of(year, month, 1);
       LocalDate end = start.withDayOfMonth(start.lengthOfMonth());
       return transactionService.getTransactionsByUserAndDateRange(userId, start, end);
   }

   // 2. Fetch transactions by custom date range
   @GetMapping("/range")
   public List<Transaction> getTransactionsByDateRange(
           @RequestParam String userId,
           @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate start,
           @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate end) {
       return transactionService.getTransactionsByUserAndDateRange(userId, start, end);
   }

   // 3. Fetch transactions for current month
   @GetMapping("/currentMonth")
   public List<Transaction> getTransactionsCurrentMonth(@RequestParam String userId) {
       LocalDate now = LocalDate.now();
       LocalDate start = now.withDayOfMonth(1);
       LocalDate end = now.withDayOfMonth(now.lengthOfMonth());
       return transactionService.getTransactionsByUserAndDateRange(userId, start, end);
   }
}
 

8. DataSourceConfig

For MySQL and H2 datasource configuration:

package com.example.banking.config;

import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {

   @Bean
   @Profile("test")
   public DataSource mysqlDataSource() {
       DriverManagerDataSource ds = new DriverManagerDataSource();
       ds.setDriverClassName("com.mysql.cj.jdbc.Driver");
       ds.setUrl("jdbc:mysql://localhost:3306/testdb");
       ds.setUsername("testuser");
       ds.setPassword("testpass");
       return ds;
   }

   @Bean
   @Profile("uat")
   public DataSource h2DataSource() {
       DriverManagerDataSource ds = new DriverManagerDataSource();
       ds.setDriverClassName("org.h2.Driver");
       ds.setUrl("jdbc:h2:mem:uatdb;DB_CLOSE_DELAY=-1");
       ds.setUsername("sa");
       ds.setPassword("");
       return ds;
   }

   @Bean
   @Profile("prod")
   public MongoClient mongoClient() {
       return MongoClients.create("mongodb://prodUser:prodPass@prodHost:27017/proddb");
   }
}
 

9. Main Application Class

package com.example.banking;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class BankingApplication {

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

10. application.yml

spring:
 profiles:
   active: uat  # Change this to test, prod or uat to switch environment

# Common configs can go here
 

How To Run

• Switch profile in application.yml or via command line:

# Run with test profile (MySQL)
mvn spring-boot:run -Dspring-boot.run.profiles=test

# Run with prod profile (MongoDB)
mvn spring-boot:run -Dspring-boot.run.profiles=prod

# Run with uat profile (H2)
mvn spring-boot:run -Dspring-boot.run.profiles=uat
 

Next →

8️⃣ Spring Boot DevTools — In Depth

What is Spring Boot DevTools?

• Spring Boot DevTools is a module that enhances the development experience by providing features like:

  • Automatic restart of your application on code changes.

  • LiveReload support to refresh your browser automatically.

  • Hot swapping for faster feedback.

  • Helpful developer-friendly error pages.

• It is only intended for development, not production.

How to Add DevTools?

Add this dependency in your pom.xml or build.gradle:

Maven

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-devtools</artifactId>
 <optional>true</optional>
</dependency>
 

Gradle

developmentOnly("org.springframework.boot:spring-boot-devtools")
 

1. Hot Swapping

• Hot swapping means you can update your code (e.g., Java classes, static resources) and see changes without restarting your JVM manually.

• DevTools triggers automatic restart or reload of changed classes.

• How it works internally:
  Spring Boot runs your app in a special classloader that watches your target/classes or build/classes folders. When a class changes, the classloader reloads the application context.

2. Auto Restart

• When you modify any class or resource, DevTools automatically restarts your app to apply changes.

• It’s faster than a full restart because:

  • Only your app classes are reloaded (not libraries).

  • Uses two classloaders: one for static libraries (no reload), one for app classes (reload).

• It watches specific folders (src/main/java, resources) by default.

• Configuring Restart:

  You can exclude or include files from restart using spring.devtools.restart.exclude and spring.devtools.restart.additional-paths in application.properties.

spring.devtools.restart.exclude=static/**,public/**
spring.devtools.restart.additional-paths=src/main/webapp
 

3. LiveReload

• DevTools comes with built-in support for LiveReload.

• When resources or templates change, it triggers your browser to reload automatically.

• How to use:

  Just enable the LiveReload plugin/extension in your browser (available for Chrome/Firefox), or install a LiveReload client.

• By default, LiveReload runs on port 35729.

• You can disable LiveReload via:

spring.devtools.livereload.enabled=false
 

4. Developer-friendly Error Pages

• When your app throws an exception, DevTools shows detailed error pages in the browser.

• These pages contain:

  • Full stack trace.

  • Variables in scope.

  • Source code snippet around the error.

• This is way more useful than generic 500 errors.

• This is enabled by default in DevTools and disables when the app runs outside development mode.

Example: Using DevTools in a Simple Spring Boot App

1. Add devtools dependency.

2. Run your app.

3. Modify a controller or HTML template.

4. Notice the app automatically restarts and your browser refreshes.

Additional Tips

• Disable caching in Thymeleaf templates during development to see instant updates:

spring.thymeleaf.cache=false
 

• Restart triggers:

  DevTools restarts only on changes to .class or .properties files. If you add new files, you might need a manual restart.

• Remote Restart:

  DevTools supports remote restart where you can connect your IDE to a remote app and trigger restart.

• When NOT to use DevTools

• In production — because it adds overhead and exposes detailed errors.

• If you want full control over restarts (e.g., with external build tools or container-based deployments).

• ---

• Summary Table

• Feature	Description	Developer Benefit
  Hot Swapping	Reload changed classes without manual restart	Faster dev cycle, instant feedback
  Auto Restart	Automatically restarts on code/resource changes	Saves time, no manual restarts
  LiveReload	Auto refresh browser on resource changes	No manual refresh needed, better front-end dev
  Error Pages	Detailed stack trace with source in browser	Easier debugging and faster issue identification

   

  9️⃣ Spring Boot Logging — Detailed Explanation

  ---

  1. Default Logging in Spring Boot

  • Spring Boot uses Logback as the default logging framework.

  • When you create a Spring Boot project, Logback is included automatically (through spring-boot-starter).

  • You do not need to configure anything to start logging; it’s ready out of the box.

  • Log output:
    Logs are printed to the console by default with a default pattern including timestamps, log levels, thread, and message.

  ---

  2. Logging Levels

  Logging levels define the severity and verbosity of logs. The levels in increasing order of severity are:

  Level	Description	When to use
  TRACE	Most detailed, logs everything including fine-grained events.	Debugging very detailed issues
  DEBUG	Less detailed than TRACE, used for debugging.	Debugging logic flow and state changes
  INFO	General application info like startup, shutdown, major events	Production useful info, app lifecycle
  WARN	Potential problems or important notices	Warnings that don’t stop app but should be noticed
  ERROR	Serious issues like exceptions	Errors that might cause failure
  OFF	Turns off logging	Disable logging

   

   

  How to set logging level?

  You can configure logging level globally or per package/class using application.properties or application.yml.

  Example: application.properties

   

  # Global logging level
  logging.level.root=INFO

  # Package specific level
  logging.level.com.sogdo.banking=DEBUG

  # Set SQL logging to TRACE (very verbose)
  logging.level.org.hibernate.SQL=TRACE
   

   

  3. External Logging Configuration

  • Spring Boot allows you to use your own Logback, Log4j2, or Java Util Logging configuration file instead of the default.

  • Place your config file under src/main/resources:

  Framework	Config file name
  Logback	logback-spring.xml or logback.xml
  Log4j2	log4j2-spring.xml or log4j2.xml
  Java Util Logging	logging.properties

   

  4. Logback Customization Example (Banking App)

  Create logback-spring.xml

  5. Logging in Code

  Use org.slf4j.Logger to log in your classes.

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

  @Service
  public class BankStatementService {

     private static final Logger logger = LoggerFactory.getLogger(BankStatementService.class);

     public List<Transaction> getTransactions(Long userId) {
         logger.info("Fetching transactions for userId: {}", userId);
         try {
             // logic to fetch transactions
             logger.debug("Querying database for transactions");
             // ...
         } catch (Exception e) {
             logger.error("Error fetching transactions", e);
         }
         return List.of(); // example
     }
  }
   

   

  6. Best Practices for Logging

  • Use appropriate log levels to avoid noisy logs in production.

  • Use parameterized logging (logger.info("User {} logged in", userId)) to avoid unnecessary string concatenation.

  • Avoid logging sensitive info like passwords or credit card numbers.

  • Use structured logging (JSON logs) if your infrastructure supports it for better log analysis.

  • Use external log management tools (like ELK stack, Splunk) to aggregate and analyze logs.

  ---

  Summary Table

  Concept	Description	Example Use Case
  Default Logging	Uses Logback out of the box	Console logs with timestamp and level
  Logging Levels	TRACE, DEBUG, INFO, WARN, ERROR	DEBUG for dev, INFO for production
  External Config	Custom logback-spring.xml to tailor logging	Different logging pattern per environment
  Logger API	Use SLF4J Logger for logging in classes	logger.info("User login: {}", userId)

   

   

  🔟 Spring Boot with REST (Core Concepts)

  ---

  1. @RestController and HTTP Method Annotations

  • @RestController = @Controller + @ResponseBody
    It means this controller handles REST APIs and returns the response body directly (usually JSON/XML) instead of resolving to a view.

  • HTTP method annotations define the endpoint type:

    • @GetMapping – For GET requests

    • @PostMapping – For POST requests

    • @PutMapping – For PUT requests

    • @DeleteMapping – For DELETE requests

  Example:

  @RestController
  @RequestMapping("/api/banking")
  public class TransactionController {

     @GetMapping("/transactions")
     public List<Transaction> getAllTransactions() {
         // Return all transactions (JSON response by default)
         return transactionService.getAll();
     }
     
     @PostMapping("/transaction")
     public Transaction createTransaction(@RequestBody Transaction transaction) {
         // Accept JSON request body, create and return transaction
         return transactionService.save(transaction);
     }
  }
   

  2. REST vs MVC (Model-View-Controller)

  Aspect	REST Controller	MVC Controller
  Purpose	Expose RESTful APIs, return data (JSON/XML)	Return Views (HTML pages, JSP, Thymeleaf)
  Annotation	@RestController	@Controller
  Response Type	JSON/XML typically	HTML View templates
  Example Use Case	Mobile apps, SPA frontend consuming JSON	Server-side rendered web pages

   

  3. Returning JSON or XML

  • Spring Boot uses Jackson library by default for JSON serialization/deserialization.

  • To support XML, add dependency spring-boot-starter-xml (which brings JAXB or Jackson-dataformat-xml).

  • The response format depends on Accept HTTP header sent by the client.

  Example returning JSON or XML:

  @GetMapping(value = "/transaction/{id}", produces = {MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE})
  public Transaction getTransaction(@PathVariable Long id) {
     return transactionService.findById(id);
  }
   

  • If client sends Accept: application/json, response will be JSON.

  • If client sends Accept: application/xml, response will be XML.

  4. Handling RequestBody and Response

  • Use @RequestBody to map HTTP request body (JSON/XML) to Java object.

  • Use @ResponseBody (or @RestController) to automatically convert Java object to JSON/XML response.

  • You can return Java objects or ResponseEntity<T> for more control over HTTP status and headers.

  Example:

  @PostMapping("/transaction")
  public ResponseEntity<Transaction> createTransaction(@RequestBody Transaction transaction) {
     Transaction savedTransaction = transactionService.save(transaction);
     return ResponseEntity.status(HttpStatus.CREATED).body(savedTransaction);
  }
   

   

  5. Banking Example: Fetching Bank Statement

  Imagine you want to provide APIs for users to fetch bank statements by:

  • Current month

  • Specific month

  • Date range

  Controller:

  @RestController
  @RequestMapping("/api/banking/statements")
  public class BankStatementController {

     @Autowired
     private BankStatementService statementService;

     // 1. Current month statements
     @GetMapping("/current-month/{userId}")
     public List<Transaction> getCurrentMonthStatement(@PathVariable Long userId) {
         return statementService.getTransactionsForCurrentMonth(userId);
     }

     // 2. Specific month (year and month as params)
     @GetMapping("/month/{userId}")
     public List<Transaction> getStatementForMonth(
         @PathVariable Long userId,
         @RequestParam int year,
         @RequestParam int month) {
         return statementService.getTransactionsForMonth(userId, year, month);
     }

     // 3. Date range (startDate and endDate as query params)
     @GetMapping("/range/{userId}")
     public List<Transaction> getStatementForDateRange(
         @PathVariable Long userId,
         @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
         @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate) {
         return statementService.getTransactionsForDateRange(userId, startDate, endDate);
     }
  }
   

   

  Explanation:

  • @PathVariable — Used for dynamic parts of URL path, e.g., userId.

  • @RequestParam — Used to pass query parameters, e.g., year, month, dates.

  • @DateTimeFormat — Ensures dates in query params are parsed properly.

   

  Summary Table of Key Annotations

  Annotation	Purpose	Example
  @RestController	Marks class as REST controller (returns response body)	@RestController
  @GetMapping	Maps GET HTTP requests	@GetMapping("/transactions")
  @PostMapping	Maps POST HTTP requests	@PostMapping("/transaction")
  @RequestBody	Binds HTTP request body (JSON/XML) to Java object	public void save(@RequestBody Transaction txn)
  @ResponseBody	Returns Java object as response body	Usually implicit in @RestController
  @PathVariable	Extracts variable from URI path	/user/{id}, @PathVariable Long id
  @RequestParam	Extracts query parameters from URL	/transactions?year=2024&month=5

   

   

   

  1️⃣1️⃣ Spring Boot Error Handling

  ---

  1. Default Error Handling in Spring Boot

  • Spring Boot provides a default error page for any uncaught exceptions or HTTP errors.

  • This default error page is a whitelabel error page — a simple HTML page showing status code and error message.

  • It’s powered by Spring Boot’s BasicErrorController (which implements ErrorController interface).

  Example: When a request hits an unknown URL or an exception is thrown, you get a default page like:

  Whitelabel Error Page
  This application has no explicit mapping for /error, so you are seeing this as a fallback.
  There was an unexpected error (type=Not Found, status=404).
  No message available
  

   

  2. ErrorController Interface

  • Spring Boot uses ErrorController to map /error path to error handling logic.

  • You can implement your own ErrorController to override default behavior for all errors globally.

  Example:

  @Controller
  public class CustomErrorController implements ErrorController {

     @RequestMapping("/error")
     public String handleError(HttpServletRequest request) {
         // You can retrieve error status and details from request attributes
         Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code");
         Exception exception = (Exception) request.getAttribute("javax.servlet.error.exception");
         
         // Return your own error view name
         return "customErrorPage";
     }

     @Override
     public String getErrorPath() {
         return "/error";
     }
  }
   

  3. Custom Error Pages (HTML / JSON)

  • You can customize error responses for HTML or REST APIs by creating your own error pages or JSON responses.

  For HTML:

  • Create error pages in src/main/resources/templates/error/ named by HTTP status codes:

   

  error/404.html
  error/500.html
  error/default.html
   

  Spring Boot will automatically pick these pages for the respective errors.

  For JSON (REST API):

  • Override error response by creating a @ControllerAdvice or @RestControllerAdvice with @ExceptionHandler.

  ---

  4. @ControllerAdvice (Core to Spring Boot Error Handling)

  • It’s a global exception handler for controllers.

  • Use it to handle exceptions across all controllers and return custom JSON or views.

  • Supports handling specific exceptions or all exceptions.

  Example: Banking API global error handler

  @RestControllerAdvice
  public class GlobalExceptionHandler {

     @ExceptionHandler(TransactionNotFoundException.class)
     public ResponseEntity<ErrorResponse> handleTransactionNotFound(TransactionNotFoundException ex) {
         ErrorResponse error = new ErrorResponse(HttpStatus.NOT_FOUND.value(),
                                                 ex.getMessage(),
                                                 System.currentTimeMillis());
         return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
     }

     @ExceptionHandler(Exception.class)
     public ResponseEntity<ErrorResponse> handleGenericException(Exception ex) {
         ErrorResponse error = new ErrorResponse(HttpStatus.INTERNAL_SERVER_ERROR.value(),
                                                 "Something went wrong. Please try again.",
                                                 System.currentTimeMillis());
         return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
     }
  }
   

   

  Explanation:

  • @RestControllerAdvice acts globally.

  • @ExceptionHandler specifies exception type to handle.

  • Returning custom error response with status and message.

  ErrorResponse DTO:

  public class ErrorResponse {
     private int status;
     private String message;
     private long timeStamp;

     // constructors, getters, setters
  }
   

   

   

  1️⃣2️⃣ Spring Boot Actuator

  ---

  1. Introduction to Actuator

  • Spring Boot Actuator provides production-ready features to monitor and manage your Spring Boot application.

  • It exposes endpoints over HTTP or JMX to provide info about application health, metrics, environment, etc.

  • Helps developers & ops teams monitor, troubleshoot, and gain insights without custom coding.

  Why use Actuator?

  • Easy monitoring of app health

  • Track metrics (requests, CPU, memory)

  • View configuration properties & environment

  • Trace HTTP requests

  • Audit app events and much more

  ---

  2. How to Add Actuator

  Add the dependency in pom.xml:

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

  3. Common Actuator Endpoints

  By default, some endpoints are enabled (like /actuator/health, /actuator/info), others are disabled or restricted.

  Endpoint	Description	Default Exposure
  /actuator/health	Shows app health status	Public
  /actuator/info	Custom application info	Public
  /actuator/metrics	Metrics like memory, CPU, etc.	Restricted
  /actuator/httptrace	Recent HTTP requests	Restricted
  /actuator/env	Environment properties	Restricted

   

  4. Health Check & Metrics

  Health Check

  • The /actuator/health endpoint gives you the health status of the app: UP, DOWN, OUT_OF_SERVICE, or UNKNOWN.

  • You can add custom health indicators to report health of dependencies like databases or external services.

  Example: Custom health check for banking database connection

  @Component
  public class BankDbHealthIndicator implements HealthIndicator {

     @Override
     public Health health() {
         // Check if bank database is reachable
         boolean dbUp = checkDatabaseConnection(); // your logic here

         if (dbUp) {
             return Health.up().withDetail("Bank DB", "Available").build();
         } else {
             return Health.down().withDetail("Bank DB", "Not reachable").build();
         }
     }

     private boolean checkDatabaseConnection() {
         // Implementation: ping DB or query a simple select 1
         return true; // assuming OK here
     }
  }
   

   

  Metrics

  • The /actuator/metrics endpoint exposes key performance metrics.

  • You can query metrics by name, e.g. /actuator/metrics/jvm.memory.used.

  5. Custom Endpoints

  You can create your own actuator endpoints to expose custom info or operations.

  Example: Custom banking actuator endpoint to show number of transactions today

  @Component
  @Endpoint(id = "transactionCount")
  public class TransactionCountEndpoint {

     private final TransactionService transactionService;

     public TransactionCountEndpoint(TransactionService transactionService) {
         this.transactionService = transactionService;
     }

     @ReadOperation
     public int transactionsToday() {
         return transactionService.countTransactionsForToday();
     }
  }
   

  @Component
  @Endpoint(id = "transactionCount")
  public class TransactionCountEndpoint {

     private final TransactionService transactionService;

     public TransactionCountEndpoint(TransactionService transactionService) {
         this.transactionService = transactionService;
     }

     @ReadOperation
     public int transactionsToday() {
         return transactionService.countTransactionsForToday();
     }
  }
   

  • Exposed at /actuator/transactionCount

  • You can add @WriteOperation or @DeleteOperation for other REST verbs.

  6. Securing Actuator Endpoints (Minimal)

  By default, sensitive actuator endpoints like /metrics and /env are not exposed publicly.

  Enable all endpoints in application.properties:

   

  management.endpoints.web.exposure.include=health,info,metrics,env,transactionCount
   

   

  Minimal security example:

  @Configuration
  public class ActuatorSecurityConfig extends WebSecurityConfigurerAdapter {

     @Override
     protected void configure(HttpSecurity http) throws Exception {
         http
             .authorizeRequests()
             .requestMatchers(EndpointRequest.toAnyEndpoint()).hasRole("ACTUATOR_ADMIN")
             .and()
             .httpBasic();
     }
  }
   

   

  • This requires users to have role ACTUATOR_ADMIN to access actuator endpoints.

  • Configure user in application.properties or via other security mechanisms.

   

   

  Next→

   

  1️⃣3️⃣ Spring Boot Testing (Core Concepts)

  Spring Boot provides powerful testing support to validate layers (controller, service, repository) with minimal configuration using special annotations called Test Slices.

  ---

  🔹 @SpringBootTest

  • Loads the full application context (like production).

  • Best for integration tests across all layers.

  @SpringBootTest
  public class BankingIntegrationTest {

     @Autowired
     private TransactionService transactionService;

     @Test
     void testMonthlyStatementFetch() {
         List<Transaction> list = transactionService.getTransactionsByMonth("2024-12");
         assertEquals(10, list.size());
     }
  }
   

  🔧 Use when: Testing multiple beans (controller + service + repo + config)

   

   

  🔹 @WebMvcTest

  • Loads only Controller layer + minimal web config.

  • No @Service, @Repository loaded unless manually mocked.

   

  @WebMvcTest(TransactionController.class)
  public class TransactionControllerTest {

     @Autowired
     private MockMvc mockMvc;

     @MockBean
     private TransactionService transactionService;

     @Test
     void testGetCurrentMonthTransactions() throws Exception {
         when(transactionService.getCurrentMonthTransactions()).thenReturn(mockedList());

         mockMvc.perform(get("/transactions/current-month"))
                .andExpect(status().isOk());
     }
  }
   

   

  🔧 Use when: You want to test only Controller + Request/Response mapping.

   

  🔹 @DataJpaTest

  Loads only JPA repository and DB layer (uses embedded H2 by default).

  Useful for DB query testing without loading full app.

  @DataJpaTest
  public class TransactionRepositoryTest {

     @Autowired
     private TransactionRepository transactionRepo;

     @Test
     void testFindByMonth() {
         transactionRepo.save(new Transaction(...));
         List<Transaction> result = transactionRepo.findByMonth("2025-01");
         assertFalse(result.isEmpty());
     }
  }
   

  🔧 Use when: Testing DB logic in isolation.

  🔹 ApplicationContext loading

  • Use @ContextConfiguration to load custom context in special cases.

  • Default behavior in Spring Boot is to auto-detect main config class.

   

   

  1️⃣4️⃣ Spring Boot Deployment

  🔹 Creating JAR/WAR

  By default, Spring Boot builds fat JAR with embedded server.

  In pom.xml:

   

  <build>
   <plugins>
     <plugin>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-maven-plugin</artifactId>
     </plugin>
   </plugins>
  </build>
   

  To build:

  mvn clean package
   

  To run:

  java -jar target/banking-app-1.0.jar
   

  🔹 WAR Deployment

  If deploying to external Tomcat server (rare today):

  • Set packaging to war

  • Extend SpringBootServletInitializer

  • Provide configure() method

   

   

  🔹 External Config on Deployment

  Spring Boot supports overriding config without rebuilding the app:

  java -jar banking-app.jar --spring.config.location=/opt/config/
   

   

  or via env variables:

   

  SPRING_DATASOURCE_URL=jdbc:mysql://... java -jar ...
   

   

  🔹 Embedded Servers

  Spring Boot supports:

  Server	Dependency
  Tomcat (default)	spring-boot-starter-web
  Jetty	spring-boot-starter-jetty
  Undertow	spring-boot-starter-undertow

   

  To switch:

  <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-jetty</artifactId>
  </dependency>
  <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-tomcat</artifactId>
     <scope>provided</scope> <!-- disables embedded tomcat -->
  </dependency>
   

   

  1️⃣5️⃣ Spring Boot Application Lifecycle

  🔹 CommandLineRunner & ApplicationRunner

  Used to execute logic at startup.

  Use-case: Initializing DB or caching configs

   

  @Component
  public class StartupRunner implements CommandLineRunner {
     @Override
     public void run(String... args) {
         System.out.println("Initializing core banking APIs...");
     }
  }
   

  @Component
  public class StartupRunner implements CommandLineRunner {
     @Override
     public void run(String... args) {
         System.out.println("Initializing core banking APIs...");
     }
  }
   

  ApplicationRunner is similar, but provides ApplicationArguments.

  🔹 Graceful Shutdown

  Spring Boot (2.3+) handles graceful shutdown using:

  server.shutdown=graceful
  spring.lifecycle.timeout-per-shutdown-phase=30s

  
  You can hook into shutdown:

  @PreDestroy
  public void onDestroy() {
     // cleanup banking transactions or close DBs
  }
  
  SPring Banners last topic you can do it own.
  
  end → Please support our work on https://razorpay.me/@niteshsynergy