美文网首页
单例模式、简单工厂模式和抽象工厂模式初探

单例模式、简单工厂模式和抽象工厂模式初探

作者: Slience无言 | 来源:发表于2016-12-05 14:07 被阅读0次

摘自《轻量级JavaEE企业应用开发》

【模式】是一条由三个部分组装成的通用规则:它表示了一个特定环境、一类问题和一个解决方案之间的关系
【设计模式】是对于特定环境下,经常出现的的某类软件开发问题的一种相对成熟的设计方案

单例模式

如果一个类始终只能创建一个实例,则称这个类为单例类,这种模式就被称为单例模式。
Spring推荐奖所有业务逻辑组件、DAO组件、数据源组件等配置为单例的行为方式,因为这些组件不需要保存任何用户状态,是所有客户端都可以通用的组件

代码实现
package com.singleton;

/**
 * 单例模式Demo
 * 《轻量级JavaEE企业应用实战》 P727
 * 如果一个类始终只能创建一个实例,则这个类称为单例类,这种模式称为单例模式
 * Spring推荐奖所有业务逻辑组件、DAO组件、数据源组件等配置成单例的行为方式
 * @author Slience
 *
 */
class Singleton {
    private static Singleton instance;
    private Singleton() {
    }
    public static Singleton getInstance() {
        //如果instance等于null,证明还没有创建过Singleton实例,为其创建Singleton实例
        //如果instance不等于null,说明已经创建过Singleton实例,
        //直接将这个Singleton返回即可,不必在new一个Singleton
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
public class SingletonTest {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2);
    }
}

单例模式主要有两个优势

  • 减少创建Java实例所带来的系统开销。
  • 便于系统跟踪单个Java实例的生命周期、实例状态等。

简单工厂模式

A实例调用B实例的方法,则称A依赖于B
当A实例需要调用B实例的时候,有两种方式可以实现:

  • 一种是使用new 关键字创建一个B实例,这种方式的缺点在于如果日后需求有变需要用C实例替代B实例,那么A实例中硬编码耦合B实例就需要修改,如果有很多实例都用new B()的方式去调用B实例的方法,那么需要修改的地方将会很多。
  • A实例只需要调用B对象的方法,并不关心B对象的实现创建过程,所以我们可以让B类实现了一个IB借口,A类只需要和IB接口耦合,A类不直接使用new关键字来创建B实例,而是重新定义一个IBFactory类,由该类来负责创建IB实例,A类只需要调用IBFactory工厂方法来得到IB实例。

使用后一种设计,可以让A类和B类解除耦合,只需要和IB结构和IBFactory耦合,这样当新需求来时C类可以去实现IB接口然后再IBFactory中修改创建IB实例的代码,就可以实现新需求了,A类中不需要对代码进行修改。
这种将多个类对象交给工厂类来生成的设计方式被称为【简单工厂模式】

代码实现

假设程序用有一个Computer对象需要依赖一个输出设备,可以让Computer对象依赖一个Output(接口)属性,再用Printer(实现输出类)对象去实现Output接口,Computer从OutputFactory工厂类生成Printer从而让Computer和Printer分离开来,日后如果有更好的实现输出类BetterPrinter,那么直接修改OutputFactory代码即可。
Computer类

package com.simplefactory;
/**
 * 《轻量级JavaEE企业应用实战 p728
 * Computer类可以通过Output接口打印内容,让打印机类实现Output接口
 * Computer使用OutputFactory来获取合适的打印机从而让打印机类和电脑类解耦
 * 
 * 使用简单工厂模式的优势是:让对象的调用者和对象的创建过程分离,当对象调用者需要对象时,
 * 直接向工厂请求即可;从而避免了对象的调用者与对象的实现类以硬编码方式耦合,
 * 以提高系统的可维护性、可拓展性。
 * 工厂模式也有一个小小的缺陷:当产品修改是,工厂类也要做相应的修改
 * @author Slience
 *
 */
