下面列出了com.fasterxml.jackson.databind.ObjectMapper#getDeserializationConfig ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Test
public void testGenerateDocumentationForBasicTypes() throws Exception {
// given
ObjectMapper mapper = createMapper();
mockFieldComment(BasicTypes.class, "string", "A string");
mockFieldComment(BasicTypes.class, "bool", "A boolean");
mockFieldComment(BasicTypes.class, "number", "An integer");
mockFieldComment(BasicTypes.class, "decimal", "A decimal");
FieldDocumentationGenerator generator =
new FieldDocumentationGenerator(mapper.writer(), mapper.getDeserializationConfig(),
javadocReader, constraintReader, typeMapping, SnippetTranslationManager.getDefaultResolver(),
null);
Type type = BasicTypes.class;
// when
List<ExtendedFieldDescriptor> result = cast(generator
.generateDocumentation(type, mapper.getTypeFactory()).values());
// then
assertThat(result.size(), is(4));
assertThat(result.get(0), is(descriptor("string", "String", "A string", "true")));
assertThat(result.get(1), is(descriptor("bool", "Boolean", "A boolean", "true")));
assertThat(result.get(2), is(descriptor("number", "Integer", "An integer", "true")));
assertThat(result.get(3), is(descriptor("decimal", "Decimal", "A decimal", "true")));
}
@Test
public void testGenerateDocumentationForExternalSerializer() throws Exception {
// given
ObjectMapper mapper = createMapper();
mockFieldComment(ExternalSerializer.class, "bigDecimal", "A decimal");
SimpleModule testModule = new SimpleModule("TestModule");
testModule.addSerializer(new BigDecimalSerializer());
mapper.registerModule(testModule);
FieldDocumentationGenerator generator =
new FieldDocumentationGenerator(mapper.writer(),
mapper.getDeserializationConfig(), javadocReader, constraintReader, typeMapping,
SnippetTranslationManager.getDefaultResolver(), null);
Type type = ExternalSerializer.class;
// when
List<ExtendedFieldDescriptor> result = cast(generator
.generateDocumentation(type, mapper.getTypeFactory()).values());
// then
assertThat(result.size(), is(1));
assertThat(result.get(0), is(descriptor("bigDecimal", "Decimal", "A decimal", "true")));
}
@Test
public void testGenerateDocumentationWithTags() throws Exception {
// given
ObjectMapper mapper = createMapper();
mockFieldComment(BasicTypes.class, "string", "A string");
mockFieldTag(BasicTypes.class, "string", "see", "this");
mockFieldComment(BasicTypes.class, "bool", "A boolean");
mockFieldTag(BasicTypes.class, "bool", "see", "<a href=\"xyz\">docs</a>");
FieldDocumentationGenerator generator =
new FieldDocumentationGenerator(mapper.writer(), mapper.getDeserializationConfig(),
javadocReader, constraintReader, typeMapping, SnippetTranslationManager.getDefaultResolver(),
null);
Type type = BasicTypes.class;
// when
List<ExtendedFieldDescriptor> result = cast(generator
.generateDocumentation(type, mapper.getTypeFactory()).values());
// then
assertThat(result.size(), is(4));
assertThat(result.get(0),
is(descriptor("string", "String", "A string<br>See this.", "true")));
assertThat(result.get(1),
is(descriptor("bool", "Boolean", "A boolean<br>See <a href=\"xyz\">docs</a>.",
"true")));
}
@Test
public void testGenerateDocumentationForRequiredProperties() throws Exception {
// given
ObjectMapper mapper = createMapper();
mockFieldComment(RequiredProperties.class, "string", "A string");
mockFieldComment(RequiredProperties.class, "number", "An integer");
FieldDocumentationGenerator generator =
new FieldDocumentationGenerator(mapper.writer(), mapper.getDeserializationConfig(),
javadocReader, constraintReader, typeMapping, SnippetTranslationManager.getDefaultResolver(),
null);
Type type = RequiredProperties.class;
// when
List<ExtendedFieldDescriptor> result = cast(generator
.generateDocumentation(type, mapper.getTypeFactory()).values());
// then
assertThat(result.size(), is(2));
assertThat(result.get(0), is(descriptor("string", "String", "A string", "false")));
assertThat(result.get(1), is(descriptor("number", "Integer", "An integer", "false")));
}
public AbstractTypeCustomizationFactory(ObjectMapper mapper) {
this.serializerProvider = mapper.getSerializerProviderInstance();
this.serializerFactory = (CustomBeanSerializerFactory) mapper.getSerializerFactory();
this.typeFactory = mapper.getTypeFactory();
this.deserializationContext = mapper.getDeserializationContext();
this.deserializationConfig = mapper.getDeserializationConfig();
}
protected FieldDescriptors createFieldDescriptors(Operation operation,
HandlerMethod handlerMethod) {
ObjectMapper objectMapper = getObjectMapper(operation);
JavadocReader javadocReader = getJavadocReader(operation);
ConstraintReader constraintReader = getConstraintReader(operation);
SnippetTranslationResolver translationResolver = getTranslationResolver(operation);
TypeMapping typeMapping = getTypeMapping(operation);
JsonProperty.Access skipAcessor = getSkipAcessor();
Type type = getType(handlerMethod);
if (type == null) {
return new FieldDescriptors();
}
try {
FieldDocumentationGenerator generator = new FieldDocumentationGenerator(
objectMapper.writer(), objectMapper.getDeserializationConfig(), javadocReader,
constraintReader, typeMapping, translationResolver, skipAcessor);
FieldDescriptors fieldDescriptors = generator.generateDocumentation(type, objectMapper.getTypeFactory());
if (shouldFailOnUndocumentedFields()) {
assertAllDocumented(fieldDescriptors.values(),
translationResolver.translate(getHeaderKey(operation)).toLowerCase());
}
return fieldDescriptors;
} catch (JsonMappingException e) {
throw new JacksonFieldProcessingException("Error while parsing fields", e);
}
}
@Test
public void testGenerateDocumentationForNestedTypes() throws Exception {
// given
ObjectMapper mapper = createMapper();
mockFieldComment(FirstLevel.class, "second", "2nd level");
mockFieldComment(SecondLevel.class, "third", "3rd level");
mockFieldComment(ThirdLevel.class, "fourth", "4th level");
mockFieldComment(FourthLevel.class, "fifth", "5th level");
mockFieldComment(FifthLevel.class, "last", "An integer");
FieldDocumentationGenerator generator =
new FieldDocumentationGenerator(mapper.writer(),
mapper.getDeserializationConfig(), javadocReader, constraintReader, typeMapping,
SnippetTranslationManager.getDefaultResolver(), null);
Type type = FirstLevel.class;
// when
List<ExtendedFieldDescriptor> result = cast(generator
.generateDocumentation(type, mapper.getTypeFactory()).values());
// then
assertThat(result.size(), is(5));
assertThat(result.get(0),
is(descriptor("second", "Object", "2nd level", "true")));
assertThat(result.get(1),
is(descriptor("second.third", "Array[Object]", "3rd level", "true")));
assertThat(result.get(2),
is(descriptor("second.third[].fourth", "Object", "4th level", "true")));
assertThat(result.get(3),
is(descriptor("second.third[].fourth.fifth", "Array[Object]", "5th level",
"true")));
assertThat(result.get(4),
is(descriptor("second.third[].fourth.fifth[].last", "Integer", "An integer",
"true")));
}
@Test
public void testGenerateDocumentationForRecursiveTypes() throws Exception {
// given
ObjectMapper mapper = createMapper();
FieldDocumentationGenerator generator = new FieldDocumentationGenerator(mapper.writer(),
mapper.getDeserializationConfig(), javadocReader, constraintReader, typeMapping,
SnippetTranslationManager.getDefaultResolver(), null);
Type type = RecursiveType.class;
// when
List<ExtendedFieldDescriptor> result = cast(generator
.generateDocumentation(type, mapper.getTypeFactory()).values());
// then
assertThat(result.size(), is(16));
assertThat(result.get(0), is(descriptor("sub1", "Array[Object]", "", "true")));
assertThat(result.get(1), is(descriptor("sub2", "Object", "", "true")));
assertThat(result.get(2), is(descriptor("sub3", "Array[Object]", "", "true")));
assertThat(result.get(3), is(descriptor("sub4", "Object", "", "true")));
assertThat(result.get(4), is(descriptor("sub5", "Array[Object]", "", "true")));
assertThat(result.get(5), is(descriptor("sub6", "Object", "", "true")));
assertThat(result.get(6), is(descriptor("sub7", "Array[Object]", "", "true")));
assertThat(result.get(7), is(descriptor("sub7[].sub1", "Array[Object]", "", "true")));
assertThat(result.get(8), is(descriptor("sub7[].sub2", "Object", "", "true")));
assertThat(result.get(9), is(descriptor("sub7[].sub3", "Array[Object]", "", "true")));
assertThat(result.get(10), is(descriptor("sub7[].sub4", "Object", "", "true")));
assertThat(result.get(11), is(descriptor("sub8", "Object", "", "true")));
assertThat(result.get(12), is(descriptor("sub8.sub1", "Array[Object]", "", "true")));
assertThat(result.get(13), is(descriptor("sub8.sub2", "Object", "", "true")));
assertThat(result.get(14), is(descriptor("sub8.sub3", "Array[Object]", "", "true")));
assertThat(result.get(15), is(descriptor("sub8.sub4", "Object", "", "true")));
}
@Test
public void testGenerateDocumentationForJacksonAnnotations() throws Exception {
// given
ObjectMapper mapper = createMapper();
mockFieldComment(JsonAnnotations.class, "location", "A location");
mockFieldComment(JsonAnnotations.class, "uri", "A uri");
when(javadocReader.resolveMethodComment(JsonAnnotations.class, "getParameter"))
.thenReturn("A parameter");
mockFieldComment(JsonAnnotations.Meta.class, "headers", "A header map");
FieldDocumentationGenerator generator =
new FieldDocumentationGenerator(mapper.writer(),
mapper.getDeserializationConfig(), javadocReader, constraintReader, typeMapping,
SnippetTranslationManager.getDefaultResolver(), null);
Type type = JsonAnnotations.class;
// when
List<ExtendedFieldDescriptor> result = cast(generator
.generateDocumentation(type, mapper.getTypeFactory()).values());
// then
assertThat(result.size(), is(4));
// @JsonPropertyOrder puts it to first place
assertThat(result.get(0), is(descriptor("uri", "String", "A uri", "true")));
// @JsonProperty
assertThat(result.get(1), is(descriptor("path", "String", "A location", "true")));
// @JsonGetter
assertThat(result.get(2), is(descriptor("param", "String", "A parameter", "true")));
// @JsonUnwrapped
assertThat(result.get(3), is(descriptor("headers", "Map", "A header map", "true")));
}
@Test
public void testGenerateDocumentationForFieldResolution() throws Exception {
// given
// different mapper for custom field resolution
ObjectMapper mapper = new ObjectMapper();
mapper.setVisibility(mapper.getSerializationConfig().getDefaultVisibilityChecker()
.withFieldVisibility(JsonAutoDetect.Visibility.PUBLIC_ONLY));
// comment on field directly
mockFieldComment(FieldCommentResolution.class, "location", "A location");
// comment on getter instead of field
when(javadocReader.resolveMethodComment(FieldCommentResolution.class, "getType"))
.thenReturn("A type");
// comment on field instead of getter
mockFieldComment(FieldCommentResolution.class, "uri", "A uri");
mockFieldComment(FieldCommentResolution.class, "secured", "A secured flag");
FieldDocumentationGenerator generator =
new FieldDocumentationGenerator(mapper.writer(),
mapper.getDeserializationConfig(), javadocReader, constraintReader, typeMapping,
SnippetTranslationManager.getDefaultResolver(), null);
Type type = FieldCommentResolution.class;
// when
List<ExtendedFieldDescriptor> result = cast(generator
.generateDocumentation(type, mapper.getTypeFactory()).values());
// then
assertThat(result.size(), is(4));
// field comment
assertThat(result.get(0), is(descriptor("location", "String", "A location", "true")));
// getter comment
assertThat(result.get(1), is(descriptor("type", "String", "A type", "true")));
// field comment
assertThat(result.get(2), is(descriptor("uri", "String", "A uri", "true")));
assertThat(result.get(3), is(descriptor("secured", "Boolean", "A secured flag", "true")));
}
@Test
public void testGenerateDocumentationForConstraints() throws Exception {
// given
ObjectMapper mapper = createMapper();
mockConstraint(ConstraintResolution.class, "location", "A constraint for location");
mockConstraint(ConstraintResolution.class, "type", "A constraint for type");
mockOptional(ConstraintResolution.class, "type", "false");
mockOptional(ConstraintResolution.class, "params", "false");
mockConstraint(ConstraintField.class, "value", "A constraint1 for value",
"A constraint2 for value");
mockOptional(ConstraintField.class, "value", "false");
FieldDocumentationGenerator generator =
new FieldDocumentationGenerator(mapper.writer(),
mapper.getDeserializationConfig(), javadocReader, constraintReader, typeMapping,
SnippetTranslationManager.getDefaultResolver(), null);
Type type = ConstraintResolution.class;
// when
List<ExtendedFieldDescriptor> fieldDescriptions = cast(generator
.generateDocumentation(type, mapper.getTypeFactory()).values());
// then
assertThat(fieldDescriptions.size(), is(5));
assertThat(fieldDescriptions.get(0),
is(descriptor("location", "String", "", "true", "A constraint for location")));
assertThat(fieldDescriptions.get(1),
is(descriptor("type", "Integer", "", "false", "A constraint for type")));
assertThat(fieldDescriptions.get(2),
is(descriptor("params", "Array[Object]", "", "false")));
assertThat(fieldDescriptions.get(3),
is(descriptor("params[].value", "String", "", "false",
"A constraint1 for value", "A constraint2 for value")));
assertThat(fieldDescriptions.get(4),
is(descriptor("flags", "Array[Boolean]", "", "true")));
}
@Test
public void testGenerateDocumentationForPrimitiveTypes() throws Exception {
// given
ObjectMapper mapper = createMapper();
mockFieldComment(PrimitiveTypes.class, "string", "A string");
mockFieldComment(PrimitiveTypes.class, "bool", "A boolean");
mockFieldComment(PrimitiveTypes.class, "number", "An integer");
mockFieldComment(PrimitiveTypes.class, "decimal", "A decimal");
FieldDocumentationGenerator generator =
new FieldDocumentationGenerator(mapper.writer(),
mapper.getDeserializationConfig(), javadocReader, constraintReader, typeMapping,
SnippetTranslationManager.getDefaultResolver(), null);
Type type = PrimitiveTypes.class;
// when
List<ExtendedFieldDescriptor> result = cast(generator
.generateDocumentation(type, mapper.getTypeFactory()).values());
// then
assertThat(result.size(), is(4));
assertThat(result.get(0), is(descriptor("string", "Array[String]", "A string", "true")));
assertThat(result.get(1), is(descriptor("bool", "Boolean", "A boolean", "true")));
assertThat(result.get(2), is(descriptor("number", "Integer", "An integer", "true")));
assertThat(result.get(3), is(descriptor("decimal", "Decimal", "A decimal", "true")));
// when change deserialization config
mapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, true);
generator = new FieldDocumentationGenerator(mapper.writer(),
mapper.getDeserializationConfig(), javadocReader, constraintReader, typeMapping,
SnippetTranslationManager.getDefaultResolver(), null);
// when
result = cast(generator.generateDocumentation(type, mapper.getTypeFactory()).values());
// then
assertThat(result.size(), is(4));
assertThat(result.get(0), is(descriptor("string", "Array[String]", "A string", "true")));
assertThat(result.get(1), is(descriptor("bool", "Boolean", "A boolean", "false")));
assertThat(result.get(2), is(descriptor("number", "Integer", "An integer", "false")));
assertThat(result.get(3), is(descriptor("decimal", "Decimal", "A decimal", "false")));
}
@Test
public void testGenerateDocumentationForComposedTypes() throws Exception {
// given
ObjectMapper mapper = createMapper();
mockFieldComment(ComposedTypes.class, "object", "An object");
mockFieldComment(BasicTypes.class, "string", "A string");
mockFieldComment(BasicTypes.class, "bool", "A boolean");
mockFieldComment(BasicTypes.class, "number", "An integer");
mockFieldComment(BasicTypes.class, "decimal", "A decimal");
mockFieldComment(ComposedTypes.class, "array", "An array");
FieldDocumentationGenerator generator =
new FieldDocumentationGenerator(mapper.writer(),
mapper.getDeserializationConfig(), javadocReader, constraintReader, typeMapping,
SnippetTranslationManager.getDefaultResolver(), null);
Type type = ComposedTypes.class;
// when
List<ExtendedFieldDescriptor> result = cast(generator
.generateDocumentation(type, mapper.getTypeFactory()).values());
// then
assertThat(result.size(), is(10));
assertThat(result.get(0),
is(descriptor("object", "Object", "An object", "true")));
assertThat(result.get(1),
is(descriptor("object.string", "String", "A string", "true")));
assertThat(result.get(2),
is(descriptor("object.bool", "Boolean", "A boolean", "true")));
assertThat(result.get(3),
is(descriptor("object.number", "Integer", "An integer", "true")));
assertThat(result.get(4),
is(descriptor("object.decimal", "Decimal", "A decimal", "true")));
assertThat(result.get(5),
is(descriptor("array", "Array[Object]", "An array", "true")));
assertThat(result.get(6),
is(descriptor("array[].string", "String", "A string", "true")));
assertThat(result.get(7),
is(descriptor("array[].bool", "Boolean", "A boolean", "true")));
assertThat(result.get(8),
is(descriptor("array[].number", "Integer", "An integer", "true")));
assertThat(result.get(9),
is(descriptor("array[].decimal", "Decimal", "A decimal", "true")));
}
@Test
public void testGenerateDocumentationForJacksonSubTypes() throws Exception {
// given
ObjectMapper mapper = createMapper();
mockFieldComment(JsonType1.class, "name", "A name");
mockFieldComment(JsonType1.class, "type", "A type");
mockFieldComment(JsonType1.class, "base1", "A base 1");
mockFieldComment(JsonType1.class, "base2", "A base 2");
mockFieldComment(JsonType1.class, "base3", "A base 3");
mockFieldComment(JsonType1.class, "base4", "A base 4");
mockFieldComment(JsonType1SubType1.class, "base1Sub1", "A base 1 sub 1");
mockFieldComment(JsonType1SubType2.class, "base1Sub2", "A base 1 sub 2");
mockFieldComment(JsonType2.class, "clazz", "A clazz");
mockFieldComment(JsonType2SubType1.class, "base2Sub1", "A base 2 sub 1");
mockFieldComment(JsonType2SubType2.class, "base2Sub2", "A base 2 sub 2");
mockTypeSpecifier(JsonType1SubType1.class, "[S1]");
FieldDocumentationGenerator generator =
new FieldDocumentationGenerator(mapper.writer(),
mapper.getDeserializationConfig(), javadocReader, constraintReader, typeMapping,
SnippetTranslationManager.getDefaultResolver(), null);
Type type = JsonType1.class;
// when
List<ExtendedFieldDescriptor> fieldDescriptions = cast(generator
.generateDocumentation(type, mapper.getTypeFactory()).values());
// then
assertThat(fieldDescriptions.size(), is(14));
assertThat(fieldDescriptions.get(0),
is(descriptor("type", "String", "A type", "true")));
assertThat(fieldDescriptions.get(1),
is(descriptor("name", "String", "A name", "true")));
assertThat(fieldDescriptions.get(2),
is(descriptor("base1", "Array[Object]", "A base 1", "true")));
assertThat(fieldDescriptions.get(3),
is(descriptor("base2", "Object", "A base 2", "true")));
assertThat(fieldDescriptions.get(4),
is(descriptor("base3", "Array[Object]", "A base 3", "true")));
assertThat(fieldDescriptions.get(5),
is(descriptor("base3[].clazz", "String", "A clazz", "true")));
assertThat(fieldDescriptions.get(6),
is(descriptor("base3[].base2Sub1", "String", "A base 2 sub 1", "true")));
assertThat(fieldDescriptions.get(7),
is(descriptor("base3[].base2Sub2", "String", "A base 2 sub 2", "true")));
assertThat(fieldDescriptions.get(8),
is(descriptor("base4", "Object", "A base 4", "true")));
assertThat(fieldDescriptions.get(9),
is(descriptor("base4.clazz", "String", "A clazz", "true")));
assertThat(fieldDescriptions.get(10),
is(descriptor("base4.base2Sub1", "String", "A base 2 sub 1", "true")));
assertThat(fieldDescriptions.get(11),
is(descriptor("base4.base2Sub2", "String", "A base 2 sub 2", "true")));
assertThat(fieldDescriptions.get(12),
is(descriptor("base1Sub1", "String", "A base 1 sub 1 [S1]", "true [S1]")));
assertThat(fieldDescriptions.get(13),
is(descriptor("base1Sub2", "String", "A base 1 sub 2", "true")));
}
@Test
public void testGenerateDocumentationForPlainSubTypes() throws Exception {
// given
ObjectMapper mapper = createMapper();
mockFieldComment(Plain.class, "field", "A field");
mockFieldComment(Plain.class, "overriddenField", "An overridden field");
mockFieldComment(PlainX.class, "overriddenField", "Custom 1");
mockFieldComment(PlainX.class, "x", "A field X");
mockFieldComment(PlainY.class, "overriddenField", "Custom 2");
mockFieldComment(PlainY.class, "y", "A field Y");
mockTypeSpecifier(Plain.class, "");
mockTypeSpecifier(PlainX.class, "(X)");
mockTypeSpecifier(PlainY.class, "(Y)");
mockOptional(Plain.class, "overriddenField", "true");
mockOptional(PlainX.class, "overriddenField", "false");
mockOptional(PlainY.class, "overriddenField", "false");
mockConstraint(Plain.class, "overriddenField", "Size[1]");
mockConstraint(PlainX.class, "overriddenField", "Size[x]");
mockConstraint(PlainY.class, "overriddenField", "Size[y]");
TypeMapping typeMapping = new TypeMapping();
typeMapping.mapSubtypes(Plain.class, PlainX.class, PlainY.class);
FieldDocumentationGenerator generator =
new FieldDocumentationGenerator(mapper.writer(),
mapper.getDeserializationConfig(), javadocReader, constraintReader, typeMapping,
SnippetTranslationManager.getDefaultResolver(), null);
Type type = Plain.class;
// when
List<ExtendedFieldDescriptor> fieldDescriptions = cast(generator
.generateDocumentation(type, mapper.getTypeFactory()).values());
// then
assertThat(fieldDescriptions.size(), is(4));
assertThat(fieldDescriptions.get(0),
is(descriptor("field", "String", "A field", "true")));
assertThat(fieldDescriptions.get(1),
is(descriptor("overriddenField", "String",
"An overridden field<br>Custom 1 (X)<br>Custom 2 (Y)",
Arrays.asList("true", "false (X)", "false (Y)"),
"Size[1]", "Size[x] (X)", "Size[y] (Y)")));
assertThat(fieldDescriptions.get(2),
is(descriptor("x", "String", "A field X (X)", "true (X)")));
assertThat(fieldDescriptions.get(3),
is(descriptor("y", "String", "A field Y (Y)", "true (Y)")));
}