root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Note on injecting results from local @Bean methods (self references) 

Closes gh-23934
This commit is contained in:
Juergen Hoeller 2019-11-13 16:17:01 +01:00
parent 2c1afca9c5
commit 55011e7a0f
1 changed files with 23 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
src/docs/asciidoc/core/core-beans.adoc
View File

@ -5428,6 +5428,7 @@ If there is no other resolution indicator (such as a qualifier or a primary mark
for a non-unique dependency situation, Spring matches the injection point name for a non-unique dependency situation, Spring matches the injection point name
(that is, the field name or parameter name) against the target bean names and choose the (that is, the field name or parameter name) against the target bean names and choose the
same-named candidate, if any. same-named candidate, if any.
====
That said, if you intend to express annotation-driven injection by name, do not That said, if you intend to express annotation-driven injection by name, do not
primarily use `@Autowired`, even if it is capable of selecting by bean name among primarily use `@Autowired`, even if it is capable of selecting by bean name among
@ -5451,16 +5452,28 @@ back to the bean that is currently injected). Note that self injection is a fall
Regular dependencies on other components always have precedence. In that sense, self Regular dependencies on other components always have precedence. In that sense, self
references do not participate in regular candidate selection and are therefore in references do not participate in regular candidate selection and are therefore in
particular never primary. On the contrary, they always end up as lowest precedence. particular never primary. On the contrary, they always end up as lowest precedence.
In practice, you should use self references as a last resort only (for example, for calling other methods In practice, you should use self references as a last resort only (for example, for
on the same instance through the bean's transactional proxy). Consider factoring out calling other methods on the same instance through the bean's transactional proxy).
the effected methods to a separate delegate bean in such a scenario. Alternatively, you Consider factoring out the effected methods to a separate delegate bean in such a scenario.
can use `@Resource`, which may obtain a proxy back to the current bean by its unique name. Alternatively, you can use `@Resource`, which may obtain a proxy back to the current bean
by its unique name.
[NOTE]
====
Trying to inject the results from `@Bean` methods on the same configuration class is
effectively a self-reference scenario as well. Either lazily resolve such references
in the method signature where it is actually needed (as opposed to an autowired field
in the configuration class) or declare the affected `@Bean` methods as `static`,
decoupling them from the containing configuration class instance and its lifecycle.
Otherwise, such beans are only considered in the fallback phase, with matching beans
on other configuration classes selected as primary candidates instead (if available).
====
`@Autowired` applies to fields, constructors, and multi-argument methods, allowing for `@Autowired` applies to fields, constructors, and multi-argument methods, allowing for
narrowing through qualifier annotations at the parameter level. In contrast, `@Resource` narrowing through qualifier annotations at the parameter level. In contrast, `@Resource`
is supported only for fields and bean property setter methods with a single argument. is supported only for fields and bean property setter methods with a single argument.
As a consequence, you should stick with qualifiers if your injection target is a constructor or a As a consequence, you should stick with qualifiers if your injection target is a
multi-argument method. constructor or a multi-argument method.
You can create your own custom qualifier annotations. To do so, define an annotation and You can create your own custom qualifier annotations. To do so, define an annotation and
provide the `@Qualifier` annotation within your definition, as the following example shows: provide the `@Qualifier` annotation within your definition, as the following example shows:
@ -6849,12 +6862,12 @@ constraints applying.
==== ====
You may declare `@Bean` methods as `static`, allowing for them to be called without You may declare `@Bean` methods as `static`, allowing for them to be called without
creating their containing configuration class as an instance. This makes particular creating their containing configuration class as an instance. This makes particular
sense when defining post-processor beans (for example, of type `BeanFactoryPostProcessor` or sense when defining post-processor beans (for example, of type `BeanFactoryPostProcessor`
`BeanPostProcessor`), since such beans get initialized early in the container or `BeanPostProcessor`), since such beans get initialized early in the container
lifecycle and should avoid triggering other parts of the configuration at that point. lifecycle and should avoid triggering other parts of the configuration at that point.
Calls to static `@Bean` methods never get intercepted by the container, Calls to static `@Bean` methods never get intercepted by the container, not even within
not even within `@Configuration` classes (as described earlier in this section), due to technical `@Configuration` classes (as described earlier in this section), due to technical
limitations: CGLIB subclassing can override only non-static methods. As a consequence, limitations: CGLIB subclassing can override only non-static methods. As a consequence,
a direct call to another `@Bean` method has standard Java semantics, resulting a direct call to another `@Bean` method has standard Java semantics, resulting
in an independent instance being returned straight from the factory method itself. in an independent instance being returned straight from the factory method itself.