Spring Boot interview questions for Freshers and experienced

These Spring Boot interview questions cover fundamental aspects of Spring Boot, providing a good foundation for understanding its core features and capabilities. Here are common Spring Boot interview questions along with their answers.

What is Spring Boot?

Answer: Spring Boot is an extension of the Spring framework that simplifies the process of building and deploying Spring applications. It comes with a set of pre-configured defaults and opinionated approaches to reduce development time and effort.

Spring Boot is a popular Java-based framework that simplifies the development of standalone, production-grade Spring applications. It provides a quick and easy way to create Spring applications without the need for complex configuration.

What are the main features of Spring Boot?

Answer: Key features of Spring Boot include:

• Autoconfiguration: Spring Boot automatically configures your application based on dependencies and available classes.
• Starter dependencies: Pre-packaged dependencies that simplify project setup and configuration.
• Spring CLI: A command-line interface for creating and running Spring Boot applications.
• Embedding servers: Built-in support for embedding web servers like Tomcat or Netty.
• Actuators: Endpoints for monitoring and managing your application.
• Spring Initializer: A web-based tool for generating Spring Boot projects with predefined configurations.

Benefits of using Spring Boot:

• Faster development: Reduces the time and effort required to set up and configure Spring applications.
• Improved productivity: Provides a streamlined development experience with features like autoconfiguration and starter dependencies.
• Better maintainability: Creates well-structured and organized applications that are easier to understand and manage.
• Enhanced scalability: Supports horizontal and vertical scaling to meet increasing demands.
• Strong community and ecosystem: Backed by a large and active community with a wide range of resources and support.

 

Explain Spring Boot starters.

Answer: Starters are a set of convenient dependency descriptors you can include in your application. They simplify Maven/Gradle dependency management by bundling common dependencies for particular functionalities.

Spring Boot starters are pre-packaged dependencies that simplify project setup and configuration. They provide a convenient way to include commonly used libraries and frameworks in your Spring Boot application without having to manually configure them.

Key features of Spring Boot starters:

• Pre-configured dependencies: Include all the necessary libraries and frameworks for a specific use case.
• Simplified configuration: Automatically configure the included dependencies based on your application's needs.
• Easy to use: Just add the starter dependency to your project's build file.
• Wide range of options: Available for various use cases, including web development, data access, security, testing, and more.

Common Spring Boot starters:

• Spring Boot Starter Web: Provides the foundation for building web applications with Spring MVC.
• Spring Boot Starter Data JPA: Simplifies data access with JPA and a chosen persistence provider.
• Spring Boot Starter Security: Enables security features like authentication, authorization, and CSRF protection.
• Spring Boot Starter Test: Includes testing frameworks like JUnit and Mockito for unit testing.
• Spring Boot Starter Actuator: Provides endpoints for monitoring and managing your application.
• Spring Boot Starter Redis: Integrates with Redis for caching and data storage.
• Spring Boot Starter Kafka: Enables integration with Apache Kafka for messaging and event streaming.

Benefits of using Spring Boot starters:

• Faster development: Reduces the time and effort required to set up and configure your application.
• Improved productivity: Provides a streamlined development experience with pre-configured dependencies.
• Better maintainability: Creates well-structured and organized applications that are easier to understand and manage.
• Enhanced scalability: Supports horizontal and vertical scaling to meet increasing demands.
• Strong community and ecosystem: Backed by a large and active community with a wide range of resources and support.

 

What is the purpose of the @SpringBootApplication annotation?

Answer: The @SpringBootApplication annotation is a composite annotation in Spring Boot that combines several other annotations to provide a convenient way to configure and run a Spring Boot application. It acts as a shortcut for specifying common configurations that are often required in Spring Boot applications.

The @SpringBootApplication annotation is equivalent to the following annotations:

• @Configuration: This annotation indicates that a class defines bean definitions.
• @EnableAutoConfiguration: This annotation enables automatic configuration of Spring beans based on the classes available on the classpath.
• @ComponentScan: This annotation enables component scanning to discover beans defined in other classes.

