设计模式：（二）单例与工厂模式

小幸运安然

已于 2022-09-22 23:39:54 修改

阅读量1.6k

点赞数 1

分类专栏：设计模式文章标签：单例模式工厂方法模式抽象工厂模式简单工厂模式

于 2021-02-28 12:19:09 首次发布

余笙

本文链接：https://blog.csdn.net/qq_42200163/article/details/114216449

版权

设计模式专栏收录该内容

7 篇文章 1 订阅

订阅专栏

一、单例设计模式（Singleton）

1、概述

1、类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。

2、定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。

3、特点：

某个类只能有一个实例（即构造器私有，防止外部通过new XXX()创建对象）

自行在类的内部创建对象实例

向外暴露一个静态的公共方法

4、八种单例模式实现方式：

饿汉式（静态常量）

饿汉式（静态代码块）

懒汉式（线程不安全）

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

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

双重检查

静态内部类

枚举

2、饿汉式（静态常量）

public class Singleton {
    //创建实例对象
    private final static Singleton instance = new Singleton();

    /**
     * 构造器私有化，防止外部类能直接new
     */
    private Singleton() {}

    /**
     * 提供一个公有的静态方法，返回实例对象
     * @return
     */
    public static Singleton getInstance() {
        return instance;
    }
}

public class SingletonTest01 {
    public static void main(String[] args) {
        //测试
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1.hashCode:" + instance1.hashCode());
        System.out.println("instance2.hashCode:" + instance2.hashCode());
    }
}

/**
 * 运行结果：
 * true
 * instance1.hashCode:1956725890
 * instance2.hashCode:1956725890
 */

1、优点：

写法简单，在类装载的时候就完成实例化，避免了线程同步问题。

2、缺点：

在类装载的时候就完成初始化，没有达到懒加载（Lazy Loading）的效果。如果从始至终都没有用到这个实例，则会造成内存的浪费。

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

4、这种单例模式可用，可能造成内存浪费。

4、饿汉式（静态代码块）

public class Singleton {
    //实例对象
    private static Singleton instance;

    /**
     * 在静态代码块中，创建单例对象
     */
    static {
        instance = new Singleton();
    }

    /**
     * 构造器私有化，防止外部类能直接new
     */
    private Singleton() {}

    /**
     * 提供一个公有的静态方法，返回实例对象
     * @return
     */
    public static Singleton getInstance() {
        return instance;
    }
}

1、这种方式与上面方式类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和饿汉式（静态常量）创建方式一样。

2、这种单例模式可用，但是可能造成内存浪费。

5、懒汉式（线程不安全）

1、当需要使用到对象的时候，才会创建对象即懒汉式。

public class Singleton {
    //实例对象
    private static Singleton instance;

    /**
     * 构造器私有化，防止外部类能直接new
     */
    private Singleton() {}

