<a href="https://www.youtube.com/playlist?

list=PLKZ1dSitnT23M1XBdZJXkzLfhM2N6UGyK"> Interview Q&A </a>

## Spring Boot developer interview questions:

### Basic Questions

1. **What is Spring Boot, and how is it different from the Spring Framework?**
- **Response**: Spring Boot is an extension of the Spring Framework that
simplifies the setup and development of new Spring applications. It provides defaults
for code and annotation configuration to drastically reduce the setup time.
- **Example**: Unlike the Spring Framework which requires extensive
configuration, Spring Boot uses `@SpringBootApplication` to auto-configure most of
the application.

2. **What are the advantages of using Spring Boot?**

- **Response**: Spring Boot offers rapid application development with minimal
configuration, embedded servers, auto-configuration, production-ready features like
metrics and health checks, and an opinionated approach to configuration.

3. **How do you create a Spring Boot application?**

- **Response**: You can create a Spring Boot application using Spring Initializr,
IDEs, or manually by adding dependencies to your `pom.xml` or `build.gradle` file.
- **Example**:
```java
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
```

4. **What is a Spring Boot starter?**

- **Response**: A Spring Boot starter is a set of convenient dependency
descriptors you can include in your application. For example, `spring-boot-starter-
web` includes all dependencies to create a web application.

5. **What are Spring Boot starters and why are they useful?**
- **Response**: Spring Boot starters simplify dependency management by
providing a comprehensive list of libraries needed for a specific function, such as
web development or JPA.
- **Example**: Adding `spring-boot-starter-web` to your project includes
dependencies like Spring MVC, Jackson, and embedded Tomcat.

6. **Explain the concept of auto-configuration in Spring Boot.**

- **Response**: Auto-configuration in Spring Boot attempts to automatically
configure your Spring application based on the jar dependencies you have added. It
reduces the need for manual configurations.
7. **How do you define properties in a Spring Boot application?**
- **Response**: Properties can be defined in `application.properties` or
`application.yml` files in the `src/main/resources` directory.
- **Example**: `application.properties`
```properties
server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
```

8. **What is `application.properties` or `application.yml` in Spring Boot?**

- **Response**: These files are used to define configuration properties for your
Spring Boot application. They allow you to externalize configuration so that you can
easily change settings without modifying code.

9. **What are profiles in Spring Boot?**

- **Response**: Profiles allow you to segregate parts of your application
configuration and make it available only in certain environments. For example, you
can have different properties for development and production environments.
- **Example**: `application-dev.properties`, `application-prod.properties`.

10. **How do you implement exception handling in Spring Boot?**

- **Response**: Exception handling in Spring Boot can be implemented using
`@ControllerAdvice` and `@ExceptionHandler`.
- **Example**:
```java
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(Exception.class)
public ResponseEntity<String> handleException(Exception e) {
return new ResponseEntity<>(e.getMessage(),
HttpStatus.INTERNAL_SERVER_ERROR);
}
}
```

### Configuration and Setup

11. **How do you configure a DataSource in Spring Boot?**

- **Response**: You can configure a DataSource by specifying properties in
`application.properties` or `application.yml`.
- **Example**:
```properties
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=password
```

12. **What are the different ways to configure Spring Boot properties?**
- **Response**: Properties can be configured using `application.properties` or
`application.yml`, command-line arguments, environment variables, and custom
configuration files.

13. **How can you enable HTTPS in a Spring Boot application?**

- **Response**: HTTPS can be enabled by configuring the keystore in
`application.properties`.
- **Example**:
```properties
server.port=8443
server.ssl.key-store=classpath:keystore.p12
server.ssl.key-store-password=changeit
server.ssl.keyStoreType=PKCS12
server.ssl.keyAlias=tomcat
```

14. **How do you configure logging in Spring Boot?**

- **Response**: Logging in Spring Boot can be configured using
`application.properties` or `logback.xml`.
- **Example**:
```properties
logging.level.org.springframework=DEBUG
logging.file.name=app.log
```

15. **What is `@SpringBootApplication` annotation?**

