设计模式-工厂模式

Gloduck 发布于

文章访问量

    定义

    • 定义：Define an interface for creating an object,but let subclasses decide which class to instance.Factory Method lets a class defer instantiation to subclasses.（定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到子类）

    优点

    • 良好的封装性，代码结构清晰。（不需要知道创建对象的过程，只需要知道产品的类名或约束字符串就可以完成对象的创建。降低模块之间的耦合）
    • 工厂模式方法的扩展性优秀。（在增加产品类的情况下，只要适当地修改具体的工厂类，或扩展一个工厂类，就可以完成”拥抱变化”）
    • 屏蔽产品类。（产品类的实现如何变化，调用者都不用关心，它只关系产品的接口，只要接口保持不变，系统中的上层模块就不要发生变化）。

    使用场景

    • 需要灵活的，可扩展的框架时。（要慎重考虑是否使用工厂类管理，会增加代码的复杂性）
      • 举例：
        1. 连接邮件服务器的框架，有三种网络协议可以选择：POP3、IMAP、HTTP。可以把这三种连接方法作为产品类

    分类

    通用类图

    工厂方法模式通用类图

    工厂方法模式通用类图

    延迟加载的工厂模式通用类图

    延迟初始化工厂模式通用类图

    工厂模式（模板）

    简介

    • 工厂模式的变种比较多，以下是一个比较通用的工厂模式模板

    类图

    模板类图

    代码

    抽象产品类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    package com.pattern.factory.products;

    public abstract class Product {
        public Product(){}
        public void method1(){
            // 产品类公共方法
            System.out.println("执行了产品类共有方法");
        }
        // 产品类抽象方法
        public abstract void method2();
    }

    具体产品类（继承自抽象产品类）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    package com.pattern.factory.products;

    public class Product1 extends Product {
        public Product1(){
            super();
        }
        @Override
        public void method2() {
            // 业务逻辑
            System.out.println("执行了产品1的方法");
        }
    }

    package com.pattern.factory.products;

    public class Product2 extends Product {
        public Product2(){
            super();
        }
        @Override
        public void method2() {
            // 业务逻辑
            System.out.println("执行了产品2的方法");
        }
        
    }

    抽象工厂类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    package com.pattern.factory.template;

    import com.pattern.factory.products.Product;

    public abstract class AbstractFactory {
        public AbstractFactory(){};
        /**
         * 抽象工厂方法，对参数做了两层限制
         * 1.产品必须继承于Product
         * 2.入参必须是Class
         */
        public abstract <T extends Product> T createProduct(Class<T> c);
    }

    具体工厂类（继承自抽象工厂类）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    package com.pattern.factory.template;

    import com.pattern.factory.products.Product;

    public class ConcreteFactory extends AbstractFactory {
        public ConcreteFactory(){
            super();
        }
        @Override
        public <T extends Product> T createProduct(Class<T> c) {
            Product product = null;
            try{
                // 反射创建产品
                product = (Product)Class.forName(c.getName()).newInstance();
            } catch (Exception e){
                // 异常处理
            }
            return (T) product;
        }
    }

    测试方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    @Test
    // 通用工厂类模板测试
    public void FactoryTemplateTest(){
        AbstractFactory factory = new ConcreteFactory();
        // 工厂创建产品1
        Product product = factory.createProduct(Product1.class);
        product.method1();
        product.method2();
    }

    测试结果

    工厂模式模板测试结果

    静态工厂模式

    简介

    • 工厂模式的一种弱化，称为简单工厂模式或静态工厂模式，实际项目中使用的比较多
    • 缺点
      • 扩展困难，不符合开闭原则

    类图

    静态工厂

    代码

    静态工厂类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    package com.pattern.factory.extend.staticfactory;

    import com.pattern.factory.products.Product;

    public class Factory {
        /**
         * 静态工厂方法，对参数做了两层限制 
         * 1.产品必须继承于Product 
         * 2.入参必须是Class
         */
        public static <T extends Product> T createProduct(Class<T> c){
            Product product = null;
            try{
                // 反射创建产品
                product = (Product)Class.forName(c.getName()).newInstance();
            } catch (Exception e){
                // 异常处理
            }
            return (T) product;
        };
    }

    产品类

    • 同上

    测试方法

    1
    2
    3
    4
    5
    6
    7
    8
    @Test
    // 静态工厂测试
    public void StaticFactoryTest(){
        // 工厂创建产品
        Product product = Factory.createProduct(Product1.class);
        product.method1();
        product.method2();
    }

    测试结果

    静态工厂测试结果

    多工厂模式

    简介

    • 为每一个产品定义一个工厂，由调用者去选择与那个工厂方法关联
    • 每个工厂都独立负责创建对应的产品对象，符合单一职责原则
    • 复杂应用一般使用多工厂的方法，然后增加一个协调类，用于封装子工厂类，对高层模块提供统一的访问接口
    • 缺点
      • 扩展困难（每增加一个产品类就需要建立一个相应的工厂类，同时维护时还需要考虑两个对象之间的关系）

    类图

    多工厂模式

    代码

    抽象多工厂类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    package com.pattern.factory.extend.multifactory;

    import com.pattern.factory.products.Product;

    public abstract class AbstractMultiFactory {
        public AbstractMultiFactory(){}
        // 此处已经不需要泛型以及参数了，因为每个具体的工厂已经明确了自己的职责，复制生产产品
        public abstract Product createProduct();
    }

    产品1生产工厂类（继承自抽象多工厂类）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    package com.pattern.factory.extend.multifactory;

    import com.pattern.factory.products.Product;
    import com.pattern.factory.products.Product1;

    public class Product1Factory extends AbstractMultiFactory {
        public Product1Factory(){
            super();
        }
        @Override
        public Product createProduct() {
            return new Product1();
        }
    }

    产品2生产工厂类（继承自抽象多工厂类）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    package com.pattern.factory.extend.multifactory;

    import com.pattern.factory.products.Product;
    import com.pattern.factory.products.Product2;

    public class Product2Factory extends AbstractMultiFactory {
        public Product2Factory(){
            super();
        }
        @Override
        public Product createProduct() {
            return new Product2();
        }
    }

    产品类

    • 同上

    测试代码

    1
    2
    3
    4
    5
    6
    7
    8
    @Test
    // 多工厂测试
    public void MultiFactoryTest(){
        AbstractMultiFactory factory = new Product1Factory();
        Product product = factory.createProduct();
        product.method1();
        product.method2();
    }

    测试结果

    多工厂测试结果

    单例工厂模式

    简介

    • 通过工厂模式反射来生成单例对象
    • 在一个项目中可以产生一个单例构造器，所有需要产生单例的类都遵循一定的规则（构造方法是private），然后通过扩展该框架，只需要输入一个类型就可以获得唯一的一个实例

    类图

    单例工厂类图

    代码

    单例工厂类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    package com.pattern.factory.extend.singletonfactory;

    import java.lang.reflect.Constructor;

    import com.pattern.factory.products.SingletonProduct;

    public class SingletonFactory {
        private static SingletonProduct singletonProduct;
        // 静态代码块初始化单例对象s
        static{
            try{
                Class cl = Class.forName(SingletonProduct.class.getName());
                // 获取无参构造方法
                Constructor constructor = cl.getDeclaredConstructor();
                // 设置无参构造方法可访问
                constructor.setAccessible(true);
                // 产生一个对象
                singletonProduct = (SingletonProduct) constructor.newInstance();
            } catch(Exception e){
                // 处理异常
            }
        }
        public static SingletonProduct getInstance(){
            return singletonProduct;
        }
    }

    单例产品类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    package com.pattern.factory.products;

    public class SingletonProduct {
        // 构造私有化
        private SingletonProduct(){}
        public void method(){
            // 业务逻辑
            System.out.println("生产的单例产品");
        }
    }

    测试代码

    1
    2
    3
    4
    5
    6
    @Test
    // 单例工厂测试
    public void SingletonFactoryTest(){
        SingletonProduct product = SingletonFactory.getInstance();
        product.method();
    }

    测试结果

    单例工厂测试结果

    注意

    • 工厂模式是典型的解耦框架，符合下列原则
      • 迪米特法则：高层模块只需要知道产品的抽象类，其他的实现类都不用关心。我不需要的就不要去交流。
      • 依赖倒置原则：只依赖产品类的抽象。
      • 里氏替换原则：可以使用产品子类替换产品父类。
    • 此处使用的是抽象类而非接口，实际上根据工厂模式的定义，使用两者都可以，选择的关键就在于对于产品类而言，是否有共有的构造或者方法。
    Gloduck

    Gloduck

    努力赶上大佬

    96
    0
    33
    TOC
    1. 1. 定义
    2. 2. 优点
    3. 3. 使用场景
    4. 4. 分类
      1. 4.1. 通用类图
      2. 4.2. 工厂模式（模板）
        1. 4.2.1. 简介
        2. 4.2.2. 类图
        3. 4.2.3. 代码
        4. 4.2.4. 测试结果
      3. 4.3. 静态工厂模式
        1. 4.3.1. 简介
        2. 4.3.2. 类图
        3. 4.3.3. 代码
        4. 4.3.4. 测试结果
      4. 4.4. 多工厂模式
        1. 4.4.1. 简介
        2. 4.4.2. 类图
        3. 4.4.3. 代码
        4. 4.4.4. 测试结果
      5. 4.5. 单例工厂模式
        1. 4.5.1. 简介
        2. 4.5.2. 类图
        3. 4.5.3. 代码
        4. 4.5.4. 测试结果
    5. 5. 注意
    NOTICE

    一个菜鸡JAVA后端的博客～

    CATEGORYS
      TAGS
      Bat Blog Code DesignPartten Git Gridea HTML Idea JVM Java Linux Multithreading Netty Network OpenWrt Other SQL Shell Software SourceCode Spring SpringBoot Sring Tool WebSite Windows XiaoMi Zookeeper java 其他 记录 路由器 闲杂