Factory pattern with abstractions clarification

Question

I am trying to get clarification around the Factory Pattern as described (with examples) here: http://www.oodesign.com/factory-pattern.html

When I attempt to implement the "class registration without reflection" example I get a null pointer exception. This is the same as has been described here:

factory method pattern with class registration produces a nullpointer exception

I understand why I am getting the null pointer exception (the HashMap is not populated by the time it is being used) and I know that I can fix it by using class.forName in the main or in a static block within the Factory implementation.

But doesn't that defeat the purpose of using this pattern? I thought the idea was that the object being created did the registration - if you are forced to manually load the class to force the static block to run, doesn't this violate the Open Close Principle?

Here is example code:

Main.java

public class Main {
  public static void main(String[] args) {
    Widget widgetA = WidgetFactory.getInstance().createWidget("WidgetA");
    Widget widgetB = WidgetFactory.getInstance().createWidget("WidgetB");

    widgetA.doSomething();
    widgetB.doSomething();
  }
}

Widget.java

public abstract class Widget {
    protected abstract Widget createWidget();
    public abstract void doSomething();
}

WidgetFactory.java

public class WidgetFactory {

    private static WidgetFactory instance;

    public static synchronized WidgetFactory getInstance() {
        if (instance == null) {
            instance = new WidgetFactory();
        }
        return instance;
    }
    private HashMap<String, Widget> widgets = new HashMap<>();

    public void registerWidget(String id, Widget widget) {
        widgets.put(id, widget);
    }

    public Widget createWidget(String id) {
        Widget widget = widgets.get(id).create();
        return widget;
    }
}

WidgetA.java

public class WidgetA extends Widget {

    static {
        WidgetFactory.getInstance().registerWidget("WidgetA", new WidgetA());
    }

    @Override
    protected Widget createWidget() {
        return new WidgetA();
    }

    @Override
    public void doSomething() {
        System.out.println("WidgetA");
    }

}

WidgetB.java

public class WidgetB extends Widget {

    static {
        WidgetFactory.getInstance().registerWidget("WidgetB", new WidgetB());
    }

    @Override
    protected Widget createWidget() {
        return new WidgetB();
    }

    @Override
    public void doSomething() {
        System.out.println("WidgetB");
    }

}

As mentioned earlier, to get it to work I can put this in the Main or the WidgetFactory class:

static {
    try {
        Class.forName(WidgetA.class.getName());
        Class.forName(WidgetB.class.getName());
    } catch (ClassNotFoundException e) {
        e.printStackTrace(System.err);
    }
}

Again, can someone please clarify how this pattern should be implemented or share a technique to make this pattern work without having to update the Main or the WidgetFactory class each time a new Widget subclass is added?

Thank you for your help!

Answer 1

You cannot do this without reflection as the JVM-specification enforces lazy class loading to save resources. There is neither a parameter for the JVM nor a "EagerClassLoader" (which loads all classes of all jar files). See also the answers to this question and this one and this one.

However you can load all classes of ONE package via reflection with this code:

public static void loadAllClassesOfPackage(String packageName) throws IOException, ClassNotFoundException {
        ClassLoader classLoader = Thread.currentThread()
                .getContextClassLoader();
        assert classLoader != null;
        String path = packageName.replace('.', '/');
        Enumeration<URL> resources = classLoader.getResources(path);
        File packageDir = new File(resources.nextElement().getFile());
        for (File file : packageDir.listFiles()) {
            if (file.isFile() && file.getName().endsWith(".class")) {
                Class.forName(packageName
                        + '.'
                        + file.getName().substring(0,
                                file.getName().length() - 6));
            }
        }
    }

As long as you only load the classes of one package with a "reasonable" number of classes, this won't take to much resources.

My sample code was inspired by this sample code which also loads the classes of subpackages as well.

Edit:

I extended my implementation with a branch for directories so that it works recursively.

public static void loadAllClassesOfPackageRecursively(String packageName)
        throws IOException, ClassNotFoundException {
    ClassLoader classLoader = Thread.currentThread()
            .getContextClassLoader();
    assert classLoader != null;
    String path = packageName.replace('.', '/');
    Enumeration<URL> resources = classLoader.getResources(path);
    File packageDir = new File(resources.nextElement().getFile());
    for (File file : packageDir.listFiles()) {
        if (file.isFile() && file.getName().endsWith(".class")) {
            Class.forName(packageName
                    + '.'
                    + file.getName().substring(0,
                            file.getName().length() - 6));
        } else if (file.isDirectory()) {
            loadAllClassesOfPackageRecursively(packageName + '.' + file.getName());
        }
    }
}