常用设计模式——深入理解工厂模式

男娘i 2022-03-11 12:38 222阅读 0赞

**工厂模式**  
工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式 在设计模式当时它属于**创建性模式** 而它却又分成了简单工厂模式、工厂方法模式、抽象工厂模式。  
  
  
**场景：**  
在开发过程中想必大家都对接过支付接口，而在选择支付方式的时候常常有很多种，如银联、支付宝 等，在随着系统逐渐运行，假如我们现在需要添加微信支付，而在这时我们怎么应对系统扩展呢？

# **一：简单工厂** #

**定义：简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现**  
  
  
上代码：  
我们先创建一个支付接口，接着创建支付宝支付，微信支付 代码如下：

支付接口：

package com.designpattern.factory;
    
    /**
     * 支付接口
     * zhan_lang
     */
    public interface Pay {
    
        void create();
    
    }

支付宝支付：

package com.designpattern.factory;
    
    /**
     * 支付宝支付
     * zhan_lang
     */
    public class AliPay implements Pay {
    
    
        @Override
        public void create() {
            System.out.println("支付宝支付");
        }
    
    
    }

微信支付：

package com.designpattern.factory;
    
    /**
     * 微信支付
     * zhan_lang
     */
    public class Wechat implements Pay {
    
        @Override
        public void create() {
            System.out.println("微信支付");
        }
    
    
    }

现在我们支付方式有了 那么我们怎么来获取支付方式呢？在这里简单工厂只需要获取对象实例即可，代码实现如下：

