Top Interview Questions for Spring Boot in 2023 - IQCode

Spring Boot Interview Questions: Basic to Advanced Level

Spring Boot has become a popular topic of discussion for Java Application development due to its fast development capabilities, low configuration requirements, built-in server, and monitoring features. It allows for the creation of robust and maintainable standalone Java applications from scratch.

What is Spring Boot?

Spring Boot is a Java-based framework used for Rapid Application Development. It comes with additional support for auto-configuration and embedded application servers such as Tomcat and Jetty.

What are the features of Spring Boot that make it different?

- Spring Boot enables the creation of standalone Spring applications with minimal configuration requirements. - It has embedded Tomcat and Jetty servers, making it easy to code and run applications. - It provides production-ready features, including metrics, health checks, and externalized configuration. - It requires no XML configuration.

Spring Boot Interview Questions for Freshers

1. What are the advantages of using Spring Boot?

Spring Boot Key Components

Spring Boot's key components are:

• Autoconfiguration: It detects and configures beans automatically based on the classpath.
• Starter dependency: It provides a fast way to create a project by including a set of dependencies related to a specific task or technology.
• Actuator: It provides production-ready features to manage and monitor an application.
• Spring Boot CLI: It provides a command-line interface tool to quickly develop Spring applications.
• Spring Boot libraries: It includes a set of libraries that can be used to build production-grade applications in a quick and efficient manner.

Why Use Spring Boot Instead of Spring?

Spring Boot is a framework built on top of the core Spring framework. It simplifies the process of building and deploying Spring applications by providing a set of pre-configured features, dependencies, and tools. Here are some reasons why you might consider using Spring Boot over Spring:

1. Faster development: With Spring Boot, you can get started quickly by writing less boilerplate code, taking advantage of auto-configuration, and using the Spring Initializr to generate a project with the dependencies you need.

2. Easier configuration: Spring Boot provides sensible default configurations for many features, which can save you time and effort. It also allows you to override these defaults easily through properties files, environment variables or annotations.

3. Standalone applications: Spring Boot applications can be built and deployed as standalone JAR files, which simplifies deployment and makes it easier to run your application on any system that has Java installed.

4. Microservices support: Spring Boot's lightweight and modular design makes it an excellent choice for building microservices-based architectures.

5. Community support: Spring Boot has a large and active community of developers who contribute to its development, answer questions on forums, and provide support through various channels.

Overall, Spring Boot is an excellent choice if you want to build robust, scalable, and maintainable Spring applications quickly and easily.

What is the starter dependency of the Spring Boot module?

In Spring Boot, the starter dependency is a set of convenient dependency descriptors that you can include in your application. They are a quick and easy way to set up a basic Spring Boot project. With starters, you can add all the required dependencies and configurations for a specific type of application development without having to manually add each individual dependency one by one. For example, if you want to develop a web application, you can include the "spring-boot-starter-web" dependency in your project, which automatically includes all required dependencies for a web application.

  <!-- example dependency for web application -->
  <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
  </dependency>

How Does Spring Boot Work?

Spring Boot is a popular Java-based framework that simplifies the development of web applications. It is designed to facilitate the creation of production-ready applications quickly and with minimum impact on the developer's time and effort.

Spring Boot works by providing a set of pre-configured modules and libraries that can be used to develop web applications without much setup and configuration. It automatically configures the Spring application based on the dependencies declared in the classpath, making it easy to create microservices and web applications.

Once you have created a Spring Boot project, you can start developing the application by adding new endpoints and implementing custom business logic. Spring Boot provides an embedded server that can be used to run and test the application locally.

Overall, Spring Boot simplifies the process of building web applications and helps the development team focus on the business logic rather than worrying about the underlying infrastructure.

Explanation of the @SpringBootApplication Annotation

The @SpringBootApplication annotation is used in Spring Boot applications as a convenient way to configure the base package of the application, to enable auto-configuration, and to configure component scanning.

Internally, this annotation is a combination of the following three annotations:

- @Configuration: This indicates that the class is a configuration class that declares one or more @Bean methods and may be processed by Spring’s container to generate bean definitions and service requests for those beans at runtime.

- @EnableAutoConfiguration: This tells Spring Boot to automatically configure the application based on the classpath settings, the beans available in the context, and various property settings.

