GVKun编程网logo

【每日一博】Java序列化与JSON序列化大比拼（java序列化和json序列化区别）

9

此处将为大家介绍关于【每日一博】Java序列化与JSON序列化大比拼的详细内容，并且为您解答有关java序列化和json序列化区别的相关问题，此外，我们还将为您介绍关于C#中实现Json序列化与反序列

此处将为大家介绍关于【每日一博】Java序列化与JSON序列化大比拼的详细内容，并且为您解答有关java序列化和json序列化区别的相关问题，此外，我们还将为您介绍关于C#中实现Json序列化与反序列化的几种方式、C++对象的JSON序列化与反序列化探索、DotNet的JSON序列化与反序列化、Golang开发：优化JSON序列化与反序列化的性能的有用信息。

本文目录一览：

【每日一博】Java序列化与JSON序列化大比拼（java序列化和json序列化区别）

【每日一博】Java序列化与JSON序列化大比拼（java序列化和json序列化区别）

有项目需要传输Map结构的数据，有人倾向用Java序列化来做，有人倾向用JSON的序列化来做。所以我们还是比比吧。

Java观点：Object2Object，使用时简单快速。

JSON观点：JSON格式与语言无关，扩展性强，速度也应该不慢。

C#中实现Json序列化与反序列化的几种方式

C#中实现Json序列化与反序列化的几种方式

什么是JSON？

JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy for humans to read and write and easy for machines to parse and generate. JSON is a text format that is completely language independent.

翻译：Json【javascript对象表示方法】，它是一个轻量级的数据交换格式，我们可以很简单的来读取和写它，并且它很容易被计算机转化和生成，它是完全独立于语言的。

Json支持下面两种数据结构：

  1. 键值对的集合--各种不同的编程语言，都支持这种数据结构；
  2. 有序的列表类型值的集合--这其中包含数组，集合，矢量，或者序列，等等。

Json有下面几种表现形式

1.对象

一个没有顺序的“键/值”,一个对象以花括号“{”开始，并以花括号"}"结束，在每一个“键”的后面，有一个冒号，并且使用逗号来分隔多个键值对。

例如：

  var user = {"name":"Manas","gender":"Male","birthday":"1987-8-8"}

 

2.数组

设置值的顺序，一个数组以中括号"["开始,并以中括号"]"结束，并且所有的值使用逗号分隔

例如：

var userlist = [{"user":{"name":"Manas","birthday":"1987-8-8"}},{"user":{"name":"Mohapatra","Male":"Female","birthday":"1987-7-7"}}]

3.字符串

任意数量的Unicode字符，使用引号做标记，并使用反斜杠来分隔。

例如：

var userlist = "{\"ID\":1,\"Name\":\"Manas\",\"Address\":\"India\"}"

好了，介绍完JSON，现在说正题。

序列化和反序列化有三种方式：

  1. 使用JavaScriptSerializer类
  2. 使用DataContractJsonSerializer类
  3. 使用JSON.NET类库

我们先来看看使用 DataContractJsonSerializer的情况

DataContractJsonSerializer类帮助我们序列化和反序列化Json，他在程序集 System.Runtime.Serialization.dll下的System.Runtime.Serialization.Json命名空间里。

首先，这里，我新建一个控制台的程序，新建一个类Student

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.Serialization;

namespace JsonSerializerAndDeSerializer
{
 [DataContract]
 public class Student
 {
  [DataMember]
  public int ID { get; set; }

  [DataMember]
  public string Name { get; set; }

  [DataMember]
  public int Age { get; set; }

  [DataMember]
  public string Sex { get; set; }
 }
}

注意：上面的Student实体中的契约 [DataMember]，[DataContract]，是使用DataContractJsonSerializer序列化和反序列化必须要加的，对于其他两种方式不必加，也可以的。

我们程序的代码：

要先引用程序集，在引入这个命名空间

//----------------------------------------------------------------------------------------------
//使用DataContractJsonSerializer方式需要引入的命名空间，在System.Runtime.Serialization.dll.中
using System.Runtime.Serialization.Json;
//--------------------------------------------------------------------------------------------
#region 1.DataContractJsonSerializer方式序列化和反序列化
   Student stu = new Student()
    {
     ID = 1,Name = "曹操",Sex = "男",Age = 1000
    };
   //序列化
   DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(Student));
   MemoryStream msObj = new MemoryStream();
   //将序列化之后的Json格式数据写入流中
   js.WriteObject(msObj,stu);
   msObj.Position = 0;
   //从0这个位置开始读取流中的数据
   StreamReader sr = new StreamReader(msObj,Encoding.UTF8);
   string json = sr.ReadToEnd();
   sr.Close();
   msObj.Close();
   Console.WriteLine(json);


   //反序列化
   string toDes = json;
   //string to = "{\"ID\":\"1\",\"Name\":\"曹操\",\"Sex\":\"男\",\"Age\":\"1230\"}";
   using (var ms = new MemoryStream(Encoding.Unicode.GetBytes(toDes)))
   {
    DataContractJsonSerializer deseralizer = new DataContractJsonSerializer(typeof(Student));
    Student model = (Student)deseralizer.Readobject(ms);// //反序列化Readobject
    Console.WriteLine("ID=" + model.ID);
    Console.WriteLine("Name=" + model.Name);
    Console.WriteLine("Age=" + model.Age);
    Console.WriteLine("Sex=" + model.Sex);
   }
   Console.ReadKey(); 
   #endregion

