下面列出了com.fasterxml.jackson.databind.JsonDeserializer#deserialize ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
@Override
public T deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
List<Object> list = new ArrayList<>();
int ptr = 0;
for (JsonToken jsonToken = p.nextToken(); jsonToken != END_ARRAY; jsonToken = p.nextToken()) {
if (ptr >= deserializersCount()) {
throw mappingException(ctxt, javaType.getRawClass(), jsonToken);
}
JsonDeserializer<?> deserializer = deserializer(ptr++);
Object value = (jsonToken != VALUE_NULL) ? deserializer.deserialize(p, ctxt) : deserializer.getNullValue(ctxt);
list.add(value);
}
if (list.size() == deserializersCount()) {
return create(list, ctxt);
} else {
throw mappingException(ctxt, javaType.getRawClass(), null);
}
}
/**
* Helper method called when {@link JsonParser} indicates that it can use
* so-called native type ids, and such type id has been found.
*
* @since 2.4
*/
protected Object _deserializeWithNativeTypeId(JsonParser jp, DeserializationContext ctxt, Object typeId)
throws IOException
{
JsonDeserializer<Object> deser;
if (typeId == null) {
/* 04-May-2014, tatu: Should error be obligatory, or should there be another method
* for "try to deserialize with native tpye id"?
*/
deser = _findDefaultImplDeserializer(ctxt);
if (deser == null) {
return ctxt.reportInputMismatch(baseType(),
"No (native) type id found when one was expected for polymorphic type handling");
}
} else {
String typeIdStr = (typeId instanceof String) ? (String) typeId : String.valueOf(typeId);
deser = _findDeserializer(ctxt, typeIdStr);
}
return deser.deserialize(jp, ctxt);
}
@Override
public PersistentMap<?, ?> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
JsonDeserializer deser = ctxt.findRootValueDeserializer(ctxt.getTypeFactory().constructRawMapType(Map.class));
Object o = deser.deserialize(p, ctxt);
if(HashMap.class.isAssignableFrom(mapType))
return HashMap.fromMap((Map)o);
if(TreeMap.class.isAssignableFrom(mapType))
return TreeMap.fromMap((Comparator)Comparator.naturalOrder(),(Map)o);
/** if(TrieMap.class.isAssignableFrom(mapType))
return TrieMap.fromMap((Map)o);
if(LinkedMap.class.isAssignableFrom(mapType))
return LinkedMap.fromMap((Map)o);
**/
Optional<Method> m = streamMethod.computeIfAbsent(mapType, c-> Stream.of(c.getMethods())
.filter(method -> "fromMap".equals(method.getName()))
.filter(method -> method.getParameterCount()==1)
.filter(method -> method.getParameterTypes()[0].isAssignableFrom(Map.class)).findFirst()
.map(m2->{ m2.setAccessible(true); return m2;}));
PersistentMap<?,?> x = m.map(mt -> (PersistentMap)new Invoker().executeMethod(o, mt, mapType)).orElse(null);
return x;
}
@Override
protected T _deserializeContents(JsonParser p, DeserializationContext ctxt) throws IOException,
JsonProcessingException {
JsonDeserializer<?> valueDes = _valueDeserializer;
JsonToken t;
final TypeDeserializer typeDeser = _valueTypeDeserializer;
T set = createMultiset();
while ((t = p.nextToken()) != JsonToken.END_ARRAY) {
Object value;
if (t == JsonToken.VALUE_NULL) {
if (_skipNullValues) {
continue;
}
value = _nullProvider.getNullValue(ctxt);
} else if (typeDeser == null) {
value = valueDes.deserialize(p, ctxt);
} else {
value = valueDes.deserializeWithType(p, ctxt, typeDeser);
}
set.add(value);
}
return set;
}
@Override
public LazyEither5<?,?,?,?,?> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
JsonDeserializer ser = ctxt.findRootValueDeserializer(ctxt.getTypeFactory().constructSimpleType(LazyEitherBean.class, new JavaType[0]));
LazyEitherBean x = (LazyEitherBean)ser.deserialize(p, ctxt);
if(x.left1!=null){
return LazyEither5.left1(x.left1);
}
if(x.left2!=null){
return LazyEither5.left2(x.left2);
}
if(x.left3!=null){
return LazyEither5.left3(x.left2);
}
if(x.left4!=null){
return LazyEither5.left4(x.left2);
}
return LazyEither5.right(x.right);
}
private Object readEncoded(JsonParser p, DeserializationContext ctxt) throws IOException {
if (!p.isExpectedStartArrayToken()) {
throw new JsonParseException(p, "Expected array for encoded object got " + p.currentToken());
}
Object value = null;
JsonToken next = p.nextToken();
if (next != JsonToken.VALUE_STRING) {
throw new JsonParseException(p, "Encoded Class value not present " + next);
}
String typeName = p.getText();
p.nextToken(); // fwd to next
ClassLoader loader = Thread.currentThread().getContextClassLoader();
if (loader == null) {
loader = getClass().getClassLoader();
}
try {
Class<?> type = loader.loadClass(typeName);
if (Collection.class.isAssignableFrom(type)) {
value = readCollection(type, p, ctxt);
} else if (Map.class.isAssignableFrom(type)) {
value = readMap(type, p, ctxt);
} else {
JsonDeserializer<Object> deser = ctxt.findRootValueDeserializer(ctxt.constructType(type));
value = deser.deserialize(p, ctxt);
}
} catch (ClassNotFoundException e) {
throw new JsonParseException(p, "Type name encoded " + typeName + " could not be loaded", e);
}
if (p.nextToken() != JsonToken.END_ARRAY) {
throw new JsonParseException(p, "Encoded expected end of ARRAY marker " + p.currentToken());
}
return value;
}
@Override
protected DeviceRenderTypeMap readValue( JsonParser jsonParser )
{
try
{
JsonDeserializer<DeviceRenderTypeMap> jsonDeserializer = deserializer.newInstance();
return jsonDeserializer.deserialize( jsonParser, MAPPER.getDeserializationContext() );
}
catch ( IOException | IllegalAccessException | InstantiationException e )
{
throw new RuntimeException( e );
}
}
@Override
public LazyEither3<?,?,?> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
JsonDeserializer ser = ctxt.findRootValueDeserializer(ctxt.getTypeFactory().constructSimpleType(LazyEitherBean.class, new JavaType[0]));
LazyEitherBean x = (LazyEitherBean)ser.deserialize(p, ctxt);
if(x.left1!=null){
return LazyEither3.left1(x.left1);
}
if(x.left2!=null){
return LazyEither3.left2(x.left2);
}
return LazyEither3.right(x.right);
}
/**
* Helper method called when current token is no START_ARRAY. Will either
* throw an exception, or try to handle value as if member of implicit
* array, depending on configuration.
*/
@SuppressWarnings("unchecked")
protected final Collection<Object> handleNonArray(JsonParser p, DeserializationContext ctxt,
Collection<Object> result)
throws IOException {
// Implicit arrays from single values?
boolean canWrap = (_unwrapSingle == Boolean.TRUE) ||
((_unwrapSingle == null) &&
ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY));
if (!canWrap) {
return (Collection<Object>) ctxt.handleUnexpectedToken(_containerType.getRawClass(), p);
}
JsonDeserializer<Object> valueDes = _valueDeserializer;
final TypeDeserializer typeDeser = _valueTypeDeserializer;
JsonToken t = p.getCurrentToken();
Object value;
try {
if (t == JsonToken.VALUE_NULL) {
// 03-Feb-2017, tatu: Hmmh. I wonder... let's try skipping here, too
if (_skipNullValues) {
return result;
}
value = _nullProvider.getNullValue(ctxt);
} else if (typeDeser == null) {
value = valueDes.deserialize(p, ctxt);
} else {
value = valueDes.deserializeWithType(p, ctxt, typeDeser);
}
} catch (Exception e) {
// note: pass Object.class, not Object[].class, as we need element type for error info
throw JsonMappingException.wrapWithPath(e, Object.class, result.size());
}
result.add(value);
return result;
}
@Override
public LazyEither<?,?> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
JsonDeserializer ser = ctxt.findRootValueDeserializer(ctxt.getTypeFactory().constructSimpleType(LazyEitherBean.class, new JavaType[0]));
LazyEitherBean x = (LazyEitherBean)ser.deserialize(p, ctxt);
if(x.left!=null){
return LazyEither.left(x.left);
}
return LazyEither.right(x.right);
}
@Override
public HiveProxyingSubScan deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
final JsonNode node = jsonParser.getCodec().readTree(jsonParser);
final String pluginName = node.get("pluginName").asText();
final CatalogService catalogService = (CatalogService) deserializationContext
.findInjectableValue(CatalogService.class.getName(), null, null);
final StoragePluginCreator.PF4JStoragePlugin plugin = catalogService.getSource(pluginName);
final Class<? extends HiveProxiedSubScan> scanClazz = plugin.getSubScanClass();
final JavaType scanType = deserializationContext.getTypeFactory().constructType(scanClazz);
final BasicBeanDescription description = deserializationContext.getConfig().introspect(scanType);
final JsonDeserializer<Object> subScanDeserializer = deserializationContext.getFactory().createBeanDeserializer(
deserializationContext, scanType, description);
if (subScanDeserializer instanceof ResolvableDeserializer) {
((ResolvableDeserializer) subScanDeserializer).resolve(deserializationContext);
}
final JsonParser movedParser = jsonParser.getCodec().treeAsTokens(node.get("wrappedHiveScan"));
deserializationContext.getConfig().initialize(movedParser);
if (movedParser.getCurrentToken() == null) {
movedParser.nextToken();
}
final HiveProxiedSubScan scan = (HiveProxiedSubScan) subScanDeserializer.deserialize(movedParser, deserializationContext);
return new HiveProxyingSubScan(pluginName, scan);
}
@Override
public Object deserialize(JsonParser p, DeserializationContext ctx) throws IOException {
if(jobsManager == null) {
throw new IllegalStateException("This deserializer need a jobsManager instance, see 'JobParametersDeserializer.setJobsManager'");
}
final JsonStreamContext jsc = p.getParsingContext();
String paramName = null;
JsonStreamContext parent = jsc;
while(parent != null) {
paramName = parent.getCurrentName();
if(paramName != null) {
break;
}
parent = parent.getParent();
}
if(parent == null) {
throw new NullPointerException("Something wrong: we can not find our parent object, " +
"may be you use this deserializer on custom object?");
}
JobParameters.Builder r = (JobParameters.Builder) parent.getParent().getCurrentValue();
String jobType = r.getType();
JobDescription desc = jobsManager.getDescription(jobType);
JobParameterDescription param = desc.getParameters().get(paramName);
TypeFactory typeFactory = ctx.getTypeFactory();
JavaType type;
if(param == null) {
type = typeFactory.constructType(Object.class);
} else {
type = typeFactory.constructType(param.getType());
}
JsonDeserializer<Object> deser = ctx.findNonContextualValueDeserializer(type);
try {
return deser.deserialize(p, ctx);
} catch (Exception e) {
throw new RuntimeException("Can not deserialize '" + jobType + "." + paramName + "' job parameter ", e );
}
}
@Override
public ValueProvider<?> deserialize(JsonParser jp, DeserializationContext ctxt)
throws IOException, JsonProcessingException {
JsonDeserializer dser =
ctxt.findRootValueDeserializer(
checkNotNull(
innerType, "Invalid %s: innerType is null. Serialization error?", getClass()));
Object o = dser.deserialize(jp, ctxt);
return StaticValueProvider.of(o);
}
@Override
public LazyEither4<?,?,?,?> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
JsonDeserializer ser = ctxt.findRootValueDeserializer(ctxt.getTypeFactory().constructSimpleType(LazyEitherBean.class, new JavaType[0]));
LazyEitherBean x = (LazyEitherBean)ser.deserialize(p, ctxt);
if(x.left1!=null){
return LazyEither4.left1(x.left1);
}
if(x.left2!=null){
return LazyEither4.left2(x.left2);
}
if(x.left3!=null){
return LazyEither4.left3(x.left2);
}
return LazyEither4.right(x.right);
}
@SuppressWarnings("unchecked")
@Override
public Object deserialize(JsonParser p, DeserializationContext ctxt,
Object result)
throws IOException {
// Ok: must point to START_ARRAY (or equivalent)
if (!p.isExpectedStartArrayToken()) {
return handleNonArray(p, ctxt, (Collection<Object>) result);
}
// [databind#631]: Assign current value, to be accessible by custom serializers
p.setCurrentValue(result);
JsonDeserializer<Object> valueDes = _valueDeserializer;
final TypeDeserializer typeDeser = _valueTypeDeserializer;
CollectionReferringAccumulator referringAccumulator =
(valueDes.getObjectIdReader() == null) ? null :
new CollectionReferringAccumulator(_containerType.getContentType().getRawClass(), (Collection<Object>) result);
JsonToken t;
while ((t = p.nextToken()) != JsonToken.END_ARRAY) {
try {
Object value;
if (t == JsonToken.VALUE_NULL) {
if (_skipNullValues) {
continue;
}
value = _nullProvider.getNullValue(ctxt);
} else if (typeDeser == null) {
value = valueDes.deserialize(p, ctxt);
} else {
value = valueDes.deserializeWithType(p, ctxt, typeDeser);
}
if (referringAccumulator != null) {
referringAccumulator.add(value);
} else {
((Collection<Object>) result).add(value);
}
} catch (UnresolvedForwardReference reference) {
if (referringAccumulator == null) {
throw JsonMappingException
.from(p, "Unresolved forward reference but no identity info", reference);
}
Referring ref = referringAccumulator.handleUnresolvedReference(reference);
reference.getRoid().appendReferring(ref);
} catch (Exception e) {
boolean wrap = (ctxt == null) || ctxt.isEnabled(DeserializationFeature.WRAP_EXCEPTIONS);
if (!wrap) {
ClassUtil.throwIfRTE(e);
}
throw JsonMappingException.wrapWithPath(e, result, ((Collection<Object>) result).size());
}
}
return result;
}
@Override
public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
int took = 0;
boolean errors = false;
BulkError error = null;
int status = -1;
List<BulkResultItem> items = null;
String fieldName;
while ((fieldName = p.nextFieldName()) != null) {
switch (fieldName) {
case "took": {
took = p.nextIntValue(-1);
break;
}
case "errors": {
errors = p.nextBooleanValue();
break;
}
case "status": {
status = p.nextIntValue(-1);
break;
}
case "error": {
p.nextValue(); // skip to START_OBJECT or VALUE_NULL
JsonDeserializer<Object> typeDeserializer = ctxt.findNonContextualValueDeserializer(ctxt.constructType(BulkError.class));
error = (BulkError) typeDeserializer.deserialize(p, ctxt);
break;
}
case "items": {
if (errors) {
items = new ArrayList<>();
p.nextValue(); // skip to START_ARRAY
p.nextValue(); // skip to START_OBJECT
ObjectMapper mapper = (ObjectMapper) p.getCodec();
MappingIterator<BulkResultItem> bulkResultItemMappingIterator = mapper.readValues(p, BulkResultItem.class);
while (bulkResultItemMappingIterator.hasNext()) {
items.add(bulkResultItemMappingIterator.next());
}
}
break;
}
}
}
return new BufferedBulkResult(took, errors, error, status, items);
}
@Override
public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
int took = 0;
boolean errors = false;
Error error = null;
int status = -1;
List<BatchItemResult> items = null;
String fieldName;
while ((fieldName = p.nextFieldName()) != null) {
switch (fieldName) {
case "took": {
took = p.nextIntValue(-1);
break;
}
case "errors": {
errors = p.nextBooleanValue();
break;
}
case "status": {
status = p.nextIntValue(-1);
break;
}
case "error": {
p.nextValue(); // skip to START_OBJECT or VALUE_NULL
JsonDeserializer<Object> typeDeserializer = ctxt.findNonContextualValueDeserializer(ctxt.constructType(Error.class));
error = (Error) typeDeserializer.deserialize(p, ctxt);
break;
}
case "items": {
if (errors) {
items = new ArrayList<>();
p.nextValue(); // skip to START_ARRAY
p.nextValue(); // skip to START_OBJECT
ObjectMapper mapper = (ObjectMapper) p.getCodec();
MappingIterator<BatchItemResult> batchResultItemMappingIterator = mapper.readValues(p, BatchItemResult.class);
while (batchResultItemMappingIterator.hasNext()) {
items.add(batchResultItemMappingIterator.next());
}
}
break;
}
}
}
return new BatchResult(took, errors, error, status, items);
}
@Override
protected T _deserializeEntries(JsonParser p, DeserializationContext ctxt)
throws IOException, JsonProcessingException
{
final KeyDeserializer keyDes = _keyDeserializer;
final JsonDeserializer<?> valueDes = _valueDeserializer;
final TypeDeserializer typeDeser = _valueTypeDeserializer;
ImmutableMap.Builder<Object, Object> builder = createBuilder();
for (; p.currentToken() == JsonToken.FIELD_NAME; p.nextToken()) {
// Must point to field name now
String fieldName = p.currentName();
Object key = (keyDes == null) ? fieldName : keyDes.deserializeKey(fieldName, ctxt);
// And then the value...
JsonToken t = p.nextToken();
// 28-Nov-2010, tatu: Should probably support "ignorable properties" in future...
Object value;
if (t == JsonToken.VALUE_NULL) {
if (!_skipNullValues) {
value = _nullProvider.getNullValue(ctxt);
// 14-Sep-2015, tatu: As per [datatype-guava#52], avoid exception due to null
// TODO: allow reporting problem via a feature, in future?
if (value != null) {
builder.put(key, value);
}
}
continue;
}
if (typeDeser == null) {
value = valueDes.deserialize(p, ctxt);
} else {
value = valueDes.deserializeWithType(p, ctxt, typeDeser);
}
builder.put(key, value);
}
// No class outside of the package will be able to subclass us,
// and we provide the proper builder for the subclasses we implement.
@SuppressWarnings("unchecked")
T map = (T) builder.build();
return map;
}
@Override
public T deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
JsonDeserializer<Object> deserializer = ctxt.findRootValueDeserializer(ctxt.constructType(byte[].class));
byte[] bytes = (byte[]) deserializer.deserialize(p, ctxt);
return deserialize(bytes);
}
@Override
public Collection<Object> deserialize(JsonParser p, DeserializationContext ctxt,
Collection<Object> result)
throws IOException {
// Ok: must point to START_ARRAY (or equivalent)
if (!p.isExpectedStartArrayToken()) {
return result;
}
// [databind#631]: Assign current value, to be accessible by custom serializers
p.setCurrentValue(result);
JsonDeserializer<Object> valueDes = _valueDeserializer;
final TypeDeserializer typeDeser = _valueTypeDeserializer;
CollectionReferringAccumulator referringAccumulator =
(valueDes.getObjectIdReader() == null) ? null :
new CollectionReferringAccumulator(_containerType.getContentType().getRawClass(), result);
JsonToken t;
while ((t = p.nextToken()) != JsonToken.END_ARRAY) {
try {
Object value;
if (t == JsonToken.VALUE_NULL) {
if (_skipNullValues) {
continue;
}
value = _nullProvider.getNullValue(ctxt);
} else if (typeDeser == null) {
value = valueDes.deserialize(p, ctxt);
} else {
value = valueDes.deserializeWithType(p, ctxt, typeDeser);
}
if (referringAccumulator != null) {
referringAccumulator.add(value);
} else {
result.add(value);
}
} catch (UnresolvedForwardReference reference) {
if (referringAccumulator == null) {
throw JsonMappingException
.from(p, "Unresolved forward reference but no identity info", reference);
}
ReadableObjectId.Referring ref = referringAccumulator.handleUnresolvedReference(reference);
reference.getRoid().appendReferring(ref);
} catch (Exception e) {
boolean wrap = (ctxt == null) || ctxt.isEnabled(DeserializationFeature.WRAP_EXCEPTIONS);
if (!wrap) {
ClassUtil.throwIfRTE(e);
}
throw JsonMappingException.wrapWithPath(e, result, result.size());
}
}
return result;
}