Top 30+ Spring Boot Interview Questions With Answers

@Configuration
@ConfigurationProperties(prefix = "myapp")
public class MyAppConfiguration {
    private String name;
    private int port;

    // Getters and setters

    // Other custom methods or business logic
}

application.properties# Database Configuration
spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase
spring.datasource.username=myusername
spring.datasource.password=mypassword

# Server Configuration
server.port=8080
server.servlet.context-path=/myapp

# Custom Application Properties
myapp.name=My Application
myapp.api.key=abc123

In this example, the MyAppConfiguration class is annotated with @ConfigurationProperties and specifies a prefix of “myapp”. The properties defined with the prefix “myapp” in the configuration files will be bound to the corresponding fields in this class.

How Does Spring Boot Support Microservices Architecture?

Spring Boot provides extensive support for building microservices-based applications. It offers a range of features and integrations that simplify the development, deployment, and management of microservices. Here’s how Spring Boot supports the microservices architecture:

1. Spring Cloud: Spring Boot integrates seamlessly with Spring Cloud, which is a set of tools and frameworks designed to build and operate cloud-native microservices. Spring Cloud provides capabilities such as service discovery, client-side load balancing, distributed configuration management, circuit breakers, and more.
2. Microservice design patterns: Spring Boot embraces microservice design patterns, such as the use of RESTful APIs for communication between services, stateless services for scalability, and decentralized data management. It provides a lightweight and flexible framework that enables developers to implement these patterns easily.
3. Service registration and discovery: Spring Boot integrates with service registry and discovery tools, such as Netflix Eureka and Consul. These tools allow microservices to register themselves with the registry and discover other services dynamically. This helps in achieving service resilience, load balancing, and automatic service discovery.
4. Externalized configuration: Spring Boot supports externalized configuration, allowing microservices to be easily configured based on the environment or specific deployment needs. It enables the separation of configuration from the code, making it easier to manage configuration properties across multiple microservices.
5. Distributed tracing and monitoring: Spring Boot integrates with distributed tracing systems like Zipkin and Sleuth, enabling the tracing of requests across multiple microservices. It also provides integrations with monitoring tools like Prometheus and Grafana to monitor the health, performance, and resource usage of microservices.
6. Resilience and fault tolerance: Spring Boot includes support for implementing fault-tolerant microservices using features such as circuit breakers (e.g., Netflix Hystrix), which help prevent cascading failures in distributed systems. It also provides mechanisms for handling retries, timeouts, and fallbacks in microservice interactions.
7. Containerization and deployment: Spring Boot applications can be easily containerized using technologies like Docker, allowing for seamless deployment and scaling of microservices using container orchestration platforms like Kubernetes.

What Is Spring Data? What Are Different Spring Data Starters Used in Spring Boot?

Spring Data is a subproject of the Spring Framework that simplifies data access by providing a unified programming model for different data storage technologies. It reduces boilerplate code and allows developers to focus on business logic. Spring Data supports relational databases, NoSQL databases, and more. It utilizes repositories to abstract data access operations, eliminating the need for manual CRUD code. Spring Data’s starters offer pre-configured dependencies and auto-configuration for specific databases, streamlining the setup process. With Spring Data, developers can easily interact with data sources and benefit from its powerful query capabilities.

Here are some examples of Spring Data starters for different types of databases:

1. spring-boot-starter-data-jpa: This starter provides support for Java Persistence API (JPA) and Hibernate. It includes the necessary dependencies and configurations for working with relational databases using JPA.
2. spring-boot-starter-data-mongodb: This starter provides support for MongoDB, a popular NoSQL database. It includes the necessary dependencies and configurations for working with MongoDB using Spring Data MongoDB.
3. spring-boot-starter-data-redis: This starter provides support for Redis, an in-memory data structure store. It includes the necessary dependencies and configurations for working with Redis using Spring Data Redis.
4. spring-boot-starter-data-cassandra: This starter provides support for Apache Cassandra, a highly scalable NoSQL database. It includes the necessary dependencies and configurations for working with Cassandra using Spring Data Cassandra.
5. spring-boot-starter-data-elasticsearch: This starter provides support for Elasticsearch, a distributed search and analytics engine. It includes the necessary dependencies and configurations for working with Elasticsearch using Spring Data Elasticsearch.

How Can You Consume RESTful Web Services in a Spring Boot Application?

