Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Allow customization for ObjectReader and ObjectWriter

Browse Source 
Allows customization from subclasses of
AbstractJackson2HttpMessageConverter, AbstractJackson2Decoder, and
AbstractJackson2Encoder

See gh-28401
This commit is contained in:
Laber, Jason M
2022-04-29 20:42:55 -04:00
committed by rstoyanchev
parent 74df50c906
commit 27b5d141e2
6 changed files with 488 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
spring-web/src/main/java/org/springframework/http/codec/json/AbstractJackson2Decoder.java
View File

@@ -46,6 +46,7 @@ import org.springframework.core.log.LogFormatUtils;
import org.springframework.http.codec.HttpMessageDecoder;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.lang.NonNull;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.MimeType;
@@ -126,7 +127,7 @@ public abstract class AbstractJackson2Decoder extends Jackson2CodecSupport imple
ObjectMapper mapper = selectObjectMapper(elementType, mimeType);
if (mapper == null) {
throw new IllegalStateException("No ObjectMapper for " + elementType);
return Flux.error(new IllegalStateException("No ObjectMapper for " + elementType));
}
boolean forceUseOfBigDecimal = mapper.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS);
@@ -138,20 +139,22 @@ public abstract class AbstractJackson2Decoder extends Jackson2CodecSupport imple
Flux<TokenBuffer> tokens = Jackson2Tokenizer.tokenize(processed, mapper.getFactory(), mapper,
true, forceUseOfBigDecimal, getMaxInMemorySize());
ObjectReader reader = getObjectReader(mapper, elementType, hints);
ObjectReader objectReader = getObjectReader(mapper, elementType, hints);
return tokens.handle((tokenBuffer, sink) -> {
try {
Object value = reader.readValue(tokenBuffer.asParser(mapper));
logValue(value, hints);
if (value != null) {
sink.next(value);
}
}
catch (IOException ex) {
sink.error(processException(ex));
}
});
return customizeReaderFromStream(objectReader, mimeType, elementType, hints)
.flatMapMany(reader -> tokens.handle((tokenBuffer, sink) -> {
try {
Object value = reader.readValue(tokenBuffer.asParser(mapper));
logValue(value, hints);
if (value != null) {
sink.next(value);
}
}
catch (IOException ex) {
sink.error(processException(ex));
}
})
);
}
/**
@@ -174,22 +177,37 @@ public abstract class AbstractJackson2Decoder extends Jackson2CodecSupport imple
@Override
public Mono<Object> decodeToMono(Publisher<DataBuffer> input, ResolvableType elementType,
@Nullable MimeType mimeType, @Nullable Map<String, Object> hints) {
return DataBufferUtils.join(input, this.maxInMemorySize)
.flatMap(dataBuffer -> Mono.justOrEmpty(decode(dataBuffer, elementType, mimeType, hints)));
.flatMap(dataBuffer -> {
try {
ObjectReader objectReader = getObjectReader(elementType, mimeType, hints);
return customizeReaderFromStream(objectReader, mimeType, elementType, hints)
.flatMap(reader -> {
try {
return Mono.justOrEmpty(decode(dataBuffer, reader, hints));
}
catch (DecodingException ex) {
return Mono.error(ex);
}
});
}
catch (IllegalStateException ex) {
return Mono.error(ex);
}
});
}
@Override
public Object decode(DataBuffer dataBuffer, ResolvableType targetType,
@Nullable MimeType mimeType, @Nullable Map<String, Object> hints) throws DecodingException {
ObjectReader reader = getObjectReader(targetType, mimeType, hints);
reader = customizeReader(reader, mimeType, targetType, hints);
return decode(dataBuffer, reader, hints);
}
ObjectMapper mapper = selectObjectMapper(targetType, mimeType);
if (mapper == null) {
throw new IllegalStateException("No ObjectMapper for " + targetType);
}
private Object decode(@NonNull DataBuffer dataBuffer, @NonNull ObjectReader objectReader,
@Nullable Map<String, Object> hints) throws DecodingException {
try {
ObjectReader objectReader = getObjectReader(mapper, targetType, hints);
Object value = objectReader.readValue(dataBuffer.asInputStream());
logValue(value, hints);
return value;
@@ -202,6 +220,15 @@ public abstract class AbstractJackson2Decoder extends Jackson2CodecSupport imple
}
}
private ObjectReader getObjectReader(ResolvableType targetType, @Nullable MimeType mimeType,
@Nullable Map<String, Object> hints) {
ObjectMapper mapper = selectObjectMapper(targetType, mimeType);
if (mapper == null) {
throw new IllegalStateException("No ObjectMapper for " + targetType);
}
return getObjectReader(mapper, targetType, hints);
}
private ObjectReader getObjectReader(
ObjectMapper mapper, ResolvableType elementType, @Nullable Map<String, Object> hints) {
@@ -217,6 +244,32 @@ public abstract class AbstractJackson2Decoder extends Jackson2CodecSupport imple
mapper.readerFor(javaType);
}
/**
* Provides the ability for subclasses to customize the {@link ObjectReader} for deserialization from a stream.
* @param reader the {@link ObjectReader} available for customization
* @param mimeType the MIME type associated with the input stream
* @param elementType the expected type of elements in the output stream
* @param hints additional information about how to do encode
* @return the customized {@link ObjectReader}
*/
protected Mono<ObjectReader> customizeReaderFromStream(@NonNull ObjectReader reader, @Nullable MimeType mimeType,
ResolvableType elementType, @Nullable Map<String, Object> hints) {
return Mono.just(customizeReader(reader, mimeType, elementType, hints));
}
/**
* Provides the ability for subclasses to customize the {@link ObjectReader} for deserialization.
* @param reader the {@link ObjectReader} available for customization
* @param mimeType the MIME type associated with the input stream
* @param elementType the expected type of elements in the output stream
* @param hints additional information about how to do encode
* @return the customized {@link ObjectReader}
*/
protected ObjectReader customizeReader(@NonNull ObjectReader reader, @Nullable MimeType mimeType,
ResolvableType elementType, @Nullable Map<String, Object> hints) {
return reader;
}
@Nullable
private Class<?> getContextClass(@Nullable ResolvableType elementType) {
MethodParameter param = (elementType != null ? getParameter(elementType) : null);

81
spring-web/src/main/java/org/springframework/http/codec/json/AbstractJackson2Encoder.java
View File

@@ -53,6 +53,7 @@ import org.springframework.http.codec.HttpMessageEncoder;
import org.springframework.http.converter.json.MappingJacksonValue;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.lang.NonNull;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;
@@ -86,7 +87,6 @@ public abstract class AbstractJackson2Encoder extends Jackson2CodecSupport imple
private final List<MediaType> streamingMediaTypes = new ArrayList<>(1);
/**
* Constructor with a Jackson {@link ObjectMapper} to use.
*/
@@ -150,7 +150,9 @@ public abstract class AbstractJackson2Encoder extends Jackson2CodecSupport imple
if (inputStream instanceof Mono) {
return Mono.from(inputStream)
.map(value -> encodeValue(value, bufferFactory, elementType, mimeType, hints))
.flatMap(value -> createEncodingToolsForStream(value, elementType, mimeType, hints)
.map(tools -> encodeValue(value, tools.mapper(), tools.writer(),
bufferFactory, mimeType, hints)))
.flux();
}
@@ -191,6 +193,7 @@ public abstract class AbstractJackson2Encoder extends Jackson2CodecSupport imple
dataBuffer);
})
.concatWith(Mono.fromCallable(() -> bufferFactory.wrap(helper.getSuffix())));
}
return dataBufferFlux
@@ -213,22 +216,21 @@ public abstract class AbstractJackson2Encoder extends Jackson2CodecSupport imple
@Override
public DataBuffer encodeValue(Object value, DataBufferFactory bufferFactory,
ResolvableType valueType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) {
ObjectEncodingTools encodingTools = createEncodingTools(value, valueType, mimeType, hints);
ObjectWriter writer = encodingTools.writer();
writer = customizeWriter(writer, mimeType, valueType, hints);
return encodeValue(value, encodingTools.mapper(), writer, bufferFactory, mimeType, hints);
}
private DataBuffer encodeValue(Object value, ObjectMapper mapper, ObjectWriter writer,
DataBufferFactory bufferFactory, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) {
Class<?> jsonView = null;
FilterProvider filters = null;
if (value instanceof MappingJacksonValue mappingJacksonValue) {
value = mappingJacksonValue.getValue();
valueType = ResolvableType.forInstance(value);
jsonView = mappingJacksonValue.getSerializationView();
filters = mappingJacksonValue.getFilters();
}
ObjectMapper mapper = selectObjectMapper(valueType, mimeType);
if (mapper == null) {
throw new IllegalStateException("No ObjectMapper for " + valueType);
}
ObjectWriter writer = createObjectWriter(mapper, valueType, mimeType, jsonView, hints);
if (filters != null) {
writer = writer.with(filters);
}
@@ -322,6 +324,35 @@ public abstract class AbstractJackson2Encoder extends Jackson2CodecSupport imple
}
}
private Mono<ObjectEncodingTools> createEncodingToolsForStream(Object value, ResolvableType valueType,
@Nullable MimeType mimeType, @Nullable Map<String, Object> hints) {
try {
ObjectEncodingTools encodingTools = createEncodingTools(value, valueType, mimeType, hints);
ObjectWriter objectWriter = encodingTools.writer();
return customizeWriterFromStream(objectWriter, mimeType, valueType, hints)
.map(customizedWriter -> new ObjectEncodingTools(encodingTools.mapper(), customizedWriter));
}
catch (IllegalStateException ex) {
return Mono.error(ex);
}
}
private ObjectEncodingTools createEncodingTools(Object value, ResolvableType valueType,
@Nullable MimeType mimeType, @Nullable Map<String, Object> hints) {
Class<?> jsonView = null;
if (value instanceof MappingJacksonValue mappingJacksonValue) {
valueType = ResolvableType.forInstance(mappingJacksonValue.getValue());
jsonView = mappingJacksonValue.getSerializationView();
}
ObjectMapper mapper = selectObjectMapper(valueType, mimeType);
if (mapper == null) {
throw new IllegalStateException("No ObjectMapper for " + valueType);
}
ObjectWriter writer = createObjectWriter(mapper, valueType, mimeType, jsonView, hints);
return new ObjectEncodingTools(mapper, writer);
}
private ObjectWriter createObjectWriter(
ObjectMapper mapper, ResolvableType valueType, @Nullable MimeType mimeType,
@Nullable Class<?> jsonView, @Nullable Map<String, Object> hints) {
@@ -334,12 +365,32 @@ public abstract class AbstractJackson2Encoder extends Jackson2CodecSupport imple
if (javaType.isContainerType()) {
writer = writer.forType(javaType);
}
return customizeWriter(writer, mimeType, valueType, hints);
return writer;
}
/**
* Provides the ability for subclasses to customize the {@link ObjectWriter} for serialization from a stream.
* @param writer the {@link ObjectWriter} available for customization
* @param mimeType the MIME type associated with the input stream
* @param elementType the expected type of elements in the output stream
* @param hints additional information about how to do encode
* @return the customized {@link ObjectWriter}
*/
protected Mono<ObjectWriter> customizeWriterFromStream(@NonNull ObjectWriter writer, @Nullable MimeType mimeType,
ResolvableType elementType, @Nullable Map<String, Object> hints) {
return Mono.just(customizeWriter(writer, mimeType, elementType, hints));
}
/**
* Provides the ability for subclasses to customize the {@link ObjectWriter} for serialization.
* @param writer the {@link ObjectWriter} available for customization
* @param mimeType the MIME type associated with the input stream
* @param elementType the expected type of elements in the output stream
* @param hints additional information about how to do encode
* @return the customized {@link ObjectWriter}
*/
protected ObjectWriter customizeWriter(ObjectWriter writer, @Nullable MimeType mimeType,
ResolvableType elementType, @Nullable Map<String, Object> hints) {
return writer;
}
@@ -438,4 +489,8 @@ public abstract class AbstractJackson2Encoder extends Jackson2CodecSupport imple
}
}
private record ObjectEncodingTools(ObjectMapper mapper, ObjectWriter writer) {
}
}

