ホームページ > 記事 > Java > 私が最高だと思う Java JSON パーサー: Jackson

私が最高だと思う Java JSON パーサー: Jackson

coldplay.xixi転載: 2020-12-16 09:48:542487ブラウズ

Java の基本チュートリアルこのコラムでは Java JSON パーサーを紹介します

今日のプログラミングの世界では、JSON がクライアントからサーバーに情報を送信するためのプロトコルとして好まれています。 XML は、ビーチで死んでいる写真を撮られたかつての波であると言っても過言ではありません。

残念ながら、JDK には JSON ライブラリがありません。なぜこれに取り組まないのかわかりません。 Log4j の時点では、競合するために java.util.logging もリリースされましたが、最終的にはあまり使用されませんでした。

Java が素晴らしい理由は、そのエコロジーが非常に完全であるためです。JDK には JSON ライブラリがありませんが、サードパーティのライブラリには JSON ライブラリがあり、非常に優れています。たとえば、この記事の豚の足 - Jackson、GitHub スター 6.1k、Spring Boot のデフォルトの JSON パーサー。

これを証明するにはどうすればよいでしょうか?

スターターを通じて新しい Spring Boot Web プロジェクトを作成すると、Maven の依存関係に Jackson が表示されます。

私が最高だと思う Java JSON パーサー: Jackson

Jackson には多くの利点があります:

実行時に消費するメモリが少なくなります。、パフォーマンスの向上;
API は非常に柔軟で、拡張やカスタマイズが簡単です。

Jackson のコアモジュールは 3 つの部分で構成されます。

jackson-annotations (アノテーションパッケージ) は、標準のアノテーション関数を提供します。
jackson-databind (データバインディングパッケージ) は、「オブジェクトバインディング」解析に基づく関連 API (ObjectMapper) と「」の関連 API を提供します。ツリーモデル」の解析 (JsonNode)。

01. Jackson の依存関係の紹介

Jackson を使用するには、pom.xml ファイルに Jackson の依存関係を追加する必要があります。

<dependency>
    <groupid>com.fasterxml.jackson.core</groupid>
    <artifactid>jackson-databind</artifactid>
    <version>2.10.1</version>
</dependency>

jackson-databind は jackson-core と jackson-annotations に依存するため、jackson-databind を追加すると、Maven は jackson-core と jackson-annotations をプロジェクトに自動的に導入します。

私が最高だと思う Java JSON パーサー: Jackson

Maven がとても愛らしい理由は、私たちがやるべきことを密かに助けてくれるからです。

02. ObjectMapper を使用する

Jackson で最も一般的に使用される API は、「オブジェクトバインディング」に基づく ObjectMapper です。これは、一連の writeValue メソッドを通じて Java オブジェクトを JSON にシリアル化し、それらをさまざまな形式で保存できます。。

writeValueAsString(Object value) メソッド、オブジェクトを文字列として保存します
writeValueAsBytes(Object value) メソッド、オブジェクトを保存しますバイト配列
writeValue(File resultFile, Object value)メソッドに、オブジェクトをファイルとして保存します

コード例を見てみましょう。文字列として保存します:

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * 微信搜索「沉默王二」，回复 Java
 *
 * @author 沉默王二
 * @date 2020/11/26
 */
public class Demo {
    public static void main(String[] args) throws JsonProcessingException {
        Writer wanger = new Writer("沉默王二", 18);
        ObjectMapper mapper = new ObjectMapper();
        String jsonString = mapper.writerWithDefaultPrettyPrinter()
                .writeValueAsString(wanger);
        System.out.println(jsonString);
    }
}

class Writer {
    private String name;
    private int age;

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

    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;
    }
}

プログラムの出力結果は次のとおりです:

{
  "name" : "沉默王二",
  "age" : 18
}

すべてのフィールドがシリアル化と逆シリアル化をサポートしているわけではないため、次の規則に従う必要があります:

フィールドの修飾子がパブリックではなく、そのゲッターメソッドとセッターメソッドがパブリックである場合、フィールドはシリアル化および逆シリアル化できます。 getter メソッドはシリアル化に使用され、setter メソッドは逆シリアル化に使用されます。
フィールドにパブリックセッターメソッドのみがあり、パブリックゲッターメソッドがない場合、そのフィールドは逆シリアル化にのみ使用できます。