Key benefits of using the @SpringBootApplication annotation:

• Simplified configuration: Provides a convenient way to specify common configurations without having to manually configure each component.
• Improved readability: Makes the application's structure more concise and easier to understand.
• Faster development: Reduces the time and effort required to set up and configure Spring Boot applications.

 

How does Spring Boot handle dependencies?

Answer: Spring Boot handles dependencies through its starter templates. When you add a starter to your project, it brings in a set of libraries that support the functionality (e.g., spring-boot-starter-web for web applications).

What is Spring Boot Actuator?

Answer: Spring Boot Actuator provides production-ready features to monitor and manage applications. It includes endpoints for health checks, metrics, environment properties, and more.

How do you configure properties in Spring Boot?

Answer: Properties in Spring Boot can be configured using:

• application.properties or application.yml files.
• Environment variables.
• Command-line arguments.
• Java system properties.
• Configuration classes with @ConfigurationProperties annotation.

What is the difference between @RestController and @Controller in Spring Boot?

Answer: The @RestController and @Controller annotations in Spring Boot are both used to define controllers that handle incoming HTTP requests, but they have different ways of returning responses.

@Controller:

• Returns a view name by default.
• The view name is resolved to a template file that is rendered and returned as the HTTP response.
• Typically used for traditional web applications that render HTML pages.

@RestController:

• Returns a plain object, JSON, or XML directly as the HTTP response.
• The returned object is automatically converted to the appropriate format based on the HTTP Accept header.
• Typically used for RESTful APIs that return data in a structured format.

Key differences:

• Response format: @Controller returns views, while @RestController returns plain objects, JSON, or XML.
• View resolution: @Controller requires a view resolver to map view names to templates, while @RestController does not.
• Use cases: @Controller is better suited for traditional web applications, while @RestController is better suited for RESTful APIs.

Example:

Java code:

@RestController

public class MyRestController {

    @GetMapping("/hello")

    public String hello() {

        return "Hello, world!";

    }

}

In this example, the @RestController annotation indicates that the MyRestController class is a REST controller. The @GetMapping("/hello") annotation maps the /hello endpoint to the hello() method. The hello() method returns a simple string, which will be returned directly as the HTTP response.

If you wanted to return a view instead, you would use the @Controller annotation and return a view name:

Java code:

@Controller

public class MyController {

    @GetMapping("/hello")

    public String hello() {

        return "hello";

    }

}

 

What is the use of the @RequestMapping annotation?

Answer: The @RequestMapping annotation in Spring MVC is used to map HTTP requests to specific methods within a controller class. It provides a flexible way to define the URL patterns, HTTP methods, and request parameters that will trigger a particular method.

Key features of the @RequestMapping annotation:

• URL mapping: Specifies the URL pattern that will match the request.
• HTTP method mapping: Specifies the HTTP methods (e.g., GET, POST, PUT, DELETE) that are allowed for the request.
• Request parameter mapping: Specifies the required request parameters.
• Path variable mapping: Specifies path variables within the URL pattern.
• Consumes and produces: Specifies the content types that the controller can consume and produce.

Example:

Java code:

@RestController

public class MyController {

    @RequestMapping(value = "/hello", method = RequestMethod.GET)

    public String hello() {

        return    "Hello, world!";

    }

}

In this example, the @RequestMapping annotation maps the /hello endpoint to the hello() method. The value attribute specifies the URL pattern, and the method attribute specifies that the request must be a GET request.

How can you create a custom starter in Spring Boot?

Answer: Creating a Custom Spring Boot Starter

A custom Spring Boot starter is a pre-packaged dependency that provides a convenient way to include your own library or framework in Spring Boot applications. By creating a starter, you can simplify the integration process for other developers and promote reusability.

Steps to Create a Custom Starter:

