浅谈JackSon的几种用法

jackson介绍

本文使用的jackson版本为2.9.6。

jackson是解析json和xml的一个框架，优点是简单易用，性能较高。

jackson处理json的方式

jackson提供了三种json的处理方式。分别是数据绑定，树模型，流式api。下面会分别介绍这三种方式。

jackson数据绑定

数据绑定用于json转化，可以将json与pojo对象进行转化。数据绑定有两种，简单数据绑定和完整数据绑定。

完整数据绑定

package com.xymxyg.json;

import com.fasterxml.jackson.databind.objectmapper;

import java.io.ioexception;

/**
 * @author guangsheng.tang
 * 下面是最常用的场景，将json字符串映射为对象，或者是将对象转化为json字符串。这是完整数据绑定。
 缺点:这种方法十分方便，但是扩展性不强，增加一个字段便要修改pojo对象，这个操作有一定风险性。并且解析的时候，如果json缺少pojo中的某字段，映射出的对象对应值默认为null，直接使用有一定风险。如果json对象多了某一字段，解析过程中会抛出unrecognizedpropertyexception异常。并且如果json较为复杂的话，pojo对象会显得特别臃肿。
 */
public class completedatabind {
  public static void main(string[] args) throws ioexception {
    string s = "{\"id\": 1,\"name\": \"小明\",\"array\": [\"1\", \"2\"]}";
    objectmapper mapper = new objectmapper();
    //json映射为对象
    student student = mapper.readvalue(s, student.class);
    //对象转化为json
    string json = mapper.writevalueasstring(student);
    system.out.println(json);
    system.out.println(student.tostring());
  }
}

package com.xymxyg.json;

/**
 * @author guangsheng.tang
 */
public class student {
  private int id;
  private string name;
  private string sex;
  private arraylist<string> array;
  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 string getsex() {
    return sex;
  }

  public void setsex(string sex) {
    this.sex = sex;
  }

  public arraylist<string> getarray() {
    return array;
  }

  public void setarray(arraylist<string> array) {
    this.array = array;
  }

  @override
  public string tostring() {
    return "student{" +
        "id=" + id +
        ", name='" + name + '\'' +
        ", sex='" + sex + '\'' +
        ", array=" + arrays.tostring(array.toarray()) +
        '}';
  }
}

简单数据绑定

简单数据绑定就是将json字符串映射为java核心的数据类型。

json类型	java类型
object	linkedhashmap
array	arraylist
string	string
number	integer,long,double
true|false	boolean
null	null

下面演示一个例子，将json转化为一个map。通过map来读取。

package com.xymxyg.json;

import com.fasterxml.jackson.databind.objectmapper;

import java.io.ioexception;
import java.util.arraylist;
import java.util.arrays;
import java.util.hashmap;
import java.util.map;

/**
 * @author guangsheng.tang
 * 简单数据绑定的示例，不用pojo对象，直接映射为一个map，然后从map中获取。
 */
public class simpledatabind {
  public static void main(string[] args) throws ioexception {
    map<string, object> map = new hashmap<>(16);
    string s = "{\"id\": 1,\"name\": \"小明\",\"array\": [\"1\", \"2\"]," +
        "\"test\":\"i'm test\",\"base\": {\"major\": \"物联网\",\"class\": \"3\"}}";
    objectmapper mapper = new objectmapper();
    map = mapper.readvalue(s, map.getclass());
    //获取id
    integer studentid = (integer) map.get("id");
    system.out.println(studentid);
    //获取数据
    arraylist list = (arraylist) map.get("array");
    system.out.println(arrays.tostring(list.toarray()));
    //新增加的字段可以很方便的处理
    string test = (string) map.get("test");
    system.out.println(test);
    //不存在的返回null
    string notexist = (string) map.get("notexist");
    system.out.println(notexist);
    //嵌套的对象获取
    map base = (map) map.get("base");
    string major = (string) base.get("major");
    system.out.println(major);
  }
}

树模型

针对jackson的树模型结构，我下面写了一个比较完善的例子。同样java树模型有优点，也有缺点。

package com.xymxyg.json;

import com.fasterxml.jackson.core.jsonpointer;
import com.fasterxml.jackson.databind.jsonnode;
import com.fasterxml.jackson.databind.objectmapper;
import com.fasterxml.jackson.databind.node.arraynode;
import com.fasterxml.jackson.databind.node.nullnode;
import com.fasterxml.jackson.databind.node.objectnode;

import java.io.ioexception;

/**
 * @author guangsheng.tang
 * jackson树模型结构，可以通过get，jsonpointer等进行操作，适合用来获取大json中的字段，比较灵活。缺点是如果需要获取的内容较多，
 * 会显得比较繁琐。
 */
