import com.fasterxml.jackson.module.jsonSchema.JsonSchemaGenerator; //导入依赖的package包/类
private static Optional<JsonSchema> getSchemma(Class<?> clazz) {
	ObjectMapper mapper = new ObjectMapper();
	Optional<JsonSchema> schema = Optional.empty();
	SchemaFactoryWrapper visitor = new SchemaFactoryWrapper();
	Optional<Class<?>> realClazz = ReflectionUtils.getGenericClass(clazz);
	boolean iterable = Iterable.class.isAssignableFrom(clazz) && realClazz.isPresent();
	if (iterable) {
		clazz = realClazz.get();
	}

	try {
		mapper.acceptJsonFormatVisitor(clazz, visitor);
		JsonSchemaGenerator schemaGen = new JsonSchemaGenerator(mapper);
		schema = Optional.ofNullable(schemaGen.generateSchema(clazz));
		if (iterable) {
			// TODO: decirle que es una collection
		}
	} catch (JsonMappingException e) {
		LOGGER.error("Se produjo un error al crear el JsonSchemma para la clase {}", clazz.getSimpleName(), e);
	}
	return schema;
}
 

import com.fasterxml.jackson.module.jsonSchema.JsonSchemaGenerator; //导入依赖的package包/类
public JsonSchema getJsonSchema(String className) throws IOException {
	
	Class<?> foundClass = null;
	for (String searchPackage : describeModelSearchPackages) {
		LOG.debug(String.format("Search className %s in package %s.", className, searchPackage));
		try{
			boolean wasNull = foundClass == null;
			foundClass = Class.forName(searchPackage + "." + className);
			if (!wasNull) {
				LOG.error(String.format("Modelname %s exists in multiple packages! Last one will win.", className));
			}
		} catch (ClassNotFoundException e){
			//not in this package, try another
		}
	}

	if (foundClass == null) {
		LOG.warn(String.format("No class found for describing modelname %s", className));
		return null;
	}

	JsonSchemaGenerator schemaGen = new JsonSchemaGenerator(objectMapper);
	JsonSchema schema = schemaGen.generateSchema(foundClass);

	return schema;
}
 

import com.fasterxml.jackson.module.jsonSchema.JsonSchemaGenerator; //导入依赖的package包/类
@Test
@Ignore("Used to generate the initial extension definition")
public void generateBaseExtensionDefinition() throws Exception {
    ObjectMapper mapper = Json.mapper();
    JsonSchemaGenerator schemaGen = new JsonSchemaGenerator(mapper);
    com.fasterxml.jackson.module.jsonSchema.JsonSchema schema = schemaGen.generateSchema(Extension.class);

    System.out.println(mapper.writeValueAsString(schema));
}
 

import com.fasterxml.jackson.module.jsonSchema.JsonSchemaGenerator; //导入依赖的package包/类
@Test
public void shouldSerializeJsonSchema() throws Exception {
    JsonSchemaGenerator generator = new JsonSchemaGenerator(unit);
    JsonSchema jsonSchema = generator.generateSchema(CurrencyUnit.class);
    final String actual = unit.writeValueAsString(jsonSchema);
    final String expected = "{\"type\":\"string\"}";

    assertThat(actual, is(expected));
}
 

import com.fasterxml.jackson.module.jsonSchema.JsonSchemaGenerator; //导入依赖的package包/类
@Test
public void shouldSerializeJsonSchema() throws Exception {
    ObjectMapper unit = unit(module());
    JsonSchemaGenerator generator = new JsonSchemaGenerator(unit);
    JsonSchema jsonSchema = generator.generateSchema(MonetaryAmount.class);
    final String actual = unit.writeValueAsString(jsonSchema);
    final String expected = "{\"type\":\"object\",\"id\":\"urn:jsonschema:javax:money:MonetaryAmount\",\"properties\":" +
            "{\"amount\":{\"type\":\"number\",\"required\":true}," +
            "\"currency\":{\"type\":\"string\",\"required\":true}," +
            "\"formatted\":{\"type\":\"string\"}}}";

    assertThat(actual, is(expected));
}
 

