深入设计模式05---抽象工厂模式

短命女 2023-06-16 15:58 17阅读 0赞

### 前言 ###

自强者打不到，自弃者扶不起。坚持就是胜利！！！  
本篇主要介绍抽象工厂模式的结构以及真实场景应用，抽象工厂模式也是常用的创建型模式之一，这种设计模式比工厂方法模式的抽象程度更高，在工厂方法模式中每一个具体的产品只需要生产一种相关的具体产品，但是在抽象工厂模式中一个具体的工厂可以上产一组相关的具体产品，这样的一组产品称为产品族（下面会有介绍），我们要知道工厂方法主要负责生产一个具体产品，而抽象工厂模式负责成产一组产品族。

### 正文 ###

*  #### 概述 ####
    
    *提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们的具体类 。*  
    **工厂方法模式的设计思想如下：**  
    我们有时候可能需要一个工厂可以提供多种产品对象，而不是单一的产品对象，例如一个电器工厂，它可以生产电视机、冰箱、空调等多种电器，而不是只生产某一种电器，此时可以考虑将一些相关的产品组成一个“产品族”，由同一个工厂来统一生产，这就是抽象工厂模式的基本思想。  
    **为了更好理解，我们引入两个概念：**  
    1） 产品等级结构：产品等级结构即产品的继承结构，例如一个抽象类是电视机，其子类包括海尔电视机、TCL电视机，则电视机与具体品牌的电视机构成了一个产品等级结构，电视机是父类，具体品牌的电视机是其子类；  
    2） 产品族： 产品族是指由同一个工厂生产的位于不同产品等级结构中的一组产品，如海尔电视机、海尔冰箱、海尔洗衣机，他们分别位于电视机、冰箱、洗衣机产品等级结构中，这一系列的产品就构成了一个产品族，在抽象工厂模式中，海尔工厂负责生产这一系列的产品。
 *  #### 结构与实现 ####
    
     *  ##### 模式结构 #####
        
         *  **AbstarctFactory（抽象工厂类）：** 抽象工厂类中声明一个方法，用于返回产品，具体工厂类实现该方法返回产品对象。
         *  **ConcreteFactory（具体工厂类）：** 实现了抽象工厂类中产生对象的方法，生产对象，客户端真正调用的是此方法来产生对象。
         *  **AbstractProduct（抽象产品角色）：** 产品的抽象定义，所有产品对象的公共父类。
         *  **ConcreteProduct（具体产品）：** 实现了抽象产品类，每一种具体产品类都对应一个具体工厂类，该具体工厂类负责生产该具体产品类。
     *  ##### 实现案例 #####
        
        与工厂方法模式不同的是抽象工厂模式一个工厂对应的是一个产品族的产品（即一个工厂可以生产多种产品）。  
        **案例说明：**  
        公司需要开发一套界面皮肤库，可以对基于Java的桌面软件进行界面美化。用户可以通过菜单选择皮肤，不同的皮肤将提供视觉效果不同的按钮、文本框、组合框等界面元素，例如春天（Spring）风格将提供浅绿色按钮、绿色边框的文本框以及绿色边框的组合框，夏天（Summer）风格提供浅蓝色的按钮、蓝色的边框文本框以及蓝色边框的组合框。  
        **案例分析：**  
        使用抽象工厂模式设计该界面皮肤库，为了系统具有良好的扩展性，充分的利用多态对系统进行设计，经过分析我们知道，首先我们需要按钮（Button）、文本框（TextField）、组合框（ComboBox）作为抽象产品类，各种风格的皮肤展示不风格的组件，SummerFactory、SpringFactory用来生产不同风格的产品。  
        **目录结构：**  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA_size_16_color_FFFFFF_t_70]  
        **简单而典型且优雅的抽象产品类代码：** 其中提供一个抽象display方法用于模拟显示组件。
        
            // 按钮抽象接口
            public interface Button {
            
                void display();
            }
            
            // 组合框抽象接口
            public interface ComboBox {
            
                void display();
            }
            
            // 文本框抽象接口
            public interface TextField {
            
                void display();
            }
        
        **具体产品类：** 有两个产品族，分别实现抽象产品中的抽象组件。
        
        Summer皮肤产品族：
        
            public class SummerButton implements Button {
                @Override
                public void display() {
                    System.out.println("浅蓝色的按钮");
                }
            }
            
            
            public class SummerComboBox implements ComboBox {
                @Override
                public void display() {
                    System.out.println("蓝色边框的组合框");
                }
            }
            
            public class SummerTextField implements TextField {
                @Override
                public void display() {
                    System.out.println("蓝色边框的文本框");
                }
            }
        
        Spring皮肤产品族：
        
            public class SpringButton implements Button {
                @Override
                public void display() {
                    System.out.println("浅绿色的按钮");
                }
            }
            
            
            
            public class SpringComboBox implements ComboBox {
                @Override
                public void display() {
                    System.out.println("绿色边框的组合框");
                }
            }
            
            
            
            public class SpringTextField implements TextField {
                @Override
                public void display() {
                    System.out.println("绿色边框的文本框");
                }
            }
        
        **抽象工厂类：** 抽象工厂设计模式中的抽象工厂类提供一组生产一族产品的方法（这里包含按钮（Button）、文本框（TextField）、组合框（ComboBox））。
        
            public interface SkinFactory {
            
                Button createButton();
            
                TextField createTextField();
            
                ComboBox createComboBox();
            }
        
        **具体工厂类：** 具体工厂类继承或实现抽象工厂类，与每一族产品一一对应，负责生产这些产品。
        
            // 春天皮肤工厂
            public class SpringSkinFatory implements SkinFactory {
                @Override
                public Button createButton() {
                    return new SpringButton();
                }
            
                @Override
                public TextField createTextField() {
                    return new SpringTextField();
                }
            
                @Override
                public ComboBox createComboBox() {
                    return new SpringComboBox();
                }
            }
            
            
             //夏天皮肤工厂
            public class SummerSkinFactory implements SkinFactory {
                @Override
                public Button createButton() {
                    return new SummerButton();
                }
            
                @Override
                public TextField createTextField() {
                    return new SummerTextField();
                }
            
                @Override
                public ComboBox createComboBox() {
                    return new SummerComboBox();
                }
            }
        
        **config配置文件：** 配置了具体的皮肤工厂类，代码中通过解析该配置文件获取具体工厂类的类名，然后通过反射获取具体工厂对象；
        
            <?xml version="1.0" ?>
            <config>
                <className>com.xz.example.factory.SummerSkinFactory</className>
            </config>
        
        **XMLUtil：** 用来解析具体的config配置文件
        
            public class XMLUtil {
            
                public static Object getBean(){
                    try {
                        // 创建DOM文档对象
                        DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
                        DocumentBuilder documentBuilder = dFactory.newDocumentBuilder();
                        Document doc = documentBuilder.parse(new File("AbstractFactoryPattern/src/com/xz/example/config.xml"));
            
                        // 获取配置bean
                        NodeList nl = doc.getElementsByTagName("className");
                        Node node = nl.item(0).getFirstChild();
                        String clazzName = node.getNodeValue();
            
                        // 利用反射生成对象并返回
                        Object obj = Class.forName(clazzName).newInstance();
                        return obj;
                    } catch (Exception e) {
                        e.printStackTrace();
                        return null;
                    }
                }
            }
        
        **客户类：** 模拟消费产品类
        
            public class Client {
            
                /**
                 *  需求:
                 *      某公司需要开发一套界面皮肤库，可以对基于Java的桌面软件进行界面美化。用户可以通过菜单选择皮肤，不同的皮肤将提供视觉效果
                 *      不同的按钮、文本框、组合框等界面元素，例如春天（Spring）风格将提供浅绿色按钮、绿色边框的文本框以及绿色边框的组合框，
                 *      夏天（Summer）风格提供浅蓝色的按钮、蓝色的边框文本框以及蓝色边框的组合框。
                 *  分析：
                 *      使用抽象工厂模式设计该界面皮肤库：
                 *          为了系统具有良好的扩展性，充分的利用多态对系统进行设计，经过分析我们知道，首先我们需要按钮（Button）、文本框（TextField）、
                 *          组合框（ComboBox）作为抽象产品类，各种风格的皮肤展示不风格的组件，SummerFactory、SpringFactory用来生产不同风格的产品。
                 * @param args
                 */
                public static void main(String[] args) {
            
                    Object bean = XMLUtil.getBean();
                    if (null != bean && bean instanceof SkinFactory){
                        SkinFactory skinFactory = (SkinFactory) bean;
                        Button button = skinFactory.createButton();
                        ComboBox comboBox = skinFactory.createComboBox();
                        TextField textField = skinFactory.createTextField();
                        button.display();
                        comboBox.display();
                        textField.display();
                    }
            
                }
            }
        
        **运行结果：**  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA_size_16_color_FFFFFF_t_70 1]  
        可以通过配置文件来配置具体的工厂类，然后通过反射机制创建具体的工厂类，从而使在更换具体的工厂时无需修改代码，只需要修改配置文件。
 *  #### 超真实案例 ####
    
    **需求**: 为了改进数据库的操作性能，用户可以自定义数据库连接对象（Condition）和语句对象（Statement），针对不同的数据库提供不同的连接对象和语句对象，例如提供mysql和oracle专用的连接类和语句类，而且用户可以通过配置文件来更换数据库（这也是书上的课后习题，可以试着自己先设计下再看下面的代码）。  
    **需求分析**：需要Mysql与Oracle的具体连接对象、语句对象实现类，提供工厂创建一类的产品族，同时应当可以重载更换连接信息。  
    客户端通过修改配置文件修改存储日志的方式
    
    ##### 上代码(简化模拟实现) #####
    
    **目录结构：**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA_size_16_color_FFFFFF_t_70 2]  
    **首先是数据库连接抽象类和语句抽象类：** 与具体的实现类构成产品等级结构；
    
        // 数据库连接类
        public abstract class Connection {
        
            private String ip = "127.0.0.1"; // 数据库ip地址
            private String port = "3306"; // 数据库端口号
        
            // 连接数据块的方法
            public abstract void connectDatabase();
        
            public String getIp() {
                return ip;
            }
        
            public void setIp(String ip) {
                this.ip = ip;
            }
        
            public String getPort() {
                return port;
            }
        
            public void setPort(String port) {
                this.port = port;
            }
        }
    
        // 语句对象抽象类
        public interface Statement {
        
            // 提交sql语句的方法
            void  query();
        
        }
    
    **具体的实现类产品族：** 需要实现抽象产品类中的方法  
    Mysql产品族：
    
        public class MysqlConnection extends Connection {
        
            @Override
            public void connectDatabase() {
                System.out.println("连接上了Mysql数据库:"+this.getIp()+":"+this.getPort());
            }
        }
        
        
        
        public class MysqlStatement implements Statement {
            @Override
            public void query() {
                System.out.println("MysqlStatement提交了sql语句");
            }
        }
    
    Oracle产品族：
    
        public class OracleConnection extends Connection {
            @Override
            public void connectDatabase() {
                System.out.println("连接上了Oracle数据库:"+this.getIp()+":"+this.getPort());
            }
        }
        
        
        
        public class OracleStatement implements Statement{
            @Override
            public void query() {
                System.out.println("OracleStatement提交了sql语句");
            }
        }
    
    **抽象工厂类：** 定义了创建数据块连接与语句对象的抽象方法。
    
        public interface DatabaseFactory {
        
            Connection createConnection();
        
            // 重载，传入端口号以及地址
            Connection createConnection(String ip,String port);
        
            Statement createStatement();
        }
    
    **具体工厂类：** 实现创建连接以及语句对象的方法
    
        public class MysqlDatabaseFactory implements DatabaseFactory {
            @Override
            public Connection createConnection() {
                return new MysqlConnection();
            }
        
            @Override
            public Connection createConnection(String ip, String port) {
                Connection connection = new MysqlConnection();
                connection.setIp(ip);
                connection.setPort(port);
                return connection;
            }
        
            @Override
            public Statement createStatement() {
                return new MysqlStatement();
            }
        }
    
        public class OracleDatabaseFactory implements DatabaseFactory{
            @Override
            public Connection createConnection() {
                return new OracleConnection();
            }
        
            @Override
            public Connection createConnection(String ip, String port) {
                Connection connection = new OracleConnection();
                connection.setPort(port);
                connection.setIp(ip);
                return connection;
            }
        
            @Override
            public Statement createStatement() {
                return new OracleStatement();
            }
        }
    
    **config配置文件：** 配置了具体的工厂类，代码中通过解析该配置文件获取具体工厂类的类名，然后通过反射获取具体工厂对象；
    
        <?xml version="1.0" ?>
        <config>
            <className>com.xz.realdemo.factory.OracleDatabaseFactory</className>
        </config>
    
    **XMLUtil：** 用来解析具体的config配置文件
    
        public class XMLUtil {
        
            public static Object getBean(){
                try {
                    // 创建DOM文档对象
                    DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
                    DocumentBuilder documentBuilder = dFactory.newDocumentBuilder();
                    Document doc = documentBuilder.parse(new File("AbstractFactoryPattern/src/com/xz/realdemo/config.xml"));
        
                    // 获取配置bean
                    NodeList nl = doc.getElementsByTagName("className");
                    Node node = nl.item(0).getFirstChild();
                    String clazzName = node.getNodeValue();
        
                    // 利用反射生成对象并返回
                    Object obj = Class.forName(clazzName).newInstance();
                    return obj;
                } catch (Exception e) {
                    e.printStackTrace();
                    return null;
                }
            }
        }
    
    **客户端模拟消费：**
    
        public class Client {
        
        
            /**
             * 需求：
             *      为了改进数据库的操作性能，用户可以自定义数据库连接对象（Condition）和语句对象（Statement），针对不同的数据库
             *      提供不同的连接对象和语句对象，例如提供mysql和oracle专用的连接类和语句类，而且用户可以通过配置文件来更换数据库。
             *  分析：
             *      需要Mysql与Oracle的具体连接对象、语句对象实现类，提供工厂创建一类的产品族，同时应当可以重载更换连接信息
             * @param args
             */
            public static void main(String[] args) {
        
                Object bean = XMLUtil.getBean();
                if (bean != null && bean instanceof DatabaseFactory){
                    DatabaseFactory factory = (DatabaseFactory) bean;
                    Connection connection = factory.createConnection("129.0.0.1","8080");
                    Statement statement = factory.createStatement();
                    connection.connectDatabase();
                    statement.query();
                }
            }
        }
    
    **运行结果：**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA_size_16_color_FFFFFF_t_70 3]
    
    **开闭原则的倾斜性：**  
    请大家思考一个问题：如果我们在产品设计之初没有考虑完善，拿第一个案例来举例，假如我们后期需要对单选框也提供皮肤样式，而已有的系统是没有单选框等级结构的，那么在增加这个等级结构时我们就需要先修改SkinFactory抽象工厂，在其中声明可以创建单选框的方法，然后逐个的修改各个具体工厂类来实现该方法创建出单选按钮，然后还需要修改客户端，否则这个按钮无法被创建出来生效，这样搞起来不是相当麻烦吗？这正是抽象工厂模式最大的缺点。  
    但是在另一方面，如果我们想要新增一个冬天（winter）皮肤，则会非常方便，大家不妨在代码中尝试一下。抽象工厂模式中新增产品等级结构非常的麻烦，但是新增新的产品族却非常的方便，他的这种性质被称为开闭原则的倾斜性。  
    开闭原则要求系统对修改关闭，对扩展开放，对于涉及到多个产品族以及产品等级结构的系统，其功能增强包括两个方面：  
    1） 增加产品族： 对于增加新的产品族，抽象工厂模式很好的遵循了开闭原则，只需要增加具体产品以及一个新的工厂，对已有的代码无需做任何更改。  
    2）增加新的产品等级结构： 对于增加新的产品等级结构，需要修改抽象工厂类以及所有的具体工厂类，也需要修改客户端的代码，这违背了开闭原则。  
    因为抽象工厂模式存在的开闭原则的倾斜性，它以一种倾斜的方式实现开闭原则，为新增产品族提供方便，但不能为新增产品等级结构提供方便，因此要求设计人员在设计之初能够考虑全面，不会在设计完成之后修改产品等级结构，否则后期的维护会十分不便。
 *  #### 优缺点分析 ####
    
     *  ##### 优点 #####
        
         *  隔离了具体类的生成，户端不需要知道什么被创建，由于这种隔离，更换一个工厂就变的相对容易。
         *  当一个产品族中的多个对象被设计成一起工作时，能够保证客户使用的始终是同一个产品族中的对象。
         *  增加新的产品族很方便，无需修改已有的系统，符合开闭原则。
     *  ##### 缺点 #####
        
         *  增加新的产品等级结构十分麻烦，对原有系统需要进行较大的修改，违背了开闭原则。
     *  ##### 适用环境 #####
        
        在以下情况下可以考虑使用抽象工厂模式：  
        1. 一个系统不应当依赖于产品如何创建、组合和表达的细节，这对所有类型的工厂模式都是十分重要的，用户无需关心对象的创建过程，实现对象的创建和使用解耦；  
        2. 系统中有多于一个的产品族，且每次只使用某一个产品族；  
        3. 属于同一个产品族的产品将在一起使用；  
        4. 产品等级结构文档，在设计完成后不会修改产品中的等级结构；
 *  #### 自练习习题 ####
    
     *  一个电器工厂可生产多种类型的电器，如海尔工厂可以生产海尔电视机、海尔空调、海尔冰箱，TCL工厂可以生产TCL电视机、TCL空调等等，相同品牌的电器构成一个产品族，而相同类型的电器构成了一个产品等级结构，使用抽象工厂模式模拟该场景。
    
    ## 自律即自由！！！ ##
    
    ***半原创博客，用以记录学习，希望可以帮到您，不喜可喷。***  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA_size_16_color_FFFFFF_t_70 4]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191127143228744.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191127144950870.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191127145349913.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191127150548714.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191108163740680.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA==,size_16,color_FFFFFF,t_70