- **Response**: `@SpringBootApplication` is a convenience annotation that
combines `@Configuration`, `@EnableAutoConfiguration`, and `@ComponentScan`.

16. **What is the purpose of `@EnableAutoConfiguration` annotation?**

- **Response**: `@EnableAutoConfiguration` tells Spring Boot to start adding
beans based on classpath settings, other beans, and various property settings.

17. **How do you externalize configuration in Spring Boot?**

- **Response**: Configuration can be externalized using properties files, YAML
files, environment variables, and command-line arguments.

18. **What is a `CommandLineRunner` in Spring Boot?**

- **Response**: `CommandLineRunner` is an interface used to execute code
after the Spring Boot application has started.
- **Example**:
```java
@SpringBootApplication
public class MyApplication implements CommandLineRunner {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}

@Override
public void run(String... args) throws Exception {
System.out.println("Application started!");
 }
}
```

19. **How do you configure multiple data sources in Spring Boot?**

- **Response**: Multiple data sources can be configured by defining multiple
`DataSource` beans and using `@Primary` for the main data source.
- **Example**:
```java
@Bean(name = "dataSource1")
@ConfigurationProperties(prefix = "spring.datasource1")
public DataSource dataSource1() {
return DataSourceBuilder.create().build();
}

@Primary
@Bean(name = "dataSource2")
@ConfigurationProperties(prefix = "spring.datasource2")
public DataSource dataSource2() {
return DataSourceBuilder.create().build();
}
```

20. **What is the difference between `application.properties` and

`bootstrap.properties`?**
- **Response**: `bootstrap.properties` is used for setting up the context,
particularly for initializing Spring Cloud Config, while `application.properties` is used
for application-specific configurations.

### Dependency Injection and Beans

21. **What is dependency injection in Spring Boot?**

- **Response**: Dependency injection is a design pattern in which an object
receives other objects it depends on. In Spring Boot, it is handled by the Spring
container.

22. **What are Spring Beans, and how are they managed in Spring Boot?**
- **Response**: Spring Beans are objects managed by the Spring container.
They are instantiated, configured, and wired by Spring.

23. **How do you define a Spring Bean?**

- **Response**: Beans can be defined using `@Component`, `@Service`,
`@Repository`, or `@Bean` annotations.
- **Example**:
```java
@Component
public class MyComponent {
// Bean definition
}
 @Bean
public MyBean myBean() {
return new MyBean();
}
```

24. **What is the role of the `@Autowired` annotation?**

- **Response**: `@Autowired` is used to automatically inject dependencies into
a Spring Bean.
- **Example**:
```java
@Component
public class MyComponent {
private final MyService myService;

@Autowired
public MyComponent(MyService myService) {
this.myService = myService;
}
}
```

25. **How do you create a custom Spring Boot starter?**

- **Response**: A custom Spring Boot starter involves creating a library project
with necessary dependencies and providing auto-configuration classes.
- **Example**:
```java
@Configuration
@ConditionalOnClass(MyService.class)
public class MyServiceAutoConfiguration {
@Bean
public MyService myService() {
return new MyService();
}
}
```

26. **What is the difference between `@Component`, `@Service`, `@Repository`,

and `@Controller`?**
- **Response**: `@Component` is a generic stereotype for any Spring-managed
component. `@Service` indicates a service layer component. `@Repository`
indicates a data access component. `@Controller` indicates a web controller.

27. **How do you create a custom annotation in Spring Boot?**

- **Response**: Custom annotations can be created using `@interface`.
- **Example**:
```java
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyCustomAnnotation {
 String value();
}
```

28. **What is the use of `@Configuration` annotation?**

- **Response**: `@Configuration` indicates that a class declares one or more
`@Bean` methods and can be processed by the Spring container to generate bean
definitions.

29. **How do you use `@Bean` annotation?**

- **Response**: `@Bean` is used to indicate that a method produces a bean to
be managed by the Spring container.
- **Example**:
```java
@Configuration
public class AppConfig {
@Bean
public MyService myService() {
return new MyServiceImpl();
}
}
```

