Create client classes in Abstract Factory

Question

Hi!
Let's we have one of the next classes in AbstractDesign patterns:
1.WindowFactory - abstract factory
2.MotifWindowFactory, MacWindowFactory - concrete factory
3.Window - abstract product
4.MotifWindow, MacWindow - concrete products
5.Client - client class
6.ClientCreator - class that creates our client class
The source code of Client is like this:
public class Client {
private AbstractFactory af = null;
public Client(AbstractFactory af) {
this.af = af;
af.createAbstractProduct();
The code of ClientCreator will be like this:
public class ClientCreator {
Client client = new Client(new MotifWindowFactory());
OK!
But we can have many client classes. And this client classes can create from different places (many ClientCreator classes) in our project.In our project we have:
public class ClientCreator1 {
Client client1 = new Client(new MotifWindowFactory());
public class ClientCreator2 {
Client client2 = new Client(new MotifWindowFactory());
public class ClientCreatorN {
Client clientN = new Client(new MotifWindowFactory());
And what will happen when I need to change concrete factory. I must go to EVERY ClientCreator classe and change code to create client classes with another concrete factory:
public class ClientCreator1 {
Client client1 = new Client(new MacWindowFactory());
public class ClientCreator2 {
Client client2 = new Client(new MacWindowFactory());
public class ClientCreatorN {
Client clientN = new Client(new MacWindowFactory());
I think that this is not flexibility.
Can any tell me what I wrong understand in AbstractFactory pattern?
Thanks.

Answer 1

The code
Client client1 = new Client(new MacWindowFactory());
Client clientN = new Client(new MacWindowFactory());results in the creation of a factory for each client. This is unnecessary. Typically, you'd use a singleton here - this is mentioned in GoF 1995:
Client client1 = new Client(MacWindowFactory.getInstance());
Client clientN = new Client(MacWindowFactory.getInstance());This means that only one factory is created (assuming a singleton implementation within MacWindowFactory.getInstance).
This approach ties each client creation to a given factory type. If you want all clients to use the same factory type, then you would change the code to:
Client client1 = new Client(WindowFactory.getInstance());
Client clientN = new Client(WindowFactory.getInstance());where WindowFactory would return the appropriate factory type. Now if WindowFactory is an interface, then you create a "Factory Factory", or "Factory Manager". i.e.
Client client1 = new Client(WindowFactoryManager.getFactoryInstance());
Client clientN = new Client(WindowFactoryManager.getFactoryInstance());The implemenetation of getFactoryInstance can work any of many ways. If you've only one concrete WindowFactory for now, then hard code it into getFactoryInstance. If you have many, then you could have a setFactoryInstance method on WindowFactoryManager. Or getFactoryInstance could use reflection to create a factory based on a Property, etc.