簡介：使用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<User> list = new ArrayList<>();
        list.add(user);

        String listToJson = toJson(list);
        System.out.println(listToJson);

        List<User> jsonToList = readValuesAsArrayList(listToJson,new TypeReference<ArrayList<User>>(){});
        User user1 = jsonToList.get(0);
        System.out.println(user1);

        ArrayList<User> 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 <T>
     * @return
     */
    public static <T> ArrayList<T> readValuesAsArrayList(String json, Class<T> 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 <T>
     * @return
     */
    public static <T> ArrayList<T> readValuesAsArrayList(String json, TypeReference<ArrayList<T>> 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 <T>
     * @return
     */
    public static <T> T fromJson(String json, Class<T> clazz){
        try {
            return OM.readValue(json, clazz);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 將Json串反序列化為物件，可以指定日期格式
     * @param json
     * @param clazz
     * @param sdf
     * @param <T>
     * @return
     */
    public static <T> T fromJson(String json, Class<T> 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 +
                    '}';
        }
    }

}