服务端提供的JSON数据接口与用户端接收解析JSON数据



JSON格式的服务接口:http://www.cnblogs.com/visec479/articles/4118338.html
首先来了解下JSON格式解析
json结构的格式就是若干个 键/值（key, value） 对的集合，该集合可以理解为字典（Dictionary），每个 键/值 对可以理解成一个对象（Object）。 键/值 对中的 键（key） 一般是 一个string，值（value）可以是string、double、int等基本类型，也可以嵌套一个 键/值 对，也可以是一个数组，数组里面的数据的类型可以是基本类型，或者 键/值 对。可以看出 键/值 本来没什么，只是嵌套得多了就会觉得混乱，下面举个具体的例子来说明。注：该代码只是用来举例说明，并不能正确运行。



 1             var testJson = {                      
 2                             "Name" :      "奥巴马" ,
 3                             "ByName" :    ["小奥","小巴","小马"],
 4                             "Education" : {
 5                                            "GradeSchool" :  "华盛顿第一小学",
 6                                            "MiddleSchool" : ["华盛顿第一初中" , "华盛顿第一高中"],
 7                                            "University" ：  { 
 8                                                               "Name" : "哈佛大学",
 9                                                               "Specialty" : ["软件工程","会计"]
10                                                             }
11                                       }
12                         }



变量testJson就是一个json对象，testJson对象包括三个 键/值 对。
第一个 键/值 对： 键（key）是"Name“ ，其对应的值（value）是 "奥巴马" ，即 testJson["Name"]  == "奥巴马"
第二个 键/值 对： 键 是 "ByName" ，值是一个数组，是一个string集合。有必要的话，数组里面的元素也可以是 键/值 对。
第三个 键/值 对： 键 是 "Education"，值是一个 Json对像，该json对象包括三个 键/值 对，这就是嵌套了。。。
总结：json对象就是若干个 键/值 对的集合，键是string，值可以是基本类型，或者嵌套一个Json对象，或者是一个数组（数组里的元素可以是基本类型，也可以是json对象，可以继续嵌套）。
获取名字：testJson["Name"]
获取第一个别名：testJson["ByName"][0] 。testJson的 键"ByName" 对应的值 是一个string数组 
获取小学名字： testJson["Education"]["GradeSchool"] , 获取大学主修专业：testJson["Education"]["University"]["Specialty"][0]
 
下面举个实例：
定义一个符合json格式要求的字符串：

string testJson = "{\"Name\" : \"奥巴马\",\"ByName\" : [\"小奥\",\"小巴\",\"小马\"],\"Education\":{\"GradeSchool\" : \"华盛顿第一小学\",\"MiddleSchool\" : [\"华盛顿第一初中\" , \"华盛顿第一高中\"], \"University\" :{ \"Name\" : \"哈佛大学\", \"Specialty\" : [\"软件工程\",\"会计\"]}}}";
            

然后需要用该字符串作为参数new 一个 JsonObject对象。微软自带的类库 System.Json ，然后添加命名空间 using System.Json;
主要代码就一句：JsonObject js = JsonObject.Parse(testJson); 用字符串testJson 作为参数new 一个 JsonObject 对象。通过监视我们可以看到js里面的内容和预料的一样，通过下面这幅图你应该可琢磨出很多东西来吧

 
额外插一句：js["Education"]["University"]["Specialty"] 的内容是 {[  "软件工程",  "会计"]}，
但js["Education"]["University"]["Specialty"].Contains( "软件工程") 的值 是false。原因自己琢磨
 
通过Servlet创建服务端JSON数据
服务端提供JSON数据接口：http://192.168.0.129:8080/JSONInterface/JsonServlet

按 Ctrl+C 复制代码
按 Ctrl+C 复制代码
开启服务查看是否已经开启~
客户端调用接口解析JSON数据
按 Ctrl+C 复制代码
按 Ctrl+C 复制代码


 
 

