jackson 解析复杂json问题

jackson 解析复杂json问题

jackson常见的json生成和解析的工具包，下面一起看看它对于复杂的json解析时带来的问题

• jackson简介
• jackson依赖包
• jackson解析javaBean
• jackson解析泛型的List
• jackson解析复杂的json

---

jackson简介

Jackson是一种JSON API，也是最流行，速度最快的JSON API。Jackson的在线API文档可以在http://wiki.fasterxml.com/JacksonInFiveMinutes中找到。Jackson的源代码托管在：https://github.com/FasterXML/jackson。
Jackson提供了两种不同的JSON解析器：
ObjectMapper：把JSON解析到自定义的Java类中，或者解析到一个Jackson指定的树形结构中（Tree model）。
Jackson JsonParser：一种“拉式”（pull）解析器，每次解析一组JSON数据。
Jackson也包含了两种不同的JSON生成器：
ObjectMapper：把自定义的Java类，或者一个Jackson指定的树形结构生成为JSON文件。
Jackson JsonGenerator：每次只生成一组JSON数据。

jackson依赖包

Jackson包含一个core JAR，和两个依赖core JAR的JAR：
Jackson Core
Jackson Annotations
Jackson Databind
其中Jackson Annotations依赖Jackson Core，Jackson Databind依赖Jackson Annotations。
这三个JAR可以从Maven中央仓库下载，然后放在CLASSPATH中，也可以用Maven配置：

<dependency>  
      <groupId>com.fasterxml.jackson.core</groupId>  
      <artifactId>jackson-databind</artifactId>  
      <version>${jackson-version}</version>  
</dependency>  
<dependency>  
      <groupId>com.fasterxml.jackson.core</groupId>  
      <artifactId>jackson-core</artifactId>  
      <version>${jackson-version}</version>  
</dependency>  
<dependency>  
      <groupId>com.fasterxml.jackson.core</groupId>  
      <artifactId>jackson-annotations</artifactId>  
      <version>${jackson-version}</version>  
</dependency>  

jackson解析javaBean

ProductBean.java

package cn.com.zckj;

/**
 * 
 * @ClassName: ProductBean
 * @Description: 实体类
 * @author deng
 * @date 2017年4月27日 下午3:38:26
 */
public class ProductBean {

    // 产品编号
    private int id;
    // 产品名称
    private String name;
    // 产品jiage
    private int price;


    public ProductBean() {
        super();
    }

    public ProductBean(int id, String name, int price) {
        super();
        this.id = id;
        this.name = name;
        this.price = price;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "产品的id:" + id + ", 名字：" + name + ", 价格：" + price ;
    }

}

解析如下：

package cn.com.zckj;

import java.io.File;
import java.io.IOException;

import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * 
* @ClassName: Demo4 
* @Description: TODO(这里用一句话描述这个类的作用) 
* @author deng
* @date 2018年4月17日 上午11:38:13
 *Jackson 生成和解析
 *
 */
public class Demo4 {

