在序列化的問題域裡面有一個常見的問題，就是反序列化時用何種方式來建立Java物件，因為反序列化的目的是把一段二進位制流轉化成一個物件。

在Java裡面建立物件有幾種方式：

1. 顯式地呼叫new語句， 比如 DemoClass demo = new DemoClass()

2. 利用反射機制，通過Class物件的newInstance()方法，比如DemoClass demo = DemoClass.class.newInstance()。 但是有個前提就是必須提供無參的建構函式

3. 利用反射機制，利用Constructor物件來建立物件

這三種方式本質上都是一樣的，都是常規的Java建立物件的new機制，不管是顯式地還是隱式的。一個new操作，編譯成指令後是3條

第一條指令的意思是根據型別分配一塊記憶體區域

第二條指令是把第一條指令返回的記憶體地址壓入運算元棧頂

第三條指令是呼叫類的建構函式

new機制有個問題就是:. 當類只提供有參的建構函式時，必須使用這個有參的建構函式。

那麼問題來了，當反序列化的時候，不可能使用顯示地new操作，因為肯定地根據傳過來的型別動態地呼叫。利用newInstance肯定沒戲了，因為不能確定這個類是否提供了無參建構函式。只能第三種，利用反射機制，使用Constructor物件來建立物件。

但是Consturctor物件有個約束，就是需要提供引數的型別列表，然後使用Constructor.newInstance方法需要傳遞相應個數的引數。

在反序列化這個場景下，可以這麼做：先根據反射獲得Constructor的引數型別列表，然後根據每種型別，構造一個對應的預設值的列表，然後呼叫Constructor.newInstance()方法。這樣可以創建出一個具有預設值的物件。

但是問題又來了，萬一這個類的建構函式做了一些特別的操作，比如判斷傳入的引數的值，如果引數值不符合規範就拋異常，那麼建立物件就失敗了

public static void testConstructor(){
		try {
			Class[] cls = new Class[] { int.class, int.class };
	        Constructor c = DemoClass.class.getDeclaredConstructor(cls);
			DemoClass obj = (DemoClass) c.newInstance(0, 0);
			System.out.println(obj.getValue1());
			System.out.println(obj.getValue2());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void testConstructorWityParameterTypes(){
		try {
			Constructor[] c = DemoClass.class.getDeclaredConstructors();
			Type[] parameterTypes = c[0].getGenericParameterTypes();
			// 判斷type型別，依次設定預設值
			DemoClass obj = (DemoClass) c[0].newInstance(0, 0);
			System.out.println(obj.getValue1());
			System.out.println(obj.getValue2());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
 

這裡提出一種使用sun.misc.Unsafe方法解決這個由於有參建構函式引起的建立Java物件的問題。Unsafe有一個allocateInstance(Class)方法，這個方法只需要傳入一個型別就可以建立Java物件了，不正好完美的解決了我們的問題嗎？

new操作被解析成了3個步驟，而Unsafe.allocateInstance()方法值做了第一步和第二步，即分配記憶體空間，返回記憶體地址，沒有做第三步呼叫建構函式。所以Unsafe.allocateInstance()方法建立的物件都是隻有初始值，沒有預設值也沒有建構函式設定的值，因為它完全沒有使用new機制，直接操作記憶體建立了物件。下面看一個完整的例子，包括如何獲得Unsafe物件。

在Eclipse裡面引用sun.misc.Unsafe類需要設定一下 Preference --> Java  --> Compiler  -->  Errors/Warnings -->  Forbidden reference ，從Error改成Warning

package com.zc.lock;


import java.lang.reflect.Field;
import sun.misc.Unsafe;

public class UnsafeUtility {

	private static Unsafe unsafe;
	static {
		try {
			Field f = Unsafe.class.getDeclaredField("theUnsafe");
			f.setAccessible(true);
			unsafe = (Unsafe) f.get(null);
		} catch (Exception e) {
		}
	}
	
	public static Unsafe getUnsafe(){
		return unsafe;
	}

}

一個測試用例

package com.zc.lock.test;

public class DemoClass {
	private int value1;
	
	private int value2 = 10;
	
	public DemoClass(int value1, int value2){
		this.value1 = value1; 
		this.value2 = value2;
	}

	public int getValue1() {
		return value1;
	}

	public void setValue1(int value1) {
		this.value1 = value1;
	}

	public int getValue2() {
		return value2;
	}

	public void setValue2(int value2) {
		this.value2 = value2;
	}
}

package com.zc.lock.test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Type;

import sun.misc.Unsafe;

import com.zc.lock.UnsafeUtility;

public class Main {
    public static void main(String[] args){
//        testNewObject();
//        testNewInstance();
//        testConstructor();
//        testConstructorWityParameterTypes();
//        testUnsafeAllocateInstance();
    }
    

    public static void testUnsafeAllocateInstance(){
        Unsafe unsafe = UnsafeUtility.getUnsafe();
        
        try {
            DemoClass obj = (DemoClass)unsafe.allocateInstance(DemoClass.class);
            System.out.println(obj.getValue1());
            System.out.println(obj.getValue2());
            obj.setValue1(1);
            obj.setValue2(2);
            System.out.println(obj.getValue1());
            System.out.println(obj.getValue2());
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
    
    public static void testNewObject(){
        DemoClass obj = new DemoClass(1,2);
        System.out.println(obj.getValue1());
        System.out.println(obj.getValue2());
    }
    
    public static void testNewInstance(){
        try {
            DemoClass obj = DemoClass.class.newInstance();
            System.out.println(obj.getValue1());
            System.out.println(obj.getValue2());
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
    
    public static void testConstructor(){
        try {
            Class[] cls = new Class[] { int.class, int.class };
            Constructor c = DemoClass.class.getDeclaredConstructor(cls);
            DemoClass obj = (DemoClass) c.newInstance(0, 0);
            System.out.println(obj.getValue1());
            System.out.println(obj.getValue2());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void testConstructorWityParameterTypes(){
        try {
            Constructor[] c = DemoClass.class.getDeclaredConstructors();
            Type[] parameterTypes = c[0].getGenericParameterTypes();
            // 判斷type型別，依次設定預設值
            DemoClass obj = (DemoClass) c[0].newInstance(0, 0);
            System.out.println(obj.getValue1());
            System.out.println(obj.getValue2());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
}