FastJson Jackson Gson使用教程
1. Gson
Gson是非常强大的API，它支持Java泛型，支持现成的JSON与Java对象的转换，只要对象的成员名称与JSON中的一致即可。如果针对Java bean和JSON要使用不同的名称，那么可以使用@SerializedName注解来映射JSON和Java类中的变量。
Gson是主类，它暴露出fromJson()和toJson()方法进行转换工作，对于默认实现，可以直接创建对象，也可以使用GsonBuilder类提供的实用选项进行转换，比如整齐打印，字段命名转换，排除字段，日期格式化等等
public static void objectToJson() {
Person p = new Person("zhaokaiqiang", 22, new Birthday(1992, 1, 19));
//构造Builder设置参数
// Gson gson = new GsonBuilder().setPrettyPrinting().create();
Gson gson = new Gson(); //默认参数
//toJson Object-->Json
String jsonString = gson.toJson(p);
System.out.println("---------单一对象生成--------");
System.out.println(jsonString);
//Json --> Object 单个对象
Person person = gson.fromJson(jsonString, Person.class);
System.out.println("---------单一对象解析--------");
System.out.println(person.toString());
}
public static void objectsToJson() {
Gson gson = new Gson();
Person person = new Person("zhaokaiqiang", 22,
new Birthday(1992, 1, 19));
ArrayList arrayList = new ArrayList<>();
arrayList.add(person);
arrayList.add(person);
arrayList.add(person);
String jsonString = gson.toJson(arrayList);
System.out.println("---------集合对象生成--------");
System.out.println(jsonString);
//集合的类型
Type type = new TypeToken>() {
}.getType();
//集合对象类型
ArrayList persons = gson.fromJson(jsonString, type);
System.out.println("---------集合对象解析--------");
System.out.println(persons.toString());
}
//符合对象key--value
public static String getJsonString() {
Person p = new Person("zhaokaiqiang", 22, new Birthday(1992, 1, 19));
JsonElement element = new JsonParser().parse(new Gson().toJson(p));
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty("name", "zhao");
jsonObject.addProperty("age", 22);
jsonObject.add("person", element);
System.out.println(jsonObject.toString());
return jsonObject.toString();
}
public static void fromJsonString() {
Gson gson = new Gson();
JsonElement jsonElement = new JsonParser().parse(getJsonString());
//JsonObject对象
JsonObject jsonObject = jsonElement.getAsJsonObject();
//key-->value 键值对元素
JsonElement personElement = jsonObject.get("person");
Person person = gson.fromJson(personElement, Person.class);
JsonElement nameElement = jsonObject.get("name");
String name = nameElement.getAsString();
JsonElement ageElement = jsonObject.get("age");
int age = ageElement.getAsInt();
System.out.println(person);
System.out.println(name);
System.out.println(age);
} 类型介绍：
1. Gson：这个类在前面已经用过了，是我们完成Json转换和解析的主要类，主要使用toJson()和fromJson()这两个方法。
2. JsonObject：这个是我们构建Object形式的Json数据的主要类，我们可以设置key和value。
3. JsonElement：这个是Json元素类，它里面可以是一个JsonObject、JsonArray、JsonNull或者是一个JsonPrimitive。注意，它里面的数据只能看作是一个元素。
4. JsonArray：这个是我们想构造Array形式的主要类，我们可以往数组里面添加数据，数据是有序的。
5. JsonParser：这个是Json的解析器，主要作用是把一个Json形式的字符串转换成一个JsonElement对象。
PS：
1）对泛型的支持
//不再重复定义Result类
Type userType = new TypeToken<Result<User>>(){}.getType();
Result<User> userResult = gson.fromJson(json,userType);
User user = userResult.data;
Type userListType = new TypeToken<Result<List<User>>>(){}.getType();
Result<List<User>> userListResult = gson.fromJson(json,userListType);
List<User> users = userListResult.data;2. Jackson
Jackson分为三个库
1. Core库：streaming parser/generator，即流式的解析器和生成器。
2. Annotations库：databinding annotations，即带注解的数据绑定包。
3. Databind库：ObjectMapper, Json Tree Model，即对象映射器，JSON树模型。
我们先介绍一下常用的几个类的功能：
1. JsonFactory：这个类是Jackson项目主要的工厂方法，主要用于配置和构建解析器(比如 JsonParser )和生成器(比如 JsonGenerator) ，这个工厂实例是线程安全的， 如果有配置的话，可以重复使用。
2. JsonGenerator：这个类主要是用来生成Json格式的内容的，我们可以使用JsonFactory的方法生成一个实例。
3. JsonParser：这个主要是用来读取Json格式的内容，并且完成解析操作的，我们可以使用JsonFactory的方法生成一个实例。
4. ObjectMapper：这个类提供了Java对象和Json 之间的转化，主要通过JsonParser和JsonGenerator实例来完成实际的对Json数据的读写操作。这个类是ObjectCodec的子类，主要的实现细节都在ObjectCodec里面。而且这个类可以重复使用，所以一般会创建这个类的一个单例模式。
//单例模式获取ObjectMapper对象
public class JacksonMapper {
private static final ObjectMapper mapper = new ObjectMapper();
private JacksonMapper() {
}
public static ObjectMapper getInstance() {
return mapper;
}
}
//获取对象对应的Json字符串
public static String getJsonString(Object object) throws JsonProcessingException {
return JacksonMapper.getInstance().writeValueAsString(object);
}
//获取对象对应的Json字符串
public static String getJsonString1(Object object) throws IOException {
ObjectMapper mapper = JacksonMapper.getInstance();
StringWriter sw = new StringWriter(); //StringWriter流对象
JsonGenerator gen = new JsonFactory().createGenerator(sw);
mapper.writeValue(gen, object); //把对象写到StringWriter里去
gen.flush();
gen.close();
return sw.toString();
}
//Object --> Json
public static void objectToJson() throws Exception {
Person p = new Person("zhaokaiqiang", 22, new Birthday(1992, 1, 19));
System.out.println(getJsonString(p));
}
//集合List --> Json
public static void objectsToJson() throws Exception {
Person p = new Person("zhaokaiqiang", 22, new Birthday(1992, 1, 19));
ArrayList persons = new ArrayList();
persons.add(p);
persons.add(p);
persons.add(p);
System.out.println(getJsonString(persons));
}
//复杂对象-->Json
public static String createObjectJson() throws Exception {
Person p = new Person("zhaokaiqiang", 22, new Birthday(1992, 1, 19));
StringWriter stringWriter = new StringWriter();
// 必须通过这种方式获取
JsonGenerator jsonGenerator = JacksonMapper.getInstance()
.getFactory().createGenerator(stringWriter);
jsonGenerator.writeStartObject(); //写入不同的对象
jsonGenerator.writeStringField("name", "zhaokaiqiang");
jsonGenerator.writeNumberField("age", 22);
jsonGenerator.writeObjectField("person", p);
jsonGenerator.writeEndObject();
jsonGenerator.flush();
jsonGenerator.close();
System.out.println(stringWriter.toString());
return stringWriter.toString();
}
//数组对象（包含不同类型的数据）--> Json
public static void createArrayJson() throws Exception {
Person p = new Person("zhaokaiqiang", 22, new Birthday(1992, 1, 19));
StringWriter stringWriter = new StringWriter();
// 只能通过这种方式获取
JsonGenerator jsonGenerator = JacksonMapper.getInstance()
.getFactory().createGenerator(stringWriter);
jsonGenerator.writeStartArray();
jsonGenerator.writeString("zhaokaiqiang");
jsonGenerator.writeNumber(22);
jsonGenerator.writeObject(p);
jsonGenerator.writeEndArray();
jsonGenerator.flush();
jsonGenerator.close();
System.out.println(stringWriter.toString());
}
//转换为普通对象
public static void toObject() throws Exception {
ObjectMapper objectMapper = JacksonMapper.getInstance();
Person p = new Person("zhaokaiqiang", 22, new Birthday(1992, 1, 19));
String jsonString = getJsonString(p);
Person person = objectMapper.readValue(jsonString, Person.class);//转换为对象
System.out.println(person.toString());
}
//解析数组对象
public static void toObjects() throws Exception {
Person p = new Person("zhaokaiqiang", 22, new Birthday(1992, 1, 19));
ArrayList persons = new ArrayList<>();
persons.add(p);
persons.add(p);
persons.add(p);
ObjectMapper objectMapper = JacksonMapper.getInstance();
String jsonString = getJsonString(persons);
//泛型支持
JavaType javaType = getCollectionType(ArrayList.class, Person.class);
ArrayList arrayList = objectMapper.readValue(jsonString, javaType);
System.out.println(arrayList);
}
//List HashMap等泛型的支持
public static JavaType getCollectionType(Class collectionClass, Class... elementClasses) {
return JacksonMapper.getInstance().getTypeFactory().constructParametricType(collectionClass, elementClasses);
}
//解析生成复杂对象
public static void fromJsons() throws Exception {
String jsonString = createObjectJson();
ObjectMapper objectMapper = JacksonMapper.getInstance();
JsonNode jsonNode = objectMapper.readTree(jsonString);
JsonNode nameNode = jsonNode.get("name");
JsonNode ageNode = jsonNode.get("age");
JsonNode persoNode = jsonNode.get("person");
String personString = persoNode.toString();
Person person = objectMapper.readValue(personString, Person.class);
System.out.println("person=" + person.toString());
System.out.println("age=" + ageNode.asInt());
System.out.println("name=" + nameNode.asText());
} 3. FastJson
Java Bean 对象 <–> json 字符串 <–> JSONObject 互相转化
Java Bean 对象 <–> json 字符串 <–> JSONArray 对象 互相转化
直接上代码
public static final String json_student = "{\"age\":42,\"id\":1,\"male\":true,\"name\":\"Sherlock Holmes\",\"schoolId\":1}";
public static final String json_array = "[{\"age\":42,\"id\":1,\"male\":true,\"name\":\"Sherlock Holmes\",\"schoolId\":1},{\"age\":42,\"id\":2,\"male\":false,\"name\":\"John Watson\",\"schoolId\":1}]";
public static void toJsonString() {
Student student = new Student(1, "Sherlock Holmes", 42, true, 5);
String json = JSON.toJSONString(student);
System.out.println(json);
System.out.println("-------------");
String format_json = JSON.toJSONString(student, true);
System.out.println(format_json);
}
public static void toJsonTest() {
//创建一个 Student 对象
Student student_s = new Student(1, "Sherlock Holmes", 42, true, 1);
//将 java bean 对象转为 JSONObject 对象
JSONObject object = (JSONObject) JSON.toJSON(student_s);
//JSONObject 直接打印, 打印 toString() 或者 toJSONString() 输出结果是一样的
System.out.println(object + " -- 打印 JSONOBject 本身");
System.out.println(object.toString() + " -- 打印 JSONOBject.toString()");
System.out.println(object.toJSONString() + " -- 打印 JSONOBject.toJSONString()");
//再创建一个 Student 对象
Student student_j = new Student(2, "John Watson", 42, false, 1);
//将两个 Student 对象放到 List 集合中
List students = new ArrayList<>();
students.add(student_s);
students.add(student_j);
//将 List 集合对象转为 JSONArray 对象
JSONArray array = (JSONArray) JSON.toJSON(students);
//JSONArray 直接打印, 打印 toString() 或者 toJSONString() 输出结果是一样的
System.out.println(array + " -- 打印 JSONArray 本身");
System.out.println(array.toString() + " -- 打印 JSONArray.toString()");
System.out.println(array.toJSONString() + " -- 打印 JSONArray.toJSONString()");
}
public static void parseArray() {
JSONArray array = JSON.parseArray(json_array);
System.out.println(array);
List students = JSON.parseArray(json_array, Student.class);
students.forEach(System.out::println);
}
public static void parseObject() {
//将 json 字符串转为 JSONObject 对象
JSONObject object = JSON.parseObject(json_student);
//打印 JSONObject 对象
System.out.println(object);
//将 json 字符串转为 Student 对象
Student student = JSON.parseObject(json_student, Student.class);
//打印 Student 对象
System.out.println(student.toString());
}
public static void parse() {
//将 json 字符串转为 JSONObect 对象
JSONObject object = (JSONObject) JSON.parse(json_student);
//打印 JSONObject 对象
System.out.println(object);
//将 json 字符串 转为 JSONArray 对象
JSONArray array = (JSONArray) JSON.parse(json_array);
//打印 JSONArray 对象
System.out.println(array);
}
public static void jsonObjectTest() {
//创建 一个 Student 对象
Student student = new Student(1, "Sherlock Holmes", 42, true, 1);
//将 Java Bean 对象转为 JSONObject 对象
JSONObject object = (JSONObject) JSON.toJSON(student);
//打印 JSONObject 对象
System.out.println(object.toString());
//获取 JSONObject 对象的 age 和 male 值
String age = object.getString("age");
boolean isMale = object.getBoolean("male");
System.out.println("age : " + age + " , male : " + isMale);
//向 JSONObject 对象中添加单个属性
object.put("action", "fuck");
System.out.println(object.toString());
//向 JSONObject 对象中添加多个属性
Map map = new HashMap<>();
map.put("home", "American");
map.put("school", "harvard");
object.putAll(map);
System.out.println(object.toJSONString());
//移除 JSONObject 对象中的属性
object.remove("action");
System.out.println(object);
//获取 JSONObject 中的属性个数
System.out.println(object.size());
}