Jackson-quick-guide

ジャクソン-概要

ジャクソンは、JavaオブジェクトをJSONにシリアル化したり、その逆を行うためのシンプルなJavaベースのライブラリです。

特徴

• 使いやすい-jackson APIは、一般的に使用されるユースケースを簡素化するための高レベルのファサードを提供します。
• マッピングを作成する必要はありません。-jackson APIは、シリアル化されるほとんどのオブジェクトにデフォルトのマッピングを提供します。
• パフォーマンス-ジャクソンは静かで高速であり、メモリフットプリントが小さく、大きなオブジェクトのグラフまたはシステムに適しています。
• * Clean JSON。*-jacksonは、読みやすく、クリーンでコンパクトなJSON結果を作成します。
• 依存関係なし-jacksonライブラリは、jdk以外のライブラリを必要としません。
• オープンソース-jacksonライブラリはオープンソースであり、無料で使用できます。

JSONを処理する3つの方法

ジャクソンはJSONを処理する3つの代替方法を提供します

• *ストリーミングAPI *-JSONコンテンツを個別のイベントとして読み書きします。 JsonParserはデータを読み取りますが、JsonGeneratorはデータを書き込みます。 これは3つの中で最も強力なアプローチであり、読み取り/書き込み操作のオーバーヘッドが最も低く、高速です。 XMLのStaxパーサーに類似しています。
• ツリーモデル-JSONドキュメントのメモリ内ツリー表現を準備します。 ObjectMapperは、JsonNodeノードのツリーを構築します。 最も柔軟なアプローチです。 XMLのDOMパーサーに類似しています。
• データバインディング-プロパティアクセサまたはアノテーションを使用して、JSONをPOJO（Plain Old Java Object）との間で変換します。 それは2つのタイプです。
• シンプルなデータバインディング-JSONからJavaマップ、リスト、文字列、数値、ブール値、nullオブジェクトへの変換を行います。
• 完全なデータバインディング-JSONを任意のJAVAタイプとの間で変換します。 + ObjectMapperは、両方のタイプのデータバインディングのJSONを読み書きします。 データバインディングは最も便利な方法であり、XMLのJAXBパーラーに類似しています。

ジャクソン-環境設定

'__ === オンラインで試す

JavaベースのライブラリであるGuavaの学習を開始するために、独自の環境をセットアップする必要はありません。 理由は非常に簡単です。すでにJavaプログラミング環境をオンラインでセットアップしているので、理論の作業をしているときに利用可能なすべての例を同時にオンラインでコンパイルして実行できます。 これにより、読んでいるものに自信が持て、さまざまなオプションで結果を確認できます。 サンプルを自由に変更して、オンラインで実行してください。

以下のサンプルコードボックスの右上隅にある Try it オプションを使用して、次の例を試してください。

public class MyFirstJavaProgram {

    public static void main(String []args) {
       System.out.println("Hello World");
    }
}

このチュートリアルのほとんどの例では、 Try it オプションがありますので、それを利用して学習を楽しんでください。 '__

ローカル環境のセットアップ

Javaプログラミング言語用に環境をセットアップする場合は、このセクションで、マシンにJavaをダウンロードしてセットアップする方法を説明します。 次の手順に従って環境を設定してください。

Java SEは、リンクhttp://java.sun.com/javase/downloads/index_jdk5.jsp[Download Java]から無料で入手できます。 そのため、オペレーティングシステムに基づいてバージョンをダウンロードします。

指示に従ってjavaをダウンロードし、*。exe *を実行して、マシンにJavaをインストールします。 マシンにJavaをインストールしたら、正しいインストールディレクトリを指すように環境変数を設定する必要があります。

Windows 2000/XPのパスのセットアップ：

Javaが_c：\ Program Files \ java \ jdk_ディレクトリにインストールされていると仮定します。

• 「マイコンピュータ」を右クリックして、「プロパティ」を選択します。
• 「詳細」タブの下の「環境変数」ボタンをクリックします。
• ここで、「Path」変数を変更して、Java実行可能ファイルへのパスも含まれるようにします。 たとえば、パスが現在「C：\ WINDOWS \ SYSTEM32」に設定されている場合、パスを「C：\ WINDOWS \ SYSTEM32; c：\ Program Files \ java \ jdk \ bin」に変更します。

Windows 95/98/MEのパスのセットアップ：

Javaが_c：\ Program Files \ java \ jdk_ディレクトリにインストールされていると仮定します。

• 「C：\ autoexec.bat」ファイルを編集し、最後に次の行を追加します。「SET PATH =％PATH％; C：\ Program Files \ java \ jdk \ bin」

Linux、UNIX、Solaris、FreeBSDのパスの設定：

環境変数PATHは、Javaバイナリがインストールされている場所を指すように設定する必要があります。 これがうまくいかない場合は、シェルのドキュメントを参照してください。

たとえば、_bash_をシェルとして使用する場合、次の行を '.bashrcの最後に追加します：export PATH =/path/to/java：$ PATH'

人気のあるJavaエディター：

Javaプログラムを作成するには、テキストエディターが必要です。 市場にはさらに洗練されたIDEがあります。 ただし、現時点では、次のいずれかを検討できます。

• メモ帳： Windowsマシンでは、メモ帳（このチュートリアルに推奨）、TextPadなどのシンプルなテキストエディタを使用できます。
• Netbeans：は、http：//www.netbeans.org/indexlからダウンロードできるオープンソースで無料のJava IDEです。
• * Eclipse：*は、eclipseオープンソースコミュニティによって開発されたJava IDEでもあり、http：//www.eclipse.org/からダウンロードできます。

jacksonアーカイブをダウンロードする

Maven Repository-JacksonからJackson jarファイルの最新バージョンをダウンロードします。 このチュートリアルでは、jackson-core-2.8.9.jar、jackson-annotations-2.8.9.jarおよびjackson-databind-2.8.9.jarがダウンロードされ、C：\> jacksonフォルダーにコピーされます。

OS	Archive name
Windows	jackson-xxx-2.8.9.jar
Linux	jackson-xxx-2.8.9.jar
Mac	jackson-xxx-2.8.9.jar

ジャクソン環境を設定する

*jackson_HOME* 環境変数を設定して、マシン上のGuava jarが保存されているベースディレクトリの場所を指すようにします。 次のように、さまざまなオペレーティングシステムのjacksonフォルダーにjackson-core-2.8.9.jar、jackson-annotations-2.8.9.jarおよびjackson-databind-2.8.9.jarを抽出したと仮定します。

OS	Output
Windows	Set the environment variable jackson_HOME to C:\jackson
Linux	export jackson_HOME=/usr/local/jackson
Mac	export jackson_HOME=/Library/jackson

CLASSPATH変数を設定する

jackson jarの場所を指すように CLASSPATH 環境変数を設定します。 次のように、さまざまなオペレーティングシステムのjacksonフォルダーにjackson-core-2.8.9.jar、jackson-annotations-2.8.9.jarおよびjackson-databind-2.8.9.jarを保存したと仮定します。

OS	Output
Windows	Set the environment variable CLASSPATH to %CLASSPATH%;%jackson_HOME%\jackson-core-2.8.9.jar;%jackson_HOME%\jackson-databind-2.8.9.jar;%jackson_HOME%\jackson-annotations-2.8.9.jar;.;
Linux	export CLASSPATH=$CLASSPATH:$jackson_HOME/jackson-core-2.8.9.jar:$jackson_HOME/jackson-databind-2.8.9.jar:$jackson_HOME/jackson-annotations-2.8.9.jar:.
Mac	export CLASSPATH=$CLASSPATH:$jackson_HOME/jackson-core-2.8.9.jar:$jackson_HOME/jackson-databind-2.8.9.jar:$jackson_HOME/jackson-annotations-2.8.9.jar:.

ジャクソン-最初のアプリケーション

jacksonライブラリーの詳細に入る前に、アプリケーションの動作を見てみましょう。 この例では、Studentクラスを作成しました。 学生の詳細を含むJSON文字列を作成し、学生オブジェクトにデシリアライズしてから、JSON文字列にシリアル化します。

