Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright 2010 Proofpoint, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.airlift.json;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonFactoryBuilder;
import com.fasterxml.jackson.core.StreamReadConstraints;
import com.fasterxml.jackson.core.StreamWriteConstraints;
import com.fasterxml.jackson.core.Version;
import com.fasterxml.jackson.core.util.JsonRecyclerPools;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.KeyDeserializer;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.Module;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.json.JsonMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.datatype.guava.GuavaModule;
import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
import com.fasterxml.jackson.datatype.joda.JodaModule;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;
import com.google.common.collect.ImmutableMap;
import com.google.inject.Inject;
import com.google.inject.Provider;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import static java.util.Objects.requireNonNull;
public class ObjectMapperProvider
implements Provider
{
private final JsonFactory jsonFactory;
private Map, JsonSerializer> keySerializers;
private Map, KeyDeserializer> keyDeserializers;
private Map, JsonSerializer> jsonSerializers;
private Map, JsonDeserializer> jsonDeserializers;
private final Set jsonSubTypes = new HashSet<>();
private final Set modules = new HashSet<>();
@Inject
public ObjectMapperProvider()
{
this(new JsonFactoryBuilder());
}
public ObjectMapperProvider(JsonFactory jsonFactory)
{
this(new JsonFactoryBuilder(requireNonNull(jsonFactory, "jsonFactory is null")));
}
private ObjectMapperProvider(JsonFactoryBuilder jsonFactoryBuilder)
{
// Disable the length limit, caller will be responsible for validating the input length
jsonFactoryBuilder.streamReadConstraints(StreamReadConstraints
.builder()
.maxStringLength(Integer.MAX_VALUE)
.maxNestingDepth(Integer.MAX_VALUE)
.maxNameLength(Integer.MAX_VALUE)
.maxDocumentLength(Long.MAX_VALUE)
.build());
jsonFactoryBuilder.streamWriteConstraints(StreamWriteConstraints
.builder()
.maxNestingDepth(Integer.MAX_VALUE)
.build());
jsonFactoryBuilder.recyclerPool(JsonRecyclerPools.threadLocalPool());
jsonFactory = jsonFactoryBuilder.build();
modules.add(new Jdk8Module());
modules.add(new JavaTimeModule());
modules.add(new GuavaModule());
modules.add(new ParameterNamesModule());
modules.add(new RecordAutoDetectModule());
try {
getClass().getClassLoader().loadClass("org.joda.time.DateTime");
modules.add(new JodaModule());
}
catch (ClassNotFoundException ignored) {
}
}
@Inject(optional = true)
public void setJsonSerializers(Map, JsonSerializer> jsonSerializers)
{
this.jsonSerializers = ImmutableMap.copyOf(jsonSerializers);
}
public ObjectMapperProvider withJsonSerializers(Map, JsonSerializer> jsonSerializers)
{
setJsonSerializers(jsonSerializers);
return this;
}
@Inject(optional = true)
public void setJsonDeserializers(Map, JsonDeserializer> jsonDeserializers)
{
this.jsonDeserializers = ImmutableMap.copyOf(jsonDeserializers);
}
public ObjectMapperProvider withJsonDeserializers(Map, JsonDeserializer> jsonDeserializers)
{
setJsonDeserializers(jsonDeserializers);
return this;
}
@Inject(optional = true)
public void setKeySerializers(@JsonKeySerde Map, JsonSerializer> keySerializers)
{
this.keySerializers = keySerializers;
}
public ObjectMapperProvider withKeySerializers(@JsonKeySerde Map, JsonSerializer> keySerializers)
{
setKeySerializers(keySerializers);
return this;
}
@Inject(optional = true)
public void setKeyDeserializers(@JsonKeySerde Map, KeyDeserializer> keyDeserializers)
{
this.keyDeserializers = keyDeserializers;
}
public ObjectMapperProvider withKeyDeserializers(@JsonKeySerde Map, KeyDeserializer> keyDeserializers)
{
setKeyDeserializers(keyDeserializers);
return this;
}
@Inject(optional = true)
public void setModules(Set modules)
{
this.modules.addAll(modules);
}
public ObjectMapperProvider withModules(Set modules)
{
setModules(modules);
return this;
}
@Inject(optional = true)
public void setJsonSubTypes(Set jsonSubTypes)
{
this.jsonSubTypes.addAll(jsonSubTypes);
}
public ObjectMapperProvider withJsonSubTypes(Set jsonSubTypes)
{
setJsonSubTypes(jsonSubTypes);
return this;
}
@Override
public ObjectMapper get()
{
JsonMapper.Builder objectMapper = JsonMapper.builder(jsonFactory);
// ignore unknown fields (for backwards compatibility)
objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
// do not allow converting a float to an integer
objectMapper.disable(DeserializationFeature.ACCEPT_FLOAT_AS_INT);
// use ISO dates
objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
// Skip fields that are null or absent (Optional) when serializing objects.
// This only applies to mapped object fields, not containers like Map or List.
objectMapper.defaultPropertyInclusion(JsonInclude.Value.construct(JsonInclude.Include.NON_ABSENT, JsonInclude.Include.ALWAYS));
// disable auto detection of json properties... all properties must be explicit
objectMapper.disable(MapperFeature.AUTO_DETECT_CREATORS);
objectMapper.disable(MapperFeature.AUTO_DETECT_FIELDS);
objectMapper.disable(MapperFeature.AUTO_DETECT_SETTERS);
objectMapper.disable(MapperFeature.AUTO_DETECT_GETTERS);
objectMapper.disable(MapperFeature.AUTO_DETECT_IS_GETTERS);
objectMapper.disable(MapperFeature.USE_GETTERS_AS_SETTERS);
objectMapper.disable(MapperFeature.CAN_OVERRIDE_ACCESS_MODIFIERS);
objectMapper.disable(MapperFeature.INFER_PROPERTY_MUTATORS);
objectMapper.disable(MapperFeature.ALLOW_FINAL_FIELDS_AS_MUTATORS);
if (jsonSerializers != null || jsonDeserializers != null || keySerializers != null || keyDeserializers != null) {
SimpleModule module = new SimpleModule(getClass().getName(), new Version(1, 0, 0, null, null, null));
if (jsonSerializers != null) {
for (Entry, JsonSerializer> entry : jsonSerializers.entrySet()) {
addSerializer(module, entry.getKey(), entry.getValue());
}
}
if (jsonDeserializers != null) {
for (Entry, JsonDeserializer> entry : jsonDeserializers.entrySet()) {
addDeserializer(module, entry.getKey(), entry.getValue());
}
}
if (keySerializers != null) {
for (Entry, JsonSerializer> entry : keySerializers.entrySet()) {
addKeySerializer(module, entry.getKey(), entry.getValue());
}
}
if (keyDeserializers != null) {
for (Entry, KeyDeserializer> entry : keyDeserializers.entrySet()) {
module.addKeyDeserializer(entry.getKey(), entry.getValue());
}
}
modules.add(module);
}
for (JsonSubType jsonSubType : jsonSubTypes) {
modules.addAll(jsonSubType.modules());
}
objectMapper.addModules(modules);
return objectMapper.build();
}
//
// Yes this code is strange. The addSerializer and addDeserializer methods arguments have
// generic types that are dependent on each other, but since our map has no type information, we
// have no type T for casting the type and serializer. This is why these methods have generic type
// T but it is only used for casting
//
@SuppressWarnings("unchecked")
private void addSerializer(SimpleModule module, Class type, JsonSerializer jsonSerializer)
{
module.addSerializer((Class) type, (JsonSerializer) jsonSerializer);
}
@SuppressWarnings("unchecked")
public void addDeserializer(SimpleModule module, Class type, JsonDeserializer jsonDeserializer)
{
module.addDeserializer((Class) type, (JsonDeserializer) jsonDeserializer);
}
@SuppressWarnings("unchecked")
private void addKeySerializer(SimpleModule module, Class type, JsonSerializer keySerializer)
{
module.addKeySerializer((Class) type, (JsonSerializer) keySerializer);
}
}