- @ComponentScan: This enables component scanning for the base package of the application, which automatically configures all the beans annotated with @Component, @Service, @Repository, @Controller, and other custom annotations that are used to mark Spring components.

In short, @SpringBootApplication is a convenience annotation that combines multiple annotations and provides a simple way to bootstrap a Spring Boot application.

Purpose of using @ComponentScan in Java Class Files

@ComponentScan is an annotation used in Java class files to enable automatic scanning of Spring-managed components such as @Controller, @Service, and @Repository.

This annotation helps locate other components that are required for the application to function properly. It eliminates the need for tedious XML configuration files and simplifies the configuration process.

In simpler terms, @ComponentScan is used to find and automatically configure classes in the Spring framework.

Starting a Spring Boot Application

To start a Spring Boot application in a typical scenario, you can simply run the main method of the class annotated with @SpringBootApplication. This class usually contains the primary configuration of the application and Spring Boot will take care of the rest. Additionally, you can also package the application as a standalone JAR file and run it using the command `java -jar ` in the command line.

Understanding Starter Dependencies

Starter dependencies are pre-packaged libraries and configurations that can speed up the development process. They are typically included in frameworks and provide essential boilerplate code to get applications up and running quickly. These dependencies can be customized to fit specific project requirements or swapped out for alternatives that better fit the project's needs. In essence, starter dependencies act as a foundation for building sophisticated and efficient applications.

What is Spring Initializer?

Spring Initializer is a web-based tool that allows developers to quickly and easily create Spring Boot projects. It provides a user-friendly interface where one can select the required dependencies and configure the project settings. The tool generates a downloadable project structure that can be directly imported into any Java IDE and can be used as a starting point for building Spring Boot applications.

Code:

//Example code here
Understanding Spring Boot CLI and Its Advantages
Spring Boot CLI stands for Spring Boot Command Line Interface which is a tool that allows developers to easily build and run Spring Boot applications from the command line. The CLI provides a fast way to prototype the application and reduces the amount of boilerplate code required. It also includes features such as live reloading and dependency management.
The benefits of using Spring Boot CLI include faster development time, reduced complexity, better productivity, and improved efficiency. In addition, it allows developers to focus on the business logic of the application rather than the technology stack.
Using the Spring Boot CLI involves a few simple steps such as installing the CLI, creating a new project, adding dependencies, and running the application. Once the application is running, developers can use the CLI to make changes and see the updates in real-time using the live reloading feature.
Overall, Spring Boot CLI is a powerful tool that can help developers streamline the development process and build high-quality applications quickly and efficiently.
The Most Common Spring Boot CLI Commands
Spring Boot CLI provides a number of useful commands for developing and testing applications quickly and easily. Here are some of the most common commands you will use:
  



1. spring run app.groovy : This command runs a Spring Boot application with the given Groovy script.
2. spring init : This command generates a new Spring Boot project using the specified options.
3. spring test : This command runs all the tests in your project.
4. spring jar myapp.jar : This command packages your project as an executable JAR file.
5. spring help : This command shows help for the available Spring Boot CLI commands.

These are just a few examples of the many useful commands available in Spring Boot CLI. By using these commands and others, you will be able to streamline your development process and create high-quality Spring Boot applications more efficiently.
Basic Annotations in Spring Boot
In Spring Boot, there are several essential annotations that help developers to manage their application effectively. Some of these basic annotations are:
1. `@SpringBootApplication`: This annotation is used to bootstrap and configure the Spring Boot application. It combines the `@Configuration`, `@EnableAutoConfiguration`, and `@ComponentScan` annotations.
2. `@RestController`: This annotation is used to define the RESTful web services. It combines the `@Controller` and `@ResponseBody` annotations.
3. `@RequestMapping`: This annotation is used to map the web requests to the respective controller methods.
4. `@Autowired`: This annotation is used to inject the dependencies into beans.
5. `@Service`: This annotation is used to mark the Java class as a service.
6. `@Component`: This annotation is used to mark the Java class as a Spring bean.
7. `@Repository`: This annotation is used to mark the Java class as a repository.
By using these annotations, developers can manage their application easily and efficiently.
Understanding Spring Boot Dependency Management
Spring Boot Dependency Management is a built-in feature of the Spring Boot framework that manages all dependencies and versions for a Spring Boot project. It ensures that all required libraries and dependencies are present in the classpath and detects and resolves any conflicts that may arise between different versions of the same library. This feature simplifies the dependency management process, saves time, and eliminates the need for manual configuration of dependency versions. In short, Spring Boot Dependency Management acts as an effective API that takes care of all the dependencies required for a Spring Boot project.
Can Non-Web Applications be created using Spring Boot?
Yes, it is possible to create non-web applications using Spring Boot. Spring Boot provides various dependencies and configurations that can be used to build command-line applications, batch processing applications, and even standalone desktop applications. By excluding the web-related dependencies, we can use only the required dependencies for our non-web application, making it more lightweight and efficient.
Changing the Port of an Embedded Tomcat Server in a Spring Boot Application
Yes, it is possible to change the port of the embedded Tomcat server in a Spring Boot application. To do so, you need to modify the `application.properties` file by adding the following line:
plain
server.port = 8081

