2. 程式人生 > >java設計模式之單例模式（列舉、靜態內部類）

java設計模式之單例模式（列舉、靜態內部類）

阿新 • • 發佈：2019-05-14

1、靜態內部類

public class InnerClassSingleton implements Serializable {
    
    //無參建構函式
    private InnerClassSingleton(){};
    
    public static final InnerClassSingleton getInstance(){
        return InnerClassHelper.INSTANCE;
    }
    
    //內部類
    private static class InnerClassHelper{
        private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
    }
}

它的原理是利用了類載入機制。

1.1、但是它可以被反射破壞
	Class clazz = InnerClassSingleton.class;
        Constructor c = clazz.getDeclaredConstructor(null);
        c.setAccessible(true);
        Object o1 = c.newInstance();

        Object o2 = InnerClassSingleton.getInstance();

執行這段程式碼會發現o1<>o2，這就破壞了單例。
而反射的newInstance()的底層用的是下面這行程式碼實現的，它就是罪魁禍首。

UnsafeFieldAccessorImpl.unsafe.allocateInstance(class)

我們知道new建立物件時會被編譯成3條指令：

  • 1、根據型別分配一塊記憶體區域
  • 2、把第一條指令返回的記憶體地址壓入運算元棧頂
  • 3、呼叫類的建構函式

而Unsafe.allocateInstance()方法值做了第一步和第二步，即分配記憶體空間，返回記憶體地址，沒有做第三步呼叫建構函式。所以Unsafe.allocateInstance()方法建立的物件都是隻有初始值，沒有預設值也沒有建構函式設定的值，因為它完全沒有使用new機制，繞過了建構函式直接操作記憶體建立了物件，而單例是通過私有化建構函式來保證的，這就使得單例失敗

。

1.2、還可以被反序列化破壞
InnerClassSingleton o1 = null;
InnerClassSingleton o2 = InnerClassSingleton.getInstance();

FileOutputStream fos = new FileOutputStream("InnerClassSingleton.obj");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(o2);
oos.flush();
oos.close();

