Abstract Factory, Factory Method, Builder

Question

Hello:

It may seem as if this is question is a dupe, but please bear with me - I promise I've read the related posts (and the GOF book).

After everything I've read, I still don't have it clear when to use an Abstract Factory, a Factory Method, or a Builder. I believe it will finally sink in after I see a simple example of a problem which is best approached by, say, a builder and it would be clearly silly to use, say, an abstract factory.

Can you provide a simple example where you would clearly use one pattern and not the others?

I understand it may boil down to a matter of opinion if the example is too simple, but I'm hopeful that if anybody can, that person is in SO.

Thanks.

Answer 1

A builder helps you construct a complex object. The StringBuilder class (Java, C#) is a great example of a builder. You build the final string piece by piece. The other factory patterns don't apply to this scenario.

A factory method gives you a complete object in one shot (as opposed to the builder), you can find a good example in .NET with the WebRequest.Create method. Again, the other patterns don't apply here.

An abstract factory is an interface (or abstract class) to create many different related objects. A good example (again in .NET) is the DbProviderFactory class, that serves to create related objects (connections, commands, ...) to a given database provider (oracle, sql server, ...), depending on its concrete implementation.

Answer 2

The Abstract Factory pattern uses subclassing (of factories) to produce other objects (non-factories). Abstract Factory also envisions that the objects produced belong to parallel hierarchies (e.g. to handle platform independance, one hierarchy for each platform).

The Builder pattern uses subclassing to produce "output" - which is not necessarily objects at all. The GOF example has the Builder producing text output (markup or otherwise).

The Factory Method pattern, unlike the other two, divides the "creator" into an abstract and concrete implementation (thus the emphasis on it belonging to a framework implementation). Like Abstract Factory, it deals with making actual objects.

All three are highly similar, because they all use subclassing. It is the subclassing that is the outstanding quality of them all, which hides the subtle differences (outlined above) and thus many people have difficulty seeing the differences.

Answer 3

Abstract Factory is particularly helpful for test driven development and reducing coupling.

For example, in C#:

public class Worker
{
    public IConsumerFactory Factory { get; set; }

    private IResource resource;

    public DoWork()
    {
        IConsumer consumer = Factory.CreateConsumer();
        consumer.Consume(resource);
    }
}

public interface IConsumerFactory
{
    IConsumer CreateConsumer();
}

public interface IConsumer
{
    void Consume(IResource resource);
}

public class DefaultConsumerFactory : IConsumerFactory
{
    public IConsumer CreateConsumer()
    {
        return new DefaultConsumer();
    }
}

public class DefaultConsumer : IConsumer
{
    public void Consume(IResource resource)
    {
      ... Do Work ...
    }
}

This way, you can use dependency injection to inject the default implementations for production code, and then you can easily mock the factory and the objects it creates.

Answer 4

Builder

// Builder encapsulates construction of other object. Building of the object can be done in multiple steps (methods)
public class ConfigurationBuilder
{
  // Each method adds some configuration part to internally created Configuration object
  void AddDbConfiguration(...);
  void AddSmtpConfiguration(...);
  void AddWebServicesConfiguration(...);
  void AddWebServerConfiguration(...);

  // Returns built configuration
  Configuration GetConfiguration();
}

Factory method

// Factory method is declared in base class or interface. Subclass defines what type is created by factory method.
public interface ICacheProvider
{
  ISession CreateCache(); // Don't have to return new instance each time - such decission is part of implementation in derived class.
}

public class InMemoryCacheProvider : ICacheProvider
{ ... }

public class DbStoredCacheProvider : ICacheProvider
{ ... }

// Client code
ICacheProvider provider = new InMemoryCacheProvider
ICache cache = provider.CreateCache(); 

Abstract Factory

// Abstract factory defines families of platform classes - you don't need to specify each platform class on the client.
public interface IDbPlatform
{
  // It basically defines many factory methods for related classes
  IDbConnection CreateConnection();
  IDbCommand CreateCommand();
  ...
}

// Abstract factory implementation - single class defines whole platform
public class OraclePlatfrom : IDbPlatform
{ ... }

public class MySqlPlatform : IDbPlatform
{ ... }

// Client code:
IDbPlatform platform = new OraclePlatform();
IConnection connection = platform.CreateConnection(); // Automatically Oracle related
...