1. Create a New Spring Boot Project:
• Use Spring Initializer to generate a new Spring Boot project.
• Select the necessary dependencies based on your starter's functionality.
• Give your project a suitable name and package.
2. Define Your Library or Framework:
• Develop the core components of your library or framework.
• Ensure that your classes are annotated with appropriate Spring components (@Configuration, @Service, @Repository, etc.) to make them discoverable by Spring Boot.
3. Create a Starter Class:
• Create a new class annotated with @Configuration.
• Use @Import to import the configuration classes of your library or framework.
• Consider adding any necessary properties or beans to the configuration class.
4. Package Your Starter:
• Create a Maven or Gradle project structure.
• Add your starter class and library/framework code to the project.
• Define the starter's dependencies and metadata in the build file (e.g., pom.xml or build.gradle).
5. Publish Your Starter:
• If you want to share your starter with others, publish it to a repository like Maven Central or JCenter. You'll need to follow the specific guidelines of the repository.

Example: A Simple Starter for a Custom Logging Framework

Java code:

@Configuration

@Import(CustomLoggingConfiguration.class)

public class CustomLoggingStarterAutoConfiguration {

    // Optional configuration properties or beans

}

Java code:

@Configuration

public class CustomLoggingConfiguration {

    @Bean

    public CustomLogger customLogger() {

        return new CustomLoggerImpl();

    }

}

In this example, CustomLoggingStarterAutoConfiguration is the starter class that imports the CustomLoggingConfiguration. The CustomLoggingConfiguration class defines a @Bean for the custom logger implementation.

Using the Starter in Another Project:

• Add the starter as a dependency in your project's build file.
• The starter's configuration will be automatically applied, and you can use the provided components in your application.

 

What is Spring Boot DevTools?

Answer: Spring Boot DevTools is a powerful tool designed to improve the development experience when working with Spring Boot applications. It offers several features that can significantly speed up the development cycle and make the process more efficient.

Key Features of Spring Boot DevTools:

• Automatic Restart: One of the most prominent features is the ability to automatically restart your application when changes are detected in your source code. This eliminates the need to manually stop and restart the application after making modifications.
• LiveReload: DevTools can automatically refresh your browser when changes are made to static resources (HTML, CSS, JavaScript). This provides instant feedback on your changes without requiring manual page refreshes.
• Configuration Changes: You can modify configuration properties without restarting the application. DevTools will reload the context with the updated values.
• Template Reloading: Changes made to templates (e.g., Thymeleaf, FreeMarker) can trigger a restart of the application, allowing you to see the updated templates immediately.
• JRebel Integration: DevTools can integrate with JRebel (a commercial hot swapping tool) to provide even faster class reloading, potentially eliminating the need for restarts in some cases.

Benefits of Using Spring Boot DevTools:

• Increased Productivity: Faster development cycles and reduced time spent on manual restarts.
• Improved Workflow: Instant feedback on changes and a more seamless development experience.
• Faster Debugging: Easier to identify and fix issues with automatic restarts and live reloading.
• Simplified Configuration: Easier to modify configuration settings without restarting the application.

How does Spring Boot handle database configuration?

Answer: Spring Boot automatically configures the database connection based on the properties provided in the application.properties or application.yml file. It supports multiple data sources and provides integration with JPA, Hibernate, and JDBC.

Spring Boot provides a flexible and convenient way to configure database connections and access. It supports various databases and persistence frameworks, making it easy to integrate with your chosen database technology.

Key features of Spring Boot's database configuration:

• Automatic configuration: Spring Boot automatically configures database connections based on the presence of certain dependencies and properties in your application.
• Data sources: Spring Boot provides a DataSource abstraction that represents a connection to a database.
• Persistence frameworks: Spring Boot supports popular persistence frameworks like JPA, Hibernate, and JDBC.
• Property-based configuration: You can configure database properties using application properties or YAML files.
• Externalized configuration: You can externalize database properties to avoid hardcoding sensitive information in your application.
• Flyway and Liquibase: Spring Boot integrates with Flyway and Liquibase for database migrations.
• Data access repositories: Spring Data JPA provides a convenient way to create data access repositories for interacting with your database.

