基于Jackson2的JsonSchema实现java实体类生成json（一）

已于 2022-11-16 12:11:49 修改
阅读量1.1k 收藏
点赞数
分类专栏： java 文章标签： jackson json JsonSchema
于 2021-06-20 23:08:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daodfs111/article/details/118076539
版权

 
同时支持Json和Xml

目录

推荐使用 基于Jackson2的JsonSchema实现java实体类生成json（二）

额外的POM依赖

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
</dependency>
<dependency>
    <groupId>com.kjetland</groupId>
    <artifactId>mbknor-jackson-jsonschema_2.13</artifactId>
    <version>1.0.39</version>
</dependency>

核心工具类

Json2Utils.java

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

	/**
	 * java类转json字符串
	 * @param mapperSource
	 * @param javaType
	 * @return
	 */
	public static String javaType2Json(ObjectMapper mapperSource, JavaType javaType) {
		try {
			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);
			}
			return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(value);
		} catch (JsonProcessingException e) {
			e.printStackTrace();
			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", "Offset 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") && !ref.endsWith("OffsetTime");
	}
	
	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 jsonNode) {
		return jsonNode.get("items");
	}
}

怎么使用

测试用的实体类

Base.java

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) + "]";
	}

}

BaseDt.java

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 + "]";
	}
	
}

Score.java

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 + "]";
	}

}

TestMap.java

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 + "]";
	}

}

Student.java

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 + "]";
	}
	
}

用法

JsonUtils类转Springboot2以代码的方式统一配置Jackson->Jackson工具类

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

转换结果

[ [ {
  "address" : null,
  "listDt" : [ {
    "bst" : null,
    "dt" : null,
    "bg" : null,
    "nt" : 0,
    "sht" : null,
    "lng" : null,
    "bt" : null,
    "chr" : "\u0000",
    "bln" : false,
    "flt" : 0.0,
    "dbl" : 0.0,
    "ld" : null,
    "testStr" : [ null ],
    "score" : {
      "langue" : null,
      "math" : null,
      "english" : null
    }
  } ],
  "userName" : null,
  "age" : null,
  "phone" : null,
  "accessTime" : null,
  "localTime" : null,
  "score" : {
    "langue" : null,
    "math" : null,
    "english" : null
  },
  "mapLt" : {
    "KEY_0" : {
      "mapList" : [ null ]
    }
  },
  "mapStr" : {
    "KEY_0" : null
  },
  "mapLocal" : {
    "KEY_0" : null
  },
  "lscoreList1" : [ {
    "KEY_0" : {
      "langue" : null,
      "math" : null,
      "english" : null
    }
  } ],
  "lscoreList2" : [ [ {
    "KEY_0" : {
      "langue" : null,
      "math" : null,
      "english" : null
    }
  } ] ],
  "mapScore" : {
    "KEY_0" : {
      "KEY_0" : {
        "KEY_0" : {
          "langue" : null,
          "math" : null,
          "english" : null
        }
      }
    }
  },
  "mapList" : {
    "KEY_0" : [ {
      "langue" : null,
      "math" : null,
      "english" : null
    } ]
  },
  "gg" : [ {
    "langue" : null,
    "math" : null,
    "english" : null
  } ]
} ] ]


<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>
daodfs1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
json转换jsonschema
08-12
json转换json schema
基于Jackson2的JsonSchema实现java实体类生成json（二）
daodfs1的博客
11-16 1035
  同时支持Json和Xml 核心工具类 Json2Utils.java 怎么使用 测试用的实体类 Base.java BaseDt.java Score.java TestMap.java Student.java 用法 JsonUtils类转Springboot2以代码的方式统一配置Jackson->Jackson工具类