In a Spring Boot application, you can consume RESTful web services using RestTemplate or WebClient. RestTemplate provides a synchronous API for making HTTP requests, while WebClient offers a non-blocking and reactive approach. Both allow you to send GET, POST, PUT, DELETE requests, handle response data, and deserialize it into Java objects.

How Can You Create and Run Unit Tests for a Spring Boot Application?

In a Spring Boot application, you can create and run unit tests using the Spring Test framework. By leveraging annotations such as @RunWith(SpringRunner.class) and @SpringBootTest, you can initialize the application context and perform tests on beans and components. 

Additionally, you can use Mockito or other mocking frameworks to mock dependencies and isolate the units under test. With the help of assertions from JUnit or AssertJ, you can verify expected behavior and assertions. 

Finally, running the tests can be done using tools like Maven or Gradle, which execute the tests and provide reports on test results and coverage.

How To Enable Debugging Log in the Spring Boot Application?

To enable debugging logs in a Spring Boot application, you can set the logging.level property in the application.properties or application.yml file to “DEBUG.” This configuration will enable the logging framework to output detailed debug information. Alternatively, you can use the @Slf4j annotation on a class to enable logging for that specific class. Additionally, you can configure logging levels for specific packages or classes by setting the logging.level.{package/class} property in the configuration file.

To enable debugging logs for the entire application, use:

logging.level.<package-name>=DEBUG

To enable debugging logs for the entire application, use:

logging.level.root=DEBUG

How Reactive Programming Is Supported in Spring Boot

Spring Boot provides support for reactive programming through its integration with the Spring WebFlux module. It allows developers to build non-blocking, event-driven applications that can handle a high volume of concurrent requests efficiently, making use of reactive streams and the reactive programming model.

How Do You Enable Security in Spring Boot Application?

We can use the following different options.

1. Using Spring Security: Enable security by adding the Spring Security Starter dependency to your project’s build configuration.
2. OAuth2 and OpenID Connect: Enable security using OAuth2 and OpenID Connect protocols for secure authentication and authorization.
3. LDAP Integration: Enable security by integrating with an LDAP (Lightweight Directory Access Protocol) server for user authentication and authorization.
4. JWT (JSON Web Token) Authentication: Enable security by implementing JWT-based authentication for stateless and scalable authentication.
5. Custom Authentication Providers: Enable security by creating custom authentication providers to handle authentication based on your own logic.

What Is the Purpose of Spring Boot DevTools? How Do We Enable It?

It is designed to improve productivity, streamline development workflows, and enable quick application restarts during the development phase.

Here are some key features and benefits of Spring Boot DevTools:

1. Automatic restart: DevTools monitors the classpath for any changes and automatically restarts the application when it detects modifications.
2. Live reload: DevTools supports live reloading of static resources such as HTML, CSS, and JavaScript files.
3. Remote application restart: DevTools provides the ability to remotely trigger a restart of the application. This can be useful when working in a distributed environment or when the application is running on a remote server. 
4. Developer-friendly error page: DevTools provides an enhanced error page that provides detailed information about exceptions and errors encountered during application development. 
5. Configuration properties support: DevTools enables hot-reloading of Spring Boot configuration properties. Changes made to application.properties or application.yml files are automatically applied without restarting the application, allowing for quick configuration updates.
6. Database console: DevTools includes an embedded database console that provides a web-based interface to interact with the application’s database. This allows developers to easily execute SQL queries, view and modify data, and perform other database-related tasks without requiring external tools.

To enable Spring Boot DevTools in your Spring Boot application, you need to include the appropriate dependencies and configurations. Here are the steps to enable DevTools:

Add the DevTools Dependency: In your pom.xml file (for Maven) or build.gradle file (for Gradle), add the following dependency:

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

// Gradle
implementation 'org.springframework.boot:spring-boot-devtools'

Enable Automatic Restart: By default, DevTools is enabled for applications run using the spring-boot:run command or from an IDE. However, you can also enable it for packaged applications by adding the following configuration property to your application.properties or application.ymlfile:

spring.devtools.restart.enabled=true

Advanced Level Spring Boot Interview Questions for Experienced Folks

How Can You Enable HTTPS in a Spring Boot Application?

To enable HTTPS in a Spring Boot application, you need to configure the application’s server properties and provide the necessary SSL/TLS certificates. Here are the general steps to enable HTTPS:

