Spring Boot Interview Questions by Dheeraj Batane

1. What is Spring Boot, and how does it differ from the traditional Spring
Framework?

Spring Boot is an extension of the Spring Framework that simplifies the development of
stand-alone, production-ready applications with minimal configuration.

Differences:

Feature Spring Framework Spring Boot

Configuration Requires manual XML or Uses auto-configuration and

Java-based configuration convention over configuration

Dependency Management Requires adding Comes with pre-configured

dependencies manually dependencies via
spring-boot-starter
modules

Embedded Server Requires external web server Comes with an embedded

setup (Tomcat, Jetty) server (Tomcat, Jetty,
Undertow)

Microservices Support Not specifically designed for Designed for microservices

microservices architecture

Deployment Requires deploying WAR files Can create standalone JARs

in an external server with embedded servers
2. What is the purpose of @SpringBootApplication annotation?

@SpringBootApplication is a convenience annotation that combines three key annotations:

●​ @Configuration - Marks the class as a source of bean definitions.

●​ @EnableAutoConfiguration - Enables Spring Boot’s auto-configuration mechanism.
●​ @ComponentScan - Scans for components (beans, controllers, services) in the
package.

Example:

@SpringBootApplication​
public class MyApplication {​
public static void main(String[] args) {​
SpringApplication.run(MyApplication.class, args);​
}}

Purpose: It simplifies Spring Boot application setup by enabling auto-configuration and

component scanning.

3. Explain the concept of auto-configuration in Spring Boot.

Auto-configuration in Spring Boot automatically configures application settings based on the

dependencies present in the classpath.

●​ It eliminates the need for manual configuration.

●​ Uses @EnableAutoConfiguration (included in @SpringBootApplication).
●​ Reads META-INF/spring.factories for predefined configurations.

Example:​
If spring-boot-starter-web is present, Spring Boot:

●​ Automatically configures an embedded Tomcat server.

●​ Registers DispatcherServlet, Jackson, etc.
●​ Configures default error handling.
4. What is the role of application.properties or application.yml in
Spring Boot?

These files are used for configuring application settings such as database connection, logging,
and server properties.

Example (application.properties)

server.port=8081​
spring.datasource.url=jdbc:mysql://localhost:3306/mydb​
spring.datasource.username=root​
spring.datasource.password=root

Example (application.yml)

server:​
port: 8081​
spring:​
datasource:​
url: jdbc:mysql://localhost:3306/mydb​
username: root​
password: root

●​ application.properties is key-value based, whereas application.yml is

hierarchical and more readable.

5. What are the advantages of Spring Boot over traditional Spring

applications?

1.​ Auto-configuration – Reduces boilerplate code.

2.​ Embedded server – No need to deploy on external servers.
3.​ Microservices-friendly – Simplifies REST API development.
4.​ Production-ready – Includes monitoring (Spring Boot Actuator).
5.​ Starter dependencies – Reduces dependency conflicts.
6.​ Spring Initializr – Simplifies project setup.
6. What is the difference between @Component, @Service, @Repository,
and @Controller in Spring Boot?

Example:

Annotation Purpose Used For

Generic Spring-managed
@Component bean Any Spring bean
@Service Business logic layer Service classes
@Repository Data access layer DAO/Repository classes
@Controller Handles HTTP requests MVC controllers
Combines @Controller and
@RestController @ResponseBody REST APIs

@Service​
public class MyService { /* Business logic */ }​
​
@Repository​
public interface MyRepository extends JpaRepository<User, Long> { }​
​
@Controller​
public class MyController { /* Returns HTML views */ }​
​
@RestController​
public class MyRestController { /* Returns JSON responses */ }

7. How do you create a Spring Boot RESTful web service?

1.​ Add spring-boot-starter-web dependency.

2.​ Use @RestController and @RequestMapping.
3.​ Return JSON responses using @GetMapping, @PostMapping, etc.

Example:

@RestController​
@RequestMapping("/users")​
 public class UserController {​
@GetMapping("/{id}")​
public User getUser(@PathVariable Long id) {​
return new User(id, "John Doe", "john@example.com");​
}​
}

8. What is Spring Boot Actuator, and what are its uses?

Spring Boot Actuator provides production-ready features like monitoring and health checks.

Features:

●​ /actuator/health - Check application health.

