Application context improvements (#12259)

Author: dstepanov

context/src/main/java/io/micronaut/runtime/Micronaut.java

@@ -24,7 +24,7 @@
 import io.micronaut.context.banner.ResourceBanner;
 import io.micronaut.context.env.Environment;
 import io.micronaut.context.env.PropertySource;
-import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.Nullable;
 import io.micronaut.core.naming.Described;
 import io.micronaut.runtime.exceptions.ApplicationStartupException;
@@ -47,6 +47,7 @@
  * @author Graeme Rocher
  * @since 1.0
  */
+@NullMarked
 public class Micronaut extends DefaultApplicationContextBuilder implements ApplicationContextBuilder  {
     private static final String BANNER_NAME = "micronaut-banner.txt";
     private static final Logger LOG = LoggerFactory.getLogger(Micronaut.class);
@@ -65,7 +66,7 @@ protected Micronaut() {
      */
     @Override
     @SuppressWarnings({"java:S1181", "java:S3776", "java:S1141"})
-    public @NonNull ApplicationContext start() {
+    public ApplicationContext start() {
         long start = System.nanoTime();
         printBanner();
         ApplicationContext applicationContext = super.build();
@@ -195,17 +196,17 @@ private static long elapsedMillis(long startNanos) {
     }
 
     @Override
-    public @NonNull Micronaut include(@Nullable String... configurations) {
+    public Micronaut include(@Nullable String... configurations) {
         return (Micronaut) super.include(configurations);
     }
 
     @Override
-    public @NonNull Micronaut exclude(@Nullable String... configurations) {
+    public Micronaut exclude(@Nullable String... configurations) {
         return (Micronaut) super.exclude(configurations);
     }
 
     @Override
-    public @NonNull Micronaut banner(boolean isEnabled) {
+    public Micronaut banner(boolean isEnabled) {
         return (Micronaut) super.banner(isEnabled);
     }
 
@@ -215,7 +216,7 @@ private static long elapsedMillis(long startNanos) {
      * @param classes The application
      * @return The classes
      */
-    public @NonNull Micronaut classes(@Nullable Class<?>... classes) {
+    public Micronaut classes(@Nullable Class<?>... classes) {
         if (classes != null) {
             for (Class<?> aClass : classes) {
                 packages(aClass.getPackage().getName());
@@ -225,67 +226,67 @@ private static long elapsedMillis(long startNanos) {
     }
 
     @Override
-    public @NonNull Micronaut properties(@Nullable Map<String, Object> properties) {
+    public Micronaut properties(@Nullable Map<String, Object> properties) {
         return (Micronaut) super.properties(properties);
     }
 
     @Override
-    public @NonNull Micronaut singletons(Object... beans) {
+    public Micronaut singletons(Object... beans) {
         return (Micronaut) super.singletons(beans);
     }
 
     @Override
-    public Micronaut beanDefinitions(@NonNull RuntimeBeanDefinition<?>... definitions) {
+    public Micronaut beanDefinitions(RuntimeBeanDefinition<?>... definitions) {
         return (Micronaut) super.beanDefinitions(definitions);
     }
 
     @Override
-    public @NonNull Micronaut propertySources(@Nullable PropertySource... propertySources) {
+    public Micronaut propertySources(@Nullable PropertySource... propertySources) {
         return (Micronaut) super.propertySources(propertySources);
     }
 
     @Override
-    public @NonNull Micronaut environmentPropertySource(boolean environmentPropertySource) {
+    public Micronaut environmentPropertySource(boolean environmentPropertySource) {
         return (Micronaut) super.environmentPropertySource(environmentPropertySource);
     }
 
     @Override
-    public @NonNull Micronaut environmentVariableIncludes(@Nullable String... environmentVariables) {
+    public Micronaut environmentVariableIncludes(@Nullable String... environmentVariables) {
         return (Micronaut) super.environmentVariableIncludes(environmentVariables);
     }
 
     @Override
-    public @NonNull Micronaut environmentVariableExcludes(@Nullable String... environmentVariables) {
+    public Micronaut environmentVariableExcludes(@Nullable String... environmentVariables) {
         return (Micronaut) super.environmentVariableExcludes(environmentVariables);
     }
 
     @Override
-    public @NonNull Micronaut mainClass(Class<?> mainClass) {
+    public Micronaut mainClass(@Nullable Class<?> mainClass) {
         return (Micronaut) super.mainClass(mainClass);
     }
 
     @Override
-    public @NonNull Micronaut classLoader(ClassLoader classLoader) {
+    public Micronaut classLoader(@Nullable ClassLoader classLoader) {
         return (Micronaut) super.classLoader(classLoader);
     }
 
     @Override
-    public @NonNull Micronaut args(@Nullable String... args) {
+    public Micronaut args(@Nullable String... args) {
         return (Micronaut) super.args(args);
     }
 
     @Override
-    public @NonNull Micronaut environments(@Nullable String... environments) {
+    public Micronaut environments(@Nullable String... environments) {
         return (Micronaut) super.environments(environments);
     }
 
     @Override
-    public @NonNull Micronaut defaultEnvironments(@Nullable String... environments) {
+    public Micronaut defaultEnvironments(@Nullable String... environments) {
         return (Micronaut) super.defaultEnvironments(environments);
     }
 
     @Override
-    public @NonNull Micronaut packages(@Nullable String... packages) {
+    public Micronaut packages(@Nullable String... packages) {
         return (Micronaut) super.packages(packages);
     }
 
@@ -356,7 +357,7 @@ public static ApplicationContext run(Class<?>[] classes, String... args) {
      */
     protected void handleStartupException(Environment environment, Throwable exception) {
         Function<Throwable, Integer> exitCodeMapper = exitHandlers.computeIfAbsent(exception.getClass(), exceptionType -> (throwable -> 1));
-        Integer code = exitCodeMapper.apply(exception);
+        int code = exitCodeMapper.apply(exception);
         if (code > 0 && !environment.getActiveNames().contains(Environment.TEST)) {
             if (LOG.isErrorEnabled()) {
                 LOG.error("Error starting Micronaut server: {}", exception.getMessage(), exception);
@@ -375,8 +376,7 @@ private void printBanner() {
         resolveBanner(out).print();
     }
 
-    @NonNull
-    private Banner resolveBanner(@NonNull PrintStream out) {
+    private Banner resolveBanner(PrintStream out) {
         return getResourceLoader().getResource(BANNER_NAME)
             .map(resource -> (Banner) new ResourceBanner(resource, out))
             .orElseGet(() -> new MicronautBanner(out));

core/src/main/java/io/micronaut/core/io/scan/ClassClassPathResourceLoader.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2017-2025 original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.micronaut.core.io.scan;
+
+import io.micronaut.core.annotation.Experimental;
+import io.micronaut.core.io.ResourceLoader;
+import org.jspecify.annotations.NullMarked;
+
+import java.io.InputStream;
+import java.net.URL;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+/**
+ * A simple {@link ClassPathResourceLoader} that uses a {@link Class}.
+ *
+ * @author Denis Stepanov
+ * @since 5.0
+ */
+@Experimental
+@NullMarked
+public class ClassClassPathResourceLoader implements ClassPathResourceLoader {
+
+    private final Class<?> clazz;
+    private final String basePath;
+
+    public ClassClassPathResourceLoader(Class<?> clazz) {
+        this(clazz, "");
+    }
+
+    public ClassClassPathResourceLoader(Class<?> clazz, String basePath) {
+        this.clazz = clazz;
+        this.basePath = basePath;
+    }
+
+    @Override
+    public ClassLoader getClassLoader() {
+        return clazz.getClassLoader();
+    }
+
+    @Override
+    public Optional<InputStream> getResourceAsStream(String path) {
+        return Optional.ofNullable(clazz.getResourceAsStream(basePath + path));
+    }
+
+    @Override
+    public Optional<URL> getResource(String path) {
+        return Optional.ofNullable(clazz.getResource(path));
+    }
+
+    @Override
+    public Stream<URL> getResources(String name) {
+        return clazz.getClassLoader().resources(name);
+    }
+
+    @Override
+    public ResourceLoader forBase(String basePath) {
+        return new ClassClassPathResourceLoader(clazz, this.basePath + basePath);
+    }
+}

core/src/main/java/io/micronaut/core/io/scan/ClassLoaderClassPathResourceLoader.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2017-2025 original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.micronaut.core.io.scan;
+
+import io.micronaut.core.annotation.Experimental;
+import io.micronaut.core.io.ResourceLoader;
+import org.jspecify.annotations.NullMarked;
+
+import java.io.InputStream;
+import java.net.URL;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+/**
+ * A simple {@link ClassPathResourceLoader} that uses a {@link ClassLoader}.
+ *
+ * @author Denis Stepanov
+ * @since 5.0
+ */
+@Experimental
+@NullMarked
+public final class ClassLoaderClassPathResourceLoader implements ClassPathResourceLoader {
+
+    private final ClassLoader classLoader;
+    private final String basePath;
+
+    public ClassLoaderClassPathResourceLoader() {
+        this(ClassPathResourceLoader.defaultLoader(null).getClassLoader(), "");
+    }
+
+    public ClassLoaderClassPathResourceLoader(ClassLoader classLoader) {
+        this(classLoader, "");
+    }
+
+    public ClassLoaderClassPathResourceLoader(ClassLoader classLoader, String basePath) {
+        this.classLoader = classLoader;
+        this.basePath = basePath;
+    }
+
+    @Override
+    public ClassLoader getClassLoader() {
+        return classLoader;
+    }
+
+    @Override
+    public Optional<InputStream> getResourceAsStream(String path) {
+        return Optional.ofNullable(classLoader.getResourceAsStream(basePath + path));
+    }
+
+    @Override
+    public Optional<URL> getResource(String path) {
+        return Optional.ofNullable(classLoader.getResource(path));
+    }
+
+    @Override
+    public Stream<URL> getResources(String name) {
+        return classLoader.resources(name);
+    }
+
+    @Override
+    public ResourceLoader forBase(String basePath) {
+        return new ClassLoaderClassPathResourceLoader(classLoader, this.basePath + basePath);
+    }
+}

core/src/main/java/io/micronaut/core/io/scan/ClassPathResourceLoader.java

@@ -17,6 +17,7 @@
 
 import io.micronaut.core.io.ResourceLoader;
 
+import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.Nullable;
 
 /**
@@ -26,6 +27,7 @@
  * @author Graeme Rocher
  * @since 1.0
  */
+@NullMarked
 public interface ClassPathResourceLoader extends ResourceLoader {
 
     /**