FastJson使用

最新推荐文章于 2024-05-15 04:51:24 发布
最新推荐文章于 2024-05-15 04:51:24 发布
阅读量254 收藏 1
点赞数 1
分类专栏： 技术点json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KAITUOZHEMJ/article/details/113481180
版权

JSON介绍：

JSON(javaScript Object Notation)是一种轻量级的数据交换格式。主要采用键值对({"name": "json"})的方式来保存和表示数据。JSON是JS对象的字符串表示法，它使用文本表示一个JS对象的信息，本质上是一个字符串。


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。

 

一：基础使用方法

依赖：

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.28</version>
        </dependency>

1：将对象转换成Json串，可以用下面的方法：

JSON.toJSONString(对象);

2：将Json串转换成java对象，分为两种情况：

//对象是单个元素
JSON.parseObject(json串，CLAZZ);
//对象包含多个元素
JSON.parseArray(json串，CLAZZ)；
  • JSONArray : 相当于List
  • JSONObject: 相当于Map<String,Object>

互转换实例：

List <---->Json

List<String> stringList = new ArrayList<>();
stringList.add("aaa");
stringList.add("bbb");
stringList.add("ccc");
stringList.add("ddd");
//list-->json
String jsonString = JSON.toJSONString(stringList);
//json-->list
List<String> list =JSON.parseArray(jsonString,String.class);

Map <---->Json

Map<String,Integer> map = new HashMap<>();
map.put("zhangsan", 18);
map.put("lisi", 28);
map.put("wangwu", 38);
//map-->json
String jsonString2 = JSON.toJSONString(map);
//json-->map
Map<String,Integer> map2 =JSON.parseObject(jsonString2,Map.class);

JavaBean <------> Json

User.java

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class User {
    private String username;
    private String password;

    @Override
    public String toString(){
        return "User [username=" + username + ", password=" + password + "]";
    }
}

UserGroup.java

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.ArrayList;
import java.util.List;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class UserGroup {
    private String name;
    List<User> userList = new ArrayList<>();

    @Override
    public String toString(){
        return "UserGroup [name=" + name + ", userList=" + userList + "]";
    }
}

测试类1：

import com.alibaba.fastjson.JSON;
import java.util.List;

public class FastJsonTest {
    public static void main(String[] args) {
        //构建用户geust
        User guestUser = new User("guest", "18");
        //构建用户root
        User rootUser = new User("root", "28");
        //构建用户组
        UserGroup group = new UserGroup();
        group.setName("admin");
        group.getUserList().add(guestUser);
        group.getUserList().add(rootUser);
        //用户组对象构建JSON串串
        String jsonString = JSON.toJSONString(group);
        System.out.println(jsonString);

        //构建用户对象组
        User[] users = new User[2];
        users[0] = guestUser;
        users[1] = rootUser;
        //用户对象数组转JSON串
        String jsonString2 = JSON.toJSONString(users);
        System.out.println(jsonString2);

        //JSON串转化用户对象列表
        List<User> users1 = JSON.parseArray(jsonString2, User.class);
        System.out.println(users1);
    }
}

测试2：java对象转 json字符串

    /**
     * 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);
    }

测试3：json字符串转java对象   注：字符串中使用双引号需要转义 (" --> \"),这里使用的是单引号

    public void JsonTOObject(){
        /* json字符串转简单java对象
         * 字符串：{"password":"123456","username":"dmego"}*/

        String jsonStr1 = "{'password':'123456','username':'dmego'}";
        User user = JSON.parseObject(jsonStr1, User.class);
        user.setPassword("3333");
        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);
    }
}

二：复杂的用法（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;
    }

三：自定义转化

将Java对象转化json格式

import com.alibaba.fastjson.annotation.JSONField;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;

@Data
@NoArgsConstructor
public class Person {

    @JSONField(name = "AGE")
    private int age;

    @JSONField(name = "FULL NAME")
    private String fullName;

    @JSONField(name = "DATE OF BIRTH")
    private Date dateOfBirth;
    public Person(int age, String fullName, Date dateOfBirth) {
        super();
        this.age = age;
        this.fullName= fullName;
        this.dateOfBirth = dateOfBirth;
    }
}

使用 JSON.toJSONString() 将 Java 对象转换换为 JSON 对象：