import com.fasterxml.jackson.module.jsonSchema.JsonSchemaGenerator; //导入依赖的package包/类
@Test
public void shouldSerializeJsonSchemaWithCustomFieldNames() throws Exception {
    ObjectMapper unit = unit(module().withAmountFieldName("value")
                                     .withCurrencyFieldName("unit")
                                     .withFormattedFieldName("pretty"));
    JsonSchemaGenerator generator = new JsonSchemaGenerator(unit);
    JsonSchema jsonSchema = generator.generateSchema(MonetaryAmount.class);
    final String actual = unit.writeValueAsString(jsonSchema);
    final String expected = "{\"type\":\"object\",\"id\":\"urn:jsonschema:javax:money:MonetaryAmount\",\"properties\":" +
            "{\"value\":{\"type\":\"number\",\"required\":true}," +
            "\"unit\":{\"type\":\"string\",\"required\":true}," +
            "\"pretty\":{\"type\":\"string\"}}}";

    assertThat(actual, is(expected));
}
 

import com.fasterxml.jackson.module.jsonSchema.JsonSchemaGenerator; //导入依赖的package包/类
@Test
public void shouldSerializeJsonSchemaWithQuotedDecimalNumbers() throws Exception {
    ObjectMapper unit = unit(module().withQuotedDecimalNumbers());
    JsonSchemaGenerator generator = new JsonSchemaGenerator(unit);
    JsonSchema jsonSchema = generator.generateSchema(MonetaryAmount.class);
    final String actual = unit.writeValueAsString(jsonSchema);
    final String expected = "{\"type\":\"object\",\"id\":\"urn:jsonschema:javax:money:MonetaryAmount\",\"properties\":" +
            "{\"amount\":{\"type\":\"string\",\"required\":true}," +
            "\"currency\":{\"type\":\"string\",\"required\":true}," +
            "\"formatted\":{\"type\":\"string\"}}}";

    assertThat(actual, is(expected));
}
 

import com.fasterxml.jackson.module.jsonSchema.JsonSchemaGenerator; //导入依赖的package包/类
public UiForm generate(Class<? extends Serializable> formDto) throws JsonMappingException {
	Field[] declaredFields = formDto.getDeclaredFields();
	ObjectMapper mapper = new ObjectMapper();

	JsonSchemaGenerator schemaGen = initSchemaGen(mapper);
	JsonSchema schema = generateSchema(formDto, schemaGen);

	Map<Field, JsonNode> nodes = initFieldsFormDefinition(mapper, declaredFields);

	Map<Field, JsonNode> sortedNodes = reorderFieldsBasedOnIndex(nodes);

	handlerGroupedFields(mapper, declaredFields, sortedNodes);

	Optional<ObjectNode> tabbedFields = Optional
			.ofNullable(handleTabbedFields(mapper, declaredFields, sortedNodes));

	ArrayNode formDefinition = mapper.createArrayNode();
	tabbedFields.ifPresent(formDefinition::add);
	sortedNodes.entrySet().stream().forEach(nodesElement -> formDefinition.add(nodesElement.getValue()));

	handleActionsAnnotation(mapper, formDto, formDefinition);

	return new UiForm(schema, formDefinition);
}
 

import com.fasterxml.jackson.module.jsonSchema.JsonSchemaGenerator; //导入依赖的package包/类
private JsonSchema generateSchema(Class<? extends Serializable> formDto, JsonSchemaGenerator schemaGen)
		throws JsonMappingException {
	return schemaGen.generateSchema(formDto);
}
 

import com.fasterxml.jackson.module.jsonSchema.JsonSchemaGenerator; //导入依赖的package包/类
private JsonSchemaGenerator initSchemaGen(ObjectMapper mapper) {
	return new JsonSchemaGenerator(mapper, new CustomSchemaFactoryWrapper());
}
 

import com.fasterxml.jackson.module.jsonSchema.JsonSchemaGenerator; //导入依赖的package包/类
/**
 * Setup the JSON schema generator.
 */
private static void initSchemaMapper() {
	ObjectMapper mapper = new ObjectMapper();
	// configure mapper, if necessary, then create schema generator
	schemaGen = new JsonSchemaGenerator(mapper);
}