50 Must-Ask Interview Questions for Spring Boots

I’m Arsalan Mirbozorgi;

Every time a new approach to making the process of building apps easier is introduced to Spring Boot, it gets better. As with Java, it’s now a popular technology for building web applications. Here are the top 50 interview questions for Spring Boots, along with explanations and real-world examples. After consultation with industry experts, we’ve compiled this list of interview questions that are sure to help you ace the interview process.

So, without further ado, here we go!


Interview Questions for Spring Boots

Q1: What’s the main distinction between Spring Boots and Spring? 

Spring Boot

  • A part of the Spring framework
  • created a Spring application project that can simply be run/executed
  • Because of this, it’s less difficult to learn than the Spring Framework.
  • expresses one’s thoughts about a subject matter



  • A Java-based framework for building web applications
  • Enables the creation of unique web apps using tools and libraries.
  • In comparison to Spring Boot, Spring is more complicated.
  • Has no strong feelings about anything.


Q.2. When was the last time you used a framework like Spring Boots, and why?

To make the Spring framework for Java development easier to use, the Spring Boot module was created. A standalone Spring-based application can be created with it and simply run. As a result, several setups and dependencies are no longer required. Spring Boot framework includes the auto-dependency resolution, embedded HTTP servers, auto-configuration, administration endpoints, and Spring Boot CLI with the goal of rapid application development.

I would argue that Spring Boot enhances productivity and gives many conveniences for writing your own business logic if you ask me why anyone should adopt it.


Q3: What are the benefits of Spring Boots?

  1. The following are some of the primary and key benefits of using Spring Boot:
  2. Automatically loads a set of default configurations for an application’s rapid start
  3. Makes standalone programs with a wide range of capabilities that are common to numerous project categories
  4. There are no WAR files required because it has embedded tomcat and servlet containers.
  5. In order to decrease developer effort and simplify maven setups, Spring Boot offers an opinionated viewpoint
  6. Gives you access to a CLI tool for creating and testing software
  7. Provides numerous security metrics and includes Spring Boot starters for dependency management
  8. APIs for monitoring and managing applications in development, test, and production are included.
  9. Simple to use and integrates easily into the rest of the spring ecosystem because of the absence of boilerplate code.


Q4: Tell us about some of Spring Boots features.

  1. Spring Boot has the following notable features:
  2. Using the Spring Boot CLI, you can avoid boilerplate code while still using Groovy to write Spring Boot applications.
  3. Spring Boot’s Starter Dependency feature collects common dependencies into one place, which enhances efficiency.


  1. In order to load the default configurations for a project, Spring Boot uses the auto-configuration capability to aid. You’ll be able to keep your WAR files to a minimum this way.
  2. The Spring Initializer is a web application that can help you set up your project’s internal structure. You can utilize this functionality instead of manually setting up the project’s structure.
  3. Spring Actuator is a feature that assists with the execution of Spring Boot software.
  4. For all applications built with Spring Boot, the logging and security functionality maintains their security without causing any headaches.


Q5: Using Maven, how do you develop a Spring Boot app?

There are numerous ways to develop a Spring Boot application with maven, but here are a few that I’ve found very effective:

  1. Spring Boot Command Line Interface
  2. Project Wizard for the Spring Season
  3. Initialization of the spring
  4. The Maven Spring Project is an annual tradition.


Q6: List the probable sources of external configuration.

With little doubt, Spring Boot enables developers to run the same application across many contexts. You see, it does this via supporting external configuration through its support for external configuration. All of these variables and files are used to specify the configuration properties required by the application. Annotations such as the @value one are helpful for getting a handle on the properties. As a result, the following are the most likely external configuration sources:


Spring Boot will search the application properties file, or its YAML file will be searched for by default by Spring Boot in the current directory, classpath root, or configuration directory to load the properties.

Spring Boot provides command-line arguments and turns them into properties for the developer’s convenience. Then it includes them in the list of available environment attributes.

Qualities that are distinctive to a profile The application-profile. properties file or its YAML file is used to load these properties. There is a placeholder for a profile in this file that relates to an active profile. The mentioned file can be located in the same directory as the non-specific property files.


Q7: What occurs in the background when a Spring Boot app is “Run as Java Application,” what exactly happens in the background?

As soon as the tomcat server detects that you are working on a web application, the Spring Boot application begins as “Run as Java program.” Join Edureka’s Java training course today to learn more about Java.


Q8: What are the exact Spring Boot starters and available starters? 

