fastJson 一些小例子

最新推荐文章于 2024-08-19 15:54:55 发布
最新推荐文章于 2024-08-19 15:54:55 发布
阅读量213 收藏
点赞数
文章标签： json java
原文链接：https://my.oschina.net/qimhkaiyuan/blog/3077883
版权 
package com.*;

import com.alibaba.fastjson.annotation.JSONField;

public class VO {

    @JSONField(name="ID")
    private int id;


    public int getId() {
        return id;
    }

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

    @Override
    public String toString() {
        return "VO{" +
                "id=" + id +
                '}';
    }
}

package com.*;

import com.alibaba.fastjson.annotation.JSONField;

public class VO {

    @JSONField(name="ID")
    private int id;


    public int getId() {
        return id;
    }

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

    @Override
    public String toString() {
        return "VO{" +
                "id=" + id +
                '}';
    }
}

测试类：

package com.*;

import ch.qos.logback.core.net.SyslogOutputStream;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.deserializer.ExtraProcessor;
import com.alibaba.fastjson.serializer.PropertyFilter;
import com.paic.gamma.apply.common.KeyGenerator;
import lombok.ToString;
import org.apache.commons.lang3.time.FastDateFormat;

import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;

public class TestString {

    public static void main(String[] strs){

        System.out.println("uuid:" +  KeyGenerator.uuid());

        String date = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss").format(new Date());
        System.out.println(date);

        System.out.println("数字："+ThreadLocalRandom.current().nextInt(10));

        int[] in = new int[]{11,22,33};

        List<String> list = Arrays.asList("aa","bb","cc");

        Map<String,String> map =list.stream().filter(s-> s.equals("aa")).collect(Collectors.toMap(String::toString,String::toString));
        System.out.println("list:" + list);
        System.out.println("map:" + map);

        testFastJson();
        testParseFastJson();
        serializeFilterFastJson();
        unserializeJsonToObject();
        testParseFastJson2();
    }




    public static void testFastJson(){

        VO vo = new VO();
        vo.setId(11);

        String str = JSON.toJSONString(vo);
        System.out.println(str);

    }

    /**
     * 反序列化，但是添加了反序列化的过滤
     */
    public static void testParseFastJson(){

        ExtraProcessor processor = new ExtraProcessor() {
            public void processExtra(Object object, String key, Object value) {
                VO2 vo = (VO2) object;
                vo.getAttributes().put(key, value);
            }
        };

        VO2 vo = JSON.parseObject("{\"id\":123,\"name\":\"abc\"}", VO2.class, processor);
        System.out.println("VO2:"+ vo);

    }

    /**
     * 反序列化，但是添加了反序列化的过滤
     */
    public static void testParseFastJson2(){

        ExtraProcessor processor = new MyExtraProcessor();

        // value本应该是字符串类型的，通过getExtraType的处理变成Integer类型了。
        VO2 vo = JSON.parseObject("{\"id\":123,\"value\":\"123456\"}", VO2.class, processor);

        System.out.println("vo:" + vo);

    }


    /**
     * 序列发字符串，添加了过滤条件
     */
    public static void serializeFilterFastJson(){
        PropertyFilter filter = new PropertyFilter() {

            public boolean apply(Object source, String name, Object value) {
                if ("ID".equals(name)) {
                    int id = ((Integer) value).intValue();
                    return id >= 100;
                }
                return false;
            }
        };

        VO vo = new VO();
        vo.setId(111);
        String jsonStr = JSON.toJSONString(vo, filter); // 序列化的时候传入filter

        System.out.println("jsonStr:"+jsonStr);

    }


    /**
     * 反序列化
     */
    public static void unserializeJsonToObject(){

        String jsonStr = "{\"id\":99}";
        System.out.println("jsonStr:" + jsonStr);

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

        System.out.println("vo:" + vo);


    }

}

 

 

 

package com.*;

import java.util.*;

public class Foo {

    private String vString = "vStringhehhehe";
    private char vchar = 'x';

    private byte vbyte = 64;
    private short vshort = 128;
    private int vint = 65535;
    private long vlong = 9999999L;

    private float vfloat = 12.1f;
    private double vdouble = 22.203d;

    private boolean vboolean = false;

    //	private Date vdate = new Date();
    private Date dddd = new Date();
    private Date vDate = new Date();
    private Date v_Date = new Date();
    private Object vnull = null;

    private String[] avString = {"aaa", "bbb", "ccc"};
    private int[] avint = {1, 2, 3, 4};
    private boolean[] avboolean = {true, false, true, true};

    private List<String> listString = new ArrayList<String>();
    private Map<String, String> map = new HashMap<String, String>();

    private Bar bar = new Bar();
    private Bar[] avBar = {new Bar(), new Bar()};
    private List<Bar> listBar = new ArrayList<Bar>();

