diff --git a/framework-docs/modules/ROOT/pages/core/beans/annotation-config/autowired-qualifiers.adoc b/framework-docs/modules/ROOT/pages/core/beans/annotation-config/autowired-qualifiers.adoc
index eb7b1199d0..24806bdffb 100644
--- a/framework-docs/modules/ROOT/pages/core/beans/annotation-config/autowired-qualifiers.adoc
+++ b/framework-docs/modules/ROOT/pages/core/beans/annotation-config/autowired-qualifiers.adoc
@@ -179,27 +179,10 @@ is preserved in `@Bean` return type signatures or collection inheritance hierarc
 In this case, you can use qualifier values to select among same-typed collections,
 as outlined in the previous paragraph.
 
-`@Autowired` also considers self references for injection (that is, references
-back to the bean that is currently injected). Note that self injection is a fallback.
-Regular dependencies on other components always have precedence. In that sense, self
-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.
-In practice, you should use self references as a last resort only (for example, for
-calling other methods on the same instance through the bean's transactional proxy).
-Consider factoring out the affected methods to a separate delegate bean in such a scenario.
-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` also considers self references for injection (that is, references back to
+the bean that is currently injected). See
+xref:core/beans/annotation-config/autowired.adoc#beans-autowired-annotation-self-injection[Self Injection]
+for details.
 
 `@Autowired` applies to fields, constructors, and multi-argument methods, allowing for
 narrowing through qualifier annotations at the parameter level. In contrast, `@Resource`
diff --git a/framework-docs/modules/ROOT/pages/core/beans/annotation-config/autowired.adoc b/framework-docs/modules/ROOT/pages/core/beans/annotation-config/autowired.adoc
index 8470dd91c2..17b7d9a639 100644
--- a/framework-docs/modules/ROOT/pages/core/beans/annotation-config/autowired.adoc
+++ b/framework-docs/modules/ROOT/pages/core/beans/annotation-config/autowired.adoc
@@ -186,14 +186,37 @@ implementation type, consider declaring the most specific return type on your fa
 method (at least as specific as required by the injection points referring to your bean).
 ====
 
+.[[beans-autowired-annotation-self-injection]]Self Injection
+****
+`@Autowired` also considers self references for injection (that is, references back to
+the bean that is currently injected).
+
+Note, however, that self injection is a fallback mechanism. Regular dependencies on other
+components always have precedence. In that sense, self references do not participate in
+regular autowiring candidate selection and are therefore in 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 on the same instance through the bean's transactional proxy. As an
+alternative, consider factoring out the affected methods to a separate delegate bean in
+such a scenario.
+
+Another alternative is to use `@Resource`, which may obtain a proxy back to the current
+bean by its unique name.
+
+======
 [NOTE]
 ====
-As of 4.3, `@Autowired` also considers self references for injection (that is, references
-back to the bean that is currently injected). Note that self injection is a fallback.
-In practice, you should use self references as a last resort only (for example, for
-calling other methods on the same instance through the bean's transactional proxy).
-Consider factoring out the affected methods to a separate delegate bean in such a scenario.
+Trying to inject the results from `@Bean` methods in 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).
 ====
+======
+****
 
 You can also instruct Spring to provide all beans of a particular type from the
 `ApplicationContext` by adding the `@Autowired` annotation to a field or method that