Replace `8081` with the desired port number.
Alternatively, you can set the port programmatically in your main Spring Boot application class:
java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.context.annotation.Bean;

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

    @Bean
    public TomcatServletWebServerFactory servletContainer() {
        TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory();
        tomcat.setPort(8081); // replace 8081 with desired port number
        return tomcat;
    }
}

This will create a new embedded Tomcat server with the specified port number.
What is the Default Port of Tomcat in a Spring Boot Application?
In a Spring Boot Application, the default port number for Tomcat server is 8080. However, this can be changed by modifying the "server.port" property in the "application.properties" file. For example, if you want to change the port number to 9090, you can add the following line in the "application.properties" file:
server.port=9090
This will change the port number to 9090 and the application will run on this port.
Replacing Embedded Tomcat Server in Spring Boot
Yes, we can replace the embedded Tomcat server in Spring Boot with another server like Jetty or Undertow. To do so, we need to exclude the Tomcat dependency and include the dependency for the desired server in our project's build configuration. We also need to configure the server-specific properties in the application.properties or application.yml file.
Disabling Default Web Server in Spring Boot Application
Yes, it is possible to disable the default web server that comes with the Spring Boot application. This can be achieved by adding the following line of code to the application's properties file:
    server.port=-1
This will disable the default web server of the application. However, the application will still start up, and any other embedded servers or web containers that are added will take precedence over the default server. 
Furthermore, if the application requires a web server, it will need to be added to the application's dependencies and configured accordingly.
It is also important to note that disabling the default web server may impact certain functionalities and features of the application, and should only be done if there is a specific need to do so.
Disabling a Specific Auto-Configuration Class
To disable a specific auto-configuration class in your Spring Boot application, you can use the `@EnableAutoConfiguration` annotation with the `exclude` parameter. 
Here's an example:

@Configuration
@EnableAutoConfiguration(exclude= {DataSourceAutoConfiguration.class})
public class MyApplication {
    // Your application code
}

In this example, we are disabling the `DataSourceAutoConfiguration` class. You can replace it with any other auto-configuration class that you want to disable.
Note that the `exclude` parameter is an array, so you can disable multiple auto-configuration classes at once by adding them to the array.
Explanation of @RestController Annotation in Spring Boot
In Spring Boot, the @RestController annotation is used to define a RESTful web service. It combines two annotations: @Controller and @ResponseBody. The @Controller annotation is used to define a controller class, and the @ResponseBody annotation is used to indicate that the return value of a method should be serialized and returned in the response body.
By using @RestController, we can create a controller that handles RESTful requests. The returned data can be serialized into JSON or XML response by the use of a suitable message converter along with @ResponseBody.
Using the @RestController annotation removes the need to include @ResponseBody annotation in each method of our controller class.
Difference between @RestController and @Controller in Spring Boot
In Spring Boot, the @RestController and @Controller annotations are used to handle HTTP requests. 
The @RestController annotation is a combination of @Controller and @ResponseBody annotations. It is typically used in RESTful web services to map requests directly to the response body. It is used when the response from the server needs to be in a specific format, such as JSON or XML.
The @Controller annotation is used to indicate that a class serves the purpose of a controller. It works with the Model-View-Controller (MVC) architecture to manage HTTP requests and responses. The @Controller annotation returns the name of the view that needs to be rendered to the client.
In summary, the @RestController annotation is used for RESTful web services that need to return data in a specific format, while the @Controller annotation is used for server-side MVC web applications that need to render views to the client.
Flow of HTTPS Requests in a Spring Boot Application
In a Spring Boot application, HTTPS requests flow through the following steps:

