Json工具类--使用1.x版本Jackson实现json的序列化和反序列化
简介：使用1.x版本(org.codehaus.jackson包下类)的Jackson实现了json的序列化和反序列化。
1.工具类代码：
import com.fasterxml.jackson.annotation.JsonFormat;
import org.codehaus.jackson.JsonNode;
import org.codehaus.jackson.map.DeserializationConfig;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.SerializationConfig;
import org.codehaus.jackson.node.ObjectNode;
import org.codehaus.jackson.type.TypeReference;
import java.io.IOException;
import java.io.Serializable;
import java.text.SimpleDateFormat;
import java.util.*;
/**
* Created by admin on 2017/9/28.
* 使用1.0版本Jackson实现json和对象互转
*/
public class TestJackson {
public static final ObjectMapper OM = new ObjectMapper();
static{
/**
* 设置将时间转换成指定的格式
*/
OM.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
/**
* 该特性决定了当遇到未知属性（没有映射到属性，没有任何setter或者任何可以处理它的handler），是否应该抛出一个JsonMappingException异常。
* 这个特性一般式所有其他处理方法对未知属性处理都无效后才被尝试，属性保留未处理状态。
* 默认情况下，该设置是被打开的。
*/
OM.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
//OM.disable(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES);
/**
* 是否允许一个类型没有注解表明打算被序列化。默认true，抛出一个异常；否则序列化一个空对象，比如没有任何属性
*/
OM.configure(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS, false);
//以下配置根据具体需要配置
/**
* 这个特性，决定了解析器是否将自动关闭那些不属于parser自己的输入源。
* 如果禁止，则调用应用不得不分别去关闭那些被用来创建parser的基础输入流InputStream和reader；
* 如果允许，parser只要自己需要获取closed方法（当遇到输入流结束，或者parser自己调用 JsonParder#close方法），就会处理流关闭。
* 注意：这个属性默认是true，即允许自动关闭流
*/
//OM.configure(JsonParser.Feature.AUTO_CLOSE_SOURCE, true);
/**
* 该特性决定parser将是否允许解析使用Java/C++ 样式的注释（包括'/'+'*' 和'//' 变量）。
* 由于JSON标准说明书上面没有提到注释是否是合法的组成，所以这是一个非标准的特性；尽管如此，这个特性还是被广泛地使用。
* 注意：该属性默认是false，因此必须显式允许，即通过JsonParser.Feature.ALLOW_COMMENTS 配置为true。
*/
//OM.configure(JsonParser.Feature.ALLOW_COMMENTS, true);
/**
* 这个特性决定parser是否将允许使用非双引号属性名字， （这种形式在Javascript中被允许，但是JSON标准说明书中没有）。
* 注意：由于JSON标准上需要为属性名称使用双引号，所以这也是一个非标准特性，默认是false的。
* 同样，需要设置JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES为true，打开该特性。
*/
//OM.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
/**
* 该特性决定parser是否允许单引号来包住属性名称和字符串值。
* 注意：默认下，该属性也是关闭的。需要设置JsonParser.Feature.ALLOW_SINGLE_QUOTES为true
*/
//OM.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
/**
* 该特性决定parser是否允许JSON字符串包含非引号控制字符（值小于32的ASCII字符，包含制表符和换行符）。 如果该属性关闭，则如果遇到这些字符，则会抛出异常。
* JSON标准说明书要求所有控制符必须使用引号，因此这是一个非标准的特性。
* 注意：默认时候，该属性关闭的。需要设置：JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS为true。
*/
//OM.configure(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true);
/**
* 该特性可以允许接受所有引号引起来的字符，使用‘反斜杠\’机制：如果不允许，只有JSON标准说明书中 列出来的字符可以被避开约束。
* 由于JSON标准说明中要求为所有控制字符使用引号，这是一个非标准的特性，所以默认是关闭的。
* 注意：一般在设置ALLOW_SINGLE_QUOTES属性时，也设置了ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER属性，
* 所以，有时候，你会看到不设置ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER为true，但是依然可以正常运行。
*/
//OM.configure(JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER,true);
/**
* 该特性决定parser是否允许JSON整数以多个0开始(比如，如果000001赋值给json某变量，
* 如果不设置该属性，则解析成int会抛异常报错：org.codehaus.jackson.JsonParseException: Invalid numeric value: Leading zeroes not allowed)
* 注意：该属性默认是关闭的，如果需要打开，则设置JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS为true。
*/
//OM.configure(JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS,true);
/**
* 该特性决定JSON对象属性名称是否可以被String#intern 规范化表示。
* 如果允许，则JSON所有的属性名将会 intern() ；如果不设置，则不会规范化，
* 默认下，该属性是开放的。此外，必须设置CANONICALIZE_FIELD_NAMES为true
* 关于intern方法作用：当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串 （该对象由 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String对象添加到池中， 并且返回此 String 对象的引用。
*/
//OM.configure(JsonParser.Feature.INTERN_FIELD_NAMES, true);
/**
* 该特性决定JSON对象的属性名称是否被规范化。
*/
//OM.configure(JsonParser.Feature.CANONICALIZE_FIELD_NAMES, true);
}
public static void main(String[] args) throws IOException {
Person person = new Person();
person.setBirthday(new Date());
String s1 = toJson(person);
System.out.println(s1);
Person person1 = fromJson(s1, Person.class);
System.out.println(person1);
User user = createUser();
String toJson = toJson(user);
System.out.println(toJson);
User fromJson = fromJson(toJson, User.class);
System.out.println(fromJson);
Map map = fromJson(toJson, Map.class);
System.out.println(toJson(map));
List list = new ArrayList<>();
list.add(user);
String listToJson = toJson(list);
System.out.println(listToJson);
List jsonToList = readValuesAsArrayList(listToJson,new TypeReference>(){});
User user1 = jsonToList.get(0);
System.out.println(user1);
ArrayList users = readValuesAsArrayList(listToJson, User.class);
User user2 = users.get(0);
System.out.println(user2);
//创建根节点
ObjectNode root = OM.createObjectNode();
//创建子节点1
ObjectNode node1 = OM.createObjectNode();
node1.put("nodekey1",1);
node1.put("nodekey2", 2);
//绑定子节点1
root.put("child", node1);
System.out.println(toJson(root));
JsonNode child = root.path("child");
JsonNode nodekey = child.path("nodekey");
String textValue = nodekey.getTextValue();
System.out.println(textValue);
}
/**
* 将Json串反序列化成ArrayList集合对象。
* @param json
* @param object
* @param
* @return
*/
public static ArrayList readValuesAsArrayList(String json, Class object) {
try {
return OM.readValue(json, OM.getTypeFactory().constructParametricType(ArrayList.class, object));
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 将Json串反序列化成ArrayList集合对象。
* @param json
* @param t
* @param
* @return
*/
public static ArrayList readValuesAsArrayList(String json, TypeReference> t) {
try {
return OM.readValue(json, t);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 将对象序列化为Json字符串
* @param obj
* @return
*/
public static String toJson(Object obj){
try {
return OM.writeValueAsString(obj);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 将对象序列化为Json字符串，可以指定日期格式
* @param obj
* @param sdf
* @return
*/
public static String toJson(Object obj,SimpleDateFormat sdf){
try {
OM.setDateFormat(sdf);
String result = OM.writeValueAsString(obj);
OM.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
return result;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 将Json串反序列化为对象
* @param json
* @param clazz
* @param
* @return
*/
public static T fromJson(String json, Class clazz){
try {
return OM.readValue(json, clazz);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 将Json串反序列化为对象，可以指定日期格式
* @param json
* @param clazz
* @param sdf
* @param
* @return
*/
public static T fromJson(String json, Class clazz,SimpleDateFormat sdf){
try {
OM.setDateFormat(sdf);
T t = OM.readValue(json, clazz);
OM.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
return t;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 创建User对象，并填充数据
* @return
*/
private static User createUser() {
User user=new User();
user.setId("01");
user.setName("张三");
user.setAge(33);
user.setPay(6666.88);
user.setValid(true);
user.setOne('E');
user.setBirthday(new Date(20l * 366 * 24 * 3600 * 1000));
Link link = new Link();
link.setAddress("河南省");
link.setPhone("13899995555");
link.setQq("123456");
user.setLink(link);
Map map=new HashMap();
map.put("aa", "this is aa");
map.put("bb", "this is bb");
map.put("cc", "this is cc");
user.setMap(map);
List list=new ArrayList(){};
list.add("普洱");
list.add("大红袍");
user.setList(list);
Set set=new HashSet();
set.add("篮球");
set.add("足球");
set.add("乒乓球");
user.setSet(set);
return user;
}
/**
* 联系方式对象，被user使用
*/
public static class Link implements Serializable {
private String phone; //移动电话
private String address; //地址
private String qq; //QQ
public String getPhone()
{
return phone;
}
public void setPhone(String phone)
{
this.phone = phone;
}
public String getAddress()
{
return address;
}
public void setAddress(String address)
{
this.address = address;
}
public String getQq()
{
return qq;
}
public void setQq(String qq)
{
this.qq = qq;
}
@Override
public String toString() {
return "Link{" +
"phone='" + phone + '\'' +
", address='" + address + '\'' +
", qq='" + qq + '\'' +
'}';
}
}
/**
* 用户对象，测试模型类
*/
public static class User implements Serializable {
private String id; //标识
private String name; //姓名
private int age; //年龄
private double pay; //工资
private boolean valid; //是否有效
private char one; //一个字符
private Date birthday; //生日
private Link link; //联系方式，自定义
private Map map; //测试用
private List list; //测试用
private Set set; //测试用
public String getId()
{
return id;
}
public void setId(String id)
{
this.id = id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
public double getPay()
{
return pay;
}
public void setPay(double pay)
{
this.pay = pay;
}
public boolean isValid()
{
return valid;
}
public void setValid(boolean valid)
{
this.valid = valid;
}
public char getOne()
{
return one;
}
public void setOne(char one)
{
this.one = one;
}
public Date getBirthday()
{
return birthday;
}
public void setBirthday(Date birthday)
{
this.birthday = birthday;
}
public Link getLink()
{
return link;
}
public void setLink(Link link)
{
this.link = link;
}
public Map getMap()
{
return map;
}
public void setMap(Map map)
{
this.map = map;
}
public List getList()
{
return list;
}
public void setList(List list)
{
this.list = list;
}
public Set getSet()
{
return set;
}
public void setSet(Set set)
{
this.set = set;
}
@Override
public String toString() {
return "User{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", age=" + age +
", pay=" + pay +
", valid=" + valid +
", one=" + one +
", birthday=" + birthday +
", link=" + link +
", map=" + map +
", list=" + list +
", set=" + set +
'}';
}
}
/**
* Person实体类，测试用
*/
public static class Person implements Serializable {
private String name;
private Integer age;
@JsonFormat(pattern = "yyyy-MM-dd")
private Date birthday;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", birthday=" + birthday +
'}';
}
}
}