Java序列化與反序列化

在Java中，我們可以通過多種方式來創(chuàng)建對象，并且只要對象沒有被回收我們都可以復用該對象。但是，我們創(chuàng)建出來的這些Java對象都是存在于JVM的堆內(nèi)存中的。只有JVM處于運行狀態(tài)的時候，這些對象才可能存在。一旦JVM停止運行，這些對象的狀態(tài)也就隨之而丟失了。

但是在真實的應用場景中，我們需要將這些對象持久化下來，并且能夠在需要的時候把對象重新讀取出來。Java的對象序列化可以幫助我們實現(xiàn)該功能。

對象序列化機制（object serialization）是Java語言內(nèi)建的一種對象持久化方式，通過對象序列化，可以把對象的狀態(tài)保存為字節(jié)數(shù)組，并且可以在有需要的時候將這個字節(jié)數(shù)組通過反序列化的方式再轉換成對象。對象序列化可以很容易的在JVM中的活動對象和字節(jié)數(shù)組（流）之間進行轉換。

在Java中，對象的序列化與反序列化被廣泛應用到RMI(遠程方法調用)及網(wǎng)絡傳輸中。

相關接口及類

Java為了方便開發(fā)人員將Java對象進行序列化及反序列化提供了一套方便的API來支持。其中包括以下接口和類：

java.io.Serializable
java.io.Externalizable
ObjectOutput
ObjectInput
ObjectOutputStream
ObjectInputStream

Serializable 接口

類通過實現(xiàn) java.io.Serializable 接口以啟用其序列化功能。未實現(xiàn)此接口的類將無法使其任何狀態(tài)序列化或反序列化。可序列化類的所有子類型本身都是可序列化的。序列化接口沒有方法或字段，僅用于標識可序列化的語義。

當試圖對一個對象進行序列化的時候，如果遇到不支持 Serializable 接口的對象。在此情況下，將拋出 NotSerializableException。

如果要序列化的類有父類，要想同時將在父類中定義過的變量持久化下來，那么父類也應該繼承java.io.Serializable接口。

Externalizable接口

除了Serializable 之外，java中還提供了另一個序列化接口Externalizable

public class User implements Externalizable {

    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(name);
        out.writeInt(age);
    }

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        name = (String) in.readObject();
        age = in.readInt();
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Externalizable繼承了Serializable，該接口中定義了兩個抽象方法：writeExternal()與readExternal()。當使用Externalizable接口來進行序列化與反序列化的時候需要開發(fā)人員重寫writeExternal()與readExternal()方法。如果沒有在這兩個方法中定義序列化實現(xiàn)細節(jié)，輸出的內(nèi)容為空，反序列化出來的對象中的屬性將會是默認值。還有一點值得注意：在使用Externalizable進行序列化的時候，在讀取對象時，會調用被序列化類的無參構造器去創(chuàng)建一個新的對象，然后再將被保存對象的字段的值分別填充到新對象中。所以，實現(xiàn)Externalizable接口的類必須要提供一個public的無參的構造器，如果沒有無參數(shù)的構造函數(shù)，在運行時會拋出異常：java.io.InvalidClassException。

ObjectOutput和ObjectInput 接口

ObjectInput接口 擴展自 DataInput 接口以包含對象的讀操作。

DataInput 接口用于從二進制流中讀取字節(jié)，并根據(jù)所有 Java 基本類型數(shù)據(jù)進行重構。同時還提供根據(jù) UTF-8 修改版格式的數(shù)據(jù)重構 String 的工具。

對于此接口中的所有數(shù)據(jù)讀取例程來說，如果在讀取所需字節(jié)數(shù)之前已經(jīng)到達文件末尾 (end of file)，則將拋出 EOFException（IOException 的一種）。如果因為到達文件末尾以外的其他原因無法讀取字節(jié)，則將拋出 IOException 而不是 EOFException。尤其是，在輸入流已關閉的情況下，將拋出 IOException。