30. **Explain the difference between `@Primary` and `@Qualifier` annotations.**

- **Response**: `@Primary` is used to give a bean preference when multiple
beans of the same type exist. `@Qualifier` is used to specify which bean should be
injected when multiple candidates are present.

### REST and Web Development

31. **How do you create a RESTful web service in Spring Boot?**

- **Response**: By using `@RestController` and `@RequestMapping`
annotations.
- **Example**:
```java
@RestController
@RequestMapping("/api")
public class MyController {
@GetMapping("/greeting")
public String greeting() {
return "Hello, World!";
}
}
```

32. **What is `@RestController` annotation?**

- **Response**: `@RestController` is a convenience annotation that combines
`@Controller` and `@ResponseBody`. It eliminates the need to annotate each
method with `@ResponseBody`.
33. **What are the HTTP methods supported by Spring Boot?**
- **Response**: Spring Boot supports GET, POST, PUT, DELETE, PATCH,
OPTIONS, and HEAD methods.

34. **How do you handle exceptions in a Spring Boot RESTful service?**

- **Response**: Exceptions can be handled using `@ControllerAdvice` and
`@ExceptionHandler`.
- **Example**:
```java
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(ResourceNotFoundException.class)
public ResponseEntity<String>
handleResourceNotFound(ResourceNotFoundException ex) {
return new ResponseEntity<>(ex.getMessage(),
HttpStatus.NOT_FOUND);
}
}
```

35. **What is the difference between `@RequestBody` and `@ResponseBody`?**

- **Response**: `@RequestBody` is used to bind the request body to a method
parameter, whereas `@ResponseBody` is used to bind a method return value to the
response body.

36. **How do you validate a request in Spring Boot?**

- **Response**: By using `@Valid` or `@Validated` annotations along with
`@RequestBody`.
- **Example**:
```java
@PostMapping("/user")
public ResponseEntity<User> createUser(@Valid @RequestBody User user) {
// save user
return ResponseEntity.ok(user);
}
```

37. **What is `@PathVariable` annotation?**

- **Response**: `@PathVariable` is used to extract values from the URI
template.
- **Example**:
```java
@GetMapping("/users/{id}")
public ResponseEntity<User> getUserById(@PathVariable Long id) {
User user = userService.findById(id);
return ResponseEntity.ok(user);
}
```

38. **What is `@RequestParam` annotation?**

 - **Response**: `@RequestParam` is used to extract query parameters from the
request.
- **Example**:
```java
@GetMapping("/search")
public ResponseEntity<List<User>> searchUsers(@RequestParam String
name) {
List<User> users = userService.findByName(name);
return ResponseEntity.ok(users);
}
```

39. **How do you implement pagination in Spring Boot?**

- **Response**: Pagination can be implemented using `Pageable` and `Page`
interfaces from Spring Data.
- **Example**:
```java
@GetMapping("/users")
public Page<User> getUsers(Pageable pageable) {
return userRepository.findAll(pageable);
}
```

40. **How do you handle CORS in Spring Boot?**

- **Response**: CORS can be handled using `@CrossOrigin` annotation or by
configuring `WebMvcConfigurer`.
- **Example**:
```java
@RestController
@CrossOrigin(origins = "http://example.com")
@RequestMapping("/api")
public class MyController {
@GetMapping("/data")
public ResponseEntity<String> getData() {
return ResponseEntity.ok("Data");
}
}
```

### Spring Data and JPA

41. **What is Spring Data JPA?**

- **Response**: Spring Data JPA is a part of the Spring Data family that makes it
easier to implement JPA-based repositories. It provides a set of interfaces and
annotations to simplify data access and manipulation.

42. **How do you configure JPA in Spring Boot?**

- **Response**: JPA is configured in Spring Boot using the
`application.properties` or `application.yml` file. You specify the datasource
properties and JPA properties.
- **Example**:
```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
```

43. **What is a repository in Spring Data JPA?**