    {
        listString.add("listString1");
        listString.add("listString2");
        listString.add("listString3");

        map.put("x", "s11111x");
        map.put("y", "s22222y");
        map.put("z", "s33333z");

        listBar.add(new Bar());
        listBar.add(new Bar());
        listBar.add(new Bar());
    }



    public String getvString() {
        return vString;
    }

    public void setvString(String vString) {
        this.vString = vString;
    }

    public char getVchar() {
        return vchar;
    }

    public void setVchar(char vchar) {
        this.vchar = vchar;
    }

    public byte getVbyte() {
        return vbyte;
    }

    public void setVbyte(byte vbyte) {
        this.vbyte = vbyte;
    }

    public short getVshort() {
        return vshort;
    }

    public void setVshort(short vshort) {
        this.vshort = vshort;
    }

    public int getVint() {
        return vint;
    }

    public void setVint(int vint) {
        this.vint = vint;
    }

    public long getVlong() {
        return vlong;
    }

    public void setVlong(long vlong) {
        this.vlong = vlong;
    }

    public float getVfloat() {
        return vfloat;
    }

    public void setVfloat(float vfloat) {
        this.vfloat = vfloat;
    }

    public double getVdouble() {
        return vdouble;
    }

    public void setVdouble(double vdouble) {
        this.vdouble = vdouble;
    }

    public boolean isVboolean() {
        return vboolean;
    }

    public void setVboolean(boolean vboolean) {
        this.vboolean = vboolean;
    }

    public Date getDddd() {
        return dddd;
    }

    public void setDddd(Date dddd) {
        this.dddd = dddd;
    }

    public Date getV_Date() {
        return v_Date;
    }

    public void setV_Date(Date v_Date) {
        this.v_Date = v_Date;
    }

    public Date getvDate() {
        return vDate;
    }

    public void setvDate(Date vDate) {
        this.vDate = vDate;
    }

    public Object getVnull() {
        return vnull;
    }

    public void setVnull(Object vnull) {
        this.vnull = vnull;
    }

    public String[] getAvString() {
        return avString;
    }

    public void setAvString(String[] avString) {
        this.avString = avString;
    }

    public int[] getAvint() {
        return avint;
    }

    public void setAvint(int[] avint) {
        this.avint = avint;
    }

    public boolean[] getAvboolean() {
        return avboolean;
    }

    public void setAvboolean(boolean[] avboolean) {
        this.avboolean = avboolean;
    }

    public List<String> getListString() {
        return listString;
    }

    public void setListString(List<String> listString) {
        this.listString = listString;
    }

    public Map<String, String> getMap() {
        return map;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public Bar getBar() {
        return bar;
    }

    public void setBar(Bar bar) {
        this.bar = bar;
    }

    public Bar[] getAvBar() {
        return avBar;
    }

    public void setAvBar(Bar[] avBar) {
        this.avBar = avBar;
    }

    public List<Bar> getListBar() {
        return listBar;
    }

    public void setListBar(List<Bar> listBar) {
        this.listBar = listBar;
    }
}

 

package com.*;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializeConfig;
import com.alibaba.fastjson.serializer.SimpleDateFormatSerializer;

import java.util.Date;
import java.util.Random;

public class Bar {

    public static SerializeConfig mapping = new SerializeConfig();
    private String barName;
    private int barAge;
    private Date barDate = new Date();
    static {
        mapping.put(Date.class, new SimpleDateFormatSerializer("yyyy-MM-dd"));
    }
    {
        Random r = new Random();
        barName = "sss_"+String.valueOf(r.nextFloat());
        barAge = r.nextInt();
    }

    public static void main(String[] args) {
        Object obj = JSON.toJSON(new Bar());
        String x1 = JSON.toJSONString(new Bar(), true);
        System.out.println(x1);
        String x2 = JSON.toJSONString(new Bar(), mapping);
        System.out.println(x2);
    }

    public String getBarName() {
        return barName;
    }

    public void setBarName(String barName) {
        this.barName = barName;
    }

    public int getBarAge() {
        return barAge;
    }

    public void setBarAge(int barAge) {
        this.barAge = barAge;
    }

    public Date getBarDate() {
        return barDate;
    }

    public void setBarDate(Date barDate) {
        this.barDate = barDate;
    }

    @Override
    public String toString() {
        return "Bar{" +
                "barName='" + barName + '\'' +
                ", barAge=" + barAge +
                ", barDate=" + barDate +
                '}';
    }
}

 

测试类2：

package com.*;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.serializer.SerializeConfig;
import com.alibaba.fastjson.serializer.SimpleDateFormatSerializer;

import java.util.*;

public class TestFastJson {

