威尼斯人线上娱乐

出口到前者JSON的几种格局,JS对象与json字符串格式

1 4月 , 2019  

先是种:利用MODEL拼成要出口JSON的对象。再用JSON.NET转成JSON输出到前者(那种常用,就不举例了。)

  本文意在介绍若是由此C#将赢获得的XML文书档案转换到对应的JSON格式字符串,然后将其出口到页日前端,以供JavaScript代码解析采取。或然你能够直接使用JavaScript代码通过Ajax的法门来读取XML,然后径直对里面包车型大巴始末展开剖析,这样恐怕更直白一些。但本文中付出的代码目的在于认证什么通过原生的C#代码来成功那一转换。除了这么些之外,你照样能够借用一些第2方类库大概更高级部分的.NET库对象来推行转换。大家来看望那里介绍的有个别较为简单的措施,但前提是你必须持有可支撑的类库和目的以备使用。

威尼斯人线上娱乐 1威尼斯人线上娱乐 2


其次种:利用table拼成JSON数据格式,再用JSON.NET转成JSON输出到前端:

  • 使用Json.NET类库
 1 <head>
 2     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 3     <title></title>
 4     <script type="text/javascript">
 5         var obj = new Object();
 6         obj.Name = "八戒"
 7         obj.Age = 500;
 8 
 9         //通过字面量的形式来定义对象
10         var obj1 = { "Name": "八戒", "Age": "500" };
11         var arr = [{ "Name": "八戒", "Age": "500" }, { "Name": "八戒1", "Age": "1000" }];
12 
13         //JSON格式:将json的字面量表示形式,当做字符串存放,则为json格式字符串
14         var str = '{ "Name": "八戒", "Age": "500" }';
15         var jsonstrarr = '[{ "Name": "八戒", "Age": "500" }, { "Name": "八戒1", "Age": "1000" }];';
16         
17         //将json字符串转换成js对象(数组)
18         var resobj = JSON.parse(str);
19         alert(resobj.Name);
20 
21     </script>
22 </head>
23 <body>
24 </body>
25 </html>
  • tags:java,json,javascript
  • categories:笔记
  • date: 2016-11-16 20:18:52

          

  前提是亟需首先下载和设置Json.NET类库,在此间可以找到

jsobAndJson


  dt = new DataTable();

            dt.Columns.Add(new DataColumn("列头",typeof(string)));
            dt.Columns.Add(new DataColumn("object", typeof(object)));

            DataRow dr = dt.NewRow();
            dr[0] = "abc";

            DataTable dt2 = dt.Clone();
            dt2.Columns.Add("defaultdata", typeof(string));
            DataRow dr2 = dt2.NewRow();
            dr2[0] = "defgijk";
            dr2["defaultdata"] = "cccc";
            dt2.Rows.Add(dr2);

            dr[1] = dt2;

            dt.Rows.Add(dr);

            GridView1.DataSource = dt.Rows[0][1];
            GridView1.DataBind();

            Label1.Text = JsonConvert.SerializeObject(dt);

  上边是三个例证:

 在前端js对象和json对象的互转:

在平凡的开支中,在内外端的数据传输与拍卖中,总会境遇java与json的数量转换,javascript内json与string之间的转换等。所以就想总结看看那八个以内是哪些更换的,能够有这么些格局展开转移呢?那3J的变换也总会与string字符串类型有关,因为字符串在我们先后中简直无法再普遍了。o(≧v≦)o。。。所以呢,就打算用现实代码实例来探视它们是何许进展多少处理的,下一遍假设有那种近乎的急需,就能够长足把代码撸出来了,也是基础的标题。

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using Newtonsoft.Json;

namespace JSonConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            string xml = "<Test><Name>Test class</Name><X>100</X><Y>200</Y></Test>";

            XmlDocument doc = new XmlDocument();
            doc.LoadXml(xml);
            string json = Newtonsoft.Json.JsonConvert.SerializeXmlNode(doc);

            Console.WriteLine("XML -> JSON: {0}", json);
            Console.ReadLine();

        }
    }
}

1、JS对象转换到为JSON

威尼斯人线上娱乐 3

其三种:用JSON.net自带的JOBJECT,拼成JSON格式,转成JSON在前者输出:

  • 使用.NET
    Framework中的JavaScriptSerializer.aspx)类

拍卖:引用三个json二.js文书,调用JSON.stringify()方法。例如:var data =
new Object(); var json_data = JSON.stringify(data);

3j.png

出口到前者JSON的几种格局,JS对象与json字符串格式。    

  首先须求保证您的工程或服务器帮助.NET
4.0或上述版本的Framework,否则无法找到此类。

 

上边就依照当下本人的读书知识,计算以下它们各自之间的关联和转换进程。