- **Response**: A repository in Spring Data JPA is an interface that provides
CRUD operations on a specific type of entity. It extends one of the repository
interfaces provided by Spring Data JPA such as `CrudRepository`, `JpaRepository`,
or `PagingAndSortingRepository`.

44. **What is the difference between `CrudRepository`, `JpaRepository`, and

`PagingAndSortingRepository`?**
- **Response**:
- `CrudRepository` provides CRUD functions.
- `JpaRepository` extends `CrudRepository` and
`PagingAndSortingRepository` and provides additional JPA-specific methods such
as batch processing.
- `PagingAndSortingRepository` extends `CrudRepository` and provides
methods for pagination and sorting.

45. **How do you define a custom query in Spring Data JPA?**

- **Response**: Custom queries can be defined using the `@Query` annotation
or by naming convention.
- **Example**:
```java
@Query("SELECT u FROM User u WHERE u.email = ?1")
User findByEmail(String email);
```

46. **What is the purpose of the `@Query` annotation?**

- **Response**: The `@Query` annotation is used to define custom JPQL or
native SQL queries directly on repository methods.

47. **How do you handle transactions in Spring Boot?**

- **Response**: Transactions are handled using the `@Transactional`
annotation.
- **Example**:
```java
@Transactional
public void performTransaction() {
// transaction code
}
```
48. **What is the role of the `@Entity` annotation?**
- **Response**: `@Entity` is used to mark a class as a JPA entity, which means it
is mapped to a database table.

49. **What is the difference between `@Table` and `@Entity`?**

- **Response**: `@Entity` marks a class as a JPA entity. `@Table` is used to
specify the table name in the database that the entity is mapped to.

50. **How do you perform CRUD operations in Spring Data JPA?**

- **Response**: CRUD operations are performed using repository interfaces like
`CrudRepository`, `JpaRepository`, etc.
- **Example**:
```java
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

@Service
public class UserService {
@Autowired
private UserRepository userRepository;

public User saveUser(User user) {

return userRepository.save(user);
}

public Optional<User> findUserById(Long id) {

return userRepository.findById(id);
}

public void deleteUser(Long id) {

userRepository.deleteById(id);
}
}
```

### Security

51. **What is Spring Security, and how does it integrate with Spring Boot?**
- **Response**: Spring Security is a framework that provides authentication,
authorization, and protection against common attacks. It integrates with Spring Boot
by including the `spring-boot-starter-security` dependency.

52. **How do you secure a Spring Boot application?**

- **Response**: By using Spring Security, you can secure a Spring Boot
application through configuration in the `SecurityConfig` class, which extends
`WebSecurityConfigurerAdapter`.
- **Example**:
```java
@Configuration
 @EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/public/**").permitAll()
.anyRequest().authenticated()
.and()
.formLogin().permitAll()
.and()
.logout().permitAll();
}
}
```

53. **What is `@EnableWebSecurity` annotation?**

- **Response**: `@EnableWebSecurity` enables Spring Security's web security
support and provides the Spring MVC integration.

54. **How do you implement OAuth2 in Spring Boot?**

- **Response**: By using the `spring-boot-starter-oauth2-client` dependency and
configuring OAuth2 properties in the `application.properties` file.
- **Example**:
```properties
spring.security.oauth2.client.registration.google.client-id=your-client-id
spring.security.oauth2.client.registration.google.client-secret=your-client-secret
spring.security.oauth2.client.registration.google.redirect-uri={baseUrl}/login/
oauth2/code/google
```

55. **How do you handle authentication and authorization in Spring Boot?**

- **Response**: By configuring `WebSecurityConfigurerAdapter` and using
`UserDetailsService` for user details and `PasswordEncoder` for password
encoding.
- **Example**:
```java
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception
{

auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
}
```

56. **What is the role of the `SecurityConfigurerAdapter` class?**

- **Response**: `SecurityConfigurerAdapter` is a base class used to configure
security settings such as authentication and authorization in Spring Security.

57. **How do you implement JWT authentication in Spring Boot?**

 - **Response**: By creating a filter that validates JWT tokens and configuring the
