常用Java设计模式系列（5）- 简单工厂、工厂方法模式和抽象工厂模式

讲到设计模式，我想大家都会想到工厂模式，在之前的几篇文章中，我们没有探讨，在这篇文章中，我们就来简单的看一下。

说道工厂模式，其实并不是指一种设计模式，从标题看就知道，其实有好几种，下面我们对这几种都简单的看看。

我们假设现在我们需要生产一些产品，这些产品我们委托给工厂进行生产。

（1）简单工厂模式

简单工厂模式，简单的说就是从前有个工厂，因为规模比较小，所以在一个工厂里面有多个生产线，生产不同的产品，客户提交订单时根据订单的要求去生产不同的产品并提供给客户。

简单工厂模式涉及的角色有：

工厂角色：具体生产产品的类

抽象产品角色：具体产品需要实现的接口；

具体产品角色：具体产品，由工厂生产出来的实体对象；

下面我们通过简单的Java代码来简单实现一下：

抽象产品角色示例代码：

package com.majing.test.designpattern.factory.simplefactory; public interface IProduct { void display(); } 具体产品角色示例代码：

package com.majing.test.designpattern.factory.simplefactory; public class ProductA implements IProduct{ @Override public void display() { System.out.println("我是ProductA."); } } package com.majing.test.designpattern.factory.simplefactory; public class ProductB implements IProduct { @Override public void display() { System.out.println("我是ProductB."); } } 工厂角色示例代码：

package com.majing.test.designpattern.factory.simplefactory; public class SimpleFactory { public static IProduct produce(String type){ IProduct product = null; if("A".equals(type)){ product = new ProductA(); }else if("B".equals(type)){ product = new ProductB(); }else{ return null; } return product; } } 测试用例示例代码：

package com.majing.test.designpattern.factory.simplefactory; public class Client { public static void main(String[] args) { IProduct product = SimpleFactory.produce("A"); product.display(); product = SimpleFactory.produce("B"); product.display(); } } 从上面的实现可以看到，工厂是一个集中生产产品的地方，根据客户的需求（这里是生产A产品，还是生产B产品），来生产出对应的产品。

这种设计模式的缺点是，如果需要这个工厂去生产新的产品，那么就需要修改工厂类，增加新产品生产逻辑，很明显，这违背了开闭原则。但是这种模式的优点是设计简单，实现方便。

但是随着科技的发展，原本的工厂需要生产的东西越来越多，这时候，工厂厂长决定将不同的产品生产线进行独立，同一类型产品生产线由单独一个工厂进行生产，这样不同的生产线之间就不会相互影响了，不用挤在一个拥挤的老工厂里了。于是就出现了工厂方法模式。

（2）工厂方法模式

工厂方法模式，是将不同的产品生产交由不同的工厂进行生产，这样的话，当我们把一个订单交给一个工厂生产时，我们就不需要去说给我生产什么产品了，毕竟这个工厂只会生产一种产品。

工厂方法模式涉及的角色大概有：

抽象产品角色：是具体产品角色的基类，包含所有具体产品共有的特性；

具体产品角色：具体产品角色，

抽象工厂角色：是具体工厂角色的基类，包含着所有具体工厂共有的特性，如生产产品；

具体工厂角色：负责生产具体产品的工厂类；

和前面一样，我们也给出相应的Java代码示例：

抽象产品角色示例代码：

package com.majing.test.designpattern.factory.factorymethod; public interface IProduct { void display(); } 具体产品角色示例代码：

package com.majing.test.designpattern.factory.factorymethod; public class ProductA implements IProduct{ @Override public void display() { System.out.println("我是ProductA."); } } package com.majing.test.designpattern.factory.factorymethod; public class ProductB implements IProduct { @Override public void display() { System.out.println("我是ProductB."); } } 抽象工厂角色示例代码：

package com.majing.test.designpattern.factory.factorymethod; public interface IFactory { IProduct produce(); } 具体工厂角色示例代码：

