FastJson

介绍

FastJson是阿里巴巴开源的json解析库，它可以解析json格式的字符串

具有特点

  1. 速度快
  2. 使用广泛
  3. 测试完备
  4. 使用简单
  5. 功能完备

Maven FatsJson

如果是使用的Maven做的项目那么只需要在里面的pom.xml文件里面添加如下代码

1
2
3
4
5
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.83</version>
</dependency>

在刷新一下Maven即可

如果添加代码dependency爆红的话只需要在外面加上一层dependencies标签

1
2
3
4
5
6
7
8
9
<dependencies>

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

</dependencies>

序列化 —— java对象转json

[数组] {对象}

1
String s = JSON.toJSONString(对象);

传入对象会以字符串形式返回一个json格式的对象

把java对象转换成json格式的对象

1
2
3
4
5
{
	"键":值,
	"键":值,
	"键":值
}
1
2
3
4
List <泛型> s = new ArrayList<泛型>();  // list集合
s.add(对象1);
s.add(对象2);
String s = JSON.toJSONString(s);

定义一个集合，并传入对象，会以字符串形式返回json格式的数组

数组中包含对象

1
2
3
4
5
6
7
8
9
10
11
12
[
	{
	"键":值,
	"键":值,
	"键":值
	},
	{
	"键":值,
	"键":值,
	"键":值
	}
]
1
2
3
4
Map<键,值> map = new HashMap<键,值>(); // map集合
map.put("键1",值1);
map.put("键2",值2);
String s = JSON.toJSONString(map);

把map里面的键值对序列化成json的字符串

1
2
3
4
5
6
7
8
9
10
11
12
{
	"键1": {
	"键":值,
	"键":值,
	"键":值
	},
	"键2": {
	"键":值,
	"键":值,
	"键":值
	}
}

反序列化 —— json转Java对象

转对象

1
2
3
4
5
String s = "{"键":值,"键":值,"键":值}";
// JSON类的静态方法	parseObject
// 参数1：需要反序列化的json对象
// 参数2：传递Java对象的class对象
对象 对象名 = JSON.parseObject(s,对象.class);

转集合

1
2
3
4
5
String s = [{"键":值,"键":值},{"键":值,"键":值,"键":值}];
// JSON类的静态方法	parseArray
// 参数1：json格式字符串
// 参数2：转换后的集合的泛型的class对象
List<泛型> 集合名 = JSON.parseArray(s,泛型.class);

转Map

1
2
3
4
5
6
7
8
9
10
String s = {"键1":{"键":值,"键":值},"键2":{"键":值,"键":值,"键":值}};
// JSON类的静态方法	parseObject

// 直接进行反序列化是没有泛型的（不安全）
Map 名 = JSON.parseObject(s);

// 调用parseObject，传递参数，TypeReference类型
// 在TypeReference类型中传递转后的Map集合
// 由于TypeReference类型只能被子类继承所以加{}以匿名内部类
Map<键,值> 名 = JSON.parseObjec(s,new TypeReference<Map<键，值>>(){});

枚举

SeriaLizerFeature枚举：进行序列化时，可以自定义特殊需求

json静态方法 toJSONString()

方法参数1：第一个是要序列化的对象

方法参数2：第二个SeriaLizerFeature枚举类型的可变参数

1
2
// WriteMapNullValue	枚举中的常量，序列化null值的字段,值序列化为null
String s = JSON.toJSONString(对象,SeriaLizerFeature.WriteMapNullValue);

举例：在对象中如果不给对象赋值的话那么进行toJSONString时不会序列化值为空的对象，但是添加枚举之后没有复制的对象也会显示值为null

1
2
// WriteNullStringEmpty	枚举常量，序列化为null的字段，值序列化为""
String s = JSON.toJSONString(对象,SeriaLizerFeature.WriteNullStringEmpty);

举例：在对象中如果不给对象赋值的话那么进行toJSONString时不会序列化值为空的对象，但是添加枚举之后没有赋值的对象也会显示值为""

1
2
// WriteNullNumberAsZero	枚举常量，序列化字段值为null的字段，值序列化为0
String s = JSON.toJSONString(对象,SeriaLizerFeature.WriteNullNumberAsZero);

举例：在对象中如果不给对象赋值的话那么进行toJSONString时不会序列化值为空的对象，但是添加枚举之后没有赋值的对象也会显示值为0

1
2
// WriteNullBooleanFalse 枚举常量,序列化字段值为null的字段，值序列化为false
String s = JSON.toJSONString(对象,SeriaLizerFeature.WriteNullBooleanFalse);

举例：在对象中如果不给对象赋值的话那么进行toJSONString时不会序列化值为空的对象，但是添加枚举之后没有赋值的对象也会显示值为false

1
2
// WriteDateUseDateFormat 枚举常量,日期的格式化(前提是得有日期)
String s = JSON.toJSONString(对象,SeriaLizerFeature.WriteDateUseDateFormat);

举例：在对象中进行toJSONString时时间是以一堆数字显示,加入这个之后会以日期的方式显示

它可以传入多个枚举常量中间以,分开即可

1
2
// PrettyFormat 枚举常量,数据格式化
String s = JSON.toJSONString(对象,SeriaLizerFeature.PrettyFormat);

举例：在对象中进行toJSONString时数据的格式是以横向显示的

如:

1
{"键1":{"键":值,"键":值},"键2":{"键":值,"键":值}}

但是经过格式化之后会以这种方式存在

1
2
3
4
5
6
7
8
9
10
{
    "键1":{
        "键":值,
        "键":值
    },
    "键2":{
        "键":值,
        "键":值,
    }
}

注解

进行序列化时进行特性定制

注解一定要作用在要序列化的对象上面

JSONField

JSonField：该注解作用于方法上、字段上、参数上，可在序列化和反序列化时进行特性功能定制

  • name：序列化后的名字（= “名字”）
  • ordinal：序列化后的顺序（= 1 | 2 | 3）
  • format：序列化后的格式（= “YYYY - MM - dd”）
  • serialize：是否序列化该字段（= true | false）
  • deserialize：是否反序列化该字段（= true | false）
  • serialzeFeatures：序列化时的特性定义（跟枚举差不多）
1
2
3
4
5
6
7
public class Student {
    private int id;
    // @JSONField 注解属性 name ，指定序列化后的名字
    @JSONField(name = "sName")
    private String name;
    private int age;
}

上面注解的意思就是在序列化的时候把原本的name名字改成sName

可以有多个注解中间用,分开

JSONType

JSONType：该注解作用于类上，对该类的字段进行序列化和反序列化时的特性功能定制

  • includes：要被序列化的字段（= {“名1” , “名2” , “名3”}）
  • orders：序列化后的顺序（= {“名1” , “名2” , “名3”}）
  • serialzeFeatures：序列化时的特性定义（跟枚举差不多）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 属性：includes 要被序列化的字段
@JSONType(includes = {"id","name","age"})
public class Student {
    private int id;
    private String name;
    private int age;
}

public class Tests{
    public void test(){
 		Student s = new Student();
		s.setId(1);
		s.strName("张三");
		s.setAge(18);       
    }
}

上面的直接的意思是指定要被序列化的对象的属性，比如上面 id、name、age 都写上了，所以都序列化，但是要是不写 id 那么 id 就不会被序列化

上面的JSONField中有一个注解叫 是否序列化该字段 如果给 id 上该注解那么上面没有在JSONType中写 id 的话即使给他上了注解也没用

1
2
3
4
5
6
7
@JSONType(includes = {"name","age"})
public class Student {
    @JSONField(serialize = true)
    private int id;
    private String name;
    private int age;
}