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

Update Asciidoctor Gradle plugin 

Upgrade to asciidoctor-gradle-plugin version 1.5.2.
Various syntax fixes in the index.adoc reference documentation.
This commit is contained in:
Brian Clozel 2015-03-02 23:25:01 +01:00
parent b7dd520784
commit 503956d7c5
2 changed files with 64 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
build.gradle
View File

@ -4,7 +4,7 @@ buildscript {
} }
dependencies { dependencies {
classpath("org.springframework.build.gradle:propdeps-plugin:0.0.7") classpath("org.springframework.build.gradle:propdeps-plugin:0.0.7")
classpath("org.asciidoctor:asciidoctor-gradle-plugin:0.7.0") classpath("org.asciidoctor:asciidoctor-gradle-plugin:1.5.2")
classpath("io.spring.gradle:docbook-reference-plugin:0.3.0") classpath("io.spring.gradle:docbook-reference-plugin:0.3.0")
classpath("ws.antonov.gradle.plugins:gradle-plugin-protobuf:0.9.1") classpath("ws.antonov.gradle.plugins:gradle-plugin-protobuf:0.9.1")
} }
@ -1096,7 +1096,7 @@ sonarRunner {
configure(rootProject) { configure(rootProject) {
description = "Spring Framework" description = "Spring Framework"
apply plugin: "asciidoctor" apply plugin: "org.asciidoctor.convert"
apply plugin: "docbook-reference" apply plugin: "docbook-reference"
apply plugin: "groovy" apply plugin: "groovy"
@ -1104,17 +1104,13 @@ configure(rootProject) {
apply from: "${gradleScriptDir}/jdiff.gradle" apply from: "${gradleScriptDir}/jdiff.gradle"
asciidoctor { asciidoctor {
baseDir = project.file('src/asciidoc') sourceDir project.file('src/asciidoc')
backend = 'docbook5' separateOutputDirs = false
options = [ backends = ['docbook5']
eruby: 'erubis', options doctype: 'book', eruby: 'erubis'
attributes: [ attributes 'spring-version': project.version,
doctype: 'book',
'spring-version' : project.version,
revnumber : project.version, revnumber : project.version,
docinfo : "" docinfo : ""
]
]
} }
reference { reference {

108
src/asciidoc/index.adoc
View File

@ -319,10 +319,10 @@ If you are going to use Spring you need to get a copy of the jar libraries that
the pieces of Spring that you need. To make this easier Spring is packaged as a set of the pieces of Spring that you need. To make this easier Spring is packaged as a set of
modules that separate the dependencies as much as possible, so for example if you don't modules that separate the dependencies as much as possible, so for example if you don't
want to write a web application you don't need the spring-web modules. To refer to want to write a web application you don't need the spring-web modules. To refer to
Spring library modules in this guide we use a shorthand naming convention `spring-*` or Spring library modules in this guide we use a shorthand naming convention `spring-{asterisk}` or
`spring-*.jar,` where `*` represents the short name for the module (e.g. `spring-core`, `spring-{asterisk}.jar,` where `{asterisk}` represents the short name for the module
`spring-webmvc`, `spring-jms`, etc.). The actual jar file name that you use is normally (e.g. `spring-core`, `spring-webmvc`, `spring-jms`, etc.). The actual jar file name that
the module name concatenated with the version number you use is normally the module name concatenated with the version number
(e.g. __spring-core-{spring-version}.jar__). (e.g. __spring-core-{spring-version}.jar__).
Each release of the Spring Framework will publish artifacts to the following places: Each release of the Spring Framework will publish artifacts to the following places:
@ -9022,7 +9022,7 @@ exist, the listener uses `/WEB-INF/applicationContext.xml` as a default. When th
parameter __does__ exist, the listener separates the String by using predefined parameter __does__ exist, the listener separates the String by using predefined
delimiters (comma, semicolon and whitespace) and uses the values as locations where delimiters (comma, semicolon and whitespace) and uses the values as locations where
application contexts will be searched. Ant-style path patterns are supported as well. application contexts will be searched. Ant-style path patterns are supported as well.
Examples are `/WEB-INF/*Context.xml` for all files with names ending with "Context.xml", Examples are `/WEB-INF/{asterisk}Context.xml` for all files with names ending with "Context.xml",
residing in the "WEB-INF" directory, and `/WEB-INF/**/*Context.xml`, for all such files residing in the "WEB-INF" directory, and `/WEB-INF/**/*Context.xml`, for all such files
in any subdirectory of "WEB-INF". in any subdirectory of "WEB-INF".
@ -9778,7 +9778,7 @@ strategy described above is used for the wildcard subpath.
[[resources-wildcards-in-path-other-stuff]] [[resources-wildcards-in-path-other-stuff]]
===== Other notes relating to wildcards ===== Other notes relating to wildcards
Please note that " `classpath*:`" when combined with Ant-style patterns will only work Please note that `classpath*:` when combined with Ant-style patterns will only work
reliably with at least one root directory before the pattern starts, unless the actual reliably with at least one root directory before the pattern starts, unless the actual
target files reside in the file system. This means that a pattern like " target files reside in the file system. This means that a pattern like "
`classpath*:*.xml`" will not retrieve files from the root of jar files but rather only `classpath*:*.xml`" will not retrieve files from the root of jar files but rather only
@ -13770,12 +13770,12 @@ The format of an execution expression is:
All parts except the returning type pattern (ret-type-pattern in the snippet above), All parts except the returning type pattern (ret-type-pattern in the snippet above),
name pattern, and parameters pattern are optional. The returning type pattern determines name pattern, and parameters pattern are optional. The returning type pattern determines
what the return type of the method must be in order for a join point to be matched. Most what the return type of the method must be in order for a join point to be matched. Most
frequently you will use `*` as the returning type pattern, which matches any return frequently you will use `{asterisk}` as the returning type pattern, which matches any return
type. A fully-qualified type name will match only when the method returns the given type. A fully-qualified type name will match only when the method returns the given
type. The name pattern matches the method name. You can use the `*` wildcard as all or type. The name pattern matches the method name. You can use the `{asterisk}` wildcard as all or
part of a name pattern. The parameters pattern is slightly more complex: `()` matches a part of a name pattern. The parameters pattern is slightly more complex: `()` matches a
method that takes no parameters, whereas `(..)` matches any number of parameters (zero method that takes no parameters, whereas `(..)` matches any number of parameters (zero
or more). The pattern `(*)` matches a method taking one parameter of any type, or more). The pattern `({asterisk})` matches a method taking one parameter of any type,
`(*,String)` matches a method taking two parameters, the first can be of any type, the `(*,String)` matches a method taking two parameters, the first can be of any type, the
second must be a String. Consult the second must be a String. Consult the
http://www.eclipse.org/aspectj/doc/released/progguide/semantics-pointcuts.html[Language http://www.eclipse.org/aspectj/doc/released/progguide/semantics-pointcuts.html[Language
@ -22230,10 +22230,11 @@ request and those will be discussed later.
[[spring-mvc-test-server-static-imports]] [[spring-mvc-test-server-static-imports]]
====== Static Imports ====== Static Imports
The fluent API in the example above requires a few static imports such as The fluent API in the example above requires a few static imports such as
`MockMvcRequestBuilders.*`, `MockMvcResultMatchers.*`, and `MockMvcBuilders.*`. An easy `MockMvcRequestBuilders.{asterisk}`, `MockMvcResultMatchers.{asterisk}`,
way to find these classes is to search for types matching __"MockMvc*"__. If using and `MockMvcBuilders.{asterisk}`. An easy way to find these classes is to search for
Eclipse, be sure to add them as "favorite static members" in the Eclipse preferences types matching __"MockMvc*"__. If using Eclipse, be sure to add them as
under__Java -> Editor -> Content Assist -> Favorites__. That will allow use of content "favorite static members" in the Eclipse preferences under
__Java -> Editor -> Content Assist -> Favorites__. That will allow use of content
assist after typing the first character of the static method name. Other IDEs (e.g. assist after typing the first character of the static method name. Other IDEs (e.g.
IntelliJ) may not require any additional configuration. Just check the support for code IntelliJ) may not require any additional configuration. Just check the support for code
completion on static members. completion on static members.
@ -22577,9 +22578,10 @@ used to verify that all expected requests were performed.
====== Static Imports ====== Static Imports
Just like with server-side tests, the fluent API for client-side tests requires a few Just like with server-side tests, the fluent API for client-side tests requires a few
static imports. Those are easy to find by searching __"MockRest*"__. Eclipse users static imports. Those are easy to find by searching __"MockRest*"__. Eclipse users
should add `"MockRestRequestMatchers.*"` and `"MockRestResponseCreators.*"` as "favorite should add `"MockRestRequestMatchers.{asterisk}"` and `"MockRestResponseCreators.{asterisk}"`
static members" in the Eclipse preferences under __Java -> Editor -> Content Assist -> as "favorite static members" in the Eclipse preferences under
Favorites__. That allows using content assist after typing the first character of the __Java -> Editor -> Content Assist -> Favorites__.
That allows using content assist after typing the first character of the
static method name. Other IDEs (e.g. IntelliJ) may not require any additional static method name. Other IDEs (e.g. IntelliJ) may not require any additional
configuration. Just check the support for code completion on static members. configuration. Just check the support for code completion on static members.
@ -23741,7 +23743,7 @@ that are nested within `<tx:advice/>` and `<tx:attributes/>` tags are summarized
| Yes | Yes
| |
| Method name(s) with which the transaction attributes are to be associated. The | Method name(s) with which the transaction attributes are to be associated. The
wildcard (*) character can be used to associate the same transaction attribute wildcard ({asterisk}) character can be used to associate the same transaction attribute
settings with a number of methods; for example, `get*`, `handle*`, `on*Event`, and so settings with a number of methods; for example, `get*`, `handle*`, `on*Event`, and so
forth. forth.
@ -27436,8 +27438,8 @@ bean, use the `initialize-database` tag in the `spring-jdbc` namespace:
The example above runs the two scripts specified against the database: the first script The example above runs the two scripts specified against the database: the first script
is a schema creation, and the second is a test data set insert. The script locations can is a schema creation, and the second is a test data set insert. The script locations can
also be patterns with wildcards in the usual ant style used for resources in Spring also be patterns with wildcards in the usual ant style used for resources in Spring
(e.g. `classpath*:/com/foo/**/sql/*-data.sql`). If a pattern is used the scripts are (e.g. `classpath{asterisk}:/com/foo/{asterisk}{asterisk}/sql/{asterisk}-data.sql`).
executed in lexical order of their URL or filename. If a pattern is used the scripts are executed in lexical order of their URL or filename.
The default behavior of the database initializer is to unconditionally execute the The default behavior of the database initializer is to unconditionally execute the
scripts provided. This will not always be what you want, for instance if running against scripts provided. This will not always be what you want, for instance if running against
@ -30644,8 +30646,8 @@ name and the second - the regular expression.For example:
[[mvc-ann-requestmapping-patterns]] [[mvc-ann-requestmapping-patterns]]
===== Path Patterns ===== Path Patterns
In addition to URI templates, the `@RequestMapping` annotation also supports Ant-style In addition to URI templates, the `@RequestMapping` annotation also supports Ant-style
path patterns (for example, `/myPath/*.do`). A combination of URI template variables and path patterns (for example, `/myPath/{asterisk}.do`). A combination of URI template variables and
Ant-style globs is also supported (e.g. `/owners/*/pets/{petId}`). Ant-style globs is also supported (e.g. `/owners/{asterisk}/pets/{petId}`).
[[mvc-ann-requestmapping-pattern-comparison]] [[mvc-ann-requestmapping-pattern-comparison]]
@ -30653,20 +30655,20 @@ Ant-style globs is also supported (e.g. `/owners/*/pets/{petId}`).
When a URL matches multiple patterns, a sort is used to find the most specific match. When a URL matches multiple patterns, a sort is used to find the most specific match.
A pattern with a lower count of URI variables and wild cards is considered more specific. A pattern with a lower count of URI variables and wild cards is considered more specific.
For example `/hotels/{hotel}/*` has 1 URI variable and 1 wild card and is considered For example `/hotels/{hotel}/{asterisk}` has 1 URI variable and 1 wild card and is considered
more specific than `/hotels/{hotel}/**` which as 1 URI variable and 2 wild cards. more specific than `/hotels/{hotel}/{asterisk}{asterisk}` which as 1 URI variable and 2 wild cards.
If two patterns have the same count, the one that is longer is considered more specific. If two patterns have the same count, the one that is longer is considered more specific.
For example `/foo/bar*` is longer and considered more specific than `/foo/*`. For example `/foo/bar{asterisk}` is longer and considered more specific than `/foo/{asterisk}`.
When two patterns have the same count and length, the pattern with fewer wild cards is considered more specific. When two patterns have the same count and length, the pattern with fewer wild cards is considered more specific.
For example `/hotels/{hotel}` is more specific than `/hotels/*`. For example `/hotels/{hotel}` is more specific than `/hotels/{asterisk}`.
There are also some additional special rules: There are also some additional special rules:
* The *default mapping pattern* `/**` is less specific than any other pattern. * The *default mapping pattern* `/{asterisk}{asterisk}` is less specific than any other pattern.
For example `/api/{a}/{b}/{c}` is more specific. For example `/api/{a}/{b}/{c}` is more specific.
* A *prefix pattern* such as `/public/**` is less specific than any other pattern that doesn't contain double wildcards. * A *prefix pattern* such as `/public/{asterisk}{asterisk}` is less specific than any other pattern that doesn't contain double wildcards.
For example `/public/path3/{a}/{b}/{c}` is more specific. For example `/public/path3/{a}/{b}/{c}` is more specific.
For the full details see `AntPatternComparator` in `AntPathMatcher`. Note that the PathMatcher For the full details see `AntPatternComparator` in `AntPathMatcher`. Note that the PathMatcher
@ -30685,8 +30687,8 @@ configuration. For more information on placeholders, see the javadocs of the
[[mvc-ann-requestmapping-suffix-pattern-match]] [[mvc-ann-requestmapping-suffix-pattern-match]]
===== Path Pattern Matching By Suffix ===== Path Pattern Matching By Suffix
By default Spring MVC automatically performs `".*"` suffix pattern matching so By default Spring MVC automatically performs `".{asterisk}"` suffix pattern matching so
that a controller mapped to `/person` is also implicitly mapped to `/person.*`. that a controller mapped to `/person` is also implicitly mapped to `/person.{asterisk}`.
This allows indicating content types via file extensions, e.g. `/person.pdf`, This allows indicating content types via file extensions, e.g. `/person.pdf`,
`/person.xml`, etc. A common pitfall however is when the last path segment of the `/person.xml`, etc. A common pitfall however is when the last path segment of the
mapping is a URI variable, e.g. `/person/{id}`. While a request for `/person/1.json` mapping is a URI variable, e.g. `/person/{id}`. While a request for `/person/1.json`
@ -31551,7 +31553,7 @@ requests from browser clients. The same annotation is recommended for use with r
from non-browser clients as well. However there is one notable difference when it comes from non-browser clients as well. However there is one notable difference when it comes
to working with HTTP PUT requests. Browsers can submit form data via HTTP GET or HTTP to working with HTTP PUT requests. Browsers can submit form data via HTTP GET or HTTP
POST. Non-browser clients can also submit forms via HTTP PUT. This presents a challenge POST. Non-browser clients can also submit forms via HTTP PUT. This presents a challenge
because the Servlet specification requires the `ServletRequest.getParameter*()` family because the Servlet specification requires the `ServletRequest.getParameter{asterisk}()` family
of methods to support form field access only for HTTP POST, not for HTTP PUT. of methods to support form field access only for HTTP POST, not for HTTP PUT.
To support HTTP PUT and PATCH requests, the `spring-web` module provides the filter To support HTTP PUT and PATCH requests, the `spring-web` module provides the filter
@ -31579,7 +31581,7 @@ To support HTTP PUT and PATCH requests, the `spring-web` module provides the fil
The above filter intercepts HTTP PUT and PATCH requests with content type The above filter intercepts HTTP PUT and PATCH requests with content type
`application/x-www-form-urlencoded`, reads the form data from the body of the request, `application/x-www-form-urlencoded`, reads the form data from the body of the request,
and wraps the `ServletRequest` in order to make the form data available through the and wraps the `ServletRequest` in order to make the form data available through the
`ServletRequest.getParameter*()` family of methods. `ServletRequest.getParameter{asterisk}()` family of methods.
[NOTE] [NOTE]
==== ====
@ -32183,7 +32185,7 @@ properties that you can use to customize their behavior:
* `alwaysUseFullPath` If `true` , Spring uses the full path within the current Servlet * `alwaysUseFullPath` If `true` , Spring uses the full path within the current Servlet
context to find an appropriate handler. If `false` (the default), the path within the context to find an appropriate handler. If `false` (the default), the path within the
current Servlet mapping is used. For example, if a Servlet is mapped using current Servlet mapping is used. For example, if a Servlet is mapped using
`/testing/*` and the `alwaysUseFullPath` property is set to true, `/testing/{asterisk}` and the `alwaysUseFullPath` property is set to true,
`/testing/viewPage.html` is used, whereas if the property is set to false, `/testing/viewPage.html` is used, whereas if the property is set to false,
`/viewPage.html` is used. `/viewPage.html` is used.
* `urlDecode` Defaults to `true`, as of Spring 2.5. If you prefer to compare encoded * `urlDecode` Defaults to `true`, as of Spring 2.5. If you prefer to compare encoded
@ -32646,7 +32648,7 @@ to the client. If a compatible view cannot be supplied by the `ViewResolver` cha
the list of views specified through the `DefaultViews` property will be consulted. This the list of views specified through the `DefaultViews` property will be consulted. This
latter option is appropriate for singleton `Views` that can render an appropriate latter option is appropriate for singleton `Views` that can render an appropriate
representation of the current resource regardless of the logical view name. The `Accept` representation of the current resource regardless of the logical view name. The `Accept`
header may include wild cards, for example `text/*`, in which case a `View` whose header may include wild cards, for example `text/{asterisk}`, in which case a `View` whose
Content-Type was `text/xml` is a compatible match. Content-Type was `text/xml` is a compatible match.
To support the resolution of a view based on a file extension, use the To support the resolution of a view based on a file extension, use the
@ -32846,7 +32848,7 @@ including the context path:
.path("/accounts").build() .path("/accounts").build()
---- ----
Or in cases where the `DispatcherServlet` is mapped by name (e.g. `/main/*`), you can Or in cases where the `DispatcherServlet` is mapped by name (e.g. `/main/{asterisk}`), you can
also have the literal part of the servlet mapping included: also have the literal part of the servlet mapping included:
[source,java,indent=0] [source,java,indent=0]
@ -33060,7 +33062,7 @@ session that might be associated with the user's request.
You can enable changing of locales by adding the `LocaleChangeInterceptor` to one of the You can enable changing of locales by adding the `LocaleChangeInterceptor` to one of the
handler mappings (see <<mvc-handlermapping>>). It will detect a parameter in the request handler mappings (see <<mvc-handlermapping>>). It will detect a parameter in the request
and change the locale. It calls `setLocale()` on the `LocaleResolver` that also exists and change the locale. It calls `setLocale()` on the `LocaleResolver` that also exists
in the context. The following example shows that calls to all `*.view` resources in the context. The following example shows that calls to all `{asterisk}.view` resources
containing a parameter named `siteLanguage` will now change the locale. So, for example, containing a parameter named `siteLanguage` will now change the locale. So, for example,
a request for the following URL, `http://www.sf.net/home.view?siteLanguage=nl` will a request for the following URL, `http://www.sf.net/home.view?siteLanguage=nl` will
change the site language to Dutch. change the site language to Dutch.
@ -33698,22 +33700,22 @@ Here is a snippet from the corresponding Spring Web MVC configuration file:
The `ControllerClassNameHandlerMapping` finds all of the various handler (or The `ControllerClassNameHandlerMapping` finds all of the various handler (or
`Controller`) beans defined in its application context and strips `Controller` off the `Controller`) beans defined in its application context and strips `Controller` off the
name to define its handler mappings. Thus, `ViewShoppingCartController` maps to the name to define its handler mappings. Thus, `ViewShoppingCartController` maps to the
`/viewshoppingcart*` request URL. `/viewshoppingcart{asterisk}` request URL.
Let's look at some more examples so that the central idea becomes immediately familiar. Let's look at some more examples so that the central idea becomes immediately familiar.
(Notice all lowercase in the URLs, in contrast to camel-cased `Controller` class names.) (Notice all lowercase in the URLs, in contrast to camel-cased `Controller` class names.)
* `WelcomeController` maps to the `/welcome*` request URL * `WelcomeController` maps to the `/welcome{asterisk}` request URL
* `HomeController` maps to the `/home*` request URL * `HomeController` maps to the `/home{asterisk}` request URL
* `IndexController` maps to the `/index*` request URL * `IndexController` maps to the `/index{asterisk}` request URL
* `RegisterController` maps to the `/register*` request URL * `RegisterController` maps to the `/register{asterisk}` request URL
In the case of `MultiActionController` handler classes, the mappings generated are In the case of `MultiActionController` handler classes, the mappings generated are
slightly more complex. The `Controller` names in the following examples are assumed to slightly more complex. The `Controller` names in the following examples are assumed to
be `MultiActionController` implementations: be `MultiActionController` implementations:
* `AdminController` maps to the `/admin/*` request URL * `AdminController` maps to the `/admin/{asterisk}` request URL
* `CatalogController` maps to the `/catalog/*` request URL * `CatalogController` maps to the `/catalog/{asterisk}` request URL
If you follow the convention of naming your `Controller` implementations as If you follow the convention of naming your `Controller` implementations as
`xxxController`, the `ControllerClassNameHandlerMapping` saves you the tedium of `xxxController`, the `ControllerClassNameHandlerMapping` saves you the tedium of
@ -34446,7 +34448,7 @@ optimization tools such as Page Speed and YSlow) so that they will be more effic
utilized by the client. The handler also properly evaluates the `Last-Modified` header utilized by the client. The handler also properly evaluates the `Last-Modified` header
(if present) so that a `304` status code will be returned as appropriate, avoiding (if present) so that a `304` status code will be returned as appropriate, avoiding
unnecessary overhead for resources that are already cached by the client. For example, unnecessary overhead for resources that are already cached by the client. For example,
to serve resource requests with a URL pattern of `/resources/**` from a to serve resource requests with a URL pattern of `/resources/{asterisk}{asterisk}` from a
`public-resources` directory within the web application root you would use: `public-resources` directory within the web application root you would use:
[source,java,indent=0] [source,java,indent=0]
@ -35535,7 +35537,7 @@ what the HTML would look like:
What if we want to display the entire list of errors for a given page? The example below What if we want to display the entire list of errors for a given page? The example below
shows that the `errors` tag also supports some basic wildcarding functionality. shows that the `errors` tag also supports some basic wildcarding functionality.
* `path="*"` - displays all errors * `path="{asterisk}"` - displays all errors
* `path="lastName"` - displays all errors associated with the `lastName` field * `path="lastName"` - displays all errors associated with the `lastName` field
* if `path` is omitted - object errors only are displayed * if `path` is omitted - object errors only are displayed
@ -35867,7 +35869,7 @@ your `'WEB-INF/lib'` directory too! If you make use of Spring's 'dateToolAttribu
[[view-velocity-contextconfig]] [[view-velocity-contextconfig]]
==== Context configuration ==== Context configuration
A suitable configuration is initialized by adding the relevant configurer bean A suitable configuration is initialized by adding the relevant configurer bean
definition to your `'*-servlet.xml'` as shown below: definition to your `'{asterisk}-servlet.xml'` as shown below:
[source,xml,indent=0] [source,xml,indent=0]
[subs="verbatim,quotes"] [subs="verbatim,quotes"]
@ -35921,7 +35923,7 @@ For non web-apps add a `VelocityConfigurationFactoryBean` or a
[[view-velocity-createtemplates]] [[view-velocity-createtemplates]]
==== Creating templates ==== Creating templates
Your templates need to be stored in the directory specified by the `*Configurer` bean Your templates need to be stored in the directory specified by the `{asterisk}Configurer` bean
shown above. This document does not cover details of creating templates for the two shown above. This document does not cover details of creating templates for the two
languages - please see their relevant websites for information. If you use the view languages - please see their relevant websites for information. If you use the view
resolvers highlighted, then the logical view names relate to the template file names in resolvers highlighted, then the logical view names relate to the template file names in
@ -39519,7 +39521,7 @@ The 3 possible behaviors are:
or `https://`. In this mode, when SockJS is enabled, both IFrame and JSONP based or `https://`. In this mode, when SockJS is enabled, both IFrame and JSONP based
transports are disabled. As a consequence, IE6 through IE9 are not supported when this transports are disabled. As a consequence, IE6 through IE9 are not supported when this
mode is enabled. mode is enabled.
* Allow all origins: to enable this mode, you should provide `*` as the allowed origin * Allow all origins: to enable this mode, you should provide `{asterisk}` as the allowed origin
value. In this mode, all transports are available. value. In this mode, all transports are available.
WebSocket and SockJS allowed origins can be configured as shown bellow: WebSocket and SockJS allowed origins can be configured as shown bellow:
@ -42443,7 +42445,7 @@ For all converters a default media type is used but can be overridden by setting
===== StringHttpMessageConverter ===== StringHttpMessageConverter
An `HttpMessageConverter` implementation that can read and write Strings from the HTTP An `HttpMessageConverter` implementation that can read and write Strings from the HTTP
request and response. By default, this converter supports all text media types ( request and response. By default, this converter supports all text media types (
`text/*`), and writes with a `Content-Type` of `text/plain`. `text/{asterisk}`), and writes with a `Content-Type` of `text/plain`.
[[rest-form-converter]] [[rest-form-converter]]
@ -42457,7 +42459,7 @@ request and response. By default, this converter reads and writes the media type
[[rest-byte-converter]] [[rest-byte-converter]]
===== ByteArrayHttpMessageConverter ===== ByteArrayHttpMessageConverter
An `HttpMessageConverter` implementation that can read and write byte arrays from the An `HttpMessageConverter` implementation that can read and write byte arrays from the
HTTP request and response. By default, this converter supports all media types ( `*/*`), HTTP request and response. By default, this converter supports all media types ( `{asterisk}/{asterisk}`),
and writes with a `Content-Type` of `application/octet-stream`. This can be overridden and writes with a `Content-Type` of `application/octet-stream`. This can be overridden
by setting the `supportedMediaTypes` property, and overriding `getContentType(byte[])`. by setting the `supportedMediaTypes` property, and overriding `getContentType(byte[])`.
@ -45123,7 +45125,7 @@ You can provide a reference to a particular MBean `server` if necessary, and the
`defaultDomain` attribute (a property of `AnnotationMBeanExporter`) accepts an alternate `defaultDomain` attribute (a property of `AnnotationMBeanExporter`) accepts an alternate
value for the generated MBean `ObjectNames`' domains. This would be used in place of the value for the generated MBean `ObjectNames`' domains. This would be used in place of the
fully qualified package name as described in the previous section on fully qualified package name as described in the previous section on
<<jmx-naming-metadata, `MetadataNamingStrategy`>>. <<jmx-naming-metadata, MetadataNamingStrategy>>.
[source,java,indent=0] [source,java,indent=0]
[subs="verbatim,quotes"] [subs="verbatim,quotes"]
@ -45427,7 +45429,7 @@ You can also use straight bean names as the link between exported beans and list
---- ----
If one wants to register a single `NotificationListener` instance for all of the beans If one wants to register a single `NotificationListener` instance for all of the beans
that the enclosing `MBeanExporter` is exporting, one can use the special wildcard `'*'` that the enclosing `MBeanExporter` is exporting, one can use the special wildcard `'{asterisk}'`
(sans quotes) as the key for an entry in the `notificationListenerMappings` property (sans quotes) as the key for an entry in the `notificationListenerMappings` property
map; for example: map; for example:
@ -49830,8 +49832,8 @@ annotate non-public methods as it changes the bytecode itself.
[TIP] [TIP]
==== ====
Spring recommends that you only annotate concrete classes (and methods of concrete Spring recommends that you only annotate concrete classes (and methods of concrete
classes) with the `@Cache*` annotation, as opposed to annotating interfaces. You classes) with the `@Cache{asterisk}` annotation, as opposed to annotating interfaces. You
certainly can place the `@Cache*` annotation on an interface (or an interface method), certainly can place the `@Cache{asterisk}` annotation on an interface (or an interface method),
but this works only as you would expect it to if you are using interface-based proxies. but this works only as you would expect it to if you are using interface-based proxies.
The fact that Java annotations are __not inherited from interfaces__ means that if you The fact that Java annotations are __not inherited from interfaces__ means that if you
are using class-based proxies ( `proxy-target-class="true"`) or the weaving-based aspect are using class-based proxies ( `proxy-target-class="true"`) or the weaving-based aspect