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、下載地址

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文字

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"}]}

2、python中josn格式資料相關操作

函式	描述
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

>>> 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 的格式化及校驗功能。

在使用 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 格式資料：

未完