创建型设计模式--工厂模式、抽象工厂模式

回到顶部

一、小案例分析

1、功能需求：

　　实现一个发送信息的功能，要便于扩展与维护。
（1）发送信息的工具有很多，比如短信、微信、邮件、QQ等。
（2）选择某个工具进行信息发送。

2、小菜鸡去实现：

（1）定义一个发送工具的父类（接口），并将各种发送工具作为子类（实现类）。
（2）定义一个选择发送工具的类，用于调用发送工具（直接new个子类对象）。
（3）代码实现：

package creative.pattern.factory.noFactory;

import java.util.Scanner;

/**
 * 测试类
 *
 */
public class Demo {
    public static void main(String[] args) {
        new SendMessage();// 实例化一个选择发送工具的类
    }
}

/**
 * 定义一个发送工具的接口
 *
 */
interface Sender {
    void sendMessage();
}

/**
 * 定义一个短信发送工具，实现接口，重写方法
 *
 */
class ShortMessageSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("发送短信");
    }
}

/**
 * 定义一个微信发送工具，实现接口，重写方法
 *
 */
class WeChatSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("发送微信");
    }
}

/**
 * 定义一个邮件发送工具，实现接口，重写方法
 *
 */
class MailSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("发送邮件");
    }
}

/**
 * 定义一个选择发送工具的类
 */
class SendMessage {
    /**
     * 用于获取需要发送信息工具
     */
    public Sender getSenderType() {
        System.out.println("输入发送工具的类型（1-3）：");
        System.out.println("1:短信");
        System.out.println("2:微信");
        System.out.println("3:邮件");
        Scanner scanner = new Scanner(System.in);
        String senderType = scanner.nextLine();
        if ("1".equals(senderType)) {
            return new ShortMessageSender();
        } else if ("2".equals(senderType)) {
            return new WeChatSender();
        } else if ("3".equals(senderType)) {
            return new MailSender();
        } else {
            return null;
        }
    }

    public SendMessage() {
        do {
            Sender sender = getSenderType();// 选择发送信息的工具
            if (sender == null) {
                System.out.println("欢迎下次使用");
                break;
            } else {
                sender.sendMessage();
            }
        } while (true);
    }
}

（4）代码分析：
　　对于逻辑简单的代码，这样实现没有问题，但是逻辑稍微复杂一些且需要修改扩展某个地方时，需要改动很多地方。
　　比如：再增加一个 QQSender，其需要实现Sender接口，并重写相关方法，然后需要在 SendMessage 类中 去修改相关代码，这里违反了开闭原则。若需要增加几个SendMessage 类，比如SendMessage2、SendMessage3时，同样需要改动很多代码。
（5）UML图：

回到顶部

二、简单工厂模式（SimpleFactory）

1、什么是简单工厂模式：

　　简单工厂模式属于创建型模式，不属于常见的23种常见模式。简单的讲 简单工厂模式是由一个工厂对象决定创建出哪一类产品的实例。

2、使用：

（1）简单工厂模式，定义了一个创建对象的类，然后由这个类来封装实例化对象的操作。
（2）当需要大量创建某种类或者对象时，可以使用工厂模式。

3、使用简单工厂模式实现：

（1）定义一个发送工具的父类（接口），并将各种发送工具作为子类（实现类）。
（2）定义一个工厂类，用于调用发送工具。
（2）定义一个选择发送工具的类，用于调用工厂类。
（3）代码实现：

package creative.pattern.factory.simpleFactory;

import java.util.Scanner;

/**
 * 测试类
 *
 */
public class SimpleFactoryDemo {
    public static void main(String[] args) {
        new SendMessage();
    }
}

/**
 * 定义一个发送工具的接口
 *
 */
interface Sender {
    void sendMessage();
}

/**
 * 定义一个短信发送工具，实现接口，重写方法
 *
 */
class ShortMessageSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("发送短信");
    }
}

/**
 * 定义一个微信发送工具，实现接口，重写方法
 *
 */
class WeChatSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("发送微信");
    }
}