JObject obj = new JObject();
    obj.Add(new JProperty("Status", "S"));
    obj.Add(new JProperty("TotalCount", totalCount));
    JArray array = new JArray();
    if (result != null)
    {
    foreach (var item in result)
    {    
    array.Add(
    new JObject(
    new JProperty("X", item.X)
    , new JProperty(" XX", item.XX)
    , new JProperty("XXX", item.XXX)
    , new JProperty("Xxxxx", item.XXXX)
    , new JProperty("xxxxxxx", item.XXXXX)
    , new JProperty("xxxxxxxxx", item.XXXXXX)
    , new JProperty("xxxxxxxxxxx", item.XXXXXXX)
    , new JProperty("xxxxxxxxxxxxx", item.XXXXXXXX)
    , new JProperty("xxxxxxxxxxxxxxxxx", item.XXXXXXXXX)
    , new JProperty("xxxxxxxxxxxxxxxxxxxx", item.XXXXXXXXXX)
    , new JProperty("xxxxxxxxxxxxxxxxxxxxxxx", item.XXXXXXXXXXX)));
    }
    obj.Add(new JProperty("WorkOrderManagerList", array));
    Response.Write(JsonConvert.SerializeObject(obj));

  上面是三个例证:

PS:json2.js以此文件在网上搜一下就能下载到。 

Java与Json

当中最要害也最长使用的就是后台的java与json数据的更换,包罗java
pojo转成json字符串,再通过response输出到浏览器前端页面实行渲染等其余处理,当然也有,以前端获取json格式字符串,到后台接收数据后,将字符串转换来bean或然聚众等等。所以,java与json转化的工具库也是挺多的,首要的归纳以下二种:杰克逊,法斯特json,谷歌-Gson,Json-lib。。等等,具体的能够参考该篇文章Java
的 JSON
开源类库选取比较

上面就说说根本运用的三种工具库把。。在此之前,把多少个类库必要动用的底蕴数据准备好,包含二个user,book五个bean。

public class User {

    private int id;
    private String userName;
    private String password;
    private int age;
    private String phoneNumber;
    private String address;
    private List<Books> lbooks;
//getter setter
...
}

public class Books {

    private String author;
    private String price;
    private String name;
//getter setter
...
}

结构的简要基础数据,那么些多少都以被上边三种库所共用的:

    public User user1;
    public User user2;
    public List<User> lusers = new ArrayList<User>();
    public List<Books> lbooks = new ArrayList<Books>(); 
    public Map<Integer,User> musers = new HashMap<Integer,User>();

    @Before
    public void init(){
        initUsers();
        lusers.add(user1);
        lusers.add(user2);
        musers.put(1, user1);
        musers.put(2, user2);
    }

    public void initUsers(){
    user1 = new User();
    user1.setId(1);
    user1.setUserName("heiOne");
    user1.setPassword("aa");
    user1.setPhoneNumber("1234");
    user1.setAge(20);
    user1.setAddress("CN.GZ");

    user2 = new User();
    user2.setId(2);
    user2.setUserName("heiTwo");
    user2.setPassword("bb");
    user2.setPhoneNumber("56789");
    user2.setAge(30);
    user2.setAddress("CN.SH");

    Books b1 = new Books();
    b1.setAuthor("泰戈尔");
    b1.setPrice("50.00");
    b1.setName("飞鸟集");
    Books b2 = new Books();
    b2.setAuthor("司汤达");
    b2.setPrice("40.00");
    b2.setName("红与黑");

    Books b3 = new Books();
    b3.setAuthor("塞林格");
    b3.setPrice("30.00");
    b3.setName("麦田里的守望者");
    lbooks.add(b1);
    lbooks.add(b2);
    List<Books> cbooks = new ArrayList<Books>();
    cbooks.addAll(lbooks);
    user1.setLbooks(lbooks);
    cbooks.add(b3);
    user2.setLbooks(cbooks);
    }

其间,User中包蕴Books的集合属性,为了测试复合结构的数额集合。

  • Jackson:
    杰克json工具库功效挺强大的,能够读取文件流获取字节码来处理json字符串,也能对树模型操作,提供了api总有有关节点的创设操作。当然了,也能处理与java对象的双向转换。那点实在能够从Jackson的maven库配置的artifactId能够见见,提供相应的不如模块成效的拍卖。

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.8.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.8.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.jaxrs/jackson-jaxrs-base -->
        <dependency>
            <groupId>com.fasterxml.jackson.jaxrs</groupId>
            <artifactId>jackson-jaxrs-base</artifactId>
            <version>2.8.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.jaxrs/jackson-jaxrs-json-provider -->
        <dependency>
            <groupId>com.fasterxml.jackson.jaxrs</groupId>
            <artifactId>jackson-jaxrs-json-provider</artifactId>
            <version>2.8.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.8.0</version>
        </dependency>

上面通过编制的一个测试用例类JavaAndJsonWith杰克逊.java来探视具体的操作。对于功用性较强的Jackson,大家只是关切它的java与json之间转换的一部分,它的骨干类正是ObjectMapper,有趣味学习更多内容的能够活动度娘。(然而话说连jackson官网都被xx了,汗…)

看来,借使java类型想要转成json格式字符串,就用writeValueAsString等格式方法;倘若json字符串要转成java类型对象,则选择readValue方法。
Java POJO与Json之间的转移:
对于java数据转成json,大多都以writeValue*连锁的法门。那种也是最简易基础的用法啦…

    @Test
    public void javaPojoPointToJsonStr() throws Exception{
     ObjectMapper om = new ObjectMapper();
     //java pojo转换成json字符串
     String ustr = om.writeValueAsString(user1);
     System.out.println("java user pojo 转换成json字符串:"+ ustr);

     //json 字符串转成java pojo
     User jsonUser = om.readValue(ustr, User.class);
     System.out.println("user json 字符串转成User.class pojo"+jsonUser);
    }

//输出:可以在www.bejson.com在线格式化校验json字符串
java user pojo 转换成json字符串:
{
    "id": 1,
    "userName": "heiOne",
    "password": "aa",
    "age": 20,
    "phoneNumber": "1234",
    "address": "CN.GZ",
    "lbooks": [
        {
            "author": "泰戈尔",
            "price": "50.00",
            "name": "飞鸟集"
        },
        {
            "author": "司汤达",
            "price": "40.00",
            "name": "红与黑"
        }
    ]
}
user json 字符串转成User.class pojo:(输出格式是通过toString定义的)
User.class pojoUser 
[id=1, userName=heiOne, password=aa, age=20, phoneNumber=1234, address=CN.GZ, 
lbooks=[Books [author=泰戈尔, price=50.00, name=飞鸟集], 
Books [author=司汤达, price=40.00, name=红与黑]]]

Java List集合与Json之间的转换:
实际上也都大约,只是当json字符串转成java
list集合时候,每一种list内的数据类型是:LinkedHashMap,然后能够透过key,value情势取出各样数据。

    @Test
    public void javaListPointToJsonStr() throws Exception{
        ObjectMapper om = new ObjectMapper();

        //java list转换成json字符串
        String listStr = om.writeValueAsString(lusers);
        System.out.println("java list集合转换为json字符串:"+listStr);

        //list形式json字符串转换成java list. List<User>不可转
        List uList = om.readValue(listStr, List.class);
        System.out.println("list json 转换成java list集合:"+uList);
        for(int i=0;i<uList.size();i++){
//          System.out.println(uList.get(i).getClass()); //LinkedHashMap
            LinkedHashMap lhm = (LinkedHashMap) uList.get(i);
            System.out.println(lhm.get("userName"));
            System.out.println(lhm.get("lbooks"));
        }
    }

//输出:
[
    {
        "id": 1,
        "userName": "heiOne",
        "password": "aa",
        "age": 20,
        "phoneNumber": "1234",
        "address": "CN.GZ",
        "lbooks": [
            {
                "author": "泰戈尔",
                "price": "50.00",
                "name": "飞鸟集"
            },
            {
                "author": "司汤达",
                "price": "40.00",
                "name": "红与黑"
            }
        ]
    },
    {
        "id": 2,
        "userName": "heiTwo",
        "password": "bb",
        "age": 30,
        "phoneNumber": "56789",
        "address": "CN.SH",
        "lbooks": [
            {
                "author": "泰戈尔",
                "price": "50.00",
                "name": "飞鸟集"
            },
            {
                "author": "司汤达",
                "price": "40.00",
                "name": "红与黑"
            },
            {
                "author": "塞林格",
                "price": "30.00",
                "name": "麦田里的守望者"
            }
        ]
    }
]

heiOne
[{author=泰戈尔, price=50.00, name=飞鸟集}, {author=司汤达, price=40.00, name=红与黑}]
heiTwo
[{author=泰戈尔, price=50.00, name=飞鸟集}, {author=司汤达, price=40.00, name=红与黑}, 
{author=塞林格, price=30.00, name=麦田里的守望者}]

Java Map集合与Json之间的转换:
行使办法和出口都与list集合大约,就不在多说了。

    @Test
    public void javaMapPointToJsonStr()throws Exception{
        ObjectMapper om = new ObjectMapper();
        //java map ---> json
        String mapStr = om.writeValueAsString(musers);
        System.out.println("java map集合转换为json字符串:"+mapStr);

        //map json --> java map
        Map umap = om.readValue(mapStr, Map.class);
        System.out.println("map json 转换为java map:"+umap);
//      System.out.println(umap.get("1").getClass());
        for(int i=1;i<=umap.size();i++){
            LinkedHashMap lhm = (LinkedHashMap) umap.get(String.valueOf(i));
            System.out.println(lhm.get("userName"));
            System.out.println(lhm.get("lbooks"));
        }

    }

  • FastJson:
    上边那个就是Ali的fastjson啦,感觉也挺强大和易用的,重假诺透过com.alibaba.fastjson.JSON对象举行转移。
    万一java类型转成json格式字符串,能够采纳toJSONString办法,反之,可以应用parseObject或者parseArray等措施。想询问越多,能够查阅fastjson的github项目

那边的例子输出可以参考jackson的test测试用例。那里多说一点,fastjson在出口字符串的时候,借使数据一致则会油然则生$ref引用符号出现,在测试的时候,发现只要将富含那几个引用符号的json字符串转换到java类型对象汇合世null值的现象。
maven库配置:

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.13</version>
        </dependency>

Java POJO与Json之间的转移:

    @Test
    public void javaPojoPointToJsonStr() throws Exception{
     //java pojo转换成json字符串
     String ustr = JSON.toJSONString(user1);
     System.out.println("java user pojo 转换成json字符串:"+ ustr);
//     
     //json 字符串转成java pojo
     User jsonUser = JSON.parseObject(ustr,User.class);
     System.out.println("user json 字符串转成User.class pojo"+jsonUser);
    }

Java List集合与Json之间的变换:

    @Test
    public void javaListPointToJsonStr() throws Exception{

//      java list转换成json字符串
        String listStr = JSON.toJSONString(lusers);
        System.out.println("java list集合转换为json字符串:"+listStr);

//      list形式json字符串转换成java list. JSON.parseObject
        List uList = JSON.parseObject(listStr, List.class);
        System.out.println("list json 转换成java list集合:"+uList);
        for(int i=0;i<uList.size();i++){
//          System.out.println(uList.get(i).getClass());//JSONObject
            JSONObject jo = (JSONObject) uList.get(i);
//          System.out.println(jo.size());
            System.out.println(jo.get("userName"));
            System.out.println(jo.get("lbooks"));
        }

        //JSON.parseArray
        List<User> uList1 = JSON.parseArray(listStr, User.class);
        System.out.println(uList1);
        for(User u : uList1){
            System.out.println(u.getUserName());
        }
    }

Java Map集合与Json之间的转移:

    @Test
    public void javaMapPointToJsonStr()throws Exception{
//      //java map ---> json
        String mapStr = JSON.toJSONString(musers);
        System.out.println("java map集合转换为json字符串:"+mapStr);
//      
        //map json --> java map
        //http://blog.csdn.net/weixiaodedao/article/details/51790790  解决使用fastJson中出现$ref问题
        JSONObject umap = JSON.parseObject(mapStr); //引用$ref,null
        System.out.println("map json 转换为java map:"+umap);
//      System.out.println(umap.get("1").getClass());
        for(int i=1;i<=umap.size();i++){
            JSONObject obj = (JSONObject) umap.get(String.valueOf(i)); //com.alibaba.fastjson.JSONObject
            System.out.println(obj.get("userName"));

        }

    }

  • JSON-lib:
    要是要转换来json格式字符串能够应用JSONObject.fromObject或者JSONArray.fromObject措施;假如要转换来集合或然java
    bean则能够运用那几个主意JSONArray.toList(已废弃)或者JSONArray.toArray,至于map的转移,能够要本人来抽取当中数据达成调整了。

maven库配置:

        <!-- https://mvnrepository.com/artifact/net.sf.json-lib/json-lib -->
        <dependency>    
             <groupId>net.sf.json-lib</groupId>    
             <artifactId>json-lib</artifactId>    
            <version>2.4</version>    
            <classifier>jdk15</classifier>    
        </dependency>  

Java POJO与Json之间的转移:

    //http://ryxxlong.iteye.com/blog/583862  json-lib使用方法
    @Test
    public void javaPojoPointToJsonStr() throws Exception{
     //java pojo转换成json字符串,都是先转换成JSONObject对象
     JSONObject jsonObject = JSONObject.fromObject(user1);
     String ustr = jsonObject.toString();
     System.out.println("java user pojo 转换成json字符串:"+ ustr);

//     json 字符串转成java pojo
     User jsonUser = (User) JSONObject.toBean(jsonObject, User.class);
     System.out.println("user json 字符串转成User.class pojo"+jsonUser);
    }

Java List集合与Json之间的变换:

    @Test
    public void javaListAndArrayPointToJsonStr() throws Exception{

//      java list转换成json字符串
        JSONArray jsonArray = JSONArray.fromObject(lusers);
        String listStr = jsonArray.toString();
        System.out.println("java list集合转换为json字符串:"+listStr);

//      list形式json字符串转换成java list. 
//      List<User> uList = JSONArray.toList(jsonArray, User.class); //toList已被废弃
        User[] array = (User[]) JSONArray.toArray(jsonArray, User.class);
//      System.out.println("list"+uList);
        System.out.println("array:"+array);

        //JSON.parseArray
//      for(User u : uList){
//          System.out.println(u.getUserName());
//      }
        for(int i=0;i<array.length;i++){
            System.out.println(array[i].getUserName());
        }
    }

Java Map集合与Json之间的转移:
倘诺想看看更细节的map与json转换,能够参照那篇小说:<u>采用json-lib进行Map与Json转换</u>

    @Test
    public void javaMapPointToJsonStr()throws Exception{
//      //java map ---> json 这里map<key,value>中必须为string类型
        Map<String,String> tmp = new HashMap<String,String>();
        tmp.put("one", "apple");
        tmp.put("two", "hehe");
        JSONObject ja= JSONObject.fromObject(tmp);
        System.out.println("java map集合转换为json字符串:"+ja.toString());//{"two":"hehe","one":"apple"}

        Map<String,Map<String,String>> mmtmp = new HashMap<String,Map<String,String>>();
        Map<String,String> mtmp = new HashMap<String,String>();
        mtmp.put("inner", "test");
        mmtmp.put("a", mtmp);
        mmtmp.put("b", mtmp);
        JSONArray jsonArray= JSONArray.fromObject(mmtmp);
        System.out.println("java map集合转换为json字符串:"+jsonArray.toString());//[{"b":{"inner":"test"},"a":{"inner":"test"}}]
//      
        //更多使用JSON-LIB 对map与json转换可以参考该片文章:https://my.oschina.net/heweipo/blog/386808       
    }

至于java与json数据的骨干转移常用工具使用方法就写到那,当然这几个都以基础内容,在项目支出中,实则能够团结在包装工具类对急需的事情拓展处理。

 

using System;
using System.Linq;
using System.Web.Script.Serialization;
using System.Xml.Linq;

class Program
{
    static void Main()
    {
        var xml = 
        @"<Columns>
          <Column Name=""key1"" DataType=""Boolean"">True</Column>
          <Column Name=""key2"" DataType=""String"">Hello World</Column>
          <Column Name=""key3"" DataType=""Integer"">999</Column>
        </Columns>";
        var dic = XDocument
            .Parse(xml)
            .Descendants("Column")
            .ToDictionary(
                c => c.Attribute("Name").Value, 
                c => c.Value
            );
        var json = new JavaScriptSerializer().Serialize(dic);
        Console.WriteLine(json);
    }
}

2、JSON转换到为JS

Json与Javascript

除外java与json之间须求更换,平时在付出web项目时候,从后端获得的json字符串在前者处理总会要转移成json对象的须要,反之亦然。所以,来看看在前者页面中的script脚本中是何许处理json数据的?

实际上,javascript原生的就有对json数据转换的格局。总的来说,在前者页面包车型地铁script脚本中:json字符串想更换到json对象,能够动用
eval('(' + jsonstr + ')')办法;json对象要转换到string字符串则足以应用JSON.stringify(jsonObject)方法。

上边看看后端输出json字符串到前端后,前端如何处理json字符串的:

  • 后端java代码:使用jackson来将list集合转换来json字符串输出:

    public List<User> lusers = new ArrayList<User>();

    @RequestMapping(value="/jj.do",method=RequestMethod.GET)
    public String toJJPage(HttpServletRequest request) throws Exception{
        if(lusers.size()<1)
        initData();
        ObjectMapper om = new ObjectMapper();

        //java list转换成json字符串
        String listStr = om.writeValueAsString(lusers);
        System.out.println("java list集合转换为json字符串:"+listStr);
        request.setAttribute("lusers", listStr);
        return "js_json";
    }
  • 在看使用springmvc将页面跳转到js_威尼斯人线上娱乐 ,json.jsp中:
    能够看到,将后端中的request域中的lusers天性输出是壹串json格式字符串,然后在script脚本中使用办法eval(‘(‘+str+’)’),JSON.stringify方法将json字符串和json对象相互转换。

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
Object listUser = request.getAttribute("lusers");
%>
<!DOCTYPE html>
<html>
  <head>
    <base href="<%=basePath%>">
    <title>Javascript-json</title>
  </head>

  <body>
    List user: <%=listUser%>
    <script type="text/javascript">
     var luser = '<%=listUser%>'; 
     alert(luser+':'+typeof(luser));    //string
     //JSON字符串转换为JSON对象
     var json = eval('(' + luser + ')'); //可用
     var json = JSON.parse(luser);
     alert(json+':'+typeof(json));
     alert(json[0].userName);
     //将json对象转换为json格式字符串
     var userJson = JSON.stringify(json);   //ok
     alert('json object --> json string:'+userJson);
    </script>
  </body>
</html>

 第七种:利用array数组和hashtable拼成JSON格式,转成JSON在前端输出:

  其出口结果为:{"key1":"True","key2":"Hello World","key3":"999"}

一.拍卖:用jQuery的三个措施$.parseJSON()将JSON格式的多寡转成JS对象。例如:var
json_data = $.getJSON(); var data = $.parseJSON(json_data);
(可用来成转换js数组)

Java与Javascript

咳咳…那些便是最简便易行了。平日须要将java对象转换来javascript对象时候,一般就是在前端页面中,例如jsp等。在<% %>中得以定义可能java代码对象,能够通过<%=variable %>表明式能够博得java对象。结合这么些特点,那么要在script脚本中运用java对象,只须求用多个'单引号将java对象引起来即可赋值给javascript变量。

能够参照上边json与javascript转换中的jsp页面中就有应用:

 <script type="text/javascript">
     var luser = '<%=listUser%>';  //将java对象赋值给javascript变量
     alert(luser+':'+typeof(luser));    //string
    </script>

ok,总计得差不多了,日后有能够全面的在整合啦…( ̄▽ ̄)~*

参考:
Java 的 JSON
开源类库采用比较
JS操作JSON总结

    

  只怕还会有更多的方法,那里不一1列出了。那么如何使用原生的C#代码将XML转换来JSON格式字符串呢?恐怕说该C#代码在较低版本的.NET
Framework中也得以运转吧?来看看下边包车型大巴牵线吧。

2.将json转换到js对象的方法:var json = eval(‘(‘ + result + ‘)’); 

 ArrayList eventList = new ArrayList();

     Hashtable hx = new Hashtable();
     hx.Add("eventid", 1);
          hx.Add("eventname", "圣诞节");
       hx.Add("eventdate", "2018-08-25");
       hx.Add("eventlocation", "公司会议中心");

       for (int i = 0; i < 3; i++)
      {
      Hashtable ht = new Hashtable();
      ht.Add("eventid", i + 1);
      ht.Add("eventname", "圣诞节");
      ht.Add("eventdate", hx);
      ht.Add("eventlocation", "公司会议中心");
      eventList.Add(ht);
     }
    JavaScriptSerializer ser = new JavaScriptSerializer();
    String jsonStr = ser.Serialize(eventList);
    Response.Write(jsonStr);

Introduction

透过地点那些表达式,就做到了将服务器端响应给客户端的Json格式的字符串解析成了三个Json(格式的)对象,名为“json”,通过“json.”或然“json[]”的格局便可进展多少访问。

 

  JSON是二个轻量级的数据交流格式,它能够分外不难地被页面包车型地铁JavaScript编码为指标的样式,从而便利数据操作。

 

  基于AJAX的页面使用XmlHttpRequest目的从服务端接收数据来响应用户的央浼,当再次来到的数额是XML格式时,它能够被转换为JSON格式的字符串从而通过JavaScript越发不难地对数码进行拍卖。

在后台对js对象和json对象的互转:

  许多应用程序都将数据存款和储蓄为XML的格式,而且会将数据以JSON的格式发送到客户端以做进一步处理。要落实那点,它们必须将XML格式转换为JSON格式。下边包车型地铁ASP.NET
C#代码达成了那一进度。

 

Code Description

 .NET Framework
4在System.Runtime.Serialization中。利用JavaScriptSerializer类对数据举行种类化和反序列化

  代码中提供了三个格局XmlToJSON,能够用来将XmlDocument指标转换为JSON字符串。代码通过迭代每贰个XML节点、属性以及子节点,来创设对应的JSON对象。

栗子:

  • 代码不会变卦数字和布尔类型的值
  • Xml
    DocumentElement对象始终会被转移为JSON对象的member:object,它遵守下边这几个规则。
  • 节点的习性会被对应地转移为JSON对象的分子”attr_name”:”attr_value”。如:

    XML JSON
    <xx yy=’nn’></xx> { "xx" : { "yy" : "nn" } }
    <xx yy=”></xx> { "xx" : { "yy" : "" } }
  • 一直不子节点、属性和情节的节点被转移为成员”child_name”:null

    XML JSON
    <xx/> { "xx" : null }
  • 未曾子舆节点和质量,不过有内容的节点被转移为成员”child_name”:”child_text”

    XML JSON
    <xx>yyy</xx> { "xx" : "yyy" }
  • 别的节点和属性会被恰本地转移为”child_name”:对象大概”child_name”:[elements]对象数组,节点的值会被转换为目标成员的”value”,如:

    XML JSON
    <xx yy=’nn’><mm>zzz</mm></xx> { "xx" : { "yy" : "nn", "mm" : "zzz" } }
    <xx yy=’nn’><mm>zzz</mm><mm>aaa</mm></xx> { "xx" : { "yy" : "nn", "mm" : [ "zzz", "aaa" ] } }
    <xx><mm>zzz</mm>some text</xx> { "xx" : { "mm" : "zzz", "value" : "some text" } }
    <xx value=’yyy’>some text<mm>zzz</mm>more text</xx> { "xx" : { "mm" : "zzz", "value" : [ "yyy", "some text", "more text" ] } }
  • 字符会被辽阳地转换为JSON字符串。注意该转换不会确认保证你的JavaScript代码不会师临其余注入攻击,假诺内部的始末出自于1段不安全的XML数据源的话。下边那几个例子演示了字符的转义:

    XML JSON
    <aa>/z’z”z\yyy</aa> { "aa" : "\/z\u0027z\”z\\yyy" }
//将param反序列列list集合
List<ApplyPart> _ApplyPart = new JavaScriptSerializer().Deserialize<List<ApplyPart>>(param);

  
在少数特殊的环境下,例如上边包车型大巴代码,可能必要您自身对反斜线开始展览转义。

  

string JSON = XmlToJSON(doc);
JSON = JSON.Replace(@"\", @"\\");

 

  注意,在页面上运用其它未经济检察查的XML数据时都会设有安全隐患。

Example

XML输入:

<space name="Cake Collage">
<frame>
  <photo img="cakecollage1.jpg" />
  <text string="Browse my cake space" />
  <rule type="F" img="cakecollage9.jpg" x="150" y="0" w="300" h="250" />
  <rule type="F" img="cakecollage2.jpg" x="0" y="0" w="150" h="220" />
</frame>
<frame>
  <photo img="cakecollage2.jpg" />
  <rule type="B" img="cakecollage1.jpg" />
  <rule type="L" img="cakecollage3.jpg" />
</frame>
</space>

JSON输出(对代码举行了格式化):

{ "space":
  { "name": "Cake Collage",
    "frame": [ {"photo": { "img": "cakecollage1.jpg" },
                "rule": [ { "type": "F",
                            "img": "cakecollage9.jpg",
                            "x": "150",
                            "y": "0",
                            "w": "300",
                            "h": "250"
                          }, 
                          { "type": "F",
                            "img": "cakecollage2.jpg",
                            "x": "0",  
                            "y": "0",  
                            "w": "150",  
                            "h": "220" 
                          }
                        ],
                "text": { "string": "Browse my cake space" }
               },
               {"photo": { "img": "cakecollage2.jpg" },
                "rule": [ { "type": "B", "img": "cakecollage1.jpg" },
                          { "type": "L",  "img": "cakecollage3.jpg" }
                        ]
               }
             ]
  }
}

  一旦JSON字符串被定义为二个JavaScript对象,如space_DOM,大家便得以在JavaScript代码中使用下边这几个指标和性情:

  • space_DOM.space.name
  • space_DOM.space.frame.length
  • space_DOM.space.frame[0].text.string
  • space_DOM.space.frame[0].rule[0].type

  你的JavaScript代码应该能够非凡灵活地答应种种气象,如成员不设有、成员只包罗value、或成员是三个数组。上面那几个函数能够将装有的积极分子转换来2个数组,从而回答各个不相同的气象。

function ObjectToArray( obj)
{
    if( !obj) return new Array();
    if( !obj.length) return new Array(obj);
    return obj;
}

space_DOM.space.frame = ObjectToArray(space_DOM.space.frame);

XmlToJSON C# code

  下边给出对应的C#源代码,通过传播的XmlDocument目的将其转移为对应的JSON格式字符串。

private static string XmlToJSON(XmlDocument xmlDoc)
{
    StringBuilder sbJSON = new StringBuilder();
    sbJSON.Append("{ ");
    XmlToJSONnode(sbJSON, xmlDoc.DocumentElement, true);
    sbJSON.Append("}");
    return sbJSON.ToString();
}

//  XmlToJSONnode:  Output an XmlElement, possibly as part of a higher array
private static void XmlToJSONnode(StringBuilder sbJSON, XmlElement node, bool showNodeName)
{
    if (showNodeName)
        sbJSON.Append("\"" + SafeJSON(node.Name) + "\": ");
    sbJSON.Append("{");
    // Build a sorted list of key-value pairs
    //  where   key is case-sensitive nodeName
    //          value is an ArrayList of string or XmlElement
    //  so that we know whether the nodeName is an array or not.
    SortedList childNodeNames = new SortedList();

    //  Add in all node attributes
    if( node.Attributes!=null)
        foreach (XmlAttribute attr in node.Attributes)
            StoreChildNode(childNodeNames,attr.Name,attr.InnerText);

    //  Add in all nodes
    foreach (XmlNode cnode in node.ChildNodes)
    {
        if (cnode is XmlText)
            StoreChildNode(childNodeNames, "value", cnode.InnerText);
        else if (cnode is XmlElement)
            StoreChildNode(childNodeNames, cnode.Name, cnode);
    }

    // Now output all stored info
    foreach (string childname in childNodeNames.Keys)
    {
        ArrayList alChild = (ArrayList)childNodeNames[childname];
        if (alChild.Count == 1)
            OutputNode(childname, alChild[0], sbJSON, true);
        else
        {
            sbJSON.Append(" \"" + SafeJSON(childname) + "\": [ ");
            foreach (object Child in alChild)
                OutputNode(childname, Child, sbJSON, false);
            sbJSON.Remove(sbJSON.Length - 2, 2);
            sbJSON.Append(" ], ");
        }
    }
    sbJSON.Remove(sbJSON.Length - 2, 2);
    sbJSON.Append(" }");
}

//  StoreChildNode: Store data associated with each nodeName
//                  so that we know whether the nodeName is an array or not.
private static void StoreChildNode(SortedList childNodeNames, string nodeName, object nodeValue)
{
    // Pre-process contraction of XmlElement-s
    if (nodeValue is XmlElement)
    {
        // Convert  <aa></aa> into "aa":null
        //          <aa>xx</aa> into "aa":"xx"
        XmlNode cnode = (XmlNode)nodeValue;
        if( cnode.Attributes.Count == 0)
        {
            XmlNodeList children = cnode.ChildNodes;
            if( children.Count==0)
                nodeValue = null;
            else if (children.Count == 1 && (children[0] is XmlText))
                nodeValue = ((XmlText)(children[0])).InnerText;
        }
    }
    // Add nodeValue to ArrayList associated with each nodeName
    // If nodeName doesn't exist then add it
    object oValuesAL = childNodeNames[nodeName];
    ArrayList ValuesAL;
    if (oValuesAL == null)
    {
        ValuesAL = new ArrayList();
        childNodeNames[nodeName] = ValuesAL;
    }
    else
        ValuesAL = (ArrayList)oValuesAL;
    ValuesAL.Add(nodeValue);
}

private static void OutputNode(string childname, object alChild, StringBuilder sbJSON, bool showNodeName)
{
    if (alChild == null)
    {
        if (showNodeName)
            sbJSON.Append("\"" + SafeJSON(childname) + "\": ");
        sbJSON.Append("null");
    }
    else if (alChild is string)
    {
        if (showNodeName)
            sbJSON.Append("\"" + SafeJSON(childname) + "\": ");
        string sChild = (string)alChild;
        sChild = sChild.Trim();
        sbJSON.Append("\"" + SafeJSON(sChild) + "\"");
    }
    else
        XmlToJSONnode(sbJSON, (XmlElement)alChild, showNodeName);
    sbJSON.Append(", ");
}

// Make a string safe for JSON
private static string SafeJSON(string sIn)
{
    StringBuilder sbOut = new StringBuilder(sIn.Length);
    foreach (char ch in sIn)
    {
        if (Char.IsControl(ch) || ch == '\'')
        {
            int ich = (int)ch;
            sbOut.Append(@"\u" + ich.ToString("x4"));
            continue;
        }
        else if (ch == '\"' || ch == '\\' || ch == '/')
        {
            sbOut.Append('\\');
        }
        sbOut.Append(ch);
    }
    return sbOut.ToString();
}

Using XmlToJSON

  下边包车型地铁代码演示了怎么在ASP.NET
二的页面中选拔XmlToJSON()格局。页面上运用了ClientScriptManager对象来作为JavaScript代码的容器。当然,你完全能够动用别的任何格局将所更换的JSON字符串放到前端页面上。通过下边的代码,程序在前者页面上调用3个名叫space_processJSON的JavaScript函数,并将JSON字符串作为参数字传送递给它。

protected void Page_Load(object sender, EventArgs e)
{
    XmlDocument doc = new XmlDocument();
    try
    {
        string path = Server.MapPath(".");
        doc.Load(path+"whatever.xml");
    }
    catch (Exception ex)
    {
        lblError.Text = ex.ToString();
        return;
    }

    // Convert XML to a JSON string
    string JSON = XmlToJSON(doc);

    // Replace \ with \\ because string is being decoded twice
    JSON = JSON.Replace(@"\", @"\\");

    // Insert code to process JSON at end of page
    ClientScriptManager cs = Page.ClientScript;
    cs.RegisterStartupScript(GetType(), "SpaceJSON", "space_processJSON('" + JSON + "');", true);
}

  来探望前端页面上定义的那些JavaScript函数的具体内容。

<script src="space/json.js" type="text/javascript"></script>

<script type="text/javascript">
function space_processJSON( JSON)
{
    space_DOM = JSON.parseJSON();
    if( !space_DOM)
    {
        alert("JSON decode error");
        return;
    }
    space_DOM.space.frame = ObjectToArray(space_DOM.space.frame);
    space_frameCount = space_DOM.space.frame.length;
    //.. or whatever
}
</script>

  原版的书文出处:《How to convert XML to JSON in ASP.NET
C#》


相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图