Comprehensive Spring Boot Interview Guide and Technical Overview

Spring Boot, a sub‑project of the Spring ecosystem, offers a one‑stop solution that simplifies Spring development by reducing boilerplate configuration, providing starter dependencies, and enabling rapid application startup.

Core Annotation

The central annotation @SpringBootApplication combines @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan, establishing the entry point for a Spring Boot application.

Configuration

JavaConfig replaces XML with pure Java classes, offering object‑oriented, type‑safe, and refactor‑friendly configuration.

Auto‑configuration relies on @EnableAutoConfiguration, @Configuration and @ConditionalOnClass to import classes listed in META-INF/spring.factories and apply conditional logic based on the presence of specific beans.

Configuration loading order includes properties files, YAML files, environment variables, and command‑line arguments, among others.

YAML provides hierarchical, ordered, and array‑friendly configuration, though it cannot be imported via @PropertySource.

XML support is still possible using @ImportResource, but Java‑based configuration is recommended.

Bootstrap vs. Application properties : bootstrap.* loads earlier (useful with Spring Cloud), while application.* is used for standard Boot auto‑configuration.

Spring Profiles enable environment‑specific bean registration, allowing different configurations for dev, test, and prod.

Custom port can be set with server.port=8090 in application.properties.

Security

Adding spring-boot-starter-security and extending WebSecurityConfigurerAdapter secures a Boot application with minimal code.

Comparison of Spring Security (heavy, feature‑rich) and Shiro (lightweight, simple) highlights trade‑offs.

Cross‑origin resource sharing (CORS) can be handled via a WebMvcConfigurer implementation:

@Configuration
public class CorsConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOrigins("*")
                .allowCredentials(true)
                .allowedMethods("GET","POST","PUT","DELETE","OPTIONS")
                .maxAge(3600);
    }
}

Alternatively, a CorsFilter bean can be defined:

@Configuration
public class CorsConfig {
    @Bean
    public CorsFilter corsFilter() {
        CorsConfiguration cfg = new CorsConfiguration();
        cfg.addAllowedOrigin("*");
        cfg.addAllowedHeader("*");
        cfg.addAllowedMethod("*");
        cfg.setAllowCredentials(true);
        UrlBasedCorsConfigurationSource src = new UrlBasedCorsConfigurationSource();
        src.registerCorsConfiguration("/**", cfg);
        return new CorsFilter(src);
    }
}

Monitoring (Actuator)

Spring Boot Actuator exposes HTTP endpoints for health, metrics, and other runtime information. Security for these endpoints can be disabled when accessed behind a firewall.

To monitor many microservices, tools built on top of Actuator provide a unified UI for visualizing metrics across services.

Third‑Party Integrations

WebSocket offers full‑duplex communication over a single TCP connection.

Spring Data simplifies database access for both NoSQL (MongoDB, Neo4j, Redis, HBase) and relational stores (JDBC, JPA).

Spring Batch supports large‑scale, fault‑tolerant batch processing.

FreeMarker is a Java‑based template engine that separates view logic from business code.

ActiveMQ integration requires only the appropriate starter dependency.

Apache Kafka provides a distributed, fault‑tolerant publish‑subscribe messaging system.

Swagger (via Springfox) automatically generates interactive API documentation that stays in sync with code changes.

Other Topics

DevTools enables hot‑reloading of changes without restarting the server.

Starters (e.g., spring-boot-starter-security, spring-boot-starter-activemq) reduce dependency conflicts and simplify configuration.

The spring-boot-starter-parent defines Java version, encoding, dependency versions, and packaging defaults.

Executable JARs contain a BOOT-INF/classes directory and can be run with java -jar, but cannot be used as regular library JARs.

Spring Boot applications can be launched via packaged JAR, Maven/Gradle plugins, or directly invoking the main method.

Embedded containers (Tomcat, Jetty, Undertow) mean no external server is required.

Features can be enabled by inheriting the parent POM, importing spring-boot-dependencies, or adding specific starter modules.

Exception handling is typically done with @ControllerAdvice, while pagination and sorting are provided by Spring Data JPA.

Session sharing across microservices can be achieved with Spring Session backed by Redis.

Scheduled tasks can be implemented using @Scheduled or Quartz.

Source: https://javajgs.com/archives/1461