ObjectOutput 擴展 DataOutput 接口以包含對象的寫入操作。

DataOutput 接口用于將數(shù)據(jù)從任意 Java 基本類型轉換為一系列字節(jié)，并將這些字節(jié)寫入二進制流。同時還提供了一個將 String 轉換成 UTF-8 修改版格式并寫入所得到的系列字節(jié)的工具。

對于此接口中寫入字節(jié)的所有方法，如果由于某種原因無法寫入某個字節(jié)，則拋出 IOException。

ObjectOutputStream類和ObjectInputStream類

通過前面的代碼片段中我們也能知道，我們一般使用ObjectOutputStream的writeObject方法把一個對象進行持久化。再使用ObjectInputStream的readObject從持久化存儲中把對象讀取出來。

父類的序列化與Transient 關鍵字

要想將父類對象也序列化，就需要讓父類也實現(xiàn)Serializable 接口。如果父類不實現(xiàn)的話的，就需要有默認的無參的構造函數(shù)。在父類沒有實現(xiàn) Serializable 接口時，虛擬機是不會序列化父對象的，而一個 Java 對象的構造必須先有父對象，才有子對象，反序列化也不例外。所以反序列化時，為了構造父對象，只能調用父類的無參構造函數(shù)作為默認的父對象。因此當我們?nèi)「笇ο蟮淖兞恐禃r，它的值是調用父類無參構造函數(shù)后的值。如果你考慮到這種序列化的情況，在父類無參構造函數(shù)中對變量進行初始化，否則的話，父類變量值都是默認聲明的值，如 int 型的默認是 0，string 型的默認是 null。

Transient 關鍵字的作用是控制變量的序列化，在變量聲明前加上該關鍵字，可以阻止該變量被序列化到文件中，在被反序列化后，transient 變量的值被設為初始值，如 int 型的是 0，對象型的是 null。

序列化ID

虛擬機是否允許反序列化，不僅取決于類路徑和功能代碼是否一致，一個非常重要的一點是兩個類的序列化 ID 是否一致（就是 private static final long serialVersionUID)

下面這段代碼中，雖然兩個類的功能代碼完全一致，但是序列化 ID 不同，他們無法相互序列化和反序列化。

package com.inout; 
 
import java.io.Serializable; 
 
public class A implements Serializable { 
 
    private static final long serialVersionUID = 1L; 
 
    private String name; 
    
    public String getName() 
    { 
        return name; 
    } 
    
    public void setName(String name) 
    { 
        this.name = name; 
    } 
} 

package com.inout; 
 
import java.io.Serializable; 
 
public class A implements Serializable { 
 
    private static final long serialVersionUID = 2L; 
    
    private String name; 
    
    public String getName() 
    { 
        return name; 
    } 
    
    public void setName(String name) 
    { 
        this.name = name; 
    } 
}

序列化 ID 在 Eclipse 下提供了兩種生成策略，一個是固定的 1L，一個是隨機生成一個不重復的 long 類型數(shù)據(jù)（實際上是使用 JDK 工具生成），在這里有一個建議，如果沒有特殊需求，就是用默認的 1L 就可以，這樣可以確保代碼一致時反序列化成功。那么隨機生成的序列化 ID 有什么作用呢，有些時候，通過改變序列化 ID 可以用來限制某些用戶的使用。

Java對象的序列化

Java平臺允許我們在內(nèi)存中創(chuàng)建可復用的Java對象，但一般情況下，只有當JVM處于運行時，這些對象才可能存在，即，這些對象的生命周期不會比JVM的生命周期更長。但在現(xiàn)實應用中，就可能要求在JVM停止運行之后能夠保存(持久化)指定的對象，并在將來重新讀取被保存的對象。Java對象序列化就能夠幫助我們實現(xiàn)該功能。