import com.alibaba.fastjson.JSON;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class JavaToJson {
    public static void main(String[] args) {
        List<Person> listOfPersons = new ArrayList<Person>();
        listOfPersons.add(new Person(15, "John Doe", new Date()));
        listOfPersons.add(new Person(20, "Janette Doe", new Date()));
        String jsonOutput= JSON.toJSONString(listOfPersons);
        System.out.println(jsonOutput);
    }

输出结果：

[  
    {  
        "AGE":15,
        "DATE OF BIRTH":1468962431394,
        "FULL NAME":"John Doe"
    },
    {  
        "AGE":20,
        "DATE OF BIRTH":1468962431394,
        "FULL NAME":"Janette Doe"
    }
]

自定义输出，并控制字段的排序，日期显示格式，序列化标记等

更新 bean 并添加几个字段：

@JSONField(name="AGE", serialize=false)
private int age;
 
@JSONField(name="LAST NAME", ordinal = 2)
private String lastName;
 
@JSONField(name="FIRST NAME", ordinal = 1)
private String firstName;
 
@JSONField(name="DATE OF BIRTH", format="dd/MM/yyyy", ordinal = 3)
private Date dateOfBirth;

以上代码中我们列出了基本参数类别，并使用 @JSONField 注解，以便实现自定义转换：

  • format 参数用于格式化 date 属性。
  • 默认情况下， FastJson 库可以序列化 Java bean 实体， 但我们可以使用 serialize 指定字段不序列化。
  • 使用 ordinal 参数指定字段的顺序

输出：

[
    {
        "FIRST NAME":"Doe",
        "LAST NAME":"Jhon",
        "DATE OF BIRTH":"19/07/2016"
    },
    {
        "FIRST NAME":"Doe",
        "LAST NAME":"Janette",
        "DATE OF BIRTH":"19/07/2016"
    }
]

四：解析json字符串报文

解析报文：

    @Test
    public void test01(){
        String str1="{'head':{'transSeq':'111111111'},body:{'glblSrlNo':'202111141404123','reqSrlNo':'202111141404123'}}";
        JSONObject jsonObject = JSONObject.parseObject(str1);
        Map head = (Map)jsonObject.get("head");
        String transSeq = (String) head.get("transSeq");
        System.out.println(transSeq);
    }

生成报文：

    @Test
    public void test02(){
        Map map = new HashMap<>();
        Map map1 = new HashMap<>();
        Map map2 = new HashMap<>();
        map1.put("rspCd", "ms00000");
        map1.put("rspInfo", "秘钥生成成功");
        map2.put("glblSrlNo","202111141404123");
        map2.put("reqSrlNo", "202111141404123");
        map.put("head", map1);
        map.put("body", map2);
        String s = JSON.toJSONString(map);
        System.out.println(s);
        //{"head":{"rspCd":"ms00000","rspInfo":"秘钥生成成功"},"body":{"glblSrlNo":"202111141404123","reqSrlNo":"202111141404123"}}
    }

输出：

{
    "head":{
        "rspCd":"ms00000",
        "rspInfo":"秘钥生成成功"
    },
    "body":{
        "glblSrlNo":"202111141404123",
        "reqSrlNo":"202111141404123"
    }
}

 

 

 

 

Ba～ba～tang
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
fastjson java 字段排序_「Java」 - xml & Json 排序输出
weixin_36179941的博客
01-10 505
项目封装了新的SDK，需要对SDK进行测试，API没有变更。设计一自动化CASE：通过openapi的方式调用YAPI上接口测试用例，返回结果A；引入SDK，编写单元测试代码，通过SDK调用接口，返回结果B；对结果（xml/Json）进行排序后断言。因为整个环境只有SDK是新的，所以完成以上CASE，基本可以找出SDK中存在的Bug。但是返回结果中xml和Json的属性顺序不一定相对，所以用基本的...
fastjson 添加key value_为什么Fastjson能够做到这么快
weixin_39683978的博客
11-22 198
一、FastJson介绍在日常的java项目开发中，JSON的使用越来越频繁，对于Json的处理工具也有很多。接下来就介绍一下阿里开源的一个高性能的JSON框架FastJson，功能完善，完全支持标准JSON库，现在已经越来越受到开发者的青睐。二、 FastJson的特点： 1) FastJson数据处理速度快，无论序列化(把JavaBean对象转化成Json格式的字符串)和反序列...
最全FastJson的基本使用_fastjson 下标几开始(1)，2024年最新阿里巴巴物联网嵌入式开发面试都问些什么
最新发布
2401_85015259的博客
05-15 1707
SimplePropertyPreFilter filter = new SimplePropertyPreFilter(实体类.class, “字段1”,“字段2”);字段为我们需要序列化的字段，如果实体类中没有改字段则不解析放弃该字段而不会报错。这个还有toJSONString 重载的方法，有很多，在给一个就是可以按照标准的json 格式输出，上面的输出都不规范，我们来看看，输出结果为：{“age”:24,“id”:0,“name”:“Aaron”}还是一个简单的函数而已，就能办到。
轻松使用fastjson
u013733643的博客
05-19 3232
前言 只有光头才能变强。 文本已收录至我的GitHub精选文章，欢迎Star：https://github.com/ZhongFuCheng3y/3y JSON相信大家对他也不陌生了，前后端交互中常常就以JSON来进行数据交换。而有的时候，我们也会将JSON直接保存在数据库中。 可能就有人不太理解，为什么要将JSON保存在关系型数据库中？ 我在最开始的时候也有类似的疑惑，问了几个同事，得出的结论都差不多：方便扩展，如果那些字段不需要用到索引，改动比较频繁，你又不想改动表的结构，那就可以在数据库中存
fastJSON的使用
weixin_63001822的博客
06-14 417
作用：实现java对象和json的字符串转换。2、java对象转json字符串。3、json字符串转java对象。
XtraGrid排序概述
LUOCHENLONG的专栏
07-05 537
弹出的排序菜单菜单的可用性由视图的 GridOptionsMenu.EnableColumnMenu 属性控制。 菜单的内容可以被定制，如同在 为弹出式菜单实现自定义行为 章节中描述的那样。 在网格视图中， GridOptionsCustomization.AllowSort 属性可以用于阻止最终用户改变视图中任何列的当前排序设置。 OptionsColumn.AllowSort 选项可以用
fastjson 使用方法详细介绍
10-19
Fastjson是一个Java语言编写的JSON处理器,由阿里巴巴公司开发。接下来通过本文给大家分享fastjson 使用方法详细介绍，感兴趣的朋友一起看看吧
fastjson使用
10-30
**Fastjson 深度解析与使用指南** Fastjson 是阿里巴巴开源的一款高性能的 JSON 库，它具有极快的解析速度和简洁的 API 设计，广泛应用于 Java 开发中。在本文中，我们将深入探讨 Fastjson 的核心特性、基本用法、...
fastjson使用实例
02-23
以下是Fastjson使用的一些关键知识点： 1. **基本使用**：首先需要引入Fastjson的依赖，通常通过Maven或Gradle进行管理。例如，在Maven中添加以下依赖： ```xml <groupId>com.alibaba</groupId> <artifactId>...
fastjson（JSONObject、JSONArray）使用及相互转换
kimi
02-01 8907
fastjson（JSONObject、JSONArray）使用及相互转换
fastjson的基本使用方法
qq_43215592的博客
12-21 1万+
常用json格式 int型数组： { "arr" : [80,81,82,83] } string数组 { "arr" : ["a","b","c","d"] } List<Integer>: { "list" : [14120913 , 14120914 , 14120915 , 14120916] } List<String>: { "list" : ["ASD14120913","ASD14120914","ASD14120915","ASD14120916.
fastjson SerializerFeature详解
热门推荐
孤天浪雨
09-14 15万+
依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.7</version> </dependency>SerializerFeature属性 名称 含义
fastjson排序问题-如何改变fastjson的排序规则
一年e度的夏天的专栏
12-09 3万+
fastjson在封装成json的时候会自动按照属性名称排序，也就是abcd…的顺序排序。 但是很多时候，我们可能需要json有一定的顺序，且按照我们的顺序，好了，让我们来看看如何。 首先：写一个实体类，用于转化成json用package com.dzy.fastjson;public class Letter { private Long id; private String na
fastjson使用教程
m0_51527921的博客
03-30 1069
序列化 序列化就是指 把JavaBean对象转成JSON格式的字符串。 1.一般对象序列化 Map<String,Object> map = new HashMap<String,Object>(); map.put("id","1"); map.put("name","zhangsan"); map.put("now", LocalDateTime.now()); map.put("now1", new Date()); map.put("nullVal", null)
fastJson使用教程
weixin_40159122的博客
12-06 235
Json是一种轻量级的数据交换模式，采用一种“键：值”对的文本格式来存储和表示数据，在系统交换数据的过程中常常被使用，是一种理想的数据交换语言。 一、json的形式 json的形式分为json对象、json字符串、json对象数组； json对象： { "id":123, "name":二月红, "age":20 } json对象数组： [ { "id":123,"name":二月...
FastJson使用技巧
LXYDSF的博客
12-03 3496
fastjson是阿里巴巴的开源JSON解析库，它可以解析JSON格式的字符串，支持将Java Bean序列化为JSON字符串，也可以从JSON字符串反序列化到JavaBean。 Fastjson 可以操作任何 Java 对象，即使是一些预先存在的没有源码的对象。
MiniUi框架简单实例
翻滚吧->阿城的博客
03-24 2万+
Miniui，框架，案例，代码
普元nui:几种情况下的数据收发
剑来
12-11 1387
1、分页查询 datagrid框架 <div id="datagrid1" dataField="data" class="nui-datagrid" style="width: 100%; height: 100%;" url="<%=request.getContextPath()%>/syzcdDksqxxb/queryShow.do?show=spList" ...
asp GridView AllowSorting 不生效
霍城延的随笔
01-21 508
最近在维护一个N年老项目，想着在Gridview 设置AllowSorting="true"但排序还不管用。 <asp:GridView ID="GridView1" runat="server" AllowPaging="True" AutoGenerateColumns="False" CellPadding="4" CssClass ="gridview" onpageindexchanging="GridView1_Pa...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值