GVKun编程网logo

Jackson枚举序列化和反序列化器（jackson 枚举 反序列化）

18

本文将介绍Jackson枚举序列化和反序列化器的详细情况，特别是关于jackson枚举反序列化的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于C#J

本文将介绍Jackson枚举序列化和反序列化器的详细情况，特别是关于jackson 枚举 反序列化的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于C# Json序列化和反序列化、C#对Json进行序列化和反序列化、Go 中 JSON 的序列化和反序列化、go 语言 json 的序列化和反序列化的知识。

本文目录一览：

Jackson枚举序列化和反序列化器（jackson 枚举 反序列化）

Jackson枚举序列化和反序列化器（jackson 枚举 反序列化）

我正在使用JAVA 1.6和Jackson 1.9.9我有一个枚举

public enum Event {    FORGOT_PASSWORD("forgot password");    private final String value;    private Event(final String description) {        this.value = description;    }    @JsonValue    final String value() {        return this.value;    }}

我添加了一个@JsonValue，这似乎可以将对象序列化为：

{"event":"forgot password"}

但是当我尝试反序列化时，我得到了

Caused by: org.codehaus.jackson.map.JsonMappingException: Can not construct instance of com.globalrelay.gas.appsjson.authportal.Event from String value ''forgot password'': value not one of declared Enum instance names

我在这里想念什么？

答案1

小编典典

如果你希望将枚举类与其JSON表示完全脱钩，则@xbakesx指出的序列化器/反序列化器解决方案是一个很好的解决方案。

另外，如果你喜欢一个独立的解决方案，则基于·和·注释的实现会更方便。

因此，利用@Stanley的示例，以下是一个完整的自包含解决方案（Java 6，Jackson 1.9）：

public enum DeviceScheduleFormat {    Weekday,    EvenOdd,    Interval;    private static Map<String, DeviceScheduleFormat> namesMap = new HashMap<String, DeviceScheduleFormat>(3);    static {        namesMap.put("weekday", Weekday);        namesMap.put("even-odd", EvenOdd);        namesMap.put("interval", Interval);    }    @JsonCreator    public static DeviceScheduleFormat forValue(String value) {        return namesMap.get(StringUtils.lowerCase(value));    }    @JsonValue    public String toValue() {        for (Entry<String, DeviceScheduleFormat> entry : namesMap.entrySet()) {            if (entry.getValue() == this)                return entry.getKey();        }        return null; // or fail    }}

C# Json序列化和反序列化

C# Json序列化和反序列化

C# Json序列化和反序列化

 
JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式。
 
方法一、使用 Newtonsoft.Json.dll
核心代码：
public static class JsonExtension
{
    /// <summary>
    /// object转json字符串
    /// </summary>
    public static string ObjectToJson(this object obj)
    {
        if (null == obj)
        {
            return null;
        }

        return JsonConvert.SerializeObject(obj);
    }

    /// <summary>
    /// json字符串转object
    /// </summary>
    public static T JsonToObject<T>(this string jsonString)
    {
        try
        {
            return JsonConvert.DeserializeObject<T>(jsonString);
        }
        catch
        {
            return default(T);
        }
    }

    /// <summary>
    /// 格式化json字符串
    /// </summary>
    public static string ConvertJsonString(this string str)
    {
        // 格式化json字符串
        JsonSerializer serializer = new JsonSerializer();
        TextReader tr = new StringReader(str);
        JsonTextReader jtr = new JsonTextReader(tr);
        object obj = serializer.Deserialize(jtr);
        if (null != obj)
        {
            StringWriter textWriter = new StringWriter();
            JsonTextWriter jsonWriter = new JsonTextWriter(textWriter)
            {
                Formatting = Formatting.Indented,
                Indentation = 4,
                IndentChar = '' ''
            };
            serializer.Serialize(jsonWriter, obj);
            return textWriter.ToString();
        }
        else
        {
            return str;
        }
    }

}
 
 
方法二、利用系统的 DataContractJsonSerializer 类
引用 System.Runtime.Serialization；
名字空间using System.Runtime.Serialization.Json;
核心代码：
public static class JsonExtension
{
    public static string GetJsonByObject<T>(this T obj)
    {
        if (null == obj)
        {
            return null;
        }

        //实例化DataContractJsonSerializer对象，需要待序列化的对象类型
        DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));

