Spring Boot Interview Theory

Trace Java source code through compilation, class loading, interpretation, and JIT compilation.

Distinguish stack, heap, and metaspace by the data each stores.

Explain how garbage-collection reachability can coexist with application-level memory leaks.

Apply the Java happens-before rules to identify a visibility bug.

Make a shared counter thread-safe using synchronization or atomic operations.

Use an ExecutorService with explicit task and shutdown handling.

Compose asynchronous operations with CompletableFuture and handle exceptional completion.

Compare platform threads and virtual threads for blocking server workloads.

Trace an ApplicationContext from bean-definition discovery to initialized singleton beans.

Predict dependency resolution when multiple candidates interact with @Primary and @Qualifier.

Explain why constructor injection exposes dependencies and improves testability.

Trace a bean through instantiation, post-processing, initialization callbacks, and destruction.

Predict how singleton, prototype, request, and session scopes affect object identity.

Diagnose a circular dependency and redesign the collaborating components to remove it.

Explain how proxy-based Spring AOP intercepts a method invocation.

Identify when self-invocation or non-overridable methods prevent proxy advice from running.

Distinguish dependency starters, dependency management, and auto-configuration.

Trace how conditional auto-configuration activates and backs off in response to application beans.

Resolve a configuration value using Spring Boot's property-source precedence.

Bind grouped external configuration into a validated @ConfigurationProperties type.

Use profiles without embedding environment-specific behavior in application code.

Interpret a condition evaluation report to diagnose missing or unexpected auto-configuration.

Explain how an executable Spring Boot JAR starts an embedded web server.

Describe when custom auto-configuration is preferable to ordinary application configuration.

Classify HTTP methods by safety and idempotency and apply appropriate status codes.

Trace an HTTP request through servlet filters, DispatcherServlet, interceptors, a controller, and message conversion.

Bind and validate path, query, header, and body inputs in a Spring MVC controller.

Use API DTOs to prevent persistence entities from defining an external JSON contract.

Map application failures to consistent HTTP responses with centralized exception handling.

Choose among a servlet filter, HandlerInterceptor, and controller advice for a cross-cutting concern.

Implement pagination semantics for a collection REST endpoint.

Explain how blocking work affects throughput in Spring MVC's thread-per-request model.

Explain how atomicity, consistency, isolation, and durability protect a database transaction.

Identify dirty reads, non-repeatable reads, and phantom reads in concurrent transaction scenarios.

Choose a transaction isolation level for a stated consistency requirement.

Explain how an index changes read performance and write cost.

Interpret a simple SQL query plan to identify a full scan or inefficient join.

Explain why connection pools require bounded size, timeouts, and prompt connection release.

Use database constraints to enforce invariants independently of application validation.

Compare offset and keyset pagination for a changing dataset.

Predict entity behavior across transient, managed, detached, and removed lifecycle states.

Explain dirty checking and write-behind within a JPA persistence context.

Map a bidirectional relationship while identifying its owning side.

Predict when lazy loading will trigger SQL or fail outside a persistence context.

Detect an N+1 query pattern and select an appropriate fetching strategy.

Distinguish cascade operations from orphan removal in an entity relationship.

Predict whether a @Transactional method commits or rolls back for a given exception and call path.

Choose optimistic or pessimistic locking for a concurrent update scenario.

Write a focused JUnit test for a service using a test double for its dependency.

Distinguish mocks, stubs, and fakes by the role each plays in a test.

Choose between a plain unit test, a Spring test slice, and @SpringBootTest.

Test Spring MVC request validation and response mapping with MockMvc.

Write a repository integration test against a real database-compatible environment.

Explain how cached Spring test contexts affect test-suite speed and isolation.

Identify false confidence caused by transactional test rollback behavior.

Design a compact test portfolio for a controller-service-repository feature.

Distinguish authentication from authorization in a concrete request scenario.

Trace a request through Spring Security's filter chain and SecurityContext.

Explain why passwords require adaptive salted hashing rather than encryption.

Predict when browser cookie authentication creates a CSRF risk.

Distinguish CORS enforcement from CSRF protection.

Compare server-side sessions and bearer tokens for application authentication.

Configure endpoint and method-level authorization for stated access rules.

Diagnose whether a failed request should produce HTTP 401 or 403.

Identify timeout and resource-exhaustion risks in a synchronous service call.

Choose safe retry conditions and an exponential-backoff strategy for a failed operation.

Explain how circuit breakers and bulkheads limit cascading failure.

Design an idempotency mechanism for a retried write request.

Reason about duplicates and ordering under at-least-once message delivery.

Explain how the transactional outbox pattern avoids a database-message dual write.

Choose a cache-aside invalidation approach for stated freshness requirements.

Compare a modular monolith and microservices for a proposed service boundary.

Use Actuator health groups to distinguish liveness from readiness.

Design structured logs that preserve request correlation across service calls.

Choose a metric and alert for a stated latency or error-rate objective.

Explain how distributed traces reveal latency across service boundaries.

Diagnose thread-pool or connection-pool saturation from observable symptoms.

Explain how graceful shutdown protects in-flight requests during deployment.

Differentiate likely CPU, memory, and blocked-thread causes of a slow application.

Identify which configuration values belong in external configuration or secret storage.

Deliver a structured explanation using a claim, mechanism, trade-off, and concrete example.

Explain the end-to-end path of a request from the client through Spring to the database and back.

Review a short Spring code sample for dependency-injection, proxy, transaction, and lazy-loading traps.

Diagnose a Spring Boot startup failure from a concise error report and configuration context.

Compare two plausible Spring designs while making the deciding constraints explicit.

Sketch a REST API, persistence model, and transaction boundary for a small backend feature.

Reason through a production incident by forming and testing hypotheses from symptoms.

Answer a timed follow-up sequence while distinguishing known facts from reasonable assumptions.