Top 20 Java Spring Boot Interview Questions and Answers for 2026

All four annotations represent Spring Stereotype Annotations. They register Java classes as Spring-managed beans within the Application Context via component scanning, but serve different architectural purposes:

• @Component: The generic, root stereotype annotation for any Spring-managed component. Use this when the class doesn’t fit into a specific layer.
• @Service: Specializes a class for the Service Layer. It holds business logic and orchestration code, making it a clear marker for domain services.
• @Repository: Specializes a class for the Data Access Object (DAO) Layer. Crucially, it enables automatic Platform Transaction exception translation, turning low-level database exceptions into Spring Data Access exceptions.
• @Controller / @RestController: Specializes a class for the Presentation Layer. @RestController combines @Controller and @ResponseBody, ensuring that handler methods automatically serialize response bodies directly into JSON or XML.

Dependency Injection (DI) is a design pattern realizing Inversion of Control (IoC), where the framework injects dependent objects into a class rather than the class creating them directly.

Injection Strategies:

• Constructor Injection (Recommended): Mechanism where dependencies are provided via the class constructor. It guarantees immutability (fields can be declared final), ensures required dependencies are not null, and prevents circular dependencies at compile/startup time.
• Setter Injection: Mechanism where dependencies are provided via public setter methods. Useful for optional configurations or mutable dependencies, though it exposes the object to post-initialization mutations.
• Field Injection: Accomplished by placing @Autowired directly on private class fields. While brief, it is highly discouraged because it tightly couples the code to the Spring IoC container, complicates unit testing without mock frameworks, and allows objects to bypass immutability guards.

While both register beans in the Spring container, their application scopes are fundamentally distinct:

• @Component: A class-level annotation used for automatic component scanning. You place it on your own source code classes, and Spring automatically detects and instantiates them.
• @Bean: A method-level annotation typically used inside @Configuration classes. It explicitly instructs Spring that the returned object from the method should be registered as a bean. Use @Bean when wrapping third-party libraries or writing highly customized instantiation logic.

Spring provides multiple lifecycle scopes for beans inside the IoC container:

• singleton (Default): Scopes a single bean definition to a single object instance per Spring IoC container. The instance is cached and reused across all requests.
• prototype: Scopes a single bean definition to any number of object instances. A completely new instance is created every time the bean is requested.
• request: Scopes a single bean instance to the lifecycle of a single HTTP request. Only valid in web-aware ApplicationContexts.
• session: Scopes a single bean instance to the lifecycle of an HTTP Session. Only valid in web-aware ApplicationContexts.
• application: Scopes a bean instance to the lifecycle of a ServletContext.
• websocket: Scopes a bean instance to the lifecycle of a WebSocket session.

Spring Boot Actuator is a sub-project that adds production-ready operational management features to an application without requiring extensive manual development.

It provides built-in HTTP endpoints or JMX entry points to monitor application health, gathering metrics, assessing traffic patterns, and verifying database connections. Common endpoints include:

• /actuator/health: Displays basic application health status.
• /actuator/metrics: Exposes internal metrics data (JVM memory usage, CPU load, HTTP request counts).
• /actuator/env: Exposes properties configured within the environment.
• /actuator/threaddump: Performs a low-level thread dump diagnostics check.

Global exception handling in Spring Boot is achieved elegantly using a centralized, decoupled approach utilizing Controller Advice patterns.

Implementation Strategy:

• Create a dedicated class annotated with @RestControllerAdvice.
• Write targeted methods within that class annotated with @ExceptionHandler, specifying the target exception type (e.g., ResourceNotFoundException.class, MethodArgumentNotValidException.class).
• Return a standardized error response object alongside an appropriate HTTP status code via ResponseEntity.

Example:

Spring Data JPA is a framework abstraction that sits on top of standard JPA implementations (like Hibernate), eliminating the boilerplate code required to implement data access layers.

Key Advantages:

• Repository Interface Abstraction: By extending interfaces like JpaRepository or CrudRepository, Spring generates standard CRUD implementation logic automatically at runtime.
• Dynamic Query Methods: It interprets repository method names directly into SQL queries (e.g., findByEmailAddressAndLastName(String email, String lastName)).
• Pagination and Sorting: Built-in support for processing dynamic pagination frameworks through parameters like Pageable and Sort without writing manual offset calculations.

These loading strategies dictate when associated entity collections are retrieved from the database to save performance memory:

• Eager Loading (FetchType.EAGER): Associated entities are fetched immediately along with the parent entity using database joins. While data is immediately available, it can degrade system performance if massive related structures are fetched unintentionally.
• Lazy Loading (FetchType.LAZY): Associated entities are deferred, fetching only when they are explicitly accessed via getter methods within an active transaction session. This minimizes initial query overhead but can trigger LazyInitializationException if accessed outside an open transaction.

The @Transactional annotation provides declarative transaction management configuration across methods or entire classes, removing low-level code management constraints.

Core Attributes:

