Object转化成JSON字符串

最新推荐文章于 2024-06-22 20:25:10 发布
最新推荐文章于 2024-06-22 20:25:10 发布
阅读量119 收藏
点赞数
文章标签： json
原文链接：http://www.cnblogs.com/iwteih/archive/2010/01/18/1650429.html
版权

有关JSON的介绍，请参见http://www.json.org/json-zh.html
对于一个类，其中可能包括field, property，方法不做JSON序列化。我们可以去field和property进行JSON转化。
模仿反射中的FieldInfo和PropertyInfo， 两者都继承于MemberInfo，我们定义三个类，用来存储field，property的信息：

JsonMemberInfo.cs

using System;

namespace XXX.JsonSerializer
{
    public class JsonMemberInfo
    {
        protected JsonAttrribute attribute;

        public JsonAttrribute Attribute
        {
            get
            {
                return this.attribute;
            }
            set
            {
                this.attribute = value;
            }
        }
    }
}
 
JsonFieldInfo.cs
 
using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;

namespace XXX.JsonSerializer
{
    public class JsonFieldInfo : JsonMemberInfo
    {
        private FieldInfo info;

        public FieldInfo Info
        {
            get
            {
                return this.info;
            }
            set
            {
                this.info = value;
            }
        }

        public string JsonName
        {
            get
            {
                if ((this.attribute != null) && (this.attribute.JsonName != string.Empty))
                {
                    return this.attribute.JsonName;
                }
                else
                {
                    return this.info.Name;
                }
            }
        }

        public JsonFieldInfo(FieldInfo i)
        {
            this.info = i;
        }
    }
}

 

JsonPropertyInfo.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;

namespace XXX.JsonSerializer
{
    public class JsonPropertyInfo : JsonMemberInfo
    {
        private PropertyInfo info;

        public PropertyInfo Info
        {
            get
            {
                return this.info;
            }
            set
            {
                this.info = value;
            }
        }

        public string JsonName
        {
            get
            {
                if ((this.attribute != null) && (this.attribute.JsonName != string.Empty))
                {
                    return this.attribute.JsonName;
                }
                else
                {
                    return this.info.Name;
                }
            }
        }

        public JsonPropertyInfo(PropertyInfo i)
        {
            this.info = i;
        }
    }
}
 

接下来，我们用一个类来保存被JSON的对象的内容：

JsonClassInfo.cs

using System;

namespace XXX.JsonSerializer
{
    public class JsonClassInfo
    {
        private Type classType;
        private JsonFieldInfo[] fields;
        private JsonPropertyInfo[] properties;

        public JsonClassInfo(Type t)
        {
            if (t == null)
            {
                 throw new Exception("Json Serializer cannot get the type of the object!");
            }
            this.classType = t;
        }

        public string ClassName
        {
            get
            {
                return this.classType.Name;
            }
        }

        public Type ClassType
        {
            get
            {
                return this.classType;
            }
        }

        public JsonFieldInfo[] ClassFields
        {
            get
            {
                return this.fields;
            }
            set
            {
                this.fields = value;
            }
        }

        public JsonPropertyInfo[] ClassProperties
        {
            get
            {
                return this.properties;
            }
            set
            {
               this.properties = value;
            }
        }
    }
}

 

所有被JSON的对象的field, property的信息会保存在这个类中。
还要指定一个对象中哪些field需要被JSON，以及提供JSON序列化时的控制。我们用到Attribute这个东东：

JsonAttrribute.cs

using System;

namespace XXX.JsonSerializer
{
    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
    public class JsonAttrribute : Attribute
    {
        private string name;
        private bool isIgnore;

        public JsonAttrribute(bool ignore)
            : this(ignore, string.Empty)
        {

        }

        public JsonAttrribute(string name)
            : this(false, name)
        {

        }

        public JsonAttrribute() : base() { }

        public JsonAttrribute(bool ignore, string name)
        {
            this.isIgnore = ignore;
            this.name = name;
        }

        public string JsonName
        {
            get
            { 
                return this.name; 
            }
            set
            {
                this.name = value;
            }
        }

        public bool IsIgnore
        {
               get { return this.isIgnore; }
        }
    }
}
 
下面上重头戏，JSON序列化的实现：

JsonSerializer.cs

 

using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Text;

namespace XXX.JsonSerializer
{
    public class JsonSerializer
    {
        private const string LeftBrace = "{";
        private const string RightBrace = "}";
        private const string LeftBracket = "[";
        private const string RightBracket = "]";
        private const string Comma = ", ";

