数据基础---josn格式数据相关操作

最新推荐文章于 2024-09-03 11:11:03 发布

diggerTT

最新推荐文章于 2024-09-03 11:11:03 发布

阅读量1k

点赞数 2

分类专栏：数据基础

本文链接：https://blog.csdn.net/qingqing7/article/details/80314344

版权

数据基础专栏收录该内容

16 篇文章 0 订阅

订阅专栏

1、java中josn格式数据相关操作

主要是对Fastjson进行学习
来源1
来源2

1.1、什么是JSON?

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。它基于JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Python等）。这些特性使JSON成为理想的数据交换语言。

fastJson

Fastjson是国内著名的电子商务互联网公司阿里巴巴内部开发的用于java后台处理json格式数据的一个工具包，包括“序列化”和“反序列化”两部分，它具备如下特征：

速度最快，测试表明，fastjson具有极快的性能，超越任其他的java json parser。包括自称最快的jackson。
功能强大，完全支持java bean、集合、Map、日期、Enum，支持范型，支持自省。
无依赖，能够直接运行在Java SE 5.0以上版本
支持Android。
开源 (Apache 2.0)

1.2、下载地址

GitHub下载地址:https://github.com/alibaba/fastjson
最新发布版本jar包下载地址: https://search.maven.org/remote_content?g=com.alibaba&a=fastjson&v=LATEST

1.3、fastjson主要API

JSONObject
json对象，就是一个键对应一个值，使用的是大括号{ }，如：{key:value}
JSONArray
json数组，使用中括号[ ],只不过数组里面的项也是json键值对格式的

/**
 * Created by wanggs on 2017/7/27.
 */

public class JsonTest {
    public static void main(String[] args) {

       // Json对象中是添加的键值对,JSONArray中添加的是Json对象

        JSONObject jsonObject = new JSONObject();
        JSONObject jsonObject1 = new JSONObject();
        JSONArray jsonArray = new JSONArray();
        jsonObject1.put("001","tom");

        // JSONObject 对象中添加键值对
        jsonObject.put("key","value");
        // 将JSONObject对象添加到json数组中
        jsonArray.add(jsonObject);
        jsonArray.add(jsonObject1);

        System.out.println(jsonArray.toString());

        // 输出结果: [{"key":"value"},{"001":"tom"}]

    }
}

1.3.1、fastjson主要API说明

fastjson入口类是com.alibaba.fastjson.JSON，主要的API是JSON.toJSONString，和parseObject。常用的序列化操作都可以在JSON类上的静态方法直接完成。

Fastjson API入口类是com.alibaba.fastjson.JSON，常用的序列化操作都可以在JSON类上的静态方法直接完成。
public static final Object parse(String text); // 把JSON文本parse为JSONObject或者JSONArray 
public static final JSONObject parseObject(String text)； // 把JSON文本parse成JSONObject    
public static final <T> T parseObject(String text, Class<T> clazz); // 把JSON文本parse为JavaBean 
public static final JSONArray parseArray(String text); // 把JSON文本parse成JSONArray 
public static final <T> List<T> parseArray(String text, Class<T> clazz); //把JSON文本parse成JavaBean集合 
public static final String toJSONString(Object object); // 将JavaBean序列化为JSON文本 
public static final String toJSONString(Object object, boolean prettyFormat); // 将JavaBean序列化为带格式的JSON文本 
public static final Object toJSON(Object javaObject); 将JavaBean转换为JSONObject或者JSONArray。

上面的方法可以分为两类：序列化和反序列化
序列化：如

String jsonString = JSON.toJSONString(obj);

反序列化：如

VO vo = JSON.parseObject("...", VO.class);

泛型反序列化：如

import com.alibaba.fastjson.TypeReference;

List<VO> list = JSON.parseObject("...", new TypeReference<List<VO>>() {})

1.3.2、fastjson主要API应用举例

package josnTest.fastJosnTest;

import com.alibaba.fastjson.JSON;  
import com.alibaba.fastjson.JSONObject;  
import com.alibaba.fastjson.serializer.SerializerFeature; 

public class FastJsonTest 
{

    /** 
     * 序列化 
     */  
    public void toJsonString()  
    {  
        User user = new User("testFastJson001", "maks", 105);  
        String text = JSON.toJSONString(user);  //User对象user序列化为josn文本，而user是一个可序列化对象
        System.out.println("toJsonString()方法：text=" + text);  
        // 输出结果：text={"age":105,"id":"testFastJson001","name":"maks"}  
    }  