A client sends an HTTPS request to the server.
The request is intercepted by the SSL/TLS layer, which negotiates the secure connection with the client.
The request is then passed to the Spring Boot application layer, which maps the request to the appropriate controller method based on the URL and HTTP method.
The controller method processes the request and returns a response.
The response is then passed back through the SSL/TLS layer, which encrypts the response and sends it back to the client.

To enable HTTPS in a Spring Boot application, you need to configure the SSL/TLS certificate and the server properties. Once configured, Spring Boot will automatically handle HTTPS requests and encrypt the communication between the client and server.
Differences between @RequestMapping and @GetMapping
@RequestMapping and @GetMapping are both annotations used in Spring MVC framework for mapping HTTP requests to handlers. The main difference between the two is that @RequestMapping is a more generic annotation that can be used for mapping HTTP requests using different HTTP verbs, such as GET, POST, PUT, DELETE, and others. On the other hand, @GetMapping is a specific type of @RequestMapping that is used only for mapping HTTP GET requests.
Another difference is that @RequestMapping provides more flexibility as it allows you to specify additional request mapping conditions, such as headers and parameters. @GetMapping, on the other hand, only maps requests based on the URL path.
  


In terms of usage, you can use @RequestMapping to map a single URL to multiple methods or multiple URLs to the same method, while @GetMapping is used to map a single URL to a single controller method that handles GET requests.
Overall, @RequestMapping provides more versatility and can be used to handle different types of HTTP requests while @GetMapping provides a more specific and concise way of handling GET requests.H3 tag: Use of Profiles in Spring Boot
In Spring Boot, profiles provide a way to define different configurations for different environments. For example, you might have different configuration files for development, testing, and production environments.
Profiles are defined in the application.properties or application.yml file using the "spring.profiles.active" property. Here's an example of how to activate a profile called "dev" in the application.properties file:
Code:

spring.profiles.active=dev

Once a profile is active, Spring Boot will load the configuration properties from the corresponding configuration file. For example, if the "dev" profile is active, Spring Boot will look for a file called application-dev.properties or application-dev.yml.
Profiles can also be used to conditionally enable or disable certain features of your application. For example, you might have a feature that is only enabled in the development environment, but disabled in production.
By using profiles, you can ensure that your Spring Boot application behaves consistently across different environments, making it easier to manage and deploy.
Introduction to Spring Actuator
Spring Actuator is a part of Spring Boot Actuator's sub-project that offers production-ready features to monitor and measure the application health and performance. It's an infrastructure component that extends the monitoring and management capabilities of Spring Boot applications.
Spring Actuator provides a simple way to expose operational information about the running application via API endpoints, which permits administrators to monitor and manage the application's health, metrics, info, logs, etc.
Advantages of Spring Actuator
Spring Actuator provides the following advantages:

• Robust monitoring system: The Actuator offers a durable monitoring system that simplifies the tracking of the application's fundamental statistics in a reliable and straightforward way.
• Transparent management: Actuator ensures the simple and hassle-free management of the application with the help of its various management tools such as Spring Boot Actuator endpoints, JMX, and shell support.
• Advanced endpoints: The Actuator endpoints offer advanced features to expose application-specific metrics and configuration details that may not be accessible through other monitoring tools.
• Customization: The Actuator's endpoints may be customized to expose application-specific data and metrics precisely.

Enabling Actuator in a Spring Boot Application

To enable Actuator in a Spring Boot application, you just need to add the Actuator starter dependency to your `pom.xml` or `build.gradle` file.

For Maven, add the following dependency:

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

For Gradle, add the following dependency:

  implementation 'org.springframework.boot:spring-boot-starter-actuator'

After adding the dependency, Actuator auto-configures itself based on the Spring Boot application context. You can access the Actuator endpoints by appending the path to your application's base URL. For example, to access the health endpoint, you can use the URL `http://localhost:8080/actuator/health` if you're running the application locally.

