Jackson2的JsonSchema实现java实体类生成json方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
package com.xxx.demo.common.util;
import java.io.IOException;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.NullNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import com.fasterxml.jackson.dataformat.xml.ser.XmlSerializerProvider;
import com.fasterxml.jackson.dataformat.xml.util.XmlRootNameLookup;
import com.kjetland.jackson.jsonSchema.JsonSchemaConfig;
import com.kjetland.jackson.jsonSchema.JsonSchemaGenerator;
public final class Json2Utils {
 
 //数组或List的循环次数
 private static final int ARRAY_LOOP = 1; 
 //Map的循环次数
 private static final int MAP_LOOP = 1; 
 //Map的key的前缀
 private static final String MAP_KEY_PREFIX = "KEY_"; 
 private static final ObjectMapper innerMapper = new ObjectMapper(); 
 private static final XmlSerializerProvider provider = new XmlSerializerProvider(new XmlRootNameLookup()); 
 static {
  provider.setNullValueSerializer(new JsonSerializer<Object> () {   
   @Override
   public void serialize(Object value, JsonGenerator gen, SerializerProvider serializers)
     throws IOException {
    gen.writeString("");
   }   
  });
 }
 
 /**
  * 普通java类转json字符串
  * @param <T>
  * @param mapper
  * @param clazz
  * @return
  */
 public static <T> String clazz2Json(ObjectMapper mapper, Class<T> clazz) {
  JavaType javaType = mapper.getTypeFactory().constructType(clazz);
  return javaType2Json(mapper, javaType);
 }
 
 /**
  * 泛型java类转json字符串
  * @param <T>
  * @param mapper
  * @param reference
  * @return
  */
 public static <T> String clazz2Json(ObjectMapper mapper, TypeReference<T> reference) {
  JavaType javaType = mapper.getTypeFactory().constructType(reference);
  return javaType2Json(mapper, javaType);
 }
 private static String javaType2Json(ObjectMapper mapperSource, JavaType javaType) {
  ObjectMapper mapper = mapperSource.copy();
  ObjectMapper innerMapper = Json2Utils.innerMapper;
  JsonSchemaConfig config = JsonSchemaConfig.vanillaJsonSchemaDraft4();
  JsonSchemaGenerator schemaGenerator = new JsonSchemaGenerator(innerMapper, config);
  JsonNode jsonNode = schemaGenerator.generateJsonSchema(javaType);
  JsonNode normalize = normalize(innerMapper, jsonNode);
  Object value = innerMapper.convertValue(normalize, javaType);
  mapper.setDefaultPropertyInclusion(Include.ALWAYS);
  if (mapper instanceof XmlMapper) {
   mapper.setSerializerProvider(provider);
  }
  try {
   return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(value);
  } catch (JsonProcessingException e) {
   return null;
  }
 }
 
 private static JsonNode normalize(ObjectMapper mapper, JsonNode source) {
  if (shouldArray(source)) {
   ArrayNode arrayNode = mapper.createArrayNode();
   fillJsonNode(mapper, source, source, arrayNode);
   return arrayNode;
  } else if (shouldObject(source)) {
   ObjectNode objectNode = mapper.createObjectNode();
   fillJsonNode(mapper, source, source, objectNode);
   return objectNode;
  }
  return NullNode.getInstance();  
 }
 
