Question

I’m trying to change some legacy code to use DI with Spring framework. I have a concrete case for which I’m wondering which is the most proper way to implement it.

It is a java desktop application. There is a DataManager interface used to query / change data from the data store. Currently there is only one implementation using a XML file for store, but in the future it is possible to add SQL implementation. Also for unit testing I may need to mock it.

Currently every peace of code that needs the data manager retrieves it by using a factory. Here is the source code of the factory:

public class DataManagerFactory   
{  
    private static DataManagerIfc dataManager;

    public static DataManagerIfc getInstance()
    {
        // Let assume synchronization is not needed
        if(dataManager == null)
            dataManager = new XMLFileDataManager();

        return dataManager;
    }
}

Now I see 3 ways to change the application to use DI and Spring.

I. Inject the dependency only in the factory and do not change any other code.

Here is the new code:

public class DataManagerFactory  
{
    private DataManagerIfc dataManager;

    public DataManagerFactory(DataManagerIfc dataManager)
    {
        this.dataManager = dataManager;
    }

    public DataManagerIfc getDataManager()
    {
        return dataManager;
    }

    public static DataManagerIfc getInstance()
    {
        return getFactoryInstance().getDataManager();
    }

    public static DataManagerFactory getFactoryInstance()
    {
        ApplicationContext context =
                    new ClassPathXmlApplicationContext(new String[] {"com/mypackage/SpringConfig.xml"});

        return context.getBean(DataManagerFactory.class);
    }
}

And the XML with the bean description:

<bean id="dataManagerFactory"
            class="com.mypackage.DataManagerFactory">
    <constructor-arg ref="xmlFileDataManager"/>
</bean>

<bean id="xmlFileDataManager"
    class="com.mypackage.datamanagers.xmlfiledatamanager.XMLFileDataManager">
</bean>

II. Change every class that is using the data manager so it takes it through the constructor and store it as a class variable. Make Spring bean definitions only for the “root” classes from where the chain of creation starts.

III. Same as II. but for every class that is using the data manager create a Spring bean definition and instantiate every such class by using the Spring Ioc container.

As I’m new to the DI concept, I will appreciate every advice what will be the correct and “best practice” solution.
Many thanks in advance.

Answer 1

Use option 3.

The first option keeps your code untestable. You won’t be able to easily mock the static factory method so that it returns a mock DataManager.

The second option will force you to have the root classes know all the dependencies of all the non-root classes in order to make the code testable.

The third option really uses dependency injection, where each bean only know about its direct dependencies, and is injected by the DI container.