Note that some Actuator endpoints may be sensitive and provide access to potentially sensitive information about your application. Make sure to secure them appropriately if needed.

Actuator Provided Endpoints for Monitoring Spring Boot Applications

In Spring Boot, Actuator provides several endpoints that can be used for monitoring the health of the application. These endpoints are used to expose various information about the application, such as application health, metrics, and environment details. These endpoints can be accessed using HTTP requests, and they can be customized to suit specific monitoring needs.

How to Retrieve a List of All Beans in a Spring Boot Application

To retrieve a list of all beans in a Spring Boot application, you can use the ApplicationContext interface. Here is a sample code to accomplish this:

Code:

java
import org.springframework.context.ApplicationContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BeanLister {

  @Autowired
  private ApplicationContext applicationContext;

  public void printAllBeans() {
      String[] allBeanNames = applicationContext.getBeanDefinitionNames();
      for (String beanName : allBeanNames) {
          System.out.println(beanName);
      }
  }

}

In the above code, we have autowired the ApplicationContext interface, which gives us access to all beans in our application context. The getBeanDefinitionNames() method returns an array of all bean names defined in the context. We then iterate over the array and print out each bean name.

You can call this method from anywhere in your application to get a list of all beans.

How to Check Environment Properties in Your Spring Boot Application?

To check the environment properties in your Spring Boot application, you can follow these steps:

1. Open the application.properties file in your project.
2. Check for any environment-related properties such as

   spring.profiles.active

   which defines the active profiles.

3. If you have multiple profiles, make sure to set the active profile before running your application.
4. You can also use the

   Environment

   object to get the properties programmatically in Java code.

5. Inject the

   Environment

   object into your code.

6. Use the

   getProperty

   method to get the desired property by passing the property key.

7. Optionally, you can also use the

   getActiveProfiles

   method to get the active profile names.

Here is a sample code snippet to get the properties:

  @Autowired
  private Environment env;

  String activeProfile = Arrays.toString(env.getActiveProfiles());

  String propertyValue = env.getProperty("propertyName");

Remember, environment properties play an important role in configuring your application for different profiles and environments. Be sure to carefully manage and test them for your Spring Boot application.

Enabling Debugging Log in a Spring Boot Application

To enable debugging log in a Spring Boot application, add the following line to the `application.properties` file:

logging.level.org.springframework=DEBUG

Alternatively, you can add this line to the `application.yml` file:

logging:
  level:
    org:
      springframework: DEBUG

This will enable debugging log for the entire Spring framework. If you want to enable debugging log for a specific package or class, replace `org.springframework` with the desired package or class name. For example, to enable debugging log for a package named `com.example`, use the following line:

logging.level.com.example=DEBUG

Remember to remove the debugging log configuration before deploying your application to production, as it can significantly impact performance.

Where to Define Properties in a Spring Boot Application?

In a Spring Boot application, we can define properties in several ways:

1. application.properties file - We can define properties in the application.properties file located in the /src/main/resources directory of our project. 2. application.yml file - We can also use the YAML format to define properties in the application.yml file. 3. Command-line arguments - We can specify properties using command-line arguments when running the application. 4. Environment variables - We can set properties as environment variables in the operating system or the container where our application runs.

Defining properties in a Spring Boot application allows us to externalize configuration settings and make our application more flexible and easier to manage.

Understanding Dependency Injection

Dependency Injection (DI) is a design pattern in software engineering that minimizes dependencies between classes and promotes loose coupling. This is achieved by injecting dependencies needed by a class via its constructor or setter methods, instead of the class creating its own dependencies. In simpler terms, it's a way of providing required objects to an object rather than having that object create them on its own. This makes the code more modular, testable, and easier to maintain.

What is an IOC Container?

An IOC (Inversion of Control) container is a software component that manages object dependencies and provides a way to create and manage objects through their lifecycle. It allows for the decoupling of components in an application and helps maintain loose coupling between them. An IOC container provides a way to create objects dynamically and inject dependencies at runtime rather than compile time. It also helps manage the scope of objects within an application. This makes the application more modular and easier to maintain. There are several IOC container frameworks available for use in various programming languages.