设计模式之单例模式和工厂模式-白红宇

设计模式之单例模式和工厂模式

阅读量：3958 次

发布时间：2019-05-24

本文共 16682 字，大约阅读时间需要 55 分钟。

1、单例模式

单例模式的八种方式：饿汉式（静态常量）、饿汉式（静态代码块）、懒汉式（线程不安全）、懒汉式（线程安全，同步方法）、懒汉式（线程不安全，同步代码块）、双重检查、静态内部类、枚举

1）：饿汉式（静态常量）

构造器私有化，类的内部创建对象，向外暴露一个静态的公共方法

package com.singleModel.test1;public class test01 {
       public static void main(String[] args) {
           Singleton instance02 = Singleton.getInstance();        Singleton instance01 = Singleton.getInstance();        System.out.println(instance01 == instance02);        System.out.println(instance01.hashCode());        System.out.println(instance02.hashCode());    }}class Singleton{
       //1、构造器私有化    private Singleton() {
       }    //2、本类内部创建实例对象    private final static Singleton instance = new Singleton();    //3、提供一个公有的静态方法，返回实例对象    public static Singleton getInstance(){
           return instance;    }}

优点：这种写法比较简单，就是在类装载的时候就完成实例化，避免了线程同步问题

缺点：（1）在类装载的时候就完成实例化，没有达到lazy loading的效果，如果从始至终从未使用过这个实例，则会造成内存的浪费。

（2）这种方式基于classLoader机制避免了多线程的同步问题，不过，instance在类装载的时候就实例化，在单例模式中大多数都是调用instance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance就没有达到lazy loading的效果。

结论：这种单例模式可用，可能造成内存浪费。

2）：饿汉式（静态代码块）

package com.singleModel.test02;public class test01 {
       public static void main(String[] args) {
           Singleton instance02 = Singleton.getInstance();        Singleton instance01 = Singleton.getInstance();        System.out.println(instance01 == instance02);        System.out.println(instance01.hashCode());        System.out.println(instance02.hashCode());    }}class Singleton{
       //1、构造器私有化    private Singleton() {
       }    //2、本类内部创建实例对象    private final static Singleton instance;    static {
           instance  = new Singleton();    }    //3、提供一个公有的静态方法，返回实例对象    public static Singleton getInstance(){
           return instance;    }}

优缺点说明：

这种方式和上面的方式其实类似，只不过将实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化的实例。优缺点和上面也是一样的。

结论：这种单例模式可用，但是可能造成内存浪费。

3）懒汉式（线程不安全）

package com.singleModel.test03;public class test01 {
       public static void main(String[] args) {
           Singleton instance02 = Singleton.getInstance();        Singleton instance01 = Singleton.getInstance();        System.out.println(instance01 == instance02);        System.out.println(instance01.hashCode());        System.out.println(instance02.hashCode());    }}class Singleton{
       //1、构造器私有化    private Singleton() {
       }    //2、本类内部创建实例对象    private static Singleton instance;    //3、提供一个公有的静态方法，返回实例对象    public static Singleton getInstance(){
           if(instance == null){
               instance = new Singleton();        }        return instance;    }}

优缺点说明：

起到了lazy loading的效果，但是只能在单线程下使用，如果在多线程下，一个线程进入了if(singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例，所以在多线程环境下不可使用这种模式。

结论：在实际开发中，不要使用这种方式。

4）：懒汉式（线程安全，同步方法）

package com.singleModel.test04;public class test01 {
       public static void main(String[] args) {
           Singleton instance02 = Singleton.getInstance();        Singleton instance01 = Singleton.getInstance();        System.out.println(instance01 == instance02);        System.out.println(instance01.hashCode());        System.out.println(instance02.hashCode());    }}class Singleton{
       //1、构造器私有化    private Singleton() {
       }    //2、本类内部创建实例对象    private static Singleton instance;    //3、提供一个公有的静态方法，返回实例对象    public static synchronized Singleton getInstance(){
           if(instance == null){
               instance = new Singleton();        }        return instance;    }}

优缺点分析：

解决了线程不安全的问题，效率太低了，每个线程在想获得类的实例的时候，执行getInstance()方法否要进行同步，而其实这个方法只执行一次实例化代码就够了，后面的相获得该实例，直接return就行了，方法进行同步效率太低。

