#195 - Add @component + @InjectModule(ignoreSingleton = true) ... additional approach co-exist with other DI libraries

Author: rbygrave

blackbox-test-inject/src/main/java/org/example/myapp/r4j/MyExample.java

@@ -1,9 +1,9 @@
 package org.example.myapp.r4j;
 
-import jakarta.inject.Singleton;
+import io.avaje.inject.Component;
 import org.example.myapp.resilience4j.MyRetry;
 
-@Singleton
+@Component
 public class MyExample {
 
   public int barfCounter;

blackbox-test-inject/src/main/java/org/example/myapp/resilience4j/RetryProvider.java

@@ -1,20 +1,20 @@
 package org.example.myapp.resilience4j;
 
+import io.avaje.inject.Component;
 import io.avaje.inject.aop.AspectProvider;
 import io.avaje.inject.aop.Fallback;
 import io.avaje.inject.aop.Invocation;
 import io.avaje.inject.aop.MethodInterceptor;
 import io.github.resilience4j.retry.Retry;
 import io.github.resilience4j.retry.RetryConfig;
-import jakarta.inject.Singleton;
 
 import java.lang.reflect.Method;
 import java.time.Duration;
 import java.time.format.DateTimeParseException;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Supplier;
 
-@Singleton
+@Component
 public class RetryProvider implements AspectProvider<MyRetry> {
 
   @Override

inject-generator/src/main/java/io/avaje/inject/generator/MetaDataOrdering.java

@@ -134,7 +134,7 @@ private void checkMissingDependencies(MetaData metaData) {
    */
   private void warnOnDependencies() {
     if (!missingDependencyTypes.isEmpty()) {
-      context.logError("Dependencies %s are not provided - missing @Singleton or @Factory/@Bean or specify external dependency via @InjectModule requires attribute", missingDependencyTypes);
+      context.logError("Dependencies %s are not provided - missing @Singleton, @Component, @Factory/@Bean or specify external dependency via @InjectModule requires attribute", missingDependencyTypes);
     } else {
       if (!queue.isEmpty()) {
         context.logWarn("There are " + queue.size() + " beans with unsatisfied dependencies (assuming external dependencies)");

inject-generator/src/main/java/io/avaje/inject/generator/Processor.java

@@ -1,5 +1,6 @@
 package io.avaje.inject.generator;
 
+import io.avaje.inject.Component;
 import io.avaje.inject.Factory;
 import io.avaje.inject.InjectModule;
 import io.avaje.inject.Prototype;
@@ -55,24 +56,19 @@ public Set<String> getSupportedAnnotationTypes() {
 
   @Override
   public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
-    Set<? extends Element> controllers = Collections.emptySet();
+    readScopes(roundEnv.getElementsAnnotatedWith(Scope.class));
+    readModule(roundEnv);
+    readChangedBeans(roundEnv.getElementsAnnotatedWith(Factory.class), true);
+    if (defaultScope.includeSingleton()) {
+      readChangedBeans(roundEnv.getElementsAnnotatedWith(Singleton.class), false);
+    }
+    readChangedBeans(roundEnv.getElementsAnnotatedWith(Component.class), false);
+    readChangedBeans(roundEnv.getElementsAnnotatedWith(Prototype.class), false);
     TypeElement typeElement = elementUtils.getTypeElement(Constants.CONTROLLER);
     if (typeElement != null) {
-      controllers = roundEnv.getElementsAnnotatedWith(typeElement);
+      readChangedBeans(roundEnv.getElementsAnnotatedWith(typeElement), false);
     }
-
-    Set<? extends Element> factoryBeans = roundEnv.getElementsAnnotatedWith(Factory.class);
-    Set<? extends Element> beans = roundEnv.getElementsAnnotatedWith(Singleton.class);
-    Set<? extends Element> prototypes = roundEnv.getElementsAnnotatedWith(Prototype.class);
-    Set<? extends Element> scopes = roundEnv.getElementsAnnotatedWith(Scope.class);
-    Set<? extends Element> proxies = roundEnv.getElementsAnnotatedWith(Proxy.class);
-    readScopes(scopes);
-    readModule(roundEnv);
-    readChangedBeans(factoryBeans, true);
-    readChangedBeans(beans, false);
-    readChangedBeans(prototypes, false);
-    readChangedBeans(controllers, false);
-    readChangedBeans(proxies, false);
+    readChangedBeans(roundEnv.getElementsAnnotatedWith(Proxy.class), false);
     allScopes.readBeans(roundEnv);
     defaultScope.write(roundEnv.processingOver());
     allScopes.write(roundEnv.processingOver());

inject-generator/src/main/java/io/avaje/inject/generator/ScopeInfo.java

@@ -60,6 +60,7 @@ String type() {
   private String moduleShortName;
   private JavaFileObject moduleFile;
   private boolean emptyModule;
+  private boolean ignoreSingleton;
 
   /**
    * Create for the main/global module scope.
@@ -89,6 +90,10 @@ public String toString() {
       '}';
   }
 
+  boolean includeSingleton() {
+    return !ignoreSingleton;
+  }
+
   void details(String name, Element contextElement) {
     if (name == null || name.isEmpty()) {
       final String simpleName = contextElement.getSimpleName().toString();
@@ -100,6 +105,7 @@ void details(String name, Element contextElement) {
   }
 
   private void read(Element element) {
+    ignoreSingleton = ScopeUtil.readIgnoreSingleton(element);
     requires(ScopeUtil.readRequires(element));
     provides(ScopeUtil.readProvides(element));
     for (String require : ScopeUtil.readRequiresPackages(element)) {

inject-generator/src/main/java/io/avaje/inject/generator/ScopeUtil.java

@@ -10,6 +10,23 @@ class ScopeUtil {
 
   private static final String INJECT_MODULE = "io.avaje.inject.InjectModule";
 
+  static boolean readIgnoreSingleton(Element element) {
+    if (element == null) {
+      return false;
+    }
+    for (AnnotationMirror annotationMirror : element.getAnnotationMirrors()) {
+      if (INJECT_MODULE.equals(annotationMirror.getAnnotationType().toString())) {
+        for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry : annotationMirror.getElementValues().entrySet()) {
+          if (entry.getKey().toString().startsWith("ignoreSingleton(")) {
+            Object value = entry.getValue().getValue();
+            return "true".equalsIgnoreCase(value.toString());
+          }
+        }
+      }
+    }
+    return false;
+  }
+
   static List<String> readProvides(Element element) {
     return readClasses(element, "provides(");
   }

inject/src/main/java/io/avaje/inject/Component.java

@@ -0,0 +1,49 @@
+package io.avaje.inject;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Identify a bean as component with singleton scope that avaje-inject will use.
+ * <p>
+ * This is an alternative to using the standard <code>@Singleton</code> annotation.
+ * We generally use <code>@Component</code> when we:
+ * <ul>
+ *   <li>Want to use avaje-inject in a project that has some other library using <code>@Singleton</code></li>
+ *   <li>Want to support BOTH <code>javax.inject</code> and <code>jakarta.inject</code></li>
+ * </ul>
+ *
+ * <h3>Example</h3>
+ * <pre>{@code
+ *
+ * @Component
+ * class MyEmailSender implements EmailSender {
+ *
+ *   ...
+ * }
+ * }</pre>
+ *
+ * <h3>Ignoring <em>@Singleton</em></h3>
+ * <p>
+ * Set {@link InjectModule#ignoreSingleton()} <code>true</code> to get avaje-inject to ignore
+ * classes annotated with <code>@Singleton</code>. Typically, we want another DI library to use
+ * those classes and want avaje-inject to co-exist independently.
+ * <p>
+ *
+ * <pre>{@code
+ *
+ *   @InjectModule(name = "coffee", ignoreSingleton = true)
+ *   package coffee;
+ *
+ *   import io.avaje.inject.InjectModule;
+ *
+ * }</pre>
+ *
+ * @see InjectModule#ignoreSingleton()
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Component {
+}

inject/src/main/java/io/avaje/inject/InjectModule.java

@@ -41,6 +41,16 @@
    */
   String name() default "";
 
+  /**
+   * Set to true to ignore anything annotated with <code>@Singleton</code>.
+   * <p>
+   * Set this to true when some other library is using <code>@Singleton</code> and we want
+   * avaje-inject to be completely independent of that by ignoring the standard <code>@Singleton</code>.
+   * <p>
+   * We instead use <code>@Component</code> instead of <code>@Singleton</code>.
+   */
+  boolean ignoreSingleton() default false;
+
   /**
    * Explicitly define features that are provided by this module and required by other modules.
    * <p>

inject/src/main/java/io/avaje/inject/aop/AspectProvider.java

@@ -8,6 +8,7 @@
  *
  * @param <T> The aspect annotation
  */
+@FunctionalInterface
 public interface AspectProvider<T extends Annotation> {
 
   /**

inject/src/main/java/io/avaje/inject/aop/Fallback.java

@@ -8,6 +8,7 @@
  * This isn't strictly required but more a helper to make it easier for aspects
  * that want to use a fallback or recovery method.
  */
+@FunctionalInterface
 public interface Fallback {
 
   /**

inject/src/main/java/io/avaje/inject/aop/MethodInterceptor.java

@@ -8,6 +8,7 @@
  * <p>
  * MethodInterceptor instances are provided by {@link AspectProvider#interceptor(Method, Annotation)}.
  */
+@FunctionalInterface
 public interface MethodInterceptor {
 
   /**