Common database configuration properties:

• spring.datasource.url: The JDBC URL for connecting to the database.
• spring.datasource.username: The username for connecting to the database.
• spring.datasource.password: The password for connecting to the database.  
• spring.datasource.driver-class-name: The JDBC driver class name.
• spring.jpa.properties.hibernate.dialect: The Hibernate dialect for the specific database.

Example using JPA and Hibernate:

YAML code:

spring.datasource.url: jdbc:mysql://localhost:3306/mydatabase

spring.datasource.username: myuser

spring.datasource.password: mypassword

spring.datasource.driver-class-name: com.mysql.cj.jdbc.Driver  

spring.jpa.properties.hibernate.dialect: org.hibernate.dialect.MySQL5Dialect  

In this example, the spring.datasource properties configure the connection to a MySQL database, and the spring.jpa.properties.hibernate.dialect property specifies the Hibernate dialect for MySQL.

Benefits of Spring Boot's database configuration:

• Simplified configuration: Reduces the complexity of database setup and configuration.
• Improved productivity: Provides a streamlined development experience.
• Enhanced flexibility: Supports various databases and persistence frameworks.
• Strong integration: Seamlessly integrates with popular database tools and technologies.
• Scalability: Supports horizontal and vertical scaling to meet increasing demands.

 

How do you enable HTTPS in Spring Boot?

Answer: To enable HTTPS in Spring Boot:

• Obtain or generate an SSL certificate.
• Configure the certificate in the application.properties or application.yml file by setting the server.ssl.key-store, server.ssl.key-store-password, etc.
• Ensure the server.port is set to 443 (or another appropriate HTTPS port).

What is the purpose of @EnableAutoConfiguration?

Answer: The @EnableAutoConfiguration annotation tells Spring Boot to start adding beans based on the classpath, other beans, and various property settings. It plays a crucial role in Spring Boot's auto-configuration feature.

What is the use of application.properties in Spring Boot?

Answer: The application.properties file is used to configure application settings such as database configurations, server port, logging levels, and custom application properties.

The application.properties file (or its YAML equivalent, application.yml) is a vital configuration file in Spring Boot applications. It serves as a central location to define various settings and properties that control the application's behavior.  

Key Roles of application.properties:

• Configuration Management: It allows you to define a wide range of configuration settings, including:
• Database connection details (URL, username, password)
• Server properties (port, context path)  
• Logging configuration (level, file location)
• Application-specific properties (custom settings for your application)
• Environment Agnostic Configuration: You can have different property files for different environments (development, test, production) to customize configurations for each.  
• Externalized Configuration: Sensitive information like passwords shouldn't be hardcoded in your application. application.properties allows you to keep them separate, improving security.
• Property Overriding: You can override properties defined in application.properties using environment variables or command-line arguments, providing flexibility for deployment.

Benefits of Using application.properties:

• Simplified Configuration: Reduces the need for complex XML configuration files.
• Improved Readability: Makes configuration settings easier to understand and manage.
• Increased Maintainability: Centralizes configuration, making updates and changes simpler.
• Environment-Specific Configuration: Enables tailoring the application's behavior to different environments.
• Enhanced Security: Externalizes sensitive information, reducing security risks.  

Example Configuration:

Properties

# Database connection details

spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase

spring.datasource.username=myuser

spring.datasource.password=mypassword  

# Server configuration

server.port=8080

# Logging configuration

logging.level.root=INFO

How does Spring Boot simplify security configuration?

Answer: Spring Boot simplifies security configuration by providing a spring-boot-starter-security dependency, which automatically sets up basic authentication and a default login page. It can be customized using the SecurityConfigurerAdapter class.

Explain the concept of profiles in Spring Boot.