• Obtain SSL/TLS Certificates: Acquire the SSL/TLS certificates from a trusted certificate authority (CA) or generate a self-signed certificate for development/testing purposes.
• Configure Server Properties: Update the application.properties or application.yml file with the following server configurations:

server.port=8443
server.ssl.key-store-type=PKCS12
server.ssl.key-store=classpath:keystore.p12
server.ssl.key-store-password=your_keystore_password
server.ssl.key-alias=your_alias_name

In the above example, replace keystore.p12 with the path to your keystore file, and set the appropriate password and alias values.

• Provide SSL/TLS Certificates: Place the SSL/TLS certificate file (keystore.p12) in the classpath or specify the absolute file path in the server properties.
• Restart the Application: Restart your Spring Boot application for the changes to take effect.
• After completing these steps, your Spring Boot application will be configured to use HTTPS. You can access the application using https://localhost:8443 or the appropriate hostname and port specified in the server configuration.

How to Configure External Configuration in Spring Boot

To configure external configuration outside the project in Spring Boot, you can use one of the following approaches:

1. External configuration files: Instead of placing the application.properties or application.ymlfile within the project, you can specify the location of an external configuration file using the spring.config.name and spring.config.location properties. For example, you can place the configuration file in a separate directory and provide its location through the command line or environment variable.
2. Operating system environment variables: You can leverage the environment variables provided by the operating system to configure your Spring Boot application. Define the required configuration properties as environment variables and access them in your application using the @Value annotation or the Environment object.
3. Spring cloud config: If you have a more complex configuration setup or need centralized configuration management, you can use Spring Cloud Config. It provides a server-side component where you can store and manage configurations for multiple applications. Your Spring Boot application can then fetch its configuration from the Spring Cloud Config server.
4. Configuration servers: Another option is to use external configuration servers like Apache ZooKeeper or HashiCorp Consul. These servers act as central repositories for configurations and can be accessed by multiple applications.

How Do You Create a Spring Boot Application Using Maven?

To create a Spring Boot application using Maven, follow these steps:

Set Up Maven: Ensure that Maven is installed on your system. You can download Maven from the Apache Maven website and follow the installation instructions.

Create a Maven Project: Open your command line or terminal and navigate to the directory where you want to create your project. Use the following Maven command to create a new project:

mvn archetype:generate -DgroupId=com.example -DartifactId=my-spring-boot-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

This command creates a new Maven project with the specified groupId and artifactId. Adjust these values according to your project’s needs.

Add Spring Boot Starter Dependency: Open the pom.xml file of your project and add the following dependency for Spring Boot:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>2.5.2</version>
    </dependency>
</dependencies>

This dependency includes the necessary Spring Boot libraries for your application.

Create a Spring Boot Main Class: Create a new Java class in the appropriate package of your Maven project. This class will serve as the entry point for your Spring Boot application. Here’s an example:

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MySpringBootApplication {

    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApplication.class, args);
    }
}

The @SpringBootApplication annotation combines several annotations required for a basic Spring Boot application.

Build and Run the Application: Use the following Maven command to build and run your Spring Boot application:

mvn spring-boot:run

Maven will build your project, resolve the dependencies, and start the Spring Boot application.

Once the application is running, you can access it in your web browser using http://localhost:8080(by default) or the specified port if you have customized it.

That’s it! You have created a Spring Boot application using Maven. You can now add additional dependencies, configure your application, and develop your desired functionality.

What Are Different Types of Conditional Annotations?

Some of the commonly used conditional annotations in Spring Boot are:

1. @ConditionalOnClass: This annotation configures a bean or component if a specific class is present in the classpath.
2. @ConditionalOnMissingClass: This annotation configures a bean or component if a specific class is not present in the classpath.
3. @ConditionalOnBean: This annotation configures a bean or component only if another specific bean is present in the application context.
4. @ConditionalOnMissingBean: This annotation configures a bean or component only if another specific bean is not present in the application context.
5. @ConditionalOnProperty: This annotation configures a bean or component based on the values of specific properties in the application configuration files.
6. @ConditionalOnExpression: This annotation configures a bean or component based on a SpEL (Spring Expression Language) expression.
7. @ConditionalOnWebApplication: This annotation configures a bean or component only if the application is a web application.
8. @ConditionalOnNotWebApplication: This annotation configures a bean or component only if the application is not a web application.