デフォルトのシリアル化および逆シリアル化ルールを変更する場合は、ObjectMapper の

setVisibility() メソッドを呼び出す必要があります。それ以外の場合は、InvalidDefinitionException がスローされます。

ObjectMapper は、readValue 一連のメソッドを通じて、さまざまなデータソースから JSON を Java オブジェクトに逆シリアル化します。

readValue(String content, Class valueType) メソッド、文字列を Java オブジェクトに逆シリアル化します
readValue(byte[ ] src) 、Class valueType) メソッド、バイト配列を Java オブジェクトに逆シリアル化します。
readValue(File src, Class valueType) メソッド、バイト配列を Java オブジェクトに逆シリアル化します。 Java オブジェクトファイルを Java オブジェクトに逆シリアル化する

文字列を Java オブジェクトに逆シリアル化するコード例を見てみましょう:

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * 微信搜索「沉默王二」，回复 Java
 *
 * @author 沉默王二
 * @date 2020/11/26
 */
public class Demo {
    public static void main(String[] args) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        String jsonString = "{\n" +
                "  \"name\" : \"沉默王二\",\n" +
                "  \"age\" : 18\n" +
                "}";
        Writer deserializedWriter = mapper.readValue(jsonString, Writer.class);
        System.out.println(deserializedWriter);
    }
}

class Writer{
    private String name;
    private int age;

    // getter/setter

    @Override
    public String toString() {
        return "Writer{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

プログラムの出力は次のとおりです:

Writer{name='沉默王二', age=18}

PS: 逆シリアル化されたオブジェクトにパラメーターを持つコンストラクターがある場合は、空のデフォルトコンストラクターを持たなければなりません。そうでない場合は、

InvalidDefinitionException 行がスローされます。

Exception in thread "main" com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of `com.itwanger.jackson.Writer` (no Creators, like default construct, exist): cannot deserialize from Object value (no delegate- or property-based Creator)
 at [Source: (String)"{
  "name" : "沉默王二",
  "age" : 18
}"; line: 2, column: 3]
    at com.fasterxml.jackson.databind.exc.InvalidDefinitionException.from(InvalidDefinitionException.java:67)
    at com.fasterxml.jackson.databind.DeserializationContext.reportBadDefinition(DeserializationContext.java:1589)
    at com.fasterxml.jackson.databind.DeserializationContext.handleMissingInstantiator(DeserializationContext.java:1055)
    at com.fasterxml.jackson.databind.deser.BeanDeserializerBase.deserializeFromObjectUsingNonDefault(BeanDeserializerBase.java:1297)
    at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserializeFromObject(BeanDeserializer.java:326)
    at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserialize(BeanDeserializer.java:159)
    at com.fasterxml.jackson.databind.ObjectMapper._readMapAndClose(ObjectMapper.java:4202)
    at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:3205)
    at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:3173)
    at com.itwanger.jackson.Demo.main(Demo.java:19)

Jackson で最も一般的に使用される API は、「オブジェクトバインディング」に基づく ObjectMapper です。

ObjectMapper は、「ツリーモデル」に基づいて JSON を JsonNode オブジェクトに解析することもできます。以下の例を参照してください。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * 微信搜索「沉默王二」，回复 Java
 *
 * @author 沉默王二
 * @date 2020/11/26
 */
public class JsonNodeDemo {
    public static void main(String[] args) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        String json = "{ \"name\" : \"沉默王二\", \"age\" : 18 }";
        JsonNode jsonNode = mapper.readTree(json);
        String name = jsonNode.get("name").asText();
        System.out.println(name); // 沉默王二
    }
}

借助 TypeReference 可以将 JSON 字符串数组转成泛型 List，来看下面的示例：

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.List;

/**
 * 微信搜索「沉默王二」，回复 Java
 *
 * @author 沉默王二
 * @date 2020/11/26
 */
