Map of beans should always use bean definition to extract the name (#…

…10908)

inject-java/src/test/groovy/io/micronaut/inject/foreach/mapof/DefaultMyService.java

@@ -0,0 +1,10 @@
+package io.micronaut.inject.foreach.mapof;
+
+import io.micronaut.context.annotation.Requires;
+import jakarta.inject.Singleton;
+
+@Requires(property = "spec.name", value = "MapOfNameSpec")
+@Singleton
+public class DefaultMyService implements MyService {
+
+}

inject-java/src/test/groovy/io/micronaut/inject/foreach/mapof/MainService.java

@@ -0,0 +1,27 @@
+package io.micronaut.inject.foreach.mapof;
+
+import io.micronaut.context.annotation.Requires;
+import jakarta.inject.Singleton;
+
+@Requires(property = "spec.name", value = "MapOfNameSpec")
+@Singleton
+public class MainService {
+
+    private final MyFooService myFooService;
+    private final MyServiceConsumer myServiceConsumer;
+
+    public MainService(MyFooService myFooService, MyServiceConsumer myServiceConsumer) {
+        this.myFooService = myFooService;
+        this.myServiceConsumer = myServiceConsumer;
+    }
+
+    public MyFooService getMyFooService() {
+        return myFooService;
+    }
+
+    public MyServiceConsumer getMyServiceConsumer() {
+        return myServiceConsumer;
+    }
+
+
+}

inject-java/src/test/groovy/io/micronaut/inject/foreach/mapof/MyBarService.java

@@ -0,0 +1,11 @@
+package io.micronaut.inject.foreach.mapof;
+
+import io.micronaut.context.annotation.Requires;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+
+@Requires(property = "spec.name", value = "MapOfNameSpec")
+@Named("bar")
+@Singleton
+public class MyBarService implements MyService {
+}

inject-java/src/test/groovy/io/micronaut/inject/foreach/mapof/MyFooService.java

@@ -0,0 +1,13 @@
+package io.micronaut.inject.foreach.mapof;
+
+import groovy.transform.CompileStatic;
+import io.micronaut.context.annotation.Requires;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+
+@Requires(property = "spec.name", value = "MapOfNameSpec")
+@Named("foo")
+@Singleton
+@CompileStatic
+public class MyFooService implements MyService {
+}

inject-java/src/test/groovy/io/micronaut/inject/foreach/mapof/MyService.java

@@ -0,0 +1,3 @@
+package io.micronaut.inject.foreach.mapof;
+
+public interface MyService { }

inject-java/src/test/groovy/io/micronaut/inject/foreach/mapof/MyServiceConsumer.java

@@ -0,0 +1,21 @@
+package io.micronaut.inject.foreach.mapof;
+
+import io.micronaut.context.annotation.Requires;
+import jakarta.inject.Singleton;
+
+import java.util.Map;
+
+@Requires(property = "spec.name", value = "MapOfNameSpec")
+@Singleton
+public class MyServiceConsumer {
+
+    private final Map<String, MyService> myServices;
+
+    public MyServiceConsumer(Map<String, MyService> myServices) {
+        this.myServices = myServices;
+    }
+
+    public Map<String, MyService> getMyServices() {
+        return myServices;
+    }
+}

inject-java/src/test/groovy/io/micronaut/inject/foreach/mapof/MyServiceConsumerSpec.groovy

@@ -0,0 +1,31 @@
+package io.micronaut.inject.foreach.mapof
+
+import io.micronaut.context.ApplicationContext
+import spock.lang.Specification
+
+class MapOfNameSpec extends Specification {
+
+    void "test proper name resolution"() {
+        given:
+            def context = ApplicationContext.run(
+                    ["spec.name": "MapOfNameSpec"]
+            )
+            MainService service = context.getBean(MainService)
+            MyBarService barService = context.getBean(MyBarService)
+            MyFooService fooService = context.getBean(MyFooService)
+            DefaultMyService defaultMyService = context.getBean(DefaultMyService)
+        when:
+            def services = service.getMyServiceConsumer().getMyServices()
+
+        then:
+            services == Map.of(
+                    "bar", barService,
+                    "foo", fooService,
+                    "defaultMyService", defaultMyService
+            )
+
+        cleanup:
+            context.close()
+    }
+
+}

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

@@ -955,19 +955,20 @@ protected <T> Stream<T> streamOfType(BeanResolutionContext resolutionContext, Cl
     @NonNull
     private static String resolveKey(BeanRegistration<?> reg) {
         BeanDefinition<?> definition = reg.beanDefinition;
-        BeanIdentifier identifier = reg.identifier;
-        if (definition instanceof NameResolver resolver) {
-            return resolver.resolveName().orElse(identifier.getName());
-        } else {
-            String name = identifier.getName();
-            if (name.equals(Primary.SIMPLE_NAME)) {
-                Class<?> candidateType = reg.beanDefinition.getBeanType();
-                String candidateSimpleName = candidateType.getSimpleName();
-                return NameUtils.decapitalize(candidateSimpleName);
-            } else {
+        if (definition instanceof NameResolver resolver && resolver.resolveName().isPresent()) {
+            return resolver.resolveName().get();
+        }
+        Qualifier<?> declaredQualifier = definition.getDeclaredQualifier();
+        if (declaredQualifier != null) {
+            String name = Qualifiers.findName(declaredQualifier);
+            if (name != null) {
                 return name;
             }
         }
+        // Must be the primary or a single bean
+        Class<?> candidateType = reg.beanDefinition.getBeanType();
+        String candidateSimpleName = candidateType.getSimpleName();
+        return NameUtils.decapitalize(candidateSimpleName);
     }
 
     /**