Compare commits
10 Commits
461dee1a7e
...
f85e998b0f
Author | SHA1 | Date |
---|---|---|
|
f85e998b0f | |
|
7e6874ad80 | |
|
097463e3b7 | |
|
f44e9899aa | |
|
37bbf28830 | |
|
e381151824 | |
|
5335ecceb4 | |
|
cd81381939 | |
|
2ab2869539 | |
|
f7f164f8ee |
|
@ -37,18 +37,18 @@ Kotlin::
|
|||
----
|
||||
======
|
||||
|
||||
[NOTE]
|
||||
[TIP]
|
||||
====
|
||||
As of Spring Framework 4.3, an `@Autowired` annotation on such a constructor is no longer
|
||||
necessary if the target bean defines only one constructor to begin with. However, if
|
||||
several constructors are available and there is no primary/default constructor, at least
|
||||
one of the constructors must be annotated with `@Autowired` in order to instruct the
|
||||
container which one to use. See the discussion on
|
||||
xref:core/beans/annotation-config/autowired.adoc#beans-autowired-annotation-constructor-resolution[constructor resolution] for details.
|
||||
An `@Autowired` annotation on such a constructor is not necessary if the target bean
|
||||
defines only one constructor. However, if several constructors are available and there is
|
||||
no primary or default constructor, at least one of the constructors must be annotated
|
||||
with `@Autowired` in order to instruct the container which one to use. See the discussion
|
||||
on xref:core/beans/annotation-config/autowired.adoc#beans-autowired-annotation-constructor-resolution[constructor resolution]
|
||||
for details.
|
||||
====
|
||||
|
||||
You can also apply the `@Autowired` annotation to _traditional_ setter methods,
|
||||
as the following example shows:
|
||||
You can apply the `@Autowired` annotation to _traditional_ setter methods, as the
|
||||
following example shows:
|
||||
|
||||
[tabs]
|
||||
======
|
||||
|
@ -84,8 +84,8 @@ Kotlin::
|
|||
----
|
||||
======
|
||||
|
||||
You can also apply the annotation to methods with arbitrary names and multiple
|
||||
arguments, as the following example shows:
|
||||
You can apply `@Autowired` to methods with arbitrary names and multiple arguments, as the
|
||||
following example shows:
|
||||
|
||||
[tabs]
|
||||
======
|
||||
|
@ -176,14 +176,15 @@ Kotlin::
|
|||
====
|
||||
Make sure that your target components (for example, `MovieCatalog` or `CustomerPreferenceDao`)
|
||||
are consistently declared by the type that you use for your `@Autowired`-annotated
|
||||
injection points. Otherwise, injection may fail due to a "no type match found" error at runtime.
|
||||
injection points. Otherwise, injection may fail due to a "no type match found" error at
|
||||
runtime.
|
||||
|
||||
For XML-defined beans or component classes found via classpath scanning, the container
|
||||
usually knows the concrete type up front. However, for `@Bean` factory methods, you need
|
||||
to make sure that the declared return type is sufficiently expressive. For components
|
||||
that implement several interfaces or for components potentially referred to by their
|
||||
implementation type, consider declaring the most specific return type on your factory
|
||||
method (at least as specific as required by the injection points referring to your bean).
|
||||
implementation type, declare the most specific return type on your factory method (at
|
||||
least as specific as required by the injection points referring to your bean).
|
||||
====
|
||||
|
||||
.[[beans-autowired-annotation-self-injection]]Self Injection
|
||||
|
@ -312,8 +313,8 @@ through `@Order` values in combination with `@Primary` on a single bean for each
|
|||
====
|
||||
|
||||
Even typed `Map` instances can be autowired as long as the expected key type is `String`.
|
||||
The map values contain all beans of the expected type, and the keys contain the
|
||||
corresponding bean names, as the following example shows:
|
||||
The map values are all beans of the expected type, and the keys are the corresponding
|
||||
bean names, as the following example shows:
|
||||
|
||||
[tabs]
|
||||
======
|
||||
|
@ -431,7 +432,7 @@ annotated constructor does not have to be public.
|
|||
====
|
||||
|
||||
Alternatively, you can express the non-required nature of a particular dependency
|
||||
through Java 8's `java.util.Optional`, as the following example shows:
|
||||
through Java's `java.util.Optional`, as the following example shows:
|
||||
|
||||
[source,java,indent=0,subs="verbatim,quotes"]
|
||||
----
|
||||
|
@ -445,8 +446,8 @@ through Java 8's `java.util.Optional`, as the following example shows:
|
|||
----
|
||||
|
||||
You can also use a parameter-level `@Nullable` annotation (of any kind in any package --
|
||||
for example, `javax.annotation.Nullable` from JSR-305) or just leverage Kotlin built-in
|
||||
null-safety support:
|
||||
for example, `org.jspecify.annotations.Nullable` from JSpecify) or just leverage Kotlin's
|
||||
built-in null-safety support:
|
||||
|
||||
[tabs]
|
||||
======
|
||||
|
@ -477,13 +478,6 @@ Kotlin::
|
|||
----
|
||||
======
|
||||
|
||||
[NOTE]
|
||||
====
|
||||
A type-level `@Nullable` annotation such as from JSpecify is not supported in Spring
|
||||
Framework 6.2 yet. You need to upgrade to Spring Framework 7.0 where the framework
|
||||
detects type-level annotations and consistently declares JSpecify in its own codebase.
|
||||
====
|
||||
|
||||
You can also use `@Autowired` for interfaces that are well-known resolvable
|
||||
dependencies: `BeanFactory`, `ApplicationContext`, `Environment`, `ResourceLoader`,
|
||||
`ApplicationEventPublisher`, and `MessageSource`. These interfaces and their extended
|
||||
|
@ -528,5 +522,6 @@ class MovieRecommender {
|
|||
The `@Autowired`, `@Inject`, `@Value`, and `@Resource` annotations are handled by Spring
|
||||
`BeanPostProcessor` implementations. This means that you cannot apply these annotations
|
||||
within your own `BeanPostProcessor` or `BeanFactoryPostProcessor` types (if any).
|
||||
|
||||
These types must be 'wired up' explicitly by using XML or a Spring `@Bean` method.
|
||||
====
|
||||
|
|
|
@ -614,93 +614,117 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
|
|||
private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
|
||||
List<String> result = new ArrayList<>();
|
||||
|
||||
// Check all bean definitions.
|
||||
processBeanDefinitions(result, type, includeNonSingletons, allowEagerInit);
|
||||
processManualSingletons(result, type, includeNonSingletons);
|
||||
|
||||
return StringUtils.toStringArray(result);
|
||||
}
|
||||
|
||||
private void processBeanDefinitions(List<String> result, ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
|
||||
for (String beanName : this.beanDefinitionNames) {
|
||||
// Only consider bean as eligible if the bean name is not defined as alias for some other bean.
|
||||
if (!isAlias(beanName)) {
|
||||
try {
|
||||
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
|
||||
// Only check bean definition if it is complete.
|
||||
if (!mbd.isAbstract() && (allowEagerInit ||
|
||||
(mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()) &&
|
||||
!requiresEagerInitForType(mbd.getFactoryBeanName()))) {
|
||||
boolean isFactoryBean = isFactoryBean(beanName, mbd);
|
||||
BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
|
||||
boolean matchFound = false;
|
||||
boolean allowFactoryBeanInit = (allowEagerInit || containsSingleton(beanName));
|
||||
boolean isNonLazyDecorated = (dbd != null && !mbd.isLazyInit());
|
||||
if (!isFactoryBean) {
|
||||
if (includeNonSingletons || isSingleton(beanName, mbd, dbd)) {
|
||||
matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit);
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (includeNonSingletons || isNonLazyDecorated) {
|
||||
matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit);
|
||||
}
|
||||
else if (allowFactoryBeanInit) {
|
||||
// Type check before singleton check, avoiding FactoryBean instantiation
|
||||
// for early FactoryBean.isSingleton() calls on non-matching beans.
|
||||
matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit) &&
|
||||
isSingleton(beanName, mbd, dbd);
|
||||
}
|
||||
if (!matchFound) {
|
||||
// In case of FactoryBean, try to match FactoryBean instance itself next.
|
||||
beanName = FACTORY_BEAN_PREFIX + beanName;
|
||||
if (includeNonSingletons || isSingleton(beanName, mbd, dbd)) {
|
||||
matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit);
|
||||
}
|
||||
}
|
||||
if (isAlias(beanName)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
try {
|
||||
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
|
||||
|
||||
// cache merged bean definition
|
||||
boolean isAbstract = mbd.isAbstract();
|
||||
boolean hasBeanClass = mbd.hasBeanClass();
|
||||
boolean isLazyInit = mbd.isLazyInit();
|
||||
String factoryBeanName = mbd.getFactoryBeanName();
|
||||
BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
|
||||
|
||||
if (shouldSkipBeanDefinition(isAbstract, allowEagerInit, hasBeanClass, isLazyInit, factoryBeanName)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
boolean isFactoryBean = isFactoryBean(beanName, mbd);
|
||||
boolean matchFound = false;
|
||||
boolean allowFactoryBeanInit = (allowEagerInit || containsSingleton(beanName));
|
||||
boolean isNonLazyDecorated = (dbd != null && !isLazyInit);
|
||||
|
||||
if (!isFactoryBean && (includeNonSingletons || isSingleton(beanName, mbd, dbd))) {
|
||||
matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit);
|
||||
}
|
||||
else {
|
||||
if (includeNonSingletons || isNonLazyDecorated) {
|
||||
matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit);
|
||||
}
|
||||
else if (allowFactoryBeanInit) {
|
||||
matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit) &&
|
||||
isSingleton(beanName, mbd, dbd);
|
||||
}
|
||||
|
||||
if (!matchFound) {
|
||||
String factoryBeanFullName = FACTORY_BEAN_PREFIX + beanName;
|
||||
if (includeNonSingletons || isSingleton(factoryBeanFullName, mbd, dbd)) {
|
||||
matchFound = isTypeMatch(factoryBeanFullName, type, allowFactoryBeanInit);
|
||||
}
|
||||
if (matchFound) {
|
||||
result.add(beanName);
|
||||
result.add(factoryBeanFullName);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (CannotLoadBeanClassException | BeanDefinitionStoreException ex) {
|
||||
if (allowEagerInit) {
|
||||
throw ex;
|
||||
}
|
||||
// Probably a placeholder: let's ignore it for type matching purposes.
|
||||
LogMessage message = (ex instanceof CannotLoadBeanClassException ?
|
||||
LogMessage.format("Ignoring bean class loading failure for bean '%s'", beanName) :
|
||||
LogMessage.format("Ignoring unresolvable metadata in bean definition '%s'", beanName));
|
||||
logger.trace(message, ex);
|
||||
// Register exception, in case the bean was accidentally unresolvable.
|
||||
onSuppressedException(ex);
|
||||
}
|
||||
catch (NoSuchBeanDefinitionException ex) {
|
||||
// Bean definition got removed while we were iterating -> ignore.
|
||||
|
||||
if (matchFound) {
|
||||
result.add(beanName);
|
||||
}
|
||||
}
|
||||
catch (CannotLoadBeanClassException | BeanDefinitionStoreException ex) {
|
||||
if (allowEagerInit) {
|
||||
throw ex;
|
||||
}
|
||||
LogMessage message = (ex instanceof CannotLoadBeanClassException ?
|
||||
LogMessage.format("Ignoring bean class loading failure for bean '%s'", beanName) :
|
||||
LogMessage.format("Ignoring unresolvable metadata in bean definition '%s'", beanName));
|
||||
logger.trace(message, ex);
|
||||
onSuppressedException(ex);
|
||||
}
|
||||
catch (NoSuchBeanDefinitionException ex) {
|
||||
// Bean definition got removed while we were iterating -> ignore
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check manually registered singletons too.
|
||||
private void processManualSingletons(List<String> result, ResolvableType type, boolean includeNonSingletons) {
|
||||
for (String beanName : this.manualSingletonNames) {
|
||||
try {
|
||||
// In case of FactoryBean, match object created by FactoryBean.
|
||||
if (isFactoryBean(beanName)) {
|
||||
if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) {
|
||||
result.add(beanName);
|
||||
// Match found for this bean: do not match FactoryBean itself anymore.
|
||||
continue;
|
||||
}
|
||||
// In case of FactoryBean, try to match FactoryBean itself next.
|
||||
beanName = FACTORY_BEAN_PREFIX + beanName;
|
||||
}
|
||||
// Match raw bean instance (might be raw FactoryBean).
|
||||
|
||||
if (isTypeMatch(beanName, type)) {
|
||||
result.add(beanName);
|
||||
}
|
||||
}
|
||||
catch (NoSuchBeanDefinitionException ex) {
|
||||
// Shouldn't happen - probably a result of circular reference resolution...
|
||||
logger.trace(LogMessage.format(
|
||||
"Failed to check manually registered singleton with name '%s'", beanName), ex);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return StringUtils.toStringArray(result);
|
||||
private boolean shouldSkipBeanDefinition(boolean isAbstract, boolean allowEagerInit,
|
||||
boolean hasBeanClass, boolean isLazyInit, @Nullable String factoryBeanName) {
|
||||
|
||||
if (isAbstract) {
|
||||
return true;
|
||||
}
|
||||
if (!allowEagerInit) {
|
||||
boolean needsEagerInit = (!hasBeanClass && isLazyInit && !isAllowEagerClassLoading()) ||
|
||||
requiresEagerInitForType(factoryBeanName);
|
||||
if (needsEagerInit) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private boolean isSingleton(String beanName, RootBeanDefinition mbd, @Nullable BeanDefinitionHolder dbd) {
|
||||
|
|
Loading…
Reference in New Issue