/**
 * 定义一个邮件发送工具，实现接口，重写方法
 *
 */
class MailSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("发送邮件");
    }
}

/**
 * 使用简单工厂模式，管理需要生产的对象
 *
 */
class SimpleFactory {
    /**
     * 用于获取需要发送信息工具
     */
    public static Sender createSender() {
        System.out.println("输入发送工具的类型（1-3）：");
        System.out.println("1:短信");
        System.out.println("2:微信");
        System.out.println("3:邮件");
        Scanner scanner = new Scanner(System.in);
        String senderType = scanner.nextLine();
        if ("1".equals(senderType)) {
            return new ShortMessageSender();
        } else if ("2".equals(senderType)) {
            return new WeChatSender();
        } else if ("3".equals(senderType)) {
            return new MailSender();
        } else {
            return null;
        }
    }
}

/**
 * 定义一个选择发送工具的类
 */
class SendMessage {
    public SendMessage() {
        do {
            Sender sender = SimpleFactory.createSender();// 选择发送信息的工具
            if (sender == null) {
                System.out.println("欢迎下次使用");
                break;
            } else {
                sender.sendMessage();
            }
        } while (true);
    }
}

（4）代码分析：
　　对于上述代码，SendMessage 只与工厂类SimpleFactory 相关联，此时需要扩展代码时，比如扩展QQSender，让其实现Sender并重写方法后，在SimpleFactory 中改变相关代码即可（违反开闭原则），不需要再改动SendMessage 的代码。
（5）UML图：

4、使用静态工厂模式实现（常用形式）：

　　将上例的SimpleFactory 中public Sender createSender()改为 public static Sender createSender()。
　　调用时，直接使用SimpleFactory.createSender() 即可。

 public static Sender createSender() {
        System.out.println("输入发送工具的类型（1-3）：");
        System.out.println("1:短信");
        System.out.println("2:微信");
        System.out.println("3:邮件");
        Scanner scanner = new Scanner(System.in);
        String senderType = scanner.nextLine();
        if ("1".equals(senderType)) {
            return new ShortMessageSender();
        } else if ("2".equals(senderType)) {
            return new WeChatSender();
        } else if ("3".equals(senderType)) {
            return new MailSender();
        } else {
            return null;
        }
    } 

回到顶部

三、工厂方法模式

1、什么是工厂方法模式：

　　在工厂内部定义一个创建对象的抽象方法，由子类去确定要实例化的对象。简单的讲 工厂方法模式将对象实例化的操作推迟到子类去实现。可以看做抽象工厂模式的一个常见类型。

2、使用工厂模式实现：

（1）定义一个发送工具的父类（接口），并将各种发送工具作为子类（实现类）。
（2）定义一个工厂方法接口，并通过工厂实现类去实例化对象。
（3）定义一个选择发送工具的类，用于调用工厂实现类。
（4）代码实现：

package creative.pattern.factory.factoryMethod;

import java.util.Scanner;

/**
 * 工厂方法模式测试类
 *
 */
public class factoryMethodDemo {
    public static void main(String[] args) {
        new SendMessage();
    }
}

/**
 * 定义一个发送工具的接口
 *
 */
interface Sender {
    void sendMessage();
}

/**
 * 定义一个短信发送工具，实现接口，重写方法
 *
 */
class ShortMessageSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("发送短信");
    }
}

/**
 * 定义一个微信发送工具，实现接口，重写方法
 *
 */
class WeChatSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("发送微信");
    }
}

/**
 * 定义一个邮件发送工具，实现接口，重写方法
 *
 */
class MailSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("发送邮件");
    }
}

/**
 * 使用工厂方法模式，让子类去创建对象
 *
 */
interface FactoryMethod {
    Sender sendMessage();
}

/**
 * 短信工厂类，实现工厂方法类并重写相关方法
 *
 */
class ShortMessageFactory implements FactoryMethod {

    @Override
    public Sender sendMessage() {
        return new ShortMessageSender();
    }
}

/**
 * 微信工厂类，实现工厂方法类并重写相关方法
 *
 */
class WeChatFactory implements FactoryMethod {

