您好,欢迎访问代理记账网站
移动应用 微信公众号 联系我们

咨询热线 -

电话 15988168888

联系客服
  • 价格透明
  • 信息保密
  • 进度掌控
  • 售后无忧

dayOne-设计原则,工厂模式,单例模式

容器单例

package com.example.demo.oneDay;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 *  Description:
 *  @auther zhangXiangYu
 *  @date 2021/6/22 0:35
 */
public class ContainerSingleton {

    private ContainerSingleton() {
    }

    ;

    private static Map<String, Object> ioc = new ConcurrentHashMap<String, Object>();

    public static Object getBean(String className) {
        synchronized (ioc) {
            if (!ioc.containsKey(className)) {
                Object obj = null;
                try {
                    obj = Class.forName(className).newInstance();
                    ioc.put(className, obj);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return obj;
            }
            return ioc.get(className);
        }
    }
}

枚举单例

package com.example.demo.oneDay;

import java.lang.reflect.Constructor;

/**
 *  Description:
 *  @auther zxy
 *  @date 2021/6/22 0:34
 */
public enum EnumSingle {

    INSTANCE;

    public EnumSingle getInstance() {
        return INSTANCE;
    }
}

class Test {

    public static void main(String[] args) throws Exception {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1 == instance2);

    }
}

饿汉式

package com.example.demo.oneDay;

/**
 *  Description:
 *  @auther zxy
 *  @date 2021/6/22 0:31
 */
public class Hungry {

    //浪费空间
    private byte[] data1 = new byte[1024 * 1024];

    private byte[] data2 = new byte[1024 * 1024];

    private byte[] data3 = new byte[1024 * 1024];

    private byte[] data4 = new byte[1024 * 1024];

    private Hungry() {

    }

    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance() {
        return HUNGRY;
    }

    //对象的实例是静态的,就说明我们即使不适用这个对象,它也存在,那么如果这个变量占用内存很大,那么很显然会造成浪费

}

懒汉式

package com.example.demo.oneDay;

/**
 *  Description:
 *  @auther zhangXiangYu
 *  @date 2021/6/22 0:32
 */
public class LazyManDemo {

    //县城不安全
    private static LazyMan lazyMan;

    public static LazyMan getInstance() {
        if (lazyMan == null) {
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }

    //双重监察所
    private volatile static LazyMan lazyMan1;

    public static LazyMan getInstance1() {
        //双重检测
        if (lazyMan1 == null) {
            synchronized (LazyMan.class) {
                if (lazyMan1 == null) {
                    lazyMan1 = new LazyMan();
                }
            }
        }
        return lazyMan1;
    }

    //反射,可以直接无视私有的构造方法去直接new对象,会破坏单例模式

}

工厂模式

一、简单工厂模式

概述

  简单工厂模式:定义一个工厂类,它可以根据参数的不同返回不同类的 实例,被创建的实例通常都具有共同的父类。因为在简单工厂模式中用于创建实例的方法是静态(static)方法,因此简单工厂模式又被称为静态工厂方法模式,它属于类创建型模式。

 

 

工厂模式结构图

简单工厂模式角色

  在简单工厂模式结构图中包含如下几个角色:

 

Factory(工厂角色):工厂角色即工厂类,它是简单工厂模式的核心,负责实现创建所有产品实例的内部逻辑;工厂类可以被外界直接调用,创建所需的产品对象;在工厂类中提供了静态的工厂方法factoryMethod(),它的返回类型为抽象产品类型Product。

Product(抽象产品角色):它是工厂类所创建的所有对象的父类,封装了各种产品对象的公有方法,它的引入将提高系统的灵活性,使得在工厂类中只需定义一个通用的工厂方法,因为所有创建的具体产品对象都是其子类对象。

ConcreteProduct(具体产品角色):它是简单工厂模式的创建目标,所有被创建的对象都充当这个角色的某个具体类的实例。每一个具体产品角色都继承了抽象产品角色,需要实现在抽象产品中声明的抽象方法。

案例

