Template Method/Singleton with Factory

[Mark Spritzler]

I am putting together an abstract Singelton, that will then have implementing classes. These classes should only need to override one method(Hence the Template Method) so that it all works for the specific implementation type.

So I have this abstract class

 
public abstract class AbstractLookup<K, V> implements Serializable  {
 
    protected HashMap<K, V> data;
    protected static AbstractLookup abstractLookup;
 
    protected AbstractLookup() {
        data = new HashMap<K, V> ();
        loadData();
    }
 
    public static AbstractLookup getInstance() {
        return abstractLookup;
    }
 
    public Map<K, V> getData() {
        return data;
    }    
 
    protected abstract void loadData();
}
 

And here is an implementation class

 
public class DiscountTypeLookup extends AbstractLookup<String, RetailDiscount> {
 
    {
        abstractLookup = new DiscountTypeLookup();
    }
 
    protected void loadData() {        
 
    }
}
 

Forget about the implementation of the loadData method, it is using Hibernate to do a search for me.

But notice the static initializer.

OK, so you might guess what I am trying to do, but I am having no luck. I am just missing something that probably is pretty easy.

I am trying to make a call to getInstance of the object, and it will return the Singleton instance. Now the class that is calling getInstance is doing so through Reflection because that class only knows its type as the abstract class type.

Here is my CacheFactory that will either return an instance of that type that exists in a Map it has, or will create a new one and add it to the Map.

 
public class CacheFactory {
    private Map<Class, AbstractLookup> lookups = new HashMap<Class, AbstractLookup>();
    private static CacheFactory cacheFactory = new CacheFactory();
 
    private CacheFactory() {}
 
    public static CacheFactory getInstance() {
        return cacheFactory;
    }
 
    public AbstractLookup getLookup(Class lookupClass) {
        AbstractLookup lookup = lookups.get(lookupClass);
        if (lookup == null) {
            lookup = loadLookup(lookupClass);
        }
        return lookup;
    }
 
    private AbstractLookup loadLookup(Class lookupClass) {
        AbstractLookup lookup = null;
        try {
            Method method = lookupClass.getMethod("getInstance");
            lookup = (AbstractLookup)method.invoke(null);
            lookups.put(lookupClass, lookup);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();  
        }
        return lookup;
    }
}
 

The problem right now is that the loadLookup method calling the getInstance static method is returning null.

I obviously want to make sure that when you call getInstance on any type of AbstractLookup and there is no instance of that type yet, that it will create one, and call loadData().

What I am oblivious to?

Thanks

Mark

[Karthik Guru]

I dont know if its a typo on your part but I dont see a 'static' block though in DiscountTypeLookup

[B]static[/B]
{        abstractLookup = new DiscountTypeLookup();    }

[Ken Blair]

Even with it changed to a static block it won't work. The problem here is the DefaultLookup class is never loaded, the only method called belongs to AbstractLookup. Even it were loaded there's still a fatal flaw in the design: each new class loaded uses the same static variable.

I believe you'll need to create a registry or make getInstance() abstract and move the static variable to the implementing class.

public abstract class AbstractLookup implements Serializable {
 
    protected AbstractLookup() {
        loadData();
    }
 
    protected abstract void loadData();
 
    public static abstract AbstractLookup getInstance();
}
 
public class DiscountTypeLookup extends AbstractLookup {
 
    private static final DiscountTypeLookup instance = new DiscountTypeLookup();
 
    private DiscountTypeLookup() {
        super();
    }
 
    protected void loadData() {
    }
 
    public static AbstractLookup getInstance() {
        return instance;
    }
}

Or a registry.

public abstract class AbstractLookup implements Serializable {
 
    private static final Map<Class, AbstractLookup> registry = new HashMap<Class, AbstractLookup>();
 
    protected AbstractLookup() {
        loadData();
    }
 
    protected abstract void loadData();
 
    public static AbstractLookup getInstance(Class c) {
        // Check registry for instance for Class, create new if one
        // doesn't exist and add it.
    }
}