        //实例化一个内存流，用于存放序列化后的数据
        using (MemoryStream stream = new MemoryStream())
        {
            //使用WriteObject序列化对象
            serializer.WriteObject(stream, obj);

            //写入内存流中
            byte[] dataBytes = new byte[stream.Length];
            stream.Position = 0;
            stream.Read(dataBytes, 0, (int)stream.Length);

            //通过UTF8格式转换为字符串
            return Encoding.UTF8.GetString(dataBytes);
        }   
    }

    public static T GetObjectByJson<T>(this string jsonString)
    {
        try
        {
            //实例化DataContractJsonSerializer对象，需要待序列化的对象类型
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));

            //把Json传入内存流中保存
            using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(jsonString)))
            {
                // 使用ReadObject方法反序列化成对象
                return (T)serializer.ReadObject(stream);
            }
        }
        catch (Exception)
        {
            return default(T);
        }
        
    }

}
 
示例demo： ObjectAndJson-CSDN下载

C#对Json进行序列化和反序列化

C#对Json进行序列化和反序列化

一、Json简介

Json(JavaScript Object Notation) 是一种轻量级的数据交换格式。它基于JS的一个子集。 Json采用完全独立于语言的文本格式。这使得Json成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成。

Json简单来说就是JS中的对象和数组，所以Json也存在两种结构：对象、数组。

Json对象：Json对象定义在花括号“{}”内，以Key:value键值对的形式存放数据，多个数据使用分号“；”分割。

二、序列化

Object obj = Serialization.JsonToObject<Object>(strJson);

三、反序列化

strJson = Serialization.ObjectToJSON(obj);

四、工具类

    public static class Serialization
    {
        public static T JsonToObject<T>(string jsonText)
        {
            DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(typeof(T));
            MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(jsonText));
            T result = (T)((object)dataContractJsonSerializer.ReadObject(memoryStream));
            memoryStream.Dispose();
            return result;
        }

        public static string ObjectToJSON<T>(T obj)
        {
            DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(typeof(T));
            string result = string.Empty;
            using (MemoryStream memoryStream = new MemoryStream())
            {
                dataContractJsonSerializer.WriteObject(memoryStream, obj);
                memoryStream.Position = 0L;
                using (StreamReader streamReader = new StreamReader(memoryStream))
                {
                    result = streamReader.ReadToEnd();
                }
            }
            return result;
        }
    }

JSONStrToList 

自定义模型

        public class Obj
        {
            public string Name { get; set; }
            public double Price { get; set; }
        }

JSONStrToList

        //json转对象、数组, 反序列化
        public static void JSONStringToList()
        {

            //json格式字符串
            string JsonStr = "{Name:''苹果'',Price:5.5}";
            JavaScriptSerializer Serializer = new JavaScriptSerializer();

            //json字符串转为对象, 反序列化
            Obj obj = Serializer.Deserialize<Obj>(JsonStr);
            Console.Write(obj.Name + ":" + obj.Price + "\r\n");

            //json格式字符串
            string JsonStrs = "[{Name:''苹果'',Price:5.5},{Name:''橘子'',Price:2.5},{Name:''柿子'',Price:16}]";

            JavaScriptSerializer Serializers = new JavaScriptSerializer();

            //json字符串转为数组对象, 反序列化
            List<Obj> objs = Serializers.Deserialize<List<Obj>>(JsonStrs);

            foreach (var item in objs)
            {
                Console.Write(item.Name + ":" + item.Price + "\r\n");
            }
        }

StrTosJSON

        public static JObject strToJson(string jsonText)
        {
             jsonText = "{\"shenzheng\":\"深圳\",\"beijing\":\"北京\",\"shanghai\":[{\"zj1\":\"zj11\",\"zj2\":\"zj22\"},\"zjs\"]}";

            JObject jo = (JObject)JsonConvert.DeserializeObject(jsonText);
            //或者
            //JObject jo = JObject.Parse(jsonText);
            string zone = jo["shenzheng"].ToString();//输出 "深圳"
            string zone_en = jo["shanghai"].ToString();//输出 "[{"zj1":"zj11","zj2":"zj22"},"zjs"]"
            string zj1 = jo["shanghai"][1].ToString();//输出 "zjs"
            Console.WriteLine(jo);
            return jo;
        }

到此这篇关于C#对Json进行序列化和反序列化的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持。

