碼上快樂

相關內容    簡體    繁體

fastjson 的使用總結

本文轉載自   查看原文   2018-05-13 19:49   62069    java/ json/ Javaweb學習

前言

最近在開發過程中使用了大量的json作為前后端數據交換的方式,由於之前沒有對json做過系統的學習,所有在使用過程中查閱了大量的文檔與資料,這里主要記錄了我在開發后對json以及fastjson使用的總結

JSON 介紹

JSON(javaScript Object Notation)是一種輕量級的數據交換格式。主要采用鍵值對({"name": "json"})的方式來保存和表示數據。JSON是JS對象的字符串表示法，它使用文本表示一個JS對象的信息，本質上是一個字符串。更多簡介見介紹JSON。

fastjson 簡介

在日志解析,前后端數據傳輸交互中,經常會遇到字符串(String)與json,XML等格式相互轉換與解析，其中json以跨語言，跨前后端的優點在開發中被頻繁使用，基本上可以說是標准的數據交換格式。fastjson是一個java語言編寫的高性能且功能完善的JSON庫，它采用一種“假定有序快速匹配”的算法，把JSON Parse 的性能提升到了極致。它的接口簡單易用，已經被廣泛使用在緩存序列化，協議交互，Web輸出等各種應用場景中。

fastjson 常用 API

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。

使用方法舉例

//將JSON文本轉換為java對象
import com.alibaba.fastjson.JSON;
Model model = JSON.parseObject(jsonStr, Model.class);

有關類庫的一些說明

  • JSONArray : 相當於List
  • 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測試類

    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測試類

    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 對象，並且將column 對象數組轉化為query對象里的List 屬性
    而實際轉化過程中，fastjson將column對象數組轉化為List ;所有我們還需要將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;
    }

    參考

    posted @ 2018-05-13 19:49  Dmego  閱讀( 62061)  評論( 1)  編輯  收藏


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 fastjson使用 FastJson-fastjson的簡單使用(alibaba) Gson 與 fastJson 在使用上的差異（fastJson的優點） java FastJSON的使用 fastJson之JSONPath使用(轉) Spring Boot fastJSON的使用 spring boot 之fastJson的使用（二） fastJson 常用API使用 fastjson的常用使用方法 fastjson.JSONPath使用舉例
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM