fastjson 的使用總結
前言
最近在開發過程當中使用了大量的json做爲先後端數據交換的方式,因爲以前沒有對json作過系統的學習,全部在使用過程當中查閱了大量的文檔與資料,這裏主要記錄了我在開發後對json以及fastjson使用的總結html
JSON 介紹
JSON(javaScript Object Notation)是一種輕量級的數據交換格式。主要採用鍵值對({"name": "json"})的方式來保存和表示數據。JSON是JS對象的字符串表示法，它使用文本表示一個JS對象的信息，本質上是一個字符串。更多簡介見介紹JSON。java
fastjson 簡介
在日誌解析,先後端數據傳輸交互中,常常會遇到字符串(String)與json,XML等格式相互轉換與解析，其中json以跨語言，跨先後端的優勢在開發中被頻繁使用，基本上能夠說是標準的數據交換格式。fastjson是一個java語言編寫的高性能且功能完善的JSON庫，它採用一種「假定有序快速匹配」的算法，把JSON Parse 的性能提高到了極致。它的接口簡單易用，已經被普遍使用在緩存序列化，協議交互，Web輸出等各類應用場景中。git
fastjson 經常使用 API
fastjson API 入口類是com.alibaba.fastjson.JSON,經常使用的序列化操做均可以在JSON類上的靜態方法直接完成。github
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。
使用方法舉例
//將JSON文本轉換爲java對象 import com.alibaba.fastjson.JSON; Model model = JSON.parseObject(jsonStr, Model.class);
有關類庫的一些說明
- JSONArray : 至關於List<Object>
- JSONObject: 至關於Map<String,Object>
fastjson 使用實例
java對象與JSON字符串的互轉
User測試類算法
/**
* User測試類
* @author dmego
*/
public class User {
private String username;
private String password;
public User(){}
public User(String username,String password){
this.username = username;
this.password = password;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "User [username=" + username + ", password=" + password + "]";
}
}
UserGroup測試類apache
import java.util.ArrayList;
import java.util.List;
/**
* 用戶組測試類
* @author dmego
*
*/
public class UserGroup {
private String name;
private List<User> users = new ArrayList<User>();
public UserGroup(){}
public UserGroup(String name,List<User> users){
this.name = name;
this.users = users;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<User> getUsers() {
return users;
}
public void setUsers(List<User> users) {
this.users = users;
}
@Override
public String toString() {
return "UserGroup [name=" + name + ", users=" + users + "]";
}
}
fastJson測試類json
package demo;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import com.alibaba.fastjson.JSON;
/**
* fastJson測試類
* @author dmego
*
*/
public class TestFastJosn {
/**
* java對象轉 json字符串
*/
@Test
public void objectTOJson(){
//簡單java類轉json字符串
User user = new User("dmego", "123456");
String UserJson = JSON.toJSONString(user);
System.out.println("簡單java類轉json字符串:"+UserJson);
//List<Object>轉json字符串
User user1 = new User("zhangsan", "123123");
User user2 = new User("lisi", "321321");
List<User> users = new ArrayList<User>();
users.add(user1);
users.add(user2);
String ListUserJson = JSON.toJSONString(users);
System.out.println("List<Object>轉json字符串:"+ListUserJson);
//複雜java類轉json字符串
UserGroup userGroup = new UserGroup("userGroup", users);
String userGroupJson = JSON.toJSONString(userGroup);
System.out.println("複雜java類轉json字符串:"+userGroupJson);
}
/**
* json字符串轉java對象
* 注：字符串中使用雙引號須要轉義 (" --> \"),這裏使用的是單引號
*/
@Test
public void JsonTOObject(){
/* json字符串轉簡單java對象
* 字符串：{"password":"123456","username":"dmego"}*/
String jsonStr1 = "{'password':'123456','username':'dmego'}";
User user = JSON.parseObject(jsonStr1, User.class);
System.out.println("json字符串轉簡單java對象:"+user.toString());
/*
* json字符串轉List<Object>對象
* 字符串：[{"password":"123123","username":"zhangsan"},{"password":"321321","username":"lisi"}]
*/
String jsonStr2 = "[{'password':'123123','username':'zhangsan'},{'password':'321321','username':'lisi'}]";
List<User> users = JSON.parseArray(jsonStr2, User.class);
System.out.println("json字符串轉List<Object>對象:"+users.toString());
/*json字符串轉複雜java對象
* 字符串：{"name":"userGroup","users":[{"password":"123123","username":"zhangsan"},{"password":"321321","username":"lisi"}]}
* */
String jsonStr3 = "{'name':'userGroup','users':[{'password':'123123','username':'zhangsan'},{'password':'321321','username':'lisi'}]}";
UserGroup userGroup = JSON.parseObject(jsonStr3, UserGroup.class);
System.out.println("json字符串轉複雜java對象:"+userGroup);
}
}
輸出結果後端
簡單java類轉json字符串:{"password":"123456","username":"dmego"}
List<Object>轉json字符串:[{"password":"123123","username":"zhangsan"},{"password":"321321","username":"lisi"}]
複雜java類轉json字符串:{"name":"userGroup","users":[{"password":"123123","username":"zhangsan"},{"password":"321321","username":"lisi"}]}
json字符串轉簡單java對象:User [username=dmego, password=123456]
json字符串轉List<Object>對象:[User [username=zhangsan, password=123123], User [username=lisi, password=321321]]
json字符串轉複雜java對象:UserGroup [name=userGroup, users=[User [username=zhangsan, password=123123], User [username=lisi, password=321321]]]
fastjson 解析複雜嵌套json字符串
這個實例是我在開發中用到的，先給出要解析的json字符串數組
[
{
"id": "user_list",
"key": "id",
"tableName": "用戶列表",
"className": "cn.dmego.domain.User",
"column": [
{
"key": "rowIndex",
"header": "序號",
"width": "50",
"allowSort": "false"
},
{
"key": "id",
"header": "id",
"hidden": "true"
},
{
"key": "name",
"header": "姓名",
"width": "100",
"allowSort": "true"
}
]
},
{
"id": "role_list",
"key": "id",
"tableName": "角色列表",
"className": "cn.dmego.domain.Role",
"column": [
{
"key": "rowIndex",
"header": "序號",
"width": "50",
"allowSort": "false"
},
{
"key": "id",
"header": "id",
"hidden": "true"
},
{
"key": "name",
"header": "名稱",
"width": "100",
"allowSort": "true"
}
]
}
]
要想解析這種複雜的字符串，首先得先定義好與之相符的java POJO 對象，通過觀察，咱們發現，這個是一個json對象數組，每個對象裏包含了許多屬性，其中還有一個屬性的類型也是對象數組。全部，咱們從裏到外，先定義最裏面的對象：緩存
public class Column {
private String key;
private String header;
private String width;
private String allowSort;
private String hidden;
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
//這裏省略部分getter與setter方法
}
再定義外層的對象：
import java.util.List;
import org.apache.commons.collections4.map.LinkedMap;
public class Query {
private String id;
private String key;
private String tableName;
private String className;
private List<LinkedMap<String, Object>> column;
private List<Column> columnList;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
//這裏省略部分getter與setter方法
public List<LinkedMap<String, Object>> getColumn() {
return column;
}
public void setColumn(List<LinkedMap<String, Object>> column) {
this.column = column;
}
public List<Column> getColumnList() {
return columnList;
}
public void setColumnList(List<Column> columnList) {
this.columnList = columnList;
}
}
個人這個json文件放置在類路徑下，最後想將這個json字符串轉化爲List<Query>對象，而且將column 對象數組轉化爲query對象裏的List<Column>屬性
而實際轉化過程當中，fastjson將column對象數組轉化爲List<Map>;全部咱們還須要將Map類型轉化爲object類型才能知足需求。
/**
* 讀取類路徑下的配置文件
* 解析成對象數組並返回
* @throws IOException
*/
@Test
public List<Query> test() throws IOException {
// 讀取類路徑下的query.json文件
ClassLoader cl = this.getClass().getClassLoader();
InputStream inputStream = cl.getResourceAsStream("query.json");
String jsontext = IOUtils.toString(inputStream, "utf8");
// 先將字符jie串轉爲List數組
List<Query> queryList = JSON.parseArray(jsontext, Query.class);
for (Query query : queryList) {
List<Column> columnList = new ArrayList<Column>();
List<LinkedMap<String,Object>> columns = query.getColumn();
for (LinkedMap<String, Object> linkedMap : columns) {
//將map轉化爲java實體類
Column column = (Column)map2Object(linkedMap, Column.class);
System.out.println(column.toString());
columnList.add(column);
}
query.setColumnList(columnList); //爲columnList屬性賦值
}
return queryList;
}
/**
* Map轉成實體對象
* @param map map實體對象包含屬性
* @param clazz 實體對象類型
* @return
*/
public static Object map2Object(Map<String, Object> map, Class<?> clazz) {
if (map == null) {
return null;
}
Object obj = null;
try {
obj = clazz.newInstance();
Field[] fields = obj.getClass().getDeclaredFields();
for (Field field : fields) {
int mod = field.getModifiers();
if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
continue;
}
field.setAccessible(true);
String flag = (String) map.get(field.getName());
if(flag != null){
if(flag.equals("false") || flag.equals("true")){
field.set(obj, Boolean.parseBoolean(flag));
}else{
field.set(obj, map.get(field.getName()));
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return obj;
}
參考
相關文章
- 1. fastjson 的使用總結
- 2. fastjson的經常使用使用總結
- 3. Fastjson包使用總結
- 4. Fastjson的經常使用方法總結
- 5. fastjson總結
- 6. fastjson 的使用
- 7. fastjson的使用
- 8. FastJson的使用
- 9. java FastJSON的使用
- 10. FastJson中JSONObject用法及經常使用方法總結
- 更多相關文章...
- • TortoiseSVN 使用教程 - SVN 教程
- • Docker 容器使用 - Docker教程
- • Composer 安裝與使用
- • 算法總結-雙指針
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. fastjson 的使用總結
- 2. fastjson的經常使用使用總結
- 3. Fastjson包使用總結
- 4. Fastjson的經常使用方法總結
- 5. fastjson總結
- 6. fastjson 的使用
- 7. fastjson的使用
- 8. FastJson的使用
- 9. java FastJSON的使用
- 10. FastJson中JSONObject用法及經常使用方法總結