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

Polishing

This commit is contained in:
Juergen Hoeller 2023-08-21 12:37:58 +02:00
parent b0fc2fe473
commit 8a6c0cd221
4 changed files with 41 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
framework-docs/modules/ROOT/pages/core/beans/basics.adoc
View File

@ -22,10 +22,11 @@ additional metadata formats.
In most application scenarios, explicit user code is not required to instantiate one or In most application scenarios, explicit user code is not required to instantiate one or
more instances of a Spring IoC container. For example, in a web application scenario, a more instances of a Spring IoC container. For example, in a web application scenario, a
simple eight (or so) lines of boilerplate web descriptor XML in the `web.xml` file simple eight (or so) lines of boilerplate web descriptor XML in the `web.xml` file
of the application typically suffices (see xref:core/beans/context-introduction.adoc#context-create[Convenient ApplicationContext Instantiation for Web Applications]). If you use the of the application typically suffices (see
https://spring.io/tools[Spring Tools for Eclipse] (an Eclipse-powered development xref:core/beans/context-introduction.adoc#context-create[Convenient ApplicationContext Instantiation for Web Applications]).
environment), you can easily create this boilerplate configuration with a few mouse clicks or If you use the https://spring.io/tools[Spring Tools for Eclipse] (an Eclipse-powered
keystrokes. development environment), you can easily create this boilerplate configuration with a
few mouse clicks or keystrokes.
The following diagram shows a high-level view of how Spring works. Your application classes The following diagram shows a high-level view of how Spring works. Your application classes
are combined with configuration metadata so that, after the `ApplicationContext` is are combined with configuration metadata so that, after the `ApplicationContext` is
@ -139,9 +140,11 @@ Kotlin::
[NOTE] [NOTE]
==== ====
After you learn about Spring's IoC container, you may want to know more about Spring's After you learn about Spring's IoC container, you may want to know more about Spring's
`Resource` abstraction (as described in xref:web/webflux-webclient/client-builder.adoc#webflux-client-builder-reactor-resources[Resources]), which provides a convenient `Resource` abstraction (as described in
mechanism for reading an InputStream from locations defined in a URI syntax. In particular, xref:web/webflux-webclient/client-builder.adoc#webflux-client-builder-reactor-resources[Resources])
`Resource` paths are used to construct applications contexts, as described in xref:core/resources.adoc#resources-app-ctx[Application Contexts and Resource Paths]. which provides a convenient mechanism for reading an InputStream from locations defined
in a URI syntax. In particular, `Resource` paths are used to construct applications contexts,
as described in xref:core/resources.adoc#resources-app-ctx[Application Contexts and Resource Paths].
==== ====
The following example shows the service layer objects `(services.xml)` configuration file: The following example shows the service layer objects `(services.xml)` configuration file:
@ -208,9 +211,9 @@ XML configuration file represents a logical layer or module in your architecture
You can use the application context constructor to load bean definitions from all these You can use the application context constructor to load bean definitions from all these
XML fragments. This constructor takes multiple `Resource` locations, as was shown in the XML fragments. This constructor takes multiple `Resource` locations, as was shown in the
xref:core/beans/basics.adoc#beans-factory-instantiation[previous section]. Alternatively, use one or more xref:core/beans/basics.adoc#beans-factory-instantiation[previous section]. Alternatively,
occurrences of the `<import/>` element to load bean definitions from another file or use one or more occurrences of the `<import/>` element to load bean definitions from
files. The following example shows how to do so: another file or files. The following example shows how to do so:
[source,xml,indent=0,subs="verbatim,quotes"] [source,xml,indent=0,subs="verbatim,quotes"]
---- ----

23
framework-docs/modules/ROOT/pages/core/beans/factory-extension.adoc
View File

@ -23,9 +23,8 @@ You can set this property only if the `BeanPostProcessor` implements the `Ordere
interface. If you write your own `BeanPostProcessor`, you should consider implementing interface. If you write your own `BeanPostProcessor`, you should consider implementing
the `Ordered` interface, too. For further details, see the javadoc of the the `Ordered` interface, too. For further details, see the javadoc of the
{api-spring-framework}/beans/factory/config/BeanPostProcessor.html[`BeanPostProcessor`] {api-spring-framework}/beans/factory/config/BeanPostProcessor.html[`BeanPostProcessor`]
and {api-spring-framework}/core/Ordered.html[`Ordered`] interfaces. See also the note and {api-spring-framework}/core/Ordered.html[`Ordered`] interfaces. See also the note on
on xref:core/beans/factory-extension.adoc#beans-factory-programmatically-registering-beanpostprocessors[programmatic registration of `BeanPostProcessor` instances] xref:core/beans/factory-extension.adoc#beans-factory-programmatically-registering-beanpostprocessors[programmatic registration of `BeanPostProcessor` instances].
.
[NOTE] [NOTE]
==== ====
@ -280,11 +279,12 @@ and {api-spring-framework}/core/Ordered.html[`Ordered`] interfaces for more deta
==== ====
If you want to change the actual bean instances (that is, the objects that are created If you want to change the actual bean instances (that is, the objects that are created
from the configuration metadata), then you instead need to use a `BeanPostProcessor` from the configuration metadata), then you instead need to use a `BeanPostProcessor`
(described earlier in xref:core/beans/factory-extension.adoc#beans-factory-extension-bpp[Customizing Beans by Using a `BeanPostProcessor`]). While it is technically possible (described earlier in
to work with bean instances within a `BeanFactoryPostProcessor` (for example, by using xref:core/beans/factory-extension.adoc#beans-factory-extension-bpp[Customizing Beans by Using a `BeanPostProcessor`]).
`BeanFactory.getBean()`), doing so causes premature bean instantiation, violating the While it is technically possible to work with bean instances within a `BeanFactoryPostProcessor`
standard container lifecycle. This may cause negative side effects, such as bypassing (for example, by using `BeanFactory.getBean()`), doing so causes premature bean instantiation,
bean post processing. violating the standard container lifecycle. This may cause negative side effects, such as
bypassing bean post processing.
Also, `BeanFactoryPostProcessor` instances are scoped per-container. This is only relevant Also, `BeanFactoryPostProcessor` instances are scoped per-container. This is only relevant
if you use container hierarchies. If you define a `BeanFactoryPostProcessor` in one if you use container hierarchies. If you define a `BeanFactoryPostProcessor` in one
@ -331,8 +331,7 @@ with placeholder values is defined:
<property name="locations" value="classpath:com/something/jdbc.properties"/> <property name="locations" value="classpath:com/something/jdbc.properties"/>
</bean> </bean>
<bean id="dataSource" destroy-method="close" <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"/> <property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/> <property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/> <property name="username" value="${jdbc.username}"/>
@ -433,8 +432,8 @@ This example file can be used with a container definition that contains a bean c
Compound property names are also supported, as long as every component of the path Compound property names are also supported, as long as every component of the path
except the final property being overridden is already non-null (presumably initialized except the final property being overridden is already non-null (presumably initialized
by the constructors). In the following example, the `sammy` property of the `bob` property of the `fred` property of the `tom` bean by the constructors). In the following example, the `sammy` property of the `bob`
is set to the scalar value `123`: property of the `fred` property of the `tom` bean is set to the scalar value `123`:
[literal,subs="verbatim,quotes"] [literal,subs="verbatim,quotes"]
---- ----

13
framework-docs/modules/ROOT/pages/core/beans/factory-scopes.adoc
View File

@ -125,8 +125,8 @@ objects regardless of scope, in the case of prototypes, configured destruction
lifecycle callbacks are not called. The client code must clean up prototype-scoped lifecycle callbacks are not called. The client code must clean up prototype-scoped
objects and release expensive resources that the prototype beans hold. To get objects and release expensive resources that the prototype beans hold. To get
the Spring container to release resources held by prototype-scoped beans, try using a the Spring container to release resources held by prototype-scoped beans, try using a
custom xref:core/beans/factory-extension.adoc#beans-factory-extension-bpp[bean post-processor], which holds a reference to custom xref:core/beans/factory-extension.adoc#beans-factory-extension-bpp[bean post-processor]
beans that need to be cleaned up. which holds a reference to beans that need to be cleaned up.
In some respects, the Spring container's role in regard to a prototype-scoped bean is a In some respects, the Spring container's role in regard to a prototype-scoped bean is a
replacement for the Java `new` operator. All lifecycle management past that point must replacement for the Java `new` operator. All lifecycle management past that point must
@ -449,12 +449,13 @@ understand the "`why`" as well as the "`how`" behind it:
---- ----
<1> The line that defines the proxy. <1> The line that defines the proxy.
To create such a proxy, you insert a child `<aop:scoped-proxy/>` element into a
scoped bean definition (see
xref:core/beans/factory-scopes.adoc#beans-factory-scopes-other-injection-proxies[Choosing the Type of Proxy to Create]
and xref:core/appendix/xsd-schemas.adoc[XML Schema-based configuration]).
To create such a proxy, you insert a child `<aop:scoped-proxy/>` element into a scoped
bean definition (see xref:core/beans/factory-scopes.adoc#beans-factory-scopes-other-injection-proxies[Choosing the Type of Proxy to Create] and
xref:core/appendix/xsd-schemas.adoc[XML Schema-based configuration]).
Why do definitions of beans scoped at the `request`, `session` and custom-scope Why do definitions of beans scoped at the `request`, `session` and custom-scope
levels require the `<aop:scoped-proxy/>` element? levels require the `<aop:scoped-proxy/>` element in common scenarios?
Consider the following singleton bean definition and contrast it with Consider the following singleton bean definition and contrast it with
what you need to define for the aforementioned scopes (note that the following what you need to define for the aforementioned scopes (note that the following
`userPreferences` bean definition as it stands is incomplete): `userPreferences` bean definition as it stands is incomplete):

18
framework-docs/modules/ROOT/pages/core/beans/java/bean-annotation.adoc
View File

@ -180,9 +180,10 @@ Kotlin::
---- ----
====== ======
The resolution mechanism is pretty much identical to constructor-based dependency The resolution mechanism is pretty much identical to constructor-based dependency
injection. See xref:core/beans/dependencies/factory-collaborators.adoc#beans-constructor-injection[the relevant section] for more details. injection. See
xref:core/beans/dependencies/factory-collaborators.adoc#beans-constructor-injection[the relevant section]
for more details.
[[beans-java-lifecycle-callbacks]] [[beans-java-lifecycle-callbacks]]
@ -317,8 +318,9 @@ type, making it harder to use for cross-reference calls in other `@Bean` methods
intend to refer to the provided resource here). intend to refer to the provided resource here).
===== =====
In the case of `BeanOne` from the example above the preceding note, it would be equally valid to call the `init()` In the case of `BeanOne` from the example above the preceding note, it would be
method directly during construction, as the following example shows: equally valid to call the `init()` method directly during construction, as the
following example shows:
[tabs] [tabs]
====== ======
@ -506,10 +508,10 @@ Kotlin::
[[beans-java-bean-aliasing]] [[beans-java-bean-aliasing]]
== Bean Aliasing == Bean Aliasing
As discussed in xref:core/beans/definition.adoc#beans-beanname[Naming Beans], it is sometimes desirable to give a single bean As discussed in xref:core/beans/definition.adoc#beans-beanname[Naming Beans], it is
multiple names, otherwise known as bean aliasing. The `name` attribute of the `@Bean` sometimes desirable to give a single bean multiple names, otherwise known as bean aliasing.
annotation accepts a String array for this purpose. The following example shows how to set The `name` attribute of the `@Bean` annotation accepts a String array for this purpose.
a number of aliases for a bean: The following example shows how to set a number of aliases for a bean:
[tabs] [tabs]
====== ======