Spring - BeanFactory

Spring BeanFactory is the simplest container in the Spring framework that manages the creation and lifecycle of beans using dependency injection. It loads bean definitions and their dependencies at runtime based on configuration metadata. It acts as the basic IoC container and is the parent of ApplicationContext.

• Instantiates, configures, and manages beans using XML or Java-based configuration.
• Supports lazy loading of beans, creating them only when requested.
• Does not support advanced features like annotation-based configuration (unlike ApplicationContext).

BeanFactory Interface classes Hierarchy

Hierarchy of spring container and its implementation showing the relationship between BeanFactory , ApplicationContext and various XML and Annotation-based context classes.

Some common methods Of BeanFactory

Let us first go through some of the methods of Bean Factory before landing up on implementation which are shown below in tabular format:

Procedure

• First, create a Spring project using Spring Initializr
• Create a POJO class.
• Configure the Student bean in the bean-factory-demo.xml file.
• Then write it to application class.

Project Structure

After creating all packages and classes, the project structure will look like below:

Steps to Configure Bean Factory in Spring

Follow these steps to configure and initialize the Spring BeanFactory in your application.

Step 1: Create a Student POJO class.

Defines the Student class as a POJO that will be managed as a Spring bean.

Student.java:

// Java Program where we are
// creating a POJO class

// POJO class
public class Student {

  // Member variables
  private String name;
  private String age;

  // Constructor 1
  public Student() {
  }

  // Constructor 2
  public Student(String name, String age) {
    this.name = name;
    this.age = age;
  }

  // Method inside POJO class
  @Override
  public String toString() {

    // Print student class attributes
    return "Student{" + "name='" + name + '\'' + ", age='" + age + '\'' + '}';
  }
}

Step 2: Configure the Student bean in the bean-factory-demo.xml file.

Configures the Student bean in the XML file so the BeanFactory knows how to create it.

XML Bean Configuration:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans/"
        xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans/
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="student" class="com.gfg.demo.domain.Student">
        <constructor-arg name="name" value="Tina"/>
        <constructor-arg name="age" value="21"/>
    </bean>
</beans>

Step 3: Now let's write the main class file.

Loads the BeanFactory and retrieves the Student bean from the container.

@SpringBootApplication
// Main class
public class DemoApplication 
{
// Main driver method
  public static void main(String[] args) 
  {
    // Creating object in a spring container (Beans)
    BeanFactory factory = new ClassPathXmlApplicationContext("bean-factory-demo.xml");
    Student student = (Student) factory.getBean("student");

    System.out.println(student);
  }
}

Output:

Explanation: The console output shows that the Student bean was successfully created by the BeanFactory and its values (name = Tina, age = 21) were correctly retrieved and displayed.

Note: XmlBeanFactory class is deprecated. 

Let's understand the above code with visuals:

The program flow is something like this:

• First of all, the Bean factory reads the XML configuration file and as per the specifications defined in it, it creates the bean of the student POJO.
• Then the student reference asks for the student object from the object factory.
• Then finally, the spring object factory hands over the spring bean (student) to its reference. Here, note that the bean returned by the object factory is of "Object" type, so we have to typecast it into our desired bean.

BeanFactory vs ApplicationContext