package com.designpattern.factory.simple;
    
    import com.designpattern.factory.AliPay;
    import com.designpattern.factory.Pay;
    import com.designpattern.factory.Wechat;
    import org.springframework.util.StringUtils;
    
    /**
     * zhan_lang
     * 简单工厂创建类
     */
    public class PayFactory {
    
    
        /**
         * 简单方式
         * @param name
         * @return
         */
        public Pay create(String name){
    
            if ("wechat".equals(name)){
                return new Wechat();
            }else if ("alipay".equals(name)){
                return new AliPay();
            }
            return null;
    
        }
    
        /**
         * className 方式
         * @param s
         */
        public Pay createByClassName(String s)  {
    
            try {
                if (!StringUtils.isEmpty(s)){
                    return (Pay) Class.forName(s).newInstance();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
    
            return null;
        }
    
    
        /**
         * clazz
         * @param clazz
         */
        public Pay createByClazz(Class<?> clazz) {
            try {
                if (clazz != null){
                    return (Pay) clazz.newInstance();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
    
            return null;
        }
    }

获取对象实例写好了 我们来调用一波，

package com.designpattern.factory.simple;
    
    import com.designpattern.factory.AliPay;
    import com.designpattern.factory.Pay;
    import com.designpattern.factory.Wechat;
    
    /**
     * 简单工厂
     *  优点：只需要传入一个正常的参数则可以获取一个实例 无需关注创建过程
     *  缺点：创建过程简单 不易于扩展 如果新增工厂类 需要修改判断 违背了开闭原则
     * zhan_lang
     */
    public class PayTest {
    
    
        public static void main(String[] args) {
    
            //未用工厂
            Pay pay = new Wechat();
            pay.create();
    
            //最原始方式(必须传入正常字符串判断)
            PayFactory payFactory = new PayFactory();
            payFactory.create("alipay").create();
    
            //ClassName 必须传入正常包点类名
            PayFactory payFactory1 = new PayFactory();
            payFactory1.createByClassName("com.designpattern.factory.AliPay").create();
    
    
            //calzz 传入已有类
            PayFactory payFactory2 = new PayFactory();
            payFactory2.createByClazz(AliPay.class).create();
    
    
        }
    
    }

简单工厂模式就是如此简单 只需要提供创建对象实例的方法就可以了 但是这里请注意 我们在判断获取哪个对象实例的时候 如果还是用if-else-if 来判断是不是有点说不过去了（太low了 有100种实例 你会判断100次吗 反正我不会） 所以我们改用以反射的方式来获取对象实例。  
至于简单工厂模式的优缺点 在调用的时候已经写出来 这里就不在啰嗦了。

# **二：工厂方法模式** #

**定义：工厂方法模式使用的频率非常高，在我们日常开发中总是能看到它的影子，其定义为：定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。**

上代码：  
这里我们还是运用支付方式来跟大家讲解 对象实例还是运用简单工厂模式里面的实例 但是我们这里需要单独创建一个工厂接口 抽象出一个支付接口 然后支付方式去实现工厂接口 这样我们创建类的实例就可以延迟到子类了。代码如下：

工厂接口：

package com.designpattern.factory.factory;
    
    import com.designpattern.factory.Pay;
    
    /**
     * 工厂接口
     * zhan_lang
     */
    public interface PayFactory {
    
        //如果工厂类需要自己的业务逻辑处理 则可以将接口改成抽象类来保留
    
        Pay create();
    
    }

创建对象实例：在这里我们就这个类实例化过程交给了子类了

package com.designpattern.factory.factory;
    
    import com.designpattern.factory.AliPay;
    import com.designpattern.factory.Pay;
    
    /**
     * zhan_lang
     */
    public class AliPayFactory implements PayFactory {
    
    
        @Override
        public Pay create() {
            return new AliPay();
        }
    
    
    }

老规矩调用一波：

package com.designpattern.factory.factory;
    
    import com.designpattern.factory.Pay;
    
    /**
     * 工厂方法模式
     * 优点：没有违背开闭原则 提高了扩展性 类过多（新增则需要添加工厂类和基类）
     * 缺点：增加了系统的抽象性和理解难度
     * zhan_lang
     */
    public class PayTest {
    
        public static void main(String[] args) {
            PayFactory payFactory = new AliPayFactory();
            Pay pay = payFactory.create();
            pay.create();
    
        }
    
    }

这样工厂方法模式就完成了 但是需要注意的是 工厂接口不仅仅只能是接口类型 如果它有自己的业务逻辑 则可以将接口改成抽象类 这里我们就不演示代码了

# **三：抽象工厂模式** #

在简单工厂和工厂方法模式当中 支付方式是出来了 在一个传统的支付当中 光有支付怎么行 我们的支付记录呢 那这种情况我们又该怎么办呢？请看抽象工厂模式

**定义：抽象工厂模式（Abastract Factory Pattern）是指提供一个创建一系列相关或相互依赖对象的接口，无须指定他们具体的类**  
上代码：  
这里我们先创建工厂接口 并提供支付和支付记录两个接口

package com.designpattern.factory.abstractfactory;
    
    /**
     * 抽象顶层接口
     * 在真实的支付场景中 我们是不光只有支付过程的  我们还有支付记录 对于这样一个系列多个产品的场景我们怎么来处理呢？
     * zhan_lang
     */
    public interface PayFactory {
    
        IPay createPay();
    
        IPayRecord createRecord();
    
    }

然后创建支付接口并提供方法

package com.designpattern.factory.abstractfactory;
    
    /**
     * 支付
     * zhan_lang
     */
    public interface IPay {
    
        void createPay();
    
    }

package com.designpattern.factory.abstractfactory;
    
    /**
     * 创建支付宝支付
     * zhan_lang
     */
    public class AliPay implements  IPay {
    
    
        @Override
        public void createPay() {
            System.out.println("创建支付宝支付");
        }
    
    }

创建支付记录接口并提供方法

package com.designpattern.factory.abstractfactory;
    
    /**
     * 支付记录
     * zhan_lang
     */
    public interface IPayRecord {
    
    
        void createRecord();
    
    }

package com.designpattern.factory.abstractfactory;
    
    /**
     * 产生支付记录
     * zhan_lang
     */
    public class AliPayRecord implements  IPayRecord {
    
    
        @Override
        public void createRecord() {
            System.out.println("产生支付记录");
        }
    }

创建支付宝工厂类 并提供支付和支付记录方法

package com.designpattern.factory.abstractfactory;
    
    /**
     * 支付宝工厂
     */
    public class AliPayFactory implements  PayFactory {
    
    
        @Override
        public IPay createPay() {
            return new AliPay();
        }
    
        @Override
        public IPayRecord createRecord() {
            return new AliPayRecord();
        }
    
    
    }

最后调用一波

package com.designpattern.factory.abstractfactory;
    
    /**
     * 抽象工厂模式
     * 优点：将一个系列的多个产品一起创建
     * 缺点：增加了系统的抽象性和理解难度 扩展新的产品比较困难 需要修改抽象工厂接口
     * zhan_lang
     */
    public class AbstractFactoryTest {
    
    
        public static void main(String[] args) {
            PayFactory payFactory = new AliPayFactory();
            payFactory.createPay().createPay();
            payFactory.createRecord().createRecord();
        }
    
    }

完美实现 有没有 ？这里同工厂方法模式一样 如果工厂接口有其他业务逻辑 可以换成抽象类来实现  
最后将类图提供给大家 方便大家理解 在idea当中 显示类图快捷键为：ctrl+Shift+Alt+U  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5fbGFuZw_size_16_color_FFFFFF_t_70]

在这里工厂方法模式就介绍完了 你了解了吗？  
最后,最后提醒大家 要学以致用 这样才不会忘 才能写出更高逼格的代码 ！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5fbGFuZw_size_16_color_FFFFFF_t_70]: /images/20220311/1db3785a93a44d1fa4a281d292810e4a.png