    /** 
     * 反序列化为json对象 
     */  
    public void parseJsonObject()  
    {  
        String text = "{\"age\":105,\"id\":\"testFastJson001\",\"name\":\"maks\"}";  //这个就是一个文本格式josn对象
        JSONObject json = JSON.parseObject(text);  //可以把text看成外界看的懂的数据，而JSONObject是java内看得懂的数据
        System.out.println("parseJsonObject()方法：json==" + json);  
        // 输出结果：json=={"age":105,"id":"testFastJson001","name":"maks"}  
    }  

    /** 
     * 反序列化为javaBean对象 
     */  
    public void parseBeanObject()  
    {  
        String text = "{\"age\":105,\"id\":\"testFastJson001\",\"name\":\"maks\"}";  
        User user = (User) JSON.parseObject(text, User.class);  //反序列化成特定格式的java对象，因为User是我们自定义的
        System.out.println("parseBeanObject()方法：user==" + user.getId() + "," + user.getName() + "," + user.getAge());  
        // 输出结果：user==testFastJson001,maks,105  
    } 

    /** 
     * 将javaBean转化为json对象 
     */  
    public void bean2Json()  
    {  
        User user = new User("testFastJson001", "maks", 105);  
        JSONObject jsonObj = (JSONObject) JSON.toJSON(user);  
        System.out.println("bean2Json()方法：jsonObj==" + jsonObj);  
        // 输出结果：jsonObj=={"age":105,"id":"testFastJson001","name":"maks"}  
    }  

    /** 
     * 全序列化 直接把java bean序列化为json文本之后，能够按照原来的类型反序列化回来。支持全序列化，需要打开SerializerFeature.WriteClassName特性 
     */  
    public void parseJSONAndBeanEachother()  
    {  
        User user = new User("testFastJson001", "maks", 105);  
        SerializerFeature[] featureArr = { SerializerFeature.WriteClassName };  
        String text = JSON.toJSONString(user, featureArr);  
        System.out.println("parseJSONAndBeanEachother()方法：text==" + text);  
        // 输出结果：text=={"@type":"fastJson.test.User","age":105,"id":"testFastJson001","name":"maks"}  
        User userObj = (User) JSON.parse(text);  
        System.out.println("parseJSONAndBeanEachother()方法：userObj==" + userObj.getId() + "," + userObj.getName() + "," + userObj.getAge());  
        // 输出结果：userObj==testFastJson001,maks,105  
    }  

    public static void main( String[] args )
    {
        FastJsonTest test = new FastJsonTest();
        // 序列化  
        test.toJsonString();
        // 反序列化为json对象  
        test.parseJsonObject(); 
        // 反序列化为javaBean对象  
        test.parseBeanObject();
        // 将javaBean转化为json对象  
        test.bean2Json(); 
        // 全序列化  
        test.parseJSONAndBeanEachother(); 

    }
}

自定义User类如下

package josnTest.fastJosnTest;

import java.io.Serializable; 

public class User implements Serializable{//可序列化声明，但到底能不能序列化，最终还要看User类的成员变量能否序列化
    private static final long serialVersionUID = 1L;  

    private String id;  
    private String name;  
    private int age;  

    public User() {  
        super();  
    }  

    public User(String id, String name, int age) {  
        super();  
        this.id = id;  
        this.name = name;  
        this.age = age;  
    }  

    public int getAge() {  
        return age;  
    }  

    public void setAge(int age) {  
        this.age = age;  
    }  

    public String getId() {  
        return id;  
    }  

    public void setId(String id) {  
        this.id = id;  
    }  

    public String getName() {  
        return name;  
    }  

    public void setName(String name) {  
        this.name = name;  
    }  

}

输出结果如下

toJsonString()方法：text={"age":105,"id":"testFastJson001","name":"maks"}
parseJsonObject()方法：json=={"name":"maks","id":"testFastJson001","age":105}
parseBeanObject()方法：user==testFastJson001,maks,105
bean2Json()方法：jsonObj=={"name":"maks","id":"testFastJson001","age":105}
parseJSONAndBeanEachother()方法：text=={"@type":"josnTest.fastJosnTest.User","age":105,"id":"testFastJson001","name":"maks"}
parseJSONAndBeanEachother()方法：userObj==testFastJson001,maks,105

JSON.parseObject(String str)与JSONObject.parseObject(String str)的区别

