这是我参与8月更文挑战的第3天，活动详情查看：8月更文挑战
一、工厂模式
工厂模式分为
- 简单工厂模式（Simple Factory Pattern）
- 工厂方法模式（Fatory Method Pattern）
- 抽象工厂模式（Abastract Factory Pattern）
其中简单工厂模式不在GOF 总计出来的23中设计模式中。工厂模式属于创建型模式，就是创建对象的模式，抽象了实例化的过程。创建型模式关心的是对象的创建，即将创建对象的过程进行了封装，作为客户程序仅仅需要去使用对象，而不再关心创建对象过程中的逻辑。
为了后面的示例，我们先准备一个Product接口。
public interface Product {
String description();
}
然后实现这个接口，创建类BlackProduct。
public class BlackProduct implements Product {
@Override
public String description() {
return "black BlackProduct";
}
}
RedProduct
public class RedProduct implements Product {
@Override
public String description() {
return "red RedProduct";
}
}
我们不使用任何模式，创建并使用Product。
public class NoneApp {
public static void main(String[] args) {
Product product = new RedProduct();
System.out.println(product.description());
}
}
父类 Product 指向子类 RedProduct的引用，应用层代码需要依赖RedProduct，如果业务扩展，我继续增加更多的Product实现，那么我们客户端的依赖会变得越来越臃肿。因此，我们要想办法把这种依赖减弱，把创建细节隐藏。虽然目前的代码中，我们创建对象的过程并不复杂，但从代码设计角度来讲不易于扩展。
二、 简单工厂模式
简单工厂适用于工厂类负责创建的对象较少的场景，且客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心。
使用简单工厂，我们需要准备一个工厂，通过传入产品的特征信息，创建对应的实例。
public class ProductFactory {
static final String RED = "red";
static final String BLACK = "black";
public Product create(String trait) {
if (trait.equals(RED)) {
return new RedProduct();
} else if (trait.equals(BLACK)) {
return new BlackProduct();
}
throw new IllegalArgumentException();
}
}
这个创建对象的逻辑有缺点，就是当我们要更新增加更加丰富的其它实现的时候，需要修改代码逻辑，不符合开闭原则，所以优化一版。
public class ProductUltraFactory {
@SneakyThrows
public Product create(Class<? extends Product> clazz) {
if (clazz != null) {
return clazz.newInstance();
}
throw new IllegalArgumentException();
}
}
针对上面两个工厂，使用方法如下。
public class SimpleApp {
public static void main(String[] args) {
final ProductFactory productFactory = new ProductFactory();
final Product product = productFactory.create(ProductFactory.RED);
System.out.println(product.description());
final ProductUltraFactory productUltraFactory = new ProductUltraFactory();
final Product otherProduct = productUltraFactory.create(RedProduct.class);
System.out.println(otherProduct.description());
}
}
简单工厂的缺点一目了然：工厂类的职责相对过重，不易于扩展过于复杂的产品结构。
三、工厂方法模式
工厂方法模式是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。在工厂方法模式中用户只需要关心所需产品对应的工厂，无须关心创建细节，而且加入新的产品符合开闭原则。
工厂方法模式主要解决产品扩展的问题，在简单工厂中，随着产品链的丰富，如果每个产品的创建逻辑有区别的话，工厂的职责会变得越来越多，有点像万能工厂，并不便于维护。根据单一职责原则我们将职能继续拆分，专人干专事。
所以我们要为每个产品单独配置一个工厂。
黑色产品的生产工厂BlackProductFactory
public class BlackProductFactory implements ProductFactory {
@Override
public Product create() {
return new BlackProduct();
}
}
红色产品的生产工厂RedProductFactory
public class RedProductFactory implements ProductFactory {
@Override
public Product create() {
return new RedProduct();
}
}
使用方法如下
public class MethodApp {
public static void main(String[] args) {
final RedProductFactory redProductFactory = new RedProductFactory();
final Product product = redProductFactory.create();
System.out.println(product.description());
final BlackProductFactory blackProductFactory = new BlackProductFactory();
final Product otherProduct = blackProductFactory.create();
System.out.println(otherProduct.description());
}
}
适用场景：
- 创建对象需要大量重复的代码。
- 客户端（应用层）不依赖于产品类实例如何被创建、实现等细节。
- 一个类通过其子类来指定创建哪个对象。
缺点：
类的个数容易过多，增加复杂度。
增加了系统的抽象性和理解难度。
四、抽象工厂模式
抽象工厂模式是指提供一个创建一系列相关或相互依赖对象的接口，无须指定他们具体的类。
客户端（应用层）不依赖于产品类实例如何被创建、实现等细节，强调的是一系列相关的产品对（属于同一产品族）一起使用创建对象需要大量重复的代码。需要提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。
我们现在已经有一种产品Product，我们假设一系列的产品中还有AnotherProduct。
public interface AnotherProduct {
String description();
}
RedAnotherProduct 是它的实现。
public class RedAnotherProduct implements AnotherProduct {
@Override
public String description() {
return "red AnotherProduct";
}
}
抽象工厂模式最关键的是准备一个一系列抽象产品的工厂ComposeFactory。
public interface ComposeFactory {
AnotherProduct createAnotherProduct();
Product createProduct();
}
这个抽象工厂的一种具体实现，比如红色产品的组合RedComposeFactory。
public class RedComposeFactory implements ComposeFactory {
@Override
public AnotherProduct createAnotherProduct() {
return new RedAnotherProduct();
}
@Override
public Product createProduct() {
return new RedProduct();
}
}
使用方法如下。
public class AbsApp {
public static void main(String[] args) {
final RedComposeFactory redComposeFactory = new RedComposeFactory();
final AnotherProduct anotherProduct = redComposeFactory.createAnotherProduct();
final Product product = redComposeFactory.createProduct();
System.out.println(anotherProduct.description());
System.out.println(product.description());
}
}
抽象工厂非常完美清晰地描述这样一层复杂的组合关系。但它也有缺点。
- 规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口。
- 增加了系统的抽象性和理解难度。