FileInputStream fis = new FileInputStream("InnerClassSingleton.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
o1 = (InnerClassSingleton) ois.readObject();
ois.close();

System.out.println(o1);
System.out.println(o2);

執行完這段程式碼我們又會發現o1<>o2，可見通過反序列化，成功破壞了單例，建立了2個物件。
那麼如何避免這種情況發生呢？很簡單，只要在程式碼中新增：

public class InnerClassSingleton implements Serializable {
	....省略重複程式碼
	private Object readResolve(){
		return INSTANCE;
	}
}

這時候我們可以再執行一下上面反序列化的方法，會很神奇的發現o1==o2，那這是為什麼呢？我們一起來看下ois.readObject()的原始碼：

private Object readObject0(boolean unshared) throws IOException {
	...省略
	case TC_OBJECT:
	  return checkResolve(readOrdinaryObject(unshared));
}
-------------------------------------------------------------------
private Object readOrdinaryObject(boolean unshared){
	if (bin.readByte() != TC_OBJECT) {
            throw new InternalError();
        }

        ObjectStreamClass desc = readClassDesc(false);
        desc.checkDeserialize();

        Class<?> cl = desc.forClass();
        if (cl == String.class || cl == Class.class
                || cl == ObjectStreamClass.class) {
            throw new InvalidClassException("invalid class descriptor");
        }

        Object obj;
        try {
	//重點！！！
	//首先isInstantiable()判斷是否可以初始化
	//如果為true，則呼叫newInstance()方法建立物件，這時建立的物件是不走建構函式的，是一個新的物件
            obj = desc.isInstantiable() ? desc.newInstance() : null;
        } catch (Exception ex) {
            throw (IOException) new InvalidClassException(
                desc.forClass().getName(),
                "unable to create instance").initCause(ex);
        }

        passHandle = handles.assign(unshared ? unsharedMarker : obj);
        ClassNotFoundException resolveEx = desc.getResolveException();
        if (resolveEx != null) {
            handles.markException(passHandle, resolveEx);
        }

        if (desc.isExternalizable()) {
            readExternalData((Externalizable) obj, desc);
        } else {
            readSerialData(obj, desc);
        }

        handles.finish(passHandle);
	
	//重點！！！
	//hasReadResolveMethod()會去判斷，我們的InnerClassSingleton物件中是否有readResolve()方法
        if (obj != null &&
            handles.lookupException(passHandle) == null &&
            desc.hasReadResolveMethod())
        {
	//如果為true，則執行readResolve()方法，而我們在自己的readResolve()方法中 直接retrun INSTANCE，所以還是返回的同一個物件，保證了單例
            Object rep = desc.invokeReadResolve(obj);
            if (unshared && rep.getClass().isArray()) {
                rep = cloneArray(rep);
            }
            if (rep != obj) {
                // Filter the replacement object
                if (rep != null) {
                    if (rep.getClass().isArray()) {
                        filterCheck(rep.getClass(), Array.getLength(rep));
                    } else {
                        filterCheck(rep.getClass(), -1);
                    }
                }
                handles.setObject(passHandle, obj = rep);
            }
        }

        return obj;
}

最後總結一下靜態內部類寫法：

  • 優點：不用synchronized，效能好；簡單
  • 缺點：無法避免被反射、反序列化破壞

2、列舉

public enum EnumSingleton {
    
    INSTANCE;

    private Object data;

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public static EnumSingleton getInstance() {
        return INSTANCE;
    }
}

反編譯這段程式碼，得到：

	static
        {
            INSTANCE = new EnumSingleton("INSTANCE",0);
            $VALUE = (new EnumSingleton[] {
                    INSTANCE
            });
        }

顯然這是一種餓漢式的寫法，用static程式碼塊來保證單例（在類載入的時候就初始化了）。

2.1、可以避免被反射破壞
//反射
Class clazz = EnumSingleton.class;
//拿到建構函式
Constructor c = clazz.getDeclaredConstructor(String.class, int.class);
c.setAccessible(true);
EnumSingleton instance1 = (EnumSingleton)c.newInstance("smart", 111);
-----------------------------------------------------------------------------------------
public T newInstance(Object ... initargs){
	if ((clazz.getModifiers() & Modifier.ENUM) != 0)
   	   throw new IllegalArgumentException("Cannot reflectively create enum objects");
}

可以看到，在newInstance()方法中，做了型別判斷，如果是列舉型別，直接丟擲異常。也就是說從jdk層面保證了列舉不能被反射。

2.2、可以避免被反序列化破壞

Java規範中規定，每一個列舉型別極其定義的列舉變數在JVM中都是唯一的，在序列化的時候Java僅僅是將列舉物件的name屬性輸出到結果中，反序列化的時候則是通過 java.lang.Enum 的 valueOf() 方法來根據名字查詢列舉物件。

private Object readObject0(boolean unshared) throws IOException {
	...省略
	case TC_ENUM:
	  return checkResolve(readEnum(unshared));
}
-------------------------------------------------------------------
private Object readEnum(boolean unshared){
	...省略
	String name = readString(false);
        Enum<?> result = null;
        Class<?> cl = desc.forClass();
        if (cl != null) {
            try {
                @SuppressWarnings("unchecked")
		//重點！！！
		//通過valueO方法獲取Enum，引數為class和name
                Enum<?> en = Enum.valueOf((Class)cl, name);
                result = en;
            } catch (IllegalArgumentException ex) {
                throw (IOException) new InvalidObjectException(
                    "enum constant " + name + " does not exist in " +
                    cl).initCause(ex);
            }
            if (!unshared) {
                handles.setObject(enumHandle, result);
            }
        }
}

所以序列化的時候只將 INSTANCE 這個名稱輸出，反序列化的時候再通過這個名稱，查詢對應的列舉型別，因此反序列化後的例項也會和之前被序列化的

相關推薦

java設計模式之單例模式（列舉、靜態內部類）

1、靜態內部類 public class InnerClassSingleton implements Serializable

JAVA設計模式之單例模式（轉）

單例對象 日誌 locking anti 常見 基本上 title 加載 懶漢式 本文繼續介紹23種設計模式系列之單例模式。 概念：　　java中單例模式是一種常見的設計模式，單例模式的寫法有好幾種，這裏主要介紹三種：懶漢式單例、餓漢式單例、登記式單例。　　單例模式有以下特

Java設計模式之單例模式（七種寫法）

不一定 java設計 font method 防止 turn 無法 lazy 三種 Java設計模式之單例模式（七種寫法） 第一種，懶漢式，lazy初始化，線程不安全,多線程中無法工作： public class Singleton { private stati

設計模式（建立型）：Java常用23種設計模式之單例模式詳解以及Java程式碼實現

可以說單例模式是所有設計模式中最簡單的一種。 單例模式就是說系統中對於某類的只能有一個物件，不可能出來第二個。 單例模式也是23中設計模式中在面試時少數幾個會要求寫程式碼的模式之一。主要考察的是多執行緒下面單例模式的執行緒安全性問題。 1.多執行緒安全單例模式例項一(不使用同步鎖)

java設計模式（一）建立型模式之 單例模式（餓漢式，懶漢式，執行緒安全，雙重檢查）

1.介紹     單例模式是一種常用的軟體設計模式，其定義是單例物件的類只能允許一個例項存在。  2.實現思路與步驟   1).將該類的構造方法定義為私有方法，這樣其他處的程式碼就無法通過呼叫該類的構造方法來例項化該類的物件，只有通過該類提供的靜態

java設計模式之單例模式（幾種寫法及比較）

概念：　　java中單例模式是一種常見的設計模式，單例模式的寫法有好幾種，這裡主要介紹三種：懶漢式單例、餓漢式單例、登記式單例。　　單例模式有以下特點：　　1、單例類只能有一個例項。　　2、單例類必須自己建立自己的唯一例項。　　3、單例類必須給所有其他物件提供這一例項。　

java架構之路-（設計模式）五種建立型模式之單例模式

　　設計模式自身一直不是很瞭解，但其實我們時刻都在使用這些設計模式的，java有23種設計模式和6大原則。 設計模式是一套被反覆使用、多數人知曉的、經過分類編目的、程式碼設計經驗的總結。使用設計模式是為了可重用程式碼、讓程式碼更容易被他人理解、保證程式碼可靠性、程式的重用性。 其中包含 建立型模式，共五種：單

Java設計模式之單例模式

設計 return 線程安全 -s ron none 方法 有一個 ava 　　一、前言： 　　轉載需要註明出處： https://i.cnblogs.com/EditPosts.aspx?opt=1 　　單例模式其實很早之前就已經接觸過了，但都是為了應付面試或者是為了裝X

python設計模式之單例模式（二）

__new__ 有意 {} 開發人員 sta 字典 spa 出現 創建 上次我們簡單了解了一下什麽是單例模式，今天我們繼續探究。上次的內容點這 python設計模式之單例模式（一） 上次們討論的是GoF的單例設計模式，該模式是指:一個類有且只有一個對象。通常我們需

設計模式之單例模式(Java實現版)

單例模式作用在一個類上，這個類提供了一種方法來訪問它的唯一物件，可以直接訪問，而不需要例項化類的物件。單例模式的作用是保證一個類只有一個物件例項。 class Singleton { private static Singleton instance = new Singleton()

Java小白如何初步掌握java設計模式之單例模式！

單例設計模式（Singleton Pattern）是最簡單且常見的設計模式之一，主要作用是提供一個全域性訪問且只例項化一次的物件，避免多例項物件的情況下引起邏輯性錯誤（例項化數量可控）… 概述 Java中，單例模式主要分三種：懶漢式單例、餓漢式單例、登記式單例三種。 特點

Java設計模式之單例模式(SingleInstance)

模式定義 需求背景 具體實現 模式定義 單例：保證一個類僅有一個例項，並提供一個訪問它的全域性訪問點。 需求背景 在App程序中保證類的例項唯一性，例如資料庫訪問入口等。

java高階設計模式之單例模式

一、定義 保證一個類僅有一個例項，並提供一個訪問它的全域性訪問點。 二、結構和說明  三、基本實現 四、認識單例模式    1、單例模式的功能         單例模式的功能是用來保證這個

設計模式之 單例模式（懶漢式和餓漢式）

設計模式： 一些人總結出來用來解決特定問題的固定的解決方案。 單例模式 解決一個類在記憶體中只存在一個物件，想要保證物件的唯一。 1 為了避免其他程式過多的建立該類物件。禁止其他程式建立該類物件。 2 為了其他程式可以訪問該類物件，在本類中自定義一個物件。 3 方便其他程

（一）設計模式之單例模式(singtonMode)

參考文章： （1）https://blog.csdn.net/li295214001/article/details/48135939 （2）http://love-love-l.blog.163.com/blog/static/21078304201001804211901/ （3）h

java中的設計模式之單例模式、工廠模式

Java中的設計模式            轉載地址：https://www.toutiao.com/i6573486403282272775/ 為什麼要學習設計模式 1）設計模式都是一些相對優秀的解決方案，很多問題都是典型的

設計模式之單例模式（關鍵詞：設計模式/單例模式/單件模式）

設計模式 單例模式 定義 單例模式：允許一些物件中只存在 1 個例項。 類裝飾器版本 1：使用 1 個全域性字典，儲存所有類的例項。 instances = {} def getInstances(aClass, *args): if aClass not in i

設計模式之單例模式二（懶漢式double check）

上一篇文章中的懶漢式單例模式採用同步方法保證了執行緒安全，但是開銷很大，每次執行該方法都會檢查鎖。下面採用double check的方式進行改寫，下面這種實現看似可行，實則有缺陷，具體缺陷在後文分析： 注意上面第二幅圖中對lazyDoubleCheckSingl

設計模式之單例模式五（序列化與反序列化破壞）

單例模式的核心是要保證單例，但是在將一個例項序列化到一個檔案中後，再反序列化得到一個例項，這兩個例項是不同的，這就違反了單例原則，如下面惡漢式單例模式對序列化的測試： 由上面的列印資訊可知得到的是兩個不同的例項，通過除錯跟程式碼可以很容易發現，在反序列化時通過反

java 設計模式之單例模式 一篇就夠了

單例模式 單例物件（Singleton）是一種常用的設計模式。 在Java應用中，單例物件能保證在一個JVM中，該物件只有一個例項存在。這樣的模式有幾個好處： 1、某些類建立比較頻繁，對於一些大型的