public class treemodel {
  public static void main(string[] args) throws ioexception {
    objectmapper mapper = new objectmapper();
    //以下是对象转化为json
    jsonnode root = mapper.createobjectnode();
    ((objectnode) root).putarray("array");
    arraynode arraynode = (arraynode) root.get("array");
    ((arraynode) arraynode).add("args1");
    ((arraynode) arraynode).add("args2");
    ((objectnode) root).put("name", "小红");
    string json = mapper.writevalueasstring(root);
    system.out.println("使用树型模型构建的json:"+json);
    //以下是树模型的解析json
    string s = "{\"id\": 1,\"name\": \"小明\",\"array\": [\"1\", \"2\"]," +
        "\"test\":\"i'm test\",\"nullnode\":null,\"base\": {\"major\": \"物联网\",\"class\": \"3\"}}";
    //读取rootnode
    jsonnode rootnode = mapper.readtree(s);
    //通过path获取
    system.out.println("通过path获取值：" + rootnode.path("name").astext());
    //通过jsonpointer可以直接按照路径获取
    jsonpointer pointer = jsonpointer.valueof("/base/major");
    jsonnode node = rootnode.at(pointer);
    system.out.println("通过at获取值:" + node.astext());
    //通过get可以取对应的value
    jsonnode classnode = rootnode.get("base");
    system.out.println("通过get获取值：" + classnode.get("major").astext());

    //获取数组的值
    system.out.print("获取数组的值：");
    jsonnode arraynode2 = rootnode.get("array");
    for (int i = 0; i < arraynode2.size(); i++) {
      system.out.print(arraynode2.get(i).astext()+" ");
    }
    system.out.println();
    //path和get方法看起来很相似，其实他们的细节不同，get方法取不存在的值的时候，会返回null。而path方法会
    //返回一个"missing node"，该"missing node"的ismissingnode方法返回值为true，如果调用该node的astext方法的话，
    // 结果是一个空字符串。
    system.out.println("get方法取不存在的节点，返回null:" + (rootnode.get("notexist") == null));
    jsonnode notexistnode = rootnode.path("notexist");
    system.out.println("notexistnode的value：" + notexistnode.astext());
    system.out.println("ismissingnode方法返回true:" + notexistnode.ismissingnode());

    //当key存在，而value为null的时候，get和path都会返回一个nullnode节点。
    system.out.println(rootnode.get("nullnode") instanceof nullnode);
    system.out.println(rootnode.path("nullnode") instanceof nullnode);
  }
}

流式api

流式api是一套比较底层的api，速度快，但是使用起来特别麻烦。它主要是有两个核心类，一个是jsongenerator，用来生成json，另一个是jsonparser，用来读取json内容。话不多说，直接上代码演示。

package com.xymxyg.json;

import com.fasterxml.jackson.core.*;

import java.io.file;
import java.io.fileinputstream;
import java.io.ioexception;

/**
 * @author guangsheng.tang
 * jsonparser和generator的优点是速度快，缺点是写起来真的很复杂。
 */
public class streamapi {
  public static void main(string[] args) throws ioexception {
    jsonfactory factory = new jsonfactory();
    string s = "{\"id\": 1,\"name\": \"小明\",\"array\": [\"1\", \"2\"]," +
        "\"test\":\"i'm test\",\"nullnode\":null,\"base\": {\"major\": \"物联网\",\"class\": \"3\"}}";

    //这里就举一个比较简单的例子，generator的用法就是一个一个write即可。
    file file = new file("/json.txt");
    jsongenerator jsongenerator = factory.creategenerator(file, jsonencoding.utf8);
    //对象开始
    jsongenerator.writestartobject();
    //写入一个键值对
    jsongenerator.writestringfield("name", "小光");
    //对象结束
    jsongenerator.writeendobject();
    //关闭jsongenerator
    jsongenerator.close();
    //读取刚刚写入的json
    fileinputstream inputstream = new fileinputstream(file);
    int i = 0;
    final int size = 1024;
    byte[] buf = new byte[size];
    stringbuilder sb = new stringbuilder();
    while ((i = inputstream.read(buf)) != -1) {
      system.out.println(new string(buf,0,i));
    }
    inputstream.close();


    //jsonparser解析的时候，思路是把json字符串根据边界符分割为若干个jsontoken，这个jsontoken是一个枚举类型。
    //下面这个小例子，可以看出jsontoken是如何划分类型的。
    jsonparser parser = factory.createparser(s);
    while (!parser.isclosed()){
      jsontoken token = parser.currenttoken();
      system.out.println(token);
      parser.nexttoken();
    }

    jsonparser jsonparser = factory.createparser(s);
    //下面是一个解析的实例
    while (!jsonparser.isclosed()) {
      jsontoken token = jsonparser.nexttoken();
      if (jsontoken.field_name.equals(token)) {
        string currentname = jsonparser.currentname();
        token = jsonparser.nexttoken();
        if ("id".equals(currentname)) {
          system.out.println("id:" + jsonparser.getvalueasint());
        } else if ("name".equals(currentname)) {
          system.out.println("name:" + jsonparser.getvalueasstring());
        } else if ("array".equals(currentname)) {
          token = jsonparser.nexttoken();
          while (!jsontoken.end_array.equals(token)) {
            system.out.println("array:" + jsonparser.getvalueasstring());
            token = jsonparser.nexttoken();
          }
        }
      }
    }
  }

}

jackson的常用注解

jackson提供了一些的注解，可以用在类上或者是在字段上。通常是数据绑定的时候使用。下面几个是最常用的几个

@jsoninclude(include.non_empty)
仅在属性不为空时序列化此字段，对于字符串，即null或空字符串

@jsonignore
序列化时忽略此字段

@jsonproperty(value = “user_name”)
指定序列化时的字段名，默认使用属性名

总结

jackson使用起来还是十分方便的，提供的功能也很多，在使用的时候，需要结合自己的业务场景，选择合适的解析方式。

参考资料

到此这篇关于浅谈jackson的几种用法的文章就介绍到这了,更多相关jackson 用法内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！