Spring Boot Interview Questions & Answers (2024)

10).  How do you create a Spring Boot application using Maven?

There are different approaches to create a Spring Boot application using maven. Here are they:

. Spring Boot CLI

. Spring Starter Project Wizard

. Spring Initializr

. Spring Maven Project

11).  What is the purpose of @Value Annotation in Spring Boot? o how to dynamically read or add value from property file in Spring boot ? 

The purpose of @Value Annotation in Spring Boot is to read the value of the environment or application property in Java code. The following is the syntax for this:

                      @Value(“${property_key_name}”)

12). What is the way to reload changes on Spring boot without server restart?

Any changes are reloaded in spring boot without starting the server by using dev tools.

          <dependency>

          <groupId>org.springframework.boot</groupId>

          <artifactId>spring-boot-devtools</artifactId>

          <optional>true</optional>

         </dependency>

Spring Boot provides a module called DevTools, which can enhance the productivity of a spring boot developer.

It can auto-deploy the changes to the server, with auto-restarting the server.

13). What is thymeleaf and how is it used?

Thymeleaf is a server-side java template engine used for web applications. The main purpose of thymeleaf is to bring natural templates for web applications which integrate well with Spring Framework and HTML5 java web applications. For using thymeleaf the following code must be added in the pom.xml file.

      org.springframework.boot

      spring-boot-starter-thymeleaf

14). What is the Spring Boot Actuator?                                                                                      (Imp Question)

Spring Boot provides the actuator to monitor and manage our application. Actuator contains the HTTP endpoints. When the application is pushed to production then by using HTTP endpoints you can choose to manage and monitor your application.

Example: 

   <dependency>  

    <groupId>org.springframework.boot</groupId>  

    <artifactId>spring-boot-starter-actuator</artifactId>  

    <version>2.2.2.RELEASE</version>  

   </dependency>  

15). What are Spring Boot Profiles and how are they useful?                                                                       (Most Imp Question)

Spring Boot profiles are a way of managing configuration for different environments.

Suppose you might have one profile for development, one profile for testing, and one profile for production. To create a profile, you can create a file with the .profile extension in the config directory of your classpath. 

Example: To create a development profile, you would create a file called development.profile in the config directory.

the following code shows a development profile that configures the database connection URL:

spring.datasource.url=jdbc:postgresql://localhost:5432/my_database

To activate the profile, you can add the –spring.profiles.active=profile-name parameter to the command line when you start your application. For example, to activate the development profile, you would start your application with the following command:

java -jar my-app.jar –spring.profiles.active=development

You can also activate the profile using the environment variable SPRING_PROFILES_ACTIVE.

16). How do you handle exceptions in the Spring boot?                                                            (Most Imp Question)

There are two main ways to handle exceptions in this framework:

Spring Boot Exception Handling: Spring Boot puts forth many options to handle exceptions, such as @ExceptionHandler annotations and global exception handlers.

Spring MVC Exception Handling: Spring MVC provides several ways to handle exceptions in a Spring MVC app, such as ModelAndView objects and ExceptionHandlerExceptionResolver beans. Spring Boot Exception Handling is the recommended way to handle exceptions in application code. It is more flexible and easier to use than Spring MVC Exception Handling.

@ExceptionHandler annotation:  To handle an exception using Spring Boot Exception Handling, you can add this annotation,with a method of your controller class. The method that you annotate with @ExceptionHandler will be executed when an exception of the specified type occurs.

Example: In below we to handle a SQLException using Spring Boot Exception Handling:

      @Controller

      public class MyController {

      @ExceptionHandler(SQLException.class)

      public String handleSQLException(SQLException e) {

         return “error”;

        }

      }

17). How to configure the spring security in spring boot? or What do you know about Spring Boot Security? 

Spring Boot Security is a framework that has a range of features for securing the application. These features include authentication, authorization, and session management.

To configure security for your SpringBoot application, you need to create a WebSecurityConfigurerAdapter class. This class comes with methods to tune up the security of your application.

Example: To configure basic authentication for your SpringBoot application:

     public class MyWebSecurityConfigurerAdapter extends WebSecurityConfigurerAdapter {

     

      @Override

     protected void configure(HttpSecurity http) throws Exception {

         http.authorizeRequests()

          .anyRequest().authenticated()

          .and()

          .httpBasic();

         }

    }

18). How can I change server in spring boot application? or how to change tomcat server by  jetty server in spring boot ?
                                                                                                                                                                                             (Most Imp Question)