使用Java對象序列化，在保存對象時，會把其狀態(tài)保存為一組字節(jié)，在未來，再將這些字節(jié)組裝成對象。必須注意地是，對象序列化保存的是對象的”狀態(tài)”，即它的成員變量。由此可知，對象序列化不會關注類中的靜態(tài)變量。

ArrayList的序列化

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;
    transient Object[] elementData; // non-private to simplify nested class access
    private int size;
}

筆者省略了其他成員變量，從上面的代碼中可以知道ArrayList實現(xiàn)了java.io.Serializable接口，那么我們就可以對它進行序列化及反序列化。因為elementData是transient的，所以我們認為這個成員變量不會被序列化而保留下來。我們寫一個Demo，驗證一下我們的想法：

public static void main(String[] args) throws IOException, ClassNotFoundException {
        List<String> stringList = new ArrayList<String>();
        stringList.add("hello");
        stringList.add("world");
        stringList.add("hollis");
        stringList.add("chuang");
        System.out.println("init StringList" + stringList);
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("stringlist"));
        objectOutputStream.writeObject(stringList);

        IOUtils.close(objectOutputStream);
        File file = new File("stringlist");
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
        List<String> newStringList = (List<String>)objectInputStream.readObject();
        IOUtils.close(objectInputStream);
        if(file.exists()){
            file.delete();
        }
        System.out.println("new StringList" + newStringList);
    }
//init StringList[hello, world, hollis, chuang]
//new StringList[hello, world, hollis, chuang]

了解ArrayList的人都知道，ArrayList底層是通過數(shù)組實現(xiàn)的。那么數(shù)組elementData其實就是用來保存列表中的元素的。通過該屬性的聲明方式我們知道，他是無法通過序列化持久化下來的。那么為什么結果卻通過序列化和反序列化把List中的元素保留下來了呢？

writeObject和readObject方法

在ArrayList中定義了2個方法： writeObject和readObject。

這里先給出結論:

在序列化過程中，如果被序列化的類中定義了writeObject 和 readObject 方法，虛擬機會試圖調用對象類里的 writeObject 和 readObject 方法，進行用戶自定義的序列化和反序列化。

如果沒有這樣的方法，則默認調用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。

用戶自定義的 writeObject 和 readObject 方法可以允許用戶控制序列化的過程，比如可以在序列化的過程中動態(tài)改變序列化的數(shù)值。

來看一下這兩個方法的具體實現(xiàn)：

private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA;

    // Read in size, and any hidden stuff
    s.defaultReadObject();

    // Read in capacity
    s.readInt(); // ignored

    if (size > 0) {
        // be like clone(), allocate array based upon size not capacity
        ensureCapacityInternal(size);

        Object[] a = elementData;
        // Read in all elements in the proper order.
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}

private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

    // Write out size as capacity for behavioural compatibility with clone()
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[I]);
    }

    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

那么為什么ArrayList要用這種方式來實現(xiàn)序列化呢？

why transient

ArrayList實際上是動態(tài)數(shù)組，每次在放滿以后自動增長設定的長度值，如果數(shù)組自動增長長度設為100，而實際只放了一個元素，那就會序列化99個null元素。為了保證在序列化的時候不會將這么多null同時進行序列化，ArrayList把元素數(shù)組設置為transient。

why writeObject and readObject

前面說過，為了防止一個包含大量空對象的數(shù)組被序列化，為了優(yōu)化存儲，所以，ArrayList使用transient來聲明elementData。 但是，作為一個集合，在序列化過程中還必須保證其中的元素可以被持久化下來，所以，通過重寫writeObject 和 readObject方法的方式把其中的元素保留下來。

writeObject方法把elementData數(shù)組中的元素遍歷的保存到輸出流（ObjectOutputStream）中。

readObject方法從輸入流（ObjectInputStream）中讀出對象并保存賦值到elementData數(shù)組中。

由此可見，可以通過在被序列化的類中增加writeObject 和 readObject方法來自定義序列化和反序列化策略。

