Jackson-annotations-quick-guide

提供：Dev Guides
移動先:案内、検索

Jackson Annotations-@JsonAnyGetter

*@ JsonAnyGetter* を使用すると、getterメソッドはMapを返すことができます。Mapは、他のプロパティと同様の方法でJSONの追加プロパティをシリアル化するために使用されます。

@JsonAnyGetterを使用しない例

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      try{
         Student student = new Student();
         student.add("Name", "Mark");
         student.add("RollNo", "1");
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   private Map<String, String> properties;
   public Student(){
      properties = new HashMap<>();
   }
   public Map<String, String> getProperties(){
      return properties;
   }
   public void add(String property, String value){
      properties.put(property, value);
   }
}

出力

{
   "properties" : {
      "RollNo" : "1",
      "Name" : "Mark"
   }
}

@JsonAnyGetterを使用した例

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import com.fasterxml.jackson.annotation.JsonAnyGetter;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      try{
         Student student = new Student();
         student.add("Name", "Mark");
         student.add("RollNo", "1");
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   private Map<String, String> properties;
   public Student(){
      properties = new HashMap<>();
   }
   @JsonAnyGetter
   public Map<String, String> getProperties(){
      return properties;
   }
   public void add(String property, String value){
      properties.put(property, value);
   }
}

出力

{
   "RollNo" : "1",
   "Name" : "Mark"
}

Jackson Annotations-@JsonGetter

*@ JsonGetter* を使用すると、特定のメソッドをゲッターメソッドとしてマークできます。

@JsonGetterを使用しない例

import java.io.IOException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      try {
         Student student = new Student("Mark", 1);
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   private String name;
   private int rollNo;
   public Student(String name, int rollNo){
      this.name = name;
      this.rollNo = rollNo;
   }
   public String getStudentName(){
      return name;
   }
   public int getRollNo(){
      return rollNo;
   }
}

出力

{
   "studentName" : "Mark",
   "rollNo" : 1
}

@JsonGetterを使用した例

import java.io.IOException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.annotation.JsonGetter;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      try {
         Student student = new Student("Mark", 1);
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   private String name;
   private int rollNo;
   public Student(String name, int rollNo){
      this.name = name;
      this.rollNo = rollNo;
   }
   @JsonGetter
   public String getStudentName(){
      return name;
   }
   public int getRollNo(){
      return rollNo;
   }
}

出力

{
   "name" : "Mark",
   "rollNo" : 1
}

ジャクソン注釈-@JsonPropertyOrder

*@ JsonPropertyOrder* を使用すると、JSONオブジェクトのシリアル化中に特定の順序を保持できます。

@JsonPropertyOrderを使用しない例

import java.io.IOException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      try {
         Student student = new Student("Mark", 1);
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   private String name;
   private int rollNo;
   public Student(String name, int rollNo) {
      this.name = name;
      this.rollNo = rollNo;
   }
   public String getName(){
      return name;
   }
   public int getRollNo(){
      return rollNo;
   }
}

出力

{
   "name" : "Mark",
   "rollNo" : 1
}

例@JsonPropertyOrder

