Updates to Helidon Common, Part 1 (#4693)

* Switch to System.Logger for common modules (except for reactive) * Move HelidonServiceLoader to common module. * GenericType now contains constant for String * Typo fix (Builder) * Using Weight instead of Priority in SE
helidon-io · Aug 10, 2022 · 7f758ac · 7f758ac
1 parent 0c796d1
commit 7f758ac
Show file tree

Hide file tree

Showing 175 changed files with 817 additions and 801 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -17,4 +17,10 @@ We are pleased to announce Helidon 4.0.0 a major release that includes significa
 
 ### Notable Changes
 
-- Java 19 (with Loom support) as the minimal Java version
+- Java 19 early access (with Loom support) as the minimal Java version
+- Using System.Logger instead of java util logging (incremental change)
+- `HelidonServiceLoader` is now part of `helidon-common` module
+- Introduction of `@Weight`, `Weighted` and `Weights` instead of `@Priority` and `Prioritized`, to base ordering on a double (allows to fit a component between any other two components), all modules using priority are refactored (except for MicroProfile where required by specifications).
+  - higher weight means a component is more important 
+  - moved priority related types to MP config (as that is the lowest level MP module)
+  - replaces all instances in SE that use priority with weight (no dependency on Jakarta, predictible and easy to understand behavior)
diff --git a/README.md b/README.md
@@ -23,6 +23,11 @@ Helidon supports two programming models:
 
 In either case your application is just a Java SE program.
 
+## Early access branch
+This branch requires Java 19 early access release with Loom support.
+Applications written using this version will require `--enable-preview` to be used when starting JVM.
+Kindly use latest official release to work with Java 17, unless you are interested in the newest and greatest!
+
 ## License
 
 Helidon is available under Apache License 2.0.

diff --git a/bom/pom.xml b/bom/pom.xml
@@ -606,11 +606,6 @@
                 <artifactId>helidon-common-key-util</artifactId>
                 <version>${helidon.version}</version>
             </dependency>
-            <dependency>
-                <groupId>io.helidon.common</groupId>
-                <artifactId>helidon-common-service-loader</artifactId>
-                <version>${helidon.version}</version>
-            </dependency>
             <dependency>
                 <groupId>io.helidon.common</groupId>
                 <artifactId>helidon-common-media-type</artifactId>

diff --git a/common/common/pom.xml b/common/common/pom.xml
@@ -28,6 +28,24 @@
     <artifactId>helidon-common</artifactId>
     <name>Helidon Common</name>
 
+    <properties>
+        <!-- Helidon common should be backward compatible with Java 11 -->
+        <version.java>11</version.java>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.hamcrest</groupId>
+            <artifactId>hamcrest-all</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
     <build>
         <plugins>
             <plugin>
@@ -71,17 +89,4 @@
             </plugin>
         </plugins>
     </build>
-
-    <dependencies>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.hamcrest</groupId>
-            <artifactId>hamcrest-all</artifactId>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
 </project>
diff --git a/common/common/src/main/java/io/helidon/common/Builder.java b/common/common/src/main/java/io/helidon/common/Builder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2021 Oracle and/or its affiliates.
+ * Copyright (c) 2017, 2022 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -39,7 +39,7 @@ public interface Builder<B extends Builder<B, T>, T> extends Supplier<T> {
     T build();
 
     /**
-     * Update the builder in a fluen API way.
+     * Update the builder in a fluent API way.
      *
      * @param consumer consumer of the builder instance
      * @return updated builder instance

diff --git a/common/common/src/main/java/io/helidon/common/Errors.java b/common/common/src/main/java/io/helidon/common/Errors.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2021 Oracle and/or its affiliates.
+ * Copyright (c) 2017, 2022 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,7 +20,6 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
-import java.util.logging.Logger;
 import java.util.stream.Collectors;
 
 /**
@@ -115,7 +114,7 @@ public boolean hasHint() {
      * otherwise.
      */
 
-    public boolean log(Logger logger) {
+    public boolean log(System.Logger logger) {
         if (!isEmpty()) {
             StringBuilder fatals = new StringBuilder("\n");
             StringBuilder warnings = new StringBuilder();
@@ -141,14 +140,14 @@ public boolean log(Logger logger) {
             if (hasFatal) {
                 fatals.append(warnings).append(hints);
 
-                logger.severe("Fatal issues found: " + fatals);
+                logger.log(System.Logger.Level.ERROR, "Fatal issues found: " + fatals);
             } else {
                 if (warnings.length() > 0) {
-                    logger.warning("Warnings found: \n" + warnings);
+                    logger.log(System.Logger.Level.WARNING, "Warnings found: \n" + warnings);
                 }
 
                 if (hints.length() > 0) {
-                    logger.config("Hints found: \n" + hints);
+                    logger.log(System.Logger.Level.TRACE, "Hints found: \n" + hints);
                 }
             }
 

diff --git a/common/common/src/main/java/io/helidon/common/GenericType.java b/common/common/src/main/java/io/helidon/common/GenericType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2021 Oracle and/or its affiliates.
+ * Copyright (c) 2018, 2022 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -62,6 +62,11 @@
  * @param <T> the generic type parameter
  */
 public class GenericType<T> implements Type {
+    /**
+     * Generic type for String.
+     */
+    public static final GenericType<String> STRING = GenericType.create(String.class);
+
     private final Type type;
     private final Class<?> rawType;
 

diff --git a/common/common/src/main/java/io/helidon/common/HelidonFeatures.java b/common/common/src/main/java/io/helidon/common/HelidonFeatures.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020 Oracle and/or its affiliates.
+ * Copyright (c) 2019, 2022 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,7 @@
 
 package io.helidon.common;
 
+import java.lang.System.Logger.Level;
 import java.util.Comparator;
 import java.util.EnumMap;
 import java.util.HashMap;
@@ -28,7 +29,6 @@
 import java.util.TreeSet;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
-import java.util.logging.Logger;
 import java.util.stream.Collectors;
 
 /**
@@ -56,8 +56,8 @@
  * </pre>
  */
 public final class HelidonFeatures {
-    private static final Logger LOGGER = Logger.getLogger(HelidonFeatures.class.getName());
-    private static final Logger EXPERIMENTAL = Logger.getLogger(HelidonFeatures.class.getName() + ".experimental");
+    private static final System.Logger LOGGER = System.getLogger(HelidonFeatures.class.getName());
+    private static final System.Logger EXPERIMENTAL = System.getLogger(HelidonFeatures.class.getName() + ".experimental");
     private static final AtomicBoolean PRINTED = new AtomicBoolean();
     private static final AtomicBoolean SCANNED = new AtomicBoolean();
     private static final AtomicReference<HelidonFlavor> CURRENT_FLAVOR = new AtomicReference<>();
@@ -145,16 +145,16 @@ private static void features(HelidonFlavor flavor, String version, boolean detai
 
         Set<FeatureDescriptor> features = FEATURES.get(currentFlavor);
         if (null == features) {
-            LOGGER.info("Helidon " + currentFlavor + " " + version + " has no registered features");
+            LOGGER.log(Level.INFO, "Helidon " + currentFlavor + " " + version + " has no registered features");
         } else {
             String featureString = "[" + features.stream()
                     .map(FeatureDescriptor::name)
                     .collect(Collectors.joining(", "))
                     + "]";
-            LOGGER.info("Helidon " + currentFlavor + " " + version + " features: " + featureString);
+            LOGGER.log(Level.INFO, "Helidon " + currentFlavor + " " + version + " features: " + featureString);
         }
         if (details) {
-            LOGGER.info("Detailed feature tree:");
+            LOGGER.log(Level.INFO, "Detailed feature tree:");
             FEATURES.get(currentFlavor)
                     .forEach(feature -> printDetails(feature.name(),
                                                      ROOT_FEATURE_NODES.get(currentFlavor).get(feature.path()[0]),
@@ -166,9 +166,11 @@ private static void features(HelidonFlavor flavor, String version, boolean detai
                                                            ROOT_FEATURE_NODES.get(currentFlavor).get(feature.path()[0])));
 
             if (!allExperimental.isEmpty()) {
-                EXPERIMENTAL.info("You are using experimental features. These APIs may change, please follow changelog!");
+                EXPERIMENTAL.log(Level.INFO,
+                                 "You are using experimental features. These APIs may change, please follow changelog!");
                 allExperimental
-                        .forEach(it -> EXPERIMENTAL.info("\tExperimental feature: " + it.name() + " (" + it.stringPath() + ")"));
+                        .forEach(it -> EXPERIMENTAL.log(Level.INFO,
+                                                        "\tExperimental feature: " + it.name() + " (" + it.stringPath() + ")"));
             }
         }
     }
@@ -184,20 +186,21 @@ private static void gatherExperimental(List<FeatureDescriptor> allExperimental,
      * Will scan all features and log errors and warnings for features that have a
      * native image limitation.
      * This method is automatically called when building a native image with Helidon.
+     *
      * @param classLoader to look for features in
      */
     public static void nativeBuildTime(ClassLoader classLoader) {
         scan(classLoader);
         for (FeatureDescriptor feat : ALL_FEATURES) {
             if (!feat.nativeSupported()) {
-                LOGGER.severe("Feature '" + feat.name()
-                                      + "' for path '" + feat.stringPath()
-                                      + "' IS NOT SUPPORTED in native image. Image may still build and run.");
+                LOGGER.log(Level.ERROR, "Feature '" + feat.name()
+                        + "' for path '" + feat.stringPath()
+                        + "' IS NOT SUPPORTED in native image. Image may still build and run.");
             } else {
                 if (!feat.nativeDescription().isBlank()) {
-                    LOGGER.warning("Feature '" + feat.name()
-                                           + "' for path '" + feat.stringPath()
-                                           + "' has limited support in native image: " + feat.nativeDescription());
+                    LOGGER.log(Level.WARNING, "Feature '" + feat.name()
+                            + "' for path '" + feat.stringPath()
+                            + "' has limited support in native image: " + feat.nativeDescription());
                 }
             }
         }
@@ -230,7 +233,7 @@ private static void scan(ClassLoader classLoader) {
             Set<FeatureDescriptor> featureDescriptors = FeatureCatalog.get(packageName);
             if (featureDescriptors == null) {
                 if (packageName.startsWith("io.helidon.")) {
-                    LOGGER.fine("No catalog entry for package " + packageName);
+                    LOGGER.log(Level.TRACE, "No catalog entry for package " + packageName);
                 }
             } else {
                 featureDescriptors.forEach(HelidonFeatures::register);
@@ -244,15 +247,15 @@ private static void scan(ClassLoader classLoader) {
                 if (feature.nativeSupported()) {
                     String desc = feature.nativeDescription();
                     if (desc != null && !desc.isBlank()) {
-                        LOGGER.warning("Native image for feature "
+                        LOGGER.log(Level.WARNING, "Native image for feature "
                                                + feature.name()
                                                + "("
                                                + feature.stringPath()
                                                + "): "
                                                + desc);
                     }
                 } else {
-                    LOGGER.severe("You are using a feature not supported in native image: "
+                    LOGGER.log(Level.ERROR, "You are using a feature not supported in native image: "
                                           + feature.name()
                                           + "("
                                           + feature.stringPath()