Requesting item from Factory without hard-coding every case

Question

I have an interface called Command:

public interface Command {
// irrelevant code
}

And about 15 classes that implement this interface:

public class Comm_A implements Command {
// irrelevant code
}

public class Comm_B implements Command {...}
....
public class Comm_XZ implements Command {...}

And the factory which should take a String and return an instance of the corresponding command:

public class CommandFactory {
    public static Command getCommand(String s) {
        if (s.equals("Comm_A")) return new Comm_A();
        else ... // each particular case
    }
}

Consider that I want to be able to add new Commands without changing the factory code.

Can I make it to automatically try and create the corresponding instance WITHOUT hard-coding each "Comm_A"..."Comm_XZ" case and WITHOUT using java.lang.reflect?

Can you call 'getCommand()' with a class instead of a String? — Florian, Nov 25 '15 at 13:48
No, the string is read from a JTextPane and manually entered. — Antti Degl, Nov 25 '15 at 13:49
Why don't you want to use reflect? While I agree that it is usually wise to stay away of it while you do not need it (and avoid "clever" tricks), this use case is perfect for it. — SJuan76, Nov 25 '15 at 13:51

score 1 · Accepted Answer · answered Nov 25 '15 at 13:49

1

generate the fully qualified name (package.class) and call

Class<?> myClass = Class.forName(className);

Then call

myClass.newInstance();

answered Nov 25 '15 at 13:49

Shloim

5,281
21
36

He asked without reflection. – Kayaman Nov 25 '15 at 13:50
I was curious if there is any other way except reflection, but if not I can use that. Thank you! – Antti Degl Nov 25 '15 at 13:52
1

Class.forName is not part of java.lang.reflect. – Shloim Nov 25 '15 at 13:53
Any other way will get you the same result, only now you'll have a parallel "reflection" module that was less debugged than Class.forName – Shloim Nov 25 '15 at 13:53

Jiri Tousek · Answer 2 · 2015-11-25T14:11:53.283

If your commands are stateless, thread-safe objects, you can create a map of eagerly-created instances and use these instances repeatedly:

public class CommandFactory {
    private final Map<String, Command> availableCommands;

    public CommandFactory(Map<String, Command> availableCommands) {
        this.availableCommands = availableCommands;
    }

    public Command getCommand(String s) {
        if (availableCommands.contains(s) {
            return availableCommands.get(s);
        } else {
            // handle error state
        }
    }
}

For this to be any good (and fulfill the "no changes to the class" requirement) however the factory would not be a static class, with instance (rather than static) getCommand() method. The available commands then can be injected using a DI framework.

If you need to create a new instance of the Command implementation for each call, then you cannot really avoid reflection without using the terrible if...else if chain. I wouldn't be too worried about using it in this case though, Class.newInstance() is quite readable and not terribly inefficient.

I would still stick with that map approach though even for this, to make it flexible and extendable by configuration. The code would be similar just with Map<String, Class>, return availableCommands.get(s).newInstance() and some more exception checking.

A third possible approach is creating a separate factory class for each command type, and having a Map<String, SpecificCommandFactory>, where you'd query for the appropriate factory and then use that factory to get a new instance of that specific command class - but this is a lot of boilerplate code and can be quite unreadable, so is only suitable if you really need to separate the commands available from the factory:

public iterface SpecificCommandFactory {
    Command createCommand();
}

public class Comm_AFactory implements SpecificCommandFactory {
    public Comm_A createCommand() {
        return new Comm_A();
    }
}

public class CommandFactory {
    private final Map<String, SpecificCommandFactory> availableCommands;

    public CommandFactory(Map<String, Command> availableCommands) {
        this.availableCommands = availableCommands;
    }

    public Command getCommand(String s) {
        if (availableCommands.contains(s) {
            return availableCommands.get(s).createCommand();
        } else {
            // handle error state
        }
    }
}

That would give you one object per class type, instead of a new object each time. — Shloim, Nov 25 '15 at 13:56
You could also have `Map` to construct a new object each time — Stewart, Nov 25 '15 at 13:57
Yeah, but if you do that, then how are you better than `Class.forName`? — Shloim, Nov 25 '15 at 13:59
@Shloim yes, that's true, it can only be used if that's not a problem - which is why I wrote "If your commands are stateless, thread-safe objects..." — Jiri Tousek, Nov 25 '15 at 14:00

score 0 · Answer 3 · edited Nov 25 '15 at 14:19

You could use some sort of delegating factory for this. Instead of holding references to the objects in a map (as in Jiri Tousek's answer) you could hold factories for the different commands:

public class CommandFactory{
    private static final Map<String, Callable<Command>> commands = new HashMap<>();
    public static void registerCommand(String command, Callable<Command> factory){
        commands.put(command, factory);
    }
    public static Command getCommand(String command){
        Callable<Command> factory = commands.get(command);
        if(factory != null){
            return factory.call();
        }
        return null;
    }
}

Requesting item from Factory without hard-coding every case

3 Answers3