    public static void main(String[] args) {
        //对象-》 json
        //ProductBean productBean=new ProductBean(1, "aa", 222);
        ObjectMapper mapper = new ObjectMapper();
        try {
            mapper.writeValue(new File("data.txt"), productBean);
        } catch (IOException e) {
            e.printStackTrace();
        }


        //json - > 对象
        try {
            ProductBean productBean2  = mapper.readValue(new File("data.txt"), ProductBean.class);
            System.out.println(productBean2);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

jackson解析List

package cn.com.zckj;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;


/**
 * 
* @ClassName: Demo5 
* @Description: TODO(这里用一句话描述这个类的作用) 
* @author deng
* @date 2018年4月18日 上午10:51:23
* 
* jackson转换list中有泛型的数据
 */
public class Demo5 {

    public static void main(String[] args) {

        ArrayList<ProductBean> productBeans = new ArrayList<ProductBean>();
        productBeans.add(new ProductBean(1, "a", 22));
        productBeans.add(new ProductBean(2, "b", 22));
        productBeans.add(new ProductBean(3, "c", 22));

        ObjectMapper mapper = new ObjectMapper();

        try {
            mapper.writeValue(new File("data.txt"), productBeans);
        } catch (IOException e) {
            e.printStackTrace();
        }



        //泛型的方式ArrayList<ProductBean> == javaType
        JavaType javaType = mapper.getTypeFactory().constructCollectionType(ArrayList.class, ProductBean.class);  
        try {
            List<ProductBean> lst =  (List<ProductBean>)mapper.readValue(new File("data.txt"), javaType);
            for(ProductBean productBean : lst){
                System.out.println(productBean);
            }

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


        //普通的方式
        try {
            List<ProductBean> lst = mapper.readValue(new File("data.txt"), ArrayList.class);
            for(ProductBean productBean : lst){
                System.out.println(productBean);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

jackson解析复杂的json

ResultBean.java

package cn.com.zzkj;

import java.util.ArrayList;


/**
 * 
* @ClassName: ResultBean 
* @Description: TODO(这里用一句话描述这个类的作用) 
* @author deng
* @date 2018年4月19日 下午6:29:18
 */
public class ResultBean {

    private String code;
    private ArrayList<ProductBean> data;



    public ResultBean() {
        super();
        // TODO Auto-generated constructor stub
    }

    public ResultBean(String code, ArrayList<ProductBean> data) {
        super();
        this.code = code;
        this.data = data;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public ArrayList getData() {
        return data;
    }

    public void setData(ArrayList<ProductBean> data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "ResultBean [code=" + code + ", data=" + data + "]";
    }
}

解析的方式

package cn.com.zzkj;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;

import com.fasterxml.jackson.databind.ObjectMapper;

public class Test {
    public static void main(String[] args) {

        ObjectMapper objectMapper = new ObjectMapper();
        ArrayList<ProductBean> data = new ArrayList<ProductBean>();

        data.add(new ProductBean(2, "你", 2));
        data.add(new ProductBean(2, "你", 2));
        data.add(new ProductBean(2, "你", 2));
        ResultBean resultBean =new ResultBean("11",data);
        try {
            objectMapper.writeValue(new File("aa.txt"), resultBean);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //这里需要注意1.实体bean的结构必须与json中的数据结构一。2.实体bean中的数据名称必须与json中对应的关键词一至
        try {
            ResultBean resultBean2 = JackSonUtil.parse(ResultBean.class, new FileInputStream(new File("aa.txt")));
            ArrayList<ProductBean> a = resultBean2.getData();
            for(ProductBean productBean : a){
                System.out.println(productBean);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

依赖

jackson-annotations-2.5.0.jar
jackson-core-2.5.0.jar
jackson-core-asl-1.9.11.jar
jackson-databind-2.5.0.jar
jackson-mapper-asl-1.9.11.jar
stax2-api-3.1.1.jar

jar包和JackSonUtil工具类
JackSonUtil.java

package cn.com.zzkj;

import java.io.IOException;
import java.io.InputStream;

import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.annotate.JsonAutoDetect.Visibility;
import org.codehaus.jackson.annotate.JsonMethod;
import org.codehaus.jackson.map.DeserializationConfig;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;


/**
 * 
 * @since 2014/10/25 18:33
 * @version 1.0 这里需要注意1.实体bean的结构必须与json中的数据结构一。2.实体bean中的数据名称必须与json中对应的关键词一至
 * 
 */
public class JackSonUtil {
    /**
     * @param clazz
     *            需要解析成的bean类型 改bean类型必须实现Serializable接口
     * @param is
     *            json的输入流
     * @return 返回解析成的bean对象 例: Djl p = JackSonUtil.parse(Djl.class, is);
     */
    public static <T> T parse(Class<T> clazz, InputStream is) {
        ObjectMapper mapper = new ObjectMapper().setVisibility(
                JsonMethod.FIELD, Visibility.ANY);
        T result = null;
        try {
            /**
             * true可以设置私有变量
             */
            mapper.configure(
                    DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY,
                    true);
            /**
             * 与未定义的属相有关
             */
            mapper.configure(
                    DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES,
                    false);
            result = mapper.readValue(is, clazz);
        } catch (JsonParseException e) {
            e.printStackTrace();
        } catch (JsonMappingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * @param clazz
     *            需要解析成的bean类型 改bean类型必须实现Serializable接口
     * @param json
     *            json文本
     * @return 返回解析成的bean对象 例: Djl p = JackSonUtil.parse(Djl.class, is);
     */
    public static <T> T parse(Class<T> clazz, String json) {
        ObjectMapper mapper = new ObjectMapper().setVisibility(
                JsonMethod.FIELD, Visibility.ANY);
        T result = null;
        try {
            /**
             * true可以设置私有变量
             */
            mapper.configure(
                    DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY,
                    true);
            /**
             * 与未定义的属相有关
             */
            mapper.configure(
                    DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES,
                    false);
            result = mapper.readValue(json, clazz);
        } catch (Exception e) {
            e.printStackTrace();
        } 
        return result;
    }
}

有了 这种方式，任何复杂的json都可以解析但是注意的是这里需要注意1.实体bean的结构必须与json中的数据结构一。2.实体bean中的数据名称必须与json中对应的关键词一至，祝你好运