import java.io.IOException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      try {
         Student student = new Student("Mark", 1);
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
@JsonPropertyOrder({ "rollNo", "name" })
class Student {
   private String name;
   private int rollNo;
   public Student(String name, int rollNo){
      this.name = name;
      this.rollNo = rollNo;
   }
   public String getName(){
      return name;
   }
   public int getRollNo(){
      return rollNo;
   }
}

出力

{
   "name" : "Mark",
   "rollNo" : 1
}

ジャクソン注釈-@JsonRawValue

*@ JsonRawValue* を使用すると、エスケープまたは装飾なしでテキストをシリアル化できます。

@JsonRawValueを使用しない例

import java.io.IOException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      try {
         Student student = new Student("Mark", 1, "{\"attr\":false}");
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   private String name;
   private int rollNo;
   private String json;
   public Student(String name, int rollNo, String json){
      this.name = name;
      this.rollNo = rollNo;
      this.json = json;
   }
   public String getName(){
      return name;
   }
   public int getRollNo(){
      return rollNo;
   }
   public String getJson(){
      return json;
   }
}

出力

{
   "name" : "Mark",
   "rollNo" : 1,
   "json" : {\"attr\":false}
}

@JsonRawValueを使用した例

import java.io.IOException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.annotation.JsonRawValue;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      try {
         Student student = new Student("Mark", 1, "{\"attr\":false}");
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   private String name;
   private int rollNo;
   @JsonRawValue
   private String json;
   public Student(String name, int rollNo, String json) {
      this.name = name;
      this.rollNo = rollNo;
      this.json = json;
   }
   public String getName(){
      return name;
   }
   public int getRollNo(){
      return rollNo;
   }
   public String getJson(){
      return json;
   }
}

出力

{
   "name" : "Mark",
   "rollNo" : 1,
   "json" : {"attr":false}
}

ジャクソン注釈-@JsonValue

*@ JsonValue* では、単一のメソッドを使用してオブジェクト全体をシリアル化できます。

例@JsonValue

import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonValue;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      try {
         Student student = new Student("Mark", 1);
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   private String name;
   private int rollNo;
   public Student(String name, int rollNo){
      this.name = name;
      this.rollNo = rollNo;
   }
   public String getName(){
      return name;
   }
   public int getRollNo(){
      return rollNo;
   }
   @JsonValue
   public String toString(){
      return "{ name : " + name + " }";
   }
}

出力

"{ name : Mark }"

ジャクソン注釈-@JsonRootName

*@ JsonRootName* を使用すると、JSONでルートノードを指定できます。 ルート値のラップも有効にする必要があります。

例@JsonRootName

import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonRootName;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      try {
         Student student = new Student("Mark", 1);
         mapper.enable(SerializationFeature.WRAP_ROOT_VALUE);
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
@JsonRootName(value = "student")
class Student {
   private String name;
   private int rollNo;
   public Student(String name, int rollNo){
      this.name = name;
      this.rollNo = rollNo;
   }
   public String getName(){
      return name;
   }
   public int getRollNo(){
      return rollNo;
   }
}

出力

{
   "student" : {
      "name" : "Mark",
      "rollNo" : 1
   }
}

Jackson Annotations-@JsonSerialize

*@ JsonSerialize* は、カスタムシリアライザーを指定してjsonオブジェクトをマーシャリングするために使用されます。

@JsonSerializeを使用した例

import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;

public class JacksonTester {
   public static void main(String args[]) throws ParseException {
      ObjectMapper mapper = new ObjectMapper();
      SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy");
      try {
         Student student = new Student("Mark", 1, dateFormat.parse("20-11-1984"));
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   private String name;
   private int rollNo;
   @JsonSerialize(using = CustomDateSerializer.class)
   private Date dateOfBirth;
   public Student(String name, int rollNo, Date dob){
      this.name = name;
      this.rollNo = rollNo;
      this.dateOfBirth = dob;
   }
   public String getName(){
      return name;
   }
   public int getRollNo(){
      return rollNo;
   }
   public Date getDateOfBirth(){
      return dateOfBirth;
   }
}
class CustomDateSerializer extends StdSerializer<Date> {
   private static final long serialVersionUID = 1L;
   private static SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy");
   public CustomDateSerializer() {
      this(null);
   }
   public CustomDateSerializer(Class<Date> t) {
      super(t);
   }
   @Override
   public void serialize(Date value,
      JsonGenerator generator, SerializerProvider arg2) throws IOException {
      generator.writeString(formatter.format(value));
   }
}

出力

{
   "name" : "Mark",
   "rollNo" : 1,
   "dateOfBirth" : "20-11-1984"
}

Jackson Annotations-@JsonCreator

*@ JsonCreator* は、逆シリアル化で使用されるコンストラクターまたはファクトリーメソッドを微調整するために使用されます。 同じことを実現するために@JsonPropertyも使用します。 以下の例では、必要なプロパティ名を定義することで、異なる形式のJSONをクラスに一致させています。

例@JsonCreator

import java.io.IOException;
import java.text.ParseException;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]) throws ParseException{
      String json = "{\"id\":1,\"theName\":\"Mark\"}";
      ObjectMapper mapper = new ObjectMapper();
      try {
         Student student = mapper
            .readerFor(Student.class)
            .readValue(json);
         System.out.println(student.rollNo +", " + student.name);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   public String name;
   public int rollNo;

   @JsonCreator
   public Student(@JsonProperty("theName") String name, @JsonProperty("id") int rollNo){
      this.name = name;
      this.rollNo = rollNo;
   }
}

出力

1, Mark

ジャクソン注釈-@JacksonInject

*@ JacksonInject* は、Json入力から解析される代わりにプロパティ値が挿入される場合に使用されます。 以下の例では、Jsonから解析するのではなく、オブジェクトに値を挿入しています。

例@JacksonInject

import java.io.IOException;
import java.text.ParseException;

import com.fasterxml.jackson.annotation.JacksonInject;
import com.fasterxml.jackson.databind.InjectableValues;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]) throws ParseException{
      String json = "{\"name\":\"Mark\"}";
      InjectableValues injectableValues = new InjectableValues.Std()
         .addValue(int.class, 1);

      ObjectMapper mapper = new ObjectMapper();
      try {
         Student student = mapper
            .reader(injectableValues)
            .forType(Student.class)
            .readValue(json);
         System.out.println(student.rollNo +", " + student.name);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   public String name;
   @JacksonInject
   public int rollNo;
}

出力

1, Mark

Jackson Annotations-@JsonAnySetter

*@ JsonAnySetter* を使用すると、setterメソッドでMapを使用して、JSONのその他のプロパティを他のプロパティと同様の方法で逆シリアル化するために使用できます。

例@JsonAnySetter

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

import com.fasterxml.jackson.annotation.JsonAnySetter;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      String jsonString = "{\"RollNo\" : \"1\",\"Name\" : \"Mark\"}";
      try {
         Student student = mapper.readerFor(Student.class).readValue(jsonString);
         System.out.println(student.getProperties().get("Name"));
         System.out.println(student.getProperties().get("RollNo"));
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   private Map<String, String> properties;
   public Student(){
      properties = new HashMap<>();
   }
   public Map<String, String> getProperties(){
      return properties;
   }
   @JsonAnySetter
   public void add(String property, String value){
      properties.put(property, value);
   }
}

出力

Mark
1

Jackson Annotations-@JsonSetter

*@ JsonSetter* を使用すると、特定のメソッドをセッターメソッドとしてマークできます。

例@JsonSetter

import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonSetter;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      String jsonString = "{\"rollNo\":1,\"name\":\"Marks\"}";

      try {
         Student student = mapper.readerFor(Student.class).readValue(jsonString);
         System.out.println(student.name);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   public int rollNo;
   public String name;
   @JsonSetter("name")
   public void setTheName(String name) {
      this.name = name;
   }
}

出力

Marks

ジャクソン注釈-@JsonDeserialize

*@ JsonDeserialize* は、カスタムデシリアライザーを指定してjsonオブジェクトを非整列化するために使用されます。

例@JsonDeserialize

import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;

public class JacksonTester {
   public static void main(String args[]) throws ParseException{
      ObjectMapper mapper = new ObjectMapper();
      String jsonString = "{\"name\":\"Mark\",\"dateOfBirth\":\"20-12-1984\"}";
      try {
         Student student = mapper
            .readerFor(Student.class)
            .readValue(jsonString);
         System.out.println(student.dateOfBirth);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   public String name;
   @JsonDeserialize(using = CustomDateDeserializer.class)
   public Date dateOfBirth;
}
class CustomDateDeserializer extends StdDeserializer<Date> {
   private static final long serialVersionUID = 1L;
   private static SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy");
   public CustomDateDeserializer() {
      this(null);
   }
   public CustomDateDeserializer(Class<Date> t) {
      super(t);
   }
   @Override
   public Date deserialize(JsonParser parser, DeserializationContext context)
      throws IOException, JsonProcessingException {

      String date = parser.getText();
      try {
         return formatter.parse(date);
      }
      catch (ParseException e) {
         e.printStackTrace();
      }
      return null;
   }
}

出力

Thu Dec 20 00:00:00 IST 1984

ジャクソン注釈-@JsonEnumDefaultValue

*@ JsonEnumDefaultValue* は、デフォルト値を使用して不明な列挙値をデシリアライズするために使用されます。

例@JsonEnumDefaultValue

import java.io.IOException;
import java.text.ParseException;

import com.fasterxml.jackson.annotation.JsonEnumDefaultValue;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]) throws ParseException{
      ObjectMapper mapper = new ObjectMapper();
      mapper.enable(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE);
      String jsonString = "\"abc\"";
      try {
         LETTERS value = mapper.readValue(jsonString, LETTERS.class);
         System.out.println(value);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
enum LETTERS {
   A, B, @JsonEnumDefaultValue UNKNOWN
}

出力

UNKNOWN

ジャクソン注釈-@JsonIgnoreProperties

*@ JsonIgnoreProperties* はクラスレベルで使用され、無視されるプロパティまたはプロパティのリストをマークします。

例-@JsonIgnoreProperties

import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]) {
      ObjectMapper mapper = new ObjectMapper();
      try {
         Student student = new Student(1,11,"1ab","Mark");
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
@JsonIgnoreProperties({ "id", "systemId" })
class Student {
   public int id;
   public String systemId;
   public int rollNo;
   public String name;

   Student(int id, int rollNo, String systemId, String name){
      this.id = id;
      this.systemId = systemId;
      this.rollNo = rollNo;
      this.name = name;
   }
}

出力

{
   "rollNo" : 11,
   "name" : "Mark"
}

ジャクソン注釈-@JsonIgnore

*@ JsonIgnore* はフィールドレベルで使用され、無視されるプロパティまたはプロパティのリストをマークします。

例-@JsonIgnore

import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      try{
         Student student = new Student(1,11,"1ab","Mark");
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   public int id;
   @JsonIgnore
   public String systemId;
   public int rollNo;
   public String name;

   Student(int id, int rollNo, String systemId, String name){
      this.id = id;
      this.systemId = systemId;
      this.rollNo = rollNo;
      this.name = name;
   }
}

出力

{
   "id" : 1,
   "rollNo" : 11,
   "name" : "Mark"
}

ジャクソン注釈-@JsonIgnoreType

*@ JsonIgnoreType* は、無視される特別なタイプのプロパティのマークで使用されます。

例-@JsonIgnoreType

import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonIgnoreType;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      try {
         Student student = new Student(1,11,"1ab","Mark");
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   public int id;
   @JsonIgnore
   public String systemId;
   public int rollNo;
   public Name nameObj;

   Student(int id, int rollNo, String systemId, String name){
      this.id = id;
      this.systemId = systemId;
      this.rollNo = rollNo;
      nameObj = new Name(name);
   }

   @JsonIgnoreType
   class Name {
      public String name;
      Name(String name){
         this.name = name;
      }
   }
}

出力

{
   "id" : 1,
   "systemId" : "1ab",
   "rollNo" : 11
}

Jackson Annotations-@JsonInclude

*@ JsonInclude* は、null/空またはデフォルト値を持つ除外プロパティで使用されます。

例-@JsonInclude

import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      try {
         Student student = new Student(1,null);
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
@JsonInclude(JsonInclude.Include.NON_NULL)
class Student {
   public int id;
   public String name;

   Student(int id,String name){
      this.id = id;
      this.name = name;
   }
}

出力

{
   "id" : 1
}

ジャクソン注釈-@JsonAutoDetect

*@ JsonAutoDetect* を使用して、他の方法ではアクセスできないプロパティを含めることができます。

例-@JsonAutoDetect

import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      try{
         Student student = new Student(1,"Mark");
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY)
class Student {
   private int id;
   private String name;

   Student(int id,String name) {
      this.id = id;
      this.name = name;
   }
}

出力

{
   "id" : 1,
   "name" : "Mark"
}

ジャクソン注釈-@JsonTypeInfo

*@ JsonTypeInfo* は、シリアル化および逆シリアル化に含まれるタイプ情報の詳細を示すために使用されます。

例-@JsonTypeInfo

import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.JsonTypeInfo.As;
import com.fasterxml.jackson.annotation.JsonTypeName;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]) throws IOException {
      Shape shape = new JacksonTester.Circle("CustomCircle", 1);
      String result = new ObjectMapper()
         .writerWithDefaultPrettyPrinter()
         .writeValueAsString(shape);
      System.out.println(result);
      String json = "{\"name\":\"CustomCircle\",\"radius\":1.0, \"type\":\"circle\"}";
      Circle circle = new ObjectMapper().readerFor(Shape.class).readValue(json);
      System.out.println(circle.name);
   }
   @JsonTypeInfo(use = JsonTypeInfo.Id.NAME,
      include = As.PROPERTY, property = "type") @JsonSubTypes({

      @JsonSubTypes.Type(value = Square.class, name = "square"),
      @JsonSubTypes.Type(value = Circle.class, name = "circle")
   })
   static class Shape {
      public String name;
      Shape(String name){
         this.name = name;
      }
   }
   @JsonTypeName("square")
   static class Square extends Shape {
      public double length;
      Square(){
         this(null,0.0);
      }
      Square(String name, double length){
         super(name);
         this.length = length;
      }
   }
   @JsonTypeName("circle")
   static class Circle extends Shape {
      public double radius;
      Circle(){
         this(null,0.0);
      }
      Circle(String name, double radius) {
         super(name);
         this.radius = radius;
      }
   }
}

出力

{
   "type" : "circle",
   "name" : "CustomCircle",
   "radius" : 1.0
}
CustomCircle

ジャクソン注釈-@JsonSubTypes

*@ JsonSubTypes* は、注釈付きのタイプのサブタイプを示すために使用されます。

例-@JsonSubTypes

import java.io.IOException;

import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.JsonTypeInfo.As;
import com.fasterxml.jackson.annotation.JsonTypeName;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]) throws IOException{
      Shape shape = new JacksonTester.Circle("CustomCircle", 1);
      String result = new ObjectMapper()
         .writerWithDefaultPrettyPrinter()
         .writeValueAsString(shape);
      System.out.println(result);
      String json = "{\"name\":\"CustomCircle\",\"radius\":1.0, \"type\":\"circle\"}";
      Circle circle = new ObjectMapper().readerFor(Shape.class).readValue(json);
      System.out.println(circle.name);
   }
   @JsonTypeInfo(use = JsonTypeInfo.Id.NAME,
      include = As.PROPERTY, property = "type") @JsonSubTypes({

      @JsonSubTypes.Type(value = Square.class, name = "square"),
      @JsonSubTypes.Type(value = Circle.class, name = "circle")
   })
   static class Shape {
      public String name;
      Shape(String name) {
         this.name = name;
      }
   }
   @JsonTypeName("square")
   static class Square extends Shape {
      public double length;
      Square(){
         this(null,0.0);
      }
      Square(String name, double length){
         super(name);
         this.length = length;
      }
   }
   @JsonTypeName("circle")
   static class Circle extends Shape {
      public double radius;
      Circle(){
         this(null,0.0);
      }
      Circle(String name, double radius){
         super(name);
         this.radius = radius;
      }
   }
}

出力

{
   "type" : "circle",
   "name" : "CustomCircle",
   "radius" : 1.0
}
CustomCircle

ジャクソン注釈-@JsonTypeName

*@ JsonTypeName* は、注釈付きクラスに使用される型名を設定するために使用されます。

例-@JsonTypeName

import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.JsonTypeInfo.As;
import com.fasterxml.jackson.annotation.JsonTypeName;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]) throws IOException {
      Shape shape = new JacksonTester.Circle("CustomCircle", 1);
      String result = new ObjectMapper()
         .writerWithDefaultPrettyPrinter()
         .writeValueAsString(shape);
      System.out.println(result);
      String json = "{\"name\":\"CustomCircle\",\"radius\":1.0, \"type\":\"circle\"}";
      Circle circle = new ObjectMapper().readerFor(Shape.class).readValue(json);
      System.out.println(circle.name);
   }
   @JsonTypeInfo(use = JsonTypeInfo.Id.NAME,
      include = As.PROPERTY, property = "type") @JsonSubTypes({

      @JsonSubTypes.Type(value = Square.class, name = "square"),
      @JsonSubTypes.Type(value = Circle.class, name = "circle")
   })
   static class Shape {
      public String name;
      Shape(String name){
         this.name = name;
      }
   }
   @JsonTypeName("square")
   static class Square extends Shape {
      public double length;
      Square(){
         this(null,0.0);
      }
      Square(String name, double length){
         super(name);
         this.length = length;
      }
   }
   @JsonTypeName("circle")
   static class Circle extends Shape {
      public double radius;
      Circle(){
         this(null,0.0);
      }
      Circle(String name, double radius){
         super(name);
         this.radius = radius;
      }
   }
}

出力

{
   "type" : "circle",
   "name" : "CustomCircle",
   "radius" : 1.0
}
CustomCircle

ジャクソン注釈-@JsonProperty

*@ JsonProperty* は、jsonプロパティに関して使用される非標準のgetter/setterメソッドをマークするために使用されます。

例-@JsonProperty

import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]) throws IOException {
      ObjectMapper mapper = new ObjectMapper();
      String json = "{\"id\" : 1}";
      Student student = mapper.readerFor(Student.class).readValue(json);
      System.out.println(student.getTheId());
   }
}
class Student {
   private int id;
   Student(){}
   Student(int id){
      this.id = id;
   }
   @JsonProperty("id")
   public int getTheId() {
      return id;
   }
   @JsonProperty("id")
   public void setTheId(int id) {
      this.id = id;
   }
}

出力

1

ジャクソン注釈-@JsonFormat

*@ JsonFormat* は、シリアル化または逆シリアル化中に形式を指定するために使用されます。 ほとんどの場合、日付フィールドで使用されます。

例-@JsonFormat

import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]) throws IOException, ParseException {
      ObjectMapper mapper = new ObjectMapper();
      SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd-MM-yyyy");
      Date date = simpleDateFormat.parse("20-12-1984");

      Student student = new Student(1, date);
      String jsonString = mapper
         .writerWithDefaultPrettyPrinter()
         .writeValueAsString(student);
      System.out.println(jsonString);
   }
}
class Student {
   public int id;
   @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy")
   public Date birthDate;
   Student(int id, Date birthDate){
      this.id = id;
      this.birthDate = birthDate;
   }
}

出力

{
   "id" : 1,
   "birthDate" : "19-12-1984"
}

ジャクソン注釈-@JsonUnwrapped

*@ JsonUnwrapped* は、シリアル化または逆シリアル化中にオブジェクトの値をラップ解除するために使用されます。

例-@JsonUnwrapped

import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import com.fasterxml.jackson.annotation.JsonUnwrapped;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]) throws IOException, ParseException{
      ObjectMapper mapper = new ObjectMapper();
      SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd-MM-yyyy");
      Date date = simpleDateFormat.parse("20-12-1984");
      Student.Name name = new Student.Name();
      name.first = "Jane";
      name.last = "Doe";
      Student student = new Student(1, name);
      String jsonString = mapper
         .writerWithDefaultPrettyPrinter()
         .writeValueAsString(student);
      System.out.println(jsonString);
   }
}
class Student {
   public int id;
   @JsonUnwrapped
   public Name name;
   Student(int id, Name name){
      this.id = id;
      this.name = name;
   }
   static class Name {
      public String first;
      public String last;
   }
}

出力

{
   "id" : 1,
   "first" : "Jane",
   "last" : "Doe"
}

ジャクソン注釈-@JsonView

*@ JsonView* は、値をシリアル化するかどうかを制御するために使用されます。

例-@JsonView

import java.io.IOException;
import java.text.ParseException;
import com.fasterxml.jackson.annotation.JsonView;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]) throws IOException, ParseException {
      ObjectMapper mapper = new ObjectMapper();
      Student student = new Student(1, "Mark", 12);
      String jsonString = mapper
         .writerWithDefaultPrettyPrinter()
         .withView(Views.Public.class)
         .writeValueAsString(student);
      System.out.println(jsonString);
   }
}
class Student {
   @JsonView(Views.Public.class)
   public int id;
   @JsonView(Views.Public.class)
   public String name;
   @JsonView(Views.Internal.class)
   public int age;

   Student(int id, String name, int age) {
      this.id = id;
      this.name = name;
      this.age = age;
   }
}
class Views {
   static class Public {}
   static class Internal extends Public {}
}

出力

{
   "id" : 1,
   "name" : "Mark"
}

ジャクソン注釈-@JsonManagedReference

*@ JsonManagedReferences* および *JsonBackReferences* は、親子関係を持つオブジェクトを表示するために使用されます。 *@ JsonManagedReferences* は親オブジェクトを参照するために使用され、 *@ JsonBackReferences* は子オブジェクトをマークするために使用されます。

例-@JsonManagedReferences

import java.io.IOException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;

import com.fasterxml.jackson.annotation.JsonBackReference;
import com.fasterxml.jackson.annotation.JsonManagedReference;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]) throws IOException, ParseException {
      ObjectMapper mapper = new ObjectMapper();
      Student student = new Student(1, "Mark");
      Book book1 = new Book(1,"Learn HTML", student);
      Book book2 = new Book(1,"Learn JAVA", student);

      student.addBook(book1);
      student.addBook(book2);

      String jsonString = mapper
         .writerWithDefaultPrettyPrinter()
         .writeValueAsString(book1);
      System.out.println(jsonString);
   }
}
class Student {
   public int rollNo;
   public String name;

   @JsonBackReference
   public List<Book> books;

   Student(int rollNo, String name){
      this.rollNo = rollNo;
      this.name = name;
      this.books = new ArrayList<Book>();
   }
   public void addBook(Book book){
      books.add(book);
   }
}
class Book {
   public int id;
   public String name;

   Book(int id, String name, Student owner){
      this.id = id;
      this.name = name;
      this.owner = owner;
   }
   @JsonManagedReference
   public Student owner;
}

出力

{
   "id" : 1,
   "name" : "Learn HTML",
   "owner" : {
      "rollNo" : 1,
      "name" : "Mark"
   }
}

ジャクソン注釈-@JsonBackReference

*@ JsonManagedReferences* および *JsonBackReferences* は、親子関係を持つオブジェクトを表示するために使用されます。 *@ JsonManagedReferences* は親オブジェクトを参照するために使用され、 *@ JsonBackReferences* は子オブジェクトをマークするために使用されます。

例-@JsonBackReferences

import java.io.IOException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;

import com.fasterxml.jackson.annotation.JsonBackReference;
import com.fasterxml.jackson.annotation.JsonManagedReference;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]) throws IOException, ParseException {
      ObjectMapper mapper = new ObjectMapper();
      Student student = new Student(1, "Mark");
      Book book1 = new Book(1,"Learn HTML", student);
      Book book2 = new Book(1,"Learn JAVA", student);

      student.addBook(book1);
      student.addBook(book2);

      String jsonString = mapper
         .writerWithDefaultPrettyPrinter()
         .writeValueAsString(book1);
      System.out.println(jsonString);
   }
}
class Student {
   public int rollNo;
   public String name;

   @JsonBackReference
   public List<Book> books;

   Student(int rollNo, String name){
      this.rollNo = rollNo;
      this.name = name;
      this.books = new ArrayList<Book>();
   }
   public void addBook(Book book){
      books.add(book);
   }
}
class Book {
   public int id;
   public String name;

   Book(int id, String name, Student owner) {
      this.id = id;
      this.name = name;
      this.owner = owner;
   }

   @JsonManagedReference
   public Student owner;
}

出力

{
   "id" : 1,
   "name" : "Learn HTML",
   "owner" : {
      "rollNo" : 1,
      "name" : "Mark"
   }
}

ジャクソン注釈-@JsonIdentityInfo

@JsonIdentityInfoは、オブジェクトに親子関係がある場合に使用されます。 @JsonIdentityInfoは、シリアル化/逆シリアル化中にオブジェクトIDが使用されることを示すために使用されます。

例-@JsonIdentityInfo

import java.io.IOException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;

import com.fasterxml.jackson.annotation.JsonIdentityInfo;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]) throws IOException, ParseException{
      ObjectMapper mapper = new ObjectMapper();
      Student student = new Student(1,13, "Mark");
      Book book1 = new Book(1,"Learn HTML", student);
      Book book2 = new Book(2,"Learn JAVA", student);

      student.addBook(book1);
      student.addBook(book2);

      String jsonString = mapper
         .writerWithDefaultPrettyPrinter()
         .writeValueAsString(book1);
      System.out.println(jsonString);
   }
}
@JsonIdentityInfo(
   generator = ObjectIdGenerators.PropertyGenerator.class,
   property = "id")
class Student {
   public int id;
   public int rollNo;
   public String name;
   public List<Book> books;

   Student(int id, int rollNo, String name){
      this.id = id;
      this.rollNo = rollNo;
      this.name = name;
      this.books = new ArrayList<Book>();
   }
   public void addBook(Book book){
      books.add(book);
   }
}
@JsonIdentityInfo(
   generator = ObjectIdGenerators.PropertyGenerator.class,
   property = "id")
class Book{
   public int id;
   public String name;

   Book(int id, String name, Student owner){
      this.id = id;
      this.name = name;
      this.owner = owner;
   }
   public Student owner;
}

出力

{
   "id" : 1,
   "name" : "Learn HTML",
   "owner" : {
      "id" : 1,
      "rollNo" : 13,
      "name" : "Mark",
      "books" : [
         1, {
            "id" : 2,
            "name" : "Learn JAVA",
            "owner" : 1
         }
      ]
   }
}

ジャクソン注釈-@JsonFilter

@JsonFilterは、使用するプロパティまたは使用しないプロパティなど、シリアル化/逆シリアル化中にフィルターを適用するために使用されます。

例-@JsonFilter

import java.io.IOException;
import java.text.ParseException;

import com.fasterxml.jackson.annotation.JsonFilter;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ser.FilterProvider;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;

public class JacksonTester {
   public static void main(String args[]) throws IOException, ParseException {
      ObjectMapper mapper = new ObjectMapper();
      Student student = new Student(1,13, "Mark");

      FilterProvider filters = new SimpleFilterProvider() .addFilter(
         "nameFilter", SimpleBeanPropertyFilter.filterOutAllExcept("name"));

      String jsonString = mapper.writer(filters)
         .withDefaultPrettyPrinter()
         .writeValueAsString(student);
      System.out.println(jsonString);
   }
}
@JsonFilter("nameFilter")
class Student {
   public int id;
   public int rollNo;
   public String name;

   Student(int id, int rollNo, String name) {
      this.id = id;
      this.rollNo = rollNo;
      this.name = name;
   }
}

出力

{
   "name" : "Mark"
}

ジャクソン注釈-カスタム注釈

@JacksonAnnotationsInsideアノテーションを使用して、簡単にカスタムアノテーションを作成できます。

例-カスタム注釈

import java.io.IOException;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.text.ParseException;

import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]) throws IOException, ParseException {
      ObjectMapper mapper = new ObjectMapper();
      Student student = new Student(1,13, "Mark");

      String jsonString = mapper
         .writerWithDefaultPrettyPrinter()
         .writeValueAsString(student);
      System.out.println(jsonString);
   }
}
@CustomAnnotation
class Student {
   public int id;
   public int rollNo;
   public String name;
   public String otherDetails;

   Student(int id, int rollNo, String name){
      this.id = id;
      this.rollNo = rollNo;
      this.name = name;
   }
}
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotationsInside
@JsonInclude(value = Include.NON_NULL)
@JsonPropertyOrder({ "rollNo", "id", "name" })
@interface CustomAnnotation {}

出力

{
   "rollNo" : 13,
   "id" : 1,
   "name" : "Mark"
}

ジャクソン注釈-Mixin

Mixin Annotationは、ターゲットクラスを変更せずに注釈を関連付ける方法です。 以下の例を参照してください-

例-Mixinアノテーション

import java.io.IOException;

import com.fasterxml.jackson.annotation.JsonIgnoreType;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]) {
      ObjectMapper mapper = new ObjectMapper();
      try {
         Student student = new Student(1,11,"1ab","Mark");
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);

         ObjectMapper mapper1 = new ObjectMapper();
         mapper1.addMixIn(Name.class, MixInForIgnoreType.class);
         jsonString = mapper1
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   public int id;
   public String systemId;
   public int rollNo;
   public Name nameObj;

   Student(int id, int rollNo, String systemId, String name) {
      this.id = id;
      this.systemId = systemId;
      this.rollNo = rollNo;
      nameObj = new Name(name);
   }
}
class Name {
   public String name;
   Name(String name){
      this.name = name;
   }
}
@JsonIgnoreType
class MixInForIgnoreType {}

出力

{
   "id" : 1,
   "systemId" : "1ab",
   "rollNo" : 11,
   "nameObj" : {
      "name" : "Mark"
   }
}
{
   "id" : 1,
   "systemId" : "1ab",
   "rollNo" : 11
}

ジャクソン注釈-無効化

ObjectMapperのdisable（）関数を使用して、ジャクソン注釈を無効にすることができます。

例-注釈を無効にする

import java.io.IOException;

import com.fasterxml.jackson.annotation.JsonIgnoreType;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      try{
         Student student = new Student(1,11,"1ab","Mark");
         String jsonString = mapper
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);

         ObjectMapper mapper1 = new ObjectMapper();
         mapper1.disable(MapperFeature.USE_ANNOTATIONS);
         jsonString = mapper1
            .writerWithDefaultPrettyPrinter()
            .writeValueAsString(student);
         System.out.println(jsonString);
      }
      catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   public int id;
   public String systemId;
   public int rollNo;
   public Name nameObj;

   Student(int id, int rollNo, String systemId, String name){
      this.id = id;
      this.systemId = systemId;
      this.rollNo = rollNo;
      nameObj = new Name(name);
   }
}
@JsonIgnoreType
class Name {
   public String name;
   Name(String name){
      this.name = name;
   }
}

出力

{
   "id" : 1,
   "systemId" : "1ab",
   "rollNo" : 11
}
{
   "id" : 1,
   "systemId" : "1ab",
   "rollNo" : 11,
   "nameObj" : {
      "name" : "Mark"
   }
}
「https://www.finddevguides.com/index.php?title=Jackson-annotations-quick-guide&oldid=79021」から取得
Powered by MediaWiki