security context.
- **Example**:
```java
@Component
public class JwtFilter extends OncePerRequestFilter {
@Override
protected void doFilterInternal(HttpServletRequest request,
HttpServletResponse response, FilterChain chain)
throws ServletException, IOException {
// JWT validation logic
}
}

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private JwtFilter jwtFilter;

@Override
protected void configure(HttpSecurity http) throws Exception {
http
.csrf().disable()
.authorizeRequests().antMatchers("/login").permitAll()
.anyRequest().authenticated()
.and()

.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);

http.addFilterBefore(jwtFilter,
UsernamePasswordAuthenticationFilter.class);
}
}
```

58. **How do you configure CORS in Spring Security?**

- **Response**: By using the `cors` method in `HttpSecurity` configuration.
- **Example**:
```java
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.cors().and()
.csrf().disable()
.authorizeRequests()
.anyRequest().authenticated();
}
```

59. **What are security filters in Spring Boot?**

 - **Response**: Security filters in Spring Boot are used to intercept requests and
apply security logic such as authentication and authorization. Examples include
`UsernamePasswordAuthenticationFilter` and `JwtFilter`.

60. **How do you encrypt passwords in Spring Boot?**

- **Response**: Passwords can be encrypted using `PasswordEncoder`
provided by Spring Security.
- **Example**:
```java
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
```

### Testing

61. **How do you write unit tests in Spring Boot?**

- **Response**: Unit tests in Spring Boot are written using JUnit and Mockito.
- **Example**:
```java
@RunWith(SpringRunner.class)
@SpringBootTest
public class MyServiceTest {
@Autowired
private MyService myService;

@Test
public void testServiceMethod() {
assertEquals("Expected Result", myService.serviceMethod());
}
}
```

62. **What is the role of `@SpringBootTest` annotation?**

- **Response**: `@SpringBootTest` is used to create an application context and
load all the beans for integration testing.

63. **How do you test RESTful web services in Spring Boot?**

- **Response**: RESTful web services are tested using `MockMvc` and
`@WebMvcTest`.
- **Example**:
```java
@RunWith(SpringRunner.class)
@WebMvcTest(MyController.class)
public class MyControllerTest {
@Autowired
private MockMvc mockMvc;

@Test
 public void testGetEndpoint() throws Exception {
mockMvc.perform(get("/api/data"))
.andExpect(status().isOk())
.andExpect(content().string("Data"));
}
}
```

64. **What is the use of `MockMvc` in Spring Boot testing?**

- **Response**: `MockMvc` is used to simulate HTTP requests and test Spring
MVC controllers without starting a full HTTP server.

65. **How do you perform integration testing in Spring Boot?**

- **Response**: Integration testing is performed using `@SpringBootTest` to load
the full application context and `TestRestTemplate` for RESTful services.
- **Example**:
```java
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment =
SpringBootTest.WebEnvironment.RANDOM_PORT)
public class MyIntegrationTest {
@Autowired
private TestRestTemplate restTemplate;

@Test
public void testApi() {
ResponseEntity<String> response =
restTemplate.getForEntity("/api/data", String.class);
assertEquals(HttpStatus.OK, response.getStatusCode());
assertEquals("Data", response.getBody());
}
}
```

66. **What are `@MockBean` and `@SpyBean` annotations?**

- **Response**: `@MockBean` is used to create and inject a mock bean into the
Spring application context. `@SpyBean` is used to create and inject a spy bean.

67. **How do you test a Spring Data JPA repository?**

- **Response**: By using `@DataJpaTest` which configures an in-memory
database, scans for `@Entity` classes, and configures Spring Data JPA repositories.
- **Example**:
```java
@RunWith(SpringRunner.class)
@DataJpaTest
public class UserRepositoryTest {
@Autowired
private UserRepository userRepository;

@Test
 public void testSaveUser() {
User user = new User("John", "Doe");
userRepository.save(user);
assertNotNull(userRepository.findById(user.getId()));
}
}
```

68. **How do you test Spring Boot services?**