●​ /actuator/info - Display application metadata.
●​ /actuator/metrics - Show runtime metrics.

To enable Actuator:

management.endpoints.web.exposure.include=*

9. What is the significance of @RestController and how is it different

from @Controller?

Example:

Feature @Controller @RestController

Handles REST API
Purpose Handles web requests requests
Return Type View (JSP, Thymeleaf) JSON or XML

Requires
@ResponseBody Yes No
@Controller​
public class WebController {​
@GetMapping("/hello")​
public String hello(Model model) {​
model.addAttribute("message", "Hello World");​
return "hello"; // Returns a view name​
}​
}​
​
@RestController​
public class ApiController {​
@GetMapping("/api/hello")​
public String hello() {​
return "Hello, JSON"; // Returns JSON response​
}​
}

10. How do you handle exceptions in Spring Boot applications?

Method 1: Using @ExceptionHandler

@RestControllerAdvice​
public class GlobalExceptionHandler {​
@ExceptionHandler(UserNotFoundException.class)​
public ResponseEntity<String> handleUserNotFound(UserNotFoundException
ex) {​
return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);​
}​
}

Method 2: Using @ControllerAdvice

@ControllerAdvice​
public class ExceptionHandlerAdvice {​
@ExceptionHandler(Exception.class)​
public String handleException(Model model, Exception ex) {​
model.addAttribute("error", ex.getMessage());​
 return "error-page";​
}​
}

11. What is Spring Boot DevTools, and what benefits does it provide during
development?

Spring Boot DevTools is a module that enhances the development experience by enabling
automatic application restarts, live reloads, and other useful features.

Benefits:

1.​ Automatic Restart – Detects code changes and restarts the application.
2.​ Live Reload – Refreshes web pages automatically (requires a browser plugin).
3.​ Property Defaults – Disables template caching for Thymeleaf, Freemarker, etc.
4.​ Remote Debugging – Supports remote development using
spring.devtools.remote.secret.

To enable DevTools:​
Add the dependency in pom.xml:

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

12. How do you use Spring Boot to connect to a database (e.g., MySQL or
PostgreSQL)?

1.​ Add the JDBC dependency:

<dependency>​
<groupId>org.springframework.boot</groupId>​
<artifactId>spring-boot-starter-data-jpa</artifactId>​
</dependency>​
<dependency>​
<groupId>mysql</groupId>​
<artifactId>mysql-connector-java</artifactId>​
<scope>runtime</scope>​
</dependency>

2.​ Configure the database in application.properties:

spring.datasource.url=jdbc:mysql://localhost:3306/mydb​
spring.datasource.username=root​
spring.datasource.password=root​
spring.jpa.hibernate.ddl-auto=update​
spring.jpa.show-sql=true

3.​ Create an Entity and Repository:

@Entity​
public class User {​
@Id @GeneratedValue​
private Long id;​
private String name;​
private String email;​
}​
​
@Repository​
public interface UserRepository extends JpaRepository<User, Long> { }

13. Explain the difference between @Bean and @Component in Spring Boot.

Feature @Bean @Component

Used in Java configuration Used in component-scanned
Use Case classes classes
Defined In @Configuration classes Regular Java classes
 Automatically managed by
Lifecycle Control Full lifecycle control Spring

Example Manually defined in a method Annotated on a class

Example: Using @Bean

@Configuration​
public class AppConfig {​
@Bean​
public MyService myService() {​
return new MyService();​
}​
}

Example: Using @Component

@Component​
public class MyService { }

14. How do you configure logging in Spring Boot?

Spring Boot uses SLF4J with Logback as the default logging framework.

1.​ Set log levels in application.properties:

logging.level.root=INFO​
logging.level.com.myapp=DEBUG

2.​ Custom logback.xml:

<configuration>​
<appender name="FILE" class="ch.qos.logback.core.FileAppender">​
<file>app.log</file>​
<encoder><pattern>%d [%thread] %-5level %logger{36} -
 %msg%n</pattern></encoder>​
</appender>​
<root level="info"><appender-ref ref="FILE"/></root>​
</configuration>

3.​ Use logging in Java code:

private static final Logger logger =

LoggerFactory.getLogger(MyService.class);​
logger.info("Application started successfully");

15. What are Spring Boot profiles, and how do you manage them for
different environments (dev, prod)?

Spring Boot profiles allow different configurations for different environments like development,
testing, and production.