Could You Provide an Explanation of Spring Boot Actuator Health Checks and the Process for Creating Custom Health Indicators?

Health checks provide valuable information about the application’s overall health, such as database connectivity, external service availability, or any other custom checks you define.

By default, Spring Boot Actuator provides a set of predefined health indicators that check the health of various components like the database, disk space, and others. However, you can also create custom health indicators to monitor specific aspects of your application.

To create a custom health indicator, you need to implement the HealthIndicator interface and override the health() method. The health() method should return an instance of Health, which represents the health status of your custom component. You can use the Health class to indicate whether the component is up, down, or in an unknown state.

Here’s an example of a custom health indicator:

import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;

@Component
public class CustomHealthIndicator implements HealthIndicator {

    @Override
    public Health health() {
        // Perform your custom health check logic here
        boolean isHealthy = true; // Replace with your actual health check logic

        if (isHealthy) {
            return Health.up().build();
        } else {
            return Health.down().withDetail("CustomComponent", "Not Healthy").build();
        }
    }
}

In this example, the CustomHealthIndicator class implements the HealthIndicator interface and overrides the health() method. Inside the health() method, you can write your custom health check logic. If the component is healthy, you can return Health.up(). Otherwise, you can return Health.down() along with additional details using the withDetail() method.

Once you create a custom health indicator, it will be automatically detected by Spring Boot Actuator, and its health check will be exposed through the /actuator/health endpoint.

How Do You Create Custom Actuator Endpoints in Spring Boot?

To create custom Actuator endpoints in Spring Boot, you can follow these steps:

1. Create a custom endpoint: Create a new class that represents your custom endpoint. This class should be annotated with @Endpoint to indicate that it is an Actuator endpoint. You can also use additional annotations like @ReadOperation, @WriteOperation, or @DeleteOperation to define the type of operations supported by your endpoint.
2. Define endpoint operations: Inside your custom endpoint class, define the operations that your endpoint should perform. You can use annotations like @ReadOperation for read-only operations, @WriteOperation for write operations, and @DeleteOperation for delete operations. These annotations help in defining the HTTP methods and request mappings for your endpoint.
3. Implement endpoint logic: Implement the logic for each operation of your custom endpoint. This can include retrieving information, modifying the application state, or performing any other desired actions. You have the flexibility to define the functionality based on your specific requirements.
4. (Optional) add security configuration: If your custom endpoint requires security restrictions, you can configure it by adding security annotations or by modifying the security configuration of your application.

Here’s an example of creating a custom Actuator endpoint:

import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
import org.springframework.boot.actuate.endpoint.annotation.ReadOperation;
import org.springframework.boot.actuate.endpoint.annotation.WriteOperation;
import org.springframework.stereotype.Component;

@Component
@Endpoint(id = "customEndpoint")
public class CustomEndpoint {

    @ReadOperation
    public String getInformation() {
        // Retrieve and return information
        return "This is custom endpoint information.";
    }

    @WriteOperation
    public void updateInformation(String newInformation) {
        // Update information
        // ...
    }
}

In this example, the CustomEndpoint class is annotated with @Endpoint to define it as an Actuator endpoint. It has two operations: getInformation() annotated with @ReadOperation for retrieving information and updateInformation() annotated with @WriteOperation for updating information.

After creating your custom endpoint, it will be automatically registered with Spring Boot Actuator, and you can access it through the /actuator base path along with the endpoint ID. In this case, the custom endpoint can be accessed via /actuator/customEndpoint.

How Can You Enable CORS (Cross-Origin Resource Sharing) In a Spring Boot Application?

To enable Cross-Origin Resource Sharing (CORS) in a Spring Boot application, you can follow these steps:

Add CORS Configuration: Create a configuration class and annotate it with @Configuration to define CORS configuration. Inside the class, create a bean of type CorsFilter to configure CORS settings.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

@Configuration
public class CorsConfig {

    @Bean
    public CorsFilter corsFilter() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();

        // Allow requests from any origin
        config.addAllowedOrigin("*");
        
        // Allow specific HTTP methods (e.g., GET, POST, PUT, DELETE)
        config.addAllowedMethod("*");
        
        // Allow specific HTTP headers
        config.addAllowedHeader("*");

        source.registerCorsConfiguration("/**", config);
        return new CorsFilter(source);
    }
}