JsonSchema转JSON
qq_42975676的博客
08-08 1784
代码JsonSchema转JSON。
java 支持jsonschema
最新发布
fei33423的专栏
07-26 477
最新版本已经支持JSON Schema draft 2020-12。Jackson：Jackson是一个流行的JSON库，提供对JSON Schema的支持。json-schema-validator：这是一个基于Jackson的JSON Schema验证器。Everit JSON Schema：Everit是一个轻量级的JSON Schema验证器，支持JSON Schema draft 2020-12。请注意，这只是一小部分支持JSON Schema draft 2020-12的Java实现。
【Java】基于JSON-Schema生成随机JSON的解决方案
hgSuper的博客
03-10 2594
java解析json-schema随机生成json串
jsonschema2pojo：从JSON或JSON Schema生成Java类型，并注释这些类型以便与Jackson，Gson等进行数据绑定
02-03
jsonschema2pojo从JSON模式（或示例JSON）生成Java类型，并可以注释这些类型以便与Jackson 1.x，Jackson 2.x或Gson进行数据绑定。 注意：在0.5.1和1.0.0之间存在重大变化。 检查。 1.0.0 Alpha，Beta和最终版本中...
jsonschema-generator:Java JSON 模式生成器——从 Java 类创建 JSON 模式（草案 6、草案 7 或草案 2019-09）
08-05
使用 Jackson 从 Java 类创建 JSON 模式（草案 6、草案 7 或草案 2019-09）。 该项目包括： （你唯一需要开始的东西） 为了您的方便，一些模块捆绑了标准配置： – 从jackson注释（例如“描述”、属性名称覆盖...
jackson-module-jsonSchema:用于从POJO生成JSON模式（v3）定义的模块
04-30
杰克逊模块该模块支持创建JSON模式（v3） 请注意，由于...用法示例（来自 ） 只需添加一个依赖项（这是从我的gradle配置中获取的） "com.fasterxml.jackson.module:jackson-module-jsonSchema:2.9.0" ，至少对于gradl
mbknor-jackson-jsonSchema:使用Jackson注释生成具有多态性的JSON模式
05-22
该项目旨在通过使用Jackson @Annotations从您的POJO生成jsonSchema，比原始的做得更好。 强调 JSON模式DRAFT-04，DRAFT-06，DRAFT-07和DRAFT-2019-09 使用JsonSchema的oneOf功能支持多态（ @JsonTypeInfo ， ...
JJSchema:使用Jackson从Java Types到JSON-Schema的生成器
05-26
Java JSON Schema和Hyper-Schema生成器。 当前，它基于v4草案。 支持Java 8日期和时间API。 最新发布 < groupId>com.github.reinert</ groupId> < artifactId>jjschema < version>1.16 简单的操作方法 假设...
json-schema-defaults:从 JSON Schema 中的默认值生成 JSON 配置
06-28
JSON 架构默认值 从 JSON Schema 中的默认值生成 JSON 对象 适用于节点和浏览器。 安装 新产品经理 npm install json-schema-defaults 凉亭 bower install json-schema-defaults 手动的 下载 用法 CommonJS (node.js) var defaults = require ( './path/to/index.js' ) ; defaults ( { ... } ) ; 要求JS // in require.js config paths: { 'defaults' : './path/to/lib/defaults.js' } // in a file define ( [ 'defaults' ] , function ( defaults ) { defaults (
批量转换json到java类工具
06-27
将json转换为javebean的工具，封装jsonschema2pojo，用户可以修改配置文件json2Beans.json，然后运行Json2JavaBean2.bat直接生成对应类。 能够批量转换json为bean，直接拷贝到项目中使用。 提醒： 需要提前安装java sdk。 如果应对restful的请求和回应，输入和输出类可以放在同一个包里。否则json文件路径，class名，package名需要一一对应，避免出现同一个包里有相同的类。 具体使用方法参考 https://mp.csdn.net/mp_blog/creation/editor/125489040
js json-schema 转换 json
jaychou1979的博客
07-27 2664
json 和json-schema的互相转换
JSON & JSON Schema
l_dongyang的博客
12-27 1249
存储数据时、数据传输时、组件交互及数据验证的时候，JSON，在不同平台、组件及场景下的应用，已经自证了它作为无关平台标记语言的易用性及通用性。结合JSON Schema能够完成数据定义、数据传输以及数据验证的完整过程。
java jackson 生成_Java 通过Jackson生成JsonSchema("additionalProperties" : false)
weixin_39926588的博客
03-06 939
1、使用Maven引用mbknor-jackson-jsonschema_2.12com.kjetlandmbknor-jackson-jsonschema_2.121.0.282、生成JsonSchema("additionalProperties" : false)1)需要import的包import com.fasterxml.jackson.databind.JsonNode;import...
java 通过Json -schema完成对数据的效验
weixin_52457750的博客
07-14 1837
Json -schema java数据效验
java 使用JSONSchema入门学习
私欲日生，如地上尘，一日不扫，便又有一层。着实用功，便见道无终穷，愈探愈深，必使精白无一毫不彻方可。
07-12 1230
expected type: Number, found: String, 因为提供的号码类型错误，则无效 更多的校验规则可以看JSONSchema规范(中文版)
java实现jsonscheme_jsonschema-generator: Java JSON Schema Generator – creating a JSON Schema (Draft 7)...
weixin_39967938的博客
02-28 853
Java JSON Schema GeneratorCreating JSON Schema (Draft 7) from your Java classes utilising Jackson (inspired by JJSchema).UsageDependency (Maven)com.github.victoolsjsonschema-generator3.3.0CodeComplete...
JSON格式的互相转换
lm759231639的博客
05-19 1493
String smodelJson="";//json字符串 JSONObject modelJsons = JSON.parseObject(modelJson);//json字符串转为json对象 JSONArray array= modelJsons.getJSONArray("metadata");//json对象转为json数组 String obj = array.getJSONOb...
java json数组转java实体类对象
05-10
可以使用Java中的Jackson库将JSON数组转换为Java实体类对象。以下是一个简单的示例代码： 假设有一个JSON数组如下所示： ```json [ { "id": 1, "name": "John", "age": 30 }, { "id": 2, "name": "Jane", "age": 25 } ] ``` Java实体类对象如下所示： ```java public class Person { private int id; private String name; private int age; // getters and setters } ``` 使用Jackson库将JSON数组转换为Java实体类对象的示例代码如下所示： ```java ObjectMapper objectMapper = new ObjectMapper(); List<Person> persons = objectMapper.readValue(jsonArrayString, new TypeReference<List<Person>>(){}); ``` 其中，`jsonArrayString`是JSON数组的字符串表示。将JSON数组字符串传递给`readValue()`方法，并在方法的第二个参数中指定要转换的Java类型。在这种情况下，我们使用`TypeReference`来指定要转换为`List<Person>`类型。 转换后，`persons`将包含两个`Person`对象，分别对应于JSON数组中的两个对象。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值