运行之后结果是：

 

再看看使用JavaScriptJsonSerializer的情况：

JavaScriptSerializer is a class which helps to serialize and deserialize JSON. It is present in namespace System.Web.Script.Serialization which is available in assembly System.Web.Extensions.dll. To serialize a .Net object to JSON string use Serialize method. It's possible to deserialize JSON string to .Net object using Deserialize<T> or DeserializeObject methods. Let's see how to implement serialization and deserialization using JavaScriptSerializer.

这里要先引用

//-----------------------------------------------------------------------------------------
//使用JavaScriptSerializer方式需要引入的命名空间，这个在程序集System.Web.Extensions.dll.中
using System.Web.Script.Serialization;
//----------------------------------------------------------------------------------------
#region 2.JavaScriptSerializer方式实现序列化和反序列化
   Student stu = new Student()
    {
     ID = 1,Name = "关羽",Age = 2000,Sex = "男"
    };

   JavaScriptSerializer js = new JavaScriptSerializer();
   string jsonData = js.Serialize(stu);//序列化
   Console.WriteLine(jsonData);


   ////反序列化方式一：
   string desJson = jsonData;
   //Student model = js.Deserialize<Student>(desJson);// //反序列化
   //string message = string.Format("ID={0},Name={1},Age={2},Sex={3}",model.ID,model.Name,model.Age,model.Sex);
   //Console.WriteLine(message);
   //Console.ReadKey(); 


   ////反序列化方式2
   dynamic modelDy = js.Deserialize<dynamic>(desJson); //反序列化
   string messageDy = string.Format("动态的反序列化,ID={0},modelDy["ID"],modelDy["Name"],modelDy["Age"],modelDy["Sex"]);//这里要使用索引取值，不能使用对象.属性
   Console.WriteLine(messageDy);
   Console.ReadKey(); 
   #endregion

结果是：

 

最后看看使用JSON.NET的情况，引入类库：

 

下面的英文，看不懂可略过。。。

Json.NET is a third party library which helps conversion between JSON text and .NET object using the JsonSerializer. The JsonSerializer converts .NET objects into their JSON equivalent text and back again by mapping the .NET object property names to the JSON property names. It is open source software and free for commercial purposes.

The following are some awesome【极好的】 features,
Flexible JSON serializer for converting between .NET objects and JSON.
LINQ to JSON for manually reading and writing JSON.
High performance,faster than .NET's built-in【内嵌】 JSON serializers.
Easy to read JSON.
Convert JSON to and from XML.
Supports .NET 2,.NET 3.5,.NET 4,Silverlight and Windows Phone.
Let's start learning how to install and implement:

In Visual Studio,go to Tools Menu -> Choose Library Package manger -> Package Manager Console. It opens a command window where we need to put the following command to install Newtonsoft.Json.

Install-Package Newtonsoft.Json
OR
In Visual Studio,Tools menu -> Manage Nuget Package manger Solution and type “JSON.NET” to search it online. Here's the figure,

 

//使用Json.NET类库需要引入的命名空间
//-----------------------------------------------------------------------------
using Newtonsoft.Json;
//-------------------------------------------------------------------------
#region 3.Json.NET序列化
   List<Student> lstStuModel = new List<Student>() 
   {
   
   new Student(){ID=1,Name="张飞",Age=250,Sex="男"},new Student(){ID=2,Name="潘金莲",Age=300,Sex="女"}
   };

   //Json.NET序列化
   string jsonData = JsonConvert.SerializeObject(lstStuModel);

   Console.WriteLine(jsonData);
   Console.ReadKey();


   //Json.NET反序列化
   string json = @"{ 'Name':'C#','Age':'3000','ID':'1','Sex':'女'}";
   Student descJsonStu = JsonConvert.DeserializeObject<Student>(json);//反序列化
   Console.WriteLine(string.Format("反序列化： ID={0},Sex={2},descJsonStu.ID,descJsonStu.Name,descJsonStu.Age,descJsonStu.Sex));
   Console.ReadKey(); 
   #endregion

运行之后，结果是：

总结

最后还是尽量使用JSON.NET来序列化和反序列化，性能好。

In this article we discussed about how many ways we can implement serialization/deserialization in C#. However JSON.NET wins over other implementations because it facilitates more functionality of JSON validation,JSON schema,LINQ to JSON etc. So use JSON.NET always.

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流。

C++对象的JSON序列化与反序列化探索

C++对象的JSON序列化与反序列化探索

C++对象的JSON序列化与反序列化探索

一：背景

作为一名 C++ 开发人员，我一直很期待能够像 C# 与 JAVA 那样，可以轻松的进行对象的序列化与反序列化，但到目前为止，尚未找到相对完美的解决方案。

本文旨在抛砖引玉，期待有更好的解决方案；同时向大家寻求帮助，解决本文中未解决的问题。  

二：相关技术介绍

本方案采用 JsonCpp 来做具体的 JSON 的读入与输出，再结合类成员变量的映射，最终实现对象的 JSON 序列化与反序列化。

本文不再讨论如何使用 JsonCpp ，此处将作者在应用时发现的两处问题进行说明：

1.        下载 Jsoncpp ，编译其 lib ，并且引用到项目中，发现有如下错误：

错误 1       fatal error C1083: Cannot open compiler generated file: ''../../build/vs71/release/lib_json\json_writer.asm'': No such file or directory       c:\Documents and Settings\Administrator\jsoncpp-src-0.6.0-rc2\jsoncpp-src-0.6.0-rc2\src\lib_json\json_writer.cpp

错误 2       fatal error LNK1257: 代码生成失败       JasonSerialize 

 

  可以通过在修改 LIB 库项目的属性解决，如下图 [ 关闭汇编输出 ] ：

2.        JSONCPP 官网首页的下载版本是 0.5.0 ，此版本不支持 Int64 等类型，下载版本 jsoncpp-src-0.6.0-rc2 后即可支持 .  

三：一个基于 JsonCpp 的序列化与反序列化基类

先看代码：

#pragma once
#include <string>
#include <vector>
#include "json/json.h"
using std::string;
using std::vector;
struct CJsonObejectBase
{
protected:
  enum CEnumJsonTypeMap
  {
    asInt = 1,
    asUInt,
    asString,
    asInt64,
    asUInt64,
  };
public:
  CJsonObejectBase(void){}
public:
  virtual ~CJsonObejectBase(void){}
  string Serialize()
  {
    Json::Value new_item;  
    int nSize = m_listName.size();
    for (int i=0; i < nSize; ++i )
    {
      void* pAddr = m_listPropertyAddr[i];
      switch(m_listType[i])
      {
      case asInt:
        new_item[m_listName[i]] = (*(INT*)pAddr);
        break;
      case asUInt:
        new_item[m_listName[i]] = (*(UINT*)pAddr);
        break;
      case asInt64:
        new_item[m_listName[i]] = (*(LONGLONG*)pAddr);
        break;
      case asUInt64:
        new_item[m_listName[i]] = (*(ULONGLONG*)pAddr);
        break;
      case asString:
        new_item[m_listName[i]] = (*(string*)pAddr);
      default:
        //我暂时只支持这几种类型，需要的可以自行添加 
        break;
      }		
    }
    Json::FastWriter writer;  
    std::string out2 = writer.write(new_item); 
    return out2;
  }

  bool DeSerialize(const char* str)
  {
    Json::Reader reader;  
    Json::Value root;
    if (reader.parse(str, root))
    {  
      int nSize = m_listName.size();
      for (int i=0; i < nSize; ++i )
      {
        void* pAddr = m_listPropertyAddr[i];

        switch(m_listType[i])
        {
        case asInt:
          (*(INT*)pAddr) = root.get(m_listName[i], 0).asInt();
          break;
        case asUInt:
          (*(UINT*)pAddr) = root.get(m_listName[i], 0).asUInt();
          break;
        case asInt64:
          (*(LONGLONG*)pAddr) = root.get(m_listName[i], 0).asInt64();
          break;
        case asUInt64:
          (*(ULONGLONG*)pAddr) = root.get(m_listName[i], 0).asUInt64();
          break;
        case asString:
          (*(string*)pAddr) = root.get(m_listName[i], "").asString();
        default:
          //我暂时只支持这几种类型，需要的可以自行添加 
          break;
        }			
      }
      return true;
    }
    return false;
  }
protected:
  void SetProperty(string name, CEnumJsonTypeMap type, void* addr)
  {
    m_listName.push_back(name);
    m_listPropertyAddr.push_back(addr);
    m_listType.push_back(type);
  }
  virtual void SetPropertys() = 0;
  vector<string> m_listName;
  vector<void*>  m_listPropertyAddr;
  vector<CEnumJsonTypeMap>	   m_listType;
};

此类主要有三个函数：Serialize、DeSerialize及 SetPropertys、SetProperty，其中前两个函数主要是用来实现对象的序列化与反序列化；SetPropertys是一个纯虚函数，如 果一个类需要具备序列化功能，只需要从此类继承，同时调用SetProperty函数，将各个字段的属性进行设置即可。    

四：使用对象的序列化及反序列化功能

要使对象具体相应功能，需要继承上述的基类，如下：  

struct CTestStruct : public CJsonObejectBase
{
  CTestStruct()
  {
    SetPropertys();
  }
  ULONGLONG MsgID;
  string MsgTitle;
  string MsgContent;
protected:
  //子类需要实现此函数，并且将相应的映射关系进行设置 
  virtual void SetPropertys()
  {
    SetProperty("MsgID", asUInt64, &MsgID);
    SetProperty("MsgTitle", asString, &MsgTitle);
    SetProperty("MsgContent", asString, &MsgContent);
  }
};

继承后，我们可以使用如下代码来进行测试

序列化：  

void CJasonSerializeDlg::OnBnClickedOk()
{
  CTestStruct stru;
  stru.MsgID = 11223344;
  stru.MsgTitle = "黑黑";
  stru.MsgContent = "哈哈";
  CString strTest = stru.Serialize().c_str();
  AfxMessageBox(strTest);
}

结果：

反序列化:  

void CJasonSerializeDlg::OnBnClickedOk2()
{
  const char* pstr = "{\"MsgContent\":\"哈哈22\",\"MsgID\":11111111111111111,\"MsgTitle\":\"黑黑22\"}";
  CTestStruct stru;
  stru.DeSerialize(pstr);
  CString strShow = "";
  strShow.Format("MsgID:%I64u\r\nMsgTile:%s\r\nMsgContent:%s", stru.MsgID, stru.MsgTitle.c_str(), stru.MsgContent.c_str());
  AfxMessageBox(strShow);
}

结果：

 

五：未解决的问题

1.        目前我对属性的映射采用的是 vector 顺序映射的方式，这样必需在子类中对每一个属性进行设置，是否有宏的策略可以使这部分工作更加轻松？

2.        目前只支持整型、 64 位整型及字符串类型，需要支持其他类型，可以在基类中添加映射即可。

3.        目前只支持单个简单对象 [ 其属性均为简单类型 ] 的序列化与反序列化，暂时未考虑如何支持复杂的，如内部包含其他的复杂对象、包含数组等情况。  

完整代码请于如下链接下载：

  http://download.csdn.net/detail/tragicguy/5630473

DotNet的JSON序列化与反序列化

DotNet的JSON序列化与反序列化

   JSON（JavaScript Object Notation）JavaScript对象表示法，它是一种基于文本，独立于语言的轻量级数据交换格式。在现在的通信中，较多的采用JSON数据格式，JSON有两种表示结构，对象和数组，JSON 数据的书写格式是：名称/值对。

   在vs解决方案中以前采用xml树的形式，组织项目的结构。在新的.net core中，项目的解决方案采用json作为项目的结构说明。

   在.net的前后台数据交互中，采用序列化对象为json，前端ajax接受传输数据，反序列化为对象，在页面对数据进行渲染。有关json的相关内容就不再赘述，在.net中序列化的类主要采用DataContractJsonSerializer类。

   现在提供一个较为通用的json的序列化和反序列化的通用方法。

  1.json的序列化：

/// <summary>
        /// 将对象序列化为JSON
        /// </summary>
        /// <typeparam name="T">序列化的类型</typeparam>
        /// <param name="t">需要序列化的对象</param>
        /// <returns>序列化后的JSON</returns>
        public static string JsonSerializer<T>(T t)
        {
            if (t == null)
                throw new ArgumentNullException("t");
            string jsonString;
            try
            {
                var ser = new DataContractJsonSerializer(typeof(T));
                var ms = new MemoryStream();
                ser.WriteObject(ms, t);
                jsonString = Encoding.UTF8.GetString(ms.ToArray());
                ms.Close();
                //替换Json的Date字符串
                const string p = @"\\/Date\((\d+)\+\d+\)\\/";
                var matchEvaluator = new MatchEvaluator(ConvertJsonDateToDateString);
                var reg = new System.Text.RegularExpressions.Regex(p);
                jsonString = reg.Replace(jsonString, matchEvaluator);
            }
            catch (Exception er)
            {
                throw new Exception(er.Message);
            }

            return jsonString;
        }

  2.json的反序列化：

/// <summary>
        /// 将JSON反序列化为对象
        /// </summary>
        public static T JsonDeserialize<T>(string jsonString)
        {
            if (string.IsNullOrEmpty(jsonString))
                throw new Exception(jsonString);
            //将"yyyy-MM-dd HH:mm:ss"格式的字符串转为"\/Date(1294499956278+0800)\/"格式
            const string p = @"\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}";
            try
            {
                var matchEvaluator = new MatchEvaluator(ConvertDateStringToJsonDate);
                var reg = new System.Text.RegularExpressions.Regex(p);
                jsonString = reg.Replace(jsonString, matchEvaluator);
                var ser = new DataContractJsonSerializer(typeof(T));
                var ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
                var obj = (T)ser.ReadObject(ms);
                return obj;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message, ex);
            }

        }

   以上是一个较为简单的json序列化和反序列化方法。

Golang开发：优化JSON序列化与反序列化的性能

Golang开发：优化JSON序列化与反序列化的性能

golang开发：优化json序列化与反序列化的性能

Golang开发：优化JSON序列化与反序列化的性能

简介
在现代的Web开发中，序列化和反序列化是非常常见的操作。尤其是在使用JSON作为数据传输格式时，优化序列化和反序列化的性能对于提升系统的效率至关重要。本文将介绍一些Golang中优化JSON序列化与反序列化性能的技巧，并提供相应的代码示例。

第一节：使用结构体标签
在Golang中，可以使用结构体标签来为JSON字段提供额外的信息。这些标签可以帮助我们指定JSON字段的名称、是否忽略或者应该如何处理。使用结构体标签可以减少字段名称的随意性，从而提高序列化和反序列化的性能。下面是一个使用了结构体标签的示例：

type User struct {
    ID       int    `json:"id"`
    Name     string `json:"name"`
    Age      int    `json:"age"`
    Address  string `json:"address,omitempty"`
    Hobby    string `json:"-"`
}
登录后复制

在上面的示例中，ID、Name、Age和Address字段都被指定了相应的json标签。Address字段使用了omitempty选项，表示当字段为空时该字段会被忽略。Hobby字段使用了"-"，表示该字段不会被序列化和反序列化。

立即学习“go语言免费学习笔记（深入）”；

第二节：使用指针类型
在Golang中，使用指针类型可以更高效地进行序列化和反序列化操作。当我们使用指针类型时，可以减少内存复制的开销，从而提高性能。下面是一个使用了指针类型的示例：

type User struct {
    ID      *int    `json:"id"`
    Name    *string `json:"name"`
    Age     *int    `json:"age"`
    Address *string `json:"address"`
}

func main() {
    id := 1
    name := "user"
    age := 20
    address := "Beijing"
    
    user := User{
        ID:      &id,
        Name:    &name,
        Age:     &age,
        Address: &address,
    }
    
    // 序列化
    data, _ := json.Marshal(user)
    
    // 反序列化
    json.Unmarshal(data, &user)
}
登录后复制

在上面的示例中，User结构体中的字段都是指针类型。在进行序列化和反序列化操作时，使用了指针类型可以减少内存分配和复制，提高性能。

第三节：使用缓冲池
在Golang中，可以使用缓冲池来重用序列化和反序列化过程中的临时内存。通过使用sync.Pool或者类似的技术，可以减少内存分配和释放的开销。下面是一个使用缓冲池的示例：

var bufferPool = sync.Pool{
    New: func() interface{} {
        return &bytes.Buffer{}
    },
}

func Serialize(v interface{}) ([]byte, error) {
    buffer := bufferPool.Get().(*bytes.Buffer)
    defer bufferPool.Put(buffer)
    
    buffer.Reset()
    
    err := json.NewEncoder(buffer).Encode(v)
    if err != nil {
        return nil, err
    }
    
    return buffer.Bytes(), nil
}

func Deserialize(data []byte, v interface{}) error {
    buffer := bufferPool.Get().(*bytes.Buffer)
    defer bufferPool.Put(buffer)
    
    buffer.Reset()
    buffer.Write(data)
    
    return json.NewDecoder(buffer).Decode(v)
}
登录后复制

在上面的示例中，使用了sync.Pool来创建了一个bytes.Buffer的缓冲池。在序列化和反序列化操作中，我们从缓冲池中获取一个临时的buffer，并在使用完之后放回缓冲池。通过使用缓冲池，可以重用临时内存，减少内存分配和释放的开销。

总结
在Golang开发中，优化JSON序列化与反序列化的性能对于提升系统的性能至关重要。本文介绍了使用结构体标签、指针类型和缓冲池的技巧，并提供了相应的代码示例。通过使用这些技巧，我们可以提高序列化和反序列化操作的性能，从而提升整个系统的效率。

以上就是Golang开发：优化JSON序列化与反序列化的性能的详细内容，更多请关注php中文网其它相关文章！

今天关于【每日一博】Java序列化与JSON序列化大比拼和java序列化和json序列化区别的讲解已经结束，谢谢您的阅读，如果想了解更多关于C#中实现Json序列化与反序列化的几种方式、C++对象的JSON序列化与反序列化探索、DotNet的JSON序列化与反序列化、Golang开发：优化JSON序列化与反序列化的性能的相关知识，请在本站搜索。

本文标签：

上一篇java bean 对象转json（bean转jsonobject）

下一篇HttpServletResponse 返回的json数据不是json字符串，而是json对象（servlet返回json给前端）

相关文章