Extend @PostConstruct to all scopes

Author: adrienlauer

CHANGELOG.md

@@ -1,3 +1,8 @@
+# Version 3.14.0 (2021-09-30)
+
+* [new] `@PostConstruct` support was extended to non-singletons. `@PreDestroy` is still limited to singletons per design
+  (only singletons instances are known and tracked by the lifecycle manager).
+
 # Version 3.13.0 (2021-07-31)
 
 * [new] Support JSON and YAML expansion in configuration. Use a `myKey|json` or `myKey|yaml` as key syntax. The suffix

cli/pom.xml

@@ -14,7 +14,7 @@
     <parent>
         <groupId>org.seedstack.seed</groupId>
         <artifactId>seed</artifactId>
-        <version>3.13.0-SNAPSHOT</version>
+        <version>3.14.0-SNAPSHOT</version>
     </parent>
 
     <artifactId>seed-cli</artifactId>

core/pom.xml

@@ -14,7 +14,7 @@
     <parent>
         <groupId>org.seedstack.seed</groupId>
         <artifactId>seed</artifactId>
-        <version>3.13.0-SNAPSHOT</version>
+        <version>3.14.0-SNAPSHOT</version>
     </parent>
 
     <artifactId>seed-core</artifactId>

core/src/main/java/org/seedstack/seed/core/internal/CorePlugin.java

@@ -7,25 +7,26 @@
  */
 package org.seedstack.seed.core.internal;
 
-import static org.seedstack.shed.misc.PriorityUtils.sortByPriority;
-
 import com.google.common.base.Strings;
 import com.google.inject.Module;
 import io.nuun.kernel.api.plugin.InitState;
 import io.nuun.kernel.api.plugin.context.InitContext;
 import io.nuun.kernel.api.plugin.request.ClasspathScanRequest;
+import org.seedstack.seed.SeedInterceptor;
+import org.seedstack.shed.misc.PriorityUtils;
+import org.seedstack.shed.reflect.Classes;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.inject.Provider;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
-import javax.inject.Provider;
-import org.seedstack.seed.SeedInterceptor;
-import org.seedstack.shed.misc.PriorityUtils;
-import org.seedstack.shed.reflect.Classes;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+
+import static org.seedstack.shed.misc.PriorityUtils.sortByPriority;
 
 /**
  * Core plugin that configures base package roots and detects diagnostic collectors, dependency providers, Guice modules
@@ -120,6 +121,8 @@ private void detectBindings(InitContext initContext) {
     @SuppressWarnings("unchecked")
     private void detectProviders(InitContext initContext) {
         initContext.scannedTypesByPredicate().get(ProvideResolver.INSTANCE)
+                .stream()
+                .filter(Provider.class::isAssignableFrom)
                 .forEach(candidate -> ProvideResolver.INSTANCE.apply(candidate).ifPresent(annotation -> {
                     if (annotation.override()) {
                         overridingBindings.add(new ProviderDefinition<>((Class<Provider<Object>>) candidate));

core/src/main/java/org/seedstack/seed/core/internal/lifecycle/ConstructionMatcher.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright © 2013-2021, The SeedStack authors <http://seedstack.org>
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+package org.seedstack.seed.core.internal.lifecycle;
+
+import com.google.inject.Binding;
+import com.google.inject.matcher.AbstractMatcher;
+import org.seedstack.shed.reflect.Classes;
+
+import javax.annotation.PostConstruct;
+
+import static org.seedstack.shed.reflect.AnnotationPredicates.elementAnnotatedWith;
+
+class ConstructionMatcher extends AbstractMatcher<Binding<?>> {
+    @Override
+    public boolean matches(Binding<?> binding) {
+        return hasPostConstruct(binding.getKey().getTypeLiteral().getRawType());
+    }
+
+    private boolean hasPostConstruct(Class<?> rawType) {
+        return Classes.from(rawType)
+                .traversingInterfaces()
+                .traversingSuperclasses()
+                .methods()
+                .anyMatch(elementAnnotatedWith(PostConstruct.class, true));
+    }
+}

core/src/main/java/org/seedstack/seed/core/internal/lifecycle/ConstructionProvisionListener.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright © 2013-2021, The SeedStack authors <http://seedstack.org>
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+package org.seedstack.seed.core.internal.lifecycle;
+
+import com.google.inject.spi.ProvisionListener;
+import org.seedstack.shed.reflect.Classes;
+
+import javax.annotation.PostConstruct;
+
+import static org.seedstack.shed.reflect.AnnotationPredicates.elementAnnotatedWith;
+import static org.seedstack.shed.reflect.ReflectUtils.invoke;
+import static org.seedstack.shed.reflect.ReflectUtils.makeAccessible;
+
+class ConstructionProvisionListener implements ProvisionListener {
+    @Override
+    public <T> void onProvision(ProvisionInvocation<T> provisionInvocation) {
+        T provision = provisionInvocation.provision();
+        Classes.from(provision.getClass())
+                .traversingInterfaces()
+                .traversingSuperclasses()
+                .methods()
+                .forEach(m -> {
+                    if (elementAnnotatedWith(PostConstruct.class, true).test(m)) {
+                        invoke(makeAccessible(m), provision);
+                    }
+                });
+    }
+}

core/src/main/java/org/seedstack/seed/core/internal/lifecycle/LifecycleMatcher.java renamed to core/src/main/java/org/seedstack/seed/core/internal/lifecycle/DestructionMatcher.java

@@ -7,43 +7,42 @@
  */
 package org.seedstack.seed.core.internal.lifecycle;
 