雖然ArrayList中寫了writeObject 和 readObject 方法，但是這兩個方法并沒有顯示的被調用啊。

那么如果一個類中包含writeObject 和 readObject 方法，那么這兩個方法是怎么被調用的呢?

對象的序列化過程通過ObjectOutputStream和ObjectInputputStream來實現(xiàn)的，那么帶著這個問題，我們來分析一下ArrayList中的writeObject 和 readObject 方法到底是如何被調用的呢？

為了節(jié)省篇幅，這里給出ObjectOutputStream的writeObject的調用棧：

writeObject ---> writeObject0 --->writeOrdinaryObject--->writeSerialData--->invokeWriteObject

這里看一下invokeWriteObject：

void invokeWriteObject(Object obj, ObjectOutputStream out)
        throws IOException, UnsupportedOperationException {
    if (writeObjectMethod != null) {
        try {
            writeObjectMethod.invoke(obj, new Object[]{ out });
        } catch (InvocationTargetException ex) {
            Throwable th = ex.getTargetException();
            if (th instanceof IOException) {
                throw (IOException) th;
            } else {
                throwMiscException(th);
            }
        } catch (IllegalAccessException ex) {
            // should not occur, as access checks have been suppressed
            throw new InternalError(ex);
        }
    } else {
        throw new UnsupportedOperationException();
    }
}

其中writeObjectMethod.invoke(obj, new Object[]{ out });是關鍵，通過反射的方式調用writeObjectMethod方法。官方是這么解釋這個writeObjectMethod的：

class-defined writeObject method, or null if none

這個方法就是我們在ArrayList中定義的writeObject方法。通過反射的方式被調用了。

如果一個類中包含writeObject 和 readObject 方法，那么這兩個方法是在使用ObjectOutputStream的writeObject方法和ObjectInputStream的readObject方法時，會通過反射的方式調用。

Serializable明明就是一個空的接口，它是怎么保證只有實現(xiàn)了該接口的方法才能進行序列化與反序列化的呢？

其實這個問題也很好回答，我們再回到剛剛ObjectOutputStream的writeObject的調用棧：

writeObject ---> writeObject0 --->writeOrdinaryObject--->writeSerialData--->invokeWriteObject

writeObject0方法中有這么一段代碼：

if (obj instanceof String) {
    writeString((String) obj, unshared);
} else if (cl.isArray()) {
    writeArray(obj, desc, unshared);
} else if (obj instanceof Enum) {
    writeEnum((Enum<?>) obj, desc, unshared);
} else if (obj instanceof Serializable) {
    writeOrdinaryObject(obj, desc, unshared);
} else {
    if (extendedDebugInfo) {
        throw new NotSerializableException(
        cl.getName() + "\n" + debugInfoStack.toString());
    } else {
        throw new NotSerializableException(cl.getName());
    }
}

在進行序列化操作時，會判斷要被序列化的類是否是Enum、Array和Serializable類型，如果不是則直接拋出NotSerializableException。

序列化對單例的破壞

通過對Singleton的序列化與反序列化得到的對象是一個新的對象，這就破壞了Singleton的單例性。

對象的序列化過程通過ObjectOutputStream和ObjectInputputStream來實現(xiàn)的，那么帶著剛剛的問題，分析一下ObjectInputputStream 的readObject 方法執(zhí)行情況到底是怎樣的。

為了節(jié)省篇幅，這里給出ObjectInputStream的readObject的調用棧：

image

這里看一下重點代碼，readOrdinaryObject方法的代碼片段：

private Object readOrdinaryObject(boolean unshared)
        throws IOException {
    //此處省略部分代碼

    Object obj;
    try {
        obj = desc.isInstantiable() ? desc.newInstance() : null;
    } catch (Exception ex) {
        throw (IOException) new InvalidClassException(
            desc.forClass().getName(),
            "unable to create instance").initCause(ex);
    }

    //此處省略部分代碼

    if (obj != null &&
        handles.lookupException(passHandle) == null &&
        desc.hasReadResolveMethod())
    {
        Object rep = desc.invokeReadResolve(obj);
        if (unshared && rep.getClass().isArray()) {
            rep = cloneArray(rep);
        }
        if (rep != obj) {
            handles.setObject(passHandle, obj = rep);
        }
    }

    return obj;
}

