22 common Spring Boot interview questions and answers

Are you a Java Spring Boot developer looking forward to your next interview, but don’t know what questions to expect? We’re here to help!

This article will help you prepare properly by outlining some commonly asked Spring Boot interview questions and answers that the interviewer can use to test you.

Interviewers use strategic Java Spring Boot questions to test the interviewee’s skill level related to a given role. Therefore, you should prepare relevant questions and know how to answer them.

Before we move on to the interview questions and corresponding answers, let’s give a basic overview of what Spring Boot is and how useful it is for Java developers.

What is Java Spring Boot?

This Java framework was created in 2014 by an important team. Spring Boot, an open source framework, allows you to efficiently develop independent production-grade applications and even run them on the Java Virtual Machine (JVM).

Java developers prefer Java for developing web applications and microservices because of its quick and easy setup process and secure configuration time.

Spring Boot enables easy setup and configuration of Spring-based applications through three core features:

• Auto-configuration – Automatic configuration of Spring applications.
• Spring Boot provides a unique approach for configuration defaults to use and packages to install for required dependencies. This unique approach helps you set up your project quickly.
• Sprsetupoot allows applications to run independently without the need for a web server.

How does Spring Boot help Java developers?

First, Spring Boot makes it easy for Java developers to automatically configure all the components needed to develop production-grade Spring applications. This reduces development time in the long run and ultimately increases efficiency.

Spring Boot also easily integrates with Spring’s ecosystem, including Spring JDBC, Spring Data, Spring Security, and Spring ORM.

Java developers can also connect Spring Boot to various databases such as Oracle, MySQL, PostgreSQL, and MongoDB.

Of course, flexible configurations such as XML configuration, Java Beans, and database transactions are also useful features.

So, now that you have a basic overview of Spring Boot, let’s explore some of the common Spring Boot interview questions and answers that will help you prepare for the interview.

Spring Boot interview questions and answers

What features does Spring Boot have?

Some of these popular features include:

• Spring Boot CLI provides Groovy for creating Spring Boot applications. In the long run, boilerplate code is avoided.
• Spring Boot provides logging and security features that easily protect your applications from potential security threats.
• It provides automatic configuration of project-related components, avoiding the risk of unnecessary WAR files.
• The Starter Initializer builds the default internal project structure. This eliminates the need to manually set up the project structure.
• Spring Boot actuator functionality allows you to access insights and metrics as your application runs.
• Of course, one of the key features of Spring Boot is Starter dependencies, which help aggregate commonly used dependencies for a particular feature.

What is Spring Boot starter?

A Spring Boot starter is a dependency descriptor that contains a set of dependency management providers that enable dependencies for your application. These provide automatic dependency resolution for the framework. Starters power development easily and quickly.

What are Spring Boot actuators and what are their benefits?

Actuators are a Spring Boot feature that allows you to monitor what’s going on inside your application while it’s running.

For example, during debugging, you can use Actuator to analyze logs by providing access to features such as CPU usage and bean identification.

Additionally, Actuator can retrieve data from the web as well as provide easy access to production-ready REST endpoints to monitor and manage information.

What is thymeleaf? How to use thymeleaf?

Thymeleaf is a Java server-side template that creates natural template layouts for both Spring and HTML5 Java web applications.

Spring Boot uses the spring-boot-starter-thymeleaf dependency in the pom.xml file to perform automatic configuration of thymeleaf and serve dynamic web content.

To enable Spring Boot to read and render thymeleaf templates or HTML files, place the templates in src/main/resources/templates .

Thymeleaf then parses the index.html file and uses the actual values ​​passed from the controller class instead of the dynamic values ​​available in the index file.

After this, a message will be displayed in your web browser as soon as your Spring Boot application runs.

 org.springframework.boot spring-boot-starter-thymeleaf 

Describes the process of creating a Spring Boot project using Spring Initializer.

Spring Initializr, a Spring web tool, allows you to create a Spring Boot project in a few steps by specifying project details.

1. Go to Spring intializr and fill in the input field.
2. Click the “Generate” button to start downloading the project.
3. Extract the downloaded project from the zip file and open it from your IDE. From the IDE, go to File -> New -> Project from Existing Source -> Spring-boot-app and select the pom.xml file. Click the Import Changes prompt to sync your project. After this, make sure to go to the application.properties file and edit the server.port number to server.port=7000 .
4. Now run the application from src->main->java->com.gfg.Spring.boot.app .

What is JPA in Spring Boot?

It is a Java specification that uses object-relational mapping (ORM) to manage relational data and enable access to data between Java objects or Java classes and relational databases in applications.

JPA uses Java Persistent Query Language (JPQL), a platform-independent, object-oriented query language.