public class TypeReferenceDemo {
    public static void main(String[] args) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        String json = "[{ \"name\" : \"沉默王三\", \"age\" : 18 }, { \"name\" : \"沉默王二\", \"age\" : 19 }]";
        List<author> listAuthor = mapper.readValue(json, new TypeReference<list>>(){});
        System.out.println(listAuthor);
    }
}
class Author{
    private String name;
    private int age;

    // getter/setter

    // toString
}</list></author>

03、更高级的配置

Jackson 之所以牛掰的一个很重要的因素是可以实现高度灵活的自定义配置。

在实际的应用场景中，JSON 中常常会有一些 Java 对象中没有的字段，这时候，如果直接解析的话，会抛出 UnrecognizedPropertyException 异常。

下面是一串 JSON 字符串：

String jsonString = "{\n" +
                "  \"name\" : \"沉默王二\",\n" +
                "  \"age\" : 18\n" +
                "  \"sex\" : \"男\",\n" +
                "}";

但 Java 对象 Writer 中没有定义 sex 字段：

class Writer{
    private String name;
    private int age;

    // getter/setter
}

我们来尝试解析一下：

ObjectMapper mapper = new ObjectMapper();
Writer deserializedWriter = mapper.readValue(jsonString, Writer.class);

不出意外，抛出异常了，sex 无法识别。

Exception in thread "main" com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException: Unrecognized field "sex" (class com.itwanger.jackson.Writer), not marked as ignorable (2 known properties: "name", "age"])
 at [Source: (String)"{
  "name" : "沉默王二",
  "age" : 18,
  "sex" : "男"
}"; line: 4, column: 12] (through reference chain: com.itwanger.jackson.Writer["sex"])

怎么办呢？可以通过 configure() 方法忽略掉这些“无法识别”的字段。

mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

除此之外，还有其他一些有用的配置信息，来了解一下：

// 在序列化时忽略值为 null 的属性
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
// 忽略值为默认值的属性
mapper.setDefaultPropertyInclusion(JsonInclude.Include.NON_DEFAULT);

04、处理日期格式

对于日期类型的字段，比如说 java.util.Date，如果不指定格式，序列化后将显示为 long 类型的数据，这种默认格式的可读性很差。

{
  "age" : 18,
  "birthday" : 1606358621209
}

怎么办呢？

第一种方案，在 getter 上使用 @JsonFormat 注解。

private Date birthday;

// GMT+8 是指格林尼治的标准时间，在加上八个小时表示你现在所在时区的时间
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
public Date getBirthday() {
    return birthday;
}

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

再来看一下结果：

{
  "age" : 18,
  "birthday" : "2020-11-26 03:02:30"
}

具体代码如下所示：

ObjectMapper mapper = new ObjectMapper();
Writer wanger = new Writer("沉默王二", 18);
wanger.setBirthday(new Date());
String jsonString = mapper.writerWithDefaultPrettyPrinter()
                .writeValueAsString(wanger);
System.out.println(jsonString);

第二种方案，调用 ObjectMapper 的 setDateFormat() 方法。

ObjectMapper mapper = new ObjectMapper();
mapper.setDateFormat(StdDateFormat.getDateTimeInstance());
Writer wanger = new Writer("沉默王二", 18);
wanger.setBirthday(new Date());
String jsonString = mapper.writerWithDefaultPrettyPrinter()
                .writeValueAsString(wanger);
System.out.println(jsonString);

输出结果如下所示：

{
  "name" : "沉默王二",
  "age" : 18,
  "birthday" : "2020年11月26日 上午11:09:51"
}

05、字段过滤

在将 Java 对象序列化为 JSON 时，可能有些字段需要过滤，不显示在 JSON 中，Jackson 有一种比较简单的实现方式。

@JsonIgnore 用于过滤单个字段。

@JsonIgnore
public String getName() {
    return name;
}

@JsonIgnoreProperties 用于过滤多个字段。

@JsonIgnoreProperties(value = { "age","birthday" })
class Writer{
    private String name;
    private int age;
    private Date birthday;
}

06、自定义序列化和反序列化

当 Jackson 默认序列化和反序列化不能满足实际的开发需要时，可以自定义新的序列化和反序列化类。

自定义的序列化类需要继承 StdSerializer，同时重写 serialize() 方法，利用 JsonGenerator 生成 JSON，示例如下：