    private static SerializeConfig mapping = new SerializeConfig();
    static {
        mapping.put(Date.class, new SimpleDateFormatSerializer("yyyy-MM-dd HH:mm:ss"));
    }

    public static void main(String[] args) {
        Foo f1 = new Foo();
        Date date = new Date();
        String text = JSON.toJSONString(date, mapping);
        System.out.println("text:" + text);
        //格式化后的json字符串
        System.out.println("f1:" + JSON.toJSONString(f1, true));
        //java bean 中的日期字段被格式化成yyyy-MM-dd HH:mm:ss
        String x2 =JSON.toJSONString(f1, mapping);
        System.out.println("x2:" + x2);
    }

    public static void json2List(){
        //List -> JSON array
        List<Bar> barList = new ArrayList<Bar>();
        barList.add(new Bar());
        barList.add(new Bar());
        barList.add(new Bar());
        String json= JSON.toJSONString(barList, true);
        System.out.println(json);
        //JSON array -> List
        List<Bar> barList1 = JSON.parseArray(json,Bar.class);
        for (Bar bar : barList1) {
            System.out.println(bar.toString());
        }
    }

    public static void json2Map(){
        //Map -> JSON
        Map<String,Bar> map = new HashMap<String, Bar>();
        map.put("a",new Bar());
        map.put("b",new Bar());
        map.put("c",new Bar());
        String json = JSON.toJSONString(map,true);
        System.out.println(json);
        //JSON -> Map
        Map<String,Bar> map1 = (Map<String,Bar>)JSON.parse(json);
        for (String key : map1.keySet()) {
            System.out.println(key+":"+map1.get(key));
        }
    }

    public static void array2JSON(){
        String[] arr_String    = {"a","b","c"};
        String json_arr_String = JSON.toJSONString(arr_String,true);
        System.out.println(json_arr_String);
        JSONArray jsonArray = JSON.parseArray(json_arr_String);
        for (Object o : jsonArray) {
            System.out.println(o);
        }
        System.out.println(jsonArray);
    }
    public static void array2JSON2(){
        Bar[] arr_Bar    = {new Bar(),new Bar(),new Bar()};
        String json_arr_Bar = JSON.toJSONString(arr_Bar,true);
        System.out.println(json_arr_Bar);
        JSONArray jsonArray = JSON.parseArray(json_arr_Bar);
        for (Object o : jsonArray) {
            System.out.println(o);
        }
        System.out.println(jsonArray);
    }