  Sunny软件公司欲基于Java语言开发一套图表库,该图表库可以为应用系统提供各种不同外观的图表,例如柱状图、饼状图、折线图等。Sunny软件公司图表库设计人员希望为应用系统开发人员提供一套灵活易用的图表库,而且可以较为方便地对图表库进行扩展,以便能够在将来增加一些新类型的图表。

  Sunny软件公司图表库设计人员提出了一个初始设计方案,将所有图表的实现代码封装在一个Chart类中,其框架代码如下所示:

 

class Chart {

    private String type;    //图表类型

    public Chart(Object[][] data, String type) {

        this.type = type;

        if (type.equalsIgnoreCase("histogram")) {

            //初始化柱状图

        } else if (type.equalsIgnoreCase("pie")) {

            //初始化饼状图

        } else if (type.equalsIgnoreCase("line")) {

            //初始化折线图

        }

    }

    public void display() {

        if (this.type.equalsIgnoreCase("histogram")) {

            //显示柱状图

        } else if (this.type.equalsIgnoreCase("pie")) {

            //显示饼状图

        } else if (this.type.equalsIgnoreCase("line")) {

            //显示折线图

        }

    }

}

  客户端代码通过调用Chart类的构造函数来创建图表对象,根据参数type的不同可以得到不同类型的图表,然后再调用display()方法来显示相应的图表。

  不难看出,Chart类是一个“巨大的”类,在该类的设计中存在如下几个问题:

 

在Chart类中包含很多“if…else…”代码块,整个类的代码相当冗长,代码越长,阅读难度、维护难度和测试难度也越大;而且大量条件语句的存在还将影响系统的性能,程序在执行过程中需要做大量的条件判断。

Chart类的职责过重,它负责初始化和显示所有的图表对象,将各种图表对象的初始化代码和显示代码集中在一个类中实现,违反了“单一职责原则”,不利于类的重用和维护;而且将大量的对象初始化代码都写在构造函数中将导致构造函数非常庞大,对象在创建时需要进行条件判断,降低了对象创建的效率。

当需要增加新类型的图表,必须修改Chart类的源代码,违反了“开闭原则”。

客户端只能通过new关键字来直接创建Chart对象,Chart类与客户端类耦合度较高,对象的创建和使用无法分离。

客户端在创建Chart对象之前可能还需要进行大量初始化设置,例如设置柱状图的颜色、高度等,如果在Chart类的构造函数中没有提供一个默认设置,那就只能由客户端来完成初始设置,这些代码在每次创建Chart对象时都会出现,导致代码的重复。

完整解决方案

  为了将Chart类的职责分离,同时将Chart对象的创建和使用分离,Sunny软件公司开发人员决定使用简单工厂模式对图表库进行重构,重构后的结构如下图所示:

 

  从图上我们可以看出,Chart接口充当抽象产品类,其子类HistogramChart、PieChart和LineChart充当具体产品类,ChartFactory充当工厂类。完整代码如下所示:

 

//抽象图表接口:抽象产品类

interface Chart {

    public void display();

}

//柱状图类:具体产品类

class HistogramChart implements Chart {

    public HistogramChart() {

        System.out.println("创建柱状图!");

    }

    public void display() {

        System.out.println("显示柱状图!");

    }

}

//饼状图类:具体产品类

class PieChart implements Chart {

    public PieChart() {

        System.out.println("创建饼状图!");

    }

    public void display() {

        System.out.println("显示饼状图!");

    }

}

//折线图类:具体产品类

class LineChart implements Chart {

    public LineChart() {

        System.out.println("创建折线图!");

    }

    public void display() {

        System.out.println("显示折线图!");

    }

}

//图表工厂类:工厂类

class ChartFactory {

    //静态工厂方法

