Just for the sake of experimentation, I've cobbled together the following
wrapper class:
class AnnotatedJavaType extends JavaType implements AnnotatedElement {
private final JavaType base;
private final Annotation[] annotations;
AnnotatedJavaType(JavaType base, Annotation[] annotations) { ... }
//all methods simply delegate to this.base
}
And the corresponding TypeFactory wrapper:
class AnnotatedTypeFactory {
JavaType construct(AnnotatedType type, TypeFactory typeFactory) {
if (type instanceof AnnotatedParameterizedType) {
JavaType[] args = Arrays.stream(((AnnotatedParameterizedType) type).
getAnnotatedActualTypeArguments())
.map(arg -> fromJavaType(arg, typeFactory))
.toArray(JavaType[]::new);
TypeBindings bindings = TypeBindings.create(ClassUtils.getRawType(type
.getType()), args);
return new AnnotatedJavaType(typeFactory.constructType(type.getType(),
bindings), type.getAnnotations());
}
//handle wildcards, arrays, variables in the similar fashion
return new AnnotatedJavaType(typeFactory.constructType(type.getType()),
type.getAnnotations());
}
}
Amusingly enough, it works! I'd never keep it in my code base, but it was
an interesting experiment.
If the functionality I'm after is impossible (and I *really* hope it is
*not*), would you be open to a contribution? I'd of course need some
consultation/guidance on the approach, but would be happy to develop it.
On Wednesday, December 27, 2017 at 11:34:37 AM UTC+1, Bojan Tomic wrote:
>
> I have a rather exotic use-case that I have to support. Types annotated
> with @Id need custom deserialization logic, e.g. the value should be
> Base64 decoded before deserializing it (not the only case).
>
> This means a type such as List<@Id Key> will be represented as a list of
> Base64 Strings that I deserialize using my custom logic.
>
> I originally have an AnnotatedType that I convert to JavaType using
> TypeFactory.constructType(annotatedType.getType()) prior to
> deserialization, which of course looses all the annotations.
> Later, in my custom Deserializers instance, in its various
> findXXXDeserializer methods, I have no way to find the correct
> deserializer as the annotations needed for the decision are gone...
>
> I was hoping the JDK8 module would have it's own TypeFactory-like
> mechanism to construct JavaType subclasses that preserve the annotations
> from AnnotatedTypes (e.g.
> AnnotatedTypeFactory.constructType(annotatedType)), but it doesn't seem
> to be the case.
>
> Is there any way at all to implement what I'm after?
>
--
You received this message because you are subscribed to the Google Groups
"jackson-user" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To post to this group, send email to [email protected].
For more options, visit https://groups.google.com/d/optout.
