I agree with you completely about servlets, which is why I imagine almost every java web framework in existence replaces them with something else. The reason I mentioned them is only because the post refers to them directly:

“At run-time an HTTP request comes in. The servlet has a reference to RequestFactory and calls build().”

It glosses over how the servlet gets the reference to the RequestFactory. I only mention this because if someone comes to this post and is learning why they shouldn’t use singletons for everything, they will get stuck wondering how to jump through that final hoop.

Now, while I personally don’t like using servlets, there is a way to give them a dynamic context by using an synchronized initialization servlet that puts an Application instance into the ServletContext. This Application object would hold / provide all of the application necessary configurable objects (offline queue, authenticator, requestFactory, etc).

For testing, the instance of the Application object can be changed with a different class that provides a different implementation, so you would have your TestApplication instance to replace your ProductionApplication instance.

This still doesn’t make code that is embedded inside servlets easy to unit test though, since you still need the servlet container.

I have never used the design I have just mentioned, so I am not sure if it has serious problems or not, but it would be easier to refactor to if someone is migrating an existing Servlet based application (easy enough that it seems like a free way to remove singleton dependencies that would be easier than replacing an existing apps use of servlets all together).

you may look at http://misko.hevery.com/2009/04/08/how-to-do-everything-wrong-with-servlets/ to see why servlets are a problem.

For clarity’s sake you should indicate this, since you cannot create the servlet via a modified constructor that takes a RequestFactory object. So the overriding design principal, as stated, is broken at this one point in favor of a simpler approach.

Your main should look like this:

class Main {
public static void main(String…args) {
AppFactory factory = new AppFactory(args);
MyApp app = factory.create();
app.run();
}
}

Notice how the code is broken to three phases. Create factory, create app, run app. This makes it testable. No matter what your app, you should fallow this pattern. To got singletons to right places the Factory only creates a single instance and then passes that instance to the constructors of all classes as it calls new. See: http://misko.hevery.com/2009/03/30/collaborator-vs-the-factory/