    public static Chart getChart(String type) {

        Chart chart = null;

        if (type.equalsIgnoreCase("histogram")) {

            chart = new HistogramChart();

            System.out.println("初始化设置柱状图!");

        } else if (type.equalsIgnoreCase("pie")) {

            chart = new PieChart();

            System.out.println("初始化设置饼状图!");

        } else if (type.equalsIgnoreCase("line")) {

            chart = new LineChart();

            System.out.println("初始化设置折线图!");

        }

        return chart;

    }

}

//编写如下客户端测试代码:

class Client {

    public static void main(String args[]) {

        Chart chart;

        chart = ChartFactory.getChart("histogram"); //通过静态工厂方法创建产品

        chart.display();

    }

}

简单工厂模式的简化

  有时候,为了简化简单工厂模式,我们可以将抽象产品类和工厂类合并,将静态工厂方法移至抽象产品类中,如下图所示。

 

 

总结

主要优点:

工厂类包含必要的判断逻辑,可以决定在什么时候创建哪一个产品类的实例,客户端可以免除直接创建产品对象的职责,而仅仅“消费”产品,简单工厂模式实现了对象创建和使用的分离。

客户端无须知道所创建的具体产品类的类名,只需要知道具体产品类所对应的参数即可。

通过引入配置文件,可以在不修改任何客户端代码的情况下更换和增加新的具体产品类,在一定程度上提高了系统的灵活性。

主要缺点:

由于工厂类集中了所有产品的创建逻辑,职责过重,一旦不能正常工作,整个系统都要受到影响。

使用简单工厂模式势必会增加系统中类的个数(引入了新的工厂类),增加了系统的复杂 度和理解难度。

系统扩展困难,一旦添加新产品就不得不修改工厂逻辑,在产品类型较多时,有可能造成 工厂逻辑过于复杂,不利于系统的扩展和维护。

简单工厂模式由于使用了静态工厂方法,造成工厂角色无法形成基于继承的等级结构。

适用场景

工厂类负责创建的对象比较少,由于创建的对象较少,不会造成工厂方法中的业务逻辑太过复杂。

客户端只知道传入工厂类的参数,对于如何创建对象并不关心。

二、工厂方法模式

工厂方法模式概述

  在简单工厂模式中只提供一个工厂类,该工厂类处于对产品类进行实例化的中心位置,它需要知道每一个产品对象的创建细节,并决定何时实例化哪一个产品类。简单工厂模式最大的缺点是当有新产品要加入到系统中时,必须修改工厂类,需要在其中加入必要的业务逻辑,这违背了“开闭原则”。此外,在简单工厂模式中,所有的产品都由同一个工厂创建,工厂类职责较重,业务逻辑较为复杂,具体产品与工厂类之间的耦合度高,严重影响了系统的灵活性和扩展性,而工厂方法模式则可以很好地解决这一问题。

  在工厂方法模式中,我们不再提供一个统一的工厂类来创建所有的产品对象,而是针对不同的产品提供不同的工厂,系统提供一个与产品等级结构对应的工厂等级结构。

  工厂方法模式:定义一个用于创建对象的接口,让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。工厂方法模式又简称为工厂模式,又可称作虚拟构造器模式或多态工厂模式。工厂方法模式是一种类创建型模式。

  工厂方法模式提供一个抽象工厂接口来声明抽象工厂方法,而由其子类来具体实现工厂方法,创建具体的产品对象。工厂方法模式结构如图所示:

 

 

工厂方法模式角色

Product(抽象产品):它是定义产品的接口,是工厂方法模式所创建对象的超类型,也就是产品对象的公共父类。

ConcreteProduct(具体产品):它实现了抽象产品接口,某种类型的具体产品由专门的具体工厂创建,具体工厂和具体产品之间一一对应。

Factory(抽象工厂):在抽象工厂类中,声明了工厂方法(Factory Method),用于返回一个产品。抽象工厂是工厂方法模式的核心,所有创建对象的工厂类都必须实现该接口。

ConcreteFactory(具体工厂):它是抽象工厂类的子类,实现了抽象工厂中定义的工厂方法,并可由客户端调用,返回一个具体产品类的实例。