It is possible to enable dependencies in an application using Spring Boot starters, a set of easy dependency management services. With these starters, it’s simple and quick to get started—the org. Spring framework. The boot package contains all of the accessible starters. Here are a few well-liked starters:

  • Spring-starter for your boots: – This is the basic beginning package, which comes with support for logging, auto-configuration, and YAML as standard.
  • This package installs the spring boot starter for JDBC. HikariCP connection pool with JDBC is started using this starter.
  • The starter for Spring MVC web applications, including RESTful, is spring-boot-starter-web
  • Does the starter use Spring Data JPA with Hibernate? Spring-boot-starter-data-jpa


  • The spring boot starting security package Does Spring Security make use of the starter?
  • It’s a beginning for aspect-oriented programming in combination with AspectJ and Spring.
  • Spring Boot applications can be tested using the spring-boot-starter-test


Q9: Explain the benefits of using a Spring Actuator

Using Spring Actuator, you can examine what’s going on inside a running Spring Boot application. Debugging your application means looking at the logs to see what’s going on. Therefore you must first understand what’s occurring in your application. The Spring Actuator comes in handy in this situation since it makes it simple to access features like bean identification and CPU consumption. It is quite simple to use the Spring Actuator to get at the production-ready REST points and all sorts of online data. Spring Security’s content negotiation approach is used to secure these points.


Q10: Describe Spring Boot dependency management 

Without declaring the version for any dependents, Spring Boot’s dependency management manages them all automatically.


Q11: What are the minimal Spring boots system requirements?


Spring Boot


Requires the installation of Spring Boots version 2.1.7.RELEASE

Java 8 and up is required.

5.1.9 and above of the Spring Framework

Build support that is made clear

Maven 3.3 or later is required.

Gradle 4.4 or higher required

Support for Servlet Containers

Version 4.0 of the Servlet API in Tomcat 9.0

Java Server Pages (Servlet) Version 3.1 in Jetty 9.4

Server-side scripting language version 4.0 for Undertow 2.0


Q12: What is thymeleaf, and how do you use it?

Thymeleaf is considered a Java template engine for web applications that runs on the server. Providing a natural template for your online app works well with Spring Framework and HTML5 Java web apps. The following pom.xml code must be included to use Thymeleaf:






Q13: Does the Spring boots allow us to alter the port of the embedded Tomcat server?

The application properties file does allow us to adjust the port of the integrated Tomcat server. You must add a property called “server.port” to this file and then assign it to any available port. If you want to use port 8081, for example, you must provide server.port=8081. Spring Boot will automatically load the application properties file and apply the necessary configurations to the application once you mention the port number.


Q14: Why is Spring Boots DevTools required?

Spring Boot DevTools are a comprehensive suite of tools designed to streamline the application development process. This module is automatically disabled if the program is running in production, and archive repackaging is also excluded by default. These attributes are then applied to a project’s respective development environment by use of the Spring Boot Developer Tools. You are only required to add the following dependency to the pom.xml file to use the DevTools:






Q15: Explain how to use Spring Initializer to construct a Spring Boot project? 

Spring provides a web utility called Spring Initializr. Create Spring Boot projects with this tool by simply supplying project data. To use Spring Initializer in a Spring Boot project, follow these steps:

  • Select the maven project and all of its dependencies from the drop-down menu. After that, provide the necessary information such as Group and Artifact and click on Generate Project to begin the process.
  • Extract the project to your computer when it has been downloaded.
  • The next step is to import the project into the Spring Tool Suite IDE by selecting the import option.
  • When importing the project, keep in mind that the project type must be set to Maven, and the pom.xml file must be present in the source project.


Once you’ve finished the above steps, you should see a Spring Boot project with all of the necessary dependencies.


Q16: of the Spring Boot Interview Guide. How do you connect a Spring Boot program with JDBC so that it can access the data?

The libraries needed to connect the application to JDBC are included in the Spring Boot starter projects. Here are the steps to create and join a MySQL database if you only need one simple app:

Step 1: 


Step 2: 

Creating a table in this database is step two.

CREATE TABLE customers(customerid INT PRIMARY KEY NOT NULL AUTO_INCREMENT, customername VARCHAR(255));

Step 3: Create a Spring Boot project and fill in the necessary information in the project template.

Step 4: Add the dependencies for JDBC, MySQL, and the web.

Step 5: Configure the database in the application properties after the project is built.





Step 6: we have the main application.

The following code belongs in a java class:

package com.edureka;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;


