use of io.micronaut.context.annotation.Type in project micronaut-core by micronaut-projects.
the class ObjectMapperFactory method objectMapper.
/**
* Builds the core Jackson {@link ObjectMapper} from the optional configuration and {@link JsonFactory}.
*
* @param jacksonConfiguration The configuration
* @param jsonFactory The JSON factory
* @return The {@link ObjectMapper}
*/
@Singleton
@Primary
@Named("json")
@BootstrapContextCompatible
public ObjectMapper objectMapper(@Nullable JacksonConfiguration jacksonConfiguration, @Nullable JsonFactory jsonFactory) {
ObjectMapper objectMapper = new ObjectMapper(jsonFactory, null, new DefaultDeserializationContext.Impl(new ResilientBeanDeserializerFactory(new DeserializerFactoryConfig())));
final boolean hasConfiguration = jacksonConfiguration != null;
if (!hasConfiguration || jacksonConfiguration.isModuleScan()) {
objectMapper.findAndRegisterModules();
}
objectMapper.registerModules(jacksonModules);
SimpleModule module = new SimpleModule(MICRONAUT_MODULE);
for (JsonSerializer serializer : serializers) {
Class<? extends JsonSerializer> type = serializer.getClass();
Type annotation = type.getAnnotation(Type.class);
if (annotation != null) {
Class[] value = annotation.value();
for (Class aClass : value) {
module.addSerializer(aClass, serializer);
}
} else {
Optional<Class> targetType = GenericTypeUtils.resolveSuperGenericTypeArgument(type);
if (targetType.isPresent()) {
module.addSerializer(targetType.get(), serializer);
} else {
module.addSerializer(serializer);
}
}
}
for (JsonDeserializer deserializer : deserializers) {
Class<? extends JsonDeserializer> type = deserializer.getClass();
Type annotation = type.getAnnotation(Type.class);
if (annotation != null) {
Class[] value = annotation.value();
for (Class aClass : value) {
module.addDeserializer(aClass, deserializer);
}
} else {
Optional<Class> targetType = GenericTypeUtils.resolveSuperGenericTypeArgument(type);
targetType.ifPresent(aClass -> module.addDeserializer(aClass, deserializer));
}
}
if (hasConfiguration && jacksonConfiguration.isTrimStrings()) {
module.addDeserializer(String.class, new StringDeserializer() {
@Override
public String deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
String value = super.deserialize(p, ctxt);
return StringUtils.trimToNull(value);
}
});
}
for (KeyDeserializer keyDeserializer : keyDeserializers) {
Class<? extends KeyDeserializer> type = keyDeserializer.getClass();
Type annotation = type.getAnnotation(Type.class);
if (annotation != null) {
Class[] value = annotation.value();
for (Class clazz : value) {
module.addKeyDeserializer(clazz, keyDeserializer);
}
}
}
objectMapper.registerModule(module);
for (BeanSerializerModifier beanSerializerModifier : beanSerializerModifiers) {
objectMapper.setSerializerFactory(objectMapper.getSerializerFactory().withSerializerModifier(beanSerializerModifier));
}
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
objectMapper.configure(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS, true);
if (hasConfiguration) {
ObjectMapper.DefaultTyping defaultTyping = jacksonConfiguration.getDefaultTyping();
if (defaultTyping != null) {
objectMapper.activateDefaultTyping(objectMapper.getPolymorphicTypeValidator(), defaultTyping);
}
JsonInclude.Include include = jacksonConfiguration.getSerializationInclusion();
if (include != null) {
objectMapper.setSerializationInclusion(include);
}
String dateFormat = jacksonConfiguration.getDateFormat();
if (dateFormat != null) {
objectMapper.setDateFormat(new SimpleDateFormat(dateFormat));
}
Locale locale = jacksonConfiguration.getLocale();
if (locale != null) {
objectMapper.setLocale(locale);
}
TimeZone timeZone = jacksonConfiguration.getTimeZone();
if (timeZone != null) {
objectMapper.setTimeZone(timeZone);
}
PropertyNamingStrategy propertyNamingStrategy = jacksonConfiguration.getPropertyNamingStrategy();
if (propertyNamingStrategy != null) {
objectMapper.setPropertyNamingStrategy(propertyNamingStrategy);
}
jacksonConfiguration.getSerializationSettings().forEach(objectMapper::configure);
jacksonConfiguration.getDeserializationSettings().forEach(objectMapper::configure);
jacksonConfiguration.getMapperSettings().forEach(objectMapper::configure);
jacksonConfiguration.getParserSettings().forEach(objectMapper::configure);
jacksonConfiguration.getGeneratorSettings().forEach(objectMapper::configure);
}
return objectMapper;
}
use of io.micronaut.context.annotation.Type in project helidon by oracle.
the class MicronautCdiExtension method processTypes.
/**
* Construct a list of Micronaut interceptors to execute on each CDI method.
* In case a Micronaut bean definition is available for the CDI bean (which should be for application, as
* the CDI annotation processor should be used, and it adds CDI beans as Micronaut beans), the information
* is combined from Micronaut and CDI bean definitions.
*
* @param event CDI event
*/
@SuppressWarnings("unchecked")
void processTypes(@Priority(PLATFORM_AFTER) @Observes ProcessAnnotatedType<?> event) {
Set<Class<?>> classInterceptors = new HashSet<>();
Map<Method, Set<Class<?>>> allMethodInterceptors = new HashMap<>();
List<MicronautBean> miBeans = unprocessedBeans.remove(event.getAnnotatedType().getJavaClass());
if (miBeans != null && miBeans.size() > 0) {
BeanDefinitionReference<?> miBean = findMicronautBeanDefinition(miBeans);
// add all interceptors that are seen based on Micronaut
findMicronautInterceptors(classInterceptors, allMethodInterceptors, miBean);
}
// find all annotations that have meta annotation Around and collect their Type list to add as interceptors
addMicronautInterceptors(classInterceptors, event.getAnnotatedType().getAnnotations());
// for each method, find the same (Around, collect Type), and add the interceptor binding for Micronaut interceptors
// CDI interceptors will be automatic
event.configureAnnotatedType().methods().forEach(method -> {
Method javaMethod = method.getAnnotated().getJavaMember();
Set<Class<?>> methodInterceptors = allMethodInterceptors.computeIfAbsent(javaMethod, it -> new HashSet<>());
methodInterceptors.addAll(classInterceptors);
addMicronautInterceptors(methodInterceptors, method.getAnnotated().getAnnotations());
if (!methodInterceptors.isEmpty()) {
// now I have a set of micronaut interceptors that are needed for this method
method.add(MicronautIntercepted.Literal.INSTANCE);
Set<Class<? extends MethodInterceptor<?, ?>>> interceptors = new HashSet<>();
methodInterceptors.forEach(it -> interceptors.add((Class<? extends MethodInterceptor<?, ?>>) it));
methods.computeIfAbsent(javaMethod, theMethod -> MethodInterceptorMetadata.create(method.getAnnotated(), executableMethodCache.get(theMethod))).addInterceptors(interceptors);
}
});
}
use of io.micronaut.context.annotation.Type in project micronaut-core by micronaut-projects.
the class InterceptorChain method resolveInterceptorsInternal.
private static Interceptor[] resolveInterceptorsInternal(ExecutableMethod<?, ?> method, Class<? extends Annotation> annotationType, Interceptor[] interceptors, @NonNull ClassLoader classLoader) {
List<Class<? extends Annotation>> annotations = method.getAnnotationTypesByStereotype(annotationType, classLoader);
Set<Class> applicableClasses = new HashSet<>();
for (Class<? extends Annotation> aClass : annotations) {
if (annotationType == Around.class && aClass.getAnnotation(Around.class) == null && aClass.getAnnotation(Introduction.class) != null) {
continue;
} else if (annotationType == Introduction.class && aClass.getAnnotation(Introduction.class) == null && aClass.getAnnotation(Around.class) != null) {
continue;
}
Type typeAnn = aClass.getAnnotation(Type.class);
if (typeAnn != null) {
applicableClasses.addAll(Arrays.asList(typeAnn.value()));
}
}
Interceptor[] interceptorArray = Arrays.stream(interceptors).filter(i -> applicableClasses.stream().anyMatch(t -> t.isInstance(i))).toArray(Interceptor[]::new);
OrderUtil.sort(interceptorArray);
return interceptorArray;
}
Aggregations