Best Pattern to create Global Objects in Java

Question

My application requires access to certain Objects throughout the application. These objects are populated through the DB.

I would like to populate the objects on server startup , and then in the application on a need -to -do basis.

What is the best pattern to implement this, i have read about the Registry pattern, but not sure that is exactly what i want.

I am also using Spring 3.x in my application , is there something in Spring that can help me?

Answer 1

Since you say you are using Spring. The best solution is to use FactoryBean. What this class allows you to do is create a bean of whatever type you like and return it to the Spring context. Spring will manage this bean and expose it to other beans by making it a singleton. An example:

public class MyObjectFooFactoryBean extends SimpleJdbcDaoSupport implements FactoryBean<ObjectFoo> {
    private String query;

    @Override
    public String getObject() throws Exception {
        return an ObjectFoo here using SimpleJdbSupport (Because I also extended SimpleJdbcDaoSupport)
    }

    @Override
    public Class<?> getObjectType() {
        return ObjectFoo.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

Above does two things. 1) Extends SimpleJdbcSupport which allows you to have access to the databse, and 2) Implements FactoryBean which returns the object to Spring's context. After this is done, you can @Autowire it or use it in the xml file.

Answer 2

Are you sure your application really requires that?

Global objects are artifacts from the past of programming, they shouldn't exist anymore in a proper object-oriented environment, and are usually considered an anti-pattern. Surely you don't need to access these objects everywhere. Why don't you just inject them in the classes that need them? If you use Spring, that's even easier, only have to declare the dependency in the context.

If there are many of these objects that you need, you could wrap them all in one holder class, that you inject as needed.