/**
 * 微信搜索「沉默王二」，回复 Java
 *
 * @author 沉默王二
 * @date 2020/11/26
 */
public class CustomSerializer extends StdSerializer<man> {
    protected CustomSerializer(Class<man> t) {
        super(t);
    }

    public CustomSerializer() {
        this(null);
    }

    @Override
    public void serialize(Man value, JsonGenerator gen, SerializerProvider provider) throws IOException {
        gen.writeStartObject();
        gen.writeStringField("name", value.getName());
        gen.writeEndObject();
    }
}

class Man{
    private int age;
    private String name;

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}</man></man>

定义好自定义序列化类后，要想在程序中调用它们，需要将其注册到 ObjectMapper 的 Module 中，示例如下所示：

ObjectMapper mapper = new ObjectMapper();
SimpleModule module =
        new SimpleModule("CustomSerializer", new Version(1, 0, 0, null, null, null));
module.addSerializer(Man.class, new CustomSerializer());
mapper.registerModule(module);
Man man = new Man( 18,"沉默王二");
String json = mapper.writeValueAsString(man);
System.out.println(json);

程序输出结果如下所示：

{"name":"沉默王二"}

自定义序列化类 CustomSerializer 中没有添加 age 字段，所以只输出了 name 字段。

再来看一下自定义的反序列化类，继承 StdDeserializer，同时重写 deserialize() 方法，利用 JsonGenerator 读取 JSON，示例如下：

public class CustomDeserializer extends StdDeserializer<woman> {
    protected CustomDeserializer(Class> vc) {
        super(vc);
    }

    public CustomDeserializer() {
        this(null);
    }

    @Override
    public Woman deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        JsonNode node = p.getCodec().readTree(p);
        Woman woman = new Woman();
        int age = (Integer) ((IntNode) node.get("age")).numberValue();
        String name = node.get("name").asText();
        woman.setAge(age);
        woman.setName(name);
        return woman;
    }
}
class Woman{
    private int age;
    private String name;

    public Woman() {
    }

    // getter/setter

    @Override
    public String toString() {
        return "Woman{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}</woman>

通过 JsonNode 把 JSON 读取到一个树形结构中，然后通过 JsonNode 的 get 方法将对应字段读取出来，然后生成新的 Java 对象，并返回。

定义好自定义反序列化类后，要想在程序中调用它们，同样需要将其注册到 ObjectMapper 的 Module 中，示例如下所示：

ObjectMapper mapper = new ObjectMapper();
SimpleModule module =
        new SimpleModule("CustomDeserializer", new Version(1, 0, 0, null, null, null));
module.addDeserializer(Woman.class, new CustomDeserializer());
mapper.registerModule(module);
String json = "{ \"name\" : \"三妹\", \"age\" : 18 }";
Woman woman = mapper.readValue(json, Woman.class);
System.out.println(woman);

程序输出结果如下所示：

Woman{age=18, name='三妹'}

07、结语

哎呀，好像不错哦，Jackson 绝对配得上“最牛掰”这三个字，虽然有点虚。如果只想简单的序列化和反序列化，使用 ObjectMapper 的 write 和 read 方法即可。

如果还想更进一步的话，就需要对 ObjectMapper 进行一些自定义配置，或者加一些注解，以及直接自定义序列化和反序列化类，更贴近一些 Java 对象。

需要注意的是，对日期格式的字段要多加小心，尽量不要使用默认配置，可读性很差。

好了，通过这篇文章的系统化介绍，相信你已经完全摸透 Jackson 了，我们下篇文章见。

PS：如果你恰好需要一份 Java 精进路线的话，我这里有一份，我差不多花了 3 天的时间整理的，还挺受欢迎的，已经 2000 多赞了，每个阶段都很详细。

相关免费学习推荐：php编程（视频）

以上が私が最高だと思う Java JSON パーサー: Jacksonの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。

声明：

この記事はsegmentfault.comで複製されています。侵害がある場合は、admin@php.cn までご連絡ください。

前の記事：Java はリフレクションを使用してオブジェクトを MongoDb 構造に変換します次の記事：Java はリフレクションを使用してオブジェクトを MongoDb 構造に変換します

続きを見る