package com.majing.test.designpattern.factory.factorymethod; public class ProductAFactory implements IFactory { @Override public IProduct produce() { return new ProductA(); } } package com.majing.test.designpattern.factory.factorymethod; public class ProductBFactory implements IFactory { @Override public IProduct produce() { return new ProductB(); } } 从上面的示例代码中，我们看到，每个工厂都只生产一类产品。这种设计模式的好处是符合开闭原则，即使后面需要生产新的产品，也不需要修改已有的工厂类，而是新建一个工厂类和新的产品。当然也存在缺点，那就是，每次有新产品时都要实现相应的产品和工厂类，类的数量会越来越多。

此时的厂长还想继续增加效益，所以做出了决定，那就是每个工厂不仅仅生产一类产品，而是生产多个产品，所有的工厂都生产多个相同种类的产品，这就引出了我们下面要说的另一种设计模式----抽象工厂模式

（3）抽象工厂模式

抽象工厂模式，是对工厂方法模式的进一步抽象，它让每个工厂都生产同一个产品簇，产品簇内包含多个产品类型。这里的示例是让每个工厂都生产ProductA和ProductB。

抽象工厂模式涉及的角色和工厂方法模式一样，这里就不赘述了。下面直接来看看抽象工厂模式的实现。

抽象产品角色示例代码：

package com.majing.test.designpattern.factory.abstractfactory; public interface IProduct { void display(); }

package com.majing.test.designpattern.factory.abstractfactory; import com.majing.test.designpattern.factory.simplefactory.IProduct; public abstract class AbstractProductA implements IProduct { }

package com.majing.test.designpattern.factory.abstractfactory; import com.majing.test.designpattern.factory.simplefactory.IProduct; public abstract class AbstractProductB implements IProduct { }

具体产品角色示例代码：

package com.majing.test.designpattern.factory.abstractfactory; public class ProductA1 extends AbstractProductA { @Override public void display() { System.out.println("我是工厂1生产的ProductA!"); } } package com.majing.test.designpattern.factory.abstractfactory; public class ProductA2 extends AbstractProductA { @Override public void display() { System.out.println("我是工厂2生产的ProductA!"); } } package com.majing.test.designpattern.factory.abstractfactory; public class ProductB1 extends AbstractProductB { @Override public void display() { System.out.println("我是工厂1生产的ProductB!"); } } package com.majing.test.designpattern.factory.abstractfactory; public class ProductB2 extends AbstractProductB { @Override public void display() { System.out.println("我是工厂2生产的ProductB!"); } } 抽象工厂角色示例代码：

package com.majing.test.designpattern.factory.abstractfactory; public interface IFactory { AbstractProductA produceA(); AbstractProductB produceB(); } 具体工厂角色示例代码：

package com.majing.test.designpattern.factory.abstractfactory; public class Factory1 implements IFactory { @Override public AbstractProductA produceA() { return new ProductA1(); } @Override public AbstractProductB produceB() { return new ProductB1(); } } package com.majing.test.designpattern.factory.abstractfactory; public class Factory2 implements IFactory { @Override public AbstractProductA produceA() { return new ProductA2(); } @Override public AbstractProductB produceB() { return new ProductB2(); } } 测试用例代码：

package com.majing.test.designpattern.factory.abstractfactory; public class Client { public static void main(String[] args) { IFactory factory = new Factory1(); AbstractProductA productA = factory.produceA(); AbstractProductB productB = factory.produceB(); productA.display(); productB.display(); } } 至此，一个简单的抽象工厂设计模式的演示代码便结束了。直观的感觉，那就是类的数量激增啊！！！大家看下每种模式的文件数（也就是类和接口数）：

从上截图就可以看出来，一个模式比一个模式复杂，大家还是根据自己的需要选择合适的实现吧。

至此，关于工厂模式的相关说明已经全部讲述完毕，如果想了解我最新的博文，请关注我的博客，谢谢。如果您愿意打赏我，可扫描下方二维码，对您的打赏我表示感谢。