Better Dependency Injection + onStarting callbacks

jknack · jknack · commit f39acfe313c1 · 2019-05-07T09:12:34.000-03:00
- Make application services accesible from DI modules
- Add onStarting callback
- Rename existing onStart to onStarted callback
- Lateinit mode which run extension after all normal extensions
diff --git a/docs/src/main/java/io/jooby/adoc/DocServer.java b/docs/src/main/java/io/jooby/adoc/DocServer.java
@@ -30,7 +30,7 @@ public static void main(String[] args) throws Exception {
 
     DocGenerator.generate(basedir, false);
 
-    Process process = new ProcessBuilder("open", basedir.resolve("out").resolve("index.html").toUri().toString())
+    Process process = new ProcessBuilder("open", basedir.resolve("asciidoc").resolve("site").resolve("index.html").toUri().toString())
         .start();
     process.waitFor();
     process.destroy();
diff --git a/jooby/src/main/java/io/jooby/Extension.java b/jooby/src/main/java/io/jooby/Extension.java
@@ -26,6 +26,10 @@
  */
 public interface Extension {
 
+  default boolean lateinit() {
+    return false;
+  }
+
   /**
    * Install, configure additional features to a Jooby application.
    *
diff --git a/jooby/src/main/java/io/jooby/Jooby.java b/jooby/src/main/java/io/jooby/Jooby.java
@@ -87,6 +87,8 @@ public class Jooby implements Router, Registry {
 
   private List<Throwing.Runnable> readyCallbacks;
 
+  private List<Throwing.Runnable> startingCallbacks;
+
   private LinkedList<AutoCloseable> stopCallbacks;
 
   private Environment env;
@@ -182,13 +184,28 @@ public Jooby() {
   }
 
   /**
-   * Start event is fire once all components has been initialized, for example router and web-server
+   * Event fired before starting router and web-server. Non-lateinit extension are installed at
+   * this stage.
+   *
+   * @param body Start body.
+   * @return This application.
+   */
+  public @Nonnull Jooby onStarting(@Nonnull Throwing.Runnable body) {
+    if (startingCallbacks == null) {
+      startingCallbacks = new ArrayList<>();
+    }
+    startingCallbacks.add(body);
+    return this;
+  }
+
+  /**
+   * Event is fire once all components has been initialized, for example router and web-server
    * are up and running, extension installed, etc...
    *
    * @param body Start body.
    * @return This application.
    */
-  public @Nonnull Jooby onStart(@Nonnull Throwing.Runnable body) {
+  public @Nonnull Jooby onStarted(@Nonnull Throwing.Runnable body) {
     if (readyCallbacks == null) {
       readyCallbacks = new ArrayList<>();
     }
@@ -300,12 +317,16 @@ public Jooby renderer(@Nonnull MediaType contentType, @Nonnull Renderer renderer
    * @return This application.
    */
   @Nonnull public Jooby install(@Nonnull Extension extension) {
-    try {
-      extension.install(this);
-      return this;
-    } catch (Exception x) {
-      throw Throwing.sneakyThrow(x);
+    if (extension.lateinit()) {
+      onStarting(() -> extension.install(this));
+    } else {
+      try {
+        extension.install(this);
+      } catch (Exception x) {
+        throw Throwing.sneakyThrow(x);
+      }
     }
+    return this;
   }
 
   @Nonnull @Override public Jooby dispatch(@Nonnull Runnable body) {
@@ -553,6 +574,9 @@ private Registry checkRegistry() {
     if (mode == null) {
       mode = ExecutionMode.DEFAULT;
     }
+
+    this.startingCallbacks = fire(this.startingCallbacks);
+
     router.start(this);
 
     return this;
@@ -568,7 +592,7 @@ private Registry checkRegistry() {
   public @Nonnull Jooby ready(@Nonnull Server server) {
     Logger log = getLog();
 
-    fireStarted();
+    this.readyCallbacks = fire(this.readyCallbacks);
 
     log.info("{} started with:", System.getProperty(APP_NAME, getClass().getSimpleName()));
 
@@ -761,20 +785,16 @@ private static void ensureTmpdir(Path tmpdir) {
     }
   }
 
-  private void fireStarted() {
-    if (readyCallbacks != null) {
-      fire(readyCallbacks);
-      readyCallbacks = null;
-    }
-  }
-
-  private void fire(List<Throwing.Runnable> tasks) {
-    Iterator<Throwing.Runnable> iterator = tasks.iterator();
-    while (iterator.hasNext()) {
-      Throwing.Runnable task = iterator.next();
-      task.run();
-      iterator.remove();
+  private List<Throwing.Runnable> fire(List<Throwing.Runnable> tasks) {
+    if (tasks != null) {
+      Iterator<Throwing.Runnable> iterator = tasks.iterator();
+      while (iterator.hasNext()) {
+        Throwing.Runnable task = iterator.next();
+        task.run();
+        iterator.remove();
+      }
     }
+    return null;
   }
 
   private void fireStop() {
diff --git a/modules/jooby-guice/src/main/java/io/jooby/di/Guiceby.java b/modules/jooby-guice/src/main/java/io/jooby/di/Guiceby.java
@@ -41,11 +41,14 @@ public Guiceby(@Nonnull Module... modules) {
     Stream.of(modules).forEach(this.modules::add);
   }
 
+  @Override public boolean lateinit() {
+    return true;
+  }
+
   @Override public void install(@Nonnull Jooby application) {
     if (injector == null) {
       Environment env = application.getEnvironment();
-      modules.add(new GuiceEnvironment(env));
-      modules.add(new ResourceModule(application));
+      modules.add(new JoobyModule(application));
       Stage stage = env.isActive("dev", "test") ? Stage.DEVELOPMENT : Stage.PRODUCTION;
       injector = Guice.createInjector(stage, modules);
     }
diff --git a/modules/jooby-guice/src/main/java/io/jooby/di/JoobyModule.java b/modules/jooby-guice/src/main/java/io/jooby/di/JoobyModule.java
@@ -15,6 +15,7 @@
  */
 package io.jooby.di;
 
+import com.google.inject.AbstractModule;
 import com.google.inject.Binder;
 import com.google.inject.Key;
 import com.google.inject.Module;
@@ -24,23 +25,45 @@
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigValue;
 import io.jooby.Environment;
+import io.jooby.Jooby;
+import io.jooby.ResourceKey;
 
 import javax.annotation.Nonnull;
 import java.lang.reflect.Type;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 
-public class GuiceEnvironment implements Module {
-  private Environment env;
+public class JoobyModule extends AbstractModule {
+  private Jooby application;
 
-  public GuiceEnvironment(@Nonnull Environment env) {
-    this.env = env;
+  public JoobyModule(@Nonnull Jooby application) {
+    this.application = application;
   }
 
-  @Override public void configure(Binder binder) {
+  @Override protected void configure() {
+    configureEnv(application.getEnvironment());
+    configureResources(application.getResources());
+  }
+
+  private void configureResources(Map<ResourceKey, Object> resources) {
+    // bind the available resources as well, supporting the name annotations that may be set
+    for (Map.Entry<ResourceKey, Object> entry : resources.entrySet()) {
+      ResourceKey key = entry.getKey();
+      if (key.getName() != null) {
+        bind(key.getType()).annotatedWith(Names.named(key.getName())).toInstance(entry.getValue());
+      } else {
+        bind(key.getType()).toInstance(entry.getValue());
+      }
+    }
+  }
+
+  private void configureEnv(Environment env) {
     Config config = env.getConfig();
-    // terminal nodes
+    bind(Config.class).toInstance(config);
+    bind(Environment.class).toInstance(env);
+
+    // configuration properties
     for (Map.Entry<String, ConfigValue> entry : config.entrySet()) {
       String name = entry.getKey();
       Named named = Names.named(name);
@@ -49,12 +72,10 @@ public GuiceEnvironment(@Nonnull Environment env) {
         List values = (List) value;
         Type listType = Types.listOf(values.iterator().next().getClass());
         Key key = Key.get(listType, Names.named(name));
-        binder.bind(key).toInstance(values);
+        bind(key).toInstance(values);
         value = values.stream().map(Object::toString).collect(Collectors.joining(","));
       }
-      binder.bindConstant().annotatedWith(named).to(value.toString());
+      bindConstant().annotatedWith(named).to(value.toString());
     }
-    binder.bind(Config.class).toInstance(config);
-    binder.bind(Environment.class).toInstance(env);
   }
 }
diff --git a/modules/jooby-guice/src/main/java/io/jooby/di/ResourceModule.java b/modules/jooby-guice/src/main/java/io/jooby/di/ResourceModule.java
diff --git a/modules/jooby-spring/src/main/java/io/jooby/di/Spring.java b/modules/jooby-spring/src/main/java/io/jooby/di/Spring.java
@@ -62,6 +62,10 @@ public Spring noMvcRoutes() {
     return this;
   }
 
+  @Override public boolean lateinit() {
+    return true;
+  }
+
   @Override public void install(@Nonnull Jooby application) throws Exception {
     if (applicationContext == null) {
       String[] packages = this.packages;
@@ -90,13 +94,11 @@ public Spring noMvcRoutes() {
       beanFactory.registerSingleton("config", config);
       beanFactory.registerSingleton("environment", environment);
 
-      application.onStart(() -> {
-        // Add resources:
-        application.getResources().forEach((key, resource) -> {
-          String name = Optional.ofNullable(key.getName())
-              .orElseGet(() -> beanName(key.getType()));
-          beanFactory.registerSingleton(name, resource);
-        });
+      // Add resources:
+      application.getResources().forEach((key, resource) -> {
+        String name = Optional.ofNullable(key.getName())
+            .orElseGet(() -> beanName(key.getType()));
+        beanFactory.registerSingleton(name, resource);
       });
 
       application.onStop(applicationContext);
diff --git a/modules/jooby-weld/src/main/java/io/jooby/di/JoobyExtension.java b/modules/jooby-weld/src/main/java/io/jooby/di/JoobyExtension.java
@@ -17,11 +17,15 @@
 
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigValue;
+import io.jooby.Environment;
 import io.jooby.Jooby;
 import io.jooby.Reified;
+import io.jooby.ResourceKey;
 import io.jooby.annotations.Path;
 
+import javax.enterprise.context.ApplicationScoped;
 import javax.enterprise.event.Observes;
+import javax.enterprise.inject.Default;
 import javax.enterprise.inject.literal.NamedLiteral;
 import javax.enterprise.inject.spi.AfterBeanDiscovery;
 import javax.enterprise.inject.spi.AnnotatedType;
@@ -30,16 +34,19 @@
 import javax.enterprise.inject.spi.InjectionTarget;
 import javax.enterprise.inject.spi.ProcessAnnotatedType;
 import javax.enterprise.inject.spi.WithAnnotations;
+import javax.enterprise.inject.spi.configurator.BeanConfigurator;
 import javax.inject.Inject;
+import javax.inject.Singleton;
+import java.lang.annotation.Annotation;
 import java.lang.reflect.Type;
 import java.util.List;
 import java.util.Map;
 
-public class WeldEnvironment implements Extension {
+public class JoobyExtension implements Extension {
   private final Jooby app;
 
   @Inject
-  public WeldEnvironment(Jooby application) {
+  public JoobyExtension(Jooby application) {
     this.app = application;
   }
 
@@ -48,9 +55,22 @@ public void registerMvc(
     this.app.mvc(controller.getAnnotatedType().getJavaClass());
   }
 
-  public void configureProperties(@Observes AfterBeanDiscovery beanDiscovery,
+  public void configureServices(@Observes AfterBeanDiscovery beanDiscovery,
       BeanManager beanManager) {
-    Config config = app.getEnvironment().getConfig();
+    for (Map.Entry<ResourceKey, Object> services : app.getResources().entrySet()) {
+      ResourceKey key = services.getKey();
+      registerSingleton(beanDiscovery, beanManager, key.getType(), key.getName(),
+          services.getValue());
+    }
+  }
+
+  public void configureEnv(@Observes AfterBeanDiscovery beanDiscovery,
+      BeanManager beanManager) {
+    Environment environment = app.getEnvironment();
+    Config config = environment.getConfig();
+
+    registerSingleton(beanDiscovery, beanManager, Config.class, null, config);
+    registerSingleton(beanDiscovery, beanManager, Environment.class, null, environment);
 
     for (Map.Entry<String, ConfigValue> configEntry : config.entrySet()) {
       final String configKey = configEntry.getKey();
@@ -76,4 +96,26 @@ public void configureProperties(@Observes AfterBeanDiscovery beanDiscovery,
           .createWith(c -> configValue);
     }
   }
+
+  private <T> void registerSingleton(AfterBeanDiscovery beanDiscovery, BeanManager beanManager,
+      Class<T> type, String name, T instance) {
+    BeanConfigurator<Object> configurator = beanDiscovery.addBean();
+    if (name != null) {
+      configurator.addQualifier(NamedLiteral.of(name)).name(name);
+    }
+    if (type.isPrimitive() || type == String.class || Number.class.isAssignableFrom(type)) {
+      AnnotatedType<?> annotatedType = beanManager.createAnnotatedType(type);
+      InjectionTarget<?> target = beanManager.createInjectionTarget(annotatedType);
+      configurator
+          .addTypes(type)
+          .addInjectionPoints(target.getInjectionPoints())
+          .createWith(c -> instance);
+    } else {
+      configurator
+          .addType(type)
+          .scope(ApplicationScoped.class)
+          .beanClass(type)
+          .createWith(c -> instance);
+    }
+  }
 }
diff --git a/modules/jooby-weld/src/main/java/io/jooby/di/Weldby.java b/modules/jooby-weld/src/main/java/io/jooby/di/Weldby.java
diff --git a/tests/src/test/java/io/jooby/FeaturedTest.java b/tests/src/test/java/io/jooby/FeaturedTest.java