 private static void fillJsonNode(ObjectMapper mapper, JsonNode sourceRoot, JsonNode source, JsonNode target) {
  if (isArray(source)) {
   for (int i = 0; i < ARRAY_LOOP; i++) {
    fillArrayNode(mapper, sourceRoot, source, target);
   }
  } else if (shouldObject(source)) {
   fillObjectNode(mapper, sourceRoot, source, target);
  }
 }
 private static void fillArrayNode(ObjectMapper mapper, JsonNode sourceRoot, JsonNode source, JsonNode target) {
  JsonNode arrayItems = getArrayItems(source);
  if (isArray(arrayItems)) {
   ArrayNode arrayNode = mapper.createArrayNode();
   ((ArrayNode) target).add(arrayNode);
   fillJsonNode(mapper, sourceRoot, arrayItems, arrayNode);
  } else if (isMap(arrayItems)) {
   JsonNode propertiesNode = arrayItems.get("additionalProperties");
   if (isPojoPlain(propertiesNode)) {
    ObjectNode objectNode = mapper.createObjectNode();
    ((ArrayNode) target).add(objectNode);
    fillJsonNode(mapper, sourceRoot, arrayItems, objectNode);
   } else {
    ((ArrayNode) target).add(NullNode.getInstance());
   }
  } else if (isPojoPlain(arrayItems)) {
   JsonNode jsonNode = sourceRoot.at(arrayItems.get("$ref").asText().substring(1));
   ObjectNode objectNode = mapper.createObjectNode();
   ((ArrayNode) target).add(objectNode);
   fillJsonNode(mapper, sourceRoot, jsonNode, objectNode);
  } else {
   ((ArrayNode) target).add(NullNode.getInstance());
  }
 }
 private static void fillObjectNode(ObjectMapper mapper, JsonNode sourceRoot, JsonNode source, JsonNode target) {
  if (isMap(source)) {
   for (int i = 0; i < MAP_LOOP; i++) {
    fillMapNode(mapper, sourceRoot, source, target, i);
   }
  } else if (source.has("properties")) {
   Iterator<Entry<String, JsonNode>> iterator = source.get("properties").fields();
   while (iterator.hasNext()) {
    Map.Entry<String, JsonNode> entry = iterator.next();
    JsonNode jsonNode = entry.getValue();
    if (shouldArray(jsonNode)) {
     ArrayNode arrayNode = mapper.createArrayNode();
     ((ObjectNode) target).set(entry.getKey(), arrayNode);
     fillJsonNode(mapper, sourceRoot, jsonNode, arrayNode);
    } else if (shouldObject(jsonNode)) {
     ObjectNode objectNode = mapper.createObjectNode();
     ((ObjectNode) target).set(entry.getKey(), objectNode);
     fillJsonNode(mapper, sourceRoot, jsonNode, objectNode);
    } else {
     ((ObjectNode) target).set(entry.getKey(), NullNode.getInstance());
    }    
   }
  }
 }
 
 private static void fillMapNode(ObjectMapper mapper, JsonNode sourceRoot, JsonNode source, JsonNode target, int i) {
  String keyName = MAP_KEY_PREFIX + i;
  JsonNode propertiesNode = source.get("additionalProperties");
  if (isArray(propertiesNode)) {
   ArrayNode arrayNode = mapper.createArrayNode();
   ((ObjectNode) target).set(keyName, arrayNode);
   fillJsonNode(mapper, sourceRoot, propertiesNode, arrayNode);
  } else if (isMap(propertiesNode)) {
   ObjectNode objectNode = mapper.createObjectNode();
   ((ObjectNode) target).set(keyName, objectNode);
   fillJsonNode(mapper, sourceRoot, propertiesNode, objectNode);
  } else if (isPojoPlain(propertiesNode)) {
   JsonNode jsonNode = sourceRoot.at(propertiesNode.get("$ref").asText().substring(1));
   ObjectNode objectNode = mapper.createObjectNode();
   ((ObjectNode) target).set(keyName, objectNode);
   fillJsonNode(mapper, sourceRoot, jsonNode, objectNode);
  } else {
   ((ObjectNode) target).set(keyName, NullNode.getInstance());
  }
 }
 private static boolean isArray(JsonNode jsonNode) {
  if (!jsonNode.has("type")) {
   return false;
  }
  return "array".equals(jsonNode.get("type").asText());
 }
 
 private static boolean isMap(JsonNode jsonNode) {
  if (!jsonNode.has("type")) {
   return false;
  }
  return "object".equals(jsonNode.get("type").asText()) && !jsonNode.get("additionalProperties").isBoolean();
 }
 