JSON格式的服务接口:http://www.cnblogs.com/visec479/articles/4118338.html
首先来了解下JSON格式解析
json结构的格式就是若干个 键/值(key, value) 对的集合，该集合可以理解为字典(Dictionary)，每个 键/值 对可以理解成一个对象(Object)。 键/值 对中的 键(key) 一般是 一个string，值(value)可以是string、double、int等基本类型，也可以嵌套一个 键/值 对，也可以是一个数组，数组里面的数据的类型可以是基本类型，或者 键/值 对。可以看出 键/值 本来没什么，只是嵌套得多了就会觉得混乱，下面举个具体的例子来说明。注：该代码只是用来举例说明，并不能正确运行。
1             var testJson = {
2                             "Name" :      "奥巴马" ,
3                             "ByName" :    ["小奥","小巴","小马"],
4                             "Education" : {
5                                            "GradeSchool" :  "华盛顿第一小学",
6                                            "MiddleSchool" : ["华盛顿第一初中" , "华盛顿第一高中"],
7                                            "University" ：  {
8                                                               "Name" : "哈佛大学",
9                                                               "Specialty" : ["软件工程","会计"]
10                                                             }
11                                       }
12                         }
变量testJson就是一个json对象，testJson对象包括三个 键/值 对。
第一个 键/值 对： 键(key)是"Name“ ，其对应的值(value)是 "奥巴马" ，即 testJson["Name"]  == "奥巴马"
第二个 键/值 对： 键 是 "ByName" ，值是一个数组，是一个string集合。有必要的话，数组里面的元素也可以是 键/值 对。
第三个 键/值 对： 键 是 "Education"，值是一个 Json对像，该json对象包括三个 键/值 对，这就是嵌套了。。。
总结：json对象就是若干个 键/值 对的集合，键是string，值可以是基本类型，或者嵌套一个Json对象，或者是一个数组(数组里的元素可以是基本类型，也可以是json对象，可以继续嵌套)。
获取名字：testJson["Name"]
获取第一个别名：testJson["ByName"][0] 。testJson的 键"ByName" 对应的值 是一个string数组
获取小学名字： testJson["Education"]["GradeSchool"] , 获取大学主修专业：testJson["Education"]["University"]["Specialty"][0]
下面举个实例：
定义一个符合json格式要求的字符串：
string testJson = "{\"Name\" : \"奥巴马\",\"ByName\" : [\"小奥\",\"小巴\",\"小马\"],\"Education\":{\"GradeSchool\" : \"华盛顿第一小学\",\"MiddleSchool\" : [\"华盛顿第一初中\" , \"华盛顿第一高中\"], \"University\" :{ \"Name\" : \"哈佛大学\", \"Specialty\" : [\"软件工程\",\"会计\"]}}}";
然后需要用该字符串作为参数new 一个 JsonObject对象。微软自带的类库 System.Json ，然后添加命名空间 using System.Json;
主要代码就一句：JsonObject js = JsonObject.Parse(testJson); 用字符串testJson 作为参数new 一个 JsonObject 对象。通过监视我们可以看到js里面的内容和预料的一样，通过下面这幅图你应该可琢磨出很多东西来吧
额外插一句：js["Education"]["University"]["Specialty"] 的内容是 {[  "软件工程",  "会计"]}，
但js["Education"]["University"]["Specialty"].Contains( "软件工程") 的值 是false。原因自己琢磨
通过Servlet创建服务端JSON数据
服务端提供JSON数据接口：http://192.168.0.129:8080/JSONInterface/JsonServlet
package JsonManager;importjava.io.IOException;importjava.io.PrintWriter;importjava.util.HashMap;importjava.util.Map;importjavax.servlet.ServletException;importjavax.servlet.http.HttpServlet;importjavax.servlet.http.HttpServletRequest;importjavax.servlet.http.HttpServletResponse;importnet.sf.json.JSONObject;/**
* JSONObject 创建一个JSON对象并out.write();
* @author Dana·Li*/
public class JsonServlet extendsHttpServlet {private static final long serialVersionUID =1L;public voiddoGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {this.doPost(request, response);
}
@SuppressWarnings({"rawtypes", "unchecked"})public voiddoPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
response.setCharacterEncoding("UTF-8");      //解决中文乱码问题
PrintWriter out=response.getWriter();
Map map= newHashMap();
map.put("name", "Dana、Li");
map.put("age", new Integer(22));
map.put("Provinces", new String("广东省"));
map.put("citiy", new String("珠海市"));
map.put("Master", new String("C、C++、Linux、Java"));
JSONObject json=JSONObject.fromObject(map);
out.write(json.toString());
out.flush();
out.close();
}
}
开启服务查看是否已经开启~
客户端调用接口解析JSON数据
importjava.io.BufferedReader;importjava.io.IOException;importjava.io.InputStreamReader;importjava.net.URL;importjava.net.URLConnection;/**
* 接收服务端Json数据
* @author Dana·Li*/
public classGetJsonInterfaceInfo{private static String urlPath="http://192.168.0.129:8080/JSONInterface/JsonServlet";/**
* @param args
* @throws IOException*/
public static voidmain(String[] args) throws IOException {//ServerFactory.getServer(8080).start();
//列出原始数据
StringBuilder json = newStringBuilder();
URL oracle= newURL(GetJsonInterfaceInfo.urlPath);
URLConnection yc=oracle.openConnection();
BufferedReaderin = new BufferedReader(new InputStreamReader(yc.getInputStream(),"UTF-8"));
String inputLine= null;while ( (inputLine = in.readLine()) != null){
json.append(inputLine);
}in.close();
String Strjson=json.toString();
System.out.println("原始数据:");
System.out.println(Strjson.toString());
}
}
本文基于署名 2.5 中国大陆许可协议发布，欢迎转载，演绎或用于商业目的，但是必须且在文章页面明显位置给出原文链接Dana、Li(包含链接)，具体操作方式可参考此处。如您有任何疑问或者授权方面的协商，请留言或加Q群！