- **Response**: By using `@MockBean` to mock dependencies and writing unit
tests for service methods.
- **Example**:
```java
@RunWith(SpringRunner.class)
@SpringBootTest
public class MyServiceTest {
@MockBean
private MyRepository myRepository;

@Autowired
private MyService myService;

@Test
public void testServiceMethod() {
when(myRepository.findById(anyLong())).thenReturn(Optional.of(new
MyEntity()));
assertEquals("Expected Result", myService.serviceMethod());
}
}
```

69. **What is `@DataJpaTest` annotation?**

- **Response**: `@DataJpaTest` is used for JPA tests. It sets up an in-memory
database and configures Spring Data JPA repositories.

70. **How do you write a test for a Spring Boot controller?**

- **Response**: By using `@WebMvcTest` and `MockMvc`.
- **Example**:
```java
@RunWith(SpringRunner.class)
@WebMvcTest(MyController.class)
public class MyControllerTest {
@Autowired
private MockMvc mockMvc;

@Test
public void testGetEndpoint() throws Exception {
mockMvc.perform(get("/api/data"))
.andExpect(status().isOk())
.andExpect(content().string("Data"));
 }
}
```

### Microservices and Cloud

71. **What is Spring Cloud, and how does it relate to Spring Boot?**
- **Response**: Spring Cloud provides tools for developers to quickly build some
of the common patterns in distributed systems (e.g., configuration management,
service discovery, circuit breakers, intelligent routing). It builds on Spring Boot to
create stand-alone, production-grade Spring-based applications.

72. **How do you create a microservice using Spring Boot?**

- **Response**: Create a Spring Boot project using `spring-boot-starter-web`,
define REST endpoints using `@RestController`, and manage dependencies using
Spring's dependency injection.

73. **What is service discovery, and how do you implement it in Spring Boot?**
- **Response**: Service discovery allows microservices to find and communicate
with each other. It can be implemented using Netflix Eureka in Spring Boot by adding
the `spring-cloud-starter-netflix-eureka-client` dependency and annotating the
application with `@EnableEurekaClient`.

74. **What is the role of Eureka in Spring Cloud?**

- **Response**: Eureka is a service registry that allows services to register
themselves and discover other registered services, enabling client-side load
balancing and failover.

75. **How do you configure load balancing in Spring Boot?**

- **Response**: Load balancing can be configured using Spring Cloud
LoadBalancer or Netflix Ribbon by including the `spring-cloud-starter-netflix-ribbon`
dependency and annotating the REST client with `@LoadBalanced`.

76. **What is Spring Cloud Config?**

- **Response**: Spring Cloud Config provides server-side and client-side support
for externalized configuration in a distributed system. It allows applications to fetch
their configuration properties from a centralized server.

77. **How do you handle distributed tracing in Spring Boot?**

- **Response**: Distributed tracing can be handled using Spring Cloud Sleuth
and Zipkin by adding the `spring-cloud-starter-sleuth` and `spring-cloud-starter-
zipkin` dependencies.

78. **What is the use of Spring Cloud Gateway?**

- **Response**: Spring Cloud Gateway is used to route requests to
microservices and provide cross-cutting concerns such as security,
monitoring/metrics, and resiliency.

79. **How do you implement API Gateway in Spring Boot?**

- **Response**: Implement an API Gateway using Spring Cloud Gateway by
adding the `spring-cloud-starter-gateway` dependency and configuring routing rules
in the application properties or YAML file.

80. **What is Hystrix, and how does it work in Spring Boot?**

- **Response**: Hystrix is a library that helps to control the interactions between
distributed services by providing fault tolerance and latency tolerance. In Spring
Boot, it is used to implement circuit breakers by adding the `spring-cloud-starter-
netflix-hystrix` dependency and annotating methods with `@HystrixCommand`.

### Miscellaneous

81. **What are the key components of a Spring Boot application?**

- **Response**: Key components include the `@SpringBootApplication`
annotation, application properties, embedded server, auto-configuration, and starter
dependencies.

82. **How does Spring Boot handle application properties and configuration?**
- **Response**: Spring Boot handles application properties using
`application.properties` or `application.yml` files. These properties can be injected
into Spring components using the `@Value` annotation or
`@ConfigurationProperties` binding.