结论：在实际开发中，不推荐使用这种方式

5）懒汉式（线程不安全，同步代码块）

package com.singleModel.test05;public class test01 {
       public static void main(String[] args) {
           Singleton instance02 = Singleton.getInstance();        Singleton instance01 = Singleton.getInstance();        System.out.println(instance01 == instance02);        System.out.println(instance01.hashCode());        System.out.println(instance02.hashCode());    }}class Singleton{
       //1、构造器私有化    private Singleton() {
       }    //2、本类内部创建实例对象    private static Singleton instance;    //3、提供一个公有的静态方法，返回实例对象    public static Singleton getInstance(){
           if(instance == null){
               synchronized (Singleton.class){
                   instance = new Singleton();            }        }        return instance;    }}

优缺点说明：

这种方式，本意是想对第四种实现方式的改进，因为前面同步方法效率太低，改为同步产生实例化的代码块，但是这种不同步并不能起到线程同步的作用，跟第三种实现方式遇到的情形一样，假如一个线程进入了if（singleton == null）判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生过个实例。

结论：在实际开发中，不能使用这种方式。

6）双重检查

package com.singleModel.test06;public class test01 {
       public static void main(String[] args) {
           Singleton instance02 = Singleton.getInstance();        Singleton instance01 = Singleton.getInstance();        System.out.println(instance01 == instance02);        System.out.println(instance01.hashCode());        System.out.println(instance02.hashCode());    }}class Singleton{
       //1、构造器私有化    private Singleton() {
    }    //2、本类内部创建实例对象    private static volatile Singleton instance;    //3、提供一个公有的静态方法，返回实例对象    public static Singleton getInstance(){
           if(instance == null){
               synchronized (Singleton.class){
                   if(instance == null){
                       instance = new Singleton();                }            }        }        return instance;    }}

优缺点说明：

Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if(singleton == null)检查，这样就可以保证线程安全了

这样，实例化代码只用执行一次，后面再次访问时，判断if（singleton == null）,直接return实例化对象，也避免了反复进行方法同步，线程安全，延迟加载，效率较高

结论：在实际开发中，推荐使用这种单例设计模式。

7）：静态内部类

package com.singleModel.test07;public class test01 {
       public static void main(String[] args) {
           Singleton instance02 = Singleton.getInstance();        Singleton instance01 = Singleton.getInstance();        System.out.println(instance01 == instance02);        System.out.println(instance01.hashCode());        System.out.println(instance02.hashCode());    }}class Singleton{
       //1、构造器私有化    private Singleton() {
    }    //2、本类北部创建实例对象    private static volatile Singleton instance;    //3.在Singleton装载的时候，静态内部类不会被装载，从而实现懒加载    private static class SingletonInstance{
           private static final Singleton INSTANCE = new Singleton();    }    //JVM在装载类的时候  是线程安全的    public static Singleton getInstance(){
           return SingletonInstance.INSTANCE;    }}

这种方式采用了类装载的机制来保证初始化实例时只有一个线程，静态内部类方式在Singleton被装载是并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SinglrtonInstance类，从而完成Singleton的实例化，类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高。

结论：推荐使用

8）枚举

package com.singleModel.test08;public class Test08 {
       public static void main(String[] args) {
           Singleton instance = Singleton.instance;        Singleton instance1 = Singleton.instance;        System.out.println(instance == instance1);        System.out.println(instance.hashCode());        System.out.println(instance1.hashCode());    }}enum Singleton{
       instance;    public void method(){
           System.out.println("hello~");    }}

借助JDK1.5中添加的枚举来实现单例对象，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，这种方式是Effective Java作者Josh Bloch提倡的方式。

结论：推荐使用

单例模式注意事项和细节说明：

单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能，当想实例化一个单例类的时候，必须要记住使用响应的获取对象的方法，而不是使用new

单例模式使用的场景：需要频繁的进行创建和销毁对象，创建对象耗时过多或耗费资源过多（即：重量级对象），但又经常用到的对象，工具类对象，频繁访问数据库或者文件的对象（比如数据源，session工厂等）

2、工厂模式