JPA allows you to perform query processing and object transactions against the database using the Entity Manager API provided by JPA.

What is Spring Boot autoconfiguration?

Autoconfiguration attempts to automate the configuration of your Spring Boot application using jar dependencies that you add to your application.

Depending on available dependencies in your application’s classpath, automatic configuration declares built-in objects for Spring-specific modules such as JPA and Spring Security.

What are Spring annotations?

Spring annotations reference metadata that provides information about a program snippet and adds supplementary data to that program. Code components such as classes and methods are often associated with annotations.

Annotations do not directly affect the behavior of the program or the subsequent behavior of the compiled code.
Their syntax begins with the ” @ ” symbol.

Spring Boot provides six main annotation types:

• Spring core annotations
• Spring data annotations
• Spring Bean Annotations
• Spring Web annotations
• Spring schedule notes
• Spring Boot annotations

What is Spring Data REST?

Spring Data REST RESTfully exposes resources around Spring Data resources using minimal code.

The following example uses the POST method to request content using http://localhost/example as the URL and Content-Type: application/json as the header.

Request details:

 {
    "name": "Jimmy",
    "Gender": "Male",
    "Age": 23
}

Response content:

 {
    "name": "Jimmy",
    "Gender": "Male",
    "Age": 23
    "_links": {
        "self": {
            "href": "http://localhost:8080/example/1"
        },
        "person": {
            "href": "http://localhost:8080/example/1"
         }
    }
}

What is the need for Spring Boot DevTools?

These are an advanced set of predefined tools whose properties are applied to the respective development environment to facilitate development and save development time.

Whenever you change the code in your Spring Boot application, the Spring Boot DevTools feature is automatically restarted. Therefore, you don’t have to manually restart the application every time you change the code.

What is spring data?

Spring Data aims to give developers easy access to relational and non-relational data, cloud-based data services, and other data access technologies while continuing to preserve the special characteristics of the underlying data stores. I am.

How can I tell it to stop automatic configuration when a bean exists?

Here we use @ConditionalOnMissingBean annotation with name and value attributes as follows:

• The value attribute stores the bean type to check.
• name attribute that specifies the name of the bean to check

How do I fetch data from a database in Spring Boot?

You can access data from a MySQL database to your Spring Boot application using the following steps.

Step 1: Create a database in MySQL using the create DATABASE person command.

Step 2: Create a table in the database.

 CREATE TABLE person(id INT PRIMARY KEY NOT NULL AUTO_INCREMENT, name VARCHAR(255));

Step 3: Create a Spring Boot application and add JDBC, MySQL, and required web dependencies to it.

Step 4: Configure the database from the application.properties file as below.

 spring.datasource.url=jdbc:mysql://localhost:3306/personDetails
spring.datasource.username=example123
spring.datasource.password=example123
spring.jpa.hibernate.ddl-auto=create-drop

Step 5: Next, let’s handle the request in our controller class.

 package com.person;
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;
@RestController
public class JdbcController {
   @Autowired
   JdbcTemplate jdbc;
   @RequestMapping("/save")
   public String index(){
      jdbc.execute("insert into person (name)values(Trial)");
      return "Name entered Successfully";
   }
}

Finally, run the application checking the database entries to see the data accessed.

Why do we need Spring profiles?

Spring profiles allow you to separate the configuration of different parts of your application for specific development purposes.

Spring profiles also save developers the hassle of managing environment-specific external configurations when Spring profiles are not available.

Additionally, this makes it harder to keep things in sync, and creates even more of a need to create several factory-like components that take advantage of specific needs depending on specific environment-specific parameters.

Can I change the port of the embedded Tomcat server in Spring Boot?

Yes, you can.

To do this, manipulate the application.properties file to include the server.port property and assign it the port of your choice. Spring Boot automatically loads your application’s properties files and applies the required configuration to your application.

For example, you can change the server.port number from its default value of 8080 to server.port= 8081 .

How do I configure Log4j for logging?

You can configure Log4j for logging in a few simple steps:

1. First, create a Java project and right-click on the project. Go to MyEclipse -> File -> New -> Java Project, name your project, and click Finish.
2. Then right-click the Java project name and select Build Path -> Configure Build Path. In this step you will add log4j files.
3. Go to Libraries, click the Add External JARS button, and select your log4j file from the drop-down menu that appears. Then click OK.
4. Create a new Java file named log4j.properties file and click Finish to add this file to your classpath.
5. From the classpath, click Advanced, select the Add Folder option, and remember to click OK.
6. Now you can find the log4j.properties file and click OK to run the project.
7. Check the output below in the console.

 [main] DEBUG Example – Hello this is a debug message
[main] INFO Example – Hello this is an info message

What is an IoC container?