 private static boolean isPojoRoot(JsonNode jsonNode) {
  return "object".equals(jsonNode.get("type").asText()) && jsonNode.get("additionalProperties").isBoolean()
    && !Arrays.asList("Local Date Time", "Local Date", "Local Time", "Offset Date Time").contains(jsonNode.get("title").asText());
 }
 
 private static boolean isPojoPlain(JsonNode jsonNode) {
  if (jsonNode.has("properties")) {
   return true;
  }
  if (!jsonNode.has("$ref")) {
   return false;
  }
  String ref = jsonNode.get("$ref").asText();
  return !ref.endsWith("LocalDateTime") && !ref.endsWith("LocalDate") && !ref.endsWith("LocalTime") && !ref.endsWith("OffsetDateTime");
 }
 
 private static boolean shouldArray(JsonNode jsonNode) {
  return isArray(jsonNode);
 }
 
 private static boolean shouldObject(JsonNode jsonNode) {
  if (isMap(jsonNode)) {
   return true;
  }
  if (jsonNode.has("title") && isPojoRoot(jsonNode)) {
   return true;
  }
  if (!jsonNode.has("title") && isPojoPlain(jsonNode)) {
   return true;
  }
  return false;
 }
 
 private static JsonNode getArrayItems(JsonNode source) {
  return source.get("items");
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.xxx.demo.common.jsontest;
import java.util.Arrays;
public class Base<T> {
 private String address; 
 private T[] listDt; 
 public String getAddress() {
  return address;
 }
 public void setAddress(String address) {
  this.address = address;
 }
 public T[] getListDt() {
  return listDt;
 }
 public void setListDt(T[] listDt) {
  this.listDt = listDt;
 }
 @Override
 public String toString() {
  return "Base [address=" + address + ", listDt=" + Arrays.toString(listDt) + "]";
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
package com.xxx.demo.common.jsontest;
import java.math.BigInteger;
import java.time.LocalDate;
import java.util.Date;
import java.util.List;

public class BaseDt {
 private Integer bst; 
 private Date dt; 
 private BigInteger bg; 
 private int nt; 
 private Short sht;
 private Long lng; 
 private Byte bt;
 
 @JacksonXmlCData
 private char chr; 
 private boolean bln; 
 private float flt; 
 private double dbl; 
 private LocalDate ld; 
 private List<String> testStr; 
 private Score score;
 public Integer getBst() {
  return bst;
 }
 public void setBst(Integer bst) {
  this.bst = bst;
 }
 public Date getDt() {
  return dt;
 }
 public void setDt(Date dt) {
  this.dt = dt;
 }
 public BigInteger getBg() {
  return bg;
 }
 public void setBg(BigInteger bg) {
  this.bg = bg;
 }
 public int getNt() {
  return nt;
 }
 public void setNt(int nt) {
  this.nt = nt;
 }
 public Short getSht() {
  return sht;
 }
 public void setSht(Short sht) {
  this.sht = sht;
 }
 public Long getLng() {
  return lng;
 }
 public void setLng(Long lng) {
  this.lng = lng;
 }
 public Byte getBt() {
  return bt;
 }
 public void setBt(Byte bt) {
  this.bt = bt;
 }
 public char getChr() {
  return chr;
 }
 public void setChr(char chr) {
  this.chr = chr;
 }
 public boolean isBln() {
  return bln;
 }
 public void setBln(boolean bln) {
  this.bln = bln;
 }
 public float getFlt() {
  return flt;
 }
 public void setFlt(float flt) {
  this.flt = flt;
 }
 public double getDbl() {
  return dbl;
 }
 public void setDbl(double dbl) {
  this.dbl = dbl;
 }
 public LocalDate getLd() {
  return ld;
 }
 public void setLd(LocalDate ld) {
  this.ld = ld;
 }
 public List<String> getTestStr() {
  return testStr;
 }
 public void setTestStr(List<String> testStr) {
  this.testStr = testStr;
 }
 public Score getScore() {
  return score;
 }
 public void setScore(Score score) {
  this.score = score;
 }
 @Override
 public String toString() {
  return "BaseDt [bst=" + bst + ", dt=" + dt + ", bg=" + bg + ", nt=" + nt + ", sht=" + sht + ", lng=" + lng
    + ", bt=" + bt + ", chr=" + chr + ", bln=" + bln + ", flt=" + flt + ", dbl=" + dbl + ", ld=" + ld
    + ", testStr=" + testStr + ", score=" + score + "]";
 } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.xxx.demo.common.jsontest;
import java.math.BigDecimal;
public class Score {
 private BigDecimal langue; 
 private BigDecimal math; 
 private BigDecimal english;
 public BigDecimal getLangue() {
  return langue;
 }
 public void setLangue(BigDecimal langue) {
  this.langue = langue;
 }
 public BigDecimal getMath() {
  return math;
 }
 public void setMath(BigDecimal math) {
  this.math = math;
 }
 public BigDecimal getEnglish() {
  return english;
 }
 public void setEnglish(BigDecimal english) {
  this.english = english;
 }
 @Override
 public String toString() {
  return "Score [langue=" + langue + ", math=" + math + ", english=" + english + "]";
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.xxx.demo.common.jsontest;
import java.util.List;
public class TestMap {
 private List<String> mapList;
 public List<String> getMapList() {
  return mapList;
 }
 public void setMapList(List<String> mapList) {
  this.mapList = mapList;
 }
 @Override
 public String toString() {
  return "TestMap [mapList=" + mapList + "]";
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
package com.xxx.demo.common.jsontest;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.List;
import java.util.Map;

public class Student<T, E> extends Base<BaseDt> {
 private String userName;
 private Integer age;
 private String phone; 
 private LocalDateTime accessTime; 
 private LocalTime localTime; 
 private Score score; 
 private List<T> grades; 
 private Map<String, E> mapLt; 
 private Map<String, String> mapStr; 
 private Map<String, LocalDateTime> mapLocal; 
 private List<Map<String, Score>> lscoreList1; 
 private List<List<Map<String, Score>>> lscoreList2; 
 private Map<String, Map<String, Map<String, Score>>> mapScore; 
 private Map<String, List<Score>> mapList;
 public String getUserName() {
  return userName;
 }
 public void setUserName(String userName) {
  this.userName = userName;
 }
 public Integer getAge() {
  return age;
 }
 public void setAge(Integer age) {
  this.age = age;
 }
 public String getPhone() {
  return phone;
 }
 public void setPhone(String phone) {
  this.phone = phone;
 }
 public LocalDateTime getAccessTime() {
  return accessTime;
 }
 public void setAccessTime(LocalDateTime accessTime) {
  this.accessTime = accessTime;
 }
 public List<T> getGrades() {
  return grades;
 }
 public void setGrades(List<T> grades) {
  this.grades = grades;
 }
 public Map<String, E> getMapLt() {
  return mapLt;
 }
 public void setMapLt(Map<String, E> mapLt) {
  this.mapLt = mapLt;
 }
 public Map<String, String> getMapStr() {
  return mapStr;
 }
 public void setMapStr(Map<String, String> mapStr) {
  this.mapStr = mapStr;
 }
 public Map<String, LocalDateTime> getMapLocal() {
  return mapLocal;
 }
 public void setMapLocal(Map<String, LocalDateTime> mapLocal) {
  this.mapLocal = mapLocal;
 }
 public LocalTime getLocalTime() {
  return localTime;
 }
 public void setLocalTime(LocalTime localTime) {
  this.localTime = localTime;
 }
 public Score getScore() {
  return score;
 }
 public void setScore(Score score) {
  this.score = score;
 }
 public List<Map<String, Score>> getLscoreList1() {
  return lscoreList1;
 }
 public void setLscoreList1(List<Map<String, Score>> lscoreList1) {
  this.lscoreList1 = lscoreList1;
 }
 public List<List<Map<String, Score>>> getLscoreList2() {
  return lscoreList2;
 }
 public void setLscoreList2(List<List<Map<String, Score>>> lscoreList2) {
  this.lscoreList2 = lscoreList2;
 }
 public Map<String, Map<String, Map<String, Score>>> getMapScore() {
  return mapScore;
 }
 public void setMapScore(Map<String, Map<String, Map<String, Score>>> mapScore) {
  this.mapScore = mapScore;
 }
 public Map<String, List<Score>> getMapList() {
  return mapList;
 }
 public void setMapList(Map<String, List<Score>> mapList) {
  this.mapList = mapList;
 }
 @Override
 public String toString() {
  return "Student [userName=" + userName + ", age=" + age + ", phone=" + phone + ", accessTime=" + accessTime
    + ", localTime=" + localTime + ", score=" + score + ", grades=" + grades + ", mapLt=" + mapLt
    + ", mapStr=" + mapStr + ", mapLocal=" + mapLocal + ", lscoreList1=" + lscoreList1 + ", lscoreList2="
    + lscoreList2 + ", mapScore=" + mapScore + ", mapList=" + mapList + "]";
 } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.xxx.demo.common.jsontest;
import java.util.List;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.xxx.demo.common.util.Json2Utils;
import com.xxx.demo.common.util.JsonUtils;
import com.xxx.demo.common.util.XmlUtils;
public class Json2Test { 
 public static void main(String[] args) {
  ObjectMapper mapper1 = JsonUtils.getObjectMapper();
  String json = Json2Utils.clazz2Json(mapper1, new TypeReference<List<List<Student<Score, TestMap>>>>() {});
  System.out.println(json);
  ObjectMapper mapper2 = XmlUtils.getObjectMapper();
  String xml = Json2Utils.clazz2Json(mapper2, new TypeReference<Student<Score, TestMap>>() {});
  System.out.println(xml);
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
<Student>
  <address></address>
  <listDt>
    <listDt>
      <bst></bst>
      <dt></dt>
      <bg></bg>
      <nt>0</nt>
      <sht></sht>
      <lng></lng>
      <bt></bt>
      <chr><![CDATA[ ]]></chr>
      <bln>false</bln>
      <flt>0.0</flt>
      <dbl>0.0</dbl>
      <ld></ld>
      <testStr>
        <testStr></testStr>
      </testStr>
      <score>
        <langue></langue>
        <math></math>
        <english></english>
      </score>
    </listDt>
  </listDt>
  <userName></userName>
  <age></age>
  <phone></phone>
  <accessTime></accessTime>
  <localTime></localTime>
  <score>
    <langue></langue>
    <math></math>
    <english></english>
  </score>
  <mapLt>
    <KEY_0>
      <mapList>
        <mapList></mapList>
      </mapList>
    </KEY_0>
  </mapLt>
  <mapStr>
    <KEY_0></KEY_0>
  </mapStr>
  <mapLocal>
    <KEY_0></KEY_0>
  </mapLocal>
  <lscoreList1>
    <lscoreList1>
      <KEY_0>
        <langue></langue>
        <math></math>
        <english></english>
      </KEY_0>
    </lscoreList1>
  </lscoreList1>
  <lscoreList2>
    <lscoreList2>
      <KEY_0>
        <langue></langue>
        <math></math>
        <english></english>
      </KEY_0>
    </lscoreList2>
  </lscoreList2>
  <mapScore>
    <KEY_0>
      <KEY_0>
        <KEY_0>
          <langue></langue>
          <math></math>
          <english></english>
        </KEY_0>
      </KEY_0>
    </KEY_0>
  </mapScore>
  <mapList>
    <KEY_0>
      <langue></langue>
      <math></math>
      <english></english>
    </KEY_0>
  </mapList>
  <gg>
    <gg>
      <langue></langue>
      <math></math>
      <english></english>
    </gg>
  </gg>
</Student>