#235 - Support injecting BeanScope

Author: rbygrave

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

@@ -97,7 +97,11 @@ List<Dependency> getDependsOn() {
     List<Dependency> list = new ArrayList<>();
     if (constructor != null) {
       for (MethodReader.MethodParam param : constructor.getParams()) {
-        list.add(param.getDependsOn());
+        Dependency dependsOn = param.getDependsOn();
+        // BeanScope is always injectable with no impact on injection ordering
+        if (!dependsOn.dependsOn().equals(Constants.BEANSCOPE)) {
+          list.add(dependsOn);
+        }
       }
     }
     return list;

inject-test/src/test/java/org/example/coffee/INeedBeanScope.java

@@ -0,0 +1,22 @@
+package org.example.coffee;
+
+import io.avaje.inject.BeanScope;
+import io.avaje.inject.Component;
+import org.example.optional.Que;
+
+/**
+ * Depends on the BeanScope.
+ */
+@Component
+class INeedBeanScope {
+
+  final BeanScope beanScope;
+
+  INeedBeanScope(BeanScope beanScope) {
+    this.beanScope = beanScope;
+  }
+
+  Que getQueue() {
+    return beanScope.get(Que.class, "frodo");
+  }
+}

inject-test/src/test/java/org/example/coffee/InjectBeanScopeTest.java

@@ -0,0 +1,24 @@
+package org.example.coffee;
+
+import io.avaje.inject.BeanScope;
+import org.example.optional.Que;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Test that we can inject BeanScope.
+ */
+class InjectBeanScopeTest {
+
+  @Test
+  void test() {
+    try (BeanScope beanScope = BeanScope.builder().build()) {
+      INeedBeanScope need = beanScope.get(INeedBeanScope.class);
+      Que queue = need.getQueue();
+
+      String result = queue.push("hi");
+      assertThat(result).isEqualTo("hi|frodo");
+    }
+  }
+}

inject/src/main/java/io/avaje/inject/spi/DBeanScopeProxy.java

@@ -0,0 +1,102 @@
+package io.avaje.inject.spi;
+
+import io.avaje.inject.BeanEntry;
+import io.avaje.inject.BeanScope;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * Proxy used when injecting the BeanScope.
+ */
+class DBeanScopeProxy implements BeanScope {
+
+  private BeanScope delegate;
+
+  /**
+   * This happens just before the BeanScope is started.
+   *
+   * @param delegate The actual BeanScope
+   */
+  void inject(BeanScope delegate) {
+    this.delegate = delegate;
+  }
+
+  @Override
+  public <T> T get(Class<T> type) {
+    return delegate.get(type);
+  }
+
+  @Override
+  public <T> T get(Class<T> type, String name) {
+    return delegate.get(type, name);
+  }
+
+  @Override
+  public <T> T get(Type type, String name) {
+    return delegate.get(type, name);
+  }
+
+  @Override
+  public <T> Optional<T> getOptional(Class<T> type) {
+    return delegate.getOptional(type);
+  }
+
+  @Override
+  public <T> Optional<T> getOptional(Type type, String name) {
+    return delegate.getOptional(type, name);
+  }
+
+  @Override
+  public List<Object> listByAnnotation(Class<?> annotation) {
+    return delegate.listByAnnotation(annotation);
+  }
+
+  @Override
+  public <T> List<T> list(Class<T> type) {
+    return delegate.list(type);
+  }
+
+  @Override
+  public <T> List<T> list(Type type) {
+    return delegate.list(type);
+  }
+
+  @Override
+  public <T> List<T> listByPriority(Class<T> type) {
+    return delegate.listByPriority(type);
+  }
+
+  @Override
+  public <T> List<T> listByPriority(Class<T> type, Class<? extends Annotation> priority) {
+    return delegate.listByPriority(type, priority);
+  }
+
+  @Override
+  public <T> Map<String, T> map(Type type) {
+    return delegate.map(type);
+  }
+
+  @Override
+  public List<BeanEntry> all() {
+    return delegate.all();
+  }
+
+  @Override
+  public boolean contains(Type type) {
+    return delegate.contains(type);
+  }
+
+  @Override
+  public boolean contains(String type) {
+    return delegate.contains(type);
+  }
+
+  @Override
+  public void close() {
+    delegate.close();
+  }
+}

inject/src/main/java/io/avaje/inject/spi/DBuilder.java

@@ -17,34 +17,29 @@ class DBuilder implements Builder {
    */
   private final List<Runnable> postConstruct = new ArrayList<>();
   private final List<AutoCloseable> preDestroy = new ArrayList<>();
-
   /**
    * List of field injection closures.
    */
   private final List<Consumer<Builder>> injectors = new ArrayList<>();
-
   /**
    * The beans created and added to the scope during building.
    */
   protected final DBeanMap beanMap = new DBeanMap();
-
   protected final BeanScope parent;
   protected final boolean parentOverride;
-
   /**
    * Bean provided by the parent scope that we are not overriding.
    */
   protected Object parentMatch;
-
   /**
    * Debug of the current bean being wired - used in injection errors.
    */
   private Type injectTarget;
-
   /**
    * Flag set when we are running post construct injection.
    */
   private boolean runningPostConstruct;
+  private DBeanScopeProxy beanScopeProxy;
 
   DBuilder(BeanScope parent, boolean parentOverride) {
     this.parent = parent;
@@ -253,13 +248,24 @@ public <T> T get(Type cls) {
 
   @Override
   public <T> T get(Type cls, String name) {
+    if (BeanScope.class.equals(cls)) {
+      return injectBeanScope();
+    }
     T bean = getMaybe(cls, name);
     if (bean == null) {
       throw new IllegalStateException(errorInjectingNull(cls, name));
     }
     return bean;
   }
 
+  @SuppressWarnings("unchecked")
+  private <T> T injectBeanScope() {
+    if (beanScopeProxy == null) {
+      beanScopeProxy = new DBeanScopeProxy();
+    }
+    return (T) beanScopeProxy;
+  }
+
   private <T> String errorInjectingNull(Type cls, String name) {
     String msg = "Injecting null for " + cls.getTypeName();
     if (name != null) {
@@ -284,6 +290,10 @@ private void runInjectors() {
 
   public BeanScope build(boolean withShutdownHook) {
     runInjectors();
-    return new DBeanScope(withShutdownHook, preDestroy, postConstruct, beanMap, parent).start();
+    var scope = new DBeanScope(withShutdownHook, preDestroy, postConstruct, beanMap, parent);
+    if (beanScopeProxy != null) {
+      beanScopeProxy.inject(scope);
+    }
+    return scope.start();
   }
 }