Core Spring Boot for Interviews

Master how Spring Boot loads, binds, and prioritizes configuration — a foundational skill for building environment-aware applications.

• @ConfigurationProperties — binding hierarchical property files to POJOs for type-safe configuration

• @Value — injecting individual property values directly into fields or constructor parameters

• application.properties vs YAML — structural differences and when to use each format

• Externalized configuration — managing settings outside the packaged JAR for flexibility

• Configuration precedence — environment variables and command-line args override file-based properties

• Profile-specific files — application-dev.yml, application-prod.yml for environment separation

Understand the internal mechanisms that make Spring Boot work — from auto-configuration to starter dependencies — and explain them confidently in interviews.

• @SpringBootApplication — combines @Configuration, @EnableAutoConfiguration, and @ComponentScan

• @EnableAutoConfiguration — triggers Spring Boot's auto-configuration mechanism on startup

• Conditional annotations — @ConditionalOnClass, @ConditionalOnMissingBean control what gets configured

• Starter dependencies — curated transitive dependency sets that eliminate manual build configuration

• Auto-configuration classes — how Spring Boot decides what to configure based on classpath contents

• Component scanning defaults — why @SpringBootApplication must be at the root package

• Overriding auto-configuration — excluding specific auto-config classes when defaults don't fit

Write testable, maintainable Spring applications by mastering DI types, stereotype annotations, bean scopes, and lifecycle hooks.

• Stereotype annotations — @Component, @Service, @Repository, @Controller and their semantic differences

• Constructor injection — the recommended approach for mandatory dependencies and easier unit testing

• Setter injection — used for optional dependencies that can be changed after bean creation

• Field injection (@Autowired on fields) — easy to write but hinders testability, avoid in production code

• Bean scopes — Singleton (one instance per context) vs Prototype (new instance per request)

• @PostConstruct — lifecycle hook executed after dependency injection is complete

• @Qualifier — resolving ambiguity when multiple beans of the same type exist in the context

Build robust, well-structured REST APIs using Spring Boot's web layer and handle HTTP interactions correctly.

• @RestController vs @Controller — @RestController combines @Controller and @ResponseBody for APIs

• HTTP method mappings — @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, @PatchMapping

• @PathVariable — extracting dynamic values from URI path segments

• @RequestParam — binding query string parameters to method arguments

• @RequestBody — deserializing incoming JSON/XML request body into a Java object

• Content negotiation — how Spring Boot automatically handles JSON and XML serialization

• ResponseEntity — returning full HTTP responses including status codes and headers

Implement clean, consistent error handling across your entire API without cluttering individual controllers with try-catch blocks.

• @ControllerAdvice — defining a global exception handler that applies across all controllers

• @ExceptionHandler — mapping specific exception types to handler methods within an advice class

• Global vs local handling — why @ControllerAdvice is preferred over per-controller try-catch blocks

• Consistent error responses — returning structured error bodies with status, message, and timestamp

• @ResponseStatus — setting HTTP status codes directly on exception classes or handler methods

• Validation errors — handling MethodArgumentNotValidException from @Valid bean validation

Demonstrate operational maturity by mastering Spring Boot's built-in tools for monitoring, logging, and server configuration.

• Spring Boot Actuator — exposing health, metrics, and environment info via built-in HTTP endpoints

• Custom Actuator endpoints — extending Actuator with application-specific operational data

• Securing Actuator endpoints — restricting access to sensitive endpoints in production environments

• SLF4J and Logback — configuring the default logging stack and managing log levels per package

• Parameterized logging — using {} placeholders instead of string concatenation for performance

• Embedded servers — Tomcat (default), Jetty, and Undertow — switching and customizing each

• Server port and context path — common application.properties configurations for deployment