根据源码显示：JSON是一个抽象类，JSON中有一个静态方法parseObject（String text），将text解析为一个JSONObject对象并返回；JSONObject是一个继承自JSON的类，当调用JSONObject.parseObject（result）时，会直接调用父类的parseObject（String text）。所以两者没什么区别，一个是用父类去调用父类自己的静态的parseObject（String text），一个是用子类去调用父类的静态parseObject（String text），两者调的是同一个方法。

关于fastjson更详细的使用方法可参考JSON最佳实践

1.4、fastjson如何处理日期

fastjson处理日期的API很简单，例如：

JSON.toJSONStringWithDateFormat(date, "yyyy-MM-dd HH:mm:ss.SSS")

使用ISO-8601日期格式

JSON.toJSONString(obj, SerializerFeature.UseISO8601DateFormat);

全局修改日期格式

JSON.DEFFAULT_DATE_FORMAT = "yyyy-MM-dd";
JSON.toJSONString(obj, SerializerFeature.WriteDateUseDateFormat);

反序列化能够自动识别如下日期格式：

ISO-8601日期格式
yyyy-MM-dd
yyyy-MM-dd HH:mm:ss
yyyy-MM-dd HH:mm:ss.SSS
毫秒数字
毫秒数字字符串
.NET JSON日期格式
new Date(198293238)

1.5、fastjson 如何处理超大对象和超大JSON文本

fastjson提供了Stream API，详细看这里 https://github.com/alibaba/fastjson/wiki/Stream-api

1.6、将数据库中的数据转换成json格式

需要两个jar包，一个连接接数据库(mysql-connector-java-version.jar如mysql-connector-java-8.0.11.jar)，一个关于json（fastjson-1.2.44.jar）

package josnTest.fastJosnTest;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Statement; 
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSONArray;


public class mysqlToJosn {
    public static void main(String[] args) {

        String driver = "com.mysql.jdbc.Driver";

        //这里我的数据库名字是Person，改成你自己的数据库名
        String url = "jdbc:mysql://111.22.33.444:3306/xxx";
        String user = "xxxx";
        String pwd = "xxxx";  
        try {
            Class.forName(driver);
            Connection con =   DriverManager.getConnection(url,user,pwd);

            Statement stet = con.createStatement();

            //我的数据库Person中的表student，改成你自己的表
            String sql = "select * from xxxx limit 5;";

            ResultSet rs = stet.executeQuery(sql);
            ResultSetMetaData metaData =  rs.getMetaData();  
            int columnCount= metaData.getColumnCount();   

            JSONArray jsonObjArray = new JSONArray();
            while(rs.next()){
                JSONObject jsonObj = new JSONObject();       
                for(int i = 1; i <= columnCount;i++)  
                {  
                    String columnName = metaData.getColumnLabel(i);  
                    String value =rs.getString(columnName);  
                    jsonObj.put(columnName, value);//每一条记录存放于一个JSONObject对象中
                }  
                jsonObjArray.add(jsonObj);  //所有对象存放于JSONArray对象中
            }
            JSONObject jsonObjTal = new JSONObject();
            jsonObjTal.put("retBody", jsonObjArray);//最后再封装一层，一般还会有与retBody平级的其他键值对，比如状态信息
            System.out.println("转换JSON数据：");  
            System.out.println(jsonObjTal.toString());  
            con.close();

        } catch (Exception e) {

            e.printStackTrace();// TODO: handle exception
        }
    } 
}

返回结果大致如下：

转换JSON数据：
{"retBody":[{"date":"20180327","fullcode":"W22770022","fluxpred":"0.00"},{"date":"20180328","fullcode":"W22770022","fluxpred":"0.00"},{"date":"20180329","fullcode":"W22770022","fluxpred":"0.00"},{"date":"20180330","fullcode":"W22770022","fluxpred":"0.00"},{"date":"20180331","fullcode":"W22770022","fluxpred":"0.00"}]}

使用redis和fastjson做应用和mysql之间的缓存

2、python中josn格式数据相关操作

Python JSON
Python 3 操作json 文件
JSON 函数
使用 JSON 函数需要导入 json 库：import json。

函数	描述
json.dumps	将 Python 对象编码成 JSON 字符串
json.loads	将已编码的 JSON 字符串解码为 Python 对象

2.1、json.dumps

json.dumps 用于将 Python 对象编码成 JSON 字符串。
语法

json.dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, encoding="utf-8", default=None, sort_keys=False, **kw)

