图解 java 设计模式——彻底弄明白单例模式，工厂模式
Posted 热爱技术的老胡
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了图解 java 设计模式——彻底弄明白单例模式，工厂模式相关的知识，希望对你有一定的参考价值。
1、图解 java 设计模式（二）——彻底弄明白单例模式，工厂模式
1.1、前言
大家可以去 b 站观看韩老师的视频：b站韩老师视频链接
1.2、设计模式介绍
1.2.1、基本介绍
- 设计模式是程序员在面对同类软件设计问题所总结出来的有用的经验，模式不是代码，而是某类问题的通用解决方案，设计模式（Design Pattern）代表了最佳的实践。这些解决方案是众多软件开发人员经过相当长的时间的试验和错误总结出来的。
- 设计模式的本质提高 软件的维护性，通用性和扩展性，并降低软件的复杂度。
- 设计模式的本质提高 软件的维护性，通用性和扩展性，并降低软件的复杂度。
- 设计模式并不局限于某种语言，java，php，c++ 都有设计模式.
1.2.2、设计模式类型
设计模式类型分为三种类型，共 23 种
- 创建型模式：单例模式、抽象工厂模式、原型模式、创建者模式、工厂模式。
- 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
- 行为型模式：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter 模式）、状态模式、策略模式、职责链模式(责任链模式)。
注意：不同的书籍上对分类和名称略有差别
1.3、单例设计模式
1.3.1、介绍
所谓的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。
比如 Hibernate 的 SessionFactory，它充当数据存储源的代理，并负责创建 Session 对象。SessionFactory 并不是轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory 就够，这时就会使用到单例模式。
1.3.2、单例设计模式 8 中方式
- 饿汉式（静态常量）
- 饿汉式（静态代码块）
- 懒汉式（线程不安全）
- 懒汉式（线程安全，同步方法）
- 懒汉式（线程安全，同步代码块）
- 双重检查
- 静态内部类
- 枚举
1.3.3、饿汉式（静态常量）
1.3.3.1、实现步骤
-
构造器私有化（防止 new）
-
类的内部创建对象
-
向外暴露一个静态的公共方法（getInstance）
-
实现代码
package com.hjc.demo1; public class SingletonTest01 public static void main(String[] args) //测试 Singleton instance = Singleton.getInstance(); Singleton instance1 = Singleton.getInstance(); System.out.println(instance == instance1); System.out.println("instance hashCode=" + instance.hashCode()); System.out.println("instance1 hashCode=" + instance.hashCode()); //饿汉式（静态变量） class Singleton //1、构造器私有化 private Singleton() //2、本类内部创建实例对象 private final static Singleton instance = new Singleton(); //3、提供一个共有的静态方法，返回实例对象 public static Singleton getInstance() return instance;
1.3.3.2、代码截图
优缺点说明
- 优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
- 缺点：在类装载的时候就完成实例化，没有达到Lazy Loading（懒加载）的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
- 这种方式基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用 getInstance 方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或其他的静态方法）导致类装载，这时候初始化 instance 就没有达到 lazy loading 的效果
- 结论：这种单例模式可用，可能会造成内存浪费
1.3.4、饿汉式（静态代码块）
1.3.4.1、代码演示
package com.hjc.demo1;
public class SingletonTest01
public static void main(String[] args)
//测试
Singleton instance = Singleton.getInstance();
Singleton instance1 = Singleton.getInstance();
System.out.println(instance == instance1);
System.out.println("instance hashCode=" + instance.hashCode());
System.out.println("instance1 hashCode=" + instance.hashCode());
//饿汉式（静态代码块）
class Singleton
//1、构造器私有化
private Singleton()
private static Singleton instance;
static
//在静态代码块中创建单例对象
instance =new Singleton();
//3、提供一个共有的静态方法，返回实例对象
public static Singleton getInstance()
return instance;
1.3.4.2、代码截图
1.3.4.3、优缺点说明
- 这种方式和放上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的
- 结论：这种单例模式可用，但是可能造成内存浪费
1.3.5、懒汉式（线程不安全）
1.3.5.1、代码演示
package com.hjc.demo1;
public class SingletonTest02
public static void main(String[] args)
System.out.println("懒汉式 1====线程不安全");
Singleton1 instance1 = Singleton1.getInstance();
Singleton1 instance2 = Singleton1.getInstance();
System.out.println(instance2 == instance1);
System.out.println("instance1.hashCode="+instance1.hashCode());
System.out.println("instance2.hashCode="+instance2.hashCode());
class Singleton1
private static Singleton1 instance;
private Singleton1()
//提供一个静态的共有方法，但是用该方法时，才去创建 instance
//懒汉式
public static Singleton1 getInstance()
if (instance == null)
instance = new Singleton1();
return instance;
1.3.5.2、代码截图
1.3.5.3、优缺点说明
- 起到了 Lazy Loading 的效果，但是只能在单线程下使用
- 如果在多线程下，一个线程进入了 if（singleton == null）判断语句块，还未来的及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所有在多线程环境下不可使用这种方式
- 结论：在实际开发中不要使用这种方式
1.3.6、懒汉式（线程安全，同步方法）
1.3.6.1、代码演示
package com.hjc.demo1;
public class SingletonTest02
public static void main(String[] args)
System.out.println("懒汉式 1====线程不安全");
Singleton1 instance1 = Singleton1.getInstance();
Singleton1 instance2 = Singleton1.getInstance();
System.out.println(instance2 == instance1);
System.out.println("instance1.hashCode="+instance1.hashCode());
System.out.println("instance2.hashCode="+instance2.hashCode());
class Singleton1
private static Singleton1 instance;
private Singleton1()
//提供一个静态的共有方法，加入同步处理的代码使用synchronized关键字
//懒汉式
public static synchronized Singleton1 getInstance()
if (instance == null)
instance = new Singleton1();
return instance;
1.3.6.2、优缺点说明
- 解决了线程安全问题
- 效率太低了，每个线程在想获得类的实例时候，执行 getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低
- 结论：在实际开发中，不推荐使用这种方式
1.3.7、懒汉式（线程安全，同步代码块）
1.3.7.1、代码演示
package com.hjc.demo1;
public class SingletonTest02
public static void main(String[] args)
System.out.println("懒汉式 1====线程不安全");
Singleton1 instance1 = Singleton1.getInstance();
Singleton1 instance2 = Singleton1.getInstance();
System.out.println(instance2 == instance1);
System.out.println("instance1.hashCode="+instance1.hashCode());
System.out.println("instance2.hashCode="+instance2.hashCode());
class Singleton1
private static Singleton1 instance;
private Singleton1()
//提供一个静态的共有方法，加入同步处理的代码使用synchronized关键字
//懒汉式
public static Singleton1 getInstance()
if (instance == null)
synchronized(Singleton1.class)
instance = new Singleton1();
return instance;
1.3.7.2、优缺点说明
不推荐使用
1.3.8、双重检查
1.3.8.1、代码演示
package com.hjc.demo1;
public class SingletonTest02
public static void main(String[] args)
System.out.println("======双重检查锁=====");
Singleton1 instance1 = Singleton1.getInstance();
Singleton1 instance2 = Singleton1.getInstance();
System.out.println(instance2 == instance1);
System.out.println("instance1.hashCode="+instance1.hashCode());
System.out.println("instance2.hashCode="+instance2.hashCode());
class Singleton1
private static volatile Singleton1 instance;
private Singleton1()
//提供一个静态的共有方法，使用 volatile 关键字和 synchronized 再使用双重检查
//懒汉式
public static Singleton1 getInstance()
if (instance == null)
synchronized(Singleton1.class)
if (instance == null)
instance = new Singleton1();
return instance;
1.3.8.2、代码截图
1.3.8.3、优缺点说明
- Double-Check 概念是多线程开发中常使用的，如代码中所示，我们进行了两次 if（singleton == null）检查，这样就可以保证线程安全了。
- 这样，实例化代码只用执行一次，后面再次访问时，判断 if（singleton1 == null），直接 return 实例化对象，也避免反复进行方法同步
- 线程安全；延迟加载；效率较高
- 结论：在实际开发中，推荐使用这种单例设计模式
1.3.9、静态内部类
1.3.9.1、代码演示
package com.hjc.demo1;
public class SingletonTest02
public static void main(String[] args)
System.out.println("======静态内部类=====");
Singleton1 instance1 = Singleton1.getInstance();
Singleton1 instance2 = Singleton1.getInstance();
System.out.println(instance2 == instance1);
System.out.println("instance1.hashCode="+instance1.hashCode());
System.out.println("instance2.hashCode="+instance2.hashCode());
class Singleton1
private static volatile Singleton1 instance;
private Singleton1()
//写一个静态内部类，该类中有一个静态属性 Singleton1
private static class SingletonInstance
private static final Singleton1 INSTANCE = new Singleton1();
//提供一个静态的共有方法，直接返回 SingletonInstance INSTANCE
public static synchronized Singleton1 getInstance()
return SingletonInstance.INSTANCE;
1.3.9.2、代码截图
1.3.9.3、优缺点说明
- 这种方式采用了类装载的机制来保证初始化实例时只有一个线程
- 静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化。
- 类的静态属性只会在第一次加载类的时候初始化，所有在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别了线程是无法进入的。
- 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
- 结论：推荐使用
1.3.10、枚举
1.3.10.1、代码演示
package com.hjc.demo1;
public class SingletonTest02
public static void main(String[] args)
System.out.println("======使用枚举=====");
Singleton1 instance1 = Singleton1.INSTANCE;
Singleton1 instance2 = Singleton1.INSTANCE;
System.out.println("instance1.hashCode="+instance1.hashCode());
System.out.println("instance2.hashCode="+instance2.hashCode());
enum Singleton1
INSTANCE;
public void sayOK()
System.out.println("ok~~~");
1.3.10.2、代码截图
1.3.10.3、优缺点说明
- 这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列重新创建新的对象。
- 这种方式是 Effective Java 作者 Josh Bloch 提倡的方式
- 结论：推荐使用
1.3.11、单例模式在 JDK 源码分析
-
我们 JDK 中，java.lang.Runtime就是经典的单例模式（饿汉式）
-
代码分析
1.3.12、总结单例模式注意事项
-
单例模式保证了系统内部中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可用提高性能。
-
当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new。
-
单例模式使用的场景
- 需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗资源过多（即重量级对象），但又经常使用到的对象，工具类对象、频繁访问数据库或文件的对象（比如数据源、Session 工程等）
- 网络的计数器（一般采用单例模式实现，否则难以同步）
- 应用程序的日志应用（只有一个实例去操作比较好，否则内容不好追加显示）
- Windows 的任务管理器就是很典型的单例模式（不能打开两个）
- 等等。。。
1.4、工厂模式
1.4.1、什么是工厂模式
它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新穿创建新创建的对象。实现了创建者和调用者分离，工厂模式分为：
- 简单工厂：用来生产同一等级结构中的任意产品，不支持扩展增加产品
- 工厂方法：用来生产同一等级结构中的固定产品，支持扩展增加产品
- 抽象工厂模式：用来生产不同产品族的全部产品，不支持扩展增加产品，支持增加产品族
1.4.2、看一个具体的需求
一个披萨的项目：要便于披萨种类的扩展，要便于维护：
- 披萨的种类很多（GreekPrizz、CheesePrizz 等）
- 披萨的制作有 prepare、bake、cut、box
- 完成披萨店订购功能
1.4.2.1、使用传统的方式来完成
1.4.2.1.1、代码演示
package com.hjc.demo1;
import com.hjc.demo1.vo.Prizz;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class OrderPrizz
public static void main(String[] args)
OrderPrizz orderPrizz = new OrderPrizz();
//构造器
private OrderPrizz()
Prizz prizz = null;
String orderType;// 订购披萨的类型
do
orderType = getType();
if (orderType.equals("greek"))
prizz = new GreekPrizz();
prizz.setName("希腊披萨");
else if (orderType.equals("cheese"))
prizz = new CheesePrizz();
prizz.setName("奶酪披萨");
else if (orderType.equals("pepper"))
prizz = new PepperPrizz();
prizz.setName("胡椒披萨");
else
break; //啥也不是
//准备原材料
prizz.prepare();
//烘烤
prizz.bake();
//切块
prizz.cut();
//装盒
prizz.box();
while (true);
private String getType()
try
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 类型:");
以上是关于图解 java 设计模式——彻底弄明白单例模式，工厂模式的主要内容，如果未能解决你的问题，请参考以下文章