You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by ja...@apache.org on 2025/07/30 13:40:55 UTC
(camel-quarkus) 01/02: Support resolving beans by name and qualifiers
This is an automated email from the ASF dual-hosted git repository.
jamesnetherton pushed a commit to branch 3.20.x
in repository https://gitbox.apache.org/repos/asf/camel-quarkus.git
commit a4882108bcd4b3db91a004dc823a9f625f1737c1
Author: James Netherton <ja...@gmail.com>
AuthorDate: Tue Jun 10 10:37:24 2025 +0100
Support resolving beans by name and qualifiers
Fixes #7426
---
.../core/deployment/CamelRegistryProcessor.java | 8 +-
.../spi/CamelBeanQualifierResolverBuildItem.java | 11 ++
.../CamelRegistryBeanQualifierResolutionTest.java | 82 ++++++--
.../core/BeanQualifierResolverIdentifier.java | 61 ++++++
.../quarkus/core/CamelBeanQualifierResolver.java | 32 +++-
.../apache/camel/quarkus/core/CamelRecorder.java | 15 +-
.../camel/quarkus/core/RuntimeBeanRepository.java | 206 +++++++++------------
.../apache/camel/quarkus/core/RuntimeRegistry.java | 2 +-
.../camel/quarkus/component/bean/BeanTest.java | 3 +-
9 files changed, 274 insertions(+), 146 deletions(-)
diff --git a/extensions-core/core/deployment/src/main/java/org/apache/camel/quarkus/core/deployment/CamelRegistryProcessor.java b/extensions-core/core/deployment/src/main/java/org/apache/camel/quarkus/core/deployment/CamelRegistryProcessor.java
index 9b08e7e97a..fe79533a77 100644
--- a/extensions-core/core/deployment/src/main/java/org/apache/camel/quarkus/core/deployment/CamelRegistryProcessor.java
+++ b/extensions-core/core/deployment/src/main/java/org/apache/camel/quarkus/core/deployment/CamelRegistryProcessor.java
@@ -28,6 +28,7 @@ import io.quarkus.deployment.annotations.Record;
import io.quarkus.deployment.builditem.ApplicationArchivesBuildItem;
import io.quarkus.deployment.builditem.CombinedIndexBuildItem;
import org.apache.camel.BindToRegistry;
+import org.apache.camel.quarkus.core.BeanQualifierResolverIdentifier;
import org.apache.camel.quarkus.core.CamelBeanQualifierResolver;
import org.apache.camel.quarkus.core.CamelCapabilities;
import org.apache.camel.quarkus.core.CamelConfig;
@@ -61,9 +62,12 @@ public class CamelRegistryProcessor {
List<CamelBeanQualifierResolverBuildItem> camelBeanQualifierResolvers,
CamelRecorder recorder) {
- Map<String, CamelBeanQualifierResolver> beanQualifierResolvers = new HashMap<>();
+ Map<BeanQualifierResolverIdentifier, CamelBeanQualifierResolver> beanQualifierResolvers = new HashMap<>();
for (CamelBeanQualifierResolverBuildItem resolver : camelBeanQualifierResolvers) {
- recorder.registerCamelBeanQualifierResolver(resolver.getBeanTypeName(), resolver.getRuntimeValue(),
+ recorder.registerCamelBeanQualifierResolver(
+ resolver.getBeanTypeName(),
+ resolver.getBeanName(),
+ resolver.getRuntimeValue(),
beanQualifierResolvers);
}
diff --git a/extensions-core/core/deployment/src/main/java/org/apache/camel/quarkus/core/deployment/spi/CamelBeanQualifierResolverBuildItem.java b/extensions-core/core/deployment/src/main/java/org/apache/camel/quarkus/core/deployment/spi/CamelBeanQualifierResolverBuildItem.java
index 7d9e96b0b9..7a207f502e 100644
--- a/extensions-core/core/deployment/src/main/java/org/apache/camel/quarkus/core/deployment/spi/CamelBeanQualifierResolverBuildItem.java
+++ b/extensions-core/core/deployment/src/main/java/org/apache/camel/quarkus/core/deployment/spi/CamelBeanQualifierResolverBuildItem.java
@@ -26,9 +26,16 @@ import org.apache.camel.quarkus.core.CamelBeanQualifierResolver;
public final class CamelBeanQualifierResolverBuildItem extends MultiBuildItem {
private final RuntimeValue<CamelBeanQualifierResolver> runtimeValue;
private final Class<?> beanType;
+ private final String beanName;
public CamelBeanQualifierResolverBuildItem(Class<?> beanType, RuntimeValue<CamelBeanQualifierResolver> runtimeValue) {
+ this(beanType, null, runtimeValue);
+ }
+
+ public CamelBeanQualifierResolverBuildItem(Class<?> beanType, String beanName,
+ RuntimeValue<CamelBeanQualifierResolver> runtimeValue) {
this.beanType = beanType;
+ this.beanName = beanName;
this.runtimeValue = runtimeValue;
}
@@ -40,6 +47,10 @@ public final class CamelBeanQualifierResolverBuildItem extends MultiBuildItem {
return beanType.getName();
}
+ public String getBeanName() {
+ return beanName;
+ }
+
public RuntimeValue<CamelBeanQualifierResolver> getRuntimeValue() {
return runtimeValue;
}
diff --git a/extensions-core/core/deployment/src/test/java/org/apache/camel/quarkus/core/deployment/CamelRegistryBeanQualifierResolutionTest.java b/extensions-core/core/deployment/src/test/java/org/apache/camel/quarkus/core/deployment/CamelRegistryBeanQualifierResolutionTest.java
index ae67c3c91e..9aad114ab7 100644
--- a/extensions-core/core/deployment/src/test/java/org/apache/camel/quarkus/core/deployment/CamelRegistryBeanQualifierResolutionTest.java
+++ b/extensions-core/core/deployment/src/test/java/org/apache/camel/quarkus/core/deployment/CamelRegistryBeanQualifierResolutionTest.java
@@ -48,7 +48,8 @@ import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
public class CamelRegistryBeanQualifierResolutionTest {
@@ -68,13 +69,25 @@ public class CamelRegistryBeanQualifierResolutionTest {
Integer.toString(methodName.hashCode()),
true, s -> null);
- RuntimeValue<CamelBeanQualifierResolver> runtimeValue = recorder
- .newInstance(TestBeanQualifierResolver.class.getName());
+ RuntimeValue<CamelBeanQualifierResolver> runtimeValueFoo = recorder
+ .newInstance(FooNamedBeanQualifierResolver.class.getName());
context.produce(new StaticBytecodeRecorderBuildItem(recorder));
- CamelBeanQualifierResolverBuildItem buildItem = new CamelBeanQualifierResolverBuildItem(Foo.class,
- runtimeValue);
- context.produce(buildItem);
+ CamelBeanQualifierResolverBuildItem buildItemFoo = new CamelBeanQualifierResolverBuildItem(
+ Foo.class,
+ "foo",
+ runtimeValueFoo);
+ context.produce(buildItemFoo);
+
+ RuntimeValue<CamelBeanQualifierResolver> runtimeValueBar = recorder
+ .newInstance(BarNamedBeanQualifierResolver.class.getName());
+ context.produce(new StaticBytecodeRecorderBuildItem(recorder));
+
+ CamelBeanQualifierResolverBuildItem buildItemBar = new CamelBeanQualifierResolverBuildItem(
+ Bar.class,
+ "bar",
+ runtimeValueBar);
+ context.produce(buildItemBar);
}
}).produces(StaticBytecodeRecorderBuildItem.class).produces(CamelBeanQualifierResolverBuildItem.class)
.build();
@@ -87,27 +100,63 @@ public class CamelRegistryBeanQualifierResolutionTest {
@Test
public void testBeanLookupWithQualifiers() {
- // Foo should be resolvable since we have a CamelBeanQualifierResolver for that type
+ // Foo & Bar should be resolvable since we have a CamelBeanQualifierResolver for those types
Set<Foo> fooBeans = context.getRegistry().findByType(Foo.class);
assertEquals(1, fooBeans.size());
- // Bar should not be resolvable as there is no CamelBeanQualifierResolver for that type
+ Foo foo = context.getRegistry().lookupByNameAndType("foo", Foo.class);
+ assertNotNull(foo);
+
+ foo = context.getRegistry().findSingleByType(Foo.class);
+ assertNotNull(foo);
+
+ Bar bar = context.getRegistry().lookupByNameAndType("bar", Bar.class);
+ assertNotNull(bar);
+
+ // We don't care about qualifiers when doing findByType so we should find all Bar beans
Set<Bar> barBeans = context.getRegistry().findByType(Bar.class);
- assertTrue(barBeans.isEmpty());
+ assertEquals(2, barBeans.size());
+
+ // There are 2 beans so we can't find using findSingleByType
+ bar = context.getRegistry().findSingleByType(Bar.class);
+ assertNull(bar);
+
+ // Bar2 should not be resolvable as there is no CamelBeanQualifierResolver to help with its bean resolution
+ Bar bar2 = context.getRegistry().lookupByNameAndType("bar2", Bar.class);
+ assertNull(bar2);
}
@Qualifier
@Retention(RUNTIME)
@Target({ TYPE, METHOD })
public @interface CamelQuarkusQualifier {
+ String value() default "";
+
class CamelQuarkusLiteral extends AnnotationLiteral<CamelQuarkusQualifier> implements CamelQuarkusQualifier {
+ private final String value;
+
+ public CamelQuarkusLiteral(String value) {
+ this.value = value;
+ }
+
+ @Override
+ public String value() {
+ return this.value;
+ }
}
}
- public static class TestBeanQualifierResolver implements CamelBeanQualifierResolver {
+ public static class FooNamedBeanQualifierResolver implements CamelBeanQualifierResolver {
@Override
public Annotation[] resolveQualifiers() {
- return new Annotation[] { new CamelQuarkusQualifier.CamelQuarkusLiteral() };
+ return new Annotation[] { new CamelQuarkusQualifier.CamelQuarkusLiteral("foo") };
+ }
+ }
+
+ public static class BarNamedBeanQualifierResolver implements CamelBeanQualifierResolver {
+ @Override
+ public Annotation[] resolveQualifiers() {
+ return new Annotation[] { new CamelQuarkusQualifier.CamelQuarkusLiteral("bar") };
}
}
@@ -121,16 +170,23 @@ public class CamelRegistryBeanQualifierResolutionTest {
public static class Service {
@Unremovable
@Produces
- @CamelQuarkusQualifier
+ @CamelQuarkusQualifier("foo")
public Foo foo() {
return new Foo();
}
@Unremovable
@Produces
- @CamelQuarkusQualifier
+ @CamelQuarkusQualifier("bar")
public Bar bar() {
return new Bar();
}
+
+ @Unremovable
+ @Produces
+ @CamelQuarkusQualifier("bar2")
+ public Bar bar2() {
+ return new Bar();
+ }
}
}
diff --git a/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/BeanQualifierResolverIdentifier.java b/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/BeanQualifierResolverIdentifier.java
new file mode 100644
index 0000000000..890156b69f
--- /dev/null
+++ b/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/BeanQualifierResolverIdentifier.java
@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.quarkus.core;
+
+import java.util.Objects;
+
+public final class BeanQualifierResolverIdentifier {
+ private final String className;
+ private final String beanName;
+
+ BeanQualifierResolverIdentifier(String className, String beanName) {
+ this.className = className;
+ this.beanName = beanName;
+ }
+
+ public static BeanQualifierResolverIdentifier of(String className) {
+ return new BeanQualifierResolverIdentifier(className, null);
+ }
+
+ public static BeanQualifierResolverIdentifier of(String className, String beanName) {
+ return new BeanQualifierResolverIdentifier(className, beanName);
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o)
+ return true;
+ if (o == null || getClass() != o.getClass())
+ return false;
+ BeanQualifierResolverIdentifier that = (BeanQualifierResolverIdentifier) o;
+ return Objects.equals(className, that.className) && Objects.equals(beanName, that.beanName);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(className, beanName);
+ }
+
+ @Override
+ public String toString() {
+ String result = "class name " + className;
+ if (beanName != null) {
+ result += ", bean name " + beanName;
+ }
+ return result;
+ }
+}
diff --git a/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/CamelBeanQualifierResolver.java b/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/CamelBeanQualifierResolver.java
index c8d7cc5330..c554d622b9 100644
--- a/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/CamelBeanQualifierResolver.java
+++ b/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/CamelBeanQualifierResolver.java
@@ -19,8 +19,36 @@ package org.apache.camel.quarkus.core;
import java.lang.annotation.Annotation;
/**
- * Abstraction for resolving bean annotation qualifiers
+ * Abstraction for resolving bean annotation qualifiers.
*/
public interface CamelBeanQualifierResolver {
- Annotation[] resolveQualifiers();
+ /**
+ * Resolves bean annotation qualifiers.
+ *
+ * @return The resolved bean {@link Annotation} qualifiers
+ */
+ default Annotation[] resolveQualifiers() {
+ return null;
+ }
+
+ /**
+ * Resolves bean annotation qualifiers with the given bean name.
+ *
+ * @param beanName The name of the bean
+ * @return The resolved bean {@link Annotation} qualifiers
+ */
+ default Annotation[] resolveAnnotations(String beanName) {
+ return null;
+ }
+
+ /**
+ * Gets the {@link BeanQualifierResolverIdentifier} associated with this {@link CamelBeanQualifierResolver}.
+ *
+ * @param className The class name of the bean
+ * @param beanName The name of the bean. Can be null
+ * @return The {@link BeanQualifierResolverIdentifier}
+ */
+ default BeanQualifierResolverIdentifier getIdentifier(String className, String beanName) {
+ return BeanQualifierResolverIdentifier.of(className, beanName);
+ }
}
diff --git a/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/CamelRecorder.java b/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/CamelRecorder.java
index 829e78d879..da994ce9e5 100644
--- a/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/CamelRecorder.java
+++ b/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/CamelRecorder.java
@@ -51,17 +51,22 @@ import org.apache.camel.support.startup.DefaultStartupStepRecorder;
public class CamelRecorder {
public void registerCamelBeanQualifierResolver(
String className,
+ String beanName,
RuntimeValue<CamelBeanQualifierResolver> runtimeValue,
- Map<String, CamelBeanQualifierResolver> beanQualifiers) {
+ Map<BeanQualifierResolverIdentifier, CamelBeanQualifierResolver> beanQualifiers) {
- if (beanQualifiers.containsKey(className)) {
- throw new RuntimeException("Duplicate CamelBeanQualifierResolver detected for class: " + className);
+ CamelBeanQualifierResolver resolver = runtimeValue.getValue();
+ BeanQualifierResolverIdentifier identifier = resolver.getIdentifier(className, beanName);
+
+ if (beanQualifiers.containsKey(identifier)) {
+ throw new RuntimeException("Duplicate CamelBeanQualifierResolver detected for: " + identifier);
}
- beanQualifiers.put(className, runtimeValue.getValue());
+ beanQualifiers.put(identifier, resolver);
}
- public RuntimeValue<Registry> createRegistry(Map<String, CamelBeanQualifierResolver> beanQualifierResolvers) {
+ public RuntimeValue<Registry> createRegistry(
+ Map<BeanQualifierResolverIdentifier, CamelBeanQualifierResolver> beanQualifierResolvers) {
return new RuntimeValue<>(new RuntimeRegistry(beanQualifierResolvers));
}
diff --git a/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/RuntimeBeanRepository.java b/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/RuntimeBeanRepository.java
index 6eb36869b0..6ecb21dedc 100644
--- a/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/RuntimeBeanRepository.java
+++ b/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/RuntimeBeanRepository.java
@@ -18,9 +18,7 @@ package org.apache.camel.quarkus.core;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.HashMap;
-import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
@@ -32,107 +30,19 @@ import io.quarkus.arc.ArcContainer;
import io.quarkus.arc.InjectableBean;
import io.quarkus.arc.InstanceHandle;
import io.smallrye.common.annotation.Identifier;
-import jakarta.enterprise.inject.AmbiguousResolutionException;
import jakarta.enterprise.inject.Default;
import jakarta.enterprise.inject.literal.NamedLiteral;
-import jakarta.enterprise.inject.spi.Bean;
import jakarta.enterprise.inject.spi.BeanManager;
import org.apache.camel.spi.BeanRepository;
public final class RuntimeBeanRepository implements BeanRepository {
+ private static final Annotation[] EMPTY_ANNOTATIONS = new Annotation[0];
+ private final Map<BeanQualifierResolverIdentifier, CamelBeanQualifierResolver> beanQualifierResolvers;
- private final Map<String, CamelBeanQualifierResolver> beanQualifierResolvers;
-
- public RuntimeBeanRepository(Map<String, CamelBeanQualifierResolver> beanQualifierResolvers) {
+ public RuntimeBeanRepository(Map<BeanQualifierResolverIdentifier, CamelBeanQualifierResolver> beanQualifierResolvers) {
this.beanQualifierResolvers = beanQualifierResolvers;
}
- private static <T> Set<Bean<? extends T>> resolveAmbiguity(BeanManager manager, Set<Bean<? extends T>> beans) {
- if (beans.size() > 1) {
- try {
- return Collections.singleton(manager.resolve(beans));
- } catch (AmbiguousResolutionException are) {
- //in case of AmbiguousResolutionException, original collection is returned
- }
- }
-
- return beans;
- }
-
- private static <T> Map<String, T> getReferencesByTypeWithName(Class<T> type, Annotation... qualifiers) {
- return getBeanManager()
- .map(manager -> getReferencesByTypeWithName(manager, type, qualifiers))
- .orElseGet(Collections::emptyMap);
- }
-
- private static <T> Set<T> getReferencesByType(BeanManager manager, Class<T> type, Annotation... qualifiers) {
- Set<T> answer = new HashSet<>();
-
- for (Bean<?> bean : resolveAmbiguity(manager, manager.getBeans(type, qualifiers))) {
- T ref = getReference(manager, type, bean);
- if (ref != null) {
- answer.add(ref);
- }
- }
-
- return answer;
- }
-
- private static <T> Optional<T> getReferenceByName(BeanManager manager, String name, Class<T> type) {
- Set<Bean<?>> beans = manager.getBeans(name);
-
- // If it is a Synthetic bean, it should match with type
- beans = beans.stream()
- .filter(bean -> {
- if (bean instanceof InjectableBean injectableBean) {
- return !injectableBean.getKind().equals(InjectableBean.Kind.SYNTHETIC)
- || bean.getTypes().contains(type);
- } else {
- return true;
- }
- }).collect(Collectors.toSet());
-
- if (beans.isEmpty()) {
- // Fallback to searching explicitly with NamedLiteral
- beans = manager.getBeans(type, NamedLiteral.of(name));
- }
-
- if (beans.isEmpty()) {
- // Fallback to SmallRye @Identifier
- beans = manager.getBeans(type, Identifier.Literal.of(name));
- }
-
- return Optional.ofNullable(manager.resolve(beans)).map(bean -> getReference(manager, type, bean));
- }
-
- private static <T> T getReference(BeanManager manager, Class<T> type, Bean<?> bean) {
- return type.cast(manager.getReference(bean, Object.class, manager.createCreationalContext(bean)));
- }
-
- private static <T> Map<String, T> getReferencesByTypeWithName(BeanManager manager, Class<T> type,
- Annotation... qualifiers) {
- Map<String, T> answer = new HashMap<>();
-
- for (Bean<?> bean : manager.getBeans(type, qualifiers)) {
-
- T ref = getReference(manager, type, bean);
- if (ref != null) {
- answer.put(bean.getName(), ref);
- }
- }
-
- return answer;
- }
-
- private static Optional<BeanManager> getBeanManager() {
- ArcContainer container = Arc.container();
- if (container == null) {
- return Optional.empty();
- }
-
- return Optional.ofNullable(container.beanManager());
- }
-
@Override
public Object lookupByName(String name) {
return lookupByNameAndType(name, Object.class);
@@ -141,43 +51,28 @@ public final class RuntimeBeanRepository implements BeanRepository {
@Override
public <T> T lookupByNameAndType(String name, Class<T> type) {
return getBeanManager()
- .flatMap(manager -> getReferenceByName(manager, name, type))
+ .flatMap(manager -> getReferenceByName(name, type, resolveQualifiersForTypeAndName(type, name)))
.orElse(null);
}
@Override
public <T> Map<String, T> findByTypeWithName(Class<T> type) {
- Optional<Annotation[]> qualifiers = resolveQualifiersForType(type);
- if (qualifiers.isPresent()) {
- return getReferencesByTypeWithName(type, qualifiers.get());
- }
- return getReferencesByTypeWithName(type);
+ return getReferencesByTypeWithName(type, resolveQualifiersForType(type));
}
@Override
public <T> Set<T> findByType(Class<T> type) {
- Optional<Annotation[]> qualifiers = resolveQualifiersForType(type);
- if (qualifiers.isPresent()) {
- return getBeanManager()
- .map(manager -> getReferencesByType(manager, type, qualifiers.get()))
- .orElseGet(Collections::emptySet);
- }
- return getBeanManager()
- .map(manager -> getReferencesByType(manager, type))
- .orElseGet(Collections::emptySet);
+ return Arc.container()
+ .listAll(type)
+ .stream()
+ .filter(InstanceHandle::isAvailable)
+ .map(InstanceHandle::get)
+ .collect(Collectors.toSet());
}
@Override
public <T> T findSingleByType(Class<T> type) {
- ArcContainer container = Arc.container();
- Optional<Annotation[]> qualifiers = resolveQualifiersForType(type);
- List<InstanceHandle<T>> handles;
- if (qualifiers.isPresent()) {
- handles = container.listAll(type, qualifiers.get());
- } else {
- handles = container.listAll(type);
- }
-
+ List<InstanceHandle<T>> handles = Arc.container().listAll(type, resolveQualifiersForType(type));
if (handles.isEmpty()) {
// No matches for the given bean type
return null;
@@ -226,12 +121,81 @@ public final class RuntimeBeanRepository implements BeanRepository {
return null;
}
- private Optional<Annotation[]> resolveQualifiersForType(Class<?> type) {
- CamelBeanQualifierResolver resolver = beanQualifierResolvers.get(type.getName());
+ private static <T> Map<String, T> getReferencesByTypeWithName(Class<T> type, Annotation... qualifiers) {
+ Map<String, T> beans = new HashMap<>();
+ Arc.container()
+ .listAll(type, qualifiers)
+ .stream()
+ .filter(InstanceHandle::isAvailable)
+ .forEach(instanceHandle -> {
+ beans.put(instanceHandle.getBean().getName(), instanceHandle.get());
+ });
+ return beans;
+ }
+
+ private static <T> Optional<T> getReferenceByName(String name, Class<T> type, Annotation... qualifiers) {
+ InstanceHandle<T> instance;
+ T result = null;
+
+ if (qualifiers.length == 0) {
+ // Try to resolve directly by name
+ instance = Arc.container().instance(name);
+ } else {
+ // If there are qualifiers then one of their attributes may represent the name we want to resolve
+ instance = Arc.container().instance(type, qualifiers);
+ }
+
+ if (instance.isAvailable()) {
+ // If it is a Synthetic bean, it must match with the desired type
+ InjectableBean<T> bean = instance.getBean();
+ if (bean.getKind().equals(InjectableBean.Kind.SYNTHETIC)) {
+ if (bean.getTypes().contains(type)) {
+ result = instance.get();
+ }
+ } else {
+ result = instance.get();
+ }
+ }
+
+ if (result == null) {
+ // Fallback to searching explicitly with NamedLiteral
+ instance = Arc.container().instance(type, NamedLiteral.of(name));
+ if (instance.isAvailable()) {
+ result = instance.get();
+ }
+ }
+
+ if (result == null) {
+ // Fallback to SmallRye @Identifier
+ instance = Arc.container().instance(type, Identifier.Literal.of(name));
+ if (instance.isAvailable()) {
+ result = instance.get();
+ }
+ }
+
+ return Optional.ofNullable(result);
+ }
+
+ private static Optional<BeanManager> getBeanManager() {
+ ArcContainer container = Arc.container();
+ if (container == null) {
+ return Optional.empty();
+ }
+
+ return Optional.ofNullable(container.beanManager());
+ }
+
+ private Annotation[] resolveQualifiersForType(Class<?> type) {
+ return resolveQualifiersForTypeAndName(type, null);
+ }
+
+ private Annotation[] resolveQualifiersForTypeAndName(Class<?> type, String beanName) {
+ BeanQualifierResolverIdentifier identifier = BeanQualifierResolverIdentifier.of(type.getName(), beanName);
+ CamelBeanQualifierResolver resolver = beanQualifierResolvers.get(identifier);
if (resolver != null) {
- return Optional.ofNullable(resolver.resolveQualifiers());
+ return resolver.resolveQualifiers();
}
- return Optional.empty();
+ return EMPTY_ANNOTATIONS;
}
private boolean isDefaultBean(InjectableBean<?> bean) {
diff --git a/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/RuntimeRegistry.java b/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/RuntimeRegistry.java
index 3f547bd290..539581e459 100644
--- a/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/RuntimeRegistry.java
+++ b/extensions-core/core/runtime/src/main/java/org/apache/camel/quarkus/core/RuntimeRegistry.java
@@ -22,7 +22,7 @@ import io.quarkus.runtime.RuntimeValue;
import org.apache.camel.support.DefaultRegistry;
public class RuntimeRegistry extends DefaultRegistry {
- public RuntimeRegistry(Map<String, CamelBeanQualifierResolver> beanQualifierResolvers) {
+ public RuntimeRegistry(Map<BeanQualifierResolverIdentifier, CamelBeanQualifierResolver> beanQualifierResolvers) {
super(new RuntimeBeanRepository(beanQualifierResolvers));
}
diff --git a/integration-test-groups/foundation/bean/src/test/java/org/apache/camel/quarkus/component/bean/BeanTest.java b/integration-test-groups/foundation/bean/src/test/java/org/apache/camel/quarkus/component/bean/BeanTest.java
index a3a41fe7f1..24c72f63f1 100644
--- a/integration-test-groups/foundation/bean/src/test/java/org/apache/camel/quarkus/component/bean/BeanTest.java
+++ b/integration-test-groups/foundation/bean/src/test/java/org/apache/camel/quarkus/component/bean/BeanTest.java
@@ -246,9 +246,8 @@ public class BeanTest {
RestAssured.given()
.get("/bean/allBeanInstances")
.then()
- .body("size()", is(5))
+ .body("size()", is(4))
.body(allOf(
- containsString("defaultBean"),
containsString("overridingBean"),
containsString("bean1"),
containsString("bean2"),