public class Computer {
    private Output out;
    public Computer(Output out) {
        this.out = out;
    }
    //定义一个模拟获取字符串输入的方法
    public void keyIn(String msg) {
        out.getDate(msg);
    }
    //定义一个模拟打印的方法
    public void print() {
        out.out();
    }
    public static void main(String[] args) {
        OutputFactory factory = new OutputFactory();
        //通过工厂类获取output对象
        //Computer和factory硬编码而不和output实现类耦合,这样修改到另一个实现类的时候
        //只需要修改factory中的getOutput方法即可
        Computer computer = new Computer(factory.getOutput());
        computer.keyIn("Hello World");
        computer.keyIn("Slience");
        computer.print();
    }
}

Output输出接口

package com.simplefactory;

public interface Output {

    //默认的打印队列大小
    final static int MAX_CACHE_LINE = 1; 
    
    void getDate(String msg);

    void out();

}

之后用Printer去实现Output

package com.simplefactory;

public class Printer implements Output {

    private String[] printData = new String[MAX_CACHE_LINE];
    //用以记录当前需要打印的作业数
    private int dataNum = 0;
    
    @Override
    public void getDate(String msg) {
        // TODO Auto-generated method stub
        if(dataNum >= MAX_CACHE_LINE) {
            System.out.println("输出队列已满,添加失败");
        } else {
            printData[dataNum++] = msg;
        }
        
    }

    @Override
    public void out() {
        // TODO Auto-generated method stub
        while(dataNum > 0) {
            System.out.println("打印机打印:" + printData[0]);
            //将原数组第二个到--dataNum个元素前移一位
            System.arraycopy(printData, 1, printData, 0, --dataNum);
        }
    }

}

创建Output对象都通过OutputFactory工厂类去创建

package com.simplefactory;

public class OutputFactory {
    public Output getOutput() {
        
        return new Printer();
        //换了新的打印机之后就可以打印两行了
        //return new BetterPrinter();
    }
}

当我们运行起Computer的时候会输出

输出队列已满,添加失败
打印机打印:Hello World

如果此时来了一个更好地Output实现类——BetterPrinter,他能够打印原大小两倍的数据量

package com.simplefactory;

public class BetterPrinter implements Output {

    private String[] printData = new String[MAX_CACHE_LINE * 2];
    //用以记录当前需要打印的作业数
    private int dataNum = 0;
    
    @Override
    public void getDate(String msg) {
        // TODO Auto-generated method stub
        if(dataNum >= MAX_CACHE_LINE * 2) {
            System.out.println("输出队列已满,添加失败");
        } else {
            printData[dataNum++] = msg;
        }
        
    }

    @Override
    public void out() {
        // TODO Auto-generated method stub
        while(dataNum > 0) {
            System.out.println("打印机打印:" + printData[0]);
            //将原数组第二个到--dataNum个元素前移一位
            System.arraycopy(printData, 1, printData, 0, --dataNum);
        }
    }

}

我们想要给Computer换上新的Output的话,只需要在OutputFactory中修改为return new BetterPrinter()即可,Computer不需要做任何的改变。但是这样还是有一个小小的缺点,那就是当产品修改时,工厂类也要做相应的修改。
在Spring中可以通过配置XML来实现工厂类的修改

工厂模式

和简单工厂模式很像,只不过新增了一个OutputFactory接口和BetterPrinterFactory和PrinterFactory工厂类,这样做的好处在于不同的工厂生产不同的对象,工厂实现类不需要对逻辑进行判断,逻辑判断可以在OutputFactoryFactory类中进行,OutputFactoryFactory类是用来根据需要生成不同的实现了OutputFactory接口的工厂类的类。

代码实现

Output接口不变,新增OutputFactory接口

package com.factory;

public interface OutputFactory {
    Output getOutput();
}

还有其实现类OutputFactoryFactory