83. **What are actuators in Spring Boot, and why are they important?**
- **Response**: Actuators provide production-ready features such as monitoring,
metrics, and health checks. They are important for managing and monitoring a
Spring Boot application in a production environment.

84. **How do you monitor a Spring Boot application?**

- **Response**: Monitor a Spring Boot application using Actuator endpoints,
Micrometer metrics, and integrating with monitoring tools like Prometheus, Grafana,
or ELK stack.

85. **What is Spring Boot Admin?**

- **Response**: Spring Boot Admin is a community project used to manage and
monitor Spring Boot applications. It provides a UI for managing and viewing the
status of Spring Boot applications.

86. **What is the role of `@SpringBootApplication` annotation?**

- **Response**: `@SpringBootApplication` is a convenience annotation that
combines `@Configuration`, `@EnableAutoConfiguration`, and `@ComponentScan`
to enable auto-configuration and component scanning.

87. **How do you deploy a Spring Boot application?**

- **Response**: A Spring Boot application can be deployed as a standalone JAR
with an embedded server, as a WAR file on an external server, or to cloud platforms
such as AWS, Azure, or Kubernetes.

88. **What are the different ways to package a Spring Boot application?**
- **Response**: Spring Boot applications can be packaged as JAR files
(standalone executable JAR) or WAR files (deployable to external servers).
89. **What is the role of `SpringApplication` class?**
- **Response**: The `SpringApplication` class is used to bootstrap and launch a
Spring application from a Java main method. It sets up the application context, auto-
configuration, and embedded server.

90. **How do you handle application migrations in Spring Boot?**

- **Response**: Application migrations can be handled using database migration
tools such as Liquibase or Flyway by configuring them in the Spring Boot application.

### Advanced Topics

91. **What is Spring Boot DevTools, and how do you use it?**
- **Response**: Spring Boot DevTools provides features like automatic restarts,
live reload, and configurations for improved development experience. It is used by
adding the `spring-boot-devtools` dependency.

92. **How do you handle versioning in a Spring Boot REST API?**

- **Response**: Versioning can be handled using URI versioning, request
parameter versioning, header versioning, or content negotiation.

93. **What are the common pitfalls in Spring Boot development?**

- **Response**: Common pitfalls include improper use of auto-configuration,
ignoring security best practices, not handling exceptions correctly, and poor
performance tuning.

94. **How do you optimize the performance of a Spring Boot application?**

- **Response**: Performance can be optimized by profiling the application,
tuning the JVM, optimizing database queries, using caching, and reducing the size of
HTTP responses.

95. **What are the best practices for Spring Boot development?**
- **Response**: Best practices include following coding standards, using
dependency injection, writing unit and integration tests, externalizing configuration,
and monitoring the application.

96. **How do you use `Liquibase` or `Flyway` with Spring Boot?**

- **Response**: Add the `liquibase-core` or `flyway-core` dependency, create
migration scripts, and configure them in `application.properties`.

97. **How do you configure caching in Spring Boot?**

- **Response**: Enable caching by adding `@EnableCaching` to the
configuration class, configure cache properties in `application.properties`, and use
`@Cacheable`, `@CachePut`, and `@CacheEvict` annotations on methods.

98. **What is `Spring Session`, and how do you use it?**

- **Response**: Spring Session provides an API and implementations for
managing user sessions. It is used to handle session data in a distributed
environment and can be integrated by adding the `spring-session` dependency.
99. **How do you handle file uploads in Spring Boot?**
- **Response**: Handle file uploads by using the `MultipartFile` interface in a
controller method and configuring file upload properties in `application.properties`.

100. **What are the new features introduced in the latest versions of Spring Boot?**
- **Response**: New features may include updates to the Spring Framework,
improved dependency management, enhanced support for modern cloud platforms,
and additional developer tools and configurations. Check the [Spring Boot release
notes](https://spring.io/projects/spring-boot#learn) for detailed information on the
latest features.