Java设计模式之工厂方法和抽象工厂怎么用

本文小编为大家详细介绍“Java设计模式之工厂方法和抽象工厂怎么用”，内容详细，步骤清晰，细节处理妥当，希望这篇“Java设计模式之工厂方法和抽象工厂怎么用”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。

一、引出问题

如果有一个客户老王，需要购买产品，产品分别是A、B、C。

如果用传统方法实现，分别定义A、B、C三个类，再分别创建他们所属的方法。

在客户对象中再分别调用他们的方法。

Product ClientProduct(String orderType) {     Product product;     if (orderType.equals("A")) {         product = new ProductA();     } else if (orderType.equals("B")) {         product = new ProductB();     } else if (orderType.equals("B")) {         product = new ProductC();     }          // product制作过程     product.common();          return product; }

如果我们需要再增加一个产品D，就需要判断再增加一个分支，然后在分支里面创建产品对象，调用产品D的方法。

这样代码的维护性是极差的，查看我们的软件设计七大原则，很明显，这违反了开闭原则、依赖倒置原则.

如果又有个客户小王，那么小王也必须依赖每个产品类，这样就显得冗杂。

二、简单工厂（静态工厂）

简单工厂（静态工厂）模式就应用而生了。

如果我们将产品A、B、C抽象出来一个父类，再专门创建一个工厂类，在客户购买产品时，只需要传入产品的类型，由工厂去创建产品。

简单工厂模式中包含如下角色：

Factory：工厂角色

工厂角色负责实现创建所有实例的内部逻辑。

Product：抽象产品角色

抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口。

ConcreteProduct：具体产品角色

具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。

看看我们对原始实现方式后的代码。

产品抽象父类：

/**  * @author tcy  * @Date 28-07-2022  */ public class Product {     public void common(){         System.out.println("这是产品父类公共方法...");     } }

产品A：

/**  * @author tcy  * @Date 28-07-2022  */ public class ProductA extends Product{     public void common(){         System.out.println("这是产品A方法...");     } }

产品B：

/**  * @author tcy  * @Date 28-07-2022  */ public class ProductB extends Product{     public void common(){         System.out.println("这是产品B方法...");     } }

工厂类：

/**  * @author tcy  * @Date 28-07-2022  */ public class SimpleFactory {     public Product createProduct(String orderType) {         Product product = null;         if (orderType.equals("A")) {             product = new ProductA();         } else if (orderType.equals("B")) {             product = new ProductB();         } else if (orderType.equals("C")) {             product = new ProductC();         }         return product;     } }

客户老王类：

/**  * @author tcy  * @Date 28-07-2022  */ public class Client {     SimpleFactory simpleFactory;     public Client(SimpleFactory simpleFactory) {         this.simpleFactory = simpleFactory;     }     public Product orderProduct(String orderType) {         Product product;             product = simpleFactory.createProduct(orderType);        //调用每个产出相应的方法         product.common();         System.out.println(product.getClass());         return product;     }     public static void main(String[] args) {         Client client=new Client(new SimpleFactory());         client.orderProduct("A");     } }

这样简单工厂模式就实现了，这样的话老王和具体的产品就很好的解耦了，也不需要老王再依赖具体产品类，依赖倒置问题就很好的解决了。

如果增加一个产品D，需要再重新定义一个D类，实现product接口，而后在工厂类中增加一个分支结构。

显而易见这样实现，缺陷依然存在：

1、工厂类集中了所有产品创建逻辑，职责过重，一旦发生异常，整个系统将受影响。
2、使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。
3、系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂。
4、简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。

这种方法只是一种编码方式，并不输入设计模式的一种，且局限于产品种类较少。

三、工厂方法

在简单工厂中老王需要具体的产品，就在他自己的类中去创建需要的产品，老王虽然不依赖具体产品，但老王现在需要依赖工厂实现类了。

简单工厂是将产品类抽象化，具体的产品由工厂类去实现。

如果我们将工厂类也抽象化，那就引出了我们今天第一个设计模式——工厂方法。

工厂方法有四个角色：

1、抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 createProduct() 来创建产品。
2、具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
3、抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
4、具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

我们对简单工厂代码进行改造。

抽象产品父类、产品A类、产品B类保持不变。重点看工厂类

抽象工厂类：

/**  * @author tcy  * @Date 28-07-2022  */ public abstract class AbstractFactory {     public abstract Product createProduct(String orderType); }

具体实现工厂A类：

/**  * @author tcy  * @Date 28-07-2022  */ public class ConcreteFactoryA extends AbstractFactory{     @Override     public Product createProduct(String orderType) {         System.out.println("参数为："+orderType);         return new ProductA();     } }

具体实现工厂B类：

/**  * @author tcy  * @Date 28-07-2022  */ public class ConcreteFactoryB extends AbstractFactory{     @Override     public Product createProduct(String orderType) {         return new ProductB();     } }

老王类：

/**  * @author tcy  * @Date 28-07-2022  */ public class Client {     AbstractFactory simpleFactory;     public Client(AbstractFactory simpleFactory) {         this.simpleFactory = simpleFactory;     }     public Product orderProduct(String orderType) {         Product product;         product = simpleFactory.createProduct(orderType);        //调用每个产出相应的方法         product.common();         System.out.println(product.getClass());         return product;     }     public static void main(String[] args) {         Client client=new Client(new ConcreteFactoryA());         client.orderProduct("A");     } }

这样的好处就在于老王只管他要关注的抽象工厂，具体是哪个工厂实现类生产产品，老王也不需要关注。

典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

缺点也是显而易见的：

• 类的个数容易过多，增加复杂度。

• 考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度。

• 抽象产品只能生产一种产品。

如果对工厂方法依然一知半解的话，接着往下看工厂方法的一个典型实现

在JDK中对工厂方法有大量的运用，其中比较典型的是

new ArrayList<>().iterator();

我们知道集合的一个大分支依赖的是Collection接口，我们以ArrayList作为举例。

Collection接口相当于产品的抽象父类，ArrayList相当于具体产品。

Iterator是一个抽象工厂，在ArrayList中有一个Itr内部类实现了Iterator接口

当我们调用集合的iterator()方法遍历对象时，就会调用各自类的具体实现方法。

四、抽象工厂

有一天，产品A、B、C升级改造了，三种产品分别有红色和蓝色，如果还用工厂方法的话，那简直是个灾难，具体工厂实现类需要六个。

就引出我们今天的第二个设计模式——抽象工厂。

抽象工厂模式(Abstract Factory Pattern)：提供一个接口，用于创建创建一系列相关或相互依赖对象的家族，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。

抽象工厂模式与工厂方法模式区别在于，工厂方法模式针对的是一个产品等级结构。

而抽象工厂模式则需要面对多个产品等级结构（各种颜色），一个工厂等级结构可以负责多个不同产品等级结构（不同颜色）中的产品对象的创建 。

抽象工厂依然是四个角色：

• AbstractFactory：抽象工厂

• ConcreteFactory：具体工厂

• AbstractProduct：抽象产品

• Product：具体产品

  我们开始改造工厂方法代码，既然是要把产品都分成一组，那理应把产品A、B、C都抽象出来，再让工厂类去实现各个产品的不同颜色，也就是概念中的——用于创建创建一系列相关或相互依赖对象的家族。

接口看改造后的代码：

产品抽象类：

/**  * @author tcy  * @Date 28-07-2022  */ public interface Product {     public void common(); }

产品抽象A家族类：

/**  * @author tcy  * @Date 28-07-2022  */ public abstract class ProductA implements Product {     public abstract void common(); }

产品抽象B家族类：

/**  * @author tcy  * @Date 28-07-2022  */ public abstract class ProductB implements Product {     public abstract void common(); }

具体红色产品A类：

/**  * @author tcy  * @Date 28-07-2022  */ public class RedProductA extends ProductA{     @Override     public void common() {         System.out.println("这是红色的产品A");     } }

具体蓝色产品A类：

/**  * @author tcy  * @Date 28-07-2022  */ public class BlueProductA extends ProductA {     @Override     public void common() {         System.out.println("这是蓝色的产品A");     } }

抽象A家族工厂类：

/**  * @author tcy  * @Date 28-07-2022  */ public interface AbstractProductFactory {     public ProductA createProduct(String orderType); }

实现A家族工厂类：

/**  * @author tcy  * @Date 28-07-2022  */ public class ConcreateProductAFactory implements AbstractProductFactory{     @Override     public ProductA createProduct(String orderType) {         return new BlueProductA();     } }

老王类：

/**  * @author tcy  * @Date 28-07-2022  */ public class Client {     ConcreateProductAFactory simpleFactory;     public Client(ConcreateProductAFactory simpleFactory) {         this.simpleFactory = simpleFactory;     }     public ProductA orderProduct(String orderType) {         ProductA product;         product = simpleFactory.createProduct(orderType);        //调用每个产出相应的方法         product.common();         System.out.println(product.getClass());         return product;     }     public static void main(String[] args) {         Client client=new Client(new ConcreateProductAFactory());         client.orderProduct("A");     } }

这样的话，每天工厂类可以把A的产品家族类（红、蓝）都实现，抽象工厂模式隔离了具体类的生成，使得老王并不需要知道什么产品被创建，从具体的产品解耦出来。

• 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。

如果要增加新产品、和新工厂很容易，如果再增加一个等级（颜色）代码修改起来就很痛苦了。

抽象工厂模式在Spring中有大量的运用。

比较典型的是，BeanFactory 是用于管理 Bean 的一个工厂，所有工厂都是 BeanFactory 的子类。这样我们可以通过 IOC 容器来管理访问 Bean，根据不同的策略调用 getBean() 方法，从而获得具体对象。

BeanFactory 的子类主要有

ClassPathXmlApplicationContext、

XmlWebApplicationContext、

StaticWebApplicationContext、

StaticApplicationContext。

在 Spring 中，DefaultListableBeanFactory 实现了所有工厂的公共逻辑。

读到这里，这篇“Java设计模式之工厂方法和抽象工厂怎么用”文章已经介绍完毕，想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会，如果想了解更多相关内容的文章，欢迎关注亿速云行业资讯频道。