*C：\> Jackson_WORKSPACE* にJacksonTesterという名前のJavaクラスファイルを作成します。

ファイル：JacksonTester.java

import java.io.IOException;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

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

      ObjectMapper mapper = new ObjectMapper();
      String jsonString = "{\"name\":\"Mahesh\", \"age\":21}";

     //map json to student
      try{
         Student student = mapper.readValue(jsonString, Student.class);

         System.out.println(student);

         jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(student);

         System.out.println(jsonString);
      }
      catch (JsonParseException e) { e.printStackTrace();}
      catch (JsonMappingException e) { e.printStackTrace(); }
      catch (IOException e) { e.printStackTrace(); }
   }
}

class Student {
   private String name;
   private int age;
   public Student(){}
   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 String toString(){
      return "Student [ name: "+name+", age: "+ age+ " ]";
   }
}

結果を確認する

次のように javac コンパイラを使用してクラスをコンパイルします。

C:\Jackson_WORKSPACE>javac JacksonTester.java

次に、jacksonTesterを実行して結果を確認します。

C:\Jackson_WORKSPACE>java JacksonTester

出力を確認する

Student [ name: Mahesh, age: 21 ]
{
  "name" : "Mahesh",
  "age" : 21
}

覚えておくべき手順

以下は、ここで考慮すべき重要な手順です。

ステップ1：ObjectMapperオブジェクトを作成します。

ObjectMapperオブジェクトを作成します。 これは再利用可能なオブジェクトです。

ObjectMapper mapper = new ObjectMapper();

手順2：JSONをオブジェクトにシリアル化解除します。

readValue（）メソッドを使用して、JSONからオブジェクトを取得します。 JSON文字列/JSON文字列のソースとオブジェクトタイプをパラメータとして渡します。

//Object to JSON Conversion
Student student = mapper.readValue(jsonString, Student.class);

ステップ3：オブジェクトをJSONにシリアル化します。

writeValueAsString（）メソッドを使用して、オブジェクトのJSON文字列表現を取得します。

//Object to JSON Conversion
jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(student);

ジャクソン-ObjectMapperクラス

前書き

ObjectMapperは、Jacksonライブラリの主要なアクタークラスです。 ObjectMapperクラスObjectMapperは、基本的なPOJO（プレーンオールドJavaオブジェクト）、または汎用のJSONツリーモデル（JsonNode）との間でJSONを読み書きする機能と、変換を実行するための関連機能を提供します。 また、さまざまなスタイルのJSONコンテンツの両方で動作し、ポリモーフィズムやオブジェクトIDなどのより高度なオブジェクトの概念をサポートするように高度にカスタマイズできます。 ObjectMapperは、より高度なObjectReaderおよびObjectWriterクラスのファクトリーとしても機能します。

クラス宣言

以下は、 com.fasterxml.jackson.databind.ObjectMapper クラスの宣言です-

public class ObjectMapper
   extends ObjectCodec
      implements Versioned, Serializable

入れ子クラス

S.No.	Class & Description
1	static class ObjectMapper.DefaultTypeResolverBuilder いわゆる「デフォルトの型指定」で使用されるタイプリゾルバービルダーを提供するカスタマイズされたTypeResolverBuilder（詳細については、enableDefaultTyping（）を参照）。
2	static class ObjectMapper.DefaultTyping enableDefaultTyping（）で使用される列挙体で、デフォルトの型指定をどの種類（クラス）に使用するかを指定します。

フィールド

• protected DeserializationConfig _deserializationConfig -シリアル化プロセスの基本的なグローバル設定を定義する構成オブジェクト。
• protected DefaultDeserializationContext _deserializationContext -ブループリントコンテキストオブジェクト。ここに保存して、カスタムサブクラスを許可します。
• protected InjectableValues _injectableValues -非シリアル化されたPOJOに注入する値のプロバイダー。
• protected JsonFactory _jsonFactory -必要に応じてJsonParserおよびJsonGeneratorインスタンスを作成するために使用されるファクトリー。
• protected SimpleMixInResolver _mixIns -ミックスインアノテーションの適用方法を定義するマッピング：キーは追加のアノテーションを受け取るタイプで、値は「ミックスイン」するアノテーションを持つタイプです。
• protected ConfigOverrides _propertyOverrides -宣言されたプロパティのタイプによってアクセスされる、現在アクティブなタイプごとの構成オーバーライド。
• protected Set <Object> _registeredModuleTypes -登録されているモジュールタイプのセット（登録されているModule.getTypeId（）に従って、MapperFeature.IGNORE_DUPLICATE_MODULE_REGISTRATIONSが有効になっている場合は追跡します。複数回、主に）。
• protected ConcurrentHashMap <JavaType、JsonDeserializer <Object >> _rootDeserializers -ルートレベルのデシリアライザーを追跡するために、別のメインレベルのマップを使用します。
• protected SerializationConfig _serializationConfig -シリアル化プロセスの基本的なグローバル設定を定義する構成オブジェクト。
• protected SerializerFactory _serializerFactory -シリアライザーの構築に使用されるシリアライザーファクトリー。
• protected DefaultSerializerProvider _serializerProvider -キャッシュを含むシリアル化に使用されるシリアライザーへのアクセスを管理するオブジェクト。
• protected SubtypeResolver _subtypeResolver -サブタイプの登録に使用されるもので、必要に応じてスーパー/サブタイプに解決します。
• protected TypeFactory _typeFactory -JavaTypeインスタンスの作成に使用される特定のファクトリ。モジュールがより多くのカスタム型処理を追加できるようにするために必要です（主に非Java JVM言語の型をサポートするため）
• *保護された静的AnnotationIntrospector DEFAULT_ANNOTATION_INTROSPECTOR *
• protected static BaseSettings DEFAULT_BASE -基本設定には、すべてのObjectMapperインスタンスに使用されるデフォルトが含まれています。
• *保護された静的VisibilityChecker <？> STD_VISIBILITY_CHECKER *

コンストラクタ

S.No.	Constructor & Description
1	ObjectMapper()* 必要に応じてデフォルトのJsonFactoryを構築するデフォルトのコンストラクターは、SerializerProviderとしてSerializerProviderを使用し、SerializerFactoryとしてBeanSerializerFactoryを使用します。
2	ObjectMapper(JsonFactory jf) 指定されたJsonFactoryを使用して、必要なJsonParsersまたはJsonGeneratorを構築するインスタンスを構築します。
3	ObjectMapper(JsonFactory jf, SerializerProvider sp, DeserializerProvider dp) 指定されたJsonFactoryを使用して必要なJsonParsersおよび/またはJsonGeneratorsを構築し、指定されたプロバイダーを使用してシリアライザーとデシリアライザーにアクセスするインスタンスを構築します。
4	protected ObjectMapper(ObjectMapper src) コピーコンストラクタ。主にcopy（）をサポートするために使用されます。

方法

1

• protected void _checkInvalidCopy（Class <？> exp）*

2

• protected void _configAndWriteValue（JsonGenerator g、Object value）*-ジェネレーターを必要に応じて構成し、書き込み機能を呼び出すために呼び出されるメソッド

3

• protected Object _convert（Object fromValue、JavaType toValueType）*-実際の変換実装：既存の読み取りおよび書き込みメソッドを使用する代わりに、多くのコードがインライン化されます。

4

• protected JsonDeserializer <Object> _findRootDeserializer（DeserializationContext ctxt、JavaType valueType）*-渡されたルートレベル値のデシリアライザーを見つけるために呼び出されるメソッド。

5

• protected JsonToken _initForReading（JsonParser p）*-指定されたパーサーがデータバインディングのコンテンツを読み取る準備ができていることを確認するために呼び出されるメソッド。

6

• protected ObjectReader _newReader（DeserializationConfig config）*-ファクトリメソッドのサブクラスは、適切なサブタイプのObjectReaderインスタンスを生成するためにオーバーライドする必要があります

7

• protected ObjectReader _newReader（DeserializationConfig config、JavaType valueType、Object valueToUpdate、FormatSchema schema、InjectableValues injectableValues）*-適切なサブタイプのObjectReaderインスタンスを生成するには、ファクトリメソッドサブクラスをオーバーライドする必要があります

8

• protected ObjectWriter _newWriter（SerializationConfig config）*-適切なサブタイプのObjectWriterインスタンスを生成するには、ファクトリメソッドサブクラスをオーバーライドする必要があります

9

• protected ObjectWriter _newWriter（SerializationConfig config、FormatSchema schema）*-ファクトリメソッドのサブクラスは、適切なサブタイプのObjectWriterインスタンスを生成するためにオーバーライドする必要があります

10

• protected ObjectWriter _newWriter（SerializationConfig config、JavaType rootType、PrettyPrinter pp）*-適切なサブタイプのObjectWriterインスタンスを生成するには、ファクトリメソッドサブクラスをオーバーライドする必要があります。

11

• protected Object _readMapAndClose（JsonParser p0、JavaType valueType）*

12

• protected Object _readValue（DeserializationConfig cfg、JsonParser p、JavaType valueType）*-値読み取り+バインディング操作の実際の実装。

13

保護されたDefaultSerializerProvider _serializerProvider（SerializationConfig config）

シリアライゼーションに使用するSerializerProviderの構築に使用されるオーバーライド可能なヘルパーメソッド。

14

• protected Object _unwrapAndDeserialize（JsonParser p、DeserializationContext ctxt、DeserializationConfig config、JavaType rootType、JsonDeserializer <Object> deser）*

15

• protected void _verifySchemaType（FormatSchema schema）*

16

• void acceptJsonFormatVisitor（Class <？> type、JsonFormatVisitorWrapper visitor）*-指定されたビジターを使用して、指定されたタイプのタイプ階層を訪問するためのメソッド。

17

• void acceptJsonFormatVisitor（JavaType type、JsonFormatVisitorWrapper visitor）*-指定されたビジターを使用して、指定されたタイプのタイプ階層を訪問するためのメソッド。

18

• ObjectMapper addHandler（DeserializationProblemHandler h）*-逆シリアル化中に特定の問題を処理するために使用される、指定されたDeserializationProblemHandlerを追加するメソッド。

19

• ObjectMapper addMixIn（Class <？> target、Class <？> mixinSource）*-指定されたクラスまたはインターフェースを補強するために使用するミックスインアノテーションを追加するために使用するメソッド。

void addMixInAnnotations（Class <？> target、Class <？> mixinSource）-非推奨です。 2.5以降：流な形式のメソッドに置き換えられました。 addMixIn（Class、Class）。

20

• boolean canDeserialize（JavaType type）*-マッパーが特定のタイプのオブジェクトをデシリアライズできると判断したかどうかを確認するために呼び出すことができるメソッド。

21

• boolean canDeserialize（JavaType type、AtomicReference <Throwable> cause）*-canDeserialize（JavaType）に似ていますが、シリアライザーを構築しようとしたときにスローされた実際のThrowableを返すことができるメソッド：これは実際の問題を理解するのに役立ちます。

22

• boolean canSerialize（Class <？> type）*-マッパーが特定のクラスのインスタンスをシリアル化できると判断したかどうかを確認するために呼び出すことができるメソッド。

23

• boolean canSerialize（Class <？> type、AtomicReference <Throwable> cause）*-canSerialize（Class）に似ているが、シリアライザーを構築しようとしたときにスローされた実際のThrowableを返すことができるメソッド：これは実際の問題は。

24

• ObjectMapper clearProblemHandlers（）*-このマッパーから登録済みのすべてのDeserializationProblemHandlersインスタンスを削除するためのメソッド。

25

• MutableConfigOverride configOverride（Classlt;？> type）*-指定されたタイプのプロパティに適用されるタイプごとのオーバーライドを追加または変更するために必要な、指定されたタイプの可変構成オーバーライドオブジェクトを取得するためのアクセサー。

26

• ObjectMapper configure（DeserializationFeature f、boolean state）*-このオブジェクトマッパーのオン/オフデシリアライゼーション機能の状態を変更するためのメソッド。

27

• ObjectMapper configure（JsonGenerator.Feature f、boolean state）*-このオブジェクトマッパーが作成するジェネレーターインスタンスのオン/オフJsonGenerator機能の状態を変更するメソッド。

28

• ObjectMapper configure（JsonParser.Feature f、boolean state）*-このオブジェクトマッパーが作成するパーサーインスタンスの指定されたJsonParser.Featuresの状態を変更するためのメソッド。

29

• ObjectMapper configure（MapperFeature f、boolean state）*-このマッパーインスタンスのオン/オフマッパー機能の状態を変更するためのメソッド。

30

• ObjectMapper configure（SerializationFeature f、boolean state）*-このオブジェクトマッパーのオン/オフシリアル化機能の状態を変更する方法。

31

• JavaType constructType（Type t）*-指定された型（通常はjava.lang.Class）からJavaTypeを構築するための簡易メソッドですが、明示的なコンテキストはありません。

32

• <T> T convertValue（Object fromValue、Class <T> toValueType）*-変換が必要な場合にのみ、指定された値から指定された値型のインスタンスへの2ステップ変換を行うための便利なメソッド。

33

• <T> T convertValue（Object fromValue、JavaType toValueType）*-convertValue（Object、Class）を参照

34

• <T> T convertValue（Object fromValue、TypeReference <？> toValueTypeRef）*-convertValue（Object、Class）を参照

35

• ObjectMapper copy（）*-このインスタンスと同じ初期構成を持つ新しいObjectMapperインスタンスを作成するためのメソッド。

36

• ArrayNode createArrayNode（）*-注：基本的なObjectCodec抽象化は具体的なノードタイプを参照できないため、戻り値の型は共変です（コアパッケージの一部であるのに対して、implsはマッパーパッケージの一部です）

protected DefaultDeserializationContext createDeserializationContext（JsonParser p、DeserializationConfig cfg）-単一のルート値を逆シリアル化するためのDeserializationContextのインスタンスを作成するために呼び出される内部ヘルパーメソッド。

37

• ObjectNode createObjectNode（）*-注：戻り値の型は共変です。基本的なObjectCodecの抽象化は具体的なノード型を参照できないためです（コアパッケージの一部であるのに対して、implsはマッパーパッケージの一部です）

38

• protected ClassIntrospector defaultClassIntrospector（）*-使用するデフォルトのClassIntrospectorを構築するために使用されるオーバーライド可能なヘルパーメソッド。

39

• ObjectMapper disable（DeserializationFeature feature）*-指定されたDeserializationConfig機能を有効にする方法。

40

• ObjectMapper disable（DeserializationFeature first、DeserializationFeature …​ f）*-指定されたDeserializationConfig機能を有効にする方法。

41

• ObjectMapper disable（JsonGenerator.Feature …​ features）*-このオブジェクトマッパーが作成するパーサーインスタンスの指定されたJsonGenerator.Featuresを無効にするメソッド。

42

• ObjectMapper disable（JsonParser.Feature …​ features）*-このオブジェクトマッパーが作成するパーサーインスタンスの指定されたJsonParser.Featuresを無効にするメソッド。

43

• ObjectMapper disable（MapperFeature …​ f）*-指定されたDeserializationConfig機能を有効にする方法。

44

• ObjectMapper disable（SerializationFeature f）*-指定されたDeserializationConfig機能を有効にする方法。

45

• ObjectMapper disable（SerializationFeature first、SerializationFeature …​ f）*-指定されたDeserializationConfig機能を有効にする方法。

46

• ObjectMapper disableDefaultTyping（）*-型情報の自動組み込みを無効にするメソッド。その場合、明示的に注釈が付けられた型（JsonTypeInfoを持つ型）のみに追加の型情報が埋め込まれます。

47

• ObjectMapper enable（DeserializationFeature feature）*-指定されたDeserializationConfig機能を有効にする方法。

48

• ObjectMapper enable（DeserializationFeature first、DeserializationFeature …​ f）*-指定されたDeserializationConfig機能を有効にする方法。

49

• ObjectMapper enable（JsonGenerator.Feature …​ features）*-このオブジェクトマッパーが作成するパーサーインスタンスの指定されたJsonGenerator.Featuresを有効にする方法。

50

• ObjectMapper enable（JsonParser.Feature …​ features）*-このオブジェクトマッパーが作成するパーサーインスタンスの指定されたJsonParser.Featuresを有効にする方法。

51

• ObjectMapper enable（MapperFeature …​ f）*-指定されたMapperConfig機能を有効にする方法。

52

• ObjectMapper enable（SerializationFeature f）*-指定されたDeserializationConfig機能を有効にする方法。

53

• ObjectMapper enable（SerializationFeature first、SerializationFeature …​ f）*-指定されたDeserializationConfig機能を有効にする方法。

54

• ObjectMapper enableDefaultTyping（）*-呼び出しと同等の便利なメソッド

55

• ObjectMapper enableDefaultTyping（ObjectMapper.DefaultTyping dti）*-呼び出しと同等の便利なメソッド

56

• ObjectMapper enableDefaultTyping（ObjectMapper.DefaultTyping applicability、JsonTypeInfo.As includeAs）*-ポリモーフィック型の適切な逆シリアル化に必要な型情報の自動インクルードを有効にするメソッド（型にJsonTypeInfoアノテーションが付けられていない場合）。

57

• ObjectMapper enableDefaultTypingAsProperty（ObjectMapper.DefaultTyping applicability、String propertyName）*-型情報の自動組み込みを有効にするためのメソッド-ポリモーフィック型の適切なデシリアライゼーションに必要（JsonTypeInfoで注釈が付けられていない限り）-「As.PROPERTY」包含メカニズムの使用含めるために使用する指定されたプロパティ名（デフォルトのタイプ情報は常にタイプ識別子としてクラス名を使用するため、デフォルトは「@class」です）

58

• ObjectMapper findAndRegisterModules（）*-機能的に同等の便利なメソッド：mapper.registerModules（mapper.findModules（））;

59

• Class <？> findMixInClassFor（Class <？> cls）*

60

• static List <Module> findModules（）*-JDK ServiceLoader機能とモジュール提供のSPIを使用して、使用可能なメソッドを検索するメソッド。

61

• static List <Module> findModules（ClassLoader classLoader）*-JDK ServiceLoader機能とモジュール提供のSPIを使用して、使用可能なメソッドを検索するメソッド。

JsonSchema generateJsonSchema（Class <？> t）-非推奨です。 2.6は外部JSONスキーマジェネレーター（https://github.com/FasterXML/jackson-module-jsonSchema）を使用するため（内部ではacceptJsonFormatVisitor（JavaType、JsonFormatVisitorWrapper）を呼び出します）

62

• DateFormat getDateFormat（）*

63

• DeserializationConfig getDeserializationConfig（）*-シリアル化解除の構成設定を定義する共有デフォルトDeserializationConfigオブジェクトを返すメソッド。

64

• DeserializationContext getDeserializationContext（）*-現在のDeserializationContextを取得するためのメソッド。

65

• JsonFactory getFactory（）*-JsonParsersやJsonGeneratorsを構築する必要がある場合にこのマッパーが使用するJsonFactoryを取得するために使用できるメソッド。

66

• InjectableValues getInjectableValues（）*

67

• JsonFactory getJsonFactory（）*-非推奨です。 2.1以降：代わりにgetFactory（）を使用してください

68

• JsonNodeFactory getNodeFactory（）*-ツリーのルートJsonNodeインスタンスを直接構築するときにこのマッパーが使用するJsonNodeFactoryを取得するために使用できるメソッド。

69

• PropertyNamingStrategy getPropertyNamingStrategy（）*

70

• SerializationConfig getSerializationConfig（）*-シリアル化の構成設定を定義する共有のデフォルトSerializationConfigオブジェクトを返すメソッド。

71

• SerializerFactory getSerializerFactory（）*-現在のSerializerFactoryを取得するためのメソッド。

72

• SerializerProvider getSerializerProvider（）*-DefaultSerializerProvider.createInstance（com.fasterxml.jackson.databind.SerializationConfig、com.fasterxml.jackson.databind.serを呼び出すことによりインスタンスが作成される「ブループリント」（またはファクトリー）インスタンスのアクセサー.SerializerFactory）。

73

• SerializerProvider getSerializerProviderInstance（）*-シリアライザーへのアクセスに使用できるSerializerProviderインスタンスを作成して返すためのアクセサー。

74

• SubtypeResolver getSubtypeResolver（）*-使用中のサブタイプリゾルバーにアクセスするためのメソッド。

75

• TypeFactory getTypeFactory（）*-現在設定されているTypeFactoryインスタンスを取得するためのアクセサー。

76

• VisibilityChecker <？> getVisibilityChecker（）*-現在構成されている可視性チェッカーにアクセスするためのメソッド。指定されたプロパティ要素（メソッド、フィールド、コンストラクター）を自動検出できるかどうかを決定するために使用されるオブジェクト。

77

• boolean isEnabled（DeserializationFeature f）*-特定のデシリアライゼーション固有の機能が有効になっているかどうかを確認する方法。

78

• boolean isEnabled（JsonFactory.Feature f）*-簡易メソッド、次と同等：

79

• boolean isEnabled（JsonGenerator.Feature f）*

80

• boolean isEnabled（JsonParser.Feature f）*

81

• boolean isEnabled（MapperFeature f）*-指定されたMapperFeatureが有効かどうかを確認するためのメソッド。

82

• boolean isEnabled（SerializationFeature f）*-指定されたシリアル化固有の機能が有効かどうかを確認する方法。

83

• int mixInCount（）*

84

• ObjectReader reader（）*-デフォルト設定でObjectReaderを構築するためのファクトリメソッド。

85

• ObjectReader reader（Base64Variant defaultBase64）*-Base64エンコードバイナリデータ用に指定されたBase64エンコードバリアントを使用するObjectReaderを構築するためのファクトリメソッド。

86

• ObjectReader reader（Class <？> type）*-非推奨です。 2.5以降、代わりにreaderFor（Class）を使用してください

87

• ObjectReader reader（ContextAttributes attrs）*-指定されたデフォルト属性を使用するObjectReaderを構築するためのファクトリメソッド。

88

• ObjectReader reader（DeserializationFeature feature）*-指定された機能を有効にしてObjectReaderを構築するためのファクトリメソッド（このマッパーインスタンスの設定と比較）。

89

• ObjectReader reader（DeserializationFeature first、DeserializationFeature …​ other）*-指定された機能を有効にしてObjectReaderを構築するためのファクトリメソッド（このマッパーインスタンスの設定と比較）。

90

• ObjectReader reader（FormatSchema schema）*-コンテンツの読み取りに使用されるJsonParserに特定のスキーマオブジェクトを渡すObjectReaderを構築するためのファクトリメソッド。

91

• ObjectReader reader（InjectableValues injectableValues）*-指定された注入可能な値を使用するObjectReaderを構築するためのファクトリメソッド。

92

• ObjectReader reader（JavaType type）*-非推奨です。 2.5以降、代わりにreaderFor（JavaType）を使用してください

93

• ObjectReader reader（JsonNodeFactory f）*-JSONツリーの構築に指定されたJsonNodeFactoryを使用するObjectReaderを構築するためのファクトリメソッド。

94

• ObjectReader reader（TypeReference <？> type）*-非推奨です。 2.5以降、代わりにreaderFor（TypeReference）を使用してください

95

• ObjectReader readerFor（Class <？> type）*-指定されたタイプのインスタンスを読み取りまたは更新するObjectReaderを構築するためのファクトリメソッド

96

• ObjectReader readerFor（JavaType type）*-指定されたタイプのインスタンスを読み取りまたは更新するObjectReaderを構築するためのファクトリメソッド

97

• ObjectReader readerFor（TypeReference <？> type）*-指定されたタイプのインスタンスを読み取りまたは更新するObjectReaderを構築するためのファクトリメソッド

98

• ObjectReader readerForUpdating（Object valueToUpdate）*-指定されたオブジェクト（通常はBeanですが、コレクションでもマップでも、配列ではありません）をJSONデータで更新するObjectReaderを構築するファクトリメソッド。

99

• ObjectReader readerWithView（Class <？> view）*-指定されたJSONビュー（フィルター）を使用してオブジェクトを逆シリアル化するObjectReaderを構築するためのファクトリメソッド。

100

• JsonNode readTree（byte [] content）*-JsonNodeインスタンスのセットを使用して表現されたツリーとしてJSONコンテンツを逆シリアル化するメソッド。

101

• JsonNode readTree（File file）*-JsonNodeインスタンスのセットを使用して表現されたツリーとしてJSONコンテンツを逆シリアル化するメソッド。

102

• JsonNode readTree（InputStream in）*-JsonNodeインスタンスのセットを使用して表現されたツリーとしてJSONコンテンツを逆シリアル化するメソッド。

103

• <T extends TreeNode> T readTree（JsonParser p）*-JsonNodeインスタンスのセットを使用して表されるツリーとしてJSONコンテンツをデシリアライズするメソッド。

104

• JsonNode readTree（Reader r）*-JsonNodeインスタンスのセットを使用して表現されたツリーとしてJSONコンテンツを逆シリアル化するメソッド。

105

• JsonNode readTree（String content）*-JsonNodeインスタンスのセットを使用して表現されたツリーとしてJSONコンテンツを逆シリアル化するメソッド。

106

• JsonNode readTree（URL source）*-JsonNodeインスタンスのセットを使用して表現されたツリーとしてJSONコンテンツを逆シリアル化するメソッド。

107

• <T> T readValue（byte [] src、Class <T> valueType）*

108

• <T> T readValue（byte [] src、int offset、int len、Class <T> valueType）*

109

• <T> T readValue（byte [] src、int offset、int len、JavaType valueType）*

110

• <T> T readValue（byte [] src、int offset、int len、TypeReference valueTypeRef）*

111

• <T> T readValue（byte [] src、JavaType valueType）*

112

• <T> T readValue（byte [] src、TypeReference valueTypeRef）*

113

• <T> T readValue（DataInput src、Class <T> valueType）*

114

• <T> T readValue（DataInput src、JavaType valueType）*

115

• <T> T readValue（File src、Class <T> valueType）*-指定されたファイルのJSONコンテンツを指定されたJavaタイプにデシリアライズするメソッド。

116

• <T> T readValue（File src、JavaType valueType）*-指定されたファイルのJSONコンテンツを指定されたJavaタイプにデシリアライズするメソッド。

117

• <T> T readValue（File src、TypeReference valueTypeRef）*-指定されたファイルのJSONコンテンツを指定されたJavaタイプにデシリアライズするメソッド。

118

• <T> T readValue（InputStream src、Class <T> valueType）*

119

• <T> T readValue（InputStream src、JavaType valueType）*

120

• <T> T readValue（InputStream src、TypeReference valueTypeRef）*

121

• <T> T readValue（JsonParser p、Class <T> valueType）-JSONコンテンツを非コンテナ型（ただし、配列型にすることができます）に逆シリアル化する方法：通常、Bean、配列、またはラッパー型（ブール値など）。*

122

• <T> T readValue（JsonParser p、JavaType valueType）*-タイプセーフなオーバーロードメソッド、基本的にreadValue（JsonParser、Class）のエイリアス。

123

• <T> T readValue（JsonParser p、ResolvedType valueType）*-JSONコンテンツをJava型に逆シリアル化するメソッド。参照は引数として渡されます。

124

• <T> T readValue（JsonParser p、TypeReference <？> valueTypeRef）*-JSONコンテンツをJava型に逆シリアル化するメソッド。参照は引数として渡されます。

125

• <T> T readValue（Reader src、Class <T> valueType）*-

1

• <T> T readValue（Reader src、JavaType valueType）*

126

• <T> T readValue（Reader src、TypeReference valueTypeRef）*

127

• <T> T readValue（String content、Class <T> valueType）*-指定されたJSONコンテンツ文字列からJSONコンテンツをデシリアライズするメソッド。

128

• <T> T readValue（String content、JavaType valueType）*-指定されたJSONコンテンツ文字列からJSONコンテンツをデシリアライズするメソッド。

129

• <T> T readValue（String content、TypeReference valueTypeRef）*-指定されたJSONコンテンツ文字列からJSONコンテンツを逆シリアル化するメソッド。

130

• <T> T readValue（URL src、Class <T> valueType）*-JSONコンテンツを特定のリソースから特定のJavaタイプにデシリアライズするメソッド。

131

• <T> T readValue（URL src、JavaType valueType）*

132

• <T> T readValue（URL src、TypeReference valueTypeRef）*-JSONコンテンツを特定のリソースから特定のJava型に逆シリアル化するメソッド。

133

• <T> MappingIterator <T> readValues（JsonParser p、Class <T> valueType）*-便利なメソッド、機能的には以下と同等：

134

• <T> MappingIterator <T> readValues（JsonParser p、JavaType valueType）*-コンビニエンスメソッド、機能的には以下と同等：

135

• <T> MappingIterator <T> readValues（JsonParser p、ResolvedType valueType）*-コンビニエンスメソッド、機能的には以下と同等：

136

• <T> MappingIterator <T> readValues（JsonParser p、TypeReference <？> valueTypeRef）*-パーサーストリームからオブジェクトのシーケンスを読み取るためのメソッド。

137

• ObjectMapper registerModule（Module module）*-このマッパーによって提供される機能を拡張できるモジュールを登録するためのメソッド。たとえば、カスタムシリアライザーおよびデシリアライザーのプロバイダーを追加します。

138

• ObjectMapper registerModules（Iterable <Module> modules）*-指定されたモジュールを順番に登録するための便利なメソッド。機能的に同等：

139

• ObjectMapper registerModules（Module …​ modules）*-指定されたモジュールを順番に登録する便利な方法。機能的に同等：

void registerSubtypes（Class <？> …​ classes）-指定されたクラスをサブタイプとして登録するためのメソッドです。これにより、タイプ名ベースの解決でスーパータイプをサブタイプにリンクできます（注釈を使用する代わりに）。

140

• void registerSubtypes（NamedType …​ types）*-指定されたクラスをサブタイプとして登録する方法。これにより、タイプ名ベースの解決でスーパータイプをサブタイプにリンクできます（注釈を使用する代わりに）。

141

• ObjectMapper setAnnotationIntrospector（AnnotationIntrospector ai）*-このマッパーインスタンスで使用されるAnnotationIntrospectorをシリアル化と逆シリアル化の両方に設定するためのメソッド。

142

• ObjectMapper setAnnotationIntrospectors（AnnotationIntrospector serializerAI、AnnotationIntrospector deserializerAI）*-このマッパーインスタンスで使用されるAnnotationIntrospectorインスタンスをシリアル化および逆シリアル化のために変更する方法。

143

• ObjectMapper setBase64Variant（Base64Variant v）*-byte []シリアライザーおよびデシリアライザーが使用するデフォルトのBase64Variantを構成するメソッド。

144

• ObjectMapper setConfig（DeserializationConfig config）*-基礎となるDeserializationConfigオブジェクトのオーバーライドを許可するメソッド。

145

• ObjectMapper setConfig（SerializationConfig config）*-シリアル化固有の構成設定を含む、基になるSerializationConfigオブジェクトのオーバーライドを許可するメソッド。

146

• ObjectMapper setDateFormat（DateFormat dateFormat）*-時間値を文字列としてシリアル化し、JSON文字列から逆シリアル化するときに使用するデフォルトのDateFormatを構成するためのメソッド。

147

• ObjectMapper setDefaultPrettyPrinter（PrettyPrinter pp）*-（SerializationFeature.INDENT_OUTPUTを有効にすることにより）「デフォルトのプリティプリンティング」が有効な場合に使用するPrettyPrinterを指定する方法

148

• ObjectMapper setDefaultTyping（TypeResolverBuilder <？> typer）*-型情報の自動組み込みを有効にするメソッド。指定されたハンドラーオブジェクトを使用して、これが影響する型および情報の埋め込み方法の詳細を決定します。

149

• ObjectMapper setFilterProvider（FilterProvider filterProvider）*-フィルターIDを実際のフィルターインスタンスにマッピングするために指定されたFilterProviderを使用するようにこのマッパーを構成する方法。

void setFilters（FilterProvider filterProvider）-非推奨です。 2.6以降、代わりにsetFilterProvider（com.fasterxml.jackson.databind.ser.FilterProvider）を使用します（連鎖を許可します）

150

• Object setHandlerInstantiator（HandlerInstantiator hi）*-クラスを指定して、ハンドラーのインスタンス（シリアライザー、デシリアライザー、型、型IDリゾルバーなど）の作成に使用するHandlerInstantiatorを構成するメソッド。

151

• ObjectMapper setInjectableValues（InjectableValues injectableValues）*-注入する値を見つけるために使用されるInjectableValuesを構成するためのメソッド。

152

• ObjectMapper setLocale（Locale l）*-フォーマットに使用するデフォルトのロケールをオーバーライドするメソッド。

153

• void setMixInAnnotations（Map <Class <？>、Class <？>> sourceMixins）*-非推奨。 2.5以降：流な形式のメソッドに置き換えられました。 setMixIns（java.util.Map <java.lang.Class <？>、java.lang.Class <？>>）。

154

• ObjectMapper setMixInResolver（ClassIntrospector.MixInResolver resolver）*-使用するミックスインクラスを特定するために特定のリゾルバーを指定するために呼び出すことができるメソッドで、直接追加されたマッピングをオーバーライドします。

155

• ObjectMapper setMixIns（Map <Class <？>、Class <？>> sourceMixins）*-処理可能な（シリアライズ可能/デシリアライズ可能な）クラスが持つ注釈を補強するために使用するミックスイン注釈の定義に使用するメソッド。

156

• ObjectMapper setNodeFactory（JsonNodeFactory f）*-ルートレベルツリーノードの構築に使用するJsonNodeFactoryを指定するメソッド（メソッドcreateObjectNode（）を使用）

157

• ObjectMapper setPropertyInclusion（JsonInclude.Value incl）*-シリアル化のためのデフォルトのPOJOプロパティ包含戦略を設定するためのメソッド。

158

• ObjectMapper setPropertyNamingStrategy（PropertyNamingStrategy s）*-使用するカスタムプロパティの命名戦略を設定する方法。

159

• ObjectMapper setSerializationInclusion（JsonInclude.Include incl）*-呼び出しと同等の便利なメソッド：

160

• ObjectMapper setSerializerFactory（SerializerFactory f）*-（bean）シリアライザーの構築に使用する特定のSerializerFactoryを設定するメソッド。

161

• ObjectMapper setSerializerProvider（DefaultSerializerProvider p）*-JsonSerializerインスタンスのキャッシングの処理に使用する実際のプロバイダーインスタンスのベースとして使用する「blueprint」SerializerProviderインスタンスを設定するメソッド。

162

• ObjectMapper setSubtypeResolver（SubtypeResolver str）*-使用するカスタムサブタイプリゾルバーを設定するためのメソッド。

163

• ObjectMapper setTimeZone（TimeZone tz）*-フォーマットに使用するデフォルトのTimeZoneをオーバーライドするメソッド。

164

• ObjectMapper setTypeFactory（TypeFactory f）*-このマッパーが使用するTypeFactoryインスタンスをオーバーライドするために使用できるメソッド。

165

• ObjectMapper setVisibility（PropertyAccessor forMethod、JsonAutoDetect.Visibility visibility）*-基礎となるVisibilityCheckersの構成を変更して、どの種類のプロパティが自動検出されるかの詳細を変更できるようにする便利なメソッド。

166

• ObjectMapper setVisibility（VisibilityChecker <？> vc）*-現在構成されているVisibilityCheckerを設定するためのメソッド。特定のプロパティ要素（メソッド、フィールド、コンストラクター）を自動検出できるかどうかを決定するために使用されるオブジェクト。

167

• void setVisibilityChecker（VisibilityChecker <？> vc）*-非推奨です。 2.6以降では、代わりにsetVisibility（VisibilityChecker）を使用します。

168

• JsonParser treeAsTokens（TreeNode n）*-JSONツリー表現からJsonParserを構築するためのメソッド。

169

• <T> T treeToValue（TreeNode n、Class <T> valueType）*-JSONツリーに含まれるデータを特定の値（通常はBean）タイプにバインドする便利な変換メソッド。

170

• <TはJsonNodeを拡張> T valueToTree（Object fromValue）*-treeToValue（com.fasterxml.jackson.core.TreeNode、java.lang.Class <T>）の逆;値（通常はBean）を指定すると、同等のJSONツリー表現が構築されます。

171

• Version version（）*-このクラスを含むjarに格納され、そこから読み取られるバージョン情報を返すメソッド。

172

• ObjectWriter writer（）*-デフォルト設定でObjectWriterを構築するための便利なメソッド。

173

• ObjectWriter writer（Base64Variant defaultBase64）*-Base64エンコードバイナリデータに指定されたBase64エンコードバリアントを使用するObjectWriterを構築するためのファクトリメソッド。

174

• ObjectWriter writer（CharacterEscapes escapes）*-

出力に指定された文字エスケープの詳細を使用するObjectReaderを構築するためのファクトリメソッド。

175

• ObjectWriter writer（ContextAttributes attrs）*-指定されたデフォルト属性を使用するObjectWriterを構築するためのファクトリメソッド。

176

• ObjectWriter writer（DateFormat df）*-指定されたDateFormatを使用してオブジェクトをシリアル化するObjectWriterを構築するためのファクトリメソッド。または、nullが渡された場合、タイムスタンプ（64ビット数を使用します。

177

• ObjectWriter writer（FilterProvider filterProvider）*-指定されたフィルタープロバイダーを使用してオブジェクトをシリアル化するObjectWriterを構築するためのファクトリメソッド。

178

• ObjectWriter writer（FormatSchema schema）*-コンテンツの書き込みに使用されるJsonGeneratorに特定のスキーマオブジェクトを渡すObjectWriterを構築するためのファクトリメソッド。

179

• ObjectWriter writer（PrettyPrinter pp）*-インデントに指定されたプリティプリンターを使用してオブジェクトをシリアル化するObjectWriterを構築するためのファクトリメソッド（またはnullの場合、プリティプリンターなし）

180

• ObjectWriter writer（SerializationFeature feature）*-指定された機能を有効にしてObjectWriterを構築するためのファクトリメソッド（このマッパーインスタンスの設定と比較）。

181

• ObjectWriter writer（SerializationFeature first、SerializationFeature …​ other）*-指定された機能を有効にしてObjectWriterを構築するためのファクトリメソッド（このマッパーインスタンスの設定と比較）。

182

• ObjectWriter writerFor（Class <？> rootType）*-値の実際のランタイムタイプの代わりに、指定されたルートタイプを使用してオブジェクトをシリアル化するObjectWriterを構築するためのファクトリメソッド。

183

• ObjectWriter writerFor（JavaType rootType）*-実際のランタイム型の値ではなく、指定されたルート型を使用してオブジェクトをシリアル化するObjectWriterを構築するためのファクトリメソッド。

184

• ObjectWriter writerFor（TypeReference <？> rootType）*-値の実際のランタイムタイプの代わりに、指定されたルートタイプを使用してオブジェクトをシリアル化するObjectWriterを構築するためのファクトリメソッド。

185

• ObjectWriter writerWithDefaultPrettyPrinter（）*-インデントにデフォルトのプリティプリンターを使用してオブジェクトをシリアル化するObjectWriterを構築するためのファクトリメソッド。

186

• ObjectWriter writerWithType（Class <？> rootType）*-非推奨です。 2.5以降、代わりにwriterFor（Class）を使用してください。

187

• ObjectWriter writerWithType（JavaType rootType）*-非推奨です。 2.5以降、代わりにwriterFor（JavaType）を使用してください。

188

• ObjectWriter writerWithType（TypeReference <？> rootType）*-非推奨です。 2.5以降では、代わりにwriterFor（TypeReference）を使用してください。

189

• ObjectWriter writerWithView（Class <？> serializationView）*-指定されたJSONビュー（フィルター）を使用してオブジェクトをシリアル化するObjectWriterを構築するためのファクトリメソッド。

190

• void writeTree（JsonGenerator jgen、JsonNode rootNode）*-提供されるジェネレーターを使用して、指定されたJSONツリーをシリアル化するメソッド。

191

• void writeTree（JsonGenerator jgen、TreeNode rootNode）*

192

• void writeValue（DataOutput out、Object value）*

193

• void writeValue（File resultFile、Object value）*-提供されたFileに書き込まれたJSON値としてJava値をシリアル化するために使用できるメソッド。

194

• void writeValue（JsonGenerator g、Object value）*-提供されたJsonGeneratorを使用して、JSON出力としてJava値をシリアル化するために使用できるメソッド。

195

• void writeValue（OutputStream out、Object value）*-提供された出力ストリーム（エンコーディングJsonEncoding.UTF8を使用）を使用して、JSON出力としてJava値をシリアル化するために使用できるメソッド。

196

• void writeValue（Writer w、Object value）*-提供されたWriterを使用して、Java値をJSON出力としてシリアル化するために使用できるメソッド。

197

• byte [] writeValueAsBytes（Object value）*-Java値をバイト配列としてシリアル化するために使用できるメソッド。

198

• String writeValueAsString（Object value）*-Java値を文字列としてシリアル化するために使用できるメソッド。

継承されたメソッド

このクラスは、次のクラスからメソッドを継承します。

• java.lang.Object

ObjectMapperの例

たとえば C：/> Jackson_WORKSPACE で選択した任意のエディターを使用して、次のJavaプログラムを作成します。

ファイル：JacksonTester.java

import java.io.IOException;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

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

      ObjectMapper mapper = new ObjectMapper();
      String jsonString = "{\"name\":\"Mahesh\", \"age\":21}";

     //map json to student
      try{
         Student student = mapper.readValue(jsonString, Student.class);

         System.out.println(student);

         jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(student);

         System.out.println(jsonString);
      }
      catch (JsonParseException e) { e.printStackTrace();}
      catch (JsonMappingException e) { e.printStackTrace(); }
      catch (IOException e) { e.printStackTrace(); }
   }
}

class Student {
   private String name;
   private int age;
   public Student(){}
   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 String toString(){
      return "Student [ name: "+name+", age: "+ age+ " ]";
   }
}

結果を確認する

次のように javac コンパイラを使用してクラスをコンパイルします。

C:\Jackson_WORKSPACE>javac JacksonTester.java

次に、jacksonTesterを実行して結果を確認します。

C:\Jackson_WORKSPACE>java JacksonTester

出力を確認する

Student [ name: Mahesh, age: 21 ]
{
  "name" : "Mahesh",
  "age" : 21
}

Jackson-object-serialization

ジャクソン-データバインディング

データバインディングAPIは、プロパティアクセサーまたはアノテーションを使用してJSONをPOJO（Plain Old Java Object）との間で変換するために使用されます。 それは2つのタイプです。

• シンプルなデータバインディング-JSONからJavaマップ、リスト、文字列、数値、ブール値、nullオブジェクトへの変換を行います。
• 完全なデータバインディング-JSONを任意のJAVAタイプとの間で変換します。

ObjectMapperは、両方のタイプのデータバインディングのJSONを読み書きします。 データバインディングは最も便利な方法であり、XMLのJAXBパーラーに類似しています。

シンプルなデータバインディング

シンプルなデータバインディングとは、JSONからJAVA Coreデータ型へのマッピングを指します。 次の表は、JSONタイプとJavaタイプの関係を示しています。

Sr. No.	JSON Type	Java Type
1	object	LinkedHashMap<String,Object>
2	array	ArrayList<Object>
3	string	String
4	complete number	Integer, Long or BigInteger
5	fractional number	Double/BigDecimal
6	true	false
Boolean	7	null

実際のシンプルなデータバインディングを見てみましょう。 ここでは、JAVAの基本型をJSONに直接マッピングし、その逆も行います。

*C：\> Jackson_WORKSPACE* にJacksonTesterという名前のJavaクラスファイルを作成します。

ファイル：JacksonTester.java

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      JacksonTester tester = new JacksonTester();
         try {
            ObjectMapper mapper = new ObjectMapper();

            Map<String,Object> studentDataMap = new HashMap<String,Object>();
            int[] marks = {1,2,3};

            Student student = new Student();
            student.setAge(10);
            student.setName("Mahesh");
           //JAVA Object
            studentDataMap.put("student", student);
           //JAVA String
            studentDataMap.put("name", "Mahesh Kumar");
           //JAVA Boolean
            studentDataMap.put("verified", Boolean.FALSE);
           //Array
            studentDataMap.put("marks", marks);

            mapper.writeValue(new File("student.json"), studentDataMap);
           //result student.json
           //{
           //  "student":{"name":"Mahesh","age":10},
           //  "marks":[1,2,3],
           //  "verified":false,
           //  "name":"Mahesh Kumar"
           //}
            studentDataMap = mapper.readValue(new File("student.json"), Map.class);

            System.out.println(studentDataMap.get("student"));
            System.out.println(studentDataMap.get("name"));
            System.out.println(studentDataMap.get("verified"));
            System.out.println(studentDataMap.get("marks"));
      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
            e.printStackTrace();
      }
   }
}

class Student {
   private String name;
   private int age;
   public Student(){}
   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 String toString(){
      return "Student [ name: "+name+", age: "+ age+ " ]";
   }
}

結果を確認する

次のように javac コンパイラを使用してクラスをコンパイルします。

C:\Jackson_WORKSPACE>javac JacksonTester.java

次に、jacksonTesterを実行して結果を確認します。

C:\Jackson_WORKSPACE>java JacksonTester

出力を確認する

{name=Mahesh, age=10}
Mahesh Kumar
false
[1, 2, 3]

リンク：/jackson/jackson_full_data_binding [完全なデータバインディング]

リンク：/jackson/jackson_data_binding_generics [ジェネリックとのデータバインディング]

ジャクソン-ツリーモデル

ツリーモデルは、JSONドキュメントのメモリ内ツリー表現を準備します。 ObjectMapperは、JsonNodeノードのツリーを構築します。 最も柔軟なアプローチです。 XMLのDOMパーサーに類似しています。

JSONからツリーを作成する

ObjectMapperは、JSONを読み取った後、ツリーのルートノードへのポインターを提供します。 ルートノードを使用して、完全なツリーを走査できます。 提供されたJSON文字列のルートノードを取得するには、次のコードスニペットを検討してください。

//Create an ObjectMapper instance
ObjectMapper mapper = new ObjectMapper();
String jsonString = "{\"name\":\"Mahesh Kumar\", \"age\":21,\"verified\":false,\"marks\": [100,90,85]}";
//create tree from JSON
JsonNode rootNode = mapper.readTree(jsonString);

トラバースツリーモデル

ツリーをトラバースしながらルートノードへの相対パスを使用して各ノードを取得し、データを処理します。 ルートノードを提供するツリーを走査する次のコードスニペットを検討してください。

JsonNode nameNode = rootNode.path("name");
System.out.println("Name: "+ nameNode.textValue());

JsonNode marksNode = rootNode.path("marks");
Iterator<JsonNode> iterator = marksNode.elements();

例

*C：\> Jackson_WORKSPACE* にJacksonTesterという名前のJavaクラスファイルを作成します。

ファイル：JacksonTester.java

import java.io.IOException;
import java.util.Iterator;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

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

      try {
         ObjectMapper mapper = new ObjectMapper();
         String jsonString = "{\"name\":\"Mahesh Kumar\",  \"age\":21,\"verified\":false,\"marks\": [100,90,85]}";
         JsonNode rootNode = mapper.readTree(jsonString);

         JsonNode nameNode = rootNode.path("name");
         System.out.println("Name: "+ nameNode.textValue());

         JsonNode ageNode = rootNode.path("age");
         System.out.println("Age: " + ageNode.intValue());

         JsonNode verifiedNode = rootNode.path("verified");
         System.out.println("Verified: " + (verifiedNode.booleanValue() ? "Yes":"No"));

         JsonNode marksNode = rootNode.path("marks");
         Iterator<JsonNode> iterator = marksNode.elements();
         System.out.print("Marks: [ ");

         while (iterator.hasNext()) {
            JsonNode marks = iterator.next();
            System.out.print(marks.intValue() + " ");
         }

         System.out.println("]");
      }
      catch (JsonParseException e) { e.printStackTrace(); }
      catch (JsonMappingException e) { e.printStackTrace(); }
      catch (IOException e) { e.printStackTrace(); }
   }
}