The IoC (Inversion of Control) container is a core Spring container that automatically implements dependency injection. It instantiates the application of the class and is responsible for configuring the objects and assembling the necessary dependencies.

It also manages the lifecycle of objects from instantiation to destruction.

IoC uses Java code, XML, and metadata configuration of Java annotations to perform these tasks.

It is called inversion of control because the container controls the Java objects and the lifecycle of these objects. Otherwise, this is a developer’s task.

Describe how to create Spring Boot applications using Maven

This process requires a series of steps.

Step 1: Select the type of project.

Step 2: Name and configure your project and click the Finish button to create the project.

Step 3: Next, configure the Maven project’s pom.xml file to create a Spring Boot project from it.

pom.xml file:

 <project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">  
  <modelVersion>4.0.0</modelVersion>  
  <groupId>com.javatpoint</groupId>  
  <artifactId>spring-boot-example</artifactId>  
  <version>0.0.1-SNAPS<name>JavaTpoint Spring Boot Example</name>  
</project>  

This configuration involves adding a parent to your Maven project. This declares the Maven project as a child project of the parent project.

 <parent>  
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-parent</artifactId>  
    <version>1.4.2.RELEASE</version>  
</parent>  

Step 4: Next, add the web dependency spring-boot-starter-web to your pom.xml.

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

Step 5 : Add the Java version of your project.

 <properties>  
    <java.version>1.8</java.version>  
</properties> 

Step 6: Remember that you need to update your Maven project every time you add a new dependency.

Step 7: Create a Java class in the src/main/java package to make your Maven project executable.

Step 8: Next, call the static run method of your Spring application’s class.

Step 9: Finally, run the class as a Java application.

What are the advantages of Spring Boot over Spring?

• Spring Boot’s bootstrapping feature, which uses boot initializers to compile source languages ​​(a technique known as bootstrapping), saves space on users’ devices and reduces application load times.
• Unlike Spring, Spring Boot allows you to manage dependencies after adding spring-boot-dependency without depending on the parent POM (parent object model) or XML file.
• Spring Boot also allows developers to use annotations or XML configuration instead of using XML configuration.
• Developers prefer Spring Boot because it requires less boilerplate code to set up an application. This is because Spring Boot comes with an in-memory database and built-in Tomcat server, reducing boilerplate code. Spring, on the other hand, has more boilerplate code.
• Spring Boot does not necessarily require WAR (Web Application Resources) files, it can only rely on JARs (Java Resources). JARs (Java resources) are more convenient for users and developers because they have a smaller and simpler structure.
• Spring Boot also automatically includes servers such as Tomcat and Jetty. Therefore, developers do not have to manually set up a server as they would do with Spring.

How do I do pagination with Spring Boot?

The pagination process divides data into sections to save resources. This requires two fields: page size and page number.

This process includes several steps:

Step 1: Initial setup
To configure the entity, name it “Person” as the domain class.

 @Entity 
public class Person {
    @Id
    private long id;
    private String name; 
}

Step 2: Create a repository
Next, use PagingAndSortingRepository extends PersonRepository so that you can get findAll(Pageable pageable ) and findAll(Sort sort) methods for paging and sorting, respectively.

 public interface PersonRepository extends PagingAndSortingRepository<Person, Integer> {
    List<Product> findAllByPrice(double price, Pageable pageable);
}

Step 3: Pagination step
The first step here involves creating a PageRequest object. Implement the Pageable interface by passing the page number and page size on request.

 Pageable firstPageWithTwoElements = PageRequest.of(0,2);
Pageable secondPageWithThreeElements = PageRequest.of(1,3);

Then pass this PageRequest object as a parameter to the repository method.

 Page<Person> allProducts = personRepository.findAllByPrice(findPageWithTwoElements);
List<Items> allTwoDollarItems = itemsRepository.findAllByPrice(2, secondPageThreeElements) 

By default, findAll(Pageable pageable) method returns Page<T> objects.

Describe how to register a custom autoconfiguration

@EnableAutoConfiguration key Specify the fully qualified name under the META-INF/spring.factories file. In this step, you will register the autoconfiguration class.

 org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.baeldung.autoconfigure.CustomAutoConfiguration

To build your project using Maven, you need to place the files in the resource/META-INF directory.

What is bootstrapping in Spring Boot?

Bootstrapping is the process that executes logic when a Spring Boot application starts.
BootInitializr compiles source languages ​​with Spring Boot. This process saves space on your device and also reduces application loading time.

Last words 👨‍💻

Well, in this article, we have discussed the Spring Boot questions that your interviewer will probably ask during the interview and the answers that will help you pass the interview with confidence. I hope you get that dream job!

You can also learn some relevant tips from the questions asked during Java interviews.

Good luck! 🙂