You will need to update pom.xml, add the dependency for spring-boot-starter-jetty. Also, you will need to exclude 

default added spring-boot-starter-tomcat dependency.

Example:

     <dependency>

               <groupId>org.springframework.boot</groupId>

                 <artifactId>spring-boot-starter-web</artifactId>

       <exclusions>

              <exclusion>

                 <groupId>org.springframework.boot</groupId>

                  <artifactId>spring-boot-starter-tomcat</artifactId>

              </exclusion>

         </exclusions>

    </dependency>

       //To add jetty dependency

    <dependency>

             <groupId>org.springframework.boot</groupId>

           <artifactId>spring-boot-starter-jetty</artifactId>

    </dependency>

19). How to configure two database or DB in spring boot ?                                                  (Most Imp Question)

In Spring Boot, configuring and using two data sources can be achieved by defining multiple DataSource beans and specifying the appropriate EntityManagerFactory and TransactionManager for each data source. Here’s a step-by-step guide:

Add Dependencies: Ensure that you have the necessary dependencies in your pom.xml or build.gradle file. 

Example: if you’re using Maven:

Add Dependecy in POM file :

<!– Spring Boot Starter Data JPA –>

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-data-jpa</artifactId>

</dependency>

<!– H2 Database (Example) – Replace with your database dependencies –>

<dependency>

    <groupId>com.h2database</groupId>

    <artifactId>h2</artifactId>

    <scope>runtime</scope>

</dependency>

Configure application.properties : Define properties for each data source in your application.properties:

in properties file add both two database 

# First Data Source

spring.datasource.first.url=jdbc:mysql://localhost:3306/firstdb

spring.datasource.first.username=root

spring.datasource.first.password=root

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

# Second Data Source

spring.datasource.second.url=jdbc:mysql://localhost:3306/seconddb

spring.datasource.second.username=root

spring.datasource.second.password=root

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

Adjust the properties according to your database configurations.

Create Configuration Classes: Create two configuration classes, each representing a data source. Annotate them with @Configuration and @EnableTransactionManagement:

java

Copy code

@Configuration

@EnableTransactionManagement

@EnableJpaRepositories(

    basePackages = “com.example.firstdb.repository”,

    entityManagerFactoryRef = “firstEntityManagerFactory”,

    transactionManagerRef = “firstTransactionManager”

)

public class FirstDataSourceConfig {

    // Define first data source beans (DataSource, EntityManagerFactory, TransactionManager)

}

@Configuration

@EnableTransactionManagement

@EnableJpaRepositories(

    basePackages = “com.example.seconddb.repository”,

    entityManagerFactoryRef = “secondEntityManagerFactory”,

    transactionManagerRef = “secondTransactionManager”

)

public class SecondDataSourceConfig {

    // Define second data source beans (DataSource, EntityManagerFactory, TransactionManager)

}

Define Data Source Beans: In each configuration class, define the data source bean, EntityManagerFactory, and TransactionManager:

java

Copy code

@Bean(name = “firstDataSource”)

@ConfigurationProperties(prefix = “spring.datasource.first”)

public DataSource firstDataSource() {

    return DataSourceBuilder.create().build();

}

@Bean(name = “firstEntityManagerFactory”)

public LocalContainerEntityManagerFactoryBean firstEntityManagerFactory(

        EntityManagerFactoryBuilder builder,

        @Qualifier(“firstDataSource”) DataSource dataSource) {

    // Configure first EntityManagerFactory

}

@Bean(name = “firstTransactionManager”)

public PlatformTransactionManager firstTransactionManager(

        @Qualifier(“firstEntityManagerFactory”) EntityManagerFactory entityManagerFactory) {

    // Configure first TransactionManager

}

Repeat the same process for the second data source.

Use Data Sources in Repository Classes: In your repository classes, use the @Qualifier annotation to specify which EntityManager to use:

java

Copy code

@Repository

public class FirstRepository {

    @PersistenceContext(unitName = “firstEntityManagerFactory”)

    private EntityManager entityManager;

    // Your repository methods

}

@Repository

public class SecondRepository {

    @PersistenceContext(unitName = “secondEntityManagerFactory”)

    private EntityManager entityManager;

    // Your repository methods

}

Now, Spring Boot should be configured to use two data sources. Adjust the configurations based on your specific requirements and database choices.

More info on spring boot : spring boot guide