json

最新推荐文章于 2022-08-27 12:06:04 发布

笨蛋悠米

最新推荐文章于 2022-08-27 12:06:04 发布

阅读量201

点赞数

本文链接：https://blog.csdn.net/weixin_46744534/article/details/107291683

版权

文章目录

- JSON

JSON

什么是JSON？

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。JSON采用完全独立于语言的文本格式，而且很多语言都提供了对 json 的支持（包括 C, C++, C#, Java, JavaScript, Perl, Python等）。这样就使得 JSON 成为理想的数据交换格式。

json 是一种轻量级的数据交换格式。

轻量级指的是跟 xml 做比较。

数据交换指的是客户端和服务器之间业务数据的传递格式。

JSON在js中的使用：

json 的定义

json 是由键值对组成，并且由花括号（大括号）包围。每个键由引号引起来，键和值之间使用冒号进行分隔，多组键值对之间进行逗号进行分隔。

json 定义示例：
可以为int，String，boolean，数组，json，json数组等类型

var jsonObj = {
    "key1":12,
    "key2":"abc",
    "key3":true,
    "key4":[11,"arr",false],
    "key5":{
        "key5_1" : 551,
        "key5_2" : "key5_2_value"
    },
    "key6":[{
        "key6_1_1":6611,
        "key6_1_2":"key6_1_2_value"
    },{
        "key6_2_1":6621,
        "key6_2_2":"key6_2_2_value"
    }]
};

json的访问

json 本身是一个对象。

json 中的 key 我们可以理解为是对象中的一个属性。

json 中的 key 访问就跟访问对象的属性一样： json 对象.key

json 访问示例：

alert(typeof(jsonObj));// object json 就是一个对象
alert(jsonObj.key1); //12
alert(jsonObj.key2); // abc
alert(jsonObj.key3); // true
alert(jsonObj.key4);// 得到数组[11,"arr",false]
// json 中 数组值的遍历
for(var i = 0; i < jsonObj.key4.length; i++) {
	alert(jsonObj.key4[i]);
}
alert(jsonObj.key5.key5_1);//551
alert(jsonObj.key5.key5_2);//key5_2_value
alert( jsonObj.key6 );// 得到 json 数组
// 取出来每一个元素都是 json 对象
var jsonItem = jsonObj.key6[0];
// alert( jsonItem.key6_1_1 ); //6611
alert( jsonItem.key6_1_2 ); //key6_1_2_value

json在前端的用法

json 在前端有两种形式。
一种是：对象的形式存在，我们叫它 json 对象。
一种是：字符串的形式存在，我们叫它 json 字符串。
一般我们要操作 json 中的数据的时候，需要 json 对象的格式。
一般我们要在客户端和服务器之间进行数据交换的时候，使用 json 字符串。

JSON.stringify()：把 json 对象转换成为 json 字符串
JSON.parse()：把 json 字符串转换成为 json 对象

示例代码：

// 把 json 对象转换成为 json 字符串
var jsonObjString = JSON.stringify(jsonObj); // 特别像 Java 中对象的 toString
alert(jsonObjString)
// 把 json 字符串。转换成为 json 对象
var jsonObj2 = JSON.parse(jsonObjString);
alert(jsonObj2.key1);// 12
alert(jsonObj2.key2);// abc

json在java中的应用

导包

有两种方式，而且各自实现的方式不一样（推荐使用方式四和二）

方式一： 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>

方式二：google的gson

<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.6</version>
</dependency>

方式三：jackson

 <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
 <dependency>
     <groupId>com.fasterxml.jackson.core</groupId>
     <artifactId>jackson-databind</artifactId>
     <version>2.12.1</version>
 </dependency>

方式四：alibaba的fastjson

 <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
 <dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>fastjson</artifactId>
     <version>1.2.75</version>
 </dependency>

json在java中的使用

javaBean 和 json 的互转

方式一：
使用JSONObject.fromObject（）方法，将一个java对象转换成json对象

    //把java对象转换成json字符串
    public void fa(){
        city c=new city();
        c.setEname("bj");
        c.setZname("北京");
        JSONObject o=JSONObject.fromObject(c);//json对象
        System.out.println(o);   //{"ename":"bj","zname":"北京"}
        String s=o.toString();//转换成String
        System.out.println(s);   //{"ename":"bj","zname":"北京"}
    }

json对象使用toBean(o,city.class)方法使用反射来转回成java对象

    //一个json对象转化成java对象   \为转义符  有了转义符就能识别"
    public void fb(){
        String s="{\"ename\":\"bj\",\"zname\":\"北京\"}";
        //先变成json
        JSONObject o=JSONObject.fromObject(s);
        System.out.println(o);   //{"ename":"bj","zname":"北京"}
        //反射，得对class    o.toBean(o,city.class)；以city.class的类的形式，去生成一个javaBean    默认都是object
        city c=(city)(o.toBean(o,city.class));
        System.out.println(c.getEname()+c.getZname());  //bj北京
    }

方式二：
使用toJson（）方法，将一个java对象转换成json对象
使用fromJson（）方法将json对象转回成java对象

    public void test1(){
        Person person = new Person(1,"国哥好帅!");
        // 创建 Gson 对象实例
        Gson gson = new Gson();
        // toJson 方法可以把 java 对象转换成为 json 字符串
        String personJsonString = gson.toJson(person);
        System.out.println(personJsonString);
        // fromJson 把 json 字符串转换回 Java 对象
        // 第一个参数是 json 字符串
        // 第二个参数是转换回去的 Java 对象类型
        Person person1 = gson.fromJson(personJsonString, Person.class);
        System.out.println(person1);
    }