  与简单工厂模式相比,工厂方法模式最重要的区别是引入了抽象工厂角色,抽象工厂可以是接口,也可以是抽象类或者具体类,其典型代码如下所示:

 

interface Factory {

    public Product factoryMethod();    

}

 

  在抽象工厂中声明了工厂方法但并未实现工厂方法,具体产品对象的创建由其子类负责,客户端针对抽象工厂编程,可在运行时再指定具体工厂类,具体工厂类实现了工厂方法,不同的具体工厂可以创建不同的具体产品,其典型代码如下所示:

 

class ConcreteFactory implements Factory {

    public Product factoryMethod() {

        return new ConcreteProduct();

    }

 

  在实际使用时,具体工厂类在实现工厂方法时除了创建具体产品对象之外,还可以负责产品对象的初始化工作以及一些资源和环境配置工作,例如连接数据库、创建文件等。

  在客户端代码中,只需关心工厂类即可,不同的具体工厂可以创建不同的产品,典型的客户端类代码片段如下所示:

 

Factory    factory;

factory    = new ConcreteFactory(); //可通过配置文件实现

Product    product;

product    = factory.factoryMethod();

 

  可以通过配置文件来存储具体工厂类ConcreteFactory的类名,更换新的具体工厂时无须修改源 代码,系统扩展更为方便。

 

案例

  Sunny软件公司欲开发一个系统运行日志记录器(Logger),该记录器可以通过多种途径保存系 统的运行日志,如通过文件记录或数据库记录,用户可以通过修改配置文件灵活地更换日志记录方式。在设计各类日志记录器时,Sunny公司的开发人员发现需要对日志记录器进行一些初始化工作,初始化参数的设置过程较为复杂,而且某些参数的设置有严格的先后次序,否则可能会发生记录失败。如何封装记录器的初始化过程并保证多种记录器切换的灵活性是Sunny公司开发人员面临的一个难题。

  Sunny公司的开发人员通过对该需求进行分析,发现该日志记录器有两个设计要点:

 

需要封装日志记录器的初始化过程,这些初始化工作较为复杂,例如需要初始化其他相关的类,还有可能需要读取配置文件(例如连接数据库或创建文件),导致代码较长,如果将它们都写在构造函数中,会导致构造函数庞大,不利于代码的修改和维护;

用户可能需要更换日志记录方式,在客户端代码中需要提供一种灵活的方式来选择日志记录器,尽量在不修改源代码的基础上更换或者增加日志记录方式。

class LoggerFactory {

    //静态工厂方法

