• 15、工厂方法模式（详解版）

    在现实生活中社会分工越来越细，越来越专业化。各种产品有专门的工厂生产，彻底告别了自给自足的小农经济时代，这大大缩短了产品的生产周期，提高了生产效率。同样，在软件开发中能否做到软件对象的生产和使用相分离呢？能否在满足“开闭原则”的前提下，客户随意增删或改变对软件相关对象的使用呢？这就是本节要讨论的问题。

    在《简单工厂模式》一节我们介绍了简单工厂模式，提到了简单工厂模式违背了开闭原则，而“工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。

    优点：

    • 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
    • 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
    • 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

    缺点：

    • 类的个数容易过多，增加复杂度
    • 增加了系统的抽象性和理解难度
    • 抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

    应用场景：

    • 客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。
    • 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
    • 客户不关心创建产品的细节，只关心产品的品牌

    模式的结构与实现

    工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。本节来分析其基本结构和实现方法。

    1. 模式的结构

    工厂方法模式的主要角色如下。

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


    其结构图如图 1 所示。

    工厂方法模式的结构图
    图1 工厂方法模式的结构图

    2. 模式的实现

    根据图 1 写出该模式的代码如下：

    1. package FactoryMethod;
    3. public class AbstractFactoryTest {
    4. public static void main(String[] args) {
    5. try {
    6. Product a;
    7. AbstractFactory af;
    8. af = (AbstractFactory) ReadXML1.getObject();
    9. a = af.newProduct();
    10. a.show();
    11. } catch (Exception e) {
    12. System.out.println(e.getMessage());
    13. }
    14. }
    15. }
    17. //抽象产品：提供了产品的接口
    18. interface Product {
    19. public void show();
    20. }
    22. //具体产品1：实现抽象产品中的抽象方法
    23. class ConcreteProduct1 implements Product {
    24. public void show() {
    25. System.out.println("具体产品1显示...");
    26. }
    27. }
    29. //具体产品2：实现抽象产品中的抽象方法
    30. class ConcreteProduct2 implements Product {
    31. public void show() {
    32. System.out.println("具体产品2显示...");
    33. }
    34. }
    36. //抽象工厂：提供了厂品的生成方法
    37. interface AbstractFactory {
    38. public Product newProduct();
    39. }
    41. //具体工厂1：实现了厂品的生成方法
    42. class ConcreteFactory1 implements AbstractFactory {
    43. public Product newProduct() {
    44. System.out.println("具体工厂1生成-->具体产品1...");
    45. return new ConcreteProduct1();
    46. }
    47. }
    49. //具体工厂2：实现了厂品的生成方法
    50. class ConcreteFactory2 implements AbstractFactory {
    51. public Product newProduct() {
    52. System.out.println("具体工厂2生成-->具体产品2...");
    53. return new ConcreteProduct2();
    54. }
    55. }
    1. package FactoryMethod;
    2. import javax.xml.parsers.*;
    3. import org.w3c.dom.*;
    4. import java.io.*;
    6. class ReadXML1 {
    7. //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
    8. public static Object getObject() {
    9. try {
    10. //创建文档对象
    11. DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
    12. DocumentBuilder builder = dFactory.newDocumentBuilder();
    13. Document doc;
    14. doc = builder.parse(new File("src/FactoryMethod/config1.xml"));
    15. //获取包含类名的文本节点
    16. NodeList nl = doc.getElementsByTagName("className");
    17. Node classNode = nl.item(0).getFirstChild();
    18. String cName = "FactoryMethod." + classNode.getNodeValue();
    19. //System.out.println("新类名："+cName);
    20. //通过类名生成实例对象并将其返回
    21. Class<?> c = Class.forName(cName);
    22. Object obj = c.newInstance();
    23. return obj;
    24. } catch (Exception e) {
    25. e.printStackTrace();
    26. return null;
    27. }
    28. }
    29. }

    注意：该程序中用到了 XML 文件，如果想要获取该文件，请点击“下载”，就可以对其进行下载。

    程序运行结果如下：

    具体工厂1生成-->具体产品1...
具体产品1显示...


    如果将 XML 配置文件中的 ConcreteFactory1 改为 ConcreteFactory2，则程序运行结果如下：

    具体工厂2生成-->具体产品2...