0、干货先写在前
1、前端传值的数据必须使用JSON.stringify()传化
2、后端，通过request.body接收数据，直接使用json.loads解析，解析前，先decode一下：receive_data = json.loads(request.body.decode())。如果使用simplejson.loads(request.body)，就不用decode()
下面是这个问题产生及解决的过程，还有一些可能的应用场景。
1、传统方式解析表单数据
之前用Django后台接收数据的时候，一直采用的是表单的形式，通过Ajax传值的时候也是一样，直接通过键值对儿将值传递给后台，前端代码类似这样：
$.post("/login/",
{
"user":"threedog",
"password":"123456"
},
function (res) {
console.log(res)
});
在后台采用`request.POST`进行数据接收：
class Login(View):
def get(self,request):
return render(request,'login.html')
def post(self,request):
print(request.POST)
print("user :",end='')
print(request.POST.get('user',None))
print("password :",end='')
print(request.POST.get('password',None))
return HttpResponse('OK')
后台接收到的是一个QueryDict，打印如下：
可以看到这里的数据是按照Json的格式传递的，后台也完美地进行解析，但是，如果前端传递的数据为嵌套的Json，这种写法就开始出现问题！
2、解析嵌套的Json数据
前端代码修改如下：
$.post("/login/",
{
"user":{
'name':'threedog',
'age':18,
'sex':'男'
},
"password":"123456"
},
function (res) {
console.log(res)
});
这个时候后台收到的东西就有意思了：
password取值正常，但是user没能拿到值，而QueryDict的打印我们发现，原本是嵌套的字典，现在全部由两个键名合并成了新的键诸如：'user[sex]'，'user[age]'。这样的键到了后台是没办法按照普通字典或者json来进行解析的。
上网查，说是要使用request.raw_post_data代替request.POST就可以，然而很遗憾，报错再查之下发现，raw_post_data在Django1.4版本之后被取消，我使用的是Django1.11。再往下查，知道了要使用request.body，还要通过simplejson来解析。
但是request.body的解析仍然不顺利，前端不变，后台直接打印request.body的结果如下：
一个包含了键值对儿的二进制字符串，这个时候按网上的办法使用simplejson.loads()解析会报错：simplejson.errors.JSONDecodeError: Expecting value: line 1 column 1 (char 0)。不用在这个上面纠结了，simplejson直接解析不了这个body。
后来灵感突发，发现前端在给出的数据原本就是JS中的object，并不是json的字符串，所以把前段的数据使用JSON.stringify()进行转换后，打印request.body以及通过simplejson.load()解析发现了令人惊喜的输出：
到了这一步就基本不用说啥了，完整接收了前端的json字符串并解析，这里如果不想安装第三方库simplejson的话，使用python自带的json模块也是可以解析的，只是在解析时需要将request.body进行一次decode()即可。完整代码如下
前端：
$.post("/login",
JSON.stringify({
"user":{
'name':'threedog',
'age':18,
'sex':'男'
},
"password":"123456"
}),
function (res) {
console.log(res)
});
后台：
class Login(View):
def get(self,request):
return render(request,'login.html')
def post(self,request):
print(request.body)
receive_data = simplejson.loads(request.body)
print(receive_data)
receive_data = json.loads(request.body.decode())
print(receive_data)
return HttpResponse('OK')
程序输出：
之前主要是因为写前端给数据的时候没有使用JSON.stringify()进行处理。导致后台无论什么方法解析都是一团糟。
3、简述应用场景
这个应用场景非常常见，除了我刚才提到的，前端给后台的，是嵌套的json数据的情况。还有微信小程序给后台数据，也需要JSON.stringify()处理给json，还有安卓，IOS app访问网站后台提交数据，都需要这种方式传值和解析。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。

