Spring Boot Interview Questions

Auto-configuration in Spring Boot is a powerful feature that automatically configures Spring applications based on the dependencies present on the classpath. It aims to simplify the setup of Spring applications by reducing the amount of boilerplate code and configuration required to get started. This feature allows developers to focus more on writing business logic rather than dealing with complex configuration settings.

Key Concepts of Auto-Configuration

1. Conditional Configuration:

   • Auto-configuration is driven by a set of conditional annotations, such as @ConditionalOnClass, @ConditionalOnMissingBean, and @ConditionalOnProperty. These annotations ensure that configuration is only applied when certain conditions are met.

2. Default Configurations:

   • Spring Boot provides sensible defaults for many configurations. If the defaults are acceptable, no additional configuration is needed. If customization is required, these defaults can be overridden.

3. Enable Auto-Configuration:

   • Auto-configuration is enabled using the @EnableAutoConfiguration annotation or, more commonly, the @SpringBootApplication annotation, which implicitly includes @EnableAutoConfiguration.

4. Auto-Configuration Classes:

   • Auto-configuration classes are located in the META-INF/spring.factories file in the Spring Boot JARs. This file lists all the auto-configuration classes that Spring Boot should consider.

How Auto-Configuration Works

1. Classpath Detection:

   • Spring Boot scans the classpath for dependencies. For example, if it detects spring-webmvc on the classpath, it assumes you are building a web application and configures Spring MVC.

2. Conditional Beans:

   • Auto-configuration classes use conditional annotations to determine whether specific beans should be created. For example, a data source is only configured if a data source is not already defined.

3. Default Settings:

   • Auto-configuration classes provide default settings and configurations. Developers can override these defaults by defining their own beans or by using properties in application.properties or application.yml.

4. Customization:

   • Developers can customize the auto-configuration using properties or by defining their own configuration classes and beans. For example, the spring.datasource.url property can be used to configure a data source.

Example: Auto-Configuration in Action

Step 1: Adding Dependencies

Add the necessary dependencies to your pom.xml file:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

Step 2: Creating the Main Application Class

Create the main application class annotated with @SpringBootApplication:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

Step 3: Defining a Repository and Entity

Define a JPA entity and a Spring Data JPA repository:

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    // Getters and setters
}

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

Step 4: Running the Application

Run the application. Spring Boot auto-configures the necessary components:

• A web server (Tomcat) is configured and started.
• Spring MVC is configured.
• A data source is configured using the H2 database.
• Spring Data JPA is configured, and the UserRepository is ready to be used.

Customizing Auto-Configuration

Using Properties

Customize the data source configuration using properties in application.properties:

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.username=sa
spring.datasource.password=password
spring.datasource.driverClassName=org.h2.Driver
spring.jpa.hibernate.ddl-auto=update

Defining Custom Beans

You can also define custom beans to override the auto-configuration:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
import org.springframework.boot.jdbc.DataSourceBuilder;

@Configuration
public class CustomDataSourceConfig {
    @Bean
    public DataSource dataSource() {
        return DataSourceBuilder.create()
            .url("jdbc:h2:mem:customdb")
            .username("customuser")
            .password("custompassword")
            .driverClassName("org.h2.Driver")
            .build();
    }
}

Summary

• Auto-Configuration: Automatically configures Spring applications based on the classpath dependencies and certain conditions.
• Conditional Configuration: Uses conditional annotations to apply configurations only when specific conditions are met.
• Default Configurations: Provides sensible defaults that can be customized.
• Customization: Allows customization through properties or by defining custom beans and configuration classes.
• Enable Auto-Configuration: Enabled using the @EnableAutoConfiguration or @SpringBootApplication annotations.

Auto-configuration in Spring Boot significantly reduces the need for manual configuration, making it easier and faster to develop Spring applications while still providing the flexibility to customize configurations as needed.