主要貼出兩部分代碼。先分析第一部分：

Object obj;
try {
    obj = desc.isInstantiable() ? desc.newInstance() : null;
} catch (Exception ex) {
    throw (IOException) new InvalidClassException(desc.forClass().getName(),"unable to create instance").initCause(ex);
}

這里創(chuàng)建的這個obj對象，就是本方法要返回的對象，也可以暫時理解為是ObjectInputStream的readObject返回的對象。

image

isInstantiable：如果一個serializable/externalizable的類可以在運行時被實例化，那么該方法就返回true。針對serializable和externalizable我會在其他文章中介紹。

desc.newInstance：該方法通過反射的方式調用無參構造方法新建一個對象。

所以。到目前為止，也就可以解釋，為什么序列化可以破壞單例了？

答：序列化會通過反射調用無參數(shù)的構造方法創(chuàng)建一個新的對象。

那么，接下來我們再看剛開始留下的問題，如何防止序列化/反序列化破壞單例模式。

防止序列化破壞單例模式

先給出解決方案，然后再具體分析原理：

只要在Singleton類中定義readResolve就可以解決該問題：

/**
 * 使用雙重校驗鎖方式實現(xiàn)單例
 */
public class Singleton implements Serializable{
    private volatile static Singleton singleton;
    private Singleton (){}
    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

    private Object readResolve() {
        return singleton;
    }
}

還是運行以下測試類：

public class SerializableDemo {
    //為了便于理解，忽略關閉流操作及刪除文件操作。真正編碼時千萬不要忘記
    //Exception直接拋出
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //Write Obj to file
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
        oos.writeObject(Singleton.getSingleton());
        //Read Obj from file
        File file = new File("tempFile");
        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
        Singleton newInstance = (Singleton) ois.readObject();
        //判斷是否是同一個對象
        System.out.println(newInstance == Singleton.getSingleton());
    }
}
//true

本次輸出結果為true。具體原理，我們回過頭繼續(xù)分析code 3中的第二段代碼:

if (obj != null &&
            handles.lookupException(passHandle) == null &&
            desc.hasReadResolveMethod()) {
    Object rep = desc.invokeReadResolve(obj);
    if (unshared && rep.getClass().isArray()) {
        rep = cloneArray(rep);
    }
    if (rep != obj) {
        handles.setObject(passHandle, obj = rep);
    }
}

hasReadResolveMethod:如果實現(xiàn)了serializable 或者 externalizable接口的類中包含readResolve則返回true

invokeReadResolve:通過反射的方式調用要被反序列化的類的readResolve方法。

所以，原理也就清楚了，主要在Singleton中定義readResolve方法，并在該方法中指定要返回的對象的生成策略，就可以防止單例被破壞。

無論是實現(xiàn)Serializable接口，或是Externalizable接口，當從I/O流中讀取對象時，readResolve()方法都會被調用到。實際上就是用readResolve()中返回的對象直接替換在反序列化過程中創(chuàng)建的對象，而被創(chuàng)建的對象則會被垃圾回收掉。

總結

1、如果一個類想被序列化，需要實現(xiàn)Serializable接口。否則將拋出NotSerializableException異常，這是因為，在序列化操作過程中會對類型進行檢查，要求被序列化的類必須屬于Enum、Array和Serializable類型其中的任何一種。

2、在變量聲明前加上該關鍵字，可以阻止該變量被序列化到文件中。

3、在類中增加writeObject 和 readObject 方法可以實現(xiàn)自定義序列化策略