32
spring-web/src/main/java/org/springframework/http/converter/json/AbstractJackson2HttpMessageConverter.java
View File

@@ -59,6 +59,7 @@ import org.springframework.http.converter.HttpMessageConversionException;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.lang.NonNull;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;
@@ -380,6 +381,7 @@ public abstract class AbstractJackson2HttpMessageConverter extends AbstractGener
Class<?> deserializationView = mappingJacksonInputMessage.getDeserializationView();
if (deserializationView != null) {
ObjectReader objectReader = objectMapper.readerWithView(deserializationView).forType(javaType);
objectReader = customizeReader(objectReader, javaType);
if (isUnicode) {
return objectReader.readValue(inputStream);
}
@@ -389,12 +391,15 @@ public abstract class AbstractJackson2HttpMessageConverter extends AbstractGener
}
}
}
ObjectReader objectReader = objectMapper.reader().forType(javaType);
objectReader = customizeReader(objectReader, javaType);
if (isUnicode) {
return objectMapper.readValue(inputStream, javaType);
return objectReader.readValue(inputStream);
}
else {
Reader reader = new InputStreamReader(inputStream, charset);
return objectMapper.readValue(reader, javaType);
return objectReader.readValue(reader);
}
}
catch (InvalidDefinitionException ex) {
@@ -405,6 +410,16 @@ public abstract class AbstractJackson2HttpMessageConverter extends AbstractGener
}
}
/**
* Provides the ability for subclasses to customize the {@link ObjectReader} for deserialization.
* @param reader the {@link ObjectReader} available for customization
* @param javaType the specified type to deserialize to
* @return the customized {@link ObjectReader}
*/
protected ObjectReader customizeReader(@NonNull ObjectReader reader, JavaType javaType) {
return reader;
}
/**
* Determine the charset to use for JSON input.
* <p>By default this is either the charset from the input {@code MediaType}
@@ -465,6 +480,7 @@ public abstract class AbstractJackson2HttpMessageConverter extends AbstractGener
config.isEnabled(SerializationFeature.INDENT_OUTPUT)) {
objectWriter = objectWriter.with(this.ssePrettyPrinter);
}
objectWriter = customizeWriter(objectWriter, javaType, contentType);
objectWriter.writeValue(generator, value);
writeSuffix(generator, object);
@@ -478,6 +494,18 @@ public abstract class AbstractJackson2HttpMessageConverter extends AbstractGener
}
}
/**
* Provides the ability for subclasses to customize the {@link ObjectWriter} for serialization.
* @param writer the {@link ObjectWriter} available for customization
* @param javaType the specified type to serialize from
* @param contentType the output content type
* @return the customized {@link ObjectWriter}
*/
protected ObjectWriter customizeWriter(@NonNull ObjectWriter writer, @Nullable JavaType javaType,
@Nullable MediaType contentType) {
return writer;
}
/**
* Write a prefix before the main content.
* @param generator the generator to use for writing content.