JAVA EE: What is Spring Dependency Injection with static Factory Method?

Wednesday, 18 July 2018

What is Spring Dependency Injection with static Factory Method?

Enjoying This Tutorial?

Subscribe to Ram N Java for high-quality, practical Java and Spring tutorials!

Introduction

In Spring, bean creation is typically handled automatically by invoking class constructors. However, when working with singleton patterns, utility classes, or legacy components where constructor access is restricted (e.g., marked private), you must instantiate objects through static factory methods. Spring supports this seamlessly using the factory-method attribute.

Why Use Static Factory Methods in Spring?

Encapsulated Object Creation: Allows classes with private constructors to be managed directly by the Spring IoC container.
Seamless Integration: Ideal for legacy systems or third-party libraries that use factory creation methods.
Passing Arguments: Spring can pass parameters to the static factory method using standard <constructor-arg> elements if required.

Step-by-Step Configuration Example

Here is an example of creating a bean via a static factory method defined on the class itself:

1. Java Class with Private Constructor & Static Factory Method

package com.ram.service;

public class OrderService {
    private OrderService() {
        // Private constructor
    }

    public static OrderService createInstance() {
        return new OrderService();
    }

    public void serve() {
        System.out.println("Order service executed successfully.");
    }
}

2. Configuring the Bean in applicationContext.xml

Use the class attribute to specify the class name and factory-method to specify the static method to call:

<bean id="orderService" 
      class="com.ram.service.OrderService" 
      factory-method="createInstance" />

3. Loading and Using the Bean

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

OrderService service = (OrderService) context.getBean("orderService");
service.serve();

Key Takeaway

When factory-method is defined alongside class, Spring delegates object creation to that static method instead of calling a public constructor. This provides complete flexibility for legacy architecture patterns and factory implementations.

Recommended Factory & Configuration Tutorials from Ram N Java

Click here to watch on Youtube:
https://www.youtube.com/watch?v=t8r-Xikrf6Y&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge:

What is Spring Dependency Injection with static Factory Method?

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0%20http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ram.core</groupId>

    <artifactId>SpringDemo</artifactId>

    <packaging>jar</packaging>

    <version>1.0-SNAPSHOT</version>

    <name>SpringDemo</name>

    <url>http://maven.apache.org</url>

    <properties>

        <spring.version>5.0.2.RELEASE</spring.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>3.8.1</version>

            <scope>test</scope>

        </dependency>

        <!-- Spring 5 dependencies -->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-core</artifactId>

            <version>${spring.version}</version>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context</artifactId>

            <version>${spring.version}</version>

        </dependency>

    </dependencies>

</project>

Employee.java

package com.ram.model;

/*

 * This class is a singleton class

 */

public class Employee

{

    private String name;

    private int age;

    private static Employee employee = null;

    private Employee()

    {

        name = "Peter";

        age = 42;

    }

    public static Employee getEmployee()

    {

        System.out.println("getEmployee() factory method "

                + "is called by the spring container ");

        if (employee == null)

        {

            employee = new Employee();

        }

        return employee;

    }

    public void displayEmployeeDetails()

    {

        System.out.println("Employee [name=" + name + ", age=" + age + "]");

    }

}

applicationContext.xml

<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-4.3.xsd">

    <bean id="employee" class="com.ram.model.Employee" factory-method="getEmployee">

    </bean>

</beans>

App.java

package com.ram.core;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ram.model.Employee;

public class App

{

    public static void main(String[] args)

    {

        ApplicationContext context = new ClassPathXmlApplicationContext(

                "applicationContext.xml");

        System.out.println("---------------------------------------");

        Employee employee = (Employee) context.getBean("employee");

        System.out.println(

                "Got employee object from the ApplicationContext[Spring Container]");

        employee.displayEmployeeDetails();

    }

}

Output

<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-4.3.xsd">

    <bean id="address" class="com.ram.model.Address" >

        <constructor-arg value="Chennai"></constructor-arg>

        <constructor-arg value="Tamil Nadu"></constructor-arg>

        <constructor-arg value="India"></constructor-arg>

    </bean>

    <bean id="employee" class="com.ram.model.Employee" autowire="no">

        <constructor-arg value="Peter"></constructor-arg>

    </bean>

</beans>