        private static readonly Type stringType = typeof(string);
        private static readonly Type dateTimeType = typeof(DateTime);
        private static readonly Type jsonAttrribute = typeof(JsonAttrribute);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public string Serialize(object obj)
        {
            if (null == obj)
            {
                return string.Empty;
            }

            Type objType = obj.GetType();

            #region Serialize an Array

            if (objType.IsArray)
            {
                StringBuilder sb = new StringBuilder();
                sb.Append(LeftBracket);

                IEnumerable enumer = obj as IEnumerable;
                if (enumer != null)
                {
                    bool extraComma = false;
                    IEnumerator enumrator = enumer.GetEnumerator();
                    while (enumrator.MoveNext())
                    {
                        //recursive serialize object in array
                        sb.Append(this.Serialize(enumrator.Current));
                        sb.Append(Comma);
                        extraComma = true;
                    }

                    if (extraComma)
                    {
                        sb.Remove(sb.Length - Comma.Length, Comma.Length);
                    }
                }

                sb.Append(RightBracket);

                return sb.ToString();
            }

            #endregion

            if (objType.IsEnum)
            {
                return string.Format("'{0}'", obj.ToString());
            }

            if (objType.IsValueType)
            {
                if (objType == dateTimeType)
                {
                    return string.Format("'{0}'", EscapeCharacter(obj.ToString()));
                }
                //  The input object is value type
                if (objType.IsPrimitive)
                {
                    //  The input object is int, doublt, etc.
                    return string.Format("'{0}'", EscapeCharacter(obj.ToString()));
                }
                else
                {
                    //  The input object is struct.
                    return this.SerializeClassStruct(obj, objType);
                }
            }
            else
            {
                //  The input object is not value type
                if (objType == stringType)
                {
                    //  The input object is string
                    return string.Format("'{0}'", EscapeCharacter(obj.ToString()));
                }
                else if (objType.IsClass)
                {
                    //  The input object is a customize class.
                    return this.SerializeClassStruct(obj, objType);
                }
                else
                {
                    //  Ingore delegate and interface.
                    return string.Empty;
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        private string SerializeClassStruct(object obj, Type objType)
        {
            StringBuilder sb = new StringBuilder();
            sb.Append(LeftBrace);

            bool extraComma = false;
            string strValue = string.Empty;
            JsonClassInfo classInfo = this.ReflectClassInfo(objType);

            foreach (JsonFieldInfo info in classInfo.ClassFields)
            {
                strValue = GetValue(obj, info.Info, info.JsonName, ref extraComma);

                sb.Append(strValue);
            }

            foreach (JsonPropertyInfo info in classInfo.ClassProperties)
            {
                strValue = GetValue(obj, info.Info, info.JsonName, ref extraComma);

                sb.Append(strValue);
            }

            if (extraComma)
            {
                sb.Remove(sb.Length - Comma.Length, Comma.Length);
            }

            sb.Append(RightBrace);

            return sb.ToString();
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="objType"></param>
        /// <param name="obj"></param>
        /// <param name="fieldInfo"></param>
        /// <param name="jsonName"></param>
        /// <param name="extraComma"></param>
        /// <returns></returns>
        private string GetValue(object obj, FieldInfo info, string jsonName, ref  bool extraComma)
        {
            object value = null;
            StringBuilder sb = new StringBuilder();

            if (obj == null)
            {
                return string.Empty;
            }

            if (info != null)
            {
                value = info.GetValue(obj);

                //According to XmlSerializer, if an object is null, it will NOT be serializered
                if (value != null)
                {
                    if (!string.IsNullOrEmpty(jsonName))
                    {
                        sb.Append(string.Format("'{0}':", this.EscapeCharacter(jsonName)));
                    }

                    sb.Append(Serialize(value));
                    sb.Append(Comma);
                    extraComma = true;
                }
            }
            return sb.ToString();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="objType"></param>
        /// <param name="obj"></param>
        /// <param name="fieldInfo"></param>
        /// <param name="jsonName"></param>
        /// <param name="extraComma"></param>
        /// <returns></returns>
        private string GetValue(object obj, PropertyInfo info, string jsonName, ref  bool extraComma)
        {
            object value = null;
            StringBuilder sb = new StringBuilder();

            if (info != null)
            {
                try
                {
                    value = info.GetValue(obj, null);
                }
                catch
                {
                    //  in case the property is indexer.
                    //  It will igorne the indexer
                    value = "";
                }

                //According to XmlSerializer, if an object is null, it will NOT be serializered
                if (value != null)
                {
                    if (!string.IsNullOrEmpty(jsonName))
                    {
                        sb.Append(string.Format("'{0}':", this.EscapeCharacter(jsonName)));
                    }

                    sb.Append(Serialize(value));
                    sb.Append(Comma);
                    extraComma = true;
                }
            }
            return sb.ToString();
        }

        private JsonClassInfo ReflectClassInfo(Type objType)
        {
            //
            //We could use cache to store reflected object 
            //

            FieldInfo[] fields = objType.GetFields(BindingFlags.GetField | BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);            

            JsonClassInfo classInfo = new JsonClassInfo(objType);

            classInfo.ClassFields = new JsonFieldInfo[fields.Length];
            for (int i = 0; i < fields.Length; ++i)
            {
                classInfo.ClassFields[i] = new JsonFieldInfo(fields[i]);

                object[] jsonInfo = fields[i].GetCustomAttributes(jsonAttrribute, true);
                if (jsonInfo != null && jsonInfo.Length > 0)
                {
                    JsonAttrribute jAttri = jsonInfo[0] as JsonAttrribute;
                    if (jAttri.IsIgnore)
                    {
                        continue;
                    }

                    classInfo.ClassFields[i].Attribute = jAttri;
                }
            }

            PropertyInfo[] properties = objType.GetProperties(BindingFlags.GetField | BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);

            classInfo.ClassProperties = new JsonPropertyInfo[properties.Length];
            for (int i = 0; i < properties.Length; ++i)
            {
                classInfo.ClassProperties[i] = new JsonPropertyInfo(properties[i]);

                object[] jsonInfo = properties[i].GetCustomAttributes(jsonAttrribute, true);
                if (jsonInfo != null && jsonInfo.Length > 0)
                {
                    JsonAttrribute jAttri = jsonInfo[0] as JsonAttrribute;
                    if (jAttri.IsIgnore)
                    {
                        continue;
                    }

                    classInfo.ClassProperties[i].Attribute = jAttri;
                }
            }

            return classInfo;
        }

        /// <summary>
        /// Escape \ & '
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public string EscapeCharacter(string input)
        {
            return input.Replace(@"\", @"\\").Replace("'", @"\'");
        }
    }
}
 

通过反射，可以得到给定object里的field, property信息，然后对不同情况进行处理。
值得注意的是对象中嵌套对象需要用到递归；对数组，对象，值，在JSON序列化要区分对待；对特殊字符要转义。
使用示例：

class Program
{
    static void Main(string[] args)
    {
        TestClass tc = new TestClass();
        JsonSerializer ser = new JsonSerializer();
        string json = ser.Serialize(tc);
        Console.WriteLine(json);
    }
}

class TestClass
{
    [JsonAttrribute("NC")]
    public NestClass nc = new NestClass();

    //This field will not be serialized because ingore = true
    [JsonAttrribute(true)]
    NestClass ic = new NestClass();

    public int[] IntegerArray = new int[] {1, 2, 3 };

    //private field will not be serialized
    [JsonAttrribute("PNC")]
    private NestClass pnc = new NestClass();
}

class NestClass
{ 
    [JsonAttrribute("NF")]
    public string NestClassFiled = "NestClassFiled";

}

 

输出如下：
{'NC':{'NF':'NestClassFiled'}, 'IntegerArray':['1', '2', '3']}
新版本的.net framework中提供了把对象转成JSON的方法，在一个dll里，具体叫什么记不得了，Scottegu的blog中提到过。

转载于:https://www.cnblogs.com/iwteih/archive/2010/01/18/1650429.html

weixin_30555125
关注
java Object转换为json
04-07
此下载包含 POJO 中使用 json格式传递到页面所需要的包 POJO 中Object/Array/List/Map转换为json格式的语法 PS：下载了可以保证json方面完全没有问题的使用。 thia's all!!!
使用json-lib将java对象转换成json字符串
03-16
标题中的“使用json-lib将java对象转换成json字符串”指的是在Java编程中，利用json-lib这个库来将Java对象转化为JSON格式的字符串。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，广泛用于前后端...
将object转为json的方法
VICHOU_FA的博客
09-08 6万+
前言 json，xml用于都可以用于网络间数据传输的格式，比较轻量级，类似于一个传输协议，同时可以被js解析。网络间还有一种对象流传输方式，但是传输者之间约定的条件要更多。 json的主要格式就是{“key”：“value”，“key”：“value”}。javabean在重写Object的toString（）方法时，返回结果也是一个json格式的。那么如何将一个对象转换成json字符串呢。
java中Object和json相互转换的方式
m0_57310426的博客
06-22 1011
ObjectMapper o=new ObjectMapper();Listlist=new ArrayList();String jons=o.writeAsValueString(list);
object 转换成json(转载)
weixin_30710457的博客
11-26 122
Object转换成json的JS代码 收藏 下面是通用的Object转换成json的JS代码 //用法 //var obj=new Object(); //obj.Name= 'Nams '; //obj.Sex=1; //JSON.serialize(obj);//wi...
Object转换成json的JS代码
lee576的专栏
04-06 1万+
下面是通用的Object转换成json的JS代码 //用法 //var   obj=new   Object(); //obj.Name= Nams ; //obj.Sex=1; //JSON.serialize(obj);//will   get:   {Name: Nams ,Sex:1} if(typeof   StringBuilder== undefined
Object对象转JSON字符串
qq_43268322的博客
04-30 6968
/* Object转json字符串 */ JSON.stringify(Object) /* josn字符串转josn对象 */ JSON.parse(Object) var obj = str.parseJSON(); //由JSON字符串转换为JSON对象
将JSON字符串转换成Map对象的方法
10-21
//将json字符串转换成jsonObject JSONObject jsonObject = JSONObject.fromObject(object); Iterator<String> ite = jsonObject.keys(); //遍历jsonObject数据,添加到Map对象 while(ite.hasNext()){ String ...
在json字符串和c++对象之间进行转换。json字符串和c++结构体之间互相转换- xyz347 / x2struct
01-27
项目“x2struct”包含的主要功能是解析JSON字符串并将其内容映射到C++的结构体中，同时也可以将C++结构体转换回JSON字符串。这个过程通常被称为序列化和反序列化。序列化是将C++对象的状态转换为可存储或可传输的...
net.sf.json.JSONObject实现Object对象与Json字符串的互转
08-13
实现Object对象与Json字符串的互转"深入探讨了如何使用`JSONObject`来处理这种转换。 首先，我们需要了解`JSONObject`的基本用法。`JSONObject`可以从一个Java对象创建，也可以解析为一个JSON字符串。例如，我们有...
VBScript把json字符串解析成json对象的2个方法
09-04
在JScript中，我们可以使用`eval`函数将JSON字符串转化为JavaScript对象，如`parseJSON`函数所示。 2. **调用JScript函数**： 在VBScript中，创建一个变量`json`存储JSON字符串，然后调用`parseJSON`函数，将结果...
JsonObject（可将json字符串格式转化为json对象或数组）
01-23
顶部添加引用using Xfrog.Net; 用法如： JsonObject newObj1 = new JsonObject("json字符串"); String errorCode = newObj1["error_code"].Value;//获取其中的属性值。 string status = newObj1["result"]["status"].Value;
Java JSON与Object互转源代码
11-25
高效的JSON与Object互转的工具源代码，如果JSON数据未按该工具规定的数据格式转化成对象，将转化成java.util.Map实例。 （比JSON官方的API更适用。支持对象之间的多级引用，支持Map, List等集合。不需要引用其它中间对象。) 该代码通过两个简单的方法进行JSON数据与Java对象之间简单转化： 1. String jsonStr = JSONTool.convertObjectToJson(object); 2. Object obj = JSONTool.convertJsonToObject(jsonStr); 缺点：对于集合(Collection，非Map)类数据结构，不能在集合中包含其他集合对象,但是可以包含数组。
json字符串和object之间的相互转化
weixin_33827731的博客
06-25 65
package asi; import java.util.ArrayList; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONException; import com.alibaba.fastjson.JSONObject; public class TestJSONObject { pri...
Json字符串与Object对象相互转换
weixin_43690972的博客
11-13 216
Json-Lib、Org.Json、Jackson、Gson、FastJson五种方式转换json类型 只列举了最省事的方式。不涉及复制情况和速度。 测试用例，一个User类，属性name，age，location。重写toString()。 public class User { private String name; private Integer age; private String l...
Object与json字符串的相互转换
热门推荐
JustryDeng
06-23 10万+
第一步：引入fastjson的依赖jar包 注：maven项目，直接在pom.xml中进行配置即可。 注：如果引入此版本的依赖，导致项目不能启动(报错:找不到启动类);那么可以换一个版本的fastjson即可。 给出文字版： <!-- fastjson--> <dependency> <groupId>com.alibaba</...
Object转成JSONObject
oak_javaLearner的博客
02-01 2万+
Object转成JSONObject
如何将对象转换成json字符串，以json格式输出，并获取到其中的特定字段
qq_62414152的博客
04-12 3098
综上所述，这段代码的作用是：使用 Gson 库的 GsonBuilder 创建一个开启了美观打印模式的 Gson 实例，然后使用这个实例将 student 对象序列化为格式化的 JSON 字符串，并最终将该 JSON 字符串输出到控制台。这样做的目的是以易于阅读的格式显示 student 对象的 JSON 表示。“menu” 键对应的值是一个对象，其中 “popup” 键对应的值又是一个对象，而这个对象的 “menuitem” 键对应的值则是一个数组，数组中的每个元素都是一个描述菜单项的 JSON 对象。
object 转换成json字符串
最新发布
09-14
在编程中，将对象转换成JSON字符串是一个常见的操作，通常用于数据传输和存储。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。 以JavaScript为例，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值