Abstract Factory Design Java
static {
    factoryMap = new HashMap&lt;String, LoggingFactory&gt;();
}

private static HashMap&lt;String, LoggingFactory&gt; factoryMap;



can be simplified to the following without any changes in functionality:

private static final Map&lt;String, LoggingFactory&gt; factoryMap = new HashMap&lt;&gt;();





public class LoggingInitializer {
    public LoggingInitializer() {
        LoggingFactory.register("ConsoleOutputLogger", new ConsoleOutputLoggingFactory());
        LoggingFactory.register("FileOutputLogger", new FileOutputLoggingFactory());
        LoggingFactory.register("ConsoleErrorLogger", new ConsoleErrorLoggingFactory());
        LoggingFactory.register("FileErrorLogger", new FileErrorLoggingFactory());
    }
}



The initialization of a class only happens in it's initializer blocks. Nowhere else.
What you're doing here is wiring up dependencies. Use  a DI framework for that ...

If you were going to set up the factories this way in the first place, you could've just not have them register themselves. It's weird that they register themselves anyways. That results in the following changes:


LoggerFactory implementations don't need to be derived from LoggingFactory to have access to the factoryMap, only to conform to the getLogger interface.
Actually the getLogger interface is what you'd have in a functional interface in modern Java.  


This results in simplifications to your API. Instead of explicitly constructing factories and using getFactory, you're off much better hiding the implementation detail of Factories and instead using a Facade, like so:

public static final class LoggingFactory {
    private static final Map&lt;String, Supplier&lt;ILogger&gt;&gt; factoryMap = new HashMap&lt;&gt;();
    static {
        ILogger consoleOutLoggerSingleton = new ConsoleOutputLogger();
        factoryMap.put("ConsoleOutputLogger", () -&gt; consoleOutputLoggerSingleton);

        ILogger fileOutputLoggerSingleton = new FileOutputLogger();
        factoryMap.put("FileOutputLogger", () -&gt; fileOutputLoggerSingleton);

        ILogger consoleErrorLoggerSingleton = new ConsoleErrorLogger();
        factoryMap.put("ConsoleErrorLogger", () -&gt; consoleErrorLoggerSingleton);

        ILogger fileErrorLoggerSingleton = new FileErrorLogger();
        factoryMap.put("FileErrorLogger", () -&gt; fileErrorLoggerSingleton);
    }

    public static ILogger getLoggerFor(String name) {
        return factoryMap.getOrDefault(name, () -&gt; new NoOpLogger()).get();
    }
}


This cuts away the "man in the middle" of your factory, not to mention the initialization outside the class. It also is more in line with usual Java logging APIs, where you directly obtain the logger.

In closing you should be aware that reinventing logging is usually a "Bad Idea™". If this hadn't been prefixed, I'd have washed your head for it :)

Finally: Just because there is a factory, the client of you API doesn't need to know- Generally the less indirection your API has, the easier it will be to use. Strive to minimize ways through your API.