注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

liangxh2008的博客

 
 
 

日志

 
 

JSON.NET与ProtoBuf在Socket下的应用  

2010-04-22 20:35:45|  分类: AppMarket |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |
    Socket通信中,客户端与服务器之间传递的是字节流。而在现实的应用中我们需要传递有一定含义的结构。如何传递有意义的结构那?别慌本文就从这里给您对JSON.NET做个简单介绍。

首先我们来简单认识一下今天的主角:JSON.NET和ProtoBuf

1:JSON.NET与ProtoBuf

这两个都是开源的项目,项目的地址如下

JSON.NET:http://json.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=29756

ProtoBuf:http://code.google.com/p/protobuf/

接下来我们看看两个项目在序列化对象时都是怎么做的。

先看JSON.NET

  1. Code  
  2.     [JsonObject]  
  3.     public class Person {  
  4.         public string userName { get; set; }  
  5.         public string pwd { get; set; }  
  6.  
  7.         public Person(string name, string code) {  
  8.             userName = name;  
  9.             pwd = code;  
  10.         }  
  11.  
  12.         public void Write() {  
  13.             Console.WriteLine(string.Format("用户名:" + userName + "密码:" + pwd));  
  14.         }  
  15.  
  16.     }  
  17. public class Json {  
  18.  
  19.         private string jsonStr;  
  20.         private List list;  
  21.  
  22.  
  23.         public Json(int num) {  
  24.             list = new List();  
  25.  
  26.             Person p = new Person("dabing", "110110");  
  27.             for (int i = 0; i < num;i++ )  
  28.                 list.Add(p);  
  29.  
  30.         }  
  31.  
  32.         #region json  
  33.         public void Set() {  
  34.             //jsonStr = JsonConvert.SerializeObject(list, Formatting.Indented, new JsonSerializerSettings() {  
  35.             //    TypeNameHandlingTypeNameHandling = TypeNameHandling.Objects  
  36.             //});  
  37.             Stopwatch watch = new Stopwatch();  
  38.             watch.Start();  
  39.             jsonStr = JsonConvert.SerializeObject(list);  
  40.             watch.Stop();  
  41.             Console.WriteLine("写入耗时(MS):" + watch.ElapsedMilliseconds);  
  42.         }  
  43.  
  44.         public List Get()  
  45.         {  
  46.             //object person = JsonConvert.DeserializeObject(jsonStr, null, new JsonSerializerSettings {  
  47.             //    TypeNameHandlingTypeNameHandling = TypeNameHandling.Objects  
  48.             //});  
  49.             Stopwatch watch = new Stopwatch();  
  50.             watch.Start();  
  51.             List obj = JsonConvert.DeserializeObject>(jsonStr);  
  52.             watch.Stop();  
  53.             Console.WriteLine("获取耗时(MS):" + watch.ElapsedMilliseconds);  
  54.             return obj;  
  55.  
  56.         }  
  57.         #endregion 

我们可以看到它对序列化的对象没有什么要求。(“[JsonObject]”可以去掉)

其实JSON的原理也很简单,底层通过反射获取对象的属性然后拼接出形如[{"userName":"dabing","pwd":"110110"},{"userName":"dabing","pwd":"110110"}]的字符串。

下面我们看ProtoBuf

  1. Code  
  2.     [DataContract]  
  3.     public class PBPerson {  
  4.  
  5.         [ProtoMember(1)]  
  6.         public string userName { get; set; }  
  7.  
  8.         [ProtoMember(2)]  
  9.         public string pwd { get; set; }  
  10.  
  11.         public void Write() {  
  12.             Console.WriteLine(string.Format("用户名:" + userName + "密码:" + pwd));  
  13.         }  
  14.  
  15.     }  
  16. public class Protobuf {  
  17.  
  18.         MemoryStream ms;  
  19.         List list;  
  20.  
  21.         public Protobuf(int num) {  
  22.             ms = new MemoryStream();  
  23.             list = new List();  
  24.  
  25.             PBPerson p = new PBPerson();  
  26.             p.userName = "fengyun";  
  27.             p.pwd = "110110";  
  28.  
  29.             for (int i = 0; i < num; i++) {  
  30.                 list.Add(p);  
  31.             }  
  32.  
  33.         }  
  34.           
  35.         #region ProtoBuf  
  36.         public void Set() {  
  37.             Stopwatch watch = new Stopwatch();  
  38.             watch.Start();  
  39.             Serializer.Serialize(ms,list);  
  40.             watch.Stop();  
  41.             Console.WriteLine("写入耗时(MS):" + watch.ElapsedMilliseconds);  
  42.         }  
  43.  
  44.         public List Get() {  
  45.             ms.Position = 0;  
  46.  
  47.             Stopwatch watch = new Stopwatch();  
  48.             watch.Start();  
  49.             List obj=Serializer.Deserialize>(ms);  
  50.             watch.Stop();  
  51.             Console.WriteLine("获取耗时(MS):" + watch.ElapsedMilliseconds);  
  52.             return obj;  
  53.         }  
  54.         #endregion 

ProtoBuf对要序列化的对象要求首先要有特性来规定像[DataContract],[ProtoMember(1)]其次就是不能有带参的构造函数。

2:JSON.NET与ProtoBuf性能的简单对比

100(J/P) 1000(J/P) 10000(J/P) 100000(J/P)

写 53/100 64/104 162/114 1139/239

读     29/13           64/16              382/42          3561/322

以上表格中100(J/P)表示100个对象在JSON/ProtoBuf下耗费的MS。

以上数据为三次得到的平均值。

从以上数据我们可以简单得出结论(仅供参考):

传递的对象越多两者耗费的时间越长。

传递单个对象的时候JSON表现出更好的性能。传递多个对象的时候ProtoBuf性能更快更稳定。

到这里我们已经把两种框架下序列化和反序列化对象的方法和性能进行了简单的说明,接下来我们再看看两个框架在Socket下是如何应用的。

3:JSON.NET与ProtoBuf在Socket下的写法

以JSON方式传递对象数组

  1. Code  
  2.     public class SocketServer {  
  3.  
  4.         RequestHandler handler;  
  5.         Socket listenSocket;  
  6.  
  7.         public void Start() {  
  8.  
  9.             IPAddress[] addressList = Dns.GetHostEntry(Environment.MachineName).AddressList;  
  10.             IPEndPoint localEndPoint = new IPEndPoint(addressList[addressList.Length - 1], 12345);  
  11.  
  12.             this.listenSocket = new Socket(localEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);  
  13.  
  14.             if (localEndPoint.AddressFamily == AddressFamily.InterNetworkV6) {  
  15.                 this.listenSocket.SetSocketOption(SocketOptionLevel.IPv6, (SocketOptionName)27, false);  
  16.                 this.listenSocket.Bind(new IPEndPoint(IPAddress.IPv6Any, localEndPoint.Port));  
  17.             }  
  18.             else {  
  19.                 this.listenSocket.Bind(localEndPoint);  
  20.             }  
  21.  
  22.             this.listenSocket.Listen(100);  
  23.  
  24.             this.accept_async();  
  25.  
  26.             handler = new RequestHandler();  
  27.         }  
  28.  
  29.         private void accept_async() {  
  30.             SocketAsyncEventArgs accept = new SocketAsyncEventArgs();  
  31.             accept.Completed += accept_Completed;  
  32.             listenSocket.AcceptAsync(accept);  
  33.         }  
  34.  
  35.         void accept_Completed(object sender, SocketAsyncEventArgs e) {  
  36.             accept_async();  
  37.             var client = e.AcceptSocket;  
  38.             e.Completed -accept_Completed;  
  39.             e.Completed += receive_Completed;  
  40.  
  41.             var buffer = new byte[1024];  
  42.             e.SetBuffer(buffer, 0, buffer.Length);  
  43.  
  44.             client.ReceiveAsync(e);  
  45.         }  
  46.  
  47.         void receive_Completed(object sender, SocketAsyncEventArgs e) {  
  48.             var client = sender as Socket;  
  49.             if (e.BytesTransferred == 0) {  
  50.                 client.Close();  
  51.                 e.Dispose();  
  52.             }  
  53.             else {  
  54.                 String received = Encoding.UTF8.GetString(e.Buffer, e.Offset, e.BytesTransferred);  
  55.                 string[] msgArray = handler.GetActualString(received);  
  56.                 foreach (string m in msgArray) {  
  57.                     List obj = JsonConvert.DeserializeObject>(m);  
  58.                     foreach (Entitly.Person p in obj) {  
  59.                         p.userName = "fengyun";  
  60.                     }  
  61.                     received = JsonConvert.SerializeObject(obj);  
  62.                     received = String.Format("[length={0}]{1}", received.Length, received);  
  63.  
  64.                     byte[] buffer = Encoding.UTF8.GetBytes(received);  
  65.                     client.Send(buffer);  
  66.                 }  
  67.                 client.ReceiveAsync(e);  
  68.             }  
  69.         }  
  70.     }  
  71.  
  72.     class Program {  
  73.         static void Main(string[] args) {  
  74.             SocketServer server = new SocketServer();  
  75.             server.Start();  
  76.  
  77.             Console.ReadLine();  
  78.         }  
  79.  
  80. 客户端  
  81. Code  
  82.     public sealed class SocketClient : IDisposable {  
  83.         RequestHandler handler;  
  84.         ///   
  85.         ///  发送或接受操作  
  86.         ///   
  87.         private const Int32 ReceiveOperation = 1SendOperation = 0;  
  88.  
  89.         ///   
  90.         /// 客户端套接字  
  91.         ///   
  92.         private Socket clientSocket;  
  93.  
  94.         ///   
  95.         /// 是否链接到服务器  
  96.         ///   
  97.         private Boolean connected = false;  
  98.  
  99.         ///   
  100.         /// 接收端口{本地}  
  101.         ///   
  102.         private IPEndPoint hostEndPoint;  
  103.  
  104.         ///   
  105.         /// 连接信号量  
  106.         ///   
  107.         private AutoResetEvent autoConnectEvent = new AutoResetEvent(false);  
  108.  
  109.         ///   
  110.         /// 操作信号量  
  111.         ///   
  112.         private AutoResetEvent[] autoSendReceiveEvents = new AutoResetEvent[]  
  113.         {  
  114.             new AutoResetEvent(false),  
  115.             new AutoResetEvent(false)  
  116.         };  
  117.  
  118.         public static object ConnLock = new object();  
  119.  
  120.         ///   
  121.         /// 初始化客户端  
  122.         /// 链接到服务器后开始发送数据  
  123.         ///   
  124.         /// 服务端地址{IP地址}  
  125.         /// 端口  
  126.         public SocketClient(String hostName, Int32 port) {  
  127.             IPHostEntry host = Dns.GetHostEntry(hostName);  
  128.  
  129.             IPAddress[] addressList = host.AddressList;  
  130.  
  131.             this.hostEndPoint = new IPEndPoint(addressList[addressList.Length - 1], port);  
  132.             this.clientSocket = new Socket(this.hostEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);  
  133.             handler = new RequestHandler();  
  134.         }  
  135.  
  136.         ///   
  137.         /// 连接到服务器过程  
  138.         ///   
  139.         /// 连接上为True否则为False  
  140.         public void Connect() {  
  141.  
  142.             lock (ConnLock) {  
  143.                 try {  
  144.                     clientSocket.Connect(this.hostEndPoint);  
  145.                     this.connected = true;  
  146.                 }  
  147.                 catch (Exception ex) {  
  148.                     this.connected = false;  
  149.                 }  
  150.             }  
  151.  
  152.         }  
  153.  
  154.         ///   
  155.         /// 断开与服务器的链接  
  156.         ///   
  157.         public void Disconnect() {  
  158.             clientSocket.Disconnect(false);  
  159.         }  
  160.  
  161.         private void OnConnect(object sender, SocketAsyncEventArgs e) {  
  162.             // 通知连接已经完成  
  163.             autoConnectEvent.Set();  
  164.  
  165.             this.connected = (e.SocketError == SocketError.Success);  
  166.         }  
  167.  
  168.         ///   
  169.         /// 接收  
  170.         ///   
  171.         ///   
  172.         ///   
  173.         private void OnReceive(object sender, SocketAsyncEventArgs e) {  
  174.             string msg = Encoding.UTF8.GetString(e.Buffer, 0, e.BytesTransferred);  
  175.             string[] msgArray = handler.GetActualString(msg);  
  176.             foreach (string m in msgArray) {  
  177.                 List obj = JsonConvert.DeserializeObject>(m);  
  178.                 foreach (Entitly.Person p in obj) {  
  179.                     Console.WriteLine(p.userName);  
  180.                 }  
  181.             }  
  182.  
  183.             autoSendReceiveEvents[SendOperation].Set();  
  184.  
  185.             (e.UserToken as Socket).ReceiveAsync(e);  
  186.  
  187.         }  
  188.  
  189.         ///   
  190.         /// 发送  
  191.         ///   
  192.         ///   
  193.         ///   
  194.         private void OnSend(object sender, SocketAsyncEventArgs e) {  
  195.             //发送完后置信号为接收  
  196.             autoSendReceiveEvents[ReceiveOperation].Set();  
  197.  
  198.             if (e.SocketError == SocketError.Success) {  
  199.                 if (e.LastOperation == SocketAsyncOperation.Send) {  
  200.                     Socket s = e.UserToken as Socket;  
  201.                     byte[] receiveBuffer = new byte[255];  
  202.                     e.SetBuffer(receiveBuffer, 0, receiveBuffer.Length);  
  203.                     e.Completed += new EventHandler(OnReceive);  
  204.                     s.ReceiveAsync(e);  
  205.                 }  
  206.             }  
  207.             else {  
  208.                 this.ProcessError(e);  
  209.             }  
  210.         }  
  211.  
  212.         ///   
  213.         /// 关闭客户端  
  214.         ///   
  215.         /// SocketAsyncEventArg  
  216.         private void ProcessError(SocketAsyncEventArgs e) {  
  217.             Socket s = e.UserToken as Socket;  
  218.             if (s.Connected) {  
  219.                 //关闭一个独立的客户端连接  
  220.                 try {  
  221.                     s.Shutdown(SocketShutdown.Both);  
  222.                 }  
  223.                 catch (Exception) {  
  224.                     //客户端已经关闭  
  225.                 }  
  226.                 finally {  
  227.                     if (s.Connected) {  
  228.                         s.Close();  
  229.                     }  
  230.                 }  
  231.             }  
  232.  
  233.             throw new SocketException((Int32)e.SocketError);  
  234.         }  
  235.  
  236.         ///   
  237.         /// 发送过程  
  238.         ///   
  239.         /// Message to send.  
  240.         /// Message sent by the host.  
  241.         public void Send(String message) {  
  242.             if (this.connected) {  
  243.  
  244.                 //将信息转化为协议  
  245.                 message = String.Format("[length={0}]{1}", message.Length, message);  
  246.                 Byte[] sendBuffer = Encoding.UTF8.GetBytes(message);  
  247.  
  248.                 SocketAsyncEventArgs completeArgs = new SocketAsyncEventArgs();  
  249.                 completeArgs.SetBuffer(sendBuffer, 0, sendBuffer.Length);  
  250.                 completeArgs.UserToken = this.clientSocket;  
  251.                 completeArgs.RemoteEndPoint = this.hostEndPoint;  
  252.                 completeArgs.Completed += new EventHandler(OnSend);  
  253.  
  254.                 clientSocket.SendAsync(completeArgs);  
  255.  
  256.                 AutoResetEvent.WaitAll(autoSendReceiveEvents);  
  257.             }  
  258.             else {  
  259.                 throw new SocketException((Int32)SocketError.NotConnected);  
  260.             }  
  261.         }  
  262.  
  263.         #region IDisposable Members  
  264.  
  265.         ///   
  266.         /// 销毁客户端  
  267.         ///   
  268.         public void Dispose() {  
  269.             this.connected = false;  
  270.             autoConnectEvent.Reset();  
  271.             autoSendReceiveEvents[SendOperation].Reset();  
  272.             autoSendReceiveEvents[ReceiveOperation].Reset();  
  273.             if (this.clientSocket.Connected) {  
  274.                 this.clientSocket.Close();  
  275.             }  
  276.         }  
  277.  
  278.         #endregion  
  279.     }  
  280.  
  281.     class Program {  
  282.         static void Main(string[] args) {  
  283.  
  284.             String host = "192.168.65.35";  
  285.             Int32 port = 12345;  
  286.             int num = 100;  
  287.  
  288.             Entitly.Person person = new Entitly.Person("dabing", "110110");  
  289.             List list = new List();  
  290.             for (int i = 0; i < num; i++) {  
  291.                 list.Add(person);  
  292.             }  
  293.  
  294.             string msg = JsonConvert.SerializeObject(list);  
  295.  
  296.             using (SocketClient sa = new SocketClient(host, port)) {  
  297.                 sa.Connect();  
  298.                 sa.Send(msg);  
  299.                 sa.Disconnect();  
  300.             }  
  301.  
  302.  
  303.             Console.ReadLine();  
  304.  
  305.         }  
  306.  
  307. 还有实体类  
  308. Code  
  309.     public class Person {  
  310.         public string userName { get; set; }  
  311.         public string pwd { get; set; }  
  312.  
  313.         public Person(string name, string code) {  
  314.             userName = name;  
  315.             pwd = code;  
  316.         }  
  317.     }  
  318.  
  319.     [DataContract]  
  320.     public class PBPerson {  
  321.  
  322.         [ProtoMember(1)]  
  323.         public string userName { get; set; }  
  324.  
  325.         [ProtoMember(2)]  
  326.         public string pwd { get; set; }  
  327.  
  328.         public void Write() {  
  329.             Console.WriteLine(string.Format("用户名:" + userName + "密码:" + pwd));  
  330.         }  
  331.  
  332.     }  
  333.  
  334.     public class RequestHandler {  
  335.         ///   
  336.         /// 存放没有接受完的部分消息  
  337.         ///   
  338.         private string temp = string.Empty;  
  339.  
  340.         ///   
  341.         /// 获取消息  
  342.         ///   
  343.         ///   
  344.         ///   
  345.         public string[] GetActualString(string input) {  
  346.             return GetActualString(input, null);  
  347.         }  
  348.  
  349.         private string[] GetActualString(string input, List outputList) {  
  350.             if (outputList == null)  
  351.                 outputList = new List();  
  352.  
  353.             if (!String.IsNullOrEmpty(temp))  
  354.                 input = temp + input;  
  355.  
  356.             string output = "";  
  357.             string pattern = @"(?<=^\[length=)(\d+)(?=\])";  
  358.             int length;  
  359.  
  360.             if (Regex.IsMatch(input, pattern)) {  
  361.  
  362.                 Match m = Regex.Match(input, pattern);  
  363.  
  364.                 // 获取消息字符串实际应有的长度  
  365.                 length = Convert.ToInt32(m.Groups[0].Value);  
  366.  
  367.                 // 获取需要进行截取的位置  
  368.                 int startIndex = input.IndexOf(']') + 1;  
  369.  
  370.                 // 获取从此位置开始后所有字符的长度  
  371.                 output = input.Substring(startIndex);  
  372.  
  373.                 if (output.Length == length) {  
  374.                     // 如果output的长度与消息字符串的应有长度相等  
  375.                     // 说明刚好是完整的一条信息  
  376.                     outputList.Add(output);  
  377.                     temp = "";  
  378.                 }  
  379.                 else if (output.Length < length) {  
  380.                     // 如果之后的长度小于应有的长度,  
  381.                     // 说明没有发完整,则应将整条信息,包括元数据,全部缓存  
  382.                     // 与下一条数据合并起来再进行处理  
  383.                     temp = input;  
  384.                     // 此时程序应该退出,因为需要等待下一条数据到来才能继续处理  
  385.  
  386.                 }  
  387.                 else if (output.Length > length) {  
  388.                     // 如果之后的长度大于应有的长度,  
  389.                     // 说明消息发完整了,但是有多余的数据  
  390.                     // 多余的数据可能是截断消息,也可能是多条完整消息  
  391.  
  392.                     // 截取字符串  
  393.                     outputoutput = output.Substring(0, length);  
  394.                     outputList.Add(output);  
  395.                     temp = "";  
  396.  
  397.                     // 缩短input的长度  
  398.                     inputinput = input.Substring(startIndex + length);  
  399.  
  400.                     // 递归调用  
  401.                     GetActualString(input, outputList);  
  402.                 }  
  403.             }  
  404.             else {    // 说明“[”,“]”就不完整  
  405.                 temp = input;  
  406.             }  
  407.  
  408.             return outputList.ToArray();  
  409.         } 

以ProtoBuf方式传递对象数组

服务端

  1. Code  
  2. public class Service {  
  3.  
  4.         public void Start() {  
  5.             TcpListener listener = new TcpListener(IPAddress.Parse("192.168.65.35"), 12345);  
  6.             listener.Start();  
  7.  
  8.             while (true) {  
  9.                 TcpClient client = listener.AcceptTcpClient();  
  10.                 ClientConnected(client);  
  11.             }  
  12.  
  13.         }  
  14.  
  15.         void ClientConnected(TcpClient client) {  
  16.             try {  
  17.                 using (NetworkStream stream = client.GetStream()) {  
  18.                     Console.WriteLine("获取到数据");  
  19.                     List cust = Serializer.DeserializeWithLengthPrefix>(stream, PrefixStyle.Base128);  
  20.                     Console.WriteLine("返回数据");  
  21.                     foreach (PBPerson p in cust) {  
  22.                         p.userName = "fengyun";  
  23.                     }  
  24.                     Serializer.SerializeWithLengthPrefix(stream, cust, PrefixStyle.Base128);  
  25.  
  26.                     int final = stream.ReadByte();  
  27.                     if (final == 123) {  
  28.                         Console.WriteLine("SERVER: Got client-happy marker");  
  29.                     }  
  30.                     else {  
  31.                         Console.WriteLine("SERVER: OOPS! Something went wrong");  
  32.                     }  
  33.                     Console.WriteLine("SERVER: Closing connection");  
  34.                     stream.Close();  
  35.                     client.Close();  
  36.                 }  
  37.             }  
  38.             finally {  
  39.             }  
  40.         }  
  41.     }  
  42.  
  43. Service ser = new Service();  
  44.  
  45. 客户端  
  46. Code  
  47.     public class Client {  
  48.         public void Send(int num) {  
  49.  
  50.             Stopwatch watch = new Stopwatch();  
  51.  
  52.             PBPerson p = new PBPerson();  
  53.             p.userName = "dabing";  
  54.             p.pwd = "110110";  
  55.  
  56.             List list = new List();  
  57.             for (int i = 0; i < num; i++) {  
  58.                 list.Add(p);  
  59.             }  
  60.  
  61.             using (TcpClient client = new TcpClient()) {  
  62.                 client.Connect(new IPEndPoint(IPAddress.Parse("192.168.65.35"), 12345));  
  63.  
  64.                 using (NetworkStream stream = client.GetStream()) {  
  65.  
  66.                     //Console.WriteLine("获取连接发送数据");  
  67.                     watch.Start();  
  68.                     Serializer.SerializeWithLengthPrefix(stream, list, PrefixStyle.Base128);  
  69.  
  70.                     //Console.WriteLine("获取数据");  
  71.                       
  72.                     List newCust = Serializer.DeserializeWithLengthPrefix>(stream, PrefixStyle.Base128);  
  73.                     watch.Stop();  
  74.                     Console.WriteLine(watch.ElapsedMilliseconds);  
  75.                     //foreach (PBPerson per in newCust) {  
  76.                        // Console.WriteLine(per.userName);  
  77.                     //}  
  78.                     stream.WriteByte(123); // just to show all bidirectional comms are OK  
  79.                     stream.Close();  
  80.                 }  
  81.                 client.Close();  
  82.             }  
  83.         }  
  84.     }  
  85.  
  86. Client c = new Client();  
  87. c.Send(10000) 

我们从代码中可以看到,ProtoBuf本身具有很多与通信相关的特性。

有了以上写法,我们再来看看两个框架再传递对象时的相率对比

4:JSON.NET与ProtoBuf在Socket下传递对象效率简单对比

我们就来看从发送开始到收完数据接收,两个框架传递不同数量对象所消耗的时间。

100(J/P) 1000(J/P) 10000(J/P)

json/proto 97/264 150/143 2202/366

  评论这张
 
阅读(630)| 评论(0)
推荐 转载

历史上的今天

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017