Detailed explanation of how to use XML configuration to define and manage Spring Beans

The Spring framework provides multiple ways to define and manage beans, and XML configuration is one of the traditional and powerful ways. Although more projects now use annotation-based configurations, understanding XML configuration is still very important when understanding how Spring works and dealing with legacy systems. This article will explain in detail how to use XML configuration to define and manage Spring Beans.

1. Spring Bean Overview

In the Spring framework, beans are objects managed by Spring IoC (Control Inversion) containers. Spring containers are responsible for creating instances of beans and managing their life cycles and dependencies. The definition of a bean includes its class, constructor, attribute, initialization method, and destroy method.

2. XML configuration file

XML configuration files are the traditional bean configuration method in Spring, defining XML elements to describe beans and their dependencies. Usually, the XML configuration file is namedand placed insrc/main/resourcesIn the directory.

1. Definition of Bean

A typical bean definition includesid、classand optional attributes and constructor parameters.

&lt;beans xmlns="/schema/beans"
       xmlns:xsi="http:///2001/XMLSchema-instance"
       xsi:schemaLocation="/schema/beans
                           /schema/beans/"&gt;

    &lt;!-- Define a simple Bean --&gt;
    &lt;bean  class=""&gt;
        &lt;!-- Attribute injection --&gt;
        &lt;property name="propertyName" value="propertyValue"/&gt;
    &lt;/bean&gt;
&lt;/beans&gt;

2. Attribute injection

Can be passedpropertyThe element injects attribute value to the Bean.

<bean  class="">
    <property name="name" value="John Doe"/>
    <property name="age" value="30"/>
</bean>

3. Constructor injection

Can be passedconstructor-argThe element injects constructor parameters to the bean.

<bean  class="">
    <constructor-arg value="123 Main St"/>
    <constructor-arg value="Springfield"/>
</bean>

4. Quote other beans

Can be passedrefAttributes refer to other beans.

<bean  class="">
    <property name="name" value="Example Inc."/>
    <property name="address" ref="address"/>
</bean>

5. Collection Injection

Spring allows the injection of collection types into beans through XML configuration, including lists, sets, maps, and properties.

<bean  class="">
    <property name="employees">
        <list>
            <value>John Doe</value>
            <value>Jane Doe</value>
        </list>
    </property>
</bean>

3. Sample project structure

A typical project structure is as follows:

my-spring-xml-project/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── project/
│   │   │               ├── 
│   │   │               ├── 
│   │   │               ├── 
│   │   │               └── 
│   │   └── resources/
│   │       └── 
└──

1. Java class definition

// 
package ;

public class Address {
    private String street;
    private String city;

    public Address(String street, String city) {
         = street;
         = city;
    }

    // Getters and setters
}

// 
package ;

public class Person {
    private String name;
    private int age;

    // Getters and setters
}

// 
package ;

public class Company {
    private String name;
    private Address address;

    // Getters and setters
}

// 
package ;

import ;

public class Department {
    private List<String> employees;

    // Getters and setters
}

2. XML configuration file

<!--  -->
<beans xmlns="/schema/beans"
       xmlns:xsi="http:///2001/XMLSchema-instance"
       xsi:schemaLocation="/schema/beans
                           /schema/beans/">

    <!-- Address Bean -->
    <bean  class="">
        <constructor-arg value="123 Main St"/>
        <constructor-arg value="Springfield"/>
    </bean>

    <!-- Person Bean -->
    <bean  class="">
        <property name="name" value="John Doe"/>
        <property name="age" value="30"/>
    </bean>

    <!-- Company Bean -->
    <bean  class="">
        <property name="name" value="Example Inc."/>
        <property name="address" ref="address"/>
    </bean>

    <!-- Department Bean -->
    <bean  class="">
        <property name="employees">
            <list>
                <value>John Doe</value>
                <value>Jane Doe</value>
            </list>
        </property>
    </bean>
</beans>

4. Load Spring configuration file

In Java code, you can useClassPathXmlApplicationContextTo load the XML configuration file and get the bean.

Example

import ;
import ;

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("");

        Address address = (Address) ("address");
        ("Address: " + () + ", " + ());

        Person person = (Person) ("person");
        ("Person: " + () + ", Age: " + ());

        Company company = (Company) ("company");
        ("Company: " + () + ", Address: " + ().getStreet());

        Department department = (Department) ("department");
        ("Department Employees: " + ());
    }
}

5. Summary

Defining and managing Spring Beans using XML configuration is a traditional but still effective approach. Through XML configuration files, you can clearly define the class, properties, constructor parameters and dependencies of a bean. Although annotation-based configurations are now more popular, XML configurations are still very useful when dealing with legacy systems or requiring strict configuration management.

The above is a detailed explanation of how to use XML configuration to define and manage Spring Beans. For more information about XML definition and management of Spring Beans, please follow my other related articles!