您可能感兴趣的文章:
  • C#使用Json.Net对JSON与对象的序列化与反序列化
  • C# Newtonsoft.Json 解析多嵌套json 进行反序列化的实例
  • C#使用Json.Net进行序列化和反序列化及定制化
  • C#中Json反序列化的实现方法
  • C#实现JSON字符串序列化与反序列化的方法
  • C#中实现Json序列化与反序列化的几种方式
  • C#实现的json序列化和反序列化代码实例
  • C#实现json的序列化和反序列化实例代码
  • C#对JSON与对象的序列化与反序列化

Go 中 JSON 的序列化和反序列化

Go 中 JSON 的序列化和反序列化

golang中对json的序列化/反序列化操作还是比较容易的,
序列化操作主要是通过encoding/json包的Marshal()方法来实现,
反序列化操作主要是通过encoding/json包的Unmarshal()方法来实现.

//JSON序列化和反序列化

//可用在api序列化输出
//转成结构体,方便程序操作等

package main

import (
	"encoding/json"
	"fmt"
)

type Response1 struct {
	Page   int
	Fruits []string
}

type Response2 struct {
	Page   int      `json:"page"`
	Fruits []string `json:"fruits"`
}

func main() {

	//布尔型
	boolByte, _ := json.Marshal(true)
	fmt.Println(string(boolByte))

	//整数型
	intByte, _ := json.Marshal(100)
	fmt.Println(string(intByte))

	//浮点型
	floatByte, _ := json.Marshal(1.23456)
	fmt.Println(string(floatByte))

	//字符串
	stringByte, _ := json.Marshal("字符串啊啊啊")
	fmt.Println(string(stringByte))

	//切片
	sliceByte, _ := json.Marshal([]string{"apple", "orange", "banana"})
	fmt.Println(string(sliceByte))

	//字典
	mapByte, _ := json.Marshal(map[string]int{"apple": 5, "orange": 6, "banana": 7})
	fmt.Println(string(mapByte))

	//自定义类型1
	customsByte1, _ := json.Marshal(&Response1{Page: 1, Fruits: []string{"apple", "orange", "banana"}})
	fmt.Println(string(customsByte1))

	//自定义类型2,tag语法
	customsByte2, _ := json.Marshal(&Response2{Page: 2, Fruits: []string{"apple", "orange", "banana"}})
	fmt.Println(string(customsByte2))

	//反序列化到结构体
	json1 := `{"Page":1,"Fruits":["apple","orange","banana"]}`
	json2 := `{"page":2,"fruits":["apple","orange","banana"]}`
	response1 := Response1{}
	response2 := Response2{}
	json.Unmarshal([]byte(json1), &response1)
	fmt.Println(response1)
	json.Unmarshal([]byte(json2), &response2)
	fmt.Println(response2)
}

go 语言 json 的序列化和反序列化

go 语言 json 的序列化和反序列化

user.go

package main

// 必须大写才可以被序列化
// 可以使用json后指定序列化的名字
type User struct {
	Name string
	Age  int
    
    // 如果不是指针，也是可以的
	Obj  *SubObj
}

func NewUser(name string, age int, obj *SubObj) *User {
	return &User{Name: name, Age: age, Obj: obj}
}

sub_obj.go

package main

type SubObj struct {
	Name string
	Age  int
}

main.go

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	user := NewUser("jianan", 29, &SubObj{
		Name: "xx",
		Age:  18,
	})

	// 序列化测试
	b, e := json.Marshal(user)
	if e == nil {
		fmt.Println(b)
		fmt.Println(string(b))
	}

	// 反序列化
	// 可以不用填入字段
	var user2 User
	e2 := json.Unmarshal(b, &user2)
	if e2 == nil {
		fmt.Println(user2.Obj.Name)
	}
}

/*
[123 34 78 97 109 101 34 58 34 106 105 97 110 97 110 34 44 34 65 103 101 34 58 50 57 44 34 79 98 106 34 58 123 34 78 97 109 101 34 58 34 120 120 34 44 34 65 103 101 34 58 49 56 125 125]
{"Name":"jianan","Age":29,"Obj":{"Name":"xx","Age":18}}
xx
*/

 

关于Jackson枚举序列化和反序列化器和jackson 枚举 反序列化的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于C# Json序列化和反序列化、C#对Json进行序列化和反序列化、Go 中 JSON 的序列化和反序列化、go 语言 json 的序列化和反序列化等相关内容，可以在本站寻找。

本文标签：

上一篇部署带有服务的Cloudfoundry应用（Spring Boot）（服务器部署springboot项目）

下一篇带有Spring-boot CLI的RepositoryRestResource（springboot包含）

相关文章