Java对象与Json对象的相互转化之Jackson实现方式

　　平常应用之间传输信息，一般用的json，这就需要将Java对象转化为json来进行传输，，而且目前有很多转化为json的方式，这里暂且总结一下各种转化为json的方式，方便后期用到的话直接拿过来就可以了。

　　１．使用Jackson方式
　　这里使用的是Maven来创建工程，针对Jackson使用下面这些依赖即可，如果是创建普通的Java工程，那么就需要这三个Jar包
　　

 <dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.8.6</version>
</dependency>
   <dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.8.7</version>
</dependency>

　　接下里是代码，因为一般传输的对象不止一个，所以这里创建多个对象存入List实现，首先创建一个简单的Java Bean对象
　　

public class Person {
        private String name;  
        private int age;  
        private boolean sex;  
        private Date birthday;  
        private String word;  
        private double salary;  

        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 boolean isSex() {  
            return sex;  
        }  

        public void setSex(boolean sex) {  
            this.sex = sex;  
        }  

        public Date getBirthday() {  
            return birthday;  
        }  


        public void setBirthday(Date birthday) {  
            this.birthday = birthday;  
        }  

        public String getWord() {  
            return word;  
        }  

        public void setWord(String word) {  
            this.word = word;  
        }  


        public double getSalary() {  
            return salary;  
        }  

        public void setSalary(double salary) {  
            this.salary = salary;  
        }  

        public Person(String name, int age) {  
            this.name = name;  
            this.age = age;  
        }  

        public Person(String name, int age, boolean sex, Date birthday,  
                String word, double salary) {  
            super();  
            this.name = name;  
            this.age = age;  
            this.sex = sex;  
            this.birthday = birthday;  
            this.word = word;  
            this.salary = salary;  
        }  

        public Person() {  
        }  

        @Override  
        public String toString() {  
            return "Person [name=" + name + ", age=" + age + ", sex=" + sex  
                    + ", birthday=" + birthday + ", word=" + word + ", salary="  
                    + salary + "]";  
        }  
}

　　接下来写一个小demo，创建一系列Java对象，将其转化为json字符串存在本地的后缀为json的文件中，后期如果需要可以直接从本地文件粘贴json字符串。另外一个方法是从本地读取json文件，将其输出到控制台，代码很简单，直接贴一下
　　

public class Demo {
    public static  List<Person> list;
       public static void main(String[] args) {  

            writeJsonObject();  

            readJsonObject();  
        }  

        // 直接写入一个对象(所谓序列化)，这里是将单个对象写入到本地文件

        public static void writeJsonObject() {  
            ObjectMapper mapper = new ObjectMapper();  
            Person person = new Person("nomouse", 25, true, new Date(), "程序员",  
                    2500.0); 
            Person person2 = new Person("Jack", 26, true, new Date(), "程序员",  
                    2600.0);
            Person person3 = new Person("Tom", 27, true, new Date(), "程序员",  
                    2600.0);
            Person person4 = new Person("Kelly", 27, true, new Date(), "程序员",  
                    2600.0);  
            list=new ArrayList<Person>();
            list.add(person);
            list.add(person2);
            list.add(person3);
            list.add(person4);
            try {  
                mapper.writeValue(new File("d:/person2.json"), list); 

            } catch (JsonGenerationException e) {  
                e.printStackTrace();  
            } catch (JsonMappingException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  

       //  直接将一个json转化为对象（所谓反序列化）  
        public static void readJsonObject() {  
            ObjectMapper mapper = new ObjectMapper();  

            try {  
              JsonNode node= mapper.readTree(new File("d:/person2.json"));
              System.out.println(node.toString());
            } catch (JsonParseException e) {  
                e.printStackTrace();  
            } catch (JsonMappingException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
}

　　简单解释一下，核心是Jackson中的ObjectMapper类，在序列化过程中调用writeValue方法，指定两个参数，一个是本地文件的地址可以不存在，另一个参数是Java对象，可以是单个对象也可以是个List对象，在读取json对象调用ObjectMapper的readTree方法即可，指定本地文件位置，得到一个JsonNode对象，之后调用toString方法输出即可。
　　当然如果觉得比较麻烦，不需要将json文件写到本地，而是将生成的json字符串直接输出到控制台，直接使用下面的两行代码即可，这个方法的参数可以接受单个java对象，也可以接受一个list数组，非常方便
　　

System.out.println(mapper.writeValueAsString(person));
System.out.println(mapper.writeValueAsString(list));

　　如果将json字符串转化为json对象，不想通过读取本地json文件的方式，可以直接将json字符串转化为Java对象，直接贴代码
　　

public static void Json2Java() {
        ObjectMapper mapper = new ObjectMapper();
        Person person = new Person("nomouse", 25, true, new Date(), "程序员", 2500.0);
        Person person2 = new Person("Jack", 26, true, new Date(), "程序员", 2600.0);
        Person person3 = new Person("Tom", 27, true, new Date(), "程序员", 2600.0);
        Person person4 = new Person("Kelly", 27, true, new Date(), "程序员", 2600.0);
         String json3 = "{\"name\":\"zhangsan\",\"age\":20,\"sex\":true,\"birthday\":\"2017-01-11\",\"word\":\"程序员\",\"salary\":3000}";  
        List<Person> list = new ArrayList<Person>();
        list.add(person);
        list.add(person2);
        list.add(person3);
        list.add(person4);
        try {
            String json = mapper.writeValueAsString(person);

            try {
                Person p1=mapper.readValue(json, Person.class);
                Person p2=mapper.readValue(json3, Person.class);
                System.out.println(p1.toString());
                System.out.println("p2:"+p2);
                String json2=mapper.writeValueAsString(list);
                List<Person> list2=mapper.readValue(json2, new TypeReference<List<Person>>() {
                });
                for (Person p : list2) {
                    System.out.println(p);
                }
                System.out.println(list2.toString());
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (JsonProcessingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

　　简单来说，你可以手动拼接json字符串，也可以通过Java对象转化为的json字符串作为参数，当然为了方便起见，推荐后边这种。

　　PS：最近一直很忙，拖了很久，这篇中断后又写的，思路比较混乱，所以说做事最好一下做完，能不要中断就尽量不要中断。不过既然这样了，这里就简单总结下整理下思路：
　　Java对象转化为Json对象：核心是ObjectMapper对象
　　通过调用writeValue方法可以将指定的Java对象以json文件的形式存到本地，这里可以是单个Java对象也可以是List对象
　　通过调用writeValueAsString方法，可以将Java对象或者List对象转化为Json对象或Json数组，这种方式方便直接在控制台进行输出
　　通过调用readValue方法，接受json对象或者是json数组，如果是单个json对象，那么第二个参数就用XXX.class即可，如果接受的是json数组，第二个参数用new TypeReference xxx格式即可。
　　差不多就这样，后期写个封装工具类好了，那么这篇赶快结束吧，中断后再写真痛苦哈哈，其实还有好几种json包的使用，如果有时间再写吧，没有就用这个了