What is XML Configuration in Spring?

XML Configuration in Spring is a traditional way of configuring Spring applications using XML files to define beans, dependencies, and application settings.

Before annotations and Java-Based Configuration became popular, XML configuration was the primary method used in Spring Framework applications.

In XML Configuration:

• Beans are defined inside XML files
• Dependencies are configured using XML tags
• Spring reads XML metadata during startup
• Spring creates and manages beans automatically

XML Configuration is used in:

• Spring Framework
• Legacy Enterprise Applications
• Large XML-based Systems
• Older Banking Applications
• Traditional Java EE Systems

Simple Definition

XML Configuration means configuring Spring beans and dependencies using XML files instead of Java code or annotations.

Why XML Configuration Was Introduced

Early enterprise Java applications needed:

• Centralized configuration management
• Loose coupling between components
• Dependency Injection support
• Externalized configuration

XML Configuration solved these problems by separating configuration from Java business logic.

Real-Time Banking Example

Consider a banking application containing:

• Payment Service
• Notification Service
• Loan Service
• Fraud Detection Service

Instead of manually creating objects:

NotificationService notificationService =
    new NotificationService();

PaymentService paymentService =
    new PaymentService(notificationService);
    

XML configuration allows Spring to:

• Create objects automatically
• Inject dependencies
• Manage lifecycle
• Centralize configuration

How XML Configuration Works Internally

Application Starts
      |
Spring Reads XML File
      |
Bean Definitions Loaded
      |
Beans Created
      |
Dependencies Injected
      |
Application Ready
    

Main XML Configuration File

Spring configuration is usually stored inside:

beans.xml
    

Basic XML Configuration Structure

<beans xmlns=
"http://www.springframework.org/schema/beans"
xmlns:xsi=
"http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation=
"http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/
spring-beans.xsd">

</beans>
    

Defining a Bean in XML

Example

<bean id="notificationService"
class="com.bank.NotificationService">
</bean>
    

Here:

• id = Bean name
• class = Fully qualified Java class name

Spring creates this bean automatically.

Another Bean Example

<bean id="paymentService"
class="com.bank.PaymentService">
</bean>
    

Dependency Injection Using XML

Spring supports dependency injection through XML configuration.

Constructor Injection Example

<bean id="notificationService"
class="com.bank.NotificationService">
</bean>

<bean id="paymentService"
class="com.bank.PaymentService">

    <constructor-arg
    ref="notificationService"/>

</bean>
    

Spring injects NotificationService into PaymentService.

Setter Injection Example

<bean id="paymentService"
class="com.bank.PaymentService">

    <property
    name="notificationService"
    ref="notificationService"/>

</bean>
    

Spring calls setter methods automatically.

Loading XML Configuration

Spring loads XML configuration using ApplicationContext.

Example

ApplicationContext context =
new ClassPathXmlApplicationContext(
    "beans.xml"
);
    

Retrieving Beans from XML Configuration

PaymentService paymentService =
context.getBean(
    "paymentService",
    PaymentService.class
);
    

Complete XML Configuration Example

<beans xmlns=
"http://www.springframework.org/schema/beans"
xmlns:xsi=
"http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation=
"http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/
spring-beans.xsd">

<bean id="notificationService"
class="com.bank.NotificationService"/>

<bean id="paymentService"
class="com.bank.PaymentService">

    <constructor-arg
    ref="notificationService"/>

</bean>

</beans>
    

Bean Scope in XML Configuration

Bean scope can also be defined in XML.

Singleton Scope

<bean id="paymentService"
class="com.bank.PaymentService"
scope="singleton"/>
    

Prototype Scope

<bean id="reportService"
class="com.bank.ReportService"
scope="prototype"/>
    

Bean Lifecycle Methods in XML

XML configuration supports lifecycle callbacks.

Example

<bean id="paymentService"
class="com.bank.PaymentService"

init-method="init"
destroy-method="cleanup"/>
    

Advantages of XML Configuration

• Centralized configuration
• Configuration separated from business logic
• No source code modification required
• Useful for legacy systems
• Easy external configuration management

1. Centralized Configuration

All bean definitions exist in one centralized location.

2. Separation of Concerns

Business logic remains separate from configuration details.

3. No Source Code Modification

Configuration changes can happen without modifying Java classes.

4. Useful for Legacy Enterprise Systems

Many older enterprise systems still rely heavily on XML configuration.

Disadvantages of XML Configuration

• Large XML files become difficult to maintain
• Verbose syntax
• No compile-time type safety
• Limited IDE support
• Difficult refactoring

1. Verbose Configuration

XML files become very large in enterprise applications.

2. Difficult Maintenance

Managing thousands of XML lines becomes complex.

3. No Type Safety

Errors appear only during runtime.

4. Poor Refactoring Support

Renaming classes manually inside XML files is error-prone.

XML Configuration vs Java-Based Configuration

XML Configuration in Spring Boot

Spring Boot mainly prefers:

• Java-Based Configuration
• Annotation-Based Configuration

However, Spring Boot still supports XML configuration for:

• Legacy system integration
• Migration projects
• Older enterprise applications

XML Configuration in Microservices

Modern microservices architectures rarely use XML configuration because:

• Java-Based Configuration is easier
• Cloud-native systems require flexibility
• Annotation-based configuration reduces complexity

However, older enterprise microservices may still use XML configurations.

Microservices Banking Example

Payment Service XML
      |
Database XML
      |
Security XML
      |
Messaging XML
    

Legacy banking applications may still manage configurations through XML files.

Common XML Tags in Spring

• <bean>
• <property>
• <constructor-arg>
• <context:component-scan>
• <context:property-placeholder>

Real-World Enterprise Use Cases

• Legacy banking systems
• Older enterprise ERP systems
• Traditional Java EE applications
• Large XML-based enterprise platforms
• Migration projects

Common Interview Questions

What is XML Configuration in Spring?

XML Configuration is a method of configuring Spring beans and dependencies using XML files.

Which XML tag defines a bean?

The <bean> tag defines a Spring Bean in XML configuration.

Why is XML configuration less popular today?

XML configuration becomes difficult to maintain in large applications, while Java-Based Configuration provides better readability, type safety, and IDE support.

Professional Interview Answer

XML Configuration in Spring is a traditional configuration mechanism where beans, dependencies, and application settings are defined using XML files. Spring IoC container reads XML metadata during startup, creates beans, injects dependencies, and manages bean lifecycle automatically. XML configuration was widely used in early enterprise Spring applications, but modern applications generally prefer Java-Based Configuration and annotations because they provide better maintainability, readability, and type safety.

Conclusion

XML Configuration was one of the foundational configuration mechanisms in the Spring Framework and played a major role in enterprise Java application development.

It enabled centralized configuration management, Dependency Injection, and loose coupling for large enterprise systems.

Although modern Spring Boot and microservices applications mostly prefer Java-Based Configuration and annotations, XML Configuration is still important for understanding legacy systems, enterprise migrations, and traditional Spring applications.

Understanding XML Configuration is essential for Java developers, Spring developers, backend engineers, and software architects preparing for interviews and working with enterprise-grade applications.