• Propagation: Defines boundary behaviors (e.g., REQUIRED joins an existing transaction or starts a new one; REQUIRES_NEW suspends current transactions to run its own isolated sandbox block).
• Isolation Level: Controls how data changes made by one transaction are visible to others (e.g., READ_COMMITTED, SERIALIZABLE), preventing dirty or phantom reads.
• Rollback Rules: Automatically triggers transaction rollbacks when unchecked exceptions (RuntimeException) cross boundaries, while allowing fine-tuning for checked exceptions.

Spring Profiles allow separating application configuration files, making specific properties available only within targeted environments (e.g., development, testing, staging, production).

Management Workflows:

• Create environment files named like application-dev.yml or application-prod.yml alongside the baseline application.yml.
• Activate profiles programmatically or declaratively using configurations like spring.profiles.active=prod inside environment variables or command-line arguments.
• Conditionally load specific beans or configurations across execution contexts via the @Profile("prod") annotation wrapper.

Spring Security uses distinct filters to manage identity proofing versus access rights controls:

• Authentication: The initial validation process to verify *who* the accessing principal user claims to be. This involves matching provided credentials (like passwords or tokens) against user stores, typically resolved via an AuthenticationManager.
• Authorization: The secondary check determining *what* actions an authenticated principal has permission to execute. This verifies if the user possesses required privileges or roles before permitting resource access, often evaluated via annotations like @PreAuthorize.

Implementing modern token validation patterns requires swapping stateful session settings for explicit filter chains.

Architecture Pattern:

• Disable default CSRF validations and force session policy execution flags to SessionCreationPolicy.STATELESS inside your SecurityFilterChain bean definition configuration.
• Create a custom interceptor extending OncePerRequestFilter to extract bearer tokens from request authorization headers, validating signature keys, and parsing claims schemas.
• Inject user details parameters back directly into Spring Security's localized thread sandbox, SecurityContextHolder, to authenticate requests downstream.

A Microservices architecture splits large, monolithic enterprise applications into collections of modular, autonomous services communicating over lightweight REST APIs or message brokers.

Spring Cloud Components:

• Service Discovery (Eureka): Acts as a centralized service registry, enabling microservice instances to dynamically locate each other without hardcoding network endpoints.
• API Gateway (Spring Cloud Gateway): Provides unified entry-routing layers, cross-cutting security checks, traffic filtering, and rate-limiting orchestrations.
• Circuit Breaker (Resilience4j): Prevents cascading service failures by wrapping network calls, gracefully fallback processing failures when targets crash or lag.

Choosing HTTP client abstraction layers depends completely on runtime reactive requirements:

• RestTemplate: A classic synchronous, blocking HTTP client execution framework. Each request blocks the execution thread until the server responds, which can become an application scaling bottleneck in heavy microservice mesh networks.
• WebClient: A modern, fluent functional reactive HTTP client supporting synchronous, asynchronous, and non-blocking streaming network calls. Part of spring-boot-starter-webflux, it is the primary choice for highly performant reactive environments.

Spring Boot defaults to **HikariCP** as its connection pooling infrastructure. Optimization involves balancing connection overheads against thread availability bounds.

Key Configurations (application.properties):

Tuning Rule: Avoid allocating massive pool sizing values blindly, as this causes excessive database context switching overhead. A common rule is setting maximum size capacities slightly above typical maximum concurrent application thread availability.

Spring Boot DevTools is a developer module designed to accelerate local testing workflows by minimizing application restart delays.

Key Capabilities:

• Automatic Restart: Monitors local class file compiles, instantly restarting application contexts when files alter. It uses a dual classloader layout to drastically reduce typical startup lag times.
• LiveReload Integration: Includes an embedded server that triggers automatic browser refreshes when static visual assets modify locally.
• Configuration Overrides: Automatically disables standard caching mechanisms for template components (like Thymeleaf) during development loops, ensuring changes surface immediately.

The @Async annotation delegates method executions onto entirely separate background threads, allowing callers to continue processing foreground tasks without blocking.

Requirements & Setup:

• Enable asynchronous architectures by placing @EnableAsync over a centralized configuration or initialization class.
• Annotate target methods with @Async. The return type must be either void or wrapped inside a CompletableFuture container to allow asynchronous results tracking.
• Self-Invocation Caveat: Methods must be called from external beans. Calling an @Async method internally from the same class bypasses the required Spring proxy interceptor, running synchronously instead.

Production memory diagnostics require configuring appropriate runtime indicators paired with structural codebase tuning flags.

Optimization Protocols:

• Explicitly configure target JVM heap size maximum bounds using standard flags (e.g., -Xmx512m or -Xmx1g) to keep application containers predictable.
• Incorporate **Spring Boot Actuator** alongside Prometheus metrics to closely monitor heap allocations, garbage collection frequencies, and thread allocations.
• Minimize structural memory leaks by auditing custom object caching mechanisms, preventing premature instantiation loops, and using proper pagination limits on massive database queries.