Answer: Profiles in Spring Boot allow you to define different configurations for different environments (e.g., development, testing, production). You can specify profiles using the @Profile annotation or by setting the spring.profiles.active property.

What is a Spring Boot Initializer?

Answer: Spring Boot Initializer is a web-based tool provided by Spring to quickly bootstrap a Spring Boot project. It allows you to select the necessary dependencies and generate a project structure with a simple UI.

A Spring Boot Initializer, also known as Spring Initializer, is an online tool that helps you quickly create a new Spring Boot project. It provides a simple web interface where you can:

• Choose Project Type: Select between Maven or Gradle as your build tool.
• Select Spring Boot Version: Pick the version of Spring Boot you want to use.
• Add Dependencies: Choose the dependencies you need, such as Spring Web, Spring Data JPA, Spring Security, etc.
• Configure Project Settings: Set your project metadata like the group ID, artifact ID, and package name.

Once you have configured these options, the Initializer generates a project structure for you, including all the necessary files and dependencies. You can then download the project as a ZIP file or directly import it into your IDE.

 

How do you implement exception handling in Spring Boot?

Answer: In Spring Boot, you can implement exception handling in several ways to manage errors gracefully and provide meaningful responses. Here are the primary methods:

1. Using @ExceptionHandler in Controllers

• The @ExceptionHandler annotation is used within a controller to handle specific exceptions that occur in the controller's request handling methods.
• You define a method in the controller that is annotated with @ExceptionHandler, specifying the exception type it handles.
• This method can return a custom error response or redirect to an error page.

Example code:

@RestController

public class MyController {

    @GetMapping("/example")

    public String example() {

        if (someConditionFails) {

            throw new CustomException("Custom error occurred");

        }

        return "Success";

    }

    @ExceptionHandler(CustomException.class)

    public ResponseEntity<String> handleCustomException(CustomException ex) {

        return new ResponseEntity<>(ex.getMessage(), HttpStatus.BAD_REQUEST);

    }

}

2. Using @ControllerAdvice for Global Exception Handling

• @ControllerAdvice is a special annotation used to define global exception handling logic across all controllers.
• You can create a class annotated with @ControllerAdvice, and within it, define methods using @ExceptionHandler to handle exceptions across the application.
• This approach centralizes exception handling, making it easier to manage and reuse.

Example code:

@ControllerAdvice

public class GlobalExceptionHandler {

    @ExceptionHandler(ResourceNotFoundException.class)

    public ResponseEntity<String> handleResourceNotFoundException(ResourceNotFoundException ex) {

        return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);

    }

    @ExceptionHandler(Exception.class)

    public ResponseEntity<String> handleGeneralException(Exception ex) {

        return new ResponseEntity<>("An error occurred", HttpStatus.INTERNAL_SERVER_ERROR);

    }

}

3. Custom Error Pages

• Spring Boot allows you to create custom error pages by placing HTML files in the src/main/resources/templates/error/ directory.
• The error pages should be named according to the HTTP status code (e.g., 404.html for a 404 error) or a general error.html file for all errors.

Example: You can create a 404.html file to display a custom "Page Not Found" message.

4. Custom Error Responses Using @ResponseStatus

• You can annotate exceptions with @ResponseStatus to define the HTTP status code that should be returned when the exception is thrown.
• This method is useful for creating custom exceptions with specific status codes.

Example code:

@ResponseStatus(HttpStatus.NOT_FOUND)

public class ResourceNotFoundException extends RuntimeException {

    public ResourceNotFoundException(String message) {

        super(message);

    }

}

5. Using Spring Boot’s ErrorController Interface

• For more advanced error handling, you can implement the ErrorController interface, which allows you to override the default error handling mechanism provided by Spring Boot.
• This method gives you complete control over how errors are processed and presented.

 

What is a Spring Boot actuator's /health endpoint?

Answer: The /health endpoint provided by Spring Boot Actuator returns the health status of the application. It can be used to check whether the application is running correctly and may include custom health indicators for specific checks (e.g., database connectivity).