add a bug fix and a test case for #11656

Author: Jarvx

inject/src/main/java/io/micronaut/context/DefaultBeanContext.java

@@ -131,6 +131,7 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.WeakHashMap;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.ForkJoinPool;
@@ -175,6 +176,13 @@ public class DefaultBeanContext implements InitializableBeanContext, Configurabl
 
     protected final SingletonScope singletonScope = new SingletonScope();
 
+    /**
+     * Track instances created by this context so that if the same instance is later
+     * registered via registerSingleton(...) we can avoid duplicate injection/initialization.
+     * Use a WeakHashMap-backed set so instances can be GC'ed and to avoid leaks.
+     */
+    private final Set<Object> beansCreatedByContext = Collections.synchronizedSet(Collections.newSetFromMap(new WeakHashMap<>()));
+
     private final BeanContextConfiguration beanContextConfiguration;
 
     // The collection should be modified only when new bean definition is added
@@ -691,7 +699,19 @@ public <T> BeanContext registerSingleton(@NonNull Class<T> type, @NonNull T sing
         if (beanDefinition != null && !(beanDefinition instanceof RuntimeBeanDefinition<T>) && beanDefinition.getBeanType().isInstance(singleton)) {
             try (BeanResolutionContext context = newResolutionContext(beanDefinition, null)) {
                 if (inject) {
-                    doInjectAndInitialize(context, singleton, beanDefinition);
+                    // If this instance was created by this context earlier, it may already have been injected/initialized.
+                    // In such case skip duplicate injection/initialization. Use the beansCreatedByContext set to detect this.
+                    boolean createdByThisContext;
+                    synchronized (beansCreatedByContext) {
+                        createdByThisContext = beansCreatedByContext.remove(singleton);
+                    }
+                    if (!createdByThisContext) {
+                        doInjectAndInitialize(context, singleton, beanDefinition);
+                    } else {
+                        if (LOG_LIFECYCLE.isDebugEnabled()) {
+                            LOG_LIFECYCLE.debug("Skipping duplicate injection/initialization for bean [{}] as it was created by the context", singleton);
+                        }
+                    }
                 }
                 DefaultBeanContext.BeanKey<T> key = new DefaultBeanContext.BeanKey<>(beanDefinition.asArgument(), qualifier);
                 singletonScope.registerSingletonBean(BeanRegistration.of(this, key, beanDefinition, singleton), qualifier);
@@ -2349,6 +2369,11 @@ private <T> T resolveByBeanFactory(@NonNull BeanResolutionContext resolutionCont
             if (bean instanceof Qualified qualified) {
                 qualified.$withBeanQualifier(declaredQualifier);
             }
+
+            // Track instances created by this context so registerSingleton can avoid
+            // doing duplicate injection/initialization when someone registers the same instance.
+            beansCreatedByContext.add(bean);
+
             return bean;
         } catch (DependencyInjectionException | DisabledBeanException | BeanInstantiationException e) {
             throw e;

test-suite/src/test/java/io/micronaut/reproduce/DoublePostConstructTest.java

@@ -0,0 +1,27 @@
+package io.micronaut.reproduce;
+
+import io.micronaut.context.ApplicationContext;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+
+public class DoublePostConstructTest {
+
+    @Test
+    void postConstructCalledOnceWhenCreateAndRegisterSingleton() {
+        try (ApplicationContext ctx = ApplicationContext.run()) {
+            // createBean should call @PostConstruct once
+            MyBean bean = ctx.createBean(MyBean.class);
+            assertEquals(1, bean.getInitCount(), "@PostConstruct should have been called once after createBean");
+
+            // registering the already-created instance must NOT call @PostConstruct again
+            ctx.registerSingleton(bean);
+
+            MyBean resolved = ctx.getBean(MyBean.class);
+            assertSame(bean, resolved, "Registered singleton should be the same instance");
+            // Expected: still 1. If bug present, this will be 2.
+            assertEquals(1, bean.getInitCount(), "@PostConstruct was called more than once when registering singleton");
+        }
+    }
+}

test-suite/src/test/java/io/micronaut/reproduce/MyBean.java

@@ -0,0 +1,26 @@
+package io.micronaut.reproduce;
+
+import jakarta.annotation.PostConstruct;
+import jakarta.inject.Singleton;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+@Singleton
+public class MyBean {
+
+    private final AtomicInteger initCount = new AtomicInteger(0);
+
+    @PostConstruct
+    void init() {
+        initCount.incrementAndGet();
+        System.out.println("MyBean init called, count=" + initCount.get() + " instance=" + this);
+    }
+
+    public String hello() {
+        return "hello";
+    }
+
+    public int getInitCount() {
+        return initCount.get();
+    }
+}