    /**
     * 提供一个公有的静态方法，当使用到该方法时，才会创建instance
     * @return
     */
    public static Singleton getInstance() {
        //若对象为空，则创建
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

1、起到了懒加载的效果，但是只能在单线程下使用。

2、如果在多线程下，一个线程进入if (instance == null)判断语句，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例对象，因此在多线程环境下不能使用这种方式。

3、在实际开发中，不要使用这种方式。

6、懒汉式（线程安全，同步方法）

public class Singleton {
    //实例对象
    private static Singleton instance;

    /**
     * 构造器私有化，防止外部类能直接new
     */
    private Singleton() {}

    /**
     * 提供一个公有的静态方法，加入同步处理，解决线程安全问题
     * @return
     */
    public static synchronized Singleton getInstance() {
        //若对象为空，则创建
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

1、解决了线程不安全问题

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

3、在实际开发中，不推荐使用。

7、懒汉式（线程安全，同步代码块）

class Singleton {
    //实例对象
    private static Singleton instance;

    /**
     * 构造器私有化，防止外部类能直接new
     */
    private Singleton() {}

    /**
     * 提供一个公有的静态方法
     * @return
     */
    public static Singleton getInstance() {
        //若对象为空，则创建
        if (instance == null) {
            //同步代码块
            synchronized (Singleton.class) {
                instance = new Singleton();
            }
        }
        return instance;
    }
}

1、这种方式本意是想对上面实现方式改进，因为上面实现方式的同步方法效率太低，改为同步产生实例化的代码块。

2、但是这种同步并不能起到线程同步的作用，假如一个线程进入了判断语句，还没有执行对象实例化，另一个线程也通过了这个判断语句，这是便会产生多个实例。

3、实际开发中，不能使用这种方式。

8、双重检查

public class Singleton {
    //实例对象
    private static volatile Singleton instance;

    /**
     * 构造器私有化，防止外部类能直接new
     */
    private Singleton() {}

    /**
     * 提供一个公有的静态方法，加入双重检查处理，解决线程安全问题，
     * 同时解决懒加载问题，也保证了效率
     * @return
     */
    public static Singleton getInstance() {
        //实例没创建，才会进入内部的 synchronized代码块
        if (instance == null) {
            synchronized (Singleton.class) {
                //此处再判断一次，可能会出现其他线程创建了实例
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

1、DoubleCheck概念是多线程开发中常使用到的，如代码中所示，进行了两次if (instance == null)检查，这样就保证了线程安全。

2、实例化代码只用执行一次，后面再次访问时，判断if (instance == null)，直接return实例化对象，也避免反复进行方法同步。

3、线程安全，延迟加载，效率较高。

4、推荐使用这种单例设计模式。

9、静态内部类

public class Singleton {
    private Singleton() {}
    
    /**
     * 静态内部类，类中有一个静态属性
     */
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static final Singleton getInstance() {
        return SingletonInstance.INSTANCE ;
    }
}

1、这种方式采用了类装载的机制来保证初始化实例时只有一个线程。

2、静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法时，才会装载SingletonInstance类，从而完成Singleton的实例化。

3、类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

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

10、枚举实现单例模式

public enum Singleton{
    INSTANCE;
    public Singleton getInstance(){
        return INSTANCE;
    }
}

public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.INSTANCE.getInstance();
        Singleton instance2 = Singleton.INSTANCE.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1=" + instance1.hashCode());
        System.out.println("instance2=" + instance2.hashCode());
    }
}

1、借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

2、推荐使用。

11、总结

1、单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。

2、当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new。

3、单例模式使用的场景：

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

二、简单工厂模式

1、概述

1、简单工厂模式定义（Simple Factory Pattern）：从设计模式的类型上来说，简单工厂模式是属于创建型模式，在简单工厂模式中创建实例的方法通常为静态（static）方法，因此又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

2、工厂模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点，提高扩展性和维护性。

3、在日常开发中，凡是需要生成复杂对象的地方，都可以尝试考虑使用工厂模式来代替。

4、复杂对象：指的是类的构造函数参数过多等对类的构造有影响的情况，因为类的构造过于复杂，如果直接在其他业务类内使用，则两者的耦合过重，后续业务更改，就需要在任何引用该类的源代码内进行更改，光是查找所有依赖就很消耗时间了，更别说要一个一个修改了。

5、按实际业务场景划分，工厂模式有3种不同的实现方式：

简单工厂模式

工厂方法模式

抽象工厂模式

2、简单工厂模式的主要角色

1、简单工厂（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。

2、抽象产品（Product）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。

3、具体产品（ConcreteProduct）：具体产品类，是简单工厂模式的创建目标。

3、简单工厂模式实现

/**
 * 创建抽象产品类
 */
public abstract class Product {
    private String name;

    /**
     * 抽象方法，由具体的产品类去实现
     */
    public abstract void make();

    public void finish(){
        System.out.println(name + "完成制作");
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

/**
 * 具体产品1，继承Product，并且实现了父类的make制作产品的方法
 */
public class ConcreteProduct1 extends Product {
    @Override
    public void make() {
        setName("饼干");
        System.out.println(getName() + "准备巧克力、奶油等材料，开始制作");
    }
}

/**
 * 具体产品2，继承Product，并且实现了父类的make制作产品的方法
 */
public class ConcreteProduct2 extends Product {
    @Override
    public void make() {
        setName("果汁");
        System.out.println(getName() + "准备水果等材料，开始制作");
    }
}

/**
* 创建工厂类，提供一个静态方法，客户端只需要传入产品的类型，就会实例化相应的产品。
* 简单工厂
*/
public class SimpleFactory {
   public Product createProduct(String type) {
       System.out.println("使用简单工厂模式~");
       Product product = null;
       if (type.equals("饼干")) {
           product = new ConcreteProduct1();
       } else if (type.equals("果汁")) {
           product = new ConcreteProduct2();
       }
       product.make();
       product.finish();
       return product;
   }
}

/**
 * 客户端调用工厂类
 */
public class Test {
    public static void main(String[] args) {
        SimpleFactory.createProduct(getType());
    }

    private static String getType() {
        try {
            BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("输入商品名称：");
            String str = bf.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}
/**
 * 运行结果：
 * 输入商品名称：
 * 饼干
 * 使用简单工厂模式~
 * 饼干准备巧克力、奶油等材料，开始制作
 * 饼干完成制作
 */

4、优缺点说明

1、优点：

工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；简单工厂模式通过这种做法实现了对责任的分割，它提供了专门的工厂类用于创建对象。

客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量。

2、缺点：

简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。

使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度

系统扩展困难，一旦增加新产品不得不修改工厂逻辑，同样破坏了“开闭原则”；在产品类型较多时，可能造成逻辑过于复杂，不利于系统的扩展和维护。

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

三、工厂方法模式

1、概述

1、工厂方法模式是简单工厂的进一步抽象和推广，由于工厂方法模式具有多态性，工厂方法模式既保持了简单工厂的优点，同时又克服了它的缺点，简单工厂模式中的工厂类负责创建实例，那么如果有新的类型添加，就要修改工厂类，这样也不利于进一步松耦合。工厂方法模式中核心工厂类不负责所有实例的创建，而是将具体的创建工作交给了子类去完成，这个核心类成为了一个抽象工厂角色。

2、工厂方法模式的主要角色

1、抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。

2、具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

3、抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。

4、具体工厂（ConcreteFactory）：主要是实现抽象工厂中的接口，完成具体产品的创建。

3、工厂方法模式实现

/**
 * 创建抽象产品类
 */
public abstract class Product {
    private String name;

    /**
     * 抽象方法，由具体的产品类去实现
     */
    public abstract void make();

    public void finish(){
        System.out.println(name + "完成制作");
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

/**
 * 具体产品1，继承Product，并且实现了父类的make制作产品的方法
 */
public class ConcreteProduct1 extends Product {
    @Override
    public void make() {
        setName("饼干");
        System.out.println(getName() + "准备巧克力、奶油等材料，开始制作");
    }
}

/**
 * 具体产品2，继承Product，并且实现了父类的make制作产品的方法
 */
public class ConcreteProduct2 extends Product {
    @Override
    public void make() {
        setName("果汁");
        System.out.println(getName() + "准备水果等材料，开始制作");
    }
}

/**
 * 创建抽象工厂类，提供了工厂的生成方法
 */
public interface AbstractFactory {
    public Product newProduct();
}

/**
 * 创建具体工厂类1
 */
public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public Product newProduct() {
        System.out.println("具体工厂1生产具体产品");
        return new ConcreteProduct1();
    }
}

/**
 * 创建具体工厂类2
 */
public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public Product newProduct() {
        System.out.println("具体工厂2生产具体产品");
        return new ConcreteProduct2();
    }
}

/**
 * 客户端调用工厂类
 */
public class Test {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        Product product1 = factory1.newProduct();
        product1.make();
        product1.finish();

        System.out.println("===================================");

        AbstractFactory factory2 = new ConcreteFactory2();
        Product product2 = factory2.newProduct();
        product2.make();
        product2.finish();
    }
}
/**
 * 运行结果：
 * 具体工厂1生产具体产品
 * 饼干准备巧克力、奶油等材料，开始制作
 * 饼干完成制作
 * ===================================
 * 具体工厂2生产具体产品
 * 果汁准备水果等材料，开始制作
 * 果汁完成制作
 */

4、优缺点说明

1、优点：

用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。

灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。

典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

2、缺点：

类的个数容易过多，增加复杂度

增加了系统的抽象性和理解难度

抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

四、抽象工厂模式

1、概述

1、抽象工厂（AbstractFactory）模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级（种类）的产品，而抽象工厂模式可生产多个等级的产品。

2、使用抽象工厂模式一般要满足以下条件：

系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。

系统一次只可能消费其中某一族产品，即同族的产品一起使用。

2、抽象工厂模式的主要角色

1、抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。

2、具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。

3、抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。

4、具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

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

1、工厂方法模式：一个抽象产品类，可以派生出多个具体产品类，每个具体工厂类只能创建一个具体产品类的实例。

2、抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类，一个抽象工厂类可以派生出多个具体工厂类，每个具体工厂类可以创建多个具体产品的实例。

3、区别：工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个，工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

4、抽象工厂模式实现

/**
 * 创建抽象产品类，抽象产品角色1
 */
public interface AbstractProductA {
    public void car();
}

/**
 * 创建抽象产品类，抽象产品角色2
 */
public interface AbstractProductB {
    public void food();
}

/**
 * 具体产品A1
 */
public class ProductA1 implements AbstractProductA {
    @Override
    public void car() {
        System.out.println("生产小汽车");
    }
}

/**
 * 具体产品A2
 */
public class ProductA2 implements AbstractProductA {
    @Override
    public void car() {
        System.out.println("生产摩托车");
    }
}

/**
 * 具体产品B1
 */
public class ProductB1 implements AbstractProductB {
    @Override
    public void food() {
        System.out.println("生产面包");
    }
}

/**
 * 具体产品B2
 */
public class ProductB2 implements AbstractProductB {
    @Override
    public void food() {
        System.out.println("生产牛奶");
    }
}

/**
 * 创建抽象工厂类
 */
public interface AbstractFactory {
    public AbstractProductA createProductA();
    public AbstractProductB createProductB();
}

/**
 * 创建具体工厂类，具体工厂1
 */
public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}

/**
 * 创建具体工厂类，具体工厂2
 */
public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

/**
 * 客户端调用工厂类
 */
public class Test {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractProductA product1 = factory1.createProductA();
        AbstractProductB product2 = factory1.createProductB();
        product1.car();
        product2.food();
        System.out.println("===================================");
        AbstractFactory factory2 = new ConcreteFactory2();
        AbstractProductA product3 = factory2.createProductA();
        AbstractProductB product4 = factory2.createProductB();
        product3.car();
        product4.food();
    }
}
/**
 * 运行结果：
 * 生产小汽车
 * 生产面包
 * ===================================
 * 生产摩托车
 * 生产牛奶
 */

5、优缺点说明

1、优点：抽象工厂模式除了具有工厂方法模式的优点外，还有如下几个优点

可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。

当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。

抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

2、缺点：

当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。

小幸运安然

关注

1
点赞
踩
7

收藏

觉得还不错? 一键收藏
4
评论
设计模式：（二）单例与工厂模式

一、单例设计模式（Singleton）1、概述类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。举例：Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。还有操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、
复制链接

扫一扫