package com.factory;

public class OutputFactoryFactory {
    public static OutputFactory getOutputFactory(String type) {
        //不考虑大小写
        if(type.equalsIgnoreCase("better")) {
            return new BetterPrinterFactory();
        } else {
            return new PrinterFactory();
        }
    }
}

之后创建BetterPrinterFactory和PrinterFactory工厂实现类,PrintFactory和BetterPrinterFactory只是两者返回的对象不同。

package com.factory;

public class BetterPrinterFactory implements OutputFactory {

    @Override
    public Output getOutput() {
        // TODO Auto-generated method stub
        return new BetterPrinter();
        //如果是PrinterFactory返回的就是
        //return new Printer();
    }
    
}

在Computer中通过对OutputFactoryFactory传入不同的参数来获取不同的Factory类,再通过不同的工厂类来创建不同的对象

package com.factory;
/**
 * 《轻量级JavaEE企业应用实战 p737
 * 
 * 
 * 
 * @author Slience
 *
 */
public class Computer {
    private Output out;
    public Computer(Output out) {
        this.out = out;
    }
    //定义一个模拟获取字符串输入的方法
    public void keyIn(String msg) {
        out.getDate(msg);
    }
    //定义一个模拟打印的方法
    public void print() {
        out.out();
    }
    public static void main(String[] args) {
        
        //工厂的工厂
        OutputFactory factory = OutputFactoryFactory.getOutputFactory("better");
        //通过工厂类获取output对象
        //Computer和factory硬编码而不和output实现类耦合,这样修改到另一个实现类的时候
        //只需要修改factory中的getOutput方法即可
        Computer computer = new Computer(factory.getOutput());
        computer.keyIn("Hello World");
        computer.keyIn("Slience");
        computer.print();
    }
}

相关文章

  • 设计模式系列-抽象工厂模式

    JAVA设计模式系列: 单例模式 观察者模式 模板方法模式 简单工厂模式 抽象工厂模式 抽象工厂模式 定义 抽象工...

  • PHP-浅谈单例模式和工厂模式

    PHP中常用的设计模式有单例模式、工厂模式(简单工厂模式、工厂方法模式和抽象工厂方法模式)、适配模式、策略模式。 ...

  • 设计模式四、抽象工厂模式

    系列传送门设计模式一、单例模式设计模式二、简单工厂模式设计模式三、工厂模式设计模式四、抽象工厂模式 抽象工厂模式 ...

  • 三、创建型模型

    简单工厂模式 工厂方法模式 抽象工厂模式 单例模式 1.简单工厂模式 简单工厂模式并不属于23种设计模式。 不难看...

  • 2021-11-16 - 学习记录

    设计模式学习:创建型:工厂(工厂方法,抽象工厂),建造者,单例,原型 设计模式:工厂模式 简单工厂 工厂方法 抽象工厂

  • 建造模式

    包括:简单工厂、工厂方法、抽象工厂、单例模式、多例模式、建造模式、原始原型模式。 简单工厂:又名静态工厂方法模式,...

  • 设计模式一、单例模式

    系列传送门设计模式一、单例模式设计模式二、简单工厂模式设计模式三、工厂模式设计模式四、抽象工厂模式 简单单例(推荐...

  • 【java知识总结】设计模式-创建型模式(1)

    1、概述 创建型模式主要有单例模式、简单工厂模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式这里主要讲单例模...

  • 创建型模式

    工厂模式(简单工厂(不属于23种设计模式)、工厂方法、抽象工厂) 建造者模式 单例模式 原型模式 1.简单工厂(静...

  • GOF23(java设计模式)--创建型模式

    单例模式、简单工厂模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式 一、单例模式作用:保证一个类只有一个实例...

网友评论

      本文标题:单例模式、简单工厂模式和抽象工厂模式初探

      本文链接:https://www.haomeiwen.com/subject/hoykmttx.html