    public static void map2JSON(){
        Map map = new HashMap();
        map.put("a","aaa");
        map.put("b","bbb");
        map.put("c","ccc");
        String json= JSON.toJSONString(map);
        System.out.println(json);
        Map map1 = JSON.parseObject(json);
        for (Object o : map.entrySet()) {
            Map.Entry<String,String> entry = (Map.Entry<String,String>)o;
            System.out.println(entry.getKey()+"--->"+entry.getValue());
        }
    }
}

 

参考连接：https://www.w3cschool.cn/search?w=SerializeConfig

 

maven 坐标：

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

转载于:https://my.oschina.net/qimhkaiyuan/blog/3077883

chuoerqiao8180
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
fastjson 使用详解
qq_22989777的博客
07-26 1910
一. JSON 二. 主流框架介绍 2.1. Gson Gson是目前功能最全的Json解析神器，Gson当初是为因应Google公司内部需求而由Google自行研发而来 无依赖，不需要例外额外的jar，能够直接跑在JDK上。 类里面只要有get和set方法，Gson完全可以将复杂类型的json到bean或bean到json的转换，是JSON解析的神器。 Gson在功能上面无可挑剔...
JAVA API中的parse_Fastjson API ParseProcess
weixin_29009971的博客
02-27 330
1. Fastjson API ParseProcess简介ParseProcess是编程扩展定制反序列化的接口。fastjson支持如下ParseProcess：ExtraProcessor 用于处理多余的字段ExtraTypeProvider 用于处理多余字段时提供类型信息2. 使用ExtraProcessor 处理多余字段public static class VO {private int...
fastjson（六）通过ParseProcess定制反序列化
挖坑埋你
01-27 7649
ParseProcess是编程扩展定制反序列化的接口。fastjson支持如下ParseProcess： ExtraProcessor 用于处理多余的字段； ExtraTypeProvider 用于处理多余字段时提供类型信息。 下面来看示例代码： 示例对象： package json.fastjson.ParseProcess; import java.util.HashMap;
【FastJson】学习笔记
hupengfei_shenyang的博客
05-15 1159
FastJsonFastJson 介绍是什么使用场景优点使用序列化和反序列化将 Java 对象转换为 JSON 格式@JSONField 注解的功能FastJson 还支持 BeanToArray 序列化功能JSON 字符串转换为 Java 对象使用 ContextValueFilter 配置 JSON 转换使用 NameFilter 和 SerializeConfigFastjson 定制序列化通过@JSONField定制序列化通过@JSONType定制序列化通过SerializeFilter定制序列化通
渗透测试 | FastJson漏洞原理与复现
m0_60571990的博客
03-09 1413
渗透测试 | FastJson漏洞原理与复现
fastjson的一个小例子
11-19
在这个小例子中，我们将深入探讨FastJson的使用方法，以及它如何帮助开发者在Android开发中快速处理JSON数据。 在Android应用开发中，JSON是一种常见的数据交换格式，用于在服务器和客户端之间传递数据。FastJson以...
fastjson的各种用法例子
04-18
**Fastjson：高效且强大的JSON库** Fastjson是阿里巴巴开源的一款高性能的Java JSON库，它不仅支持JSON到Java对象的映射，还提供了方便的JSON字符串解析和生成功能。在Java开发中，Fastjson因其简单易用、性能优异...
Android FastJSON小示例
09-28
在这个例子中，我们使用`JSON.parseObject()`方法将JSON字符串解析成`JSONObject`对象，然后通过键值对获取对应的值。 同样，FastJSON也支持将Java对象转换为JSON字符串： ```java import ...
lotus domino 结合fastjson开发例子
03-02
lotus domino 结合fastjson开发例子
fastjson基础
05-13
FastJson 是阿里巴巴提供的一款高效、功能丰富的 Java 语言编写的 JSON 库。它不仅支持 JSON 数据的序列化（将 Java 对象转换成 JSON 字符串）和反序列化（将 JSON 字符串转换成 Java 对象），还提供了许多便利的...
fastjson反序列化的时候报错
有梦想的咸鱼
12-26 7774
java.lang.VerifyError: (class: com/alibaba/fastjson/parser/deserializer/FastjsonASMDeserializer_2_类名, method: deserialze signature: (Lcom/alibaba/fastjson/parser/DefaultJSONParser;Ljava/lang/reflect/Ty
fastjson使用心得
热门推荐
Coder的不平凡
11-20 1万+
喜欢fastjson，因为只需要依赖JDK，其他环境都不需要依赖就可以使用。而且它非常的快。这里我也把使用它的一些感悟和总结写出来，供大家指正。         说到fastjson，我们就要懂得一个概念就是序列化：将对象信息转换为可以传输和存储的信息【百度百科】
(Lcom/alibaba/fastjson/parser/DefaultJSONParser;--Accessing value from uninitialized register 52解决方法
菜鸟
05-05 5737
(Lcom/alibaba/fastjson/parser/DefaultJSONParser;Ljava/lang/reflect/Type;Ljava/lang/Object;I)Ljava/lang/Object;) Accessing value from uninitialized register 52 在敲代码的时候因为在一个VO对象里面多加了两个属性，导致原来的方法报错，根据网上...
Python爬虫案例二：获取虎牙主播图片(动态网站)
m0_74614835的博客
08-19 793
params不能写在__init__()里面，因为__init__()只执行一次，params是变化的。'iPageNo': '{}'.format(i), # i是字符串。print('ok 第{}张--{}'.format(self.no, name))1.异步数据（即先返回HTML，再返回目标的数据，只是触发了JSON请求），不在HTML中。os.mkdir('../虎牙')测试链接：https://live.huya.com/# 构造7页的params。2.不能刷新网页，直接翻页。
字符串值提取工具-08-java 执行 xml 解析, xpath
08-18 241
我们希望通过 java 执行 xml-path 解析 xml。
JWT（JSON Web Token）工作原理及特点
modelsetget的博客
08-18 360
总结了JWT的基本概念、结构、工作流程、优势以及一些深入思考问题，希望对您理解JWT有所帮助。
MySQL中处理JSON数据:大数据分析的新方向
Chujun123528的博客
08-18 1183
灵活性：JSON数据类型允许你在单个列中存储复杂的数据结构，如数组和嵌套对象，这减少了需要创建多个表来存储相关信息的必要性。查询能力：MySQL为JSON数据类型提供了一系列内置的函数，如, , , , , 等，使得查询和修改JSON数据变得非常便捷。索引支持：MySQL支持为JSON文档中的特定路径创建虚拟列（Generated Columns），然后可以在这些虚拟列上创建索引，从而加速基于JSON内容的查询。性能优化：随着MySQL的不断改进，对JSON数据的处理性能也在不断提高。虽然与专门的NoSQL
学习分享： Java 中调用 API 的一般方式
最新发布
weixin_71842181的博客
08-19 346
学习分享： Java 中调用 API 的一般方式。
fastjson2和fastjson的区别
12-09
以下是一个使用fastjson2的例子，用于将JSON字符串转换为Java对象： ```java import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; public class FastJsonDemo { public static void main...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值