結果を確認する

次のように javac コンパイラを使用してクラスをコンパイルします。

C:\Jackson_WORKSPACE>javac JacksonTester.java

次に、jacksonTesterを実行して結果を確認します。

C:\Jackson_WORKSPACE>java JacksonTester

出力を確認する

Name: Mahesh Kumar
Age: 21
Verified: No
Marks: [ 100 90 85 ]

リンク：/jackson/jackson_tree_to_json [ツリーからJSON]

リンク：/jackson/jackson_tree_to_object [ツリーからJavaオブジェクトへ]

ジャクソン-ストリーミングAPI

ストリーミングAPIは、JSONコンテンツを個別のイベントとして読み書きします。 JsonParserはデータを読み取りますが、JsonGeneratorはデータを書き込みます。 これは3つの中で最も強力なアプローチであり、読み取り/書き込み操作のオーバーヘッドが最も低く、高速です。 XMLのStaxパーサーに類似しています。

この記事では、JacksonストリーミングAPIを使用してJSONデータを読み書きする方法を紹介します。 ストリーミングAPIはトークンの概念で動作し、Jsonの詳細はすべて慎重に処理する必要があります。 以下は、例で使用する2つのクラスです。

• link：/jackson/jackson_jsongenerator [JsonGenerator] -JSON文字列に書き込みます。
• link：/jackson/jackson_jsonparser [JsonParser] -JSON文字列を解析します。

JsonGeneratorを使用してJSONを記述する

JsonGeneratorの使用は非常に簡単です。 最初に、JsonFactory.createJsonGenerator（）メソッドを使用してJsonGeneratorを作成し、write *（）メソッドを使用して各json値を書き込みます。

JsonFactory jsonFactory = new JsonFactory();
JsonGenerator jsonGenerator = jsonFactory.createGenerator(new File(
   "student.json"), JsonEncoding.UTF8);
//{
jsonGenerator.writeStartObject();
//"name" : "Mahesh Kumar"
jsonGenerator.writeStringField("name", "Mahesh Kumar");

JsonGeneratorの動作を見てみましょう。 C：\> Jackson_WORKSPACE にJacksonTesterという名前のJavaクラスファイルを作成します。

ファイル：JacksonTester.java

import java.io.File;
import java.io.IOException;
import java.util.Map;

import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

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

      try {
         JsonFactory jsonFactory = new JsonFactory();
         JsonGenerator jsonGenerator = jsonFactory.createGenerator(new File("student.json"), JsonEncoding.UTF8);

         jsonGenerator.writeStartObject();

        //"name" : "Mahesh Kumar"
         jsonGenerator.writeStringField("name", "Mahesh Kumar");

        //"age" : 21
         jsonGenerator.writeNumberField("age", 21);

        //"verified" : false
         jsonGenerator.writeBooleanField("verified", false);

        //"marks" : [100, 90, 85]
         jsonGenerator.writeFieldName("marks");

        //[
         jsonGenerator.writeStartArray();
        //100, 90, 85
         jsonGenerator.writeNumber(100);
         jsonGenerator.writeNumber(90);
         jsonGenerator.writeNumber(85);
        //]

         jsonGenerator.writeEndArray();

         jsonGenerator.writeEndObject();
         jsonGenerator.close();

        //result student.json
        //{
        //  "name":"Mahesh Kumar",
        //  "age":21,
        //  "verified":false,
        //  "marks":[100,90,85]
        //}

         ObjectMapper mapper = new ObjectMapper();
         Map<String,Object> dataMap = mapper.readValue(new File("student.json"), Map.class);

         System.out.println(dataMap.get("name"));
         System.out.println(dataMap.get("age"));
         System.out.println(dataMap.get("verified"));
         System.out.println(dataMap.get("marks"));
      }
      catch (JsonParseException e) { e.printStackTrace(); }
      catch (JsonMappingException e) { e.printStackTrace(); }
      catch (IOException e) { e.printStackTrace(); }
   }
}

結果を確認する

次のように javac コンパイラを使用してクラスをコンパイルします。

C:\Jackson_WORKSPACE>javac JacksonTester.java

次に、jacksonTesterを実行して結果を確認します。

C:\Jackson_WORKSPACE>java JacksonTester

出力を確認する

Mahesh Kumar
21
false
[100, 90, 85]

JsonParserを使用したJSONの読み取り

JsonParserの使用方法も簡単です。 最初にJsonFactory.createJsonParser（）メソッドを使用してJsonParserを作成し、そのnextToken（）メソッドを使用して各json文字列をトークンとして読み取ります。 各トークンを確認し、それに応じて処理します

JsonFactory jasonFactory = new JsonFactory();
JsonParser jsonParser = jasonFactory.createJsonParser(new File("student.json"));
while (jsonParser.nextToken() != JsonToken.END_OBJECT) {
  //get the current token
   String fieldname = jsonParser.getCurrentName();
   if ("name".equals(fieldname)) {
     //move to next token
      jsonParser.nextToken();
      System.out.println(jsonParser.getText());
   }
}

JsonParserの動作を見てみましょう。 C：\> Jackson_WORKSPACE にJacksonTesterという名前のJavaクラスファイルを作成します。

ファイル：JacksonTester.java

import java.io.File;
import java.io.IOException;
import java.util.Map;

import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      JacksonTester tester = new JacksonTester();
      try {
         JsonFactory jsonFactory = new JsonFactory();

         JsonGenerator jsonGenerator = jsonFactory.createGenerator(new File(
            "student.json"), JsonEncoding.UTF8);
         jsonGenerator.writeStartObject();
         jsonGenerator.writeStringField("name", "Mahesh Kumar");
         jsonGenerator.writeNumberField("age", 21);
         jsonGenerator.writeBooleanField("verified", false);
         jsonGenerator.writeFieldName("marks");
         jsonGenerator.writeStartArray();//[
         jsonGenerator.writeNumber(100);
         jsonGenerator.writeNumber(90);
         jsonGenerator.writeNumber(85);
         jsonGenerator.writeEndArray();
         jsonGenerator.writeEndObject();
         jsonGenerator.close();

        //result student.json
        //{
        //  "name":"Mahesh Kumar",
        //  "age":21,
        //  "verified":false,
        //  "marks":[100,90,85]
        //}

         JsonParser jsonParser = jsonFactory.createParser(new File("student.json"));
         while (jsonParser.nextToken() != JsonToken.END_OBJECT) {
           //get the current token
            String fieldname = jsonParser.getCurrentName();
            if ("name".equals(fieldname)) {
              //move to next token
               jsonParser.nextToken();
               System.out.println(jsonParser.getText());
            }
            if("age".equals(fieldname)){
              //move to next token
               jsonParser.nextToken();
               System.out.println(jsonParser.getNumberValue());
            }
            if("verified".equals(fieldname)){
              //move to next token
               jsonParser.nextToken();
               System.out.println(jsonParser.getBooleanValue());
            }
            if("marks".equals(fieldname)){
              //move to [
               jsonParser.nextToken();
              //loop till token equal to "]"
               while (jsonParser.nextToken() != JsonToken.END_ARRAY) {
                  System.out.println(jsonParser.getNumberValue());
               }
            }
         }
      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

結果を確認する

次のように javac コンパイラを使用してクラスをコンパイルします。

C:\Jackson_WORKSPACE>javac JacksonTester.java

次に、jacksonTesterを実行して結果を確認します。

C:\Jackson_WORKSPACE>java JacksonTester

出力を確認する

Mahesh Kumar
21
false
[100, 90, 85]