public class SampleApplication {

public static void main(String[] args) {

SpringApplication.run(SampleApplication.class, args);




Step 7: this is the next step in the process, and it involves writing the code that follows to handle HTTP requests:

package com.edureka;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.web.bind.annotation.RestController;


public class JdbcController {


JdbcTemplate jdbc;


public String index(){

jdbc.execute(“insert into customers(name)values(‘Aryya’)”);

return “Data Entry Successful”;




Step 8: This project will be finished as a Java application.

Step 9: you will notice the message Data Entry Successful when you open the URL (localhost:8080/insert). Alternatively, you can go ahead and double-check that the information has been entered into the table.


Q17: In Spring Boots, how do I activate HTTP/2 support?

HTTP/2 functionality in Spring Boot may be enabled by setting server.http2.enabled=true.


Q18:  what do the annotations @RequestMapping and @RestController do?


  • This annotation tells Spring that any HTTP request must be mapped to the corresponding method and is used to give routing information.
  • You must import org.springframework.web.bind.annotation.RequestMapping in order to use this annotation;



  • The @ResponseBody and @Controller annotations are added using this annotation.
  • Bind. Annotation needs to be imported into your project first before it can be used 


Consider, for example, that you have a function example() that corresponds to the URL /example.

package com.edureka;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;


public class SampleController {


public String example(){

return”Welcome To Edureka”;




Q19: The Spring Boot CLI provides a command-line interface for running Spring Boot projects. How does this happen? 

Officially, the Spring Framework provides support for Spring Boot CLI. The following are the steps needed to complete a Spring Boot project:

  • Install the CLI tool by downloading it from the official website and unzipping it. To run the Spring Boot application, navigate to the bin folder in the Spring setup.
  • A groovy file is required since the Spring Boot CLI executes groovy files. To begin, open a terminal window and navigate to the bin folder in your home directory. Launch the Groovy editor now (for example, Sample.groovy)
  • Create the following controller in this file:


@RestController public class Sample {


String index(){

<h2>”Welcome To Edureka”</h2>;

} }


After that, run the groovy script by saying:

./spring run Sample.groovy;

Visit localhost:8080/example, and you’ll get this output once the project has been completed. Hello, And Thank You For Visiting Edureka.


Let us know if you face any issues and problems with these Spring Boot interview questions by contacting us.


Q20: Discuss the distinctions between JPA and Hibernate 


JPA is a Data Access Abstraction that helps developers write less boilerplate code by abstracting away common operations.


With Hibernate, you get the benefits of Java Persistence API implementation with a low degree of coupling


Q21: In Spring Boot Actuator, how can we establish a custom endpoint?

The @Endpoint annotation in Spring Boot 2.x can be used to construct a custom endpoint. Spring Boot also makes use of @WebEndpointor, @WebEndpointExtension, and other Spring MVC, Jersey, and HTTP-based extensions to provide endpoints.


Q22: Explanation of spring data 

Cloud-based data services and data access technologies are among the features of Spring Data, which is created to make it simpler for developers to work with them. In other words, it simplifies data access while preserving the underlying data.


Q23: In Spring Boot, what exactly do you mean by “auto-configuration”? And how do you go about turning it off?

Auto-configuration is a technique for configuring an application’s environment on the fly. For example, if a data source bean is present in the application’s classpath, the JDBC template will be automatically configured. Auto-configuration makes it simple to develop a Java application by automatically configuring beans, controllers, and so on.

If you don’t want the auto-configuration property to be used, you must exclude the attribute @EnableAutoConfiguration from the situation.


If the class isn’t on the classpath, use the following code to disable auto-configuration:


In addition, Spring Boot has the spring.autoconfigure.exclude property for excluding a list of auto-configuration classes. It is possible to add several classes using comma-separated lists or application.properties.


Q24: How do @SpringBootApplication and @EnableAutoConfiguration annotations differ from one another?


  • A class or bootstrap method that is used
  • @Configuration, @ComponentScan, and @EnableAutoConfiguration annotations are all used in conjunction.


  • Automatic configuration and component scanning are enabled with @EnableAutoConfiguration.
  • @Configuration and @ComponentScan annotations are used in conjunction.


Q25: When deploying Spring Boot web apps, what are the procedures involved?

The following plugin must be added to the pom.xml file in order to deploy a Spring Boot web application:





You’ll obtain a JAR that executes the packaging step if you use the aforementioned plugin. A single JAR file will house all of the application’s libraries and dependencies. An embedded server will be included as well. As a result, the program can be run in the same way as a regular JAR.

To create a JAR file, make sure the packaging element in the pom.xml file is set to jar:


In the same way, if you desire to create a WAR file, you must mention it.



Q26: When dealing with transaction management, how would you use ReadOnly as true?

The following is an example of using ReadOnly as TRUE in transaction management:

You need to read data from a database; how would you go about doing that? As an illustration, imagine you have a client database, and you’d like to see facts about each one, such as customerID and customer name. You’ll need to make the transaction read-only so that we don’t have to worry about it checking for entity updates.


Q27: How do I deploy Spring Boot to a separate server?

To use Spring Boot to set up a new server, follow these steps:

  1. Take the project and turn it into a WAR file
  2. After that, upload the WAR file to the server of your choice.


What happens next depends on the server you select when deploying the WAR file.


Q28: Using Spring Boot, how can I provide my custom application configuration?

Spring Boot’s @Value annotation can be used to make the configuration of a custom application available. There is only one issue with this annotation: it disperses all of the configuration variables across the entire application. Rather than decentralizing, consider taking a centralized strategy.

In other words, you can construct a configuration component utilizing the @ConfigurationProperties to achieve a more centralized approach. For instance:



public class SampleConfiguration {

private int number;

private boolean value;

private String message;

The configured values in application.properties will be as follows according to the snippet above:

example.number: 100

example.value: true

example.message: Dynamic Message


Q29: Can we build a non-web program with Spring Boot? 

Yes, by eliminating the web dependencies from the classpath and altering the way Spring Boot builds the application context, we can create a non-web application.


Q30: An external database, such as MySQL or Oracle, can be connected in several ways. What are the steps? 

The following are the steps to link an external database:

  • pom.xml should have the MySQL Connector requirement added.
  • When you’re finished, delete the H2 Dependency from your pom.xml file.
  • Prepare your MySQL database and establish a connection to it.
  • Put your project on hold and restart it later.

Q31: Spring Boot Interview Q&A. Provide advantages of YAML over Properties file, as well as multiple approaches to import YAML in Spring boot. Explain.

It’s easier to work with YAML files because they contain data more hierarchically. The developers will have an easier time troubleshooting if there is a problem. You can use a YAML file instead of properties when using the SnakeYAML library in your classpath with SpringApplication. Spring Boot offers the following options for loading a YAML file:

To load YAML as a Map, use the YamlMapFactoryBean.

Load YAML as Properties Q32 with YamlPropertiesFactoryBean. 


Q32: It’s not clear to me where Hibernate gets its position as the default JPA implementation. Explain. 

The spring-boot-starter-data-jpa dependency is automatically added to the pom.xml file when using the Spring Boot Auto Configuration. Spring Boot automatically configures Hibernate as the default implementation of JPA anytime it encounters Hibernate in the classpath because of the transitive dependency.


Q33: When you hear the term Spring Data REST, what do you think it means?

This library uses Spring Data repositories to expose RESTful resources. Take a look at the following: 

@RepositoryRestResource(collectionResourceRel = “sample”, path = “sample”)

public interface SampleRepository

extends CustomerRepository<sample, Long> {

You may now use the POST method in the following fashion to expose REST services:


“customername”: “Rohit”


Response Content 


“customername”: “Rohit”

“_links”: {

“self”: {

“href”: “http://localhost:8080/sample/1”


“sample”: {

“href”: “http://localhost:8080/sample/1”



The newly generated resource’s href is included in the response content.


Q34: Explain the distinction between RequestMapping and GetMapping

Using @GetMapping as a shortcut for @RequestMapping(method = RequestMethod.GET) is a clever use of composite annotations. Both of these approaches help consumers. There are several ways to eat this product:

uses the value “text/plain” as the input.

the code that consumes it is of type ‘consumer’


Q35: Where should the beginning of a transaction boundary be located?

The transaction border should begin at the Service Layer, as this layer contains the business transaction logic.


Q36: How does Spring Data Rest operate with path=”sample”, collectionResourceRel=”sample”?

@RepositoryRestResource(collectionResourceRel = “sample”, path = “sample”)

public interface SampleRepository extends

PagingAndSortingRepository<Sample, Long>

  • If the resource is exported under a different segment, it will be specified here.
  • Links to the collection resource are generated using the ResourceRel value.


Q37: Describe the process of registering a customized auto-configure.

The fully qualified name of an auto-configuration class must be mentioned in the META-INF/spring. Factories file’s @EnableAutoConfiguration key. This file should be in the resources/META-INT directory if we built it using maven.


Q38: How do you Configure Log4j for the logging process? 

Since Spring Boot supports Log4j2 for configuration logging, you must exclude Logback and use Log4j2 instead. Using the beginners’ project is the only way to accomplish this.


Q39: WAR vs. embedded containers: what are the differences?


Spring Boot provides substantial value to WAR.


Embedded Containers 

Spring Boot has only one component, and it is only used when making upgrades.


Q40: Do you believe that Profiles are necessary?

Different aspects of the application settings can be separated and made available for different environments using profiles. It’s possible to limit the loading of any @Component or @Configuration by adding a @Profile to it. Assume you’ve got a few different settings.

Dev \sQA \sStage \sProduction

Now, if you want distinct application configurations in each environment, you can use profiles to have separate application configurations in each environment. In other words, Spring and Spring Boot let you specify things like:

The user profile that is most active in a particular setting.

The setting up of different working settings for different kinds of people.


Q41: To integrate Spring Boots with a custom JS file, what are the steps?

Spring Boot requires the following steps to add custom JS code:

  1. After that, make a new folder called static in the resources directory and put it there.
  2. Static stuff in that folder can be placed in this folder.


If the browser shows an unauthorized error, disable security or look for the password in a log file and pass it in the request header.


Q42: If a bean already exists, how can I tell an auto-configuration to stop?

The @ConditionalOnMissingBean annotation must be used to tell an auto-configuration class to stop when a bean is missing. The following are the characteristics of this annotation:

The type of beans to be checked is stored in this attribute, while the name is kept in this attribute.


Q43: What are the drawbacks of using Spring Data REST in real-world applications?

When using Spring Data REST, you should avoid exposing your database entities as REST Services. When creating RESTful services, the domain model and the end-users are critical factors to keep in mind. However, none of these variables are taken into account while utilizing Spring Data REST. It’s easy to see who’s who. So, for now, let me just suggest that Spring Data REST can be used for the project’s initial development.


Q44: If H2 isn’t on the classpath, what error message do you get?

There will be an error if H2 is not on the classpath.

Database type NONE does not have an inbuilt database driver class.

Restart your server after adding H2 to your pom.xml file to fix the problem.

To add the dependency, add the following code to your project:







Q45: What’s the best approach to use profiles in Spring Boots to set up environment-specific settings?

In light of the fact that a Profile is nothing more than a key to identifying an environment, let’s look at two profiles as an example:

dev \sprod

Here are a few examples of things you’ll see in the application’s property file:

example.number: 100

example.value: true

example.message: Dynamic Message 

For example, if you desire to change the application.properties for the dev profile, you must make a file called application-dev.properties and override the properties you wish to change. The following code can be mentioned:

example.message: Dynamic Message in Dev

Similarly, if you wish to customize the prod profile’s application.properties, use the code below:

example.message: Dynamic Message in Prod

The active profile must be configured in an environment once the profile-specific configuration is complete. Either of you can accomplish this.

  • Use -Dspring.profiles.active=prod in  arguments
  • Use spring.profiles.active=prod in application.properties file


Q46: What requirements does Spring Boots require to start a JPA application and establish a connection to an in-memory database H2?

Spring Boot needs the dependencies to launch a JPA application and connect to an in-memory database called H2.

website launcher h2 information starting point for the JPA

Refer to the following line of code to include the dependencies:















Q47: Is Spring Boot’s relaxed binding something that it supports?

When using relaxed binding, the property name and environment property key do not have to match. The type-safe binding of configuration properties can be relaxed in Spring Boot. SampleProp, for example, can be tied to any of the following environment attributes if it is in a bean class along with the @ConfigurationPropertie annotation:

sampleProp \ssample-Prop \ssample Prop \sSAMPLE PROP \s


Q48: To connect to H2, where do I enter my database credentials?

So, to answer your query, the answer is quite straightforward. The application’s dependencies are set up thanks to Spring Boot auto-configuration. As a result, the auto-configuration property handles the database connection information and establishes a connection to H2.


Q49: State the name of the default H2 database which Spring Boot configures?

H2’s default database is called testdb. Please see the example below:

spring.datasource.name=testdb # Name of the datasource.

To be clear, if you’re using an H2 in-memory database, the Spring Boot framework used to set up your H2 database is called Spring Boot.


Q50: Is it possible to replace tomcat in spring-boot-starter-web with jetty?

Spring-boot-starter-web can use jetty instead of tomcat if the present dependency is removed and the following is included:















To sum up, here are some sample interview questions for Spring Boot. I wish that these Spring Boot questions for interviews will assist you in preparation for your upcoming interviews. I wish you the best of luck!

Please Send Email

Your message sent successfully
There has been an error