具体产品2显示...

    模式的应用实例

    【例1】用工厂方法模式设计畜牧场。

    分析：有很多种类的畜牧场，如养马场用于养马，养牛场用于养牛，所以该实例用工厂方法模式比较适合。

    对养马场和养牛场等具体工厂类，只要定义一个生成动物的方法 newAnimal() 即可。由于要显示马类和牛类等具体产品类的图像，所以它们的构造函数中用到了 JPanel、JLabd 和 ImageIcon 等组件，并定义一个 show() 方法来显示它们。

    客户端程序通过对象生成器类 ReadXML2 读取 XML 配置文件中的数据来决定养马还是养牛。其结构图如图 2 所示。

    畜牧场结构图
    图2 畜牧场结构图


    注意：该程序中用到了 XML 文件，并且要显示马类和牛类等具体产品类的图像，如果想要获取 HTML 文件和图片，请点击“下载”，就可以对其进行下载。

    程序代码如下：

    1. package FactoryMethod;
    3. import java.awt.*;
    4. import javax.swing.*;
    6. public class AnimalFarmTest {
    7. public static void main(String[] args) {
    8. try {
    9. Animal a;
    10. AnimalFarm af;
    11. af = (AnimalFarm) ReadXML2.getObject();
    12. a = af.newAnimal();
    13. a.show();
    14. } catch (Exception e) {
    15. System.out.println(e.getMessage());
    16. }
    17. }
    18. }
    20. //抽象产品：动物类
    21. interface Animal {
    22. public void show();
    23. }
    25. //具体产品：马类
    26. class Horse implements Animal {
    27. JScrollPane sp;
    28. JFrame jf = new JFrame("工厂方法模式测试");
    30. public Horse() {
    31. Container contentPane = jf.getContentPane();
    32. JPanel p1 = new JPanel();
    33. p1.setLayout(new GridLayout(1, 1));
    34. p1.setBorder(BorderFactory.createTitledBorder("动物：马"));
    35. sp = new JScrollPane(p1);
    36. contentPane.add(sp, BorderLayout.CENTER);
    37. JLabel l1 = new JLabel(new ImageIcon("src/A_Horse.jpg"));
    38. p1.add(l1);
    39. jf.pack();
    40. jf.setVisible(false);
    41. jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //用户点击窗口关闭
    42. }
    44. public void show() {
    45. jf.setVisible(true);
    46. }
    47. }
    49. //具体产品：牛类
    50. class Cattle implements Animal {
    51. JScrollPane sp;
    52. JFrame jf = new JFrame("工厂方法模式测试");
    54. public Cattle() {
    55. Container contentPane = jf.getContentPane();
    56. JPanel p1 = new JPanel();
    57. p1.setLayout(new GridLayout(1, 1));
    58. p1.setBorder(BorderFactory.createTitledBorder("动物：牛"));
    59. sp = new JScrollPane(p1);
    60. contentPane.add(sp, BorderLayout.CENTER);
    61. JLabel l1 = new JLabel(new ImageIcon("src/A_Cattle.jpg"));
    62. p1.add(l1);
    63. jf.pack();
    64. jf.setVisible(false);
    65. jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //用户点击窗口关闭
    66. }
    68. public void show() {
    69. jf.setVisible(true);
    70. }
    71. }
    73. //抽象工厂：畜牧场
    74. interface AnimalFarm {
    75. public Animal newAnimal();
    76. }
    78. //具体工厂：养马场
    79. class HorseFarm implements AnimalFarm {
    80. public Animal newAnimal() {
    81. System.out.println("新马出生！");
    82. return new Horse();
    83. }
    84. }
    86. //具体工厂：养牛场
    87. class CattleFarm implements AnimalFarm {
    88. public Animal newAnimal() {
    89. System.out.println("新牛出生！");
    90. return new Cattle();
    91. }
    92. }
    1. package FactoryMethod;
    2. import javax.xml.parsers.*;
    3. import org.w3c.dom.*;
    4. import java.io.*;
    6. class ReadXML2 {
    7. public static Object getObject() {
    8. try {
    9. DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
    10. DocumentBuilder builder = dFactory.newDocumentBuilder();
    11. Document doc;
    12. doc = builder.parse(new File("src/FactoryMethod/config2.xml"));
    13. NodeList nl = doc.getElementsByTagName("className");
    14. Node classNode = nl.item(0).getFirstChild();
    15. String cName = "FactoryMethod." + classNode.getNodeValue();
    16. System.out.println("新类名：" + cName);
    17. Class<?> c = Class.forName(cName);
    18. Object obj = c.newInstance();
    19. return obj;
    20. } catch (Exception e) {
    21. e.printStackTrace();
    22. return null;
    23. }
    24. }
    25. }

    程序的运行结果如图 3 所示。

    畜牧场养殖的运行结果
    图3 畜牧场养殖的运行结果


    注意：当需要生成的产品不多且不会增加，一个具体工厂类就可以完成任务时，可删除抽象工厂类。这时工厂方法模式将退化到简单工厂模式。
  • 相关阅读:
    [转]移动端实现垂直居中的几种方法
    MySQL常见的两种存储引擎：MyISAM与InnoDB的爱恨情仇
    关于分布式计算的一些概念
    一份最中肯的Java学习路线+资源分享（拒绝傻逼式分享）
    Java多线程学习（八）线程池与Executor 框架
    深入理解工厂模式
    深入理解单例模式
    Java NIO 之 Buffer(缓冲区)
    Java NIO 概览
    分布式系统的经典基础理论
  • 原文地址：https://www.cnblogs.com/phpcqy/p/14279834.html
Copyright © 2020-2023  润新知