自己的疑問

  1. 既然通過writeObject、readObject可以自定義序列化策略，通過 Externalizable#writeExternal、Externalizable#readExternal也能實現(xiàn)自定序列化策略，那么這2者有什么區(qū)別呢？

答：如果通過Serializable 接口使用默認序列化或通過writeObject、readObject方法來自定義序列化，當在反序列化不會調用類的構造方法，直接就能根據(jù)二進制創(chuàng)建出對象；而使用Externalizable接口則在反序列化時會調用類的默認構造方法。

  1. 如果writeObject、readObject和Externalizable接口同時實現(xiàn)，這時時怎么序列化與反序列化的呢？

答：只會執(zhí)行Externalizable中的writeExternal、readExternal方法，writeObject、readObject不會執(zhí)行。示例代碼：

public class User implements Externalizable { 

    private String name; 

    private transient String password; 

    // 必須要有無參構造器 
    public User() { 
        System.out.println("constructor"); 
    } 


    // 序列化User對象 
    public void writeExternal(ObjectOutput out) throws IOException { 
        System.out.println("writeExternal"); 
        out.writeObject(name); 
        out.writeObject(password); 
    } 

    // 反序列化User對象 
    public void readExternal(ObjectInput in) throws IOException, 
                                                    ClassNotFoundException { 
        System.out.println("readExternal"); 
        name = (String) in.readObject(); 
        password = (String) in.readObject(); 
    } 

    // 不會被執(zhí)行 
    private void writeObject(ObjectOutputStream out) throws IOException { 
        System.out.println("writeObject"); 
    } 

    // 不會被執(zhí)行 
    private void readObject(ObjectInputStream in) throws IOException { 
        System.out.println("readObject"); 
    } 

    // 在writeExternal之前執(zhí)行,只是為了說明執(zhí)行順序,實際不需要寫。 
    private Object writeReplace() throws ObjectStreamException { 
        this.setName("kobe"); 
        System.out.println("writeReplace"); 
        return this; 
    } 

    // 在readExternal之后執(zhí)行,只是為了說明執(zhí)行順序,實際不需要寫。 
    private Object readResolve() throws ObjectStreamException { 
        this.setName("kobe"); 
        System.out.println("readresolve"); 
        return this; 
    } 

    public String getName() { 
        return name; 
    } 

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

    public String getPassword() { 
        return password; 
    } 

    public void setPassword(String password) { 
        this.password = password; 
    } 

    @Override 
    public String toString() { 
        return "User{" + 
                ", name='" + name + '/'' + 
                ", password='" + password + '/'' + 
                '}'; 
    } 
}

歡迎關注我的公眾號

我的公眾號
最后編輯于 ：
?著作權歸作者所有,轉載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關閱讀更多精彩內(nèi)容

  • 一、 序列化和反序列化概念 Serialization（序列化）是一種將對象以一連串的字節(jié)描述的過程；反序列化de...
    步積閱讀 1,489評論 0贊 10
  • 原帖地址：原帖個人網(wǎng)站地址：個人網(wǎng)站簡書對markdown的支持太完美了，我竟然可以直接Ctrl C/V過來。 定...
    ryderchan閱讀 3,910評論 1贊 9
  • 什么是序列化 （1）序列化是將對象轉變?yōu)樽止?jié)序列的過程,反序列化則是將字節(jié)序列恢復為對象的過程。 （2）對象序列化...
    伊凡的一天閱讀 1,709評論 0贊 4
  • 序列化的意義 1.永久存儲某個jvm中運行時的對象。2.對象可以網(wǎng)絡傳輸3.rmi調用都是以序列化的方式傳輸參數(shù) ...
    炫邁哥閱讀 717評論 0贊 0
  • 管宏洋讀《活法》第二章 學習要點：戰(zhàn)勝自我向前進，人生大變樣。 學習感悟：誠實的認真的拼命的工作這就是人生的真理。...
    管宏洋閱讀 189評論 0贊 0

友情鏈接更多精彩內(nèi)容