Backend interview prep

Start

Spring Java Configuration Interview Questions and Answers

Master Spring Java Configuration with interview questions covering @Configuration, @Bean, @ComponentScan, @Import, @PropertySource, Java Config vs XML, configuration classes, profiles, and production best practices.

Introduction

In the early versions of Spring, applications were configured using large XML files.

Example

<bean id="customerService"

class="com.example.CustomerService"/>

As applications grew larger, XML configuration became difficult to maintain.

Spring introduced Java-based Configuration (Java Config), allowing developers to configure the entire application using Java classes and annotations.

Today, almost every modern Spring Boot application uses Java Configuration.

Common annotations include:

  • @Configuration
  • @Bean
  • @ComponentScan
  • @Import
  • @PropertySource
  • @Profile

Java Configuration Architecture

flowchart LR

Application --> ConfigurationClass

ConfigurationClass --> BeanDefinitions

BeanDefinitions --> SpringContainer

SpringContainer --> ApplicationBeans

Q1. What is Java Configuration?

Answer

Java Configuration is the process of configuring the Spring IoC Container using Java classes instead of XML.

Configuration classes define

  • Beans
  • Component scanning
  • External properties
  • Profiles
  • Imports

Benefits

  • Type safety
  • Better IDE support
  • Easier refactoring
  • Less XML
  • Better readability

Q2. What is @Configuration?

@Configuration indicates that a class contains Spring bean definitions.

Example

@Configuration

public class AppConfig {

}

Spring processes this class during startup and registers all defined beans.

Q3. What is @Bean?

@Bean tells Spring that the returned object should be managed as a Spring Bean.

Example

@Configuration

public class AppConfig {

    @Bean

    public PaymentService paymentService() {

        return new PaymentService();

    }

}

Spring creates the bean and stores it in the IoC Container.

Bean Creation

flowchart LR

ConfigurationClass --> BeanMethod

BeanMethod --> SpringContainer

SpringContainer --> PaymentService

Q4. When should we use @Bean instead of @Component?

Use @Component

  • For classes you own.

Use @Bean

  • For third-party libraries.
  • When object creation requires custom logic.
  • When constructor arguments must be manually configured.

Example

@Bean

public ObjectMapper

objectMapper(){

    return new ObjectMapper();

}

Q5. What is @ComponentScan?

@ComponentScan instructs Spring to scan packages for annotated classes.

Example

@Configuration

@ComponentScan(

"com.codewithvenu")

Spring automatically registers

  • @Component
  • @Service
  • @Repository
  • @Controller
  • @RestController

Component Scan

flowchart LR

ComponentScan --> Controller

ComponentScan --> Service

ComponentScan --> Repository

ComponentScan --> Component

Q6. What is @Import?

@Import combines multiple configuration classes.

Example

@Configuration

@Import({

DatabaseConfig.class,

SecurityConfig.class

})

Benefits

  • Modular configuration
  • Better organization
  • Cleaner architecture

Q7. What is @PropertySource?

@PropertySource loads external property files.

Example

@Configuration

@PropertySource(

"classpath:application.properties")

Properties become available through

  • @Value
  • Environment
  • Configuration classes

Q8. What is @Profile?

@Profile activates beans for specific environments.

Example

@Bean

@Profile("dev")

public DataSource

devDataSource(){

}

Profiles

  • dev
  • test
  • stage
  • prod

Profile Selection

flowchart LR

Application --> Profile

Profile --> DevBean

Profile --> TestBean

Profile --> ProdBean

Only beans matching the active profile are created.

Q9. Java Configuration vs XML Configuration

Java Config XML Config
Type-safe String-based
IDE support Limited
Refactoring support Difficult
Compile-time validation Runtime errors
Modern approach Legacy approach

Java Configuration is the preferred approach for modern Spring applications.

Q10. Java Configuration Best Practices

Organize Configuration

Split large configurations into multiple classes.

Use @Configuration

Avoid mixing configuration with business logic.

Prefer Component Scanning

Reduce manual bean declarations.

Externalize Properties

Avoid hardcoded values.

Use Profiles

Separate development, testing, and production environments.

Banking Example

flowchart TD

AppConfig --> DatabaseConfig

AppConfig --> SecurityConfig

AppConfig --> MessagingConfig

DatabaseConfig --> DataSource

SecurityConfig --> JwtFilter

MessagingConfig --> KafkaProducer

SpringContainer --> CustomerService

Configuration is modular and environment-independent.

Common Interview Questions

  • What is Java Configuration?
  • What is @Configuration?
  • What is @Bean?
  • @Bean vs @Component?
  • What is @ComponentScan?
  • What is @Import?
  • What is @PropertySource?
  • What is @Profile?
  • Java Config vs XML?
  • Java Configuration best practices?

Quick Revision

Topic Summary
Java Config Configure Spring using Java
@Configuration Configuration class
@Bean Register Spring bean
@ComponentScan Scan annotated classes
@Import Import configuration classes
@PropertySource Load property files
@Profile Environment-specific beans
@Value Inject property values
Java Config Preferred approach
XML Legacy configuration

Java Configuration Lifecycle

sequenceDiagram
Application->>Spring Container: Start
Spring Container->>Configuration Class: Load
Configuration Class->>Bean Methods: Execute
Bean Methods-->>Spring Container: Register Beans
Spring Container->>Component Scan: Discover Components
Component Scan-->>Spring Container: Register Components
Spring Container-->>Application: Ready

Production Example – Banking Platform

A banking platform separates configuration into multiple modules.

Configuration Structure

  • DatabaseConfig creates the DataSource and JPA configuration.
  • SecurityConfig configures JWT authentication and security filters.
  • MessagingConfig configures Kafka producers and consumers.
  • CacheConfig configures Redis.
  • ApplicationConfig imports all configuration classes.

Profiles

  • dev uses a local PostgreSQL database.
  • test uses an in-memory database.
  • prod connects to a managed cloud database.
flowchart LR

ApplicationConfig --> DatabaseConfig

ApplicationConfig --> SecurityConfig

ApplicationConfig --> MessagingConfig

ApplicationConfig --> CacheConfig

DatabaseConfig --> PostgreSQL

MessagingConfig --> Kafka

CacheConfig --> Redis

SecurityConfig --> JWTAuthentication

This modular configuration simplifies maintenance, improves readability, and enables different environments to use different infrastructure without changing application code.

Key Takeaways

  • Java Configuration replaces XML by configuring the Spring IoC Container using Java classes and annotations.
  • @Configuration identifies classes that contain Spring bean definitions.
  • @Bean registers objects as Spring-managed beans and is especially useful for third-party libraries or custom object creation.
  • @ComponentScan automatically discovers annotated components, reducing manual configuration.
  • @Import helps organize large applications by combining multiple configuration classes.
  • @PropertySource loads external configuration files, while @Profile enables environment-specific bean creation.
  • Java Configuration provides type safety, compile-time checking, IDE support, and easier refactoring compared to XML.
  • Well-organized configuration classes improve maintainability and support enterprise-scale Spring applications.