    @Override
    public Sender sendMessage() {
        return new WeChatSender();
    }
}

/**
 * 邮件工厂类，实现工厂方法类并重写相关方法
 *
 */
class MailFactory implements FactoryMethod {

    @Override
    public Sender sendMessage() {
        return new MailSender();
    }
}

/**
 * 定义一个选择发送工具的类
 */
class SendMessage {
    public SendMessage() {
        do {
            System.out.println("输入发送工具的类型（1-3）：");
            System.out.println("1:短信");
            System.out.println("2:微信");
            System.out.println("3:邮件");
            Scanner scanner = new Scanner(System.in);
            String senderType = scanner.nextLine();
            if ("1".equals(senderType)) {
                FactoryMethod factoryMethod = new ShortMessageFactory();
                Sender sender = factoryMethod.sendMessage();// 选择发送短信
                sender.sendMessage();
            } else if ("2".equals(senderType)) {
                FactoryMethod factoryMethod = new WeChatFactory();
                Sender sender = factoryMethod.sendMessage();// 选择发送微信
                sender.sendMessage();
            } else if ("3".equals(senderType)) {
                FactoryMethod factoryMethod = new MailFactory();
                Sender sender = factoryMethod.sendMessage();// 选择发送邮件
                sender.sendMessage();
            } else {
                System.out.println("欢迎下次使用");
                break;
            }
        } while (true);
    }
}

（5）代码分析：
　　SendMessage 类只与FactoryMethod 有关，当扩展新的功能时，比如QQSender，只需创建一个QQFactory，实现FactoryMethod 并重写其方法即可，调用时无需更改其他代码（必要的逻辑处理除外，符合开闭原则）。
（6）UML图：

回到顶部

四、抽象工厂模式

1、什么是抽象工厂模式

　　为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。
注：
　　产品族：是指位于不同产品等级结构中功能相关联的产品组成的家族。
　　产品等级结构：可以理解为一个接口或者一个抽象类。

2、抽象工厂模式与工厂方法模式的区别

（1）抽象工厂模式是工厂方法模式的升级版，其针对的是多个产品等级结构，即抽象工厂模式所提供的产品是衍生自不同的接口或抽象类。
（2）工厂方法模式：针对一个产品等级结构，即工厂方法模式衍生自同一个接口或者抽象类。
（3）如下图所示，ShortMessage 与 WeChat属于同一个产品等级，ShortMessage 与 ShortMessage2属于两个产品等级，为产品族。所以若存在两个产品等级及以上的情况，即为抽象工厂模式，若是同一个产品等级，则为工厂方法模式。
　　下图为工厂方法模式：

下图为抽象工厂模式：

3、举例：

　　在之前案例的基础上，增加一个功能，微信、短信均可以图片。
（1）定义一个发送工具的父类（接口），并将各种发送工具作为子类（实现类）。
（2）定义一个工厂方法接口，在方法中对产品族进行约束，并通过工厂实现类去实例化对象。
（3）定义一个选择发送工具的类（测试类），用于调用工厂实现类。
（4）代码实现：

package creative.pattern.factory.absFactory;

/**
 * 抽象工厂模式测试类
 *
 */
public class AbsFactoryDemo {
    public static void main(String[] args) {
        AbsFactory absFactory = new WeChatFactory();
        absFactory.getSender().sendMessage();
        absFactory.getSender2().sendMessage();
        ((WeChatSender2) absFactory.getSender2()).sendPicture();

        AbsFactory absFactory2 = new ShortMessageFactory();
        absFactory2.getSender().sendMessage();
        absFactory2.getSender2().sendMessage();
        ((ShortMessageSender2) absFactory2.getSender2()).sendPicture();
    }
}

/**
 * 定义一个发送工具的接口
 *
 */
interface Sender {
    void sendMessage();
}

/**
 * 定义一个微信发送工具，实现接口，重写方法
 *
 */
class WeChatSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("使用微信，发送短信");
    }
}

/**
 * 定义一个微信发送工具，实现接口，重写方法，并新增自己的方法
 *
 */