实例

以下实例将数组编码为 JSON 格式数据：

#!/usr/bin/python
import json
data = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]
jsonData=json.dumps(data)
print(jsonData)

以上代码执行结果为：

[{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}]

使用参数让 JSON 数据格式化输出：

import json
data = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]
jsonData=json.dumps(data,sort_keys=True,indent=4,separators=(',',':'))
print(jsonData)
[
    {
        "a":1,
        "b":2,
        "c":3,
        "d":4,
        "e":5
    }
]

python 原始类型向 json 类型的转化对照表：

Python	JSON
dict	object
list, tuple	array
str, unicode	string
int, long, float	number
True	true
False	false
None	null

2.2、json.loads

json.loads 用于解码 JSON 数据。该函数返回 Python 字段的数据类型。
语法

json.loads(s[, encoding[, cls[, object_hook[, parse_float[, parse_int[, parse_constant[, object_pairs_hook[, **kw]]]]]]]])

实例

以下实例展示了Python 如何解码 JSON 对象：

import json
jsonData = '{"a":1,"b":2,"c":3,"d":4,"e":5}';
text = json.loads(jsonData)
print(text)

以上代码执行结果为：

{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

json 类型转换到 python 的类型对照表：

JSON	Python
object	dict
array	list
string	unicode
number (int)	int, long
number (real)	float
true	True
false	False
null	None

更多内容参考：https://docs.python.org/2/library/json.html。
注意：以上为python2中的语法，在python3中可能略有差别

json.loads(str)出现错误总结

>>> import json  
>>> test="{'data':'123'}"  
>>> result=json.loads(test)  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
  File "d:\Anaconda3\lib\json\__init__.py", line 319, in loads  
    return _default_decoder.decode(s)  
  File "d:\Anaconda3\lib\json\decoder.py", line 339, in decode  
    obj, end = self.raw_decode(s, idx=_w(s, 0).end())  
  File "d:\Anaconda3\lib\json\decoder.py", line 355, in raw_decode  
    obj, end = self.scan_once(s, idx)  
json.decoder.JSONDecodeError: Expecting property name enclosed in double quotes:  
 line 1 column 2 (char 1)

原因在于：字符串里用单引号来标识字符(python里自动的)。

解决办法如下：将字符串里的单引号替换成双引号

1 >>> import re  
2 >>> test=re.sub('\'','\"',test)  
3 >>> result=json.loads(test)  
4 >>> result['data']  
5 '123'

对于带u’的字符串，u也要去掉：

>>> c=f.read()  
>>> c  
"{u'meta': {u'code': 200, u'requestId': u'5815f6739fb6b77494061e19'}, u'response  
': {u'tips': {u'count': 0, u'items': []}}}"  
>>> d=re.sub("u'","\"",c)  
>>> d  
'{"meta\': {"code\': 200, "requestId\': "5815f6739fb6b77494061e19\'}, "response\  
': {"tips\': {"count\': 0, "items\': []}}}'  
>>> d=re.sub("'","\"",d)  
>>> d  
'{"meta": {"code": 200, "requestId": "5815f6739fb6b77494061e19"}, "response": {"  
tips": {"count": 0, "items": []}}}'  
>>> json.loads(d)  
{'response': {'tips': {'items': [], 'count': 0}}, 'meta': {'requestId': '5815f67  
39fb6b77494061e19', 'code': 200}}

2.2.1、抓取请求，并解析json内容

这里采用的是python 的 requests 库进行抓取。

2.3、使用第三方库：Demjson

Demjson 是 python 的第三方模块库，可用于编码和解码 JSON 数据，包含了 JSONLint 的格式化及校验功能。

Github 地址：https://github.com/dmeranda/demjson

官方地址：http://deron.meranda.us/python/demjson/
环境配置

在使用 Demjson 编码或解码 JSON 数据前，我们需要先安装 Demjson 模块。本教程我们会下载 Demjson 并安装：

$ tar -xvzf demjson-2.2.3.tar.gz
$ cd demjson-2.2.3
$ python setup.py install

JSON 函数

函数	描述
encode	将 Python 对象编码成 JSON 字符串
decode	将已编码的 JSON 字符串解码为 Python 对象

encode

Python encode() 函数用于将 Python 对象编码成 JSON 字符串。
语法

demjson.encode(self, obj, nest_level=0)

实例

以下实例将数组编码为 JSON 格式数据：

未完

diggerTT

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录