    public static Logger createLogger(String args) {

        if (args.equalsIgnoreCase("db")) {

            // 连接数据库,

            // 代码省略

            // 创建数据库日志记录器对象 Logger

            logger = new DatabaseLogger();

            // 初始化数据库日志记录器,代码省略

            return logger;

        } else if (args.equalsIgnoreCase("file")) {

            // 创建日志文件

            //创建文件日志记录器对象

            Logger logger = new FileLogger();

            //初始化文件日志记录器,代码省略        

            return logger;

        } else {

            return null;

        }

    }

}

从代码可以看出,使用简单工厂模式虽然实现了了对象的创建和使用分离,但是任然存在两个问题,1、工厂类过于庞大,导致维护和测试难度增大。2、系统扩展不灵活,如果增加新类型的日志记录器,必须修改静态工厂方法的业务逻辑,违反了“开闭原则”。

 

完整解决方案

![](2019-06-03-18-01-56.png

如上图所示,Logger接口充当抽象产品,其子类FileLogger和DatabaseLogger充当具体产品,LoggerFactory接口充当抽象工厂,其子类FileLoggerFactory和DatabaseLoggerFactory充当具体工厂。完整代码如下:

 

//日志记录器接口:抽象产品

interface Logger {

    public void writeLog();

}

//数据库日志记录器:具体产品

class DatabaseLogger implements Logger {

    public void writeLog() {

        System.out.println("数据库日志记录。");

    }

}

//文件日志记录器:具体产品

class FileLogger implements Logger {

    public void writeLog() {

        System.out.println("文件日志记录。");

    }

}

//日志记录器工厂接口:抽象工厂

interface LoggerFactory {

    public Logger createLogger();

}

//数据库日志记录器工厂类:具体工厂

class DatabaseLoggerFactory implements LoggerFactory {

    public Logger createLogger() {

        //连接数据库,代码省略                                                        

        // 创建数据库日志记录器对象

        Logger logger = new DatabaseLogger();

        //初始化数据库日志记录器,代码省略        

        return logger;

    }

}

//文件日志记录器工厂类:具体工厂        

class FileLoggerFactory implements LoggerFactory {

    public Logger createLogger() {

        //创建文件日志记录器对象                                        

        Logger logger = new FileLogger();

        // 创建文件,代码省略                                                

        return logger;

    }

}

//编写如下客户端测试代码:

class Client {

    public static void main(String args[]) {

        LoggerFactory factory;

        Logger logger;

        factory = new FileLoggerFactory();  //可引入配置文件实现        

        logger = factory.createLogger();

        logger.writeLog();

    }

}

工厂方法模式总结

工厂方法模式是简单工厂模式的延伸,它继承了简单工厂模式的优点,同时还弥补了简单工厂模式的不足。工厂方法模式是使用频率最高的设计模式之一,是很多开源框架和API类库的 核心模式。

 

主要优点

在工厂方法模式中,工厂方法用来创建客户所需要的产品,同时还向客户隐藏了哪种具体产品类将被实例化这一细节,用户只需要关心所需产品对应的工厂,无须关心创建细节,甚至无须知道具体产品类的类名。

基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够让工厂可以自主确定创建何种产品对象,而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式,就正是因为所有的具体工厂类都具有同一抽象父类。

使用工厂方法模式的另一个优点是在系统中加入新产品时,无须修改抽象工厂和抽象产品提供的接口,无须修改客户端,也无须修改其他的具体工厂和具体产品,而只要添加一个具体工厂和具体产品就可以了,这样,系统的可扩展性也就变得非常好,完全符合“开闭原则”。

主要缺点

在添加新产品时,需要编写新的具体产品类,而且还要提供与之对应的具体工厂类,系统中类的个数将成对增加,在一定程度上增加了系统的复杂度,有更多的类需要编译和运行,会给系统带来一些额外的开销。

由于考虑到系统的可扩展性,需要引入抽象层,在客户端代码中均使用抽象层进行定义,增加了系统的抽象性和理解难度,且在实现时可能需要用到DOM、反射等技术,增加了系统的实现难度。

适用场景

客户端不知道它所需要的对象的类。在工厂方法模式中,客户端不需要知道具体产品类的类名,只需要知道所对应的工厂即可,具体的产品对象由具体工厂类创建,可将具体工厂类的类名存储在配置文件或数据库中。

抽象工厂类通过其子类来指定创建哪个对象。在工厂方法模式中,对于抽象工厂类只需要提供一个创建产品的接口,而由其子类来确定具体要创建的对象,利用面向对象的多态性和里氏代换原则,在程序运行时,子类对象将覆盖父类对象,从而使得系统更容易扩展。

抽象工厂模式

抽象工厂模式概述

  抽象工厂模式为创建一组对象提供了一种解决方案。与工厂方法模式相比,抽象工厂模式中的具体工厂不只是创建一种产品,它负责创建一族产品。

  抽象工厂模式定义如下:抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。抽象工厂模式又称为Kit模式,它是一种对象创建型模式。

  在抽象工厂模式中,每一个具体工厂都提供了多个工厂方法用于产生多种不同类型的产品,这些产品构成了一个产品族,抽象工厂模式结构如下图所示:

![](2019-06-04-09-31-46.png

 

抽象工厂角色

AbstractFactory(抽象工厂):它声明了一组用于创建一族产品的方法,每一个方法对应一种产品。

ConcreteFactory(具体工厂):它实现了在抽象工厂中声明的创建产品的方法,生成一组具体产品,这些产品构成了一个产品族,每一个产品都位于某个产品等级结构中。

AbstractProduct(抽象产品):它为每种产品声明接口,在抽象产品中声明了产品所具有的业务方法。

ConcreteProduct(具体产品):它定义具体工厂生产的具体产品对象,实现抽象产品接口中声明的业务方法。

案例

  Sunny软件公司欲开发一套界面皮肤库,可以对Java桌面软件进行界面美化。为了保护版权,该皮肤库源代码不打算公开,而只向用户提供已打包为jar文件的class字节码文件。用户在使用时可以通过菜单来选择皮肤,不同的皮肤将提供视觉效果不同的按钮、文本框、组合框等界面元素,其结构示意图如下图所示:

![](2019-06-04-09-39-35.png

  该皮肤库需要具备良好的灵活性和可扩展性,用户可以自由选择不同的皮肤,开发人员可以在不修改既有代码的基础上增加新的皮肤。

  Sunny软件公司的开发人员针对上述要求,决定使用工厂方法模式进行系统的设计,为了保证系统的灵活性和可扩展性,提供一系列具体工厂来创建按钮、文本框、组合框等界面元素,客户端针对抽象工厂编程,初始结构如下图所示:

![](2019-06-04-09-41-33.png

从上图可以发现,提供了大量工厂来创建具体的界面组件,可以通过配置文件更换具体界面组件从而改变界面风格。但是,此设计方案存在如下问题:

 

当需要增加新的皮肤时,虽然不要修改现有代码,但是需要增加大量类,针对每一个新增具体组件都需要增加一个具体工厂,类的个数成对增加,这无疑会导致系统越来越庞大,增加系统的维护成本和运行开销;

由于同一种风格的具体界面组件通常要一起显示,因此需要为每个组件都选择一个具体工厂,用户在使用时必须逐个进行设置,如果某个具体工厂选择失误将会导致界面显示混乱,虽然我们可以适当增加一些约束语句,但客户端代码和配置文件都较为复杂。

产品等级结构与产品族

  在介绍完整解决方案之前,为了更好地理解抽象工厂模式,我们先引入两个概念。在工厂方法模式中具体工厂负责生产具体的产品,每一个具体工厂对应一种具体产品,工厂方法具有唯一性,一般情况下,一个具体工厂中只有一个或者一组重载的工厂方法。但是有时候我们希望一个工厂可以提供多个产品对象,而不是单一的产品对象,如一个电器工厂,它可以生产电视机、电冰箱、空调等多种电器,而不是只生产某一种电器。

 

产品等级结构:产品等级结构即产品的继承结构,如一个抽象类是电视机,其子类有海尔电视机、海信电视机、TCL电视机,则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构,抽象电视机是父类,而具体品牌的电视机是其子类。

产品族:在抽象工厂模式中,产品族是指由同一个工厂生产的,位于不同产品等级结构中的一组产品,如海尔电器工厂生产的海尔电视机、海尔电冰箱,海尔电视机位于电视机产品等级结构中,海尔电冰箱位于电冰箱产品等级结构中,海尔电视机、海尔电冰箱构成了一个产品族。产品等级结构与产品族示意图如图所示:

![](2019-06-04-09-48-42.png

  在上图中,不同颜色的多个正方形、圆形和椭圆形分别构成了三个不同的产品等级结构,而相同颜色的正方形、圆形和椭圆形构成了一个产品族,每一个形状对象都位于某个产品族,并属于某个产品等级结构。图中一共有五个产品族,分属于三个不同的产品等级结构。我们只要指明一个产品所处的产品族以及它所属的等级结构,就可以唯一确定这个产品。

  当系统所提供的工厂生产的具体产品并不是一个简单的对象,而是多个位于不同产品等级结构、属于不同类型的具体产品时就可以使用抽象工厂模式。抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形式。抽象工厂模式与工厂方法模式最大的区别在于, 工厂方法模式针对的是一个产品等级结构,而抽象工厂模式需要面对多个产品等级结构,一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时,抽象工厂模式比工厂方法模式更为简单、更有效率。抽象工厂模式示意图如图所示:

![](2019-06-04-09-51-46.png

  在图中,每一个具体工厂可以生产属于一个产品族的所有产品,例如生产颜色相同的正方形、圆形和椭圆形,所生产的产品又位于不同的产品等级结构中。如果使用工厂方法模式,需要提供15个具体工厂,而使用抽象工厂模式只需要提供5个具体工厂,极大减少了系统中类的个数。

完整解决方案

  Sunny公司开发人员使用抽象工厂模式来重构界面皮肤库的设计,其基本结构如图所示:

![](2019-06-04-09-54-08.png

在图中,SkinFactory接口充当抽象工厂,其子类SpringSkinFactory和SummerSkinFactory充当 具体工厂,接口Button、TextField和ComboBox充当抽象产品,其子类SpringButton、SpringTextField、SpringComboBox和SummerButton、SummerTextField、SummerComboBox充当具体产品。完整代码如下所示:

 

//在本实例中我们对代码进行了大量简化,实际使用时,界面组件的初始化代码较为复杂,还需要使用JD

//按钮接口:抽象产品

interface Button {

    public void display();

}

//Spring按钮类:具体产品

class SpringButton implements Button {

    public void display() {

        System.out.println("显示浅绿色按钮。");

    }

}

//Summer按钮类:具体产品

class SummerButton implements Button {

    public void display() {

        System.out.println("显示浅蓝色按钮。");

    }

}

//文本框接口:抽象产品

interface TextField {

    public void display();

}

//Spring文本框类:具体产品

class SpringTextField implements TextField {

    public void display() {

        System.out.println("显示绿色边框文本框。");

    }

}

//Summer文本框类:具体产品

class SummerTextField implements TextField {

    public void display() {

        System.out.println("显示蓝色边框文本框。");

    }

}

//组合框接口:抽象产品

interface ComboBox {

    public void display();

}

//Spring组合框类:具体产品

class SpringComboBox implements ComboBox {

    public void display() {

        System.out.println("显示绿色边框组合框。");

    }

}

//Summer组合框类:具体产品

class SummerComboBox implements ComboBox {

    public void display() {

        System.out.println("显示蓝色边框组合框。");

    }

}

//界面皮肤工厂接口:抽象工厂

interface SkinFactory {

    public Button createButton();

    public TextField createTextField();

    public ComboBox createComboBox();

}

//Spring皮肤工厂:具体工厂

class SpringSkinFactory implements SkinFactory {

    public Button createButton() {

        return new SpringButton();

    }

    public TextField createTextField() {

        return new SpringTextField();

    }

    public ComboBox createComboBox() {

        return new SpringComboBox();

    }

}

//Summer皮肤工厂:具体工厂

class SummerSkinFactory implements SkinFactory {

    public Button createButton() {

        return new SummerButton();

    }

    public TextField createTextField() {

        return new SummerTextField();

    }

    public ComboBox createComboBox() {

        return new SummerComboBox();

    }

}

//为了让系统具备良好的灵活性和可扩展性,我们引入了工具类XMLUtil和配置文件,其中, XMLUtil类的代码如下所示:

public class XMLUtil {

    //该方法用于从XML配置文件中提取具体类类名,并返回一个实例对象

    public static Object getBean() {

        try {

            //创建文档对象

            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstan

            DocumentBuilder builder = dFactory.newDocumentBuilder();

            Document doc;

            doc = builder.parse(new File("config.xml"));

            //获取包含类名的文本节点

            NodeList nl = doc.getElementsByTagName("className");

            Node classNode = nl.item(0).getFirstChild();

            String cName = classNode.getNodeValue();

            //通过类名生成实例对象并将其返回

            Class c = Class.forName(cName);

            Object obj = c.newInstance();

            return obj;

        } catch (Exception e) {

            e.printStackTrace();

            return null;

        }

    }

}

// 配置文件config.xml中存储了具体工厂类的类名,代码如下所示:

<?xml version="1.0"?><config><className>SpringSkinFactory</className></config>

//编写如下客户端测试代码

class Client {

    public static void main(String args[]) {

        //使用抽象层定义

        SkinFactory factory;

        Button bt;

        TextField tf;

        ComboBox cb;

        factory = (SkinFactory) XMLUtil.getBean();

        bt = factory.createButton();

        tf = factory.createTextField();

        cb = factory.createComboBox();

        bt.display();

        tf.display();

        cb.display();

    }

}

抽象工厂模式“开闭原则”的倾斜性

  在抽象工厂模式中,增加新的产品族很方便,但是增加新的产品等级结构很麻烦,抽象工厂模式的这种性质称为“开闭原则”的倾斜性。“开闭原则”要求系统对扩展开放,对修改封闭,通过扩展达到增强其功能的目的,对于涉及到多个产品族与多个产品等级结构的系统,其功能增强包括两方面:

 

增加产品族:对于增加新的产品族,抽象工厂模式很好地支持了“开闭原则”,只需要增加具体产品并对应增加一个新的具体工厂,对已有代码无须做任何修改。

增加新的产品等级结构:对于增加新的产品等级结构,需要修改所有的工厂角色,包括抽象工厂类,在所有的工厂类中都需要增加生产新产品的方法,违背了“开闭原则”。

 正因为抽象工厂模式存在“开闭原则”的倾斜性,它以一种倾斜的方式来满足“开闭原则”,为增加新产品族提供方便,但不能为增加新产品结构提供这样的方便,因此要求设计人员在设计 之初就能够全面考虑,不会在设计完成之后向系统中增加新的产品等级结构,也不会删除已有的产品等级结构,否则将会导致系统出现较大的修改,为后续维护工作带来诸多麻烦。

总结

主要优点:

抽象工厂模式隔离了具体类的生成,使得客户并不需要知道什么被创建。由于这种隔离,更换一个具体工厂就变得相对容易,所有的具体工厂都实现了抽象工厂中定义的那些公共接口,因此只需改变具体工厂的实例,就可以在某种程度上改变整个软件系统的行为。

当一个产品族中的多个对象被设计成一起工作时,它能够保证客户端始终只使用同一个产品族中的对象。

增加新的产品族很方便,无须修改已有系统,符合“开闭原则”。

主要缺点:

增加新的产品等级结构麻烦,需要对原有系统进行较大的修改,甚至需要修改抽象层代码,这显然会带来较大的不便,违背了“开闭原则”。

适用场景

一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节,这对于所有类型的工厂模式都是很重要的,用户无须关心对象的创建过程,将对象的创建和使用解耦。

系统中有多于一个的产品族,而每次只使用其中某一产品族。可以通过配置文件等方式来使得用户可以动态改变产品族,也可以很方便地增加新的产品族。

属于同一个产品族的产品将在一起使用,这一约束必须在系统的设计中体现出来。同一个产品族中的产品可以是没有任何关系的对象,但是它们都具有一些共同的约束,如同一操作系统下的按钮和文本框,按钮与文本框之间没有直接关系,但它们都是属于某一操作系统的,此时具有一个共同的约束条件:操作系统的类型。

产品等级结构稳定,设计完成之后,不会向系统中增加新的产品等级结构或者删除已有的产品等级结构。

 

 


分享:

低价透明

统一报价,无隐形消费

金牌服务

一对一专属顾问7*24小时金牌服务

信息保密

个人信息安全有保障

售后无忧

服务出问题客服经理全程跟进