class WeChatSender2 implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("使用微信，发送短信");
    }

    public void sendPicture() {
        System.out.println("使用微信，发送图片");
    }
}

/**
 * 定义一个短信发送工具，实现接口，重写方法
 *
 */
class ShortMessageSender implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("使用短信，发送短信");
    }
}

/**
 * 定义一个短信发送工具，实现接口，重写方法，并新增自己的方法
 *
 */
class ShortMessageSender2 implements Sender {

    @Override
    public void sendMessage() {
        System.out.println("使用短信，发送短信");
    }

    public void sendPicture() {
        System.out.println("使用短信，发送图片");
    }
}

/**
 * 抽象工厂模式
 *
 */
interface AbsFactory {
    Sender getSender();

    Sender getSender2();
}

/**
 * 工厂子类，实现抽象工厂类，重写相关方法，
 *
 */
class WeChatFactory implements AbsFactory {

    @Override
    public Sender getSender() {
        return new WeChatSender();
    }

    @Override
    public Sender getSender2() {
        return new WeChatSender2();
    }
}

/**
 * 工厂子类，实现抽象工厂类，重写相关方法，
 *
 */
class ShortMessageFactory implements AbsFactory {

    @Override
    public Sender getSender() {
        return new ShortMessageSender();
    }

    @Override
    public Sender getSender2() {
        return new ShortMessageSender2();
    }
}

（5）代码分析：
　　对于产品族，定义在一个接口中，然后通过不同的子类去实现。扩展时，只需要实现接口并重写相关方法即可，满足开闭原则。

（6）UML图：

回到顶部

五、JDK中工厂模式举例（Calendar）

1、部分源码

public abstract class Calendar implements Serializable, Cloneable, Comparable<Calendar> {
    /**
     * Gets a calendar using the default time zone and locale. The
     * <code>Calendar</code> returned is based on the current time
     * in the default time zone with the default
     * {@link Locale.Category#FORMAT FORMAT} locale.
     *
     * @return a Calendar.
     */
    public static Calendar getInstance()
    {
        return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
    }

     private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;

        if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "Gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        if (cal == null) {
            // If no known calendar type is explicitly specified,
            // perform the traditional way to create a Calendar:
            // create a BuddhistCalendar for th_TH locale,
            // a JapaneseImperialCalendar for ja_JP_JP locale, or
            // a GregorianCalendar for any other locales.
            // NOTE: The language, country and variant strings are interned.
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                       && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }
}

2、源码分析

　　Calendar内部采用简单工厂模式进行对象的实例化。其根据不同的逻辑判断条件来选择实例化具体的对象。

回到顶部

六、总结：

1、工厂模式的意义：

　　将实例化对象的代码提取出来，放到一个类（工厂类）里面进行维护，使其与主项目解耦，提高程序的维护性与扩展性。

2、传统模式：

　　直接在需要的地方实例化某对象。扩展代码时，需要在使用到的地方进行修改，违反了开闭原则。

3、简单工厂模式：

　　在需要用到的地方，调用工厂类即可，扩展代码时，修改工厂类即可，也违反了开闭原则。
（1）简单工厂模式（普通方法）：
　　使用一个工厂类，在某方法中通过逻辑处理并实例化需要的对象。
（2）简单工厂模式（静态方法）：
　　将简单工厂模式（普通方法）的普通方法改为静态方法，并通过”类名.方法名“来调用。
（3）简单工厂模式（多方法）：
　　使用一个工厂类，并通过调用不同的方法去实例化不同的对象。

4、工厂方法模式：

　　使用一个工厂类接口与多个工厂实现类，在不同的工厂实现类中去实例化不同的对象。扩展代码时，定义一个工厂实现类，实现工厂类接口并重写相关方法即可，满足开闭原则。可以理解为抽象工厂模式的一般形式。

5、抽象工厂模式：

　　可以理解为工厂方法模式的升级版，其在一个接口中定义了一个产品族的处理（多个方法），子类实现该接口，并重写相关方法即可，扩展类似于工厂方法模式，满足开闭原则。