最近在写一个接口，请求方传过来的是一个json文件（如下图这种传递格式），以前接口接收的都是json字符串，用String接收即可，这种貌似得解析一下，下面把解析过程写一下，欢迎交流



相对于json字符串，文件格式能传递的字节数更大
代码：
请求方法传递过来的文件，用HttpServletRequest 接收
 @Override
    public Map<String, Object>  ocrBack1( HttpServletRequest requestStr) {
        try {
            MultipartHttpServletRequest requestStr1 = (MultipartHttpServletRequest) requestStr;
            Iterator<String> fileNames = requestStr1.getFileNames();
            while (fileNames.hasNext()) {
                String next = fileNames.next();
                List<MultipartFile> files = requestStr1.getFiles(next);
                if (files.size() > 0) {
                    Iterator<MultipartFile> iterator = files.iterator();
                    while (iterator.hasNext()) {
                        MultipartFile next1 = iterator.next();//获取到文件
                        InputStream inputStream = next1.getInputStream();
                        String s = ReadFile((FileInputStream) inputStream);
                        JSONArray jsonArray = JSONArray.fromObject(s);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


文件流转化为json串：
public String ReadFile(FileInputStream fileInputStream){
        BufferedReader reader = null;
        String laststr = "";
        try{
            InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");
            reader = new BufferedReader(inputStreamReader);
            String tempString = null;
            while((tempString = reader.readLine()) != null){
                laststr += tempString;
            }
            reader.close();
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(reader != null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return laststr;
    }

还有一种读取本地xxx.json文件并解析的，其实就是把本地文件转化成流，然后调用这个工具类即可
public class Util {

public String ReadFile(String Path){
BufferedReader reader = null;
String laststr = "";
try{
FileInputStream fileInputStream = new FileInputStream(Path);
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");
reader = new BufferedReader(inputStreamReader);
String tempString = null;
while((tempString = reader.readLine()) != null){
laststr += tempString;
}
reader.close();
}catch(IOException e){
e.printStackTrace();
}finally{
if(reader != null){
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return laststr;
}

}
（2）Test.java:
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

public class Test {

public static void main(String[] args) {
// TODO Auto-generated method stub
String JsonContext = new Util().ReadFile("D:\\test\\apkinfo.json");
JSONArray jsonArray = JSONArray.fromObject(JsonContext);
int size = jsonArray.size();
System.out.println("Size: " + size);
for(int  i = 0; i < size; i++){
JSONObject jsonObject = jsonArray.getJSONObject(i);
System.out.println("[" + i + "]name=" + jsonObject.get("name"));
System.out.println("[" + i + "]package_name=" + jsonObject.get("package_name"));
System.out.println("[" + i + "]check_version=" + jsonObject.get("check_version"));
}
}

}