1.​ Define environment-specific application-{profile}.properties:

○​ application-dev.properties
○​ application-prod.properties
2.​ Example configuration:

# application-dev.properties​
spring.datasource.url=jdbc:mysql://localhost:3306/devdb​
logging.level.root=DEBUG​
​
# application-prod.properties​
spring.datasource.url=jdbc:mysql://prod-db-host:3306/proddb​
logging.level.root=ERROR

3.​ Activate profile in application.properties:

spring.profiles.active=dev
Or set via command-line:

java -jar myapp.jar --spring.profiles.active=prod

16. How do you implement security in a Spring Boot application?

1.​ Add the dependency:

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

2.​ Create a Security Configuration:

@Configuration​
@EnableWebSecurity​
public class SecurityConfig {​
@Bean​
public SecurityFilterChain securityFilterChain(HttpSecurity http)
throws Exception {​
http​
.authorizeHttpRequests(auth ->
auth.anyRequest().authenticated())​
.formLogin(Customizer.withDefaults());​
return http.build();​
}​
}

3.​ Default username: user, password printed in console.

17. What is Spring Boot’s embedded server, and how does it work?
Spring Boot comes with embedded servers like Tomcat, Jetty, Undertow.

●​ The default is Tomcat (spring-boot-starter-web).

●​ Runs inside the application, no need to deploy WAR files.
●​ Change the server in pom.xml:

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

18. What is the use of @EnableAutoConfiguration in Spring Boot?

●​ Enables automatic configuration based on classpath dependencies.

●​ Internally part of @SpringBootApplication.
●​ Uses spring.factories to load configurations.

@Configuration​
@EnableAutoConfiguration​
@ComponentScan​
public class MyApplication { }

19. What is the difference between application.properties and

application.yml files?

Feature application.properties application.yml

Format Key-value pairs Hierarchical YAML

Readability Less readable More readable

server:\n port:
Example server.port=8081 8081

YAML is preferred for complex configurations.

20. What is Spring Boot's support for creating microservices?

Spring Boot simplifies microservices development with:

1.​ Spring Cloud – Provides tools for cloud-native apps.

2.​ Spring Boot Actuator – Adds monitoring endpoints.
3.​ Spring Config Server – Centralized configuration management.
4.​ Spring Cloud Eureka – Service discovery.
5.​ Spring Cloud Gateway – API gateway for microservices.

Example microservice:

@RestController​
@RequestMapping("/users")​
public class UserController {​
@GetMapping("/{id}")​
public User getUser(@PathVariable Long id) {​
return new User(id, "John Doe");​
}​
}

21. How does Spring Boot handle dependency injection?

Spring Boot uses Spring’s Dependency Injection (DI) to manage object dependencies.

●​ Types of Dependency Injection:

1.​ Constructor Injection (Recommended)
2.​ Setter Injection
3.​ Field Injection (Not Recommended)

Example of Constructor Injection:

@Service​
public class UserService {​
private final UserRepository userRepository;​
​
@Autowired​
public UserService(UserRepository userRepository) {​
this.userRepository = userRepository;​
}​
}

●​ Spring Boot automatically injects dependencies using @Autowired (though it’s optional
for constructors in Spring Boot 2+).

22. How do you test a Spring Boot application using @SpringBootTest?

●​ @SpringBootTest loads the entire application context for integration testing.

Example of Testing a REST API:

@SpringBootTest​
@AutoConfigureMockMvc​
class UserControllerTest {​
​
@Autowired​
private MockMvc mockMvc;​
​
@Test​
void testGetUser() throws Exception {​
mockMvc.perform(get("/users/1"))​
.andExpect(status().isOk())​
.andExpect(jsonPath("$.name").value("John Doe"));​
}​
}

●​ For Unit Testing, use @MockBean to mock dependencies.

23. Explain the difference between @RequestMapping, @GetMapping,

@PostMapping, and other HTTP method annotations.

Annotation HTTP Method Usage

 @RequestMapping Any (GET, POST, etc.) Generic mapping

@GetMapping GET Fetch data

@PostMapping POST Create a resource

@PutMapping PUT Update a resource

@DeleteMapping DELETE Delete a resource

Example:

