Move away from annotation API that now returns defaults (micronaut-pr…

…ojects#8776)
glorrian · Feb 14, 2023 · 2be0a44 · 2be0a44
1 parent 0edb327
commit 2be0a44
Show file tree

Hide file tree

Showing 5 changed files with 26 additions and 25 deletions.
diff --git a/context/src/main/java/io/micronaut/scheduling/processor/ScheduledMethodProcessor.java b/context/src/main/java/io/micronaut/scheduling/processor/ScheduledMethodProcessor.java
@@ -91,21 +91,21 @@ public void process(BeanDefinition<?> beanDefinition, ExecutableMethod<?, ?> met
 
         List<AnnotationValue<Scheduled>> scheduledAnnotations = method.getAnnotationValuesByType(Scheduled.class);
         for (AnnotationValue<Scheduled> scheduledAnnotation : scheduledAnnotations) {
-            String fixedRate = scheduledAnnotation.get(MEMBER_FIXED_RATE, String.class).orElse(null);
+            String fixedRate = scheduledAnnotation.stringValue(MEMBER_FIXED_RATE).orElse(null);
 
-            String initialDelayStr = scheduledAnnotation.get(MEMBER_INITIAL_DELAY, String.class).orElse(null);
+            String initialDelayStr = scheduledAnnotation.stringValue(MEMBER_INITIAL_DELAY).orElse(null);
             Duration initialDelay = null;
             if (StringUtils.hasText(initialDelayStr)) {
                 initialDelay = conversionService.convert(initialDelayStr, Duration.class).orElseThrow(() ->
                     new SchedulerConfigurationException(method, "Invalid initial delay definition: " + initialDelayStr)
                 );
             }
 
-            String scheduler = scheduledAnnotation.get(MEMBER_SCHEDULER, String.class).orElse(TaskExecutors.SCHEDULED);
+            String scheduler = scheduledAnnotation.stringValue(MEMBER_SCHEDULER).orElse(TaskExecutors.SCHEDULED);
             Optional<TaskScheduler> optionalTaskScheduler = beanContext
                     .findBean(TaskScheduler.class, Qualifiers.byName(scheduler));
 
-            if (!optionalTaskScheduler.isPresent()) {
+            if (optionalTaskScheduler.isEmpty()) {
                 optionalTaskScheduler = beanContext.findBean(ExecutorService.class, Qualifiers.byName(scheduler))
                         .filter(ScheduledExecutorService.class::isInstance)
                         .map(ScheduledExecutorTaskScheduler::new);
@@ -142,9 +142,9 @@ public void process(BeanDefinition<?> beanDefinition, ExecutableMethod<?, ?> met
                 }
             };
 
-            String cronExpr = scheduledAnnotation.get(MEMBER_CRON, String.class, null);
-            String zoneIdStr = scheduledAnnotation.get(MEMBER_ZONE_ID, String.class, null);
-            String fixedDelay = scheduledAnnotation.get(MEMBER_FIXED_DELAY, String.class).orElse(null);
+            String cronExpr = scheduledAnnotation.stringValue(MEMBER_CRON).orElse(null);
+            String zoneIdStr = scheduledAnnotation.stringValue(MEMBER_ZONE_ID).orElse(null);
+            String fixedDelay = scheduledAnnotation.stringValue(MEMBER_FIXED_DELAY).orElse(null);
 
             if (StringUtils.isNotEmpty(cronExpr)) {
                 if (LOG.isDebugEnabled()) {

diff --git a/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java b/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java
@@ -1147,7 +1147,7 @@ public final <T> T getRequiredValue(Class<T> type) {
      * @throws IllegalStateException If no member is available that conforms to the given name and type
      */
     @NonNull
-    public final <T> T getRequiredValue(String member, Class<T> type) {
+    public final <T> T  getRequiredValue(String member, Class<T> type) {
         return get(member, ConversionContext.of(type)).orElseThrow(() -> new IllegalStateException("No value available for annotation member @" + annotationName + "[" + member + "] of type: " + type));
     }
 

diff --git a/inject/src/main/java/io/micronaut/context/RequiresCondition.java b/inject/src/main/java/io/micronaut/context/RequiresCondition.java
@@ -528,13 +528,12 @@ private boolean matchesPresenceOfClasses(ConditionContext context, AnnotationVal
 
     private boolean matchesPresenceOfEntities(ConditionContext context, AnnotationValue<Requires> annotationValue) {
         if (annotationValue.contains(MEMBER_ENTITIES)) {
-            Optional<AnnotationClassValue[]> classNames = annotationValue.get(MEMBER_ENTITIES, AnnotationClassValue[].class);
-            if (classNames.isPresent()) {
+            AnnotationClassValue<?>[] classNames = annotationValue.annotationClassValues(MEMBER_ENTITIES);
+            if (ArrayUtils.isNotEmpty(classNames)) {
                 BeanContext beanContext = context.getBeanContext();
                 if (beanContext instanceof ApplicationContext) {
                     ApplicationContext applicationContext = (ApplicationContext) beanContext;
-                    final AnnotationClassValue<?>[] classValues = classNames.get();
-                    for (AnnotationClassValue<?> classValue : classValues) {
+                    for (AnnotationClassValue<?> classValue : classNames) {
                         final Optional<? extends Class<?>> entityType = classValue.getType();
                         if (entityType.isEmpty()) {
                             context.fail("Annotation type [" + classValue.getName() + "] not present on classpath");

diff --git a/jackson-databind/src/main/java/io/micronaut/jackson/codec/JacksonFeatures.java b/jackson-databind/src/main/java/io/micronaut/jackson/codec/JacksonFeatures.java
@@ -58,31 +58,31 @@ public static JacksonFeatures fromAnnotation(AnnotationValue<io.micronaut.jackso
         JacksonFeatures jacksonFeatures = new JacksonFeatures();
 
 
-        SerializationFeature[] enabledSerializationFeatures = jacksonFeaturesAnn.get("enabledSerializationFeatures", SerializationFeature[].class).orElse(null);
-        if (enabledSerializationFeatures != null) {
+        SerializationFeature[] enabledSerializationFeatures = jacksonFeaturesAnn.enumValues("enabledSerializationFeatures", SerializationFeature.class);
+        if (ArrayUtils.isNotEmpty(enabledSerializationFeatures)) {
             for (SerializationFeature serializationFeature : enabledSerializationFeatures) {
                 jacksonFeatures.addFeature(serializationFeature, true);
             }
         }
 
-        DeserializationFeature[] enabledDeserializationFeatures = jacksonFeaturesAnn.get("enabledDeserializationFeatures", DeserializationFeature[].class).orElse(null);
+        DeserializationFeature[] enabledDeserializationFeatures = jacksonFeaturesAnn.enumValues("enabledDeserializationFeatures", DeserializationFeature.class);
 
-        if (enabledDeserializationFeatures != null) {
+        if (ArrayUtils.isNotEmpty(enabledDeserializationFeatures)) {
             for (DeserializationFeature deserializationFeature : enabledDeserializationFeatures) {
                 jacksonFeatures.addFeature(deserializationFeature, true);
             }
         }
 
-        SerializationFeature[] disabledSerializationFeatures = jacksonFeaturesAnn.get("disabledSerializationFeatures", SerializationFeature[].class).orElse(null);
-        if (disabledSerializationFeatures != null) {
+        SerializationFeature[] disabledSerializationFeatures = jacksonFeaturesAnn.enumValues("disabledSerializationFeatures", SerializationFeature.class);
+        if (ArrayUtils.isNotEmpty(disabledSerializationFeatures)) {
             for (SerializationFeature serializationFeature : disabledSerializationFeatures) {
                 jacksonFeatures.addFeature(serializationFeature, false);
             }
         }
 
-        DeserializationFeature[] disabledDeserializationFeatures = jacksonFeaturesAnn.get("disabledDeserializationFeatures", DeserializationFeature[].class).orElse(null);
+        DeserializationFeature[] disabledDeserializationFeatures = jacksonFeaturesAnn.enumValues("disabledDeserializationFeatures", DeserializationFeature.class);
 
-        if (disabledDeserializationFeatures != null) {
+        if (ArrayUtils.isNotEmpty(disabledDeserializationFeatures)) {
             for (DeserializationFeature feature : disabledDeserializationFeatures) {
                 jacksonFeatures.addFeature(feature, false);
             }

diff --git a/retry/src/main/java/io/micronaut/retry/intercept/AnnotationRetryStateBuilder.java b/retry/src/main/java/io/micronaut/retry/intercept/AnnotationRetryStateBuilder.java
@@ -62,13 +62,15 @@ class AnnotationRetryStateBuilder implements RetryStateBuilder {
     public RetryState build() {
         AnnotationValue<Retryable> retry = annotationMetadata.findAnnotation(Retryable.class)
                                                              .orElseThrow(() -> new IllegalStateException("Missing @Retryable annotation"));
-        int attempts = retry.get(ATTEMPTS, Integer.class).orElse(DEFAULT_RETRY_ATTEMPTS);
+        int attempts = retry.intValue(ATTEMPTS).orElse(DEFAULT_RETRY_ATTEMPTS);
         Duration delay = retry.get(DELAY, Duration.class).orElse(Duration.ofSeconds(1));
-        Class<? extends RetryPredicate> predicateClass = retry.get(PREDICATE, Class.class)
-                                                              .orElse(DefaultRetryPredicate.class);
+        @SuppressWarnings("unchecked")
+        Class<? extends RetryPredicate> predicateClass = (Class<? extends RetryPredicate>) retry.classValue(PREDICATE).orElse(DefaultRetryPredicate.class);
         RetryPredicate predicate = createPredicate(predicateClass, retry);
-        Class<? extends Throwable> capturedException = retry.get(CAPTUREDEXCEPTION, Class.class)
-                                                            .orElse(RuntimeException.class);
+        @SuppressWarnings("unchecked")
+        Class<? extends RuntimeException> capturedException = (Class<? extends RuntimeException>) retry
+                                            .classValue(CAPTUREDEXCEPTION)
+                                            .orElse(RuntimeException.class);
 
         return new SimpleRetry(
             attempts,