精华内容
下载资源
问答
  • axios向springboot后台传递json数据
    千次阅读
    2022-04-17 12:28:21

    小白遇坑

    刚开始我是用get方法来传递json数据,但是总是报错:Required request body is missing,我人傻了,对着这个错误百度了半天,才发现,原来axios get请求方式传递给后台的参数都是字符串形式,无法传递json对象或数组对象等,犯了这么低级的错误,实在是惭愧!

    axios post方式传递json数据

    1. 首先安装axios
    npm run dev
    
    1. 在main.js中引入axios
    import axios from 'axios' //引入
    Vue.prototype.$axios=axios //定义为全局
    
    1. 在需要传值的地方使用以下代码
    this.$axios({
                      url:'http://localhost:8087/creatClusterAndNodes', //此处是你向后端发送数据的地址,根据你自己的地址进行修改
                      data:this.formdata, //此处是要传递的json数据,根据你的参数进行修改
                      method:"POST",  //设置为POST请求
                      header:{
                        'Content-Type':'application/json' //规定传递的参数格式为json
                      }
                    })
                      .then(res=>{
                        console.log(res.data)
                      })
                      .catch(Error=>{
                        console.log(Error)
                      })
    
    1. 后台接收参数
     @RequestMapping(value = "/creatClusterAndNodes", method = RequestMethod.POST, produces = "application/json;charset=UTF-8") //这里的method要设置为RequestMethod.POST
        public String creatClusterAndNodes(@RequestBody JSONObject jsonParam) {
            System.out.println("jsonParam:"+jsonParam);
            return "okk";
        }
    
    更多相关内容
  • json数据

    千次阅读 2021-07-13 10:28:01
    Android中关于json数据,相当于键值对 1.生成json数据 {"type":"Point", "coordinates":[ 533958.52189999819, 3123489.1460000016 ] } 可以看到上面的type和coordinates分别是json的对象结构和数据结构 ...

    json数据包括JSONObject和JSONArray。

    即json包括json对象和json数组,json对象中有2种数据结构,对象结构和数组结构。

    JSONObject的数据格式:{“名称”:“值”,“名称”:[数组],……}

    JSONArray的数据格式:[{“名称”:“值”},{“名称”:[数组]},{“名称”:“值”},……]
    JSONArray中包含1个或多个JSONObject

    json数据,相当于键值对,下面我们来看一个复杂的json数据

    {
        "features":[
            {
                "id":1,
                "geometry":{
                    "type":"Point",
                    "coordinates":[
                        533958.52189999819,
                        3123489.1460000016
                    ]
                }
            },
           {
                "id":1,
                "geometry":{
                    "type":"Point",
                    "coordinates":[
                        533958.52189999819,
                        3123489.1460000016
                    ]
                }
            },
        ]
    }

    关于java处理json的框架库有Jackson,Gson和FastJson等,我目前只用过fastjson库,Jackson是SpringBoot默认的json解析,听说Gson功能上好,FastJson不建议生产使用,也听过Gson和FastJson两种并行使用。

    下面的代码我们用的是fastjson库,Fastjson是一个Java语言编写的JSON处理器,由阿里巴巴公司开发。fastjson是目前java语言中最快的json库,比自称最快的jackson速度要快。

    一.生成json数据

    1.通过原生生成json数据

    //json对象
    JSONObject j1 = new JSONObject();
    j1.put("type", "Point");    //对象结构
    j1.put("coordinates", new double[]{533958.52189999819, 3123489.1460000016});//数组结构
    
    //json数组
    JSONArray jsonArray1 = new JSONArray();
    jsonArray1.add(j1);

    2.json字符串生成json数据

    //生成json对象
    String stuString = "{\"id\":1,\"age\":2,\"name\":\"zhang\"}";//引号需要转义字符
    JSONObject jsonObject1 = JSON.parseObject(stuString);
    
    //生成json数组
    String stuString2 = "[{\"id\":1,\"age\":2,\"name\":\"zhang\"}]";//引号需要转义字符
    JSONArray jsonArray1 = JSON.parseArray(stuString2);
    
    //上面的JSON换成JSONObject或者JSONArray都可以因为parseObject方法和parseArray方法在JSON中,而JSONObject和JSONArray都继承自JSON
    

    3.json字符串生成对应的类

    Student stu1= JSON.parseObject(stuString,Student.class);
    List<Student>  stu2= JSON.parseArray(studentLsit,Student.class);
    //字符串stuString中存放的是json对象,字符串studentLsit中存放的json数组

    4.读取数据

    //JSON实际上也是键值对("key":"value")
    //key 必须是字符串,value 可以是合法的 JSON 数据类型(字符串, 数字, 对象, 数组, 布尔值或 null)
    int a1= js.getIntValue("s1");
    long a3= js.getLongValue("s2");
    String a2= js.getString("s3");
    Object o= js.get("name");
    JSONObject js1=js.getJSONObject("s4");
    JSONArray js2=js.getJSONArray("s5");

    5.通过实体生成json对象和json字符串

    Student student = new Student();
    student.setId(1);
    student.setAge("20");
    student.setName("张三");
    JSONObject js= (JSONObject) JSON.toJSON(student);//通过实体生成json对象
    String stuString = JSON.toJSONString(student);   //通过json类中的方法转换成字符串
    String stuString2 = JSON.toJSON(student).toString();//通过Object中的方法转换成字符串
    String stuString3 = js.toString();//其实就是调用JSON中的toJSONString方法
    
    ArrayList<Student> studentLsit = new ArrayList<>();
    studentLsit.add(student);
    JSONArray js2= (JSONArray) JSON.toJSON(studentLsit);//通过实体数组生成json对象
    String stuLsitString = JSON.toJSONString(studentLsit);//通过json类中的方法转换成字符串
    String stuLsitString2 = JSON.toJSON(studentLsit).toString();//通过Object中的方法转换成字符串
    String stuLsitString3 = js2.toString();//其实就是调用JSON中的toJSONString方法
    //同理,JSON也可以换成JSONObject或者JSONArray

    6.遍历json数组

    //遍历json数组
            JSONArray jsonArray=JSONObject.parseArray(data);
            JSONObject object;
            if(jsonArray.size()>0){
                for(int i=0;i<jsonArray.size();++i){
                    // 遍历 jsonarray 数组,把每一个对象转成 json 对象
                    object =jsonArray.getJSONObject(i);
                    String stuString = JSONObject.toJSONString(object);
                }
            }

    7.判断是json对象还是json数组

        JSONObject json = JSONObject.parseObject(s1); //得到整个json串
        Object o=json.get("terrainEntity");        //获取到对应的json对象
            if(o instanceof JSONArray){    //判断是那个类
            JSONArray json2=json.getJSONArray("terrainEntity");
        }
            else if(o instanceof JSONObject){
            JSONObject json2=json.getJSONObject("terrainEntity");
        }
    //instanceof关键字,是用来判断前面的那个是属于哪个类的

    二.总结

    根据最上面的json数据,可以看到上面的type和coordinates分别是json的对象结构和数据结构

    直接用JSONObject创建即可。

    然后就是创建嵌套的json数据

    首先我们先要创建一个

                //首先创建一个JSONObject,因为是json的对象结构
                JSONObject jsonObject = new JSONObject();
                JSONArray jsonArray1 = new JSONArray();
                for(int i=0;i<2;++i) {
                    //创建一个嵌套的json数据,
                    JSONObject j2 = new JSONObject(); 
                    j2.put("id", 1);
                    JSONObject j21 = new JSONObject();
                    j21.put("type", "Point");
                    j21.put("coordinates", new double[]{533958.52189999819, 3123489.1460000016});
                    j2.put("geometry", j21);
                    //数组中,添加每一个json数据
                    jsonArray1.add(j2);
                }
                jsonObject.put("features",jsonArray1);
    

    fastjson的apihttps://www.w3cschool.cn/fastjson/fastjson-stream.html

    使用fastjson在处理超大文本反序列化,具体是指,把从服务器端获取到的超大json文本数组(每一个json对象中的内容也很多很长,具体有好多键值对),然后我要把这个json数组转换成类对象的数组的时候,就会出错,具体处理方式,这个fastjson好像有超大JSON文本序列化和反序列化的方法,下次遇到了,可以看看学习一下,目前还不会用。

    展开全文
  • json数据的转换工具

    热门讨论 2018-07-13 20:38:52
    用来转换.json文件,不用手动的去操作,只需放在json文件目录下,运行即可
  • Java Json解析,Java Web Json解析,Java Web服务端获取Json数据,客户端通过HTTP获取Json数据
  • 开发过程中经常会遇到json数据的处理,而单独对json数据进行增删改并不方便,尤其是Geojson文件的处理,通过对网络资料的整理总结,下面介绍Java语言方法对json数据进行读取、添加、删除与修改操作。
  • json-handle谷歌浏览器json数据解析工具

    千次下载 热门讨论 2014-10-24 08:26:23
    json-handle谷歌浏览器json数据解析工具,装了此插件,在访问json数据时,自动解析成清晰的json格式.不用再为json而看得头晕眼花.此插件的使用:打开谷歌浏览器,到设置里面的拓展程序,然后勾选最上面的开发者模式,最后...
  • VB利用官方api读写JSON数据格式文件简单实例,是一个非常、非常简单的例子…………
  • 经过Deflater压缩和Base64编码之后的deFlaterStrokeJson.json文件,如下所示: 3.1.2 还原成原始的stroke.json数据 关压缩还不行,我们得使用压缩后的json文件数据啊,因此我们还需要将压缩后的json数据进行解压,...

    一、背景

    最近刚刚做完一个中文汉字笔画排序的功能,链接如下:

    其中优化之后,将数据库的内容,序列化成为了json数据,然后通过解析json数据,拿到汉字笔画的相关信息。但是未处理前的json文件,体积较大,有2.13Mb,因此需要压缩才行。

    部分数据如下所示:

    在这里插入图片描述

    {
    	  "33828": {
    	    "code": "33828",
    	    "name": "萤",
    	    "order": "7298",
    	    "strokeSum": "11"
    	  },
    	  "22920": {
    	    "code": "22920",
    	    "name": "妈",
    	    "order": "1051",
    	    "strokeSum": "6"
    	  },
    	  "20718": {
    	    "code": "20718",
    	    "name": "僮",
    	    "order": "13341",
    	    "strokeSum": "14"
    	  },
    	  "30615": {
    	    "code": "30615",
    	    "name": "瞗",
    	    "order": "15845",
    	    "strokeSum": "16"
    	  },
    	  "36969": {
    	    "code": "36969",
    	    "name": "適",
    	    "order": "13506",
    	    "strokeSum": "14"
    	  }
    }
    
      
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    二、常规压缩json

    2.1 未处理前的json文件

    未处理前的json文件,格式好看但是体积较大。

    在这里插入图片描述

    在这里插入图片描述
    未处理前的json文件,一共占用125414行
    在这里插入图片描述

    未处理的原始json文件大小为2.13Mb
    在这里插入图片描述

    2.2 将JSON压缩成一行,去掉换行和空格字符

    在这里插入图片描述

    在Android Studio中打开,如下所示:

    在这里插入图片描述

    将JSON压缩成一行,去掉换行和空格字符后的json文件大小为:1.39Mb,只之前的2.13Mb小了整整0.74Mb,这个在移动端是很可观的优化!

    在这里插入图片描述

    2.3 将JSON的key进行缩短

    json 是 key-value 结构,如果定义好规范,则可以将 key 尽量缩短,甚至是无意义的字母,但前提是文档一定要写清楚,避免不必要的麻烦。

    比如之前的 key-value结构如下所示:
    在这里插入图片描述

    {
    	  "33828": {
    	    "code": "33828",
    	    "name": "萤",
    	    "order": "7298",
    	    "strokeSum": "11"
    	  },
    	  "22920": {
    	    "code": "22920",
    	    "name": "妈",
    	    "order": "1051",
    	    "strokeSum": "6"
    	  },
    	  "20718": {
    	    "code": "20718",
    	    "name": "僮",
    	    "order": "13341",
    	    "strokeSum": "14"
    	  },
    	  "30615": {
    	    "code": "30615",
    	    "name": "瞗",
    	    "order": "15845",
    	    "strokeSum": "16"
    	  },
    	  "36969": {
    	    "code": "36969",
    	    "name": "適",
    	    "order": "13506",
    	    "strokeSum": "14"
    	  }
    }
    
      
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    现在我们将key进行优化,使用

    c 代替 code
    n 代替 name
    o 代替 order
    s 代替 strokeSum

    在这里插入图片描述

    在这里插入图片描述

    将JSON的key进行缩短优化后的json文件大小为:1.77Mb,只之前的2.13Mb小了整整0.36Mb,这个在移动端是很可观的优化!

    然后再将缩短key之后的文件,重复【2.2 将JSON压缩成一行,去掉换行和空格字符】的操作。

    再看一看文件大小为1.04Mb,比最开始的原始数据2.13Mb小了整整1.09Mb,这个在移动端是很可观的优化!

    在这里插入图片描述

    在这里插入图片描述

    当然这样key的名字变化了,对应解析Json的java实体bean也要修改一下。

    因为我使用的是jackson来进行json解析的,所以使用注解@JsonProperty来表示一下修改的json文件对应原来的java bean里面的属性,这样解析的时候就不会出错了。
    在这里插入图片描述

    2.4 常规总结

    经过上面的常规操作,
    我们的json文件大小减少到了1.04Mb
    比最开始的原始数据2.13Mb
    小了整整1.09Mb

    压缩率为51.174%,压缩后体积为原来的48.826%

    已经算很给力了,但是这个json文件还是有1.04Mb啊,是否还可以进行压缩呢?答案是肯定的,我们下面介绍下使用算法对该json文件进行压缩。

    三、使用压缩算法进行压缩

    3.1 使用Deflater压缩json,Inflater解压json

    Deflater 是同时使用了LZ77算法哈夫曼编码的一个无损数据压缩算法

    在这里插入图片描述

    我们可以使用 java 提供的 Deflater 和 Inflater 类对 json 进行压缩和解压缩,下面是工具类

    package com.oyp.sort.utils;
    

    import android.support.annotation.Nullable;
    import android.util.Base64;

    import java.io.ByteArrayOutputStream;
    import java.util.zip.DataFormatException;
    import java.util.zip.Deflater;
    import java.util.zip.Inflater;

    /**

    • DeflaterUtils 压缩字符串
      /
      public class DeflaterUtils {
      /
      *

      • 压缩
        /
        public static String zipString(String unzipString) {
        /
        *

        • https://www.yiibai.com/javazip/javazip_deflater.html#article-start
          
        • 0 ~ 9 压缩等级 低到高
          
        • public static final int BEST_COMPRESSION = 9;            最佳压缩的压缩级别。
          
        • public static final int BEST_SPEED = 1;                  压缩级别最快的压缩。
          
        • public static final int DEFAULT_COMPRESSION = -1;        默认压缩级别。
          
        • public static final int DEFAULT_STRATEGY = 0;            默认压缩策略。
          
        • public static final int DEFLATED = 8;                    压缩算法的压缩方法(目前唯一支持的压缩方法)。
          
        • public static final int FILTERED = 1;                    压缩策略最适用于大部分数值较小且数据分布随机分布的数据。
          
        • public static final int FULL_FLUSH = 3;                  压缩刷新模式,用于清除所有待处理的输出并重置拆卸器。
          
        • public static final int HUFFMAN_ONLY = 2;                仅用于霍夫曼编码的压缩策略。
          
        • public static final int NO_COMPRESSION = 0;              不压缩的压缩级别。
          
        • public static final int NO_FLUSH = 0;                    用于实现最佳压缩结果的压缩刷新模式。
          
        • public static final int SYNC_FLUSH = 2;                  用于清除所有未决输出的压缩刷新模式; 可能会降低某些压缩算法的压缩率。
          

        */
        //使用指定的压缩级别创建一个新的压缩器。
        Deflater deflater = new Deflater(Deflater.BEST_COMPRESSION);
        //设置压缩输入数据。
        deflater.setInput(unzipString.getBytes());
        //当被调用时,表示压缩应该以输入缓冲区的当前内容结束。
        deflater.finish();

        final byte[] bytes = new byte[256];
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream(256);

        while (!deflater.finished()) {
        //压缩输入数据并用压缩数据填充指定的缓冲区。
        int length = deflater.deflate(bytes);
        outputStream.write(bytes, 0, length);
        }
        //关闭压缩器并丢弃任何未处理的输入。
        deflater.end();
        return Base64.encodeToString(outputStream.toByteArray(), Base64.NO_PADDING);
        }

      /**

      • 解压缩
        */
        @Nullable
        public static String unzipString(String zipString) {
        byte[] decode = Base64.decode(zipString, Base64.NO_PADDING);
        //创建一个新的解压缩器 https://www.yiibai.com/javazip/javazip_inflater.html
        Inflater inflater = new Inflater();
        //设置解压缩的输入数据。
        inflater.setInput(decode);

        final byte[] bytes = new byte[256];
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream(256);
        try {
        //finished() 如果已到达压缩数据流的末尾,则返回true。
        while (!inflater.finished()) {
        //将字节解压缩到指定的缓冲区中。
        int length = inflater.inflate(bytes);
        outputStream.write(bytes, 0, length);
        }
        } catch (DataFormatException e) {
        e.printStackTrace();
        return null;
        } finally {
        //关闭解压缩器并丢弃任何未处理的输入。
        inflater.end();
        }

        return outputStream.toString();
        }
        }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84

    3.1.1 压缩原始的stroke.json数据

    然后我们先将原始的stroke.json数据压缩成deFlaterStrokeJson.json。

    在这里插入图片描述

     //原始文件   stroke.json
     String strokeJson = LocalFileUtils.getStringFormAsset(context, "stroke.json");
      mapper = JSONUtil.toCollection(strokeJson, HashMap.class, String.class, Stroke.class);
      // 使用 Deflater  加密
      String deFlaterStrokeJson = DeflaterUtils.zipString(strokeJson);
      writeFile(deFlaterStrokeJson,"deFlaterStrokeJson.json");
    
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    其中 writeFile方法是写入到sdcard的方法。

    private static void writeFile(String mapperJson, String fileName) {
            Writer write = null;
            try {
                File file = new File(Environment.getExternalStorageDirectory(), fileName);
                Log.d(TAG, "file.exists():" + file.exists() + " file.getAbsolutePath():" + file.getAbsolutePath());
                // 如果父目录不存在,创建父目录
                if (!file.getParentFile().exists()) {
                    file.getParentFile().mkdirs();
                }
                // 如果已存在,删除旧文件
                if (file.exists()) {
                    file.delete();
                }
                file.createNewFile();
                // 将格式化后的字符串写入文件
                write = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");
                write.write(mapperJson);
                write.flush();
                write.close();
            } catch (Exception e) {
                Log.e(TAG, "e = " + Log.getStackTraceString(e));
            }finally {
                if (write != null){
                    try {
                        write.close();
                    } catch (IOException e) {
                        Log.e(TAG, "e = " + Log.getStackTraceString(e));
                    }
                }
            }
        }
    
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    运行完毕之后,将sdcard中的deFlaterStrokeJson.json导出来,放到assets目录下,以备后续解析使用。

    在这里插入图片描述

    使用Deflater压缩json,压缩后大小为 387KB,比上一次的1067KB,又少了很多很多。

    经过Deflater压缩和Base64编码之后的deFlaterStrokeJson.json文件,如下所示:

    在这里插入图片描述

    3.1.2 还原成原始的stroke.json数据

    关压缩还不行,我们得使用压缩后的json文件数据啊,因此我们还需要将压缩后的json数据进行解压,操作如下所示:

    在这里插入图片描述

    //使用 Inflater 解密
    String deFlaterStrokeJson = LocalFileUtils.getStringFormAsset(context, "deFlaterStrokeJson.json");
    String strokeJson = DeflaterUtils.unzipString(deFlaterStrokeJson);
    mapper = JSONUtil.toCollection(strokeJson, HashMap.class, String.class, Stroke.class);
    
     
    • 1
    • 2
    • 3
    • 4

    解压之后运行一切正常!完美!

    3.1.3 Deflater压缩总结

    经过上面的常规操作,
    我们的json文件大小减少到了387KB
    比刚才未使用压缩算法的原始数据1067KB
    小了整整680KB

    压缩率为63.73%,压缩后体积为原来的36.27%

    优化步骤体积
    1.未处理的原始json2.13MB
    2.将JSON压缩成一行,去掉换行和空格字符1.39MB
    3.将JSON的key进行缩短1.04MB
    4.使用Deflater压缩json,Base64编码0.38MB

    在这里插入图片描述

    在这里插入图片描述

    3.2 使用Gzip压缩解压json

    在我封装的http库里面,有对请求json数据进行Gzip压缩,对服务器返回的json数据进行Gzip解压。这里也来试一下Gzip压缩json。

    编写一个 Gzip压缩解压并使用Base64进行编码工具类

    package com.oyp.sort.utils;
    

    import android.text.TextUtils;
    import android.util.Base64;
    import android.util.Log;

    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.nio.charset.Charset;
    import java.util.zip.GZIPInputStream;
    import java.util.zip.GZIPOutputStream;

    /**

    • Gzip压缩解压并使用Base64进行编码工具类
      /
      public class GzipUtil {
      private static final String TAG = “GzipUtil”;
      /
      *

      • 将字符串进行gzip压缩
      • @param data
      • @param encoding
      • @return
        */
        public static String compress(String data, String encoding) {
        if (data null || data.length() 0) {
        return null;
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        GZIPOutputStream gzip;
        try {
        gzip = new GZIPOutputStream(out);
        gzip.write(data.getBytes(encoding));
        gzip.close();
        } catch (IOException e) {
        e.printStackTrace();
        }
        return Base64.encodeToString(out.toByteArray(), Base64.NO_PADDING);
        }

      public static String uncompress(String data, String encoding) {
      if (TextUtils.isEmpty(data)) {
      return null;
      }
      byte[] decode = Base64.decode(data, Base64.NO_PADDING);
      ByteArrayOutputStream out = new ByteArrayOutputStream();
      ByteArrayInputStream in = new ByteArrayInputStream(decode);
      GZIPInputStream gzipStream = null;
      try {
      gzipStream = new GZIPInputStream(in);
      byte[] buffer = new byte[256];
      int n;
      while ((n = gzipStream.read(buffer)) >= 0) {
      out.write(buffer, 0, n);
      }
      } catch (IOException e) {
      Log.e(TAG, "e = " + Log.getStackTraceString(e));
      } finally {
      try {
      out.close();
      if (gzipStream != null) {
      gzipStream.close();
      }
      } catch (IOException e) {
      Log.e(TAG, "e = " + Log.getStackTraceString(e));
      }

       <span class="token punctuation">}</span>
       <span class="token keyword">return</span> <span class="token keyword">new</span> <span class="token class-name">String</span><span class="token punctuation">(</span>out<span class="token punctuation">.</span><span class="token function">toByteArray</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">,</span> Charset<span class="token punctuation">.</span><span class="token function">forName</span><span class="token punctuation">(</span>encoding<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
      

      }

    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74

    3.2.1 压缩原始的stroke.json数据

    在这里插入图片描述

      //原始文件   stroke.json
    String strokeJson = LocalFileUtils.getStringFormAsset(context, "stroke.json");
    mapper = JSONUtil.toCollection(strokeJson, HashMap.class, String.class, Stroke.class);
    // 使用 GZIP  压缩
    String gzipStrokeJson = GzipUtil.compress(strokeJson,CHARSET_NAME);
    writeFile(gzipStrokeJson,"gzipStrokeJson.json");
    
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    运行完毕之后,将sdcard中的gzipStrokeJson.json导出来,放到assets目录下,以备后续解析使用。

    在这里插入图片描述

    导出来的gzipStrokeJson.json文件为405kb,没有比刚才使用Deflater压缩json后大小为 387KB优秀!

    在这里插入图片描述

    3.2.2 还原成原始的stroke.json数据

    关压缩还不行,我们得使用压缩后的json文件数据啊,因此我们还需要将压缩后的json数据进行解压,操作如下所示:

    在这里插入图片描述

    //使用 GZIP 解压
    String gzipStrokeJson = LocalFileUtils.getStringFormAsset(context, "gzipStrokeJson.json");
    String strokeJson = GzipUtil.uncompress(gzipStrokeJson,CHARSET_NAME);
    mapper = JSONUtil.toCollection(strokeJson, HashMap.class, String.class, Stroke.class);
    
     
    • 1
    • 2
    • 3
    • 4

    解压之后,json解析一切正常!

    3.2.3 Gzip压缩总结

    经过上面的常规操作,
    我们的json文件大小减少到了405kb
    虽然比不上刚才的Deflater压缩:387KB
    但是比刚才未使用压缩算法的原始数据1067KB
    小了整整662KB

    压缩率为62.04%,压缩后体积为原来的37.95%,也是不错的!

    四、 其他压缩算法

    除了上面的算法之外,我们还可以使用很多其他的压缩算法,进一步压缩json的体积。我们的原始json中还是有很多重复的key值可以进行优化的,下面的算法中有部分可以进行key优化!

    https://web-resource-optimization.blogspot.com/2011/06/json-compression-algorithms.html

    常见的json压缩算法有CJSON与HPack,其原理都是将key和value进行抽离,节省掉部分的重复的key值造成的空间消耗。

    4.1 CJSON

    CJSON 的压缩算法, 主要是将资料抽离成 Template 与 Value,节省掉重复的 “Key 值”.

    原始JSON:

    [{
    		"x": 100,
    		"y": 100
    	},
    	{
    		"x": 100,
    		"y": 100,
    		"width": 200,
    		"height": 150
    	},
    	{}
    ]
    
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    在这里插入图片描述
    CJSON压缩后:

    {
    	"templates": [
    		[0, "x", "y"],
    		[1, "width", "height"]
    	],
    	"values": [{
    			"values": [1, 100, 100]
    		},
    		{
    			"values": [2, 100, 100, 200, 150]
    		},
    		{}
    	]
    }
    
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    在这里插入图片描述

    4.2 HPack

    HPack 的压缩算法, 也是将 Key, Value 抽离, 阵列中第一个值, 就是 HPack 的 Template, 后面依序就是 Value.

    [
        {
             "name": "Andrea",
             "age": 31,
             "gender": "Male",
             "skilled": true
        },
        {
             "name": "Eva",
             "age": 27,
             "gender": "Female",
             "skilled": true
        },
        {
             "name": "Daniele",
             "age": 26,
             "gender": "Male",
             "skilled": false
        }
    ]
    
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    在这里插入图片描述

    压缩之后的数据

    [
        [
            "name",
            "age",
            "gender",
            "skilled"
        ],
        [
            "Andrea",
            31,
            "Male",
            true
        ],
        [
            "Eva",
            27,
            "Female",
            true
        ],
        [
            "Daniele",
            26,
            "Male",
            false
        ]
    ]
    
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    在这里插入图片描述

    两种方法都是主要讲json 的 键抽出来统一建成索引,只是最后的格式不同。

    HPack 简化后的格式比CJSON 少了许多字符,所以HPack 的压缩效率比较高。数据量越大,效果越明显,应用场景也更加有意义。

    如果 JSON 内容太少, CJSON的资料可能反而会比较多。

    压缩效果

    下图来自:https://www.oschina.net/p/jsonhpack
    在这里插入图片描述

    五、参考资料

    在这里插入图片描述


    作者:欧阳鹏 欢迎转载,与人分享是进步的源泉!

    展开全文
  • 后台返回json数据和前台解析json数据 一般来说web开发中,前台采用json数据提交给后台,后台处理数据以后返回json数据给前台,前台解析json,显示数据。 总而言之,前后台直接交换的数据格式最常用的非json数据...

    后台返回json数据给前台和前台解析json数据(总结)

    一般来说web开发中,前台采用json数据提交给后台,后台处理数据以后返回json数据给前台,前台解析json,显示数据。
    总而言之,前后台直接交换的数据格式最常用的非json数据无疑了。
    这里就总结一些json数据的前后台处理方式。

    1.JSON数据

    JSON(JavaScript Object Notation, JS 对象简谱)

    是一种轻量级的数据交换格式,比xml更轻巧(由于 JSON 所使用的字符要比 XML 少得多,可以大大得节约传输数据所占用的带宽)。

    json是javascript原生格式,就是说在javascript中处理json数据,需要引用其他API或工具包。

    简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写,同时也易于机器解析和生成,并有效地提升网络传输效率。

    只需要记住!
    Json是一种文本字符串!被存储在responseText属性中,而读取json数据可以使用javascript的eval函数来解析json。

    2.json规则:

    在 JS 语言中,一切都是对象,对象是一个无序的 “键/值” 对集合
    因此,任何支持的类型都可以通过 JSON 来表示,例如字符串、数字、对象、数组等。但是对象和数组是比较特殊且常用的两种类型:
    • 对象表示为键值对.
    • 数据由逗号分隔.
    • 花括号{}保存对象.
    • 方括号[]保存数组.

    键/值对组合中的键名写在前面并用双引号 “” 包裹,使用冒号 : 分隔,然后紧接着值:

    {"firstName": "Json"}
    

    这很容易理解,等价于这条 JavaScript 语句:

    {firstName : "Json"}
    

    对象在 JS 中是使用花括号包裹 {} 起来的内容,数据结构为 {key1:value1, key2:value2, …} 的键值对结构。

    在面向对象的语言中,key 为对象的属性,value 为对应的值。

    键名可以使用整数和字符串来表示,值的类型可以是任意类型。

    数组在 JS 中是方括号 [] 包裹起来的内容,数据结构为 [“java”, “javascript”, “vb”, …] 的索引结构。

    在 JS 中,数组是一种比较特殊的数据类型,它也可以像对象那样使用键值对,但还是索引使用得多。同样,键名可以使用整数和字符串来表示,值的类型可以是任意类型。

    3.JSON 与 JS 对象的关系:

    很多人搞不清楚 JSON 和 Js 对象的关系,甚至连谁是谁都不清楚。其实,可以这么理解:
    JSON 是 JS 对象的字符串表示法,它使用文本表示一个 JS 对象的信息,本质是一个字符串
    如:

    var obj = {a: 'Hello', b: 'World'};    //这是一个对象,注意键名也是可以使用引号包裹的
    var json = '{"a": "Hello", "b": "World"}';  //这是一个 JSON 字符串,本质是一个字符串
    

    4.后台返回json数据

    一般来说,使用JsonObject来将Java类型数据转换成Json类型,首先要下载该库相关的jar包,下载地址如下:

    json-jar包下载

    JsonObject的使用:
    后台controller部分代码:

    JSONObject object = new JSONObject();  //创建Json对象
    object.put("username", "张三");         //设置Json对象的属性
    object.put("password", "123456");
    System.out.println(object.toString());  //调用toString方法将json对象转换成json字符串
    
    //把json数据返回给浏览器:
    PrintWriter out = cu.getWriterOut(response);
    out.print(object.toString());
    //或者
    response.getWriter().write(jsonObject.toString());
    
    

    5.在JavaScript代码中接收Json数据:

    假设result为浏览器得到的json数据,可以使用以下js代码可以将json对象转换为字符串。

    比如:

    通过$.get从后台获取了一段json串{“id”:“1”,“name”:“ww”},然后要拿到这里面的id和name值:

    注意!注意!注意!
    如果你直接这么写!

    $.get(url,
         function(data) {
           alert("ID:" + data.id + "\nName:" + data.name);
         });
    

    直接这样写的话,界面会alert提示undefined,因为没能正确解析返回的字符串。

    图示:
    在这里插入图片描述

    解决方案:

    1、 需要用eval()函数

    将返回的串转化成可用的strig串,eval(data),但是因为原串里面是以{}开始和结束的,会被认为是可执行方法,因此需要加上()包围起来,最终形成:

    var jsonobj= eval('(' + data + ')');  // 把JSON字符串解析为javascript对象
    

    然后再

    alert("ID:" + jsonobj.id + "\nName:" + jsonobj.name);
    

    各种正常的按key取值,就能正常显示了。

    2、获取的时候就直接表示返回的是json格式,用 . g e t J S O N 代 替 .getJSON代替 .getJSON.get,其他代码不变,也能正常获取。

    也可以直接获取json对象的属性,如下:console.log(result.username);

    前端js代码:

    $.ajax({
    url: url,
    type: "POST",
    data: parameters,
    dataType:"json",
    async: false,
    success: function(result){
    var newData = JSON.stringify(result);    //将json对象转换为字符串
    newData = eval("("+newData+")");   /解析json
    
    var annualDays = newData.annualDays;
    var entryDate = newData.entryDate;
    
    $("input[name='extendDataFormInfo.value(fd_shengyu_nianjia)']").val(annualDays);
    $("input[name='extendDataFormInfo.value(fd_ruzhi_date)']").val(entryDate);
    
    }});
    
    

    ps: 注意注释中的代码,如果少了这一句,那么直接alert(result);得到的结果会是

    在这里插入图片描述

    所以在这里stringfy()的作用是用于从一个对象解析出字符串
    加上了var newData = JSON.stringify(result);这句,然后你再alert(newData);
    得到的就会是你想要的结果,如下:
    在这里插入图片描述

    另外:
    如果返回的json数据格式不是很规范的解决办法:

    判断后台返回的数据格式是否字符串,是则转,不是则不转?

      var $obj = (typeof data.content == 'string') ? JSON.parse(data.content):data.content
    

    总结:

    1. 前台发送请求,并且设置数据为json格式‘
        $.ajax({
        url:"selectByid.",
        datatype:'json',
        data:{id:id}, // 发送数据 
    
    1. 数据回调函数
    success:function(data){
    alert(data);
    var json = eval("("+data+")");//将json类型字符串转换为json对象
    alert("hjf"+json.name);
    
    1. 给对应的input赋值:
    $("#id").val(json.id),
    $("#name").val(json.name),
    $("#age").val(json.age);
    
    1. 后台代码:返回json数据
    response.getWriter().print(str);    //将数据返回前台ajax
    

    6.前端ajax接不到json解决?

    在前台:

    async:false,                //加上这个属性就好了
    

    7.返回的json字符串中有转义符解决?

    比如:

    "result":"{\"id\":\"60\",\"qid\":\"1\",\"bazi\":\"baiz\",\"shenxiao\":\"\",\"xingzuo\":\"\",\"wuge\":\"\",\"jianyi\":\"\",\}"
    

    这样我们我们使用JSON.parse(result) ,直接转化为json的话是会报错的。

    解决方法:
    我们先把转义符用正则表达式去掉,

       var string = result.replace("/\\","");
       var getDataArray = JSON.parse(string)
    

    这样就OK了,不过要注意有时候也是需要指定返回数据类型的
    dataType:“json”

    8.使用其他的json依赖包方式:

    引入阿里巴巴的json依赖包:

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

    模拟后台:

        String params="{\"channelCode\":\"bbb\",\"accountNo\":\"121300000932\",\"message\":\"字符信息解密成功\",\"status\":\"1\"}";
        JSONObject pa=JSONObject.parseObject(params);
        System.out.println(pa.getString("message"));
    

    结果:
    在这里插入图片描述

    或者:
    引入net.sf.json-lib依赖包:

        <dependency>
          <groupId>net.sf.json-lib</groupId>
          <artifactId>json-lib</artifactId>
          <version>2.4</version>		 
          <classifier>jdk15</classifier>
        </dependency>
    

    后台:

    String params="{\"channelCode\":\"ccy\",\"accountNo\":\"121300000932\",\"message\":\"字符信息解密成功\",\"status\":\"1\"}";
    JSONObject pa=JSONObject.fromObject(params);
    String accountNo=pa.getString("accountNo");
    System.out.println(accountNo);
    

    结果:
    在这里插入图片描述

    9.后台对象转换json数据返回给前台

    List集合转换成json代码:

      List list = new ArrayList();
      list.add( "first" );
      list.add( "second" );
      JSONArray jsonArray2 = JSONArray.fromObject( list );
    

    Map集合转换成json代码:

       Map map = new HashMap();
      map.put("name", "json");
      map.put("bool", Boolean.TRUE);
      map.put("int", new Integer(1));
      map.put("arr", new String[] { "a", "b" });
      map.put("func", "function(i){ return this.arr[i]; }");
      JSONObject json = JSONObject.fromObject(map);
    

    或者在项目中加入引入JSON-lib包,JSON-lib包同时依赖于以下的JAR包:
    下载地址

      1.commons-lang.jar
      2.commons-beanutils.jar
      3.commons-collections.jar
      4.commons-logging.jar 
      5.ezmorph.jar
      6.json-lib-2.2.2-jdk15.jar
    

    用法同上

      JSONObject jsonObject = JSONObject.fromObject(message);
      getResponse().getWriter().write(jsonObject.toString());
    

    当把数据转为json后,用如上的方法发送到客户端。前端就可以取得json数据了。(可以参考最下面的实例)

    10.后台返回数据给前台,json中文乱码解决方法

    在实际运用场景中,当前台发起请求后,我们需要从后台返回数据给前台,这时,如果返回的数据中包含中文,则经常会出现在后台查询出来都是好好,但是传输回去就莫名的乱码了,而且即使在 web.xml 中进行编码过滤了,但还是乱码。

    解决办法:
    只需要在 spring-mvc.xml 配置文件中配置一次就好,省去了我们重复写的麻烦,配置内容如下:

    <!--自定义消息转换器的编码,解决后台传输json回前台时,中文乱码问题-->
        <mvc:annotation-driven >
            <mvc:message-converters register-defaults="true">
                <bean class="org.springframework.http.converter.StringHttpMessageConverter" >
                    <property name = "supportedMediaTypes">
                        <list>
                            <value>application/json;charset=utf-8</value>
                            <value>text/html;charset=utf-8</value>
                            <!-- application 可以在任意 form 表单里面 enctype 属性默认找到 -->
                            <value>application/x-www-form-urlencoded</value>
                        </list>
                    </property>
                </bean>
                <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" ></bean>
            </mvc:message-converters>
        </mvc:annotation-driven>
    

    加上这段配置,保存重新运行,再次访问,会发现,原先的中文乱码都已经正常显示了。

    方法二:在后台的方法映射添加:

    @RequestMapping(value="/getphone",produces = “text/plain;charset=utf-8”)

    11.Spring MVC返回json数据的方式

    1. 采用@ResponseBody注解

    @ResponseBody 注解的作用是:

    将controller的方法返回的对象通过适当的转换器转换为指定的格式之后,写入到response对象的body区,通常用来返回JSON数据或者是XML数据,需要注意的呢,在使用此注解之后不会再走试图处理器,而是直接将数据写入到输入流中,他的效果等同于通过response对象输出指定格式的数据。

    使用举例:
    在这里插入图片描述

    使用@ResponseBody 注解返回响应体 直接将返回值序列化json
    优点:不需要自己再处理

    再举例:

    RequestMapping("/login")
      @ResponseBody
      public User login(User user){
        return user;
      }
    

    使用@ResponseBody 注解返回响应体 直接将返回值序列化json。

    User字段:userName pwd,那么在前台接收到的数据为:’{“userName”:“xxx”,“pwd”:“xxx”}’,效果等同于如下代码:

    @RequestMapping("/login")
    public void login(User user, HttpServletResponse response){
       response.getWriter.write(JSONObject.fromObject(user).toString());
    }
    
    

    需要在springmvc的配置文件xml中添加:

    <mvc:annotation-driven/>  
    

    2. 采用工具类,进行json格式转换带回

    JSON-lib包是一个beans,collections,maps,java arrays 和XML和JSON互相转换的包。在本例中,我们将使用JSONObject类创建JSONObject对象,然后我们打印这些对象的值。为了使用JSONObject对象,我们要引入"net.sf.json"包。为了给对象添加元素,我们要使用put()方法。

    要使程序可以运行必须引入JSON-lib包,JSON-lib包同时依赖于以下的JAR包:

    commons-lang.jar
    commons-beanutils.jar
    commons-collections.jar
    commons-logging.jar 
    ezmorph.jar
    json-lib-2.2.2-jdk15.jar
    

    效果:在这里插入图片描述

    工具类:
    ResponseUtil.java

    package com.zout.utils;
    import java.io.PrintWriter;
    import javax.servlet.http.HttpServletResponse;
    import net.sf.json.JSONArray;
    import net.sf.json.JSONObject;
    
    /**
     *@class_name:ResponseUtil  
     *@param: EasyUi-响应工具类
     *@return: 返回字符串格式数据、result是JSONObject对象(json对象)
     *@author:Zoutao
     *@createtime:2018年3月8日
     */
    public class ResponseUtil {
    	public static void write(HttpServletResponse response, Object result)
    			throws Exception {
    		response.setContentType("text/html;charset=utf-8");
    		response.addHeader("Access-Control-Allow-Origin", "*");
    		PrintWriter out = response.getWriter();
    		out.println(result.toString());
    		System.out.println("带回的json字符串为:"+result.toString()+"类型为:"+result.getClass().getName());
    		out.flush();
    		out.close();
    	}
    	
    	public static void main(String[] args) throws Exception {
    		/*在web运用控制层中调用如下:*/
    		JSONObject result = new JSONObject(); //创建json对象
    		JSONArray jsonArray = JSONArray.fromObject("name:zhangsan"); //字符串转为json数组
    		result.put("rows", jsonArray);  //放入json数组中,并起个名字
    		HttpServletResponse response = null; //jsp的response对象
    		ResponseUtil.write(response, result); //result写入response带回前台,jsp按名字拿取。
    	}
    }
    
    

    后台具体调用:

    	JSONObject result = new JSONObject();
    			if (resultTotal > 0) {		//处理结果
    				System.out.println("操作成功。");
    				result.put("success",true)
    				result.put("message","操作成功"); //消息语句
    			} else {
    				System.out.println("操作失败。");
    				result.put("success", false);			
    				result.put("message","操作失败");
    			}
    			ResponseUtil.write(response,result); //带回字符串+状态码
    			return null;
    

    图:
    在这里插入图片描述

    后台已经通过工具类封装为json字符串了,使用response带回需要的数据,使用result带回状态字符串或状态码。

    前台:
    这是当成返回一个json字符串,然后直接采取字符串截取的方式,取出消息语句message等消息。
    在这里插入图片描述

    这是另外一种写法:就是解析传回来的json字符串我js的对象,然后按照key/value的取值。

      function (data) {
              var data=eval("("+data+")");  //解析json
             //alert(data.message)
                $.messager.show({
                  title:'消息',
                  msg:data.message,  //按key取值
                  timeout:1000,
                  showType:'slide',
                  height:120,
                 width:200
         });
     });
    

    推荐这种方式。
    效果图:
    在这里插入图片描述


    以上都是后台返回json数据给前台和前台解析json数据的一些总结,还有json数据的封装,工具类的使用等等,东西有点复杂有点多,挑选自己需要的地方即可。

    另外的一些常用的web开发json:

    Json–Java数据类型对照表(映射)表

    展开全文
  • Axios 发送 json 数据

    千次阅读 2022-03-07 19:26:25
    Axios 发送 json 数据
  • C++实现的服务器post访问并实现JSON数据流解析

    千次下载 热门讨论 2013-11-08 18:08:15
    本代码借鉴了网上其他大神用C++实现的post方法,自己经过修改并添加了对接收的json数据流进行了解析的功能
  • JavaScript调用Android方法,向Android方法传递json数据
  • json数据存入数据库中

    千次阅读 2021-01-25 23:41:59
    /** * @ClassName: Test * @description: 用于读取json数据,并将次数记录在数据库中。 * @author: * @Date: Apr 15, 2019 4:12:34 PM */ public class Test { public static JSONArray getJSONArray(String url) {...
  • Python对json数据的提取

    千次阅读 2021-01-04 14:33:31
    JSON的全称是”JavaScript Object Notation”,意思是JavaScript对象表示法,它是一种基于文本,独立于语言的轻量级数据交换格式。XML也是一种数据交换格式,为什么没有...1,为什么要研究json数据的提取呢? 是因为z
  • JavaScript JSON数据处理全集

    千次阅读 多人点赞 2019-07-25 11:40:58
    JSON 是轻量级的文本数据交换格式。...对象转字符串JSON数据:JSON.stringify() JSON 语法 JavaScript 对象表示语法的子集。 数据在名称/值对中 数据由逗号分隔 大括号保存对象 中括号保存数组 JSON 取值类型 ...
  • Json数据格式的使用

    千次阅读 多人点赞 2020-08-02 00:48:57
    Json数据格式的使用一.概念介绍二.语法介绍1. 基本定义规则2. 获取数据3. JSON数据和Java对象的相互转换I.Java对象转换JSONII.JSON转为Java对象 一.概念介绍 全称为:JavaScript Object Notation,JavaScript对象表示...
  • MySQL 5.7 JSON 数据类型使用总结

    万次阅读 2019-03-30 14:39:40
    从版本5.7.8开始,mysql开始支持json数据类型,json数据类型存储时会做格式检验,不满足json格式会报错,json数据类型默认值不允许为空。 二、简单使用示例 数据准备 create table json_tab ( id int unsigned ...
  • java list 转换为json数据

    热门讨论 2010-12-12 12:08:59
    java list 转换为json数据java list 转换为json数据java list 转换为json数据java list 转换为json数据java list 转换为json数据java list 转换为json数据java list 转换为json数据java list 转换为json数据java ...
  • JSON数据格式

    万次阅读 多人点赞 2019-03-30 14:18:54
    文章目录JSON数据格式概念 JSON数据格式概念 曾经一段时间里xml成为了互联网业界内的数据传输格式标准,但是有人对xml提出了质疑,认为xml数据格式比较繁杂,冗长等弊端,于是提出了很多解决方案 在2001年的时候JSON...
  • MySQL json 数据类型

    千次阅读 2021-01-21 09:47:04
    必须要5.7以上版本才能使用写在开头mysql json 的功能很强大,只是用来当一个储存数据的字段 就没什么意义了。使用proto做交互的话,只要JSON 写得好 用proro.Unmarshal() 就可以很方便的转换类型 可以精简很多代码...
  • json数据结构

    万次阅读 2018-08-11 21:38:40
    JSON即JavaScript Object Natation,它是一种轻量级的数据交换格式,非常适合服务器与JavaScript的交互。JSON易于人阅读和编写。同时也易于机器解析和生成。JSON采用完全独立语言的文本格式,但是也是用了类似于...
  • python获取json数据中某个字段

    千次阅读 2020-12-29 18:13:13
    Python 怎么获取json 里的特定的某个值有什么放不下,不就是几瓶酒几根烟几个难熬的夜晚。首先我们要导入json包,新建一个对象。 我坐在一块一亿五千万年的石头上,发了一个下午的呆…接着直接调用json.dumps将对象...
  • 易语言 精易模块 操作json数据

    千次阅读 2021-06-13 02:43:40
    json 原始数据 { "status":200, "results":"success" } .版本 2 .支持库 spec .局部变量 bool, 逻辑型 .局部变量 json, 类_json bool = json.解析 (到文本 (读入文件 (“json.txt”))) .如果真 (bool) 调试...
  • 前端和后端的JSON数据交互

    千次阅读 2021-06-05 14:10:48
     @requestbody能解析,但springmvc会进行解析,所以通常不用@... 3、application/json,application/xml等  @requestbody能解析,springmvc不会进行解析,所以必须要加@requestbody注解  一句话概括:@requestb
  • 前端实现json数据格式化展示

    万次阅读 2019-05-23 22:26:53
    后端返回给前端一串json字符串,前端需要做格式化处理并将其美观地展示给用户。 2. 效果演示: 3. 实现代码: <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> &...
  • json数据格式化(editplus 格式化 Json 工具 )

    千次下载 热门讨论 2012-03-22 23:00:53
    json数据格式化(editplus 格式化 Json 工具 )
  • 前言 JSON的可读性比XML强几...在一个项目的各个接口间,及前后端之间数据的传输多使用 JSON格式的数据进行传输交互。而Spring Boot框架项目接口返回 JSON格式的数据比较简单:在 Controller 类中使用@RestControl...
  • VUE获取JSON数据问题

    千次阅读 2021-01-12 01:50:40
    我想用vue获取json中的conversation数组中最后一项中...json数据部分:{"dialogue": [{"name":"a","conversation":[{"speaker":"a","content":"小伙子"},{"speaker":"b","content":"The core idea"},{"speaker": "a...
  • 使用GSON解析JSON数据

    万次阅读 多人点赞 2019-07-18 15:51:30
    GSON是谷歌提供的一个开源库,可以用来解析JSON数据 不过GSON并没有被添加到Android官方的API中,所以如果要使用这个开源库,我们就要先添加依赖,编辑app/build.gradle文件,在dependencies闭包中添加如下内容: ...
  • python处理request返回的json数据

    千次阅读 2022-02-12 22:48:30
    有2中方法可以处理request返回的数据: 1.对request发起请求返回的响应对象进行.json()操作,.json操作返回...2.对request请求得到的响应对象中的text数据进行json.loads()操作,操作后返回的是字典类型,如下: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,365,936
精华内容 546,374
关键字:

json数据