package com.factoryModel;public abstract class Pizza {
       private String name;    public String getName() {
           return name;    }    public void setName(String name) {
           this.name = name;    }    //准备元材料，不同的披萨做法不一样，所以做成抽象方法    public abstract void prepare();    public void bake(){
           System.out.println(name + "is bake");    }    public void cut(){
           System.out.println(name + "is cut");    }    public void box(){
           System.out.println(name + "is box");    }}

package com.factoryModel;public class CheesePizza extends Pizza {
       public void prepare() {
           System.out.println("制作奶酪披萨准备原材料");    }}

package com.factoryModel;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class OrderPizza {
       public OrderPizza() {
           Pizza pizza = null;        String orderType;        do {
               orderType = getType();            if(orderType.equals("cheese")){
                   pizza = new CheesePizza();                pizza.setName("cheese");            }else if (orderType.equals("greece")){
                   pizza = new GreecePizza();                pizza.setName("greece");            } else {
                   break;            }            pizza.prepare();            pizza.bake();            pizza.cut();            pizza.box();        }while (true);    }    private String getType(){
           BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));        System.out.println("input is ");        try {
               String readLine = bufferedReader.readLine();            return readLine;        } catch (IOException e) {
               return "";        }    }}

package com.factoryModel;public class PizzaStore {
       public static void main(String[] args) {
           new OrderPizza();    }}

传统方式的优缺点：

优点：比较好理解，简单易操作

缺点：违反了设计模式的ocp原则。即对扩展开放，对修改关闭，当我们给类新增加功能的时候，尽量不修改代码，或者尽可能减少修改代码。

1）简单工厂模式：

简单工厂模式是属于创建型模式，是工厂模式的一种，简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例，简单工厂模式是工厂模式家族中最简单使用的模式，

简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为。

在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。

package com.factoryModel.simpleFactory;import com.factoryModel.CheesePizza;import com.factoryModel.GreecePizza;import com.factoryModel.Pizza;public class SimpleFactory {
       //增加orderType,返回对应的Pizza对象    public Pizza createPizza(String orderType){
           Pizza pizza = null;        System.out.println("使用简单工厂模式");        if(orderType.equals("cheese")){
               pizza = new CheesePizza();            pizza.setName("cheese");        }else if (orderType.equals("greece")){
               pizza = new GreecePizza();            pizza.setName("greece");        }        return pizza;    }}

package com.factoryModel.simpleFactory;import com.factoryModel.Pizza;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class OrderPizza {
       SimpleFactory simpleFactory;    //构造器    public OrderPizza(SimpleFactory simpleFactory) {
           setFactory(simpleFactory);    }    public void setFactory(SimpleFactory simpleFactory){
           String orderType = "";        this.simpleFactory = simpleFactory;        do {
               orderType = getType();            Pizza pizza = this.simpleFactory.createPizza(orderType);            if( pizza != null){
                   pizza.prepare();                pizza.bake();                pizza.cut();                pizza.box();            }else{
                   System.out.println("订购失败");                break;            }        }while (true);    }    private String getType(){
           BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));        System.out.println("input is ");        try {
               String readLine = bufferedReader.readLine();            return readLine;        } catch (IOException e) {
               return "";        }    }}

package com.factoryModel.simpleFactory;public class PizzaStore {
       public static void main(String[] args) {
           new OrderPizza(new SimpleFactory());    }}

工厂方法模式

工厂方法模式定义了一个创建对象的抽象方法，由子类决定要实例化的类，工厂方法模式将对象的实例化推迟到子类。

在这里插入图片描述

package com.factoryModel.methodFactory;public abstract class Pizza {
       private String name;    public String getName() {
           return name;    }    public void setName(String name) {
           this.name = name;    }    //准备元材料，不同的披萨做法不一样，所以做成抽象方法    public abstract void prepare();    public void bake(){
           System.out.println(name + "is bake");    }    public void cut(){
           System.out.println(name + "is cut");    }    public void box(){
           System.out.println(name + "is box");    }}

package com.factoryModel.methodFactory;public class BJCheesePizza extends Pizza {
       public void prepare() {
           setName("北京奶酪披萨");        System.out.println("北京的奶酪准备原材料");    }}

package com.factoryModel.methodFactory;public class BJPepperPizza extends Pizza {
       public void prepare() {
           setName("北京胡椒披萨");        System.out.println("北京的胡椒准备原材料");    }}

package com.factoryModel.methodFactory;public class LDCheesePizza extends Pizza {
       public void prepare() {
           setName("伦敦奶酪披萨");        System.out.println("伦敦的奶酪准备原材料");    }}

