序列化：將對象變成字節(jié)流的形式傳出去。
反序列化：從字節(jié)流恢復成原來的對象。
序列化可以將內存中的類寫入文件或數(shù)據(jù)庫中。比如將某個類序列化后存為文件，下次讀取時只需將文件中的數(shù)據(jù)反序列化就可以將原先的類還原到內存中。也可以將類序列化為流數(shù)據(jù)進行傳輸?？偟膩碚f就是將一個已經(jīng)實例化的類轉成文件存儲，下次需要實例化的時候只要反序列化即可將類實例化到內存中并保留序列化時類中的所有變量和狀態(tài)。
例如：hibernate中實體類的鈍化就是將類序列化后存入磁盤并釋放內存空間。
序列化 是將對象的狀態(tài)信息轉換為可以存儲或傳輸?shù)男问降倪^程。在序列化期間，對象將其當前狀態(tài)寫入到臨時或持久性存儲區(qū)。以后，可以通過從存儲區(qū)中讀取或反序列化對象的狀態(tài)，重新創(chuàng)建該對象。
序列化使其他代碼可以查看或修改，那些不序列化便無法訪問的對象實例數(shù)據(jù)。
謝邀。
對這個真不了解，有點慚愧。
幸好以前看過相關博客，列表如下，可以參考一下思路。
具體如下：
常用的RPC序列化協(xié)議包括：Thrift、Protobuf、Avro、Kryo、MsgPack 、Hessian、Jackson。
· 傳輸協(xié)議。常用的傳輸協(xié)包括：HTTP、Socket、TCP、UDP等。
· 連接。連接包括：長連接、短連接。
· IO模型。常用的網(wǎng)絡IO模型：同步阻塞IO（Blocking IO）、同步非阻塞IO（Non-blocking IO）、IO多路復用（IO Multiplexing）、異步IO（Asynchronous IO）。
Redis，序列化，統(tǒng)一服務框架 ，并成功的實現(xiàn)一筆數(shù)，指定協(xié)議格式并完成框架配合，總而言之，序列號的原理。
這是一個非常細節(jié)的問題，要是讓你來把“對象”轉化為字節(jié)流，你會怎么做？很容易想到的一個方法是xml（或者json）。
從而可以達到實現(xiàn)最終目的。
如果沒有統(tǒng)一的服務框架，各個團隊的服務提供方就需要各自實現(xiàn)一套序列化、反序列化、網(wǎng)絡框架、連接池、收發(fā)線程、超時處理、狀態(tài)機等“業(yè)務之外”的重復技術勞動，造成整體的低效。
redis是一個開源的使用ANSI C語言編寫、支持網(wǎng)絡、可基于內存亦可持久化的日志型、Key-Value數(shù)據(jù)庫，并提供多種語言的API。
redis是一個key-value存儲系統(tǒng)。
和Memcached類似，它支持存儲的value類型相對更多，包括string(字符串)、list(鏈表)、set(集合)、zset(sorted set--有序集合)和hash（哈希類型）。
這些數(shù)據(jù)類型都支持push/pop、add/remove及取交集并集和差集及更豐富的操作，而且這些操作都是原子性的。在此基礎上，redis支持各種不同方式的排序。
與memcached一樣，為了保證效率，數(shù)據(jù)都是緩存在內存中。
區(qū)別的是redis會周期性的把更新的數(shù)據(jù)寫入磁盤或者把修改操作寫入追加的記錄文件，并且在此基礎上實現(xiàn)了master-slave(主從)同步。
redis是一個高性能的key-value數(shù)據(jù)庫。
redis的出現(xiàn)，很大程度補償了memcached這類key/value存儲的不足，在部分場合可以對關系數(shù)據(jù)庫起到很好的補充作用。
redis提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客戶端，使用很方便。
// 3.創(chuàng)建 序列化類 GenericToStringSerializer genericToStringSerializer = new GenericToStringSerializer(Object.class); // 6.序列化類，對象映射設置 // 7.設置 value 的轉化格式和 key 的轉化格式 redisTemplate.setValueSerializer(genericToStringSerializer); redisTemplate.setKeySerializer(new StringRedisSerializer());
序列化通俗地講就是將一個對象轉換成一個字節(jié)流的過程，這樣就可以輕松保存在磁盤文件或數(shù)據(jù)庫中。反序列化是序列化的逆過程，就是將一個字節(jié)流轉換回原來的對象的過程。
然而為什么需要序列化和反序列化這樣的機制呢？這個問題也就涉及到序列化和反序列化的用途了，
對于序列化的主要用途有：
1）、將應用程序的狀態(tài)保存在一個磁盤文件或數(shù)據(jù)庫中，并在應用程序下次運行時恢復狀態(tài)。例如, Asp.net 中利用序列化和反2）、序列化來保存和恢復會話狀態(tài)。3）、一組對象可以輕松復制到Windows 窗體的剪貼板中，再粘貼回同一個或者另一個應用程序。將對象按值從一個應用程序域中發(fā)送到另一個程序域并且如果把對象序列化成內存中的字節(jié)流，就可以利用一些其他的技術來處理數(shù)據(jù)，例如，對數(shù)據(jù)進行加密和壓縮等。
序列化和反序列化的簡單使用：
using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
namespace Serializable
{
[Serializable]
public class Person
{
public string personName;
[NonSerialized]
public string personHeight;
private int personAge;
public int PersonAge
{
get { return personAge; }
set { personAge = value; }
}
public void Write()
{
Console.WriteLine("Person Name: "+personName);
Console.WriteLine("Person Height: " +personHeight);
Console.WriteLine("Person Age: "+ personAge);
}
}
class Program
{
static void Main(string[] args)
{
Person person = new Person();
person.personName = "Jerry";
person.personHeight = "175CM";
person.PersonAge = 22;
Stream stream = Serialize(person);
//為了演示，都重置
stream.Position = 0;
person = null;
person = Deserialize(stream);
person.Write();
Console.Read();
}
private static MemoryStream Serialize(Person person)
{
MemoryStream stream = new MemoryStream();
// 構造二進制序列化格式器
BinaryFormatter binaryFormatter = new BinaryFormatter();
// 告訴序列化器將對象序列化到一個流中
binaryFormatter.Serialize(stream, person);
return stream;
}
private static Person Deserialize(Stream stream)
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
return (Person)binaryFormatter.Deserialize(stream);
}
}
}
主要是調用System.Runtime.Serialization.Formatters.Binary命名空間下的BinnaryFormatter類來進行序列化和反序列化，
從中可以看出除了標記NonSerialized的其他成員都能序列化,注意這個屬性只能應用于一個類型中的字段，而且會被派生類型繼承。
SOAP 和XML 的序列化和反序列化和上面類似，只需要改下格式化器就可以了， 這里我就不列出來了。
三、控制序列化和反序列化 有兩種方式來實現(xiàn)控制序列化和反序列化：
通過OnSerializing, OnSerialized,OnDeserializing, OnDeserialized,NonSerialized和OptionalField等屬性實現(xiàn)System.Runtime.Serialization.ISerializable接口第一種方式實現(xiàn)控制序列化和反序列化代碼：
using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
namespace ControlSerialization
{
[Serializable]
public class Circle
{
private double radius; //半徑
[NonSerialized]
public double area; //面積
public Circle(double inputradiu)
{
radius = inputradiu;
area = Math.PI * radius * radius;
}
[OnDeserialized]
private void OnDeserialized(StreamingContext context)
{
area = Math.PI * radius * radius;
}
public void Write()
{
Console.WriteLine("Radius is: " + radius);
Console.WriteLine("Area is: " + area);
}
}
class Program
{
static void Main(string[] args)
{
Circle c = new Circle(10);
MemoryStream stream =new MemoryStream();
BinaryFormatter formatter = new BinaryFormatter();
// 將對象序列化到內存流中，這里可以使用System.IO.Stream抽象類中派生的任何類型的一個對象， 這里我使用了 MemoryStream類型。
formatter.Serialize(stream,c);
stream.Position = 0;
c = null;
c = (Circle)formatter.Deserialize(stream);
c.Write();
Console.Read();
}
}
}
注意：如果注釋掉 OnDeserialized屬性的話，area字段的值就是0了，因為area字段沒有被序列化到流中。
在上面需要序列化的對象中，格式化器只會序列化對象的radius字段的值。area字段中的值不會序列化，因為該字段已經(jīng)應用了NonSerializedAttribute屬性，然后我們用Circle c=new Circle(10)這樣代碼構建一個Circle對象時，在內部，area會設置一個約為314.159這樣的值，這個對象序列化時，只有radius的字段的值（10）寫入流中， 但當反序列化成一個Circle對象時，它的area字段的值會初始化為0，而不是約314.159的一個值。為了解決這樣的問題，所以自定義一個方法應用OnDeserializedAttribute屬性。此時的執(zhí)行過程為：每次反序列化類型的一個實例，格式化器都會檢查類型中是否定義了 一個應用了該attribute的方法，如果是，就調用該方法，調用該方法時，所有可序列化的字段都會被正確設置。除了OnDeserializedAttribute這個定制attribute,system.Runtime.Serialization命名空間還定義了OnSerializingAttribute,OnSerializedAttribute和OnDeserializingAttribute這些定制屬性。
實現(xiàn)ISerializable接口方式控制序列化和反序列化代碼：
using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Security.Permissions;
namespace ControlSerilization2
{
[Serializable]
public class MyObject : ISerializable
{
public int n1;
public intn2;
[NonSerialized]
public String str;
public MyObject()
{
}
protected MyObject(SerializationInfo info, StreamingContext context)
{
n1 = info.GetInt32("i");
n2 = info.GetInt32("j");
str = info.GetString("k");
}
[SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter = true)]
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.AddValue("i", n1);
info.AddValue("j", n2);
info.AddValue("k", str);
}
public void Write()
{
Console.WriteLine("n1 is: " + n1);
Console.WriteLine("n2 is: " + n2);
Console.WriteLine("str is: " + str);
}
}
class Program
{
static void Main(string[] args)
{
MyObject obj = new MyObject();
obj.n1 = 2;
obj.n2 = 3;
obj.str = "Jeffy";
MemoryStream stream = new MemoryStream();
BinaryFormatter formatter = new BinaryFormatter();
// 將對象序列化到內存流中，這里可以使用System.IO.Stream抽象類中派生的任何類型的一個對象， 這里我使用了 MemoryStream類型。
formatter.Serialize(stream, obj);
stream.Position = 0;
obj = null;
obj = (MyObject)formatter.Deserialize(stream);
obj.Write();
Console.Read();
}
}
}
此時的執(zhí)行過程為：當格式化器序列化對象時，會檢查每個對象，如果發(fā)現(xiàn)一個對象的類型實現(xiàn)了ISerializable接口，格式化器會忽視所有定制屬性，改為構造一個新的System.Runtime.Serialization.SerializationInfo對象，這個對象包含了要實際為對象序列化的值的集合。構造好并初始化好SerializationInfo對象后，格式化器調用類型的GetObjectData方法，并向它傳遞對SerializationInfo對象的引用，GetObjectData方法負責決定需要哪些信息來序列化對象，并將這些信息添加到SerializationInfo對象中，通過調用AddValue方法來添加需要的每個數(shù)據(jù)，添加好所有必要的序列化信息后，會返回至格式化器，然后格式化器獲取已經(jīng)添加到SerializationInfo對象中的所有值，并將它們都序列化到流中，當反序列化時，格式化器從流中提取一個對象時，會為新對象分配內存，最初，這個對象的所有字段都設為0或null,然后，格式化器檢查類型是否實現(xiàn)了ISerializable接口，如果存在這個接口， 格式化器就嘗試調用一個特殊構造器，它的參數(shù)和GetObjectData方法的完全一致。
四、格式化器如何序列化和反序列化從上面的分析中可以看出，進行序列化和反序列化主要是格式化器在工作的，然而下面就是要講講格式化器是如何序列化一個應用了 SerializableAttribute 屬性的對象。
1、格式化器調用FormatterServices的GetSerializableMembers方法：public static MemberInfo[] GetSerializableMembers(Type type,StreamingContext context);這個方法利用發(fā)射獲取類型的public和private實現(xiàn)字段（標記了NonSerializedAttributee屬性的字段除外）。方法返回由MemberInfo對象構成的一個數(shù)組，其中每個元素對應于一個可序列化的實例字段。2、對象被序列化，System.Reflection.MemberInfo對象數(shù)組傳給FormatterServices的靜態(tài)方法GetObjectData: public static object[] GetObjectData(Object obj,MemberInfo[] members); 這個方法返回一個Object數(shù)組，其中每個元素都標識了被序列化的那個對象中的一個字段的值。3、格式化器將程序集標識和類型的完整名稱寫入流中。4、格式化器然后遍歷兩個數(shù)組中的元素，將每個成員的名稱和值寫入流中。接下來是解釋格式化器如何自動反序列化一個應用了 SerializableAttribute屬性的對象。
1、格式化器從流中讀取程序集標識和完整類型名稱。2、格式化器調用FormatterServices的靜態(tài)方法GetUninitializedObject: public static Object GetUninitializedObject(Type ttype);這個方法為一個新對象分配內存，但不為對象調用構造器。然而，對象的所有字段都被初始化為0或null.3格式化器現(xiàn)在構造并初始化一個MemberInfo數(shù)組，調用FormatterServices的GetSerializableMembers方法，這個方法返回序列化好、現(xiàn)在需要反序列化的一組字段。4、格式化器根據(jù)流中包含的數(shù)據(jù)創(chuàng)建并初始化一個Object數(shù)組。5、將對新分配的對象、MemberInfo數(shù)組以及并行Object數(shù)組的引用傳給FormatterServices的靜態(tài)方法PopulateObjectMembers: public static Object PopulateObjectMembers(Object obj,MemberInfo[] members,Object[] data);這個方法遍歷數(shù)組，將每個字段初始化成對應的值。
1).創(chuàng)建FileOutputStream(創(chuàng)建存取文件的FileOutputStream對象，如果文件不存在，它會自動被創(chuàng)建出來)
FileOutputStream fileStream=new FileOutputStream("MyGame.ser");
(2).創(chuàng)建ObjectOutputStream(它能讓你寫入對象，但無法直接地連接文件，所以需要參數(shù)的指引)
ObjectOutputStream os=new ObjectOutputStream(fileStream);
(3).寫入對象(將變量所引用的對象序列化并寫入MyGame.ser這個文件)
os.writeObject(characterOne);
os.writeObject(characterTwo);
os.writeObject(characterThree);
(4).關閉ObjectOutputStream(關閉所關聯(lián)的輸出串流)
os.close();
即：Object 寫入 ObjectOutputStream 連接到 FileOutputStream 到文件
3.解序列化的步驟：還原對象
(1).創(chuàng)建FileInputStream（如果文件不存在就會拋出異常）
FileInputStream fileStream=new FileInputStream("MyGame.ser");
(2).創(chuàng)建ObjectInputStream(它知道如何讀取對象，但是要鏈接的stream提供文件存取)
ObjectInputStream os=new ObjectInputStream(fileStream);
(3).讀取對象（每次調用readObject方法都會從stream中讀出下一個對象，讀取順序與寫入順序相同，次數(shù)超過會拋出異常）
Object one=os.readObject();
Object two=os.readObject();
Object three=os.readObject();
(4).轉換對象類型(返回值是Object類型，因此必須轉換類型)
GameCharacter elf=(GameCharacter)one;
GameCharacter troll=(GameCharacter)two;
GameCharacter magician=(GameCharacter)three;
(5).關閉ObjectInputStream（FileInputStream會自動跟著關掉）
os.close();
即：文件 被讀取 FileInputStream 被連接 ObjectInputSteam 恢復成對象