方式三：将对象转换成json字符串

        ObjectMapper mapper=new ObjectMapper();
        User user=new User("yzl是人",15,"xml是猪");
        //list也是直接加
        String s = mapper.writeValueAsString(user);

方式四：各种互转

        List<User> userList=new ArrayList<User>();
        User user=new User("yzl是人",15,"xml是猪");
        User user1=new User("yzl是人",16,"xml是猪");
        User user2=new User("yzl是人",17,"xml是猪");
        User user3=new User("yzl是人",18,"xml是猪");
        userList.add(user);
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);

        System.out.println("*******Java对象 转 JSON字符串*******");
        String str1 = JSON.toJSONString(userList);
        System.out.println("JSON.toJSONString(list)==>"+str1);
        String str2 = JSON.toJSONString(user1);
        System.out.println("JSON.toJSONString(user1)==>"+str2);
        
        System.out.println("\n****** JSON字符串 转 Java对象*******");
        User jp_user1=JSON.parseObject(str2,User.class);
        System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);
        
        System.out.println("\n****** Java对象 转 JSON对象 ******");
        JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
        System.out.println("(JSONObject)JSON.toJSON(user2)==>"+jsonObject1.getString("name"));
        
        System.out.println("\n****** JSON对象 转 Java对象 ******");
        User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
        System.out.println("JSON.toJavaObject(jsonObject1,User.class)==>"+to_java_user);

List 和 json 的互转

方式一：
使用JSONArray.fromObject（）方法，将一个集合对象转换成json对象

    //java集合----json
    public void fc(){
        city c=new city();
        c.setEname("bj");
        c.setZname("beijing");
        city c1=new city();
        c1.setEname("nj");
        c1.setZname("nanjing");
        List<city> li=new ArrayList<>();
        li.add(c);
        li.add(c1);
        System.out.println(li);     //[model.city@78186a70, model.city@306279ee]
        //把集合转换成json对象
        JSONArray arr=JSONArray.fromObject(li);
        System.out.println(arr);    //[{"ename":"bj","zname":"beijing"},{"ename":"nj","zname":"nanjing"}]
        //如果以字符串的是形式来运用
        System.out.println("-------------");
        System.out.println(arr.toString());     //字符串的形式   [{"ename":"bj","zname":"beijing"},{"ename":"nj","zname":"nanjing"}]

    }

json对象使用toCollection(o,city.class)方法使用反射来转回成集合对象

    //json----java集合
    public  void fd()
    {
        //已知一个字符串，格式是json
        String str="[{\"ename\":\"bj\",\"zname\":\"beijing\"},{\"ename\":\"nj\",\"zname\":\"nanjing\"}]";
        JSONArray arr=JSONArray.fromObject(str);
        System.out.println(arr);  //[{"ename":"bj","zname":"beijing"},{"ename":"nj","zname":"nanjing"}]
        //需要java集合
        //arr.toCollection 按格式转换成集合（源数据，以反射的方式：city.class）
        //得到的默认是object集合，在强制类型转换
        List<city> cs=(List<city>)arr.toCollection(arr,city.class);
        for(city c:cs)
        {
            System.out.println(c.getEname()+" "+c.getZname());
            //bj beijing
			//nj nanjing
        }
    }

方式二：
使用toJson（）方法，将一个java对象转换成json对象
使用fromJson（）方法将json对象转回成java对象

转换回去的那里需要注意，因为需要实现一个TypeToken接口，但是专门实现又会产生很多类，所以使用匿名内部类来实现

    public void test2() {
        List<Person> personList = new ArrayList<>();
        personList.add(new Person(1, "国哥"));
        personList.add(new Person(2, "康师傅"));
        Gson gson = new Gson();
        // 把 List 转换为 json 字符串
        String personListJsonString = gson.toJson(personList);
        System.out.println(personListJsonString);
         List<Person> list = gson.fromJson(personListJsonString, new TypeToken<List<Person>>(){}.getType());
        System.out.println(list);
        Person person = list.get(0);
        System.out.println(person);
    }

map 和 json 的互转

方式二：
使用toJson（）方法，将一个java对象转换成json对象
使用fromJson（）方法将json对象转回成java对象

转换回去的那里需要注意，因为需要实现一个TypeToken接口，但是专门实现又会产生很多类，所以使用匿名内部类来实现

    public void test3(){
        Map<Integer,Person> personMap = new HashMap<>();
        personMap.put(1, new Person(1, "国哥好帅"));
        personMap.put(2, new Person(2, "康师傅也好帅"));
        Gson gson = new Gson();
        // 把 map 集合转换成为 json 字符串
        String personMapJsonString = gson.toJson(personMap);
        System.out.println(personMapJsonString);
        // Map<Integer,Person> personMap2 = gson.fromJson(personMapJsonString, new
        PersonMapType().getType());
        Map<Integer,Person> personMap2 = gson.fromJson(personMapJsonString, new
                TypeToken<HashMap<Integer,Person>>(){}.getType());
        System.out.println(personMap2);
        Person p = personMap2.get(1);
        System.out.println(p);
    }

ajax传输json（jquery实现）

ajax部分的核心代码：

    <script src="js/jquery-3.3.1.min.js"></script>
    <script type="text/javascript">
        //整个body加载完
        $(function () {
            //点击ta开始启动ajax
            $("#ta").click(function () {
                var x=$("#name").val();  //取id为name的值
                var y=$("#pwd").val();
                //ajax，发出去收回来
                var ha=$.ajax(
                    {
                        type:"POST",
                        url:"get.do",
                        data:{"name":x,"pwd":y},
                        //dataType指定json数据类型，也可不写
                        dataType:"json",       
                        async:false
                    }
                ).responseText;
                
                alert(ha);
                $("#aaa").html(ha);
            });
        });
    </script>