In this example, we configure CORS to allow requests from any origin (*), allow all HTTP methods (*), and allow all HTTP headers (*). You can customize these settings based on your specific requirements.

Enable Web MVC Configuration: If you haven’t done so already, make sure to enable Web MVC configuration in your Spring Boot application by either using the @EnableWebMvc annotation on a configuration class or extending the WebMvcConfigurerAdapter class.

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter {

    // Additional Web MVC configuration if needed
}

Test CORS Configuration: Once you have enabled CORS in your Spring Boot application, you can test it by making cross-origin requests to your endpoints. Ensure that the necessary CORS headers are included in the response, such as Access-Control-Allow-Origin, Access-Control-Allow-Methods, and Access-Control-Allow-Headers.

Enabling CORS allows your Spring Boot application to handle cross-origin requests and respond appropriately. It’s important to consider the security implications and configure CORS settings based on your application’s requirements and security policies.

How Can You Schedule Tasks in a Spring Boot Application?

In a Spring Boot application, you can schedule tasks using the @Scheduled annotation provided by Spring’s Task Scheduling feature. Here’s how you can schedule tasks in a Spring Boot application:

Enable Scheduling: First, make sure that task scheduling is enabled in your Spring Boot application. This can be done by either using the @EnableScheduling annotation on a configuration class or by adding the @SpringBootApplication annotation along with @EnableScheduling on your main application class.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class MyAppApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyAppApplication.class, args);
    }
}
Copy

Create Scheduled Task Method: Define a method in your application that you want to schedule. Annotate the method with @Scheduled and specify the desired scheduling expression using cron, fixed delay, or fixed rate.

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class MyScheduledTasks {

    @Scheduled(cron = "0 0 8 * * *") // Run at 8 AM every day
    public void executeTask() {
        // Logic for the scheduled task
        System.out.println("Scheduled task executed!");
    }
}

In this example, the executeTask() method is scheduled to run at 8 AM every day based on the cron expression provided.

Test the Scheduled Task: Once you have defined the scheduled task, you can start your Spring Boot application and observe the scheduled task executing based on the specified schedule.

The @Scheduled annotation provides several options for specifying the scheduling expression, including cron expressions, fixed delays, and fixed rates. You can choose the most appropriate option based on your scheduling requirements.

How Can You Enable Caching in a Spring Boot Application?

To enable caching in a Spring Boot application, you can follow these steps:

Add Caching Dependencies: Ensure that the necessary caching dependencies are included in your project’s dependencies. Spring Boot provides support for various caching providers such as Ehcache, Redis, and Caffeine. Add the corresponding caching dependency to your project’s pom.xml file.

For example, to use the Ehcache caching provider, add the following dependency:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>

Enable Caching: To enable caching in your Spring Boot application, add the @EnableCachingannotation to your configuration class. This annotation enables Spring’s caching infrastructure and prepares the application for caching.

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableCaching
public class CachingConfig {
    // Additional configuration if needed
}

Annotate Methods for Caching: Identify the methods in your application that you want to cache and annotate them with the appropriate caching annotations. Spring Boot provides annotations such as @Cacheable, @CachePut, and @CacheEvict for caching operations.

For example, suppose you have a method that retrieves data from a database, and you want to cache the results. You can annotate the method with @Cacheable and specify the cache name.

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class DataService {

    @Cacheable("dataCache")
    public Data getData(String key) {
        // Logic to fetch data from a database or external service
        return data;
    }
}

In this example, the getData() method is annotated with @Cacheable and specifies the cache name as “dataCache”. The first time this method is called with a specific key, the data will be fetched and cached. Subsequent calls with the same key will retrieve the data from the cache instead of executing the method.

Configure Cache Settings: If you need to customize the caching behavior, you can provide additional configuration properties specific to your chosen caching provider. These configuration properties can be set in the application.properties or application.yml file.

For example, if you are using Ehcache, you can configure the cache settings in the ehcache.xml file and specify the location of the file in the application.properties file.

By following these steps, you can enable caching in your Spring Boot application and leverage the benefits of caching to improve performance and reduce database or external service calls.

Conclusion

In conclusion, these Spring Boot interview questions cover a wide range of topics related to Spring Boot, its features, and best practices. By familiarizing yourself with these questions and their answers, you can better prepare for Spring Boot interviews and demonstrate your knowledge and expertise in developing Spring Boot applications.