浅谈 java 设计模式--抽象工厂模式（AbstractFactory pattern）

问题:

当系统要创建一组相关或者相互依赖的对象时, 请使用抽象工厂模式.

抽象工厂模式可以向客户端提供一个接口, 使得客户端可以在不必指定产品的具体类型的情况下, 创建多个产品族中的产品对象. 这就是抽象工厂的用意.

类图:



源代码:

package com.designpatterns.AbstractFactory;
/**
* 抽象工厂
*/
public interface AbstractFactory {
public AbstractProductA createProductA();
public AbstractProductB createProductB();
}

public interface AbstractProductA {
public void operation();
}

public interface AbstractProductB {
public void operation();
}

public class ConcreteFactory1 implements AbstractFactory{
public AbstractProductA createProductA(){
return new ProductA1();
}

public AbstractProductB createProductB(){
return new ProductB1();
}
}

public class ConcreteFactory2 implements AbstractFactory{
public AbstractProductA createProductA(){
return new ProductA2();
}

public AbstractProductB createProductB(){
return new ProductB2();
}
}

public class ProductA1 implements AbstractProductA {
public ProductA1(){
System.out.println("ProductA1...");
}

public void operation() {}
}

public class ProductA2 implements AbstractProductA {
public ProductA2(){
System.out.println("ProductA2...");
}

public void operation() {}
}

public class ProductB1 implements AbstractProductB {
public ProductB1(){
System.out.println("ProductB1...");
}

public void operation() {}
}

public class ProductB2 implements AbstractProductB {
public ProductB2(){
System.out.println("ProductB2...");
}
public void operation() {}
}

/**
* 客户端类
*/
public class Client {
public static void main(String[] args) {
AbstractFactory af1 = new ConcreteFactory1();
af1.createProductA();
af1.createProductB();

AbstractFactory af2 = new ConcreteFactory2();
af2.createProductA();
af2.createProductB();
}
}

讨论:

AbstractFactory模式是为创建一组(有多类)相关或依赖的对象提供创建接口, 而Factory模式是为一类对象提供创建接口或延迟对象的创建到子类中实现. AbstractFactory模式通常都是使用Factory模式实现, 如上例所示.

Definition

Provides an interface for creating families of related or dependent objects without specifying their concrete classes.

Class Diagram

Participants

Abstract Factory (FinancialToolsFactory)

declares an interface for operations that create abstract products objects

Concrete Factory (EuropeFinancialToolsFactory, CanadaFinancialToolsFactory)

implements the operations to create concrete product objects

Abstract Product (TaxProcessor, ShipFeeProcessor)

declares an interface for a type of product object

Concrete Product (EuropeTaxProcessor, CanadaTaxProcessor, EuropeShipFeeProcessor, CanadaShipFeeProcessor)

defines a product object to be created by the corresponding concrete factory implements the AbstractProduct interface

Client (OrderProcessor)

uses interfaces declared by AbstractFactory and AbstractProduct classes

Example: Financial Tools Factory

Example: Class Diagram

Example: Java sample code

// Factories
package com.apwebco.patterns.gof.abstractfactory;
public abstract class FinancialToolsFactory {
public abstract TaxProcessor createTaxProcessor();
public abstract ShipFeeProcessor createShipFeeProcessor();
}
public class CanadaFinancialToolsFactory extends FinancialToolsFactory {
public TaxProcessor createTaxProcessor() {
return new CanadaTaxProcessor();
}
public ShipFeeProcessor createShipFeeProcessor() {
return new CanadaShipFeeProcessor();
}
}
public class EuropeFinancialToolsFactory extends FinancialToolsFactory {
public TaxProcessor createTaxProcessor() {
return new EuropeTaxProcessor();
}
public ShipFeeProcessor createShipFeeProcessor() {
return new EuropeShipFeeProcessor();
}
}
// Products
public abstract class ShipFeeProcessor {
abstract void calculateShipFee(Order order);
}
public abstract class TaxProcessor {
abstract void calculateTaxes(Order order);
}
public class EuropeShipFeeProcessor extends ShipFeeProcessor {
public void calculateShipFee(Order order) {
// insert here Europe specific ship fee calculation
}
}
public class CanadaShipFeeProcessor extends ShipFeeProcessor {
public void calculateShipFee(Order order) {
// insert here Canada specific ship fee calculation
}
}
public class EuropeTaxProcessor extends TaxProcessor {
public void calculateTaxes(Order order) {
// insert here Europe specific taxt calculation
}
}
public class CanadaTaxProcessor extends TaxProcessor {
public void calculateTaxes(Order order) {
// insert here Canada specific taxt calculation
}
}
// Client
public class OrderProcessor {
private TaxProcessor taxProcessor;
private ShipFeeProcessor shipFeeProcessor;

public OrderProcessor(FinancialToolsFactory factory) {
taxProcessor = factory.createTaxProcessor();
shipFeeProcessor = factory.createShipFeeProcessor();
}
public void processOrder (Order order)	{
// ....
taxProcessor.calculateTaxes(order);
shipFeeProcessor.calculateShipFee(order);
// ....
}
}
// Integration with the overall application
public class Application {
public static void main(String[] args) {
// .....
String countryCode = "EU";
Customer customer = new Customer();
Order order = new Order();
OrderProcessor orderProcessor = null;
FinancialToolsFactory factory = null;

if (countryCode == "EU") {
factory = new EuropeFinancialToolsFactory();
} else if (countryCode == "CA") {
factory = new CanadaFinancialToolsFactory();
}
orderProcessor = new OrderProcessor(factory);
orderProcessor.processOrder(order);
}
}

Benefits

Isolates concrete classes
Allows to change product family easily
Promotes consistency among products

Usage

When the system needs to be independent of how its products are created composed and represented.
When the system needs to be configured with one of multiple families of products.
When a family of products need to be used together and this constraint needs to be enforced.
When you need to provide a library of products, expose their interfaces not the implementation.