-import static org.seedstack.shed.reflect.AnnotationPredicates.elementAnnotatedWith;
-
 import com.google.inject.Binding;
 import com.google.inject.Scope;
 import com.google.inject.Scopes;
 import com.google.inject.matcher.AbstractMatcher;
 import com.google.inject.spi.BindingScopingVisitor;
-import java.lang.annotation.Annotation;
-import javax.annotation.PostConstruct;
+import org.seedstack.shed.reflect.Classes;
+
 import javax.annotation.PreDestroy;
 import javax.inject.Singleton;
-import org.seedstack.shed.reflect.Classes;
+import java.lang.annotation.Annotation;
+
+import static org.seedstack.shed.reflect.AnnotationPredicates.elementAnnotatedWith;
 
-class LifecycleMatcher extends AbstractMatcher<Binding<?>> {
-    private final PreDestroyScopingVisitor preDestroyScopingVisitor = new PreDestroyScopingVisitor();
+class DestructionMatcher extends AbstractMatcher<Binding<?>> {
+    private final SingletonScopingVisitor singletonScopingVisitor = new SingletonScopingVisitor();
 
     @Override
     public boolean matches(Binding<?> binding) {
         Class<?> rawType = binding.getKey().getTypeLiteral().getRawType();
-        return binding.acceptScopingVisitor(preDestroyScopingVisitor) &&
-                (isAutoCloseable(rawType) || hasJsr250Methods(rawType));
+        return binding.acceptScopingVisitor(singletonScopingVisitor) &&
+                (isAutoCloseable(rawType) || hasPreDestroy(rawType));
     }
 
-    private boolean hasJsr250Methods(Class<?> rawType) {
+    private boolean hasPreDestroy(Class<?> rawType) {
         return Classes.from(rawType)
                 .traversingInterfaces()
                 .traversingSuperclasses()
                 .methods()
-                .anyMatch(elementAnnotatedWith(PreDestroy.class, true)
-                        .or(elementAnnotatedWith(PostConstruct.class, true)));
+                .anyMatch(elementAnnotatedWith(PreDestroy.class, true));
     }
 
     private boolean isAutoCloseable(Class<?> rawType) {
         return AutoCloseable.class.isAssignableFrom(rawType);
     }
 
-    private static class PreDestroyScopingVisitor implements BindingScopingVisitor<Boolean> {
+    private static class SingletonScopingVisitor implements BindingScopingVisitor<Boolean> {
         @Override
         public Boolean visitEagerSingleton() {
             return true;

core/src/main/java/org/seedstack/seed/core/internal/lifecycle/LifecycleProvisionListener.java renamed to core/src/main/java/org/seedstack/seed/core/internal/lifecycle/DestructionProvisionListener.java

@@ -12,14 +12,16 @@
 import static org.seedstack.shed.reflect.ReflectUtils.makeAccessible;
 
 import com.google.inject.spi.ProvisionListener;
+
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
+
 import org.seedstack.shed.reflect.Classes;
 
-class LifecycleProvisionListener implements ProvisionListener {
+class DestructionProvisionListener implements ProvisionListener {
     private final LifecycleManager lifecycleManager;
 
-    LifecycleProvisionListener(LifecycleManager lifecycleManager) {
+    DestructionProvisionListener(LifecycleManager lifecycleManager) {
         this.lifecycleManager = lifecycleManager;
     }
 
@@ -31,9 +33,6 @@ public <T> void onProvision(ProvisionInvocation<T> provisionInvocation) {
                 .traversingSuperclasses()
                 .methods()
                 .forEach(m -> {
-                    if (elementAnnotatedWith(PostConstruct.class, true).test(m)) {
-                        invoke(makeAccessible(m), provision);
-                    }
                     if (elementAnnotatedWith(PreDestroy.class, true).test(m)) {
                         lifecycleManager.registerPreDestroy(provision, m);
                     }

core/src/main/java/org/seedstack/seed/core/internal/lifecycle/LifecycleModule.java

@@ -9,15 +9,16 @@
 
 import com.google.inject.AbstractModule;
 import com.google.inject.multibindings.Multibinder;
-import java.util.Set;
 import org.seedstack.seed.LifecycleListener;
 
+import java.util.Set;
+
 class LifecycleModule extends AbstractModule {
     private final Set<Class<? extends LifecycleListener>> lifecycleListenerClasses;
     private final LifecycleManager lifecycleManager;
 
     LifecycleModule(Set<Class<? extends LifecycleListener>> lifecycleListenerClasses,
-            LifecycleManager lifecycleManager) {
+                    LifecycleManager lifecycleManager) {
         this.lifecycleListenerClasses = lifecycleListenerClasses;
         this.lifecycleManager = lifecycleManager;
     }
@@ -31,7 +32,8 @@ protected void configure() {
             lifecycleListenerMultibinder.addBinding().to(lifecycleListenerClass);
         }
 
-        // Listen for singletons having lifecycle annotations or interfaces
-        bindListener(new LifecycleMatcher(), new LifecycleProvisionListener(lifecycleManager));
+        // Bind lifecycle provision listeners
+        bindListener(new ConstructionMatcher(), new ConstructionProvisionListener());
+        bindListener(new DestructionMatcher(), new DestructionProvisionListener(lifecycleManager));
     }
 }

core/src/test/java/org/seedstack/seed/core/CoreIT.java

@@ -7,25 +7,18 @@
  */
 package org.seedstack.seed.core;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
-
 import com.google.inject.ConfigurationException;
 import com.google.inject.CreationException;
 import com.google.inject.Injector;
 import com.google.inject.Module;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.reflect.Method;
-import java.util.function.Predicate;
-import javax.inject.Inject;
-import javax.inject.Named;
 import org.aopalliance.intercept.MethodInvocation;
+import org.assertj.core.util.Lists;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.seedstack.seed.Bind;
 import org.seedstack.seed.Logging;
 import org.seedstack.seed.Nullable;
+import org.seedstack.seed.Provide;
 import org.seedstack.seed.SeedException;
 import org.seedstack.seed.SeedInterceptor;
 import org.seedstack.seed.core.fixtures.BoundFromInterface;
@@ -49,6 +42,18 @@
 import org.slf4j.LoggerFactory;
 import some.other.pkg.ForeignClass;
 
+import javax.inject.Inject;
+import javax.inject.Named;
+import javax.inject.Provider;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.function.Predicate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
 @RunWith(SeedITRunner.class)
 public class CoreIT {
     @Inject
@@ -143,6 +148,21 @@ public void methodInterceptorsAreWorking() {
         assertThat(SomeSeedInterceptor.invokedTimes).isEqualTo(1);
     }
 
+    @Test
+    public void annotatedProviderIsWorking() {
+        HolderNominal instance = injector.getInstance(HolderNominal.class);
+        assertThat(instance.testValue).isEqualTo(Lists.newArrayList("test"));
+    }
+
+    @Provide
+    @Named("test")
+    private static class ValueProvider implements Provider<List<String>> {
+        @Override
+        public List<String> get() {
+            return Lists.newArrayList("test");
+        }
+    }
+
     @Bind
     private static class LoggerHolder {
         private static final Logger logger = LoggerFactory.getLogger(LoggerHolder.class);
@@ -203,6 +223,9 @@ private static class HolderNominal {
         @Inject
         @Dummy
         ProvidedInterface<Integer> providedFromInterfaceWithAnnotation;
+        @Inject
+        @Named("test")
+        List<String> testValue;
     }
 
     private static class HolderException {