@RestController​
@RequestMapping("/users")​
public class UserController {​
​
@GetMapping("/{id}")​
public User getUser(@PathVariable Long id) { return new User(id, "John
Doe"); }​
​
@PostMapping("/")​
public User createUser(@RequestBody User user) { return user; }​
}

24. What are Spring Boot’s default error handling mechanisms, and how
can they be customized?

●​ Spring Boot provides default error handling using BasicErrorController.

●​ Returns JSON responses like:

{​
"timestamp": "2024-02-11T12:00:00.123+00:00",​
"status": 404,​
"error": "Not Found",​
"message": "User not found",​
"path": "/users/99"​
}
Custom Error Handling using @ControllerAdvice:

@RestControllerAdvice​
public class GlobalExceptionHandler {​
​
@ExceptionHandler(UserNotFoundException.class)​
public ResponseEntity<String> handleUserNotFound(UserNotFoundException
ex) {​
return
ResponseEntity.status(HttpStatus.NOT_FOUND).body(ex.getMessage());​
}​
}

25. How do you perform batch processing in Spring Boot?

●​ Use Spring Batch for processing large volumes of data.

Steps:

1.​ Add Spring Batch dependency.

2.​ Create a Job configuration.
3.​ Define ItemReader, ItemProcessor, and ItemWriter.

Example:

@Configuration​
@EnableBatchProcessing​
public class BatchConfig {​
​
@Bean​
public Job processJob(JobBuilderFactory jobBuilderFactory, Step step) {​
return jobBuilderFactory.get("processJob")​
.incrementer(new RunIdIncrementer())​
.start(step)​
.build();​
}​
​
@Bean​
public Step step(StepBuilderFactory stepBuilderFactory,
ItemReader<String> reader,​
ItemProcessor<String, String> processor,
ItemWriter<String> writer) {​
return stepBuilderFactory.get("step")​
.<String, String>chunk(10)​
.reader(reader)​
.processor(processor)​
.writer(writer)​
.build();​
}​
}

26. What is Spring Data JPA, and how is it used in Spring Boot?

●​ Spring Data JPA simplifies database interactions by reducing boilerplate code.

Example:

Define an Entity:​
@Entity​
public class User {​
@Id @GeneratedValue​
private Long id;​
private String name;​
}​
​
Create a Repository:​
​
@Repository​
public interface UserRepository extends JpaRepository<User, Long> { }​
​
Use the Repository in a Service:​
​
@Service​
public class UserService {​
@Autowired​
private UserRepository userRepository;​
​
 public User createUser(User user) {​
return userRepository.save(user);​
}​
}

27. How do you manage transaction handling in Spring Boot applications?

●​ Use @Transactional for atomicity.

●​ By default, Spring Boot uses JPA transaction management.

Example:

@Service​
public class UserService {​
​
@Autowired​
private UserRepository userRepository;​
​
@Transactional​
public void updateUser(Long id, String newName) {​
User user = userRepository.findById(id).orElseThrow();​
user.setName(newName);​
}​
}

28. What are the different ways to run a Spring Boot application?
Using Maven or Gradle:

1.​ Using IDE (Eclipse, IntelliJ) – Run the main() method.

2.​ Deploying to an external Tomcat server (WAR packaging).
29. Explain the Spring Boot logging mechanism with default loggers (e.g.,
Logback).

●​ Spring Boot uses SLF4J with Logback by default.

Logging Levels:

●​ TRACE, DEBUG, INFO, WARN, ERROR

Configuring logging in application.properties:

logging.level.root=INFO​
logging.level.com.myapp=DEBUG

Using logs in Java:

private static final Logger logger =

LoggerFactory.getLogger(MyService.class);​
logger.info("Application started");

30. How do you configure Spring Boot to send an email (e.g., using
JavaMailSender)?

1.​ Add JavaMail dependency:

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

2.​ Configure application.properties:

spring.mail.host=smtp.gmail.com​
spring.mail.port=587​
spring.mail.username=your-email@gmail.com​
spring.mail.password=your-password​
spring.mail.properties.mail.smtp.auth=true​
spring.mail.properties.mail.smtp.starttls.enable=true

3.​ Create an Email Service:

@Service​
public class EmailService {​
@Autowired​
private JavaMailSender mailSender;​
​
public void sendEmail(String to, String subject, String text) {​
SimpleMailMessage message = new SimpleMailMessage();​
message.setTo(to);​
message.setSubject(subject);​
message.setText(text);​
mailSender.send(message);​
}​
}