package com.factoryModel.methodFactory;public class LDPepperPizza extends Pizza {
       public void prepare() {
           setName("伦敦胡椒披萨");        System.out.println("伦敦的胡椒准备原材料");    }}

package com.factoryModel.methodFactory;public class BJOrderPizza extends OrderPizza{
       Pizza createPizza(String orderType) {
           Pizza pizza = null;        if(orderType.equals("cheese")){
               pizza = new BJCheesePizza();        }else if(orderType.equals("pepper")){
               pizza =  new BJPepperPizza();        }        return pizza;    }}

package com.factoryModel.methodFactory;public class LDOrderPizza extends OrderPizza {
       Pizza createPizza(String orderType) {
           Pizza pizza = null;        if(orderType.equals("cheese")){
               pizza = new LDCheesePizza();        }else if(orderType.equals("pepper")){
               pizza = new LDPepperPizza();        }        return pizza;    }}

package com.factoryModel.methodFactory;public class PizzaStore {
       public static void main(String[] args) {
           //new BJOrderPizza();        new LDOrderPizza();    }}

抽象工厂模式

抽象工厂模式定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类。

抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。从设计层面看，抽象工厂模式就是对简单工厂模式的改进（或者称进一步的抽象），将工厂抽象成两层，AbsFactory（抽象工厂）和具体实现的工厂子类，程序员可以根据创建对象类型使用对应的工厂子类，这样将单个的简单工厂类变成了工厂簇，更利于代码的的维护和扩展。

在这里插入图片描述

package com.factoryModel.absFactory.order;import com.factoryModel.absFactory.pizza.Pizza;public interface AbsFactory {
       public Pizza createPizza(String orderType);}

package com.factoryModel.absFactory.order;import com.factoryModel.absFactory.pizza.BJCheesePizza;import com.factoryModel.absFactory.pizza.BJPepperPizza;import com.factoryModel.absFactory.pizza.Pizza;public class BJFactory implements AbsFactory {
       public Pizza createPizza(String orderType) {
           Pizza pizza = null;        if(orderType.equals("cheese")){
               pizza = new BJCheesePizza();        }else if(orderType.equals("pepper")){
               pizza = new BJPepperPizza();        }        return pizza;    }}

package com.factoryModel.absFactory.order;import com.factoryModel.absFactory.pizza.LDCheesePizza;import com.factoryModel.absFactory.pizza.LDPepperPizza;import com.factoryModel.absFactory.pizza.Pizza;public class LDFactory implements AbsFactory {
       public Pizza createPizza(String orderType) {
           Pizza pizza = null;        if(orderType.equals("cheese")){
               pizza = new LDCheesePizza();        }else if(orderType.equals("pepper")){
               pizza = new LDPepperPizza();        }        return pizza;    }}

package com.factoryModel.absFactory.order;import com.factoryModel.absFactory.pizza.Pizza;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class OrderPizza {
       AbsFactory factory;    public OrderPizza(AbsFactory factory) {
           setFactory(factory);    }    private void setFactory(AbsFactory factory){
           Pizza pizza = null;        String orderType = "";        this.factory = factory;        do {
               orderType = getType();            pizza =factory.createPizza(orderType);            if(pizza != null){
                   pizza.prepare();                pizza.bake();                pizza.cut();                pizza.box();            }else{
                   System.out.println("订购失败");                break;            }        }while (true);    }    private String getType(){
           BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));        System.out.println("input is ");        try {
               String readLine = bufferedReader.readLine();            return readLine;        } catch (IOException e) {
               return "";        }    }}

package com.factoryModel.absFactory.order;public class PizzaStore {
       public static void main(String[] args) {
           new OrderPizza(new BJFactory());    }}

工厂模式小结：

（1）工厂模式的意义：将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦，从而提高项目的扩展和维护性。

（2）三种工厂模式：简单工厂模式、工厂方法模式、抽象工厂模式

（3）设计模式的依赖抽象原则

创建对象实例时，不要直接new类，而是把这个new类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。

不要让类继承具体类，而是继承抽象类或者是实现interface(接口)

不要覆盖基类中已经实现的方法。

转载地址：http://fimzi.baihongyu.com/

你可能感兴趣的文章