diff --git a/spring-boot-project/spring-boot-docs/src/main/asciidoc/spring-boot-features.adoc b/spring-boot-project/spring-boot-docs/src/main/asciidoc/spring-boot-features.adoc index e6b812c560..f47d0d5ab4 100644 --- a/spring-boot-project/spring-boot-docs/src/main/asciidoc/spring-boot-features.adoc +++ b/spring-boot-project/spring-boot-docs/src/main/asciidoc/spring-boot-features.adoc @@ -4,8 +4,8 @@ [partintro] -- This section dives into the details of Spring Boot. Here you can learn about the key -features that you may want to use and customize. If you have not already done so, you might want -to read the "<>" and +features that you may want to use and customize. If you have not already done so, you +might want to read the "<>" and "<>" sections so that you have a good grounding of the basics. -- @@ -91,10 +91,10 @@ For instance, if you are running your application by using `java -jar`, you can [[boot-features-banner]] === Customizing the Banner -The banner that is printed on start up can be changed by adding a `banner.txt` file -to your classpath or by setting the `banner.location` property to the location of such a file. -If the file has an encoding other than UTF-8, you can set `banner.charset`. -In addition to a text file, you can also add a `banner.gif`, `banner.jpg`, or `banner.png` +The banner that is printed on start up can be changed by adding a `banner.txt` file to +your classpath or by setting the `banner.location` property to the location of such a +file. If the file has an encoding other than UTF-8, you can set `banner.charset`. In +addition to a text file, you can also add a `banner.gif`, `banner.jpg`, or `banner.png` image file to your classpath or set the `banner.image.location` property. Images are converted into an ASCII art representation and printed above any text banner. @@ -141,8 +141,8 @@ The printed banner is registered as a singleton bean under the following name: [NOTE] ==== -YAML maps `off` to `false`, so be sure to add quotes if you want to disable the -banner in your application. +YAML maps `off` to `false`, so be sure to add quotes if you want to disable the banner in +your application. [source,yaml,indent=0] ---- @@ -170,8 +170,8 @@ NOTE: The constructor arguments passed to `SpringApplication` are configuration for spring beans. In most cases, these are references to `@Configuration` classes, but they could also be references to XML configuration or to packages that should be scanned. -It is also possible to configure the `SpringApplication` by using an `application.properties` -file. See _<>_ for details. +It is also possible to configure the `SpringApplication` by using an +`application.properties` file. See _<>_ for details. For a complete list of the configuration options, see the {dc-spring-boot}/SpringApplication.{dc-ext}[`SpringApplication` Javadoc]. @@ -181,20 +181,21 @@ For a complete list of the configuration options, see the [[boot-features-fluent-builder-api]] === Fluent Builder API If you need to build an `ApplicationContext` hierarchy (multiple contexts with a -parent/child relationship) or if you just prefer using a '`fluent`' builder API, you -can use the `SpringApplicationBuilder`. +parent/child relationship) or if you just prefer using a '`fluent`' builder API, you can +use the `SpringApplicationBuilder`. -The `SpringApplicationBuilder` lets you chain together multiple method calls and -includes `parent` and `child` methods that let you create a hierarchy, as shown in the following example: +The `SpringApplicationBuilder` lets you chain together multiple method calls and includes +`parent` and `child` methods that let you create a hierarchy, as shown in the following +example: [source,java,indent=0] ---- include::{code-examples}/builder/SpringApplicationBuilderExample.java[tag=hierarchy] ---- -NOTE: There are some restrictions when creating an `ApplicationContext` hierarchy. For example, -Web components *must* be contained within the child context, and the same `Environment` -is used for both parent and child contexts. See the +NOTE: There are some restrictions when creating an `ApplicationContext` hierarchy. For +example, Web components *must* be contained within the child context, and the same +`Environment` is used for both parent and child contexts. See the {dc-spring-boot}/builder/SpringApplicationBuilder.{dc-ext}[`SpringApplicationBuilder` Javadoc] for full details. @@ -214,8 +215,8 @@ cannot register a listener on those as a `@Bean`. You can register them with the methods. If you want those listeners to be registered automatically, regardless of the way the -application is created, you can add a `META-INF/spring.factories` file to your project -and reference your listener(s) by using the `org.springframework.context.ApplicationListener` +application is created, you can add a `META-INF/spring.factories` file to your project and +reference your listener(s) by using the `org.springframework.context.ApplicationListener` key. [indent=0] @@ -227,8 +228,8 @@ key. Application events are sent in the following order, as your application runs: -. An `ApplicationStartingEvent` is sent at the start of a run but before any - processing except the registration of listeners and initializers. +. An `ApplicationStartingEvent` is sent at the start of a run but before any processing + except the registration of listeners and initializers. . An `ApplicationEnvironmentPreparedEvent` is sent when the `Environment` to be used in the context is known but before the context is created. . An `ApplicationPreparedEvent` is sent just before the refresh is started but after bean @@ -240,32 +241,32 @@ Application events are sent in the following order, as your application runs: TIP: You often need not use application events, but it can be handy to know that they exist. Internally, Spring Boot uses events to handle a variety of tasks. -Application events are sent by using Spring Framework's event publishing mechanism. Part of -this mechanism ensures that an event published to the listeners in a child context -is also published to the listeners in any ancestors contexts. As a result of this, if -your application uses a hierarchy of `SpringApplication` instances, a listener may -receive multiple instances of the same type of application event. +Application events are sent by using Spring Framework's event publishing mechanism. Part +of this mechanism ensures that an event published to the listeners in a child context is +also published to the listeners in any ancestors contexts. As a result of this, if your +application uses a hierarchy of `SpringApplication` instances, a listener may receive +multiple instances of the same type of application event. To allow your listener to distinguish between an event for its context and an event for -a descendant context, it should request that its application context is injected and -then compare the injected context with the context of the event. The context can be injected -by implementing `ApplicationContextAware` or, if the listener is a bean, by using `@Autowired`. +a descendant context, it should request that its application context is injected and then +compare the injected context with the context of the event. The context can be injected by +implementing `ApplicationContextAware` or, if the listener is a bean, by using `@Autowired`. [[boot-features-web-environment]] === Web Environment -A `SpringApplication` attempts to create the right type of `ApplicationContext` on -your behalf. By default, an `AnnotationConfigApplicationContext` or -`AnnotationConfigServletWebServerApplicationContext` is used, depending on whether you -are developing a web application or not. +A `SpringApplication` attempts to create the right type of `ApplicationContext` on your +behalf. By default, an `AnnotationConfigApplicationContext` or +`AnnotationConfigServletWebServerApplicationContext` is used, depending on whether you are +developing a web application or not. -The algorithm used to determine a '`web environment`' is fairly simplistic (it is based on the -presence of a few classes). You can use `setWebEnvironment(boolean webEnvironment)` if +The algorithm used to determine a '`web environment`' is fairly simplistic (it is based on +the presence of a few classes). You can use `setWebEnvironment(boolean webEnvironment)` if you need to override the default. -It is also possible to take complete control of the `ApplicationContext` type that is -used by calling `setApplicationContextClass(...)`. +It is also possible to take complete control of the `ApplicationContext` type that is used +by calling `setApplicationContextClass(...)`. TIP: It is often desirable to call `setWebEnvironment(false)` when using `SpringApplication` within a JUnit test. @@ -355,8 +356,8 @@ include::{code-examples}/ExitCodeApplication.java[tag=example] ---- Also, the `ExitCodeGenerator` interface may be implemented by exceptions. When such an -exception is encountered, Spring Boot returns the exit code provided by the -implemented `getExitCode()` method. +exception is encountered, Spring Boot returns the exit code provided by the implemented +`getExitCode()` method. [[boot-features-application-admin]] @@ -365,13 +366,14 @@ It is possible to enable admin-related features for the application by specifyin `spring.application.admin.enabled` property. This exposes the {sc-spring-boot}/admin/SpringApplicationAdminMXBean.{sc-ext}[`SpringApplicationAdminMXBean`] on the platform `MBeanServer`. You could use this feature to administer your Spring Boot -application remotely. This feature could also be useful for any service wrapper implementation. +application remotely. This feature could also be useful for any service wrapper +implementation. TIP: If you want to know on which HTTP port the application is running, get the property with a key of `local.server.port`. -CAUTION: Take care when enabling this feature, as the MBean exposes a method to shutdown the -application. +CAUTION: Take care when enabling this feature, as the MBean exposes a method to shutdown +the application. @@ -382,8 +384,8 @@ application code in different environments. You can use properties files, YAML f environment variables, and command-line arguments to externalize configuration. Property values can be injected directly into your beans by using the `@Value` annotation, accessed through Spring's `Environment` abstraction or -<> -through `@ConfigurationProperties`. +<> through `@ConfigurationProperties`. Spring Boot uses a very particular `PropertySource` order that is designed to allow sensible overriding of values. Properties are considered in the following order: @@ -417,8 +419,8 @@ sensible overriding of values. Properties are considered in the following order: annotations on your `@Configuration` classes. . Default properties (specified using `SpringApplication.setDefaultProperties`). -To provide a concrete example, suppose you develop a `@Component` that uses a -`name` property, as shown in the following example: +To provide a concrete example, suppose you develop a `@Component` that uses a `name` +property, as shown in the following example: [source,java,indent=0] ---- @@ -437,44 +439,47 @@ To provide a concrete example, suppose you develop a `@Component` that uses a ---- On your application classpath (for example, inside your jar) you can have an -`application.properties` file that provides a sensible default property value for `name`. When -running in a new environment, an `application.properties` file can be provided outside of your -jar that overrides the `name`. For one-off testing, you can launch with a specific -command line switch (for example, `java -jar app.jar --name="Spring"`). +`application.properties` file that provides a sensible default property value for `name`. +When running in a new environment, an `application.properties` file can be provided +outside of your jar that overrides the `name`. For one-off testing, you can launch with a +specific command line switch (for example, `java -jar app.jar --name="Spring"`). [TIP] ==== -The `SPRING_APPLICATION_JSON` properties can be supplied on the -command line with an environment variable. For example, you could use the following line in a -UN{asterisk}X shell: +The `SPRING_APPLICATION_JSON` properties can be supplied on the command line with an +environment variable. For example, you could use the following line in a UN{asterisk}X +shell: ---- $ SPRING_APPLICATION_JSON='{"foo":{"bar":"spam"}}' java -jar myapp.jar ---- -In the preceding example, you end up with `foo.bar=spam` in the Spring -`Environment`. You can also supply the JSON as -`spring.application.json` in a System property, as shown in the following example: +In the preceding example, you end up with `foo.bar=spam` in the Spring `Environment`. You +can also supply the JSON as `spring.application.json` in a System property, as shown in +the following example: ---- $ java -Dspring.application.json='{"foo":"bar"}' -jar myapp.jar ---- -You can also supply the JSON by using a command line argument, as shown in the following example: +You can also supply the JSON by using a command line argument, as shown in the following +example: ---- $ java -jar myapp.jar --spring.application.json='{"foo":"bar"}' ---- -You can also supply the JSON as a JNDI variable, as follows: `java:comp/env/spring.application.json`. -==== +You can also supply the JSON as a JNDI variable, as follows: +`java:comp/env/spring.application.json`. + [[boot-features-external-config-random-values]] === Configuring Random Values -The `RandomValuePropertySource` is useful for injecting random values (for example, into secrets -or test cases). It can produce integers, longs, uuids or strings, as shown in the following example: +The `RandomValuePropertySource` is useful for injecting random values (for example, into +secrets or test cases). It can produce integers, longs, uuids or strings, as shown in the +following example: [source,properties,indent=0] ---- @@ -494,20 +499,20 @@ value and `max` is the maximum value (exclusive). [[boot-features-external-config-command-line-args]] === Accessing Command Line Properties -By default, `SpringApplication` converts any command line option arguments (that is, arguments starting -with '`--`', such as `--server.port=9000`) to a `property` and add it to the Spring -`Environment`. As mentioned previously, command line properties always take precedence over -other property sources. +By default, `SpringApplication` converts any command line option arguments (that is, +arguments starting with '`--`', such as `--server.port=9000`) to a `property` and add it +to the Spring `Environment`. As mentioned previously, command line properties always take +precedence over other property sources. -If you do not want command line properties to be added to the `Environment`, you can disable -them by using `SpringApplication.setAddCommandLineProperties(false)`. +If you do not want command line properties to be added to the `Environment`, you can +disable them by using `SpringApplication.setAddCommandLineProperties(false)`. [[boot-features-external-config-application-property-files]] === Application Property Files -`SpringApplication` loads properties from `application.properties` files in the -following locations and adds them to the Spring `Environment`: +`SpringApplication` loads properties from `application.properties` files in the following +locations and adds them to the Spring `Environment`: . A `/config` subdirectory of the current directory. . The current directory @@ -517,14 +522,14 @@ following locations and adds them to the Spring `Environment`: The list is ordered by precedence (properties defined in locations higher in the list override those defined in lower locations). -NOTE: You can also <> as -an alternative to '.properties'. +NOTE: You can also <> as an +alternative to '.properties'. If you do not like `application.properties` as the configuration file name, you can switch -to another file name by specifying a `spring.config.name` environment property. You can also refer -to an explicit location by using the `spring.config.location` environment property -(a comma-separated list of directory locations or file paths). The following example -shows how to specify a different file name: +to another file name by specifying a `spring.config.name` environment property. You can +also refer to an explicit location by using the `spring.config.location` environment +property (a comma-separated list of directory locations or file paths). The following +example shows how to specify a different file name: [indent=0] ---- @@ -540,11 +545,12 @@ The following example shows how to specify two locations: WARNING: `spring.config.name` and `spring.config.location` are used very early to determine which files have to be loaded, so they must be defined as an environment -property (typically an OS environment variable, a system property, or a command line argument). +property (typically an OS environment variable, a system property, or a command line +argument). -If `spring.config.location` contains directories (as opposed to files), they should end -in `/` (and, at runtime, be appended with the names generated from `spring.config.name` before -being loaded, including profile-specific file names). Files specified in +If `spring.config.location` contains directories (as opposed to files), they should end in +`/` (and, at runtime, be appended with the names generated from `spring.config.name` +before being loaded, including profile-specific file names). Files specified in `spring.config.location` are used as-is, with no support for profile-specific variants, and are overridden by any profile-specific properties. @@ -557,9 +563,9 @@ Config locations are searched in reverse order. By default, the configured locat . `classpath:/` When custom config locations are configured, they are used in addition to the default -locations. Custom locations are searched before the default locations. For example, -if custom locations of `classpath:/custom-config/,file:./custom-config/` are configured, -the search order becomes: +locations. Custom locations are searched before the default locations. For example, if +custom locations of `classpath:/custom-config/,file:./custom-config/` are configured, the +search order becomes: . `file:./custom-config/` . `classpath:custom-config/` @@ -568,19 +574,18 @@ the search order becomes: . `classpath:/config/` . `classpath:/` -This search ordering lets you specify default values in one configuration file -and then selectively override those values in another. You can provide default values -for your application in `application.properties` (or whatever other basename you choose -with `spring.config.name`) in one of the default locations. These default values can -then be overriden at runtime with a different file located in one of the custom -locations. +This search ordering lets you specify default values in one configuration file and then +selectively override those values in another. You can provide default values for your +application in `application.properties` (or whatever other basename you choose with +`spring.config.name`) in one of the default locations. These default values can then be +overriden at runtime with a different file located in one of the custom locations. NOTE: If you use environment variables rather than system properties, most operating -systems disallow period-separated key names, but you can use underscores instead (for example, -`SPRING_CONFIG_NAME` instead of `spring.config.name`). +systems disallow period-separated key names, but you can use underscores instead (for +example, `SPRING_CONFIG_NAME` instead of `spring.config.name`). -NOTE: If your application runs in a container, then JNDI properties (in `java:comp/env`) or -servlet context initialization parameters can be used instead of, or as well as, +NOTE: If your application runs in a container, then JNDI properties (in `java:comp/env`) +or servlet context initialization parameters can be used instead of, or as well as, environment variables or system properties. @@ -589,9 +594,9 @@ environment variables or system properties. === Profile-specific Properties In addition to `application.properties` files, profile-specific properties can also be defined by using the naming convention `application-{profile}.properties`. The -`Environment` has a set of default profiles (by default `[default]`) that are -used if no active profiles are set. In other words, if no profiles are explicitly activated, -then properties from `application-default.properties` are loaded. +`Environment` has a set of default profiles (by default `[default]`) that are used if no +active profiles are set. In other words, if no profiles are explicitly activated, then +properties from `application-default.properties` are loaded. Profile-specific properties are loaded from the same locations as standard `application.properties`, with profile-specific files always overriding the non-specific @@ -599,8 +604,8 @@ ones, irrespective of whether the profile-specific files are inside or outside y packaged jar. If several profiles are specified, a last-wins strategy applies. For example, profiles -specified by the `spring.profiles.active` property are added after those configured through -the `SpringApplication` API and therefore take precedence. +specified by the `spring.profiles.active` property are added after those configured +through the `SpringApplication` API and therefore take precedence. NOTE: If you have specified any files in `spring.config.location`, profile-specific variants of those files are not considered. Use directories in @@ -611,8 +616,8 @@ variants of those files are not considered. Use directories in [[boot-features-external-config-placeholders-in-properties]] === Placeholders in Properties The values in `application.properties` are filtered through the existing `Environment` -when they are used, so you can refer back to previously defined values (for example, from System -properties). +when they are used, so you can refer back to previously defined values (for example, from +System properties). [source,properties,indent=0] ---- @@ -621,16 +626,16 @@ properties). ---- TIP: You can also use this technique to create '`short`' variants of existing Spring Boot -properties. See the _<>_ how-to -for details. +properties. See the _<>_ how-to for +details. [[boot-features-external-config-yaml]] === Using YAML Instead of Properties -http://yaml.org[YAML] is a superset of JSON and, as such, is a very convenient format -for specifying hierarchical configuration data. The `SpringApplication` class -automatically supports YAML as an alternative to properties whenever you have the +http://yaml.org[YAML] is a superset of JSON and, as such, is a very convenient format for +specifying hierarchical configuration data. The `SpringApplication` class automatically +supports YAML as an alternative to properties whenever you have the http://www.snakeyaml.org/[SnakeYAML] library on your classpath. NOTE: If you use '`Starters`', SnakeYAML is automatically provided by @@ -688,8 +693,9 @@ The preceding example would be transformed into these properties: To bind to properties like that by using the Spring `DataBinder` utilities (which is what `@ConfigurationProperties` does), you need to have a property in the target bean of type -`java.util.List` (or `Set`) and you either need to provide a setter or initialize it -with a mutable value. For example, the following example binds to the properties shown previously: +`java.util.List` (or `Set`) and you either need to provide a setter or initialize it with +a mutable value. For example, the following example binds to the properties shown +previously: [source,java,indent=0] ---- @@ -706,11 +712,12 @@ with a mutable value. For example, the following example binds to the properties [NOTE] ==== -Extra care is required when configuring lists as shown in the preceding example, as overriding does not work as you -might expect. In the preceding example, when `my.servers` is redefined in several places, the -individual elements are targeted for overriding, but the list itself is not targeted for overriding. To make sure that a -`PropertySource` with higher precedence can override the list, you need to define it as -a single property, as shown in the following example: +Extra care is required when configuring lists as shown in the preceding example, as +overriding does not work as you might expect. In the preceding example, when `my.servers` +is redefined in several places, the individual elements are targeted for overriding, but +the list itself is not targeted for overriding. To make sure that a `PropertySource` with +higher precedence can override the list, you need to define it as a single property, as +shown in the following example: [source,yaml,indent=0] ---- @@ -724,16 +731,17 @@ a single property, as shown in the following example: [[boot-features-external-config-exposing-yaml-to-spring]] ==== Exposing YAML as Properties in the Spring Environment -The `YamlPropertySourceLoader` class can be used to expose YAML as a `PropertySource` -in the Spring `Environment`. Doing so lets you use the `@Value` annotation with -placeholders syntax to access YAML properties. +The `YamlPropertySourceLoader` class can be used to expose YAML as a `PropertySource` in +the Spring `Environment`. Doing so lets you use the `@Value` annotation with placeholders +syntax to access YAML properties. [[boot-features-external-config-multi-profile-yaml]] ==== Multi-profile YAML Documents -You can specify multiple profile-specific YAML documents in a single file by -using a `spring.profiles` key to indicate when the document applies, as shown in the following example: +You can specify multiple profile-specific YAML documents in a single file by using a +`spring.profiles` key to indicate when the document applies, as shown in the following +example: [source,yaml,indent=0] ---- @@ -757,8 +765,8 @@ property is `127.0.0.1`. Similarly, if the `production` profile is active, the profiles are *not* enabled, then the value for the property is `192.168.1.100`. If none are explicitly active when the application context starts, the default profiles -are activated . So, in the following YAML, we set a value for `security.user.password` that is -*only* available in the "default" profile: +are activated . So, in the following YAML, we set a value for `security.user.password` +that is *only* available in the "default" profile: [source,yaml,indent=0] ---- @@ -772,8 +780,9 @@ are activated . So, in the following YAML, we set a value for `security.user.pas password: weak ---- -Whereas, in the following example, the password is always set because it is not attached to any -profile, and it would have to be explicitly reset in all other profiles as necessary: +Whereas, in the following example, the password is always set because it is not attached +to any profile, and it would have to be explicitly reset in all other profiles as +necessary: [source,yaml,indent=0] ---- @@ -784,17 +793,17 @@ profile, and it would have to be explicitly reset in all other profiles as neces password: weak ---- -Spring profiles designated by using the "spring.profiles" element may optionally be negated -by using the `!` character. If both negated and non-negated profiles are specified for -a single document, at least one non-negated profile must match, and no negated profiles -may match. +Spring profiles designated by using the "spring.profiles" element may optionally be +negated by using the `!` character. If both negated and non-negated profiles are specified +for a single document, at least one non-negated profile must match, and no negated +profiles may match. [[boot-features-external-config-yaml-shortcomings]] ==== YAML Shortcomings -YAML files cannot be loaded by using the `@PropertySource` annotation. So, in the -case that you need to load values that way, you need to use a properties file. +YAML files cannot be loaded by using the `@PropertySource` annotation. So, in the case +that you need to load values that way, you need to use a properties file. @@ -804,8 +813,8 @@ As <>, any YAML c ultimately transformed to properties. That process may be counter-intuitive when overriding "`list`" properties through a profile. -For example, assume a `MyPojo` object with `name` and `description` attributes -that are `null` by default. The following example exposes a list of `MyPojo` from `FooProperties`: +For example, assume a `MyPojo` object with `name` and `description` attributes that are +`null` by default. The following example exposes a list of `MyPojo` from `FooProperties`: [source,java,indent=0] ---- @@ -839,12 +848,12 @@ Consider the following configuration: If the `dev` profile is not active, `FooProperties.list` contains one `MyPojo` entry as defined above. If the `dev` profile is enabled however, the `list` _still_ -contains only one entry (with a name of "`my another name`" and a description of `null`). This -configuration _does not_ add a second `MyPojo` instance to the list, and it does not merge -the items. +contains only one entry (with a name of "`my another name`" and a description of `null`). +This configuration _does not_ add a second `MyPojo` instance to the list, and it does not +merge the items. -When a collection is specified in multiple profiles, the one with -the highest priority (and only that one) is used: +When a collection is specified in multiple profiles, the one with the highest priority +(and only that one) is used: [source,yaml,indent=0] ---- @@ -862,8 +871,8 @@ the highest priority (and only that one) is used: - name: my another name ---- -In the preceding example, if the `dev` profile is active, `FooProperties.list` -contains _one_ `MyPojo` entry (with a name of "`my another name`" and a description of `null`). +In the preceding example, if the `dev` profile is active, `FooProperties.list` contains +_one_ `MyPojo` entry (with a name of "`my another name`" and a description of `null`). @@ -872,8 +881,8 @@ contains _one_ `MyPojo` entry (with a name of "`my another name`" and a descript Using the `@Value("${property}")` annotation to inject configuration properties can sometimes be cumbersome, especially if you are working with multiple properties or your data is hierarchical in nature. Spring Boot provides an alternative method of working with -properties that lets strongly typed beans govern and validate the configuration of -your application, as shown in the following example: +properties that lets strongly typed beans govern and validate the configuration of your +application, as shown in the following example: [source,java,indent=0] ---- @@ -933,27 +942,27 @@ The preceding POJO defines the following properties: * `foo.enabled`, `false` by default. * `foo.remote-address`, with a type that can be coerced from `String`. -* `foo.security.username`, with a nested "security" object whose name is determined by the name -of the property. In particular, the return type is not used at all there and could have -been `SecurityProperties`. +* `foo.security.username`, with a nested "security" object whose name is determined by the +name of the property. In particular, the return type is not used at all there and could +have been `SecurityProperties`. * `foo.security.password`. * `foo.security.roles`, with a collection of `String`. [NOTE] ==== Getters and setters are usually mandatory, since binding is through standard Java Beans -property descriptors, just like in Spring MVC. A setter may be -omitted in the following cases: +property descriptors, just like in Spring MVC. A setter may be omitted in the following +cases: * Maps, as long as they are initialized, need a getter but not necessarily a setter, since they can be mutated by the binder. -* Collections and arrays can be accessed either through an index (typically with YAML) or by -using a single comma-separated value (properties). In the latter case, a setter is +* Collections and arrays can be accessed either through an index (typically with YAML) or +by using a single comma-separated value (properties). In the latter case, a setter is mandatory. We recommend to always add a setter for such types. If you initialize a collection, make sure it is not immutable (as in the preceding example). * If nested POJO properties are initialized (like the `Security` field in the preceding -example), a setter is not required. If you want the binder to create the instance on the fly by -using its default constructor, you need a setter. +example), a setter is not required. If you want the binder to create the instance on the +fly by using its default constructor, you need a setter. Some people use Project Lombok to add getters and setters automatically. Make sure that Lombok does not generate any particular constructor for such type, as it is used @@ -986,11 +995,11 @@ The bean name in the example above is `foo-com.example.FooProperties`. ==== Even if the preceding configuration creates a regular bean for `FooProperties`, we -recommend that `@ConfigurationProperties` only deal with the environment and, in particular, -does not inject other beans from the context. Having said that, the -`@EnableConfigurationProperties` annotation is _also_ automatically applied to your project -so that any _existing_ bean annotated with `@ConfigurationProperties` is configured -from the `Environment`. You could shortcut `MyConfiguration` by making sure +recommend that `@ConfigurationProperties` only deal with the environment and, in +particular, does not inject other beans from the context. Having said that, the +`@EnableConfigurationProperties` annotation is _also_ automatically applied to your +project so that any _existing_ bean annotated with `@ConfigurationProperties` is +configured from the `Environment`. You could shortcut `MyConfiguration` by making sure `FooProperties` is already a bean, as shown in the following example: [source,java,indent=0] @@ -1004,8 +1013,8 @@ from the `Environment`. You could shortcut `MyConfiguration` by making sure } ---- -This style of configuration works particularly well with the -`SpringApplication` external YAML configuration, as shown in the following example: +This style of configuration works particularly well with the `SpringApplication` external +YAML configuration, as shown in the following example: [source,yaml,indent=0] ---- @@ -1022,8 +1031,8 @@ This style of configuration works particularly well with the # additional configuration as required ---- -To work with `@ConfigurationProperties` beans, you can just inject them in the same way -as any other bean, as shown in the following example: +To work with `@ConfigurationProperties` beans, you can just inject them in the same way as +any other bean, as shown in the following example: [source,java,indent=0] ---- @@ -1048,16 +1057,16 @@ as any other bean, as shown in the following example: } ---- -TIP: Using `@ConfigurationProperties` also lets you generate metadata files that can -be used by IDEs to offer auto-completion for your own keys. See the +TIP: Using `@ConfigurationProperties` also lets you generate metadata files that can be +used by IDEs to offer auto-completion for your own keys. See the <> appendix for details. [[boot-features-external-config-3rd-party-configuration]] ==== Third-party Configuration -As well as using `@ConfigurationProperties` to annotate a class, you can also use it -on public `@Bean` methods. Doing so can be particularly useful when you want to bind +As well as using `@ConfigurationProperties` to annotate a class, you can also use it on +public `@Bean` methods. Doing so can be particularly useful when you want to bind properties to third-party components that are outside of your control. To configure a bean from the `Environment` properties, add `@ConfigurationProperties` to @@ -1072,18 +1081,19 @@ its bean registration, as shown in the following example: } ---- -Any property defined with the `bar` prefix is mapped onto that `BarComponent` bean -in a similar manner as the preceding `FooProperties` example. +Any property defined with the `bar` prefix is mapped onto that `BarComponent` bean in a +similar manner as the preceding `FooProperties` example. [[boot-features-external-config-relaxed-binding]] ==== Relaxed Binding Spring Boot uses some relaxed rules for binding `Environment` properties to -`@ConfigurationProperties` beans, so there does not need to be an exact match between -the `Environment` property name and the bean property name. Common examples where this -is useful include dash-separated environment properties (for example, `context-path` binds to `contextPath`), and -capitalized environment properties (for example, `PORT` binds to `port`). +`@ConfigurationProperties` beans, so there does not need to be an exact match between the +`Environment` property name and the bean property name. Common examples where this is +useful include dash-separated environment properties (for example, `context-path` binds to +`contextPath`), and capitalized environment properties (for example, `PORT` binds to +`port`). For example, consider the following `@ConfigurationProperties` class: @@ -1119,13 +1129,15 @@ In the preceding example, the following properties names can all be used: |Kebab case, which is recommended for use in `.properties` and `.yml` files. |`person.first_name` -|Underscore notation, which is an alternative format for use in `.properties` and `.yml` files. +|Underscore notation, which is an alternative format for use in `.properties` and `.yml` + files. |`PERSON_FIRSTNAME` |Upper case format, which is recommended when using a system environment variables. |=== -NOTE: The `prefix` value for the annotation must be in kebab case (lowercase and separated by `-`, such as `kebab-case`). +NOTE: The `prefix` value for the annotation must be in kebab case (lowercase and separated +by `-`, such as `kebab-case`). .relaxed binding rules per property source [cols="2,4,4"] @@ -1141,7 +1153,8 @@ NOTE: The `prefix` value for the annotation must be in kebab case (lowercase and |Standard YAML list syntax or comma-separated values |Environment Variables -|Upper case format with underscore as the delimiter. `_` should not be used within a property name +|Upper case format with underscore as the delimiter. `_` should not be used within a +property name |Numeric values surrounded by underscores, such as `MY_FOO_1_BAR = my.foo[1].bar` |System properties @@ -1149,14 +1162,15 @@ NOTE: The `prefix` value for the annotation must be in kebab case (lowercase and |Standard list syntax using `[ ]` or comma-separated values |=== -TIP: We recommend that, when possible, properties are stored in lower-case kebab format, such as `my.property-name=foo`. +TIP: We recommend that, when possible, properties are stored in lower-case kebab format, +such as `my.property-name=foo`. [[boot-features-external-config-conversion]] ==== Properties Conversion -Spring attempts to coerce the external application properties to the right type when -it binds to the `@ConfigurationProperties` beans. If you need custom type conversion, you -can provide a `ConversionService` bean (with bean named `conversionService`) or custom +Spring attempts to coerce the external application properties to the right type when it +binds to the `@ConfigurationProperties` beans. If you need custom type conversion, you can +provide a `ConversionService` bean (with bean named `conversionService`) or custom property editors (through a `CustomEditorConfigurer` bean) or custom `Converters` (with bean definitions annotated as `@ConfigurationPropertiesBinding`). @@ -1170,11 +1184,11 @@ only rely on custom converters qualified with `@ConfigurationPropertiesBinding`. [[boot-features-external-config-validation]] ==== @ConfigurationProperties Validation -Spring Boot attempts to validate `@ConfigurationProperties` classes whenever they -are annotated with Spring's `@Validated` annotation. You can use JSR-303 `javax.validation` +Spring Boot attempts to validate `@ConfigurationProperties` classes whenever they are +annotated with Spring's `@Validated` annotation. You can use JSR-303 `javax.validation` constraint annotations directly on your configuration class. To do so, ensure that a -compliant JSR-303 implementation is on your classpath and then add constraint annotations to -your fields, as shown in the following example: +compliant JSR-303 implementation is on your classpath and then add constraint annotations +to your fields, as shown in the following example: [source,java,indent=0] ---- @@ -1190,8 +1204,8 @@ your fields, as shown in the following example: } ---- -In order to validate the values of nested properties, you must annotate the associated field -as `@Valid` to trigger its validation. The following example builds on the preceding +In order to validate the values of nested properties, you must annotate the associated +field as `@Valid` to trigger its validation. The following example builds on the preceding `FooProperties` example: [source,java,indent=0] @@ -1239,9 +1253,9 @@ section for details. [[boot-features-external-config-vs-value]] ==== @ConfigurationProperties vs. @Value -The `@Value` annotation is a core container feature, and it does not provide the same features as -type-safe configuration properties. The following table summarizes the features that are -supported by `@ConfigurationProperties` and `@Value`: +The `@Value` annotation is a core container feature, and it does not provide the same +features as type-safe configuration properties. The following table summarizes the +features that are supported by `@ConfigurationProperties` and `@Value`: [cols="4,2,2"] |=== @@ -1274,8 +1288,9 @@ property files>>. [[boot-features-profiles]] == Profiles Spring Profiles provide a way to segregate parts of your application configuration and -make it be available only in certain environments. Any `@Component` or `@Configuration` can -be marked with `@Profile` to limit when it is loaded, as shown in the following example: +make it be available only in certain environments. Any `@Component` or `@Configuration` +can be marked with `@Profile` to limit when it is loaded, as shown in the following +example: [source,java,indent=0] ---- @@ -1288,10 +1303,9 @@ be marked with `@Profile` to limit when it is loaded, as shown in the following } ---- -In the normal Spring way, you can use a `spring.profiles.active` -`Environment` property to specify which profiles are active. You can -specify the property in any of the usual ways. For example, you could -include it in your `application.properties`: +In the normal Spring way, you can use a `spring.profiles.active` `Environment` property to +specify which profiles are active. You can specify the property in any of the usual ways. +For example, you could include it in your `application.properties`: [source,properties,indent=0] ---- @@ -1305,15 +1319,14 @@ You could also specify it on the command line by using the following switch: [[boot-features-adding-active-profiles]] === Adding Active Profiles -The `spring.profiles.active` property follows the same ordering rules as other -properties: The highest `PropertySource` wins. This means that you can specify -active profiles in `application.properties` and then *replace* them by using the command line -switch. +The `spring.profiles.active` property follows the same ordering rules as other properties: +The highest `PropertySource` wins. This means that you can specify active profiles in +`application.properties` and then *replace* them by using the command line switch. Sometimes, it is useful to have profile-specific properties that *add* to the active -profiles rather than replace them. The `spring.profiles.include` property can be used -to unconditionally add active profiles. The `SpringApplication` entry point also has -a Java API for setting additional profiles (that is, on top of those activated by the +profiles rather than replace them. The `spring.profiles.include` property can be used to +unconditionally add active profiles. The `SpringApplication` entry point also has a Java +API for setting additional profiles (that is, on top of those activated by the `spring.profiles.active` property). See the `setAdditionalProfiles()` method. For example, when an application with the following properties is run by using the switch, @@ -1330,8 +1343,8 @@ For example, when an application with the following properties is run by using t - prodmq ---- -NOTE: Remember that the `spring.profiles` property can be defined in a YAML document -to determine when this particular document is included in the configuration. See +NOTE: Remember that the `spring.profiles` property can be defined in a YAML document to +determine when this particular document is included in the configuration. See <> for more details. @@ -1357,14 +1370,14 @@ See _<>_ for details. Spring Boot uses http://commons.apache.org/logging[Commons Logging] for all internal logging but leaves the underlying log implementation open. Default configurations are provided for -http://docs.oracle.com/javase/8/docs/api/java/util/logging/package-summary.html[Java Util Logging], -http://logging.apache.org/log4j/2.x/[Log4J2], and http://logback.qos.ch/[Logback]. In each -case, loggers are pre-configured to use console output with optional file output also -available. +http://docs.oracle.com/javase/8/docs/api/java/util/logging/package-summary.html[Java Util +Logging], http://logging.apache.org/log4j/2.x/[Log4J2], and +http://logback.qos.ch/[Logback]. In each case, loggers are pre-configured to use console +output with optional file output also available. By default, if you use the '`Starters`', Logback is used for logging. Appropriate -Logback routing is also included to ensure that dependent libraries that use -Java Util Logging, Commons Logging, Log4J, or SLF4J all work correctly. +Logback routing is also included to ensure that dependent libraries that use Java Util +Logging, Commons Logging, Log4J, or SLF4J all work correctly. TIP: There are a lot of logging frameworks available for Java. Do not worry if the above list seems confusing. Generally, you do not need to change your logging dependencies and @@ -1401,8 +1414,8 @@ NOTE: Logback does not have a `FATAL` level. It is mapped to `ERROR`. [[boot-features-logging-console-output]] === Console Output The default log configuration echoes messages to the console as they are written. By -default `ERROR`-level, `WARN`-level, and `INFO`-level messages are logged. You can also enable a -"`debug`" mode by starting your application with a `--debug` flag. +default `ERROR`-level, `WARN`-level, and `INFO`-level messages are logged. You can also +enable a "`debug`" mode by starting your application with a `--debug` flag. [indent=0] ---- @@ -1411,9 +1424,9 @@ default `ERROR`-level, `WARN`-level, and `INFO`-level messages are logged. You c NOTE: You can also specify `debug=true` in your `application.properties`. -When the debug mode is enabled, a selection of core loggers (embedded container, Hibernate, -and Spring Boot) are configured to output more information. Enabling the debug mode does -_not_ configure your application to log all messages with `DEBUG` level. +When the debug mode is enabled, a selection of core loggers (embedded container, +Hibernate, and Spring Boot) are configured to output more information. Enabling the debug +mode does _not_ configure your application to log all messages with `DEBUG` level. Alternatively, you can enable a "`trace`" mode by starting your application with a `--trace` flag (or `trace=true` in your `application.properties`). Doing so enables trace @@ -1459,8 +1472,9 @@ The mapping of log level to a color is as follows: | Green |=== -Alternatively, you can specify the color or style that should be used by providing it -as an option to the conversion. For example, to make the text yellow, use the following setting: +Alternatively, you can specify the color or style that should be used by providing it as +an option to the conversion. For example, to make the text yellow, use the following +setting: [source,indent=0] ---- @@ -1508,16 +1522,16 @@ current directory. relative to the current directory. |=== -Log files rotate when they reach 10 MB and, as with console output, `ERROR`-level, `WARN`-level, -and `INFO`-level messages are logged by default. +Log files rotate when they reach 10 MB and, as with console output, `ERROR`-level, +`WARN`-level, and `INFO`-level messages are logged by default. NOTE: The logging system is initialized early in the application lifecycle. Consequently, logging properties are not found in property files loaded through `@PropertySource` annotations. TIP: Logging properties are independent of the actual logging infrastructure. As a -result, specific configuration keys (such as `logback.configurationFile` for Logback) -are not managed by spring Boot. +result, specific configuration keys (such as `logback.configurationFile` for Logback) are +not managed by spring Boot. [[boot-features-custom-log-levels]] @@ -1525,8 +1539,8 @@ are not managed by spring Boot. All the supported logging systems can have the logger levels set in the Spring `Environment` (for example, in `application.properties`) by using '`+logging.level.*=LEVEL+`' where '`LEVEL`' is one of TRACE, DEBUG, INFO, WARN, ERROR, -FATAL, or OFF. The `root` logger can be configured by using `logging.level.root`. -The following example shows potential logging settings in `application.properties`: +FATAL, or OFF. The `root` logger can be configured by using `logging.level.root`. The +following example shows potential logging settings in `application.properties`: [source,properties,indent=0,subs="verbatim,quotes,attributes"] ---- @@ -1544,14 +1558,14 @@ for details of how you can apply remapping in your own configuration. [[boot-features-custom-log-configuration]] === Custom Log Configuration -The various logging systems can be activated by including the appropriate libraries on -the classpath and can be further customized by providing a suitable configuration file in the +The various logging systems can be activated by including the appropriate libraries on the +classpath and can be further customized by providing a suitable configuration file in the root of the classpath or in a location specified by the Spring `Environment` property `logging.config`. You can force Spring Boot to use a particular logging system by using the -`org.springframework.boot.logging.LoggingSystem` system property. The value should be -the fully qualified class name of a `LoggingSystem` implementation. You can also disable +`org.springframework.boot.logging.LoggingSystem` system property. The value should be the +fully qualified class name of a `LoggingSystem` implementation. You can also disable Spring Boot's logging configuration entirely by using a value of `none`. NOTE: Since logging is initialized *before* the `ApplicationContext` is created, it is not @@ -1602,15 +1616,18 @@ To help with the customization, some other properties are transferred from the S |`logging.pattern.console` |`CONSOLE_LOG_PATTERN` -|The log pattern to use on the console (stdout). (Only supported with the default logback setup.) +|The log pattern to use on the console (stdout). (Only supported with the default logback + setup.) |`logging.pattern.file` |`FILE_LOG_PATTERN` -|The log pattern to use in a file (if `LOG_FILE` is enabled). (Only supported with the default logback setup.) +|The log pattern to use in a file (if `LOG_FILE` is enabled). (Only supported with the + default logback setup.) |`logging.pattern.level` |`LOG_LEVEL_PATTERN` -|The format to use when rendering the log level (default `%5p`). (Only supported with the default logback setup.) +|The format to use when rendering the log level (default `%5p`). (Only supported with the + default logback setup.) |`PID` |`PID` @@ -1622,26 +1639,25 @@ To help with the customization, some other properties are transferred from the S All the supported logging systems can consult System properties when parsing their configuration files. See the default configurations in `spring-boot.jar` for examples: -* https://github.com/spring-projects/spring-boot/blob/master/spring-boot-project/spring-boot/src/main/resources/org/springframework/boot/logging/logback/defaults.xml[Logback] -* https://github.com/spring-projects/spring-boot/blob/master/spring-boot-project/spring-boot/src/main/resources/org/springframework/boot/logging/log4j2/log4j2.xml[Log4j 2] -* https://github.com/spring-projects/spring-boot/blob/master/spring-boot-project/spring-boot/src/main/resources/org/springframework/boot/logging/java/logging-file.properties[Java Util logging] +* {github-code}/spring-boot-project/spring-boot/src/main/resources/org/springframework/boot/logging/logback/defaults.xml[Logback] +* {github-code}/spring-boot-project/spring-boot/src/main/resources/org/springframework/boot/logging/log4j2/log4j2.xml[Log4j 2] +* {github-code}/spring-boot-project/spring-boot/src/main/resources/org/springframework/boot/logging/java/logging-file.properties[Java Util logging] [TIP] ==== If you want to use a placeholder in a logging property, you should use <> and not -the syntax of the underlying framework. Notably, if you use Logback, you should use -`:` as the delimiter between a property name and its default value and not use `:-`. +the syntax of the underlying framework. Notably, if you use Logback, you should use `:` as +the delimiter between a property name and its default value and not use `:-`. ==== [TIP] ==== -You can add MDC and other ad-hoc content to log lines by overriding -only the `LOG_LEVEL_PATTERN` (or `logging.pattern.level` with -Logback). For example, if you use `logging.pattern.level=user:%X{user} -%5p`, then the default log format contains an MDC entry for "user", -if it exists, as shown in the following example. +You can add MDC and other ad-hoc content to log lines by overriding only the +`LOG_LEVEL_PATTERN` (or `logging.pattern.level` with Logback). For example, if you use +`logging.pattern.level=user:%X{user} %5p`, then the default log format contains an MDC +entry for "user", if it exists, as shown in the following example. ---- 2015-09-30 12:30:04.031 user:someone INFO 22174 --- [ nio-8080-exec-0] demo.Controller @@ -1663,8 +1679,8 @@ cannot use extensions in it. You need to either use `logback-spring.xml` or defi WARNING: The extensions cannot be used with Logback's http://logback.qos.ch/manual/configuration.html#autoScan[configuration scanning]. If you -attempt to do so, making changes to the configuration file results in an error similar -to one of the following being logged: +attempt to do so, making changes to the configuration file results in an error similar to +one of the following being logged: ---- ERROR in ch.qos.logback.core.joran.spi.Interpreter@4:71 - no applicable action for [springProperty], current ElementPath is [[configuration][springProperty]] @@ -1674,11 +1690,11 @@ ERROR in ch.qos.logback.core.joran.spi.Interpreter@4:71 - no applicable action f ==== Profile-specific Configuration -The `` tag lets you optionally include or exclude sections of -configuration based on the active Spring profiles. Profile sections are supported anywhere -within the `` element. Use the `name` attribute to specify which profile -accepts the configuration. Multiple profiles can be specified using a comma-separated -list. The following listing shows three sample profiles: +The `` tag lets you optionally include or exclude sections of configuration +based on the active Spring profiles. Profile sections are supported anywhere within the +`` element. Use the `name` attribute to specify which profile accepts the +configuration. Multiple profiles can be specified using a comma-separated list. The +following listing shows three sample profiles: [source,xml,indent=0] ---- @@ -1698,14 +1714,14 @@ list. The following listing shows three sample profiles: ==== Environment Properties -The `` tag lets you expose properties from the Spring `Environment` -for use within Logback. Doing so can be useful if you want to access values from your +The `` tag lets you expose properties from the Spring `Environment` for +use within Logback. Doing so can be useful if you want to access values from your `application.properties` file in your Logback configuration. The tag works in a similar -way to Logback's standard `` tag. However, rather than specifying a direct `value`, -you specify the `source` of the property (from the `Environment`). If you need to store -the property somewhere other than in `local` scope, you can use the `scope` attribute. If -you need a fallback value (in case the property is not set in the `Environment`), you can -use the `defaultValue` attribute. +way to Logback's standard `` tag. However, rather than specifying a direct +`value`, you specify the `source` of the property (from the `Environment`). If you need to +store the property somewhere other than in `local` scope, you can use the `scope` +attribute. If you need a fallback value (in case the property is not set in the +`Environment`), you can use the `defaultValue` attribute. [source,xml,indent=0] ---- @@ -1717,18 +1733,18 @@ use the `defaultValue` attribute. ---- -NOTE: The `source` must be specified using kebab case (such as `my.property-name`). However, properties can be added to the -`Environment` by using the relaxed rules. +NOTE: The `source` must be specified using kebab case (such as `my.property-name`). +However, properties can be added to the `Environment` by using the relaxed rules. [[boot-features-developing-web-applications]] == Developing Web Applications Spring Boot is well suited for web application development. You can create a -self-contained HTTP server by using embedded Tomcat, Jetty, Undertow, or Netty. -Most web applications use the `spring-boot-starter-web` module to get up -and running quickly. You can also choose to build reactive web applications -by using the `spring-boot-starter-webflux` module. +self-contained HTTP server by using embedded Tomcat, Jetty, Undertow, or Netty. Most web +applications use the `spring-boot-starter-web` module to get up and running quickly. You +can also choose to build reactive web applications by using the +`spring-boot-starter-webflux` module. If you have not yet developed a Spring Boot web application, you can follow the "Hello World!" example in the @@ -1770,8 +1786,8 @@ The following code shows a typical example `@RestController` to serve JSON data: ---- Spring MVC is part of the core Spring Framework, and detailed information is available in -the {spring-reference}web.html#mvc[reference documentation]. There are also several guides -that cover Spring MVC available at http://spring.io/guides. +the {spring-reference}web.html#mvc[reference documentation]. There are also several +guides that cover Spring MVC available at http://spring.io/guides. @@ -1783,17 +1799,19 @@ applications. The auto-configuration adds the following features on top of Spring's defaults: * Inclusion of `ContentNegotiatingViewResolver` and `BeanNameViewResolver` beans. -* Support for serving static resources, including support for WebJars (covered later in this document). +* Support for serving static resources, including support for WebJars (covered later in + this document). * Automatic registration of `Converter`, `GenericConverter`, and `Formatter` beans. * Support for `HttpMessageConverters` (see below). * Automatic registration of `MessageCodesResolver` (covered later in this document). * Static `index.html` support. * Custom `Favicon` support (covered later in this document). -* Automatic use of a `ConfigurableWebBindingInitializer` bean (covered later in this document). +* Automatic use of a `ConfigurableWebBindingInitializer` bean (covered later in this + document). -If you want to keep Spring Boot MVC features and -you want to add additional {spring-reference}web.html#mvc[MVC configuration] (interceptors, -formatters, view controllers, and other features), you can add your own `@Configuration` class of type +If you want to keep Spring Boot MVC features and you want to add additional +{spring-reference}web.html#mvc[MVC configuration] (interceptors, formatters, view +controllers, and other features), you can add your own `@Configuration` class of type `WebMvcConfigurer` but *without* `@EnableWebMvc`. If you wish to provide custom instances of `RequestMappingHandlerMapping`, `RequestMappingHandlerAdapter`, or `ExceptionHandlerExceptionResolver`, you can declare a `WebMvcRegistrationsAdapter` @@ -1807,8 +1825,8 @@ annotated with `@EnableWebMvc`. ==== HttpMessageConverters Spring MVC uses the `HttpMessageConverter` interface to convert HTTP requests and responses. Sensible defaults are included out of the box. For example, objects can be -automatically converted to JSON (by using the Jackson library) or XML (by using the Jackson -XML extension, if available, or by using JAXB if the Jackson XML extension is not +automatically converted to JSON (by using the Jackson library) or XML (by using the +Jackson XML extension, if available, or by using JAXB if the Jackson XML extension is not available). By default, strings are encoded in `UTF-8`. If you need to add or customize converters, you can use Spring Boot's @@ -1833,22 +1851,22 @@ If you need to add or customize converters, you can use Spring Boot's } ---- -Any `HttpMessageConverter` bean that is present in the context is added to the list -of converters. You can also override default converters in the same way. +Any `HttpMessageConverter` bean that is present in the context is added to the list of +converters. You can also override default converters in the same way. [[boot-features-json-components]] ==== Custom JSON Serializers and Deserializers -If you use Jackson to serialize and deserialize JSON data, you might want to write -your own `JsonSerializer` and `JsonDeserializer` classes. Custom serializers are usually -http://wiki.fasterxml.com/JacksonHowToCustomDeserializers[registered with Jackson through a module], -but Spring Boot provides an alternative `@JsonComponent` annotation that makes it easier -to directly register Spring Beans. +If you use Jackson to serialize and deserialize JSON data, you might want to write your +own `JsonSerializer` and `JsonDeserializer` classes. Custom serializers are usually +http://wiki.fasterxml.com/JacksonHowToCustomDeserializers[registered with Jackson through +a module], but Spring Boot provides an alternative `@JsonComponent` annotation that makes +it easier to directly register Spring Beans. -You can use the `@JsonComponent` annotation directly on `JsonSerializer` or `JsonDeserializer` -implementations. You can also use it on classes that contains serializers/deserializers as -inner-classes, as shown in the following example: +You can use the `@JsonComponent` annotation directly on `JsonSerializer` or +`JsonDeserializer` implementations. You can also use it on classes that contains +serializers/deserializers as inner-classes, as shown in the following example: [source,java,indent=0] ---- @@ -1871,8 +1889,8 @@ inner-classes, as shown in the following example: } ---- -All `@JsonComponent` beans in the `ApplicationContext` are automatically registered -with Jackson. Because `@JsonComponent` is meta-annotated with `@Component`, the usual +All `@JsonComponent` beans in the `ApplicationContext` are automatically registered with +Jackson. Because `@JsonComponent` is meta-annotated with `@Component`, the usual component-scanning rules apply. Spring Boot also provides @@ -1888,8 +1906,8 @@ the Javadoc for details. [[boot-features-spring-message-codes]] ==== MessageCodesResolver -Spring MVC has a strategy for generating error codes for rendering error messages -from binding errors: `MessageCodesResolver`. If you set the +Spring MVC has a strategy for generating error codes for rendering error messages from +binding errors: `MessageCodesResolver`. If you set the `spring.mvc.message-codes-resolver.format` property `PREFIX_ERROR_CODE` or `POSTFIX_ERROR_CODE`, Spring Boot creates one for you (see the enumeration in {spring-javadoc}/validation/DefaultMessageCodesResolver.Format.{dc-ext}[`DefaultMessageCodesResolver.Format`]). @@ -1899,20 +1917,20 @@ from binding errors: `MessageCodesResolver`. If you set the [[boot-features-spring-mvc-static-content]] ==== Static Content By default, Spring Boot serves static content from a directory called `/static` (or -`/public` or `/resources` or `/META-INF/resources`) in the classpath or from the root -of the `ServletContext`. It uses the `ResourceHttpRequestHandler` from Spring MVC so that you -can modify that behavior by adding your own `WebMvcConfigurer` and overriding the +`/public` or `/resources` or `/META-INF/resources`) in the classpath or from the root of +the `ServletContext`. It uses the `ResourceHttpRequestHandler` from Spring MVC so that +you can modify that behavior by adding your own `WebMvcConfigurer` and overriding the `addResourceHandlers` method. -In a stand-alone web application, the default servlet from the container is also -enabled and acts as a fallback, serving content from the root of the `ServletContext` if -Spring decides not to handle it. Most of the time, this will not happen (unless you modify -the default MVC configuration) because Spring can always handle requests -through the `DispatcherServlet`. +In a stand-alone web application, the default servlet from the container is also enabled +and acts as a fallback, serving content from the root of the `ServletContext` if Spring +decides not to handle it. Most of the time, this will not happen (unless you modify the +default MVC configuration) because Spring can always handle requests through the +`DispatcherServlet`. By default, resources are mapped on `+/**+`, but you can tune that with the -`spring.mvc.static-path-pattern` property. For instance, relocating all resources to `/resources/**` -can be achieved as follows: +`spring.mvc.static-path-pattern` property. For instance, relocating all resources to +`/resources/**` can be achieved as follows: [source,properties,indent=0,subs="verbatim,quotes,attributes"] ---- @@ -1920,19 +1938,19 @@ can be achieved as follows: ---- You can also customize the static resource locations by using the -`spring.resources.static-locations` property (replacing the default values with a list -of directory locations). The root Servlet context path `"/"` is automatically -added as a location as well. If you do this, the default welcome page detection -switches to your custom locations. So, if there is an `index.html` in any of your locations -on startup, it is the home page of the application. +`spring.resources.static-locations` property (replacing the default values with a list of +directory locations). The root Servlet context path `"/"` is automatically added as a +location as well. If you do this, the default welcome page detection switches to your +custom locations. So, if there is an `index.html` in any of your locations on startup, it +is the home page of the application. -In addition to the '`standard`' static resource locations mentioned earlier, a special case is made -for http://www.webjars.org/[Webjars content]. Any resources with a path in `+/webjars/**+` -are served from jar files if they are packaged in the Webjars format. +In addition to the '`standard`' static resource locations mentioned earlier, a special +case is made for http://www.webjars.org/[Webjars content]. Any resources with a path in +`+/webjars/**+` are served from jar files if they are packaged in the Webjars format. -TIP: Do not use the `src/main/webapp` directory if your application is packaged as a -jar. Although this directory is a common standard, it works *only* with war packaging, -and it is silently ignored by most build tools if you generate a jar. +TIP: Do not use the `src/main/webapp` directory if your application is packaged as a jar. +Although this directory is a common standard, it works *only* with war packaging, and it +is silently ignored by most build tools if you generate a jar. Spring Boot also supports the advanced resource handling features provided by Spring MVC, allowing use cases such as cache-busting static resources or using version agnostic URLs @@ -1946,8 +1964,8 @@ version. NOTE: If you are using JBoss, you need to declare the `webjars-locator-jboss-vfs` dependency instead of the `webjars-locator`. Otherwise, all Webjars resolve as a `404`. -To use cache busting, the following configuration configures a cache busting -solution for all static resources, effectively adding a content hash, such as +To use cache busting, the following configuration configures a cache busting solution for +all static resources, effectively adding a content hash, such as ``, in URLs: [source,properties,indent=0,subs="verbatim,quotes,attributes"] @@ -1957,15 +1975,16 @@ solution for all static resources, effectively adding a content hash, such as ---- NOTE: Links to resources are rewritten in templates at runtime, thanks to a -`ResourceUrlEncodingFilter` that is auto-configured for Thymeleaf and FreeMarker. You should -manually declare this filter when using JSPs. Other template engines are currently not automatically -supported but can be with custom template macros/helpers and the use of the +`ResourceUrlEncodingFilter` that is auto-configured for Thymeleaf and FreeMarker. You +should manually declare this filter when using JSPs. Other template engines are currently +not automatically supported but can be with custom template macros/helpers and the use of +the {spring-javadoc}/web/servlet/resource/ResourceUrlProvider.{dc-ext}[`ResourceUrlProvider`]. When loading resources dynamically with, for example, a JavaScript module loader, renaming -files is not an option. That is why other strategies are also supported and can be combined. -A "fixed" strategy adds a static version string in the URL without changing the file -name, as shown in the following example: +files is not an option. That is why other strategies are also supported and can be +combined. A "fixed" strategy adds a static version string in the URL without changing the +file name, as shown in the following example: [source,properties,indent=0,subs="verbatim,quotes,attributes"] ---- @@ -1977,8 +1996,8 @@ name, as shown in the following example: ---- With this configuration, JavaScript modules located under `"/js/lib/"` use a fixed -versioning strategy (`"/v12/js/lib/mymodule.js"`), while other resources still use -the content one (``). +versioning strategy (`"/v12/js/lib/mymodule.js"`), while other resources still use the +content one (``). See {sc-spring-boot-autoconfigure}/web/ResourceProperties.{sc-ext}[`ResourceProperties`] for more of the supported options. @@ -1986,8 +2005,9 @@ for more of the supported options. [TIP] ==== This feature has been thoroughly described in a dedicated -https://spring.io/blog/2014/07/24/spring-framework-4-1-handling-static-web-resources[blog post] -and in Spring Framework's {spring-reference}web.html#mvc-config-static-resources[reference documentation]. +https://spring.io/blog/2014/07/24/spring-framework-4-1-handling-static-web-resources[blog +post] and in Spring Framework's +{spring-reference}web.html#mvc-config-static-resources[reference documentation]. ==== @@ -2032,9 +2052,9 @@ TIP: Depending on how you run your application, IntelliJ IDEA orders the classpa differently. Running your application in the IDE from its main method results in a different ordering than when you run your application by using Maven or Gradle or from its packaged jar. This can cause Spring Boot to fail to find the templates on the classpath. -If you have this problem, you can reorder the classpath in the IDE to place the -module's classes and resources first. Alternatively, you can configure the template prefix -to search every templates directory on the classpath, as follows: `classpath*:/templates/`. +If you have this problem, you can reorder the classpath in the IDE to place the module's +classes and resources first. Alternatively, you can configure the template prefix to +search every templates directory on the classpath, as follows: `classpath*:/templates/`. @@ -2044,19 +2064,20 @@ By default, Spring Boot provides an `/error` mapping that handles all errors in way, and it is registered as a '`global`' error page in the servlet container. For machine clients, it produces a JSON response with details of the error, the HTTP status, and the exception message. For browser clients, there is a '`whitelabel`' error view that renders -the same data in HTML format (to customize it, add a `View` that resolves to -'`error`'). To replace the default behavior completely, you can implement -`ErrorController` and register a bean definition of that type or add a bean of -type `ErrorAttributes` to use the existing mechanism but replace the contents. +the same data in HTML format (to customize it, add a `View` that resolves to '`error`'). +To replace the default behavior completely, you can implement `ErrorController` and +register a bean definition of that type or add a bean of type `ErrorAttributes` to use the +existing mechanism but replace the contents. TIP: The `BasicErrorController` can be used as a base class for a custom `ErrorController`. This is particularly useful if you want to add a handler for a new content type (the default is to handle `text/html` specifically and provide a fallback for everything else). -To do so, extend `BasicErrorController`, add a public method with a -`@RequestMapping` that has a `produces` attribute, and create a bean of your new type. +To do so, extend `BasicErrorController`, add a public method with a `@RequestMapping` that +has a `produces` attribute, and create a bean of your new type. -You can also define a class annotated with `@ControllerAdvice` to customize the JSON document to return for a -particular controller and/or exception type, as shown in the following example: +You can also define a class annotated with `@ControllerAdvice` to customize the JSON +document to return for a particular controller and/or exception type, as shown in the +following example: [source,java,indent=0,subs="verbatim,quotes,attributes"] ---- @@ -2082,19 +2103,20 @@ particular controller and/or exception type, as shown in the following example: ---- In the preceding example, if `YourException` is thrown by a controller defined in the same -package as `FooController`, a JSON representation of the `CustomErrorType` POJO is -used instead of the `ErrorAttributes` representation. +package as `FooController`, a JSON representation of the `CustomErrorType` POJO is used +instead of the `ErrorAttributes` representation. [[boot-features-error-handling-custom-error-pages]] ===== Custom Error Eages -If you want to display a custom HTML error page for a given status code, you can add a file to -an `/error` folder. Error pages can either be static HTML (that is, added under any of the -static resource folders) or built by using templates. The name of the file should be the -exact status code or a series mask. +If you want to display a custom HTML error page for a given status code, you can add a +file to an `/error` folder. Error pages can either be static HTML (that is, added under +any of the static resource folders) or built by using templates. The name of the file +should be the exact status code or a series mask. -For example, to map `404` to a static HTML file, your folder structure would be as follows: +For example, to map `404` to a static HTML file, your folder structure would be as +follows: [source,indent=0,subs="verbatim,quotes,attributes"] ---- @@ -2109,7 +2131,8 @@ For example, to map `404` to a static HTML file, your folder structure would be +- ---- -To map all `5xx` errors by using a FreeMarker template, your folder structure would be as follows: +To map all `5xx` errors by using a FreeMarker template, your folder structure would be as +follows: [source,indent=0,subs="verbatim,quotes,attributes"] ---- @@ -2144,8 +2167,8 @@ interface, as shown in the following example: You can also use regular Spring MVC features such as {spring-reference}web.html#mvc-exceptionhandlers[`@ExceptionHandler` methods] and -{spring-reference}web.html#mvc-ann-controller-advice[`@ControllerAdvice`]. The `ErrorController` -then picks up any unhandled exceptions. +{spring-reference}web.html#mvc-ann-controller-advice[`@ControllerAdvice`]. The +`ErrorController` then picks up any unhandled exceptions. @@ -2176,9 +2199,10 @@ underlying embedded servlet container and works even if you do not have a Spring } ---- -NOTE: If you register an `ErrorPage` with a path that ends up being handled by a -`Filter` (as is common with some non-Spring web frameworks, like Jersey and Wicket), -then the `Filter` has to be explicitly registered as an `ERROR` dispatcher, as shown in the following example: +NOTE: If you register an `ErrorPage` with a path that ends up being handled by a `Filter` +(as is common with some non-Spring web frameworks, like Jersey and Wicket), then the +`Filter` has to be explicitly registered as an `ERROR` dispatcher, as shown in the +following example: [source,java,indent=0,subs="verbatim,quotes,attributes"] ---- @@ -2192,14 +2216,15 @@ then the `Filter` has to be explicitly registered as an `ERROR` dispatcher, as s } ---- -Note that the default `FilterRegistrationBean` does not include the `ERROR` dispatcher type. +Note that the default `FilterRegistrationBean` does not include the `ERROR` dispatcher +type. [[boot-features-error-handling-websphere]] ===== Error Handling on WebSphere Application Server -When deployed to a servlet container, Spring Boot uses its error page filter to forward -a request with an error status to the appropriate error page. The request can only be +When deployed to a servlet container, Spring Boot uses its error page filter to forward a +request with an error status to the appropriate error page. The request can only be forwarded to the correct error page if the response has not already been committed. By default, WebSphere Application Server 8.0 and later commits the response upon successful completion of a servlet's service method. You should disable this behavior by setting @@ -2214,8 +2239,8 @@ auto-configuration for Spring HATEOAS that works well with most applications. Th auto-configuration replaces the need to use `@EnableHypermediaSupport` and registers a number of beans to ease building hypermedia-based applications, including a `LinkDiscoverers` (for client side support) and an `ObjectMapper` configured to correctly -marshal responses into the desired representation. The `ObjectMapper` is customized -by setting the various `spring.jackson.*` properties or, if one exists, by a +marshal responses into the desired representation. The `ObjectMapper` is customized by +setting the various `spring.jackson.*` properties or, if one exists, by a `Jackson2ObjectMapperBuilder` bean. You can take control of Spring HATEOAS's configuration by using @@ -2234,13 +2259,13 @@ way what kind of cross-domain requests are authorized, instead of using some les and less powerful approaches such as IFRAME or JSONP. As of version 4.2, Spring MVC {spring-reference}web.html#cors[supports CORS]. -Using {spring-reference}web.html#controller-method-cors-configuration[controller method CORS -configuration] with +Using {spring-reference}web.html#controller-method-cors-configuration[controller method +CORS configuration] with {spring-javadoc}/web/bind/annotation/CrossOrigin.{dc-ext}[`@CrossOrigin`] annotations in your Spring Boot application does not require any specific configuration. -{spring-reference}web.html#global-cors-configuration[Global CORS configuration] can be defined -by registering a `WebMvcConfigurer` bean with a customized `addCorsMappings(CorsRegistry)` -method, as shown in the following example: +{spring-reference}web.html#global-cors-configuration[Global CORS configuration] can be +defined by registering a `WebMvcConfigurer` bean with a customized +`addCorsMappings(CorsRegistry)` method, as shown in the following example: [source,java,indent=0] ---- @@ -2269,9 +2294,8 @@ Unlike Spring MVC, it does not require the Servlet API, is fully asynchronous an non-blocking, and implements the http://www.reactive-streams.org/[Reactive Streams] specification through http://projectreactor.io/[the Reactor project]. -Spring WebFlux comes in two flavors: functional and annotation-based. The -annotation-based one is quite close to the Spring MVC model we know, as shown in the -following example: +Spring WebFlux comes in two flavors: functional and annotation-based. The annotation-based +one is quite close to the Spring MVC model we know, as shown in the following example: [source,java,indent=0] ---- @@ -2338,9 +2362,9 @@ To get started, add the `spring-boot-starter-webflux` module to your application NOTE: Adding both `spring-boot-starter-web` and `spring-boot-starter-webflux` modules in your application results in Spring Boot auto-configuring Spring MVC, not WebFlux. This -behavior has been chosen because many Spring developers add -`spring-boot-starter-webflux` to their Spring MVC application to use the reactive -`WebCLient`. You can still enforce your choice by setting the chosen application type to +behavior has been chosen because many Spring developers add `spring-boot-starter-webflux` +to their Spring MVC application to use the reactive `WebCLient`. You can still enforce +your choice by setting the chosen application type to `SpringApplication.setWebApplicationType(WebApplicationType.REACTIVE)`. @@ -2352,8 +2376,8 @@ applications. The auto-configuration adds the following features on top of Spring's defaults: -* Configuring codecs for `HttpMessageReader` and `HttpMessageWriter` instances -(described later in this document). +* Configuring codecs for `HttpMessageReader` and `HttpMessageWriter` instances (described +later in this document). * Support for serving static resources, including support for WebJars (described later in this document). @@ -2372,8 +2396,8 @@ Spring WebFlux uses the `HttpMessageReader` and `HttpMessageWriter` interfaces t HTTP requests and responses. They are configured with `CodecConfigurer` to have sensible defaults by looking at the libraries available in your classpath. -Spring Boot applies further customization by using `CodecCustomizer` instances. -For example, `spring.jackson.*` configuration keys are applied to the Jackson codec. +Spring Boot applies further customization by using `CodecCustomizer` instances. For +example, `spring.jackson.*` configuration keys are applied to the Jackson codec. If you need to add or customize codecs, you can create a custom `CodecCustomizer` component, as shown in the following example: @@ -2395,21 +2419,21 @@ component, as shown in the following example: } ---- -You can also leverage <>. +You can also leverage <>. [[boot-features-webflux-static-content]] ==== Static Content By default, Spring Boot serves static content from a directory called `/static` (or -`/public` or `/resources` or `/META-INF/resources`) in the classpath. -It uses the `ResourceWebHandler` from Spring WebFlux so that you -can modify that behavior by adding your own `WebFluxConfigurer` and overriding the -`addResourceHandlers` method. +`/public` or `/resources` or `/META-INF/resources`) in the classpath. It uses the +`ResourceWebHandler` from Spring WebFlux so that you can modify that behavior by adding +your own `WebFluxConfigurer` and overriding the `addResourceHandlers` method. By default, resources are mapped on `+/**+`, but you can tune that by setting the -`spring.mvc.static-path-pattern` property. For instance, relocating all resources to `/resources/**` -can be achieved as follows: +`spring.mvc.static-path-pattern` property. For instance, relocating all resources to +`/resources/**` can be achieved as follows: [source,properties,indent=0,subs="verbatim,quotes,attributes"] ---- @@ -2417,14 +2441,14 @@ can be achieved as follows: ---- You can also customize the static resource locations by using -`spring.resources.static-locations` Doing so replaces the default values with a list of directory -locations. If you do so, the default welcome page detection switches to your custom -locations. So, if there is an `index.html` in any of your locations on startup, it is -the home page of the application. +`spring.resources.static-locations`. Doing so replaces the default values with a list of +directory locations. If you do so, the default welcome page detection switches to your +custom locations. So, if there is an `index.html` in any of your locations on startup, it +is the home page of the application. -In addition to the '`standard`' static resource locations listed earlier, a special case is made -for http://www.webjars.org/[Webjars content]. Any resources with a path in `+/webjars/**+` -are served from jar files if they are packaged in the Webjars format. +In addition to the '`standard`' static resource locations listed earlier, a special case +is made for http://www.webjars.org/[Webjars content]. Any resources with a path in +`+/webjars/**+` are served from jar files if they are packaged in the Webjars format. TIP: Spring WebFlux applications do not strictly depend on the Servlet API, so they cannot be deployed as war files and do not use the `src/main/webapp` directory. @@ -2456,17 +2480,17 @@ Its position in the processing order is immediately before the handlers provided WebFlux, which are considered last. For machine clients it will produce a JSON response with details of the error, the HTTP status and the exception message. For browser clients there is a '`whitelabel`' error handler that renders the same data in HTML format. You -can also provide your own HTML templates to display errors -(see the <>). +can also provide your own HTML templates to display errors (see the +<>). -The first step to customizing this feature is often about using the existing mechanism -but replacing or augmenting the error contents. For that, you can simply add a bean -of type `ErrorAttributes`. +The first step to customizing this feature is often about using the existing mechanism but +replacing or augmenting the error contents. For that, you can simply add a bean of type +`ErrorAttributes`. To change the error handling behavior, you can implement `ErrorWebExceptionHandler` and register a bean definition of that type. Because a `WebExceptionHandler` is quite -low-level, Spring Boot also provides a convenient `AbstractErrorWebExceptionHandler` -to let you handle errors in a WebFlux functional way, as shown in the following example: +low-level, Spring Boot also provides a convenient `AbstractErrorWebExceptionHandler` to +let you handle errors in a WebFlux functional way, as shown in the following example: [source,java,indent=0,subs="verbatim,quotes,attributes"] ---- @@ -2493,12 +2517,13 @@ directly and override specific methods. [[boot-features-webflux-error-handling-custom-error-pages]] ===== Custom Error Pages -If you want to display a custom HTML error page for a given status code, you can add -a file to an `/error` folder. Error pages can either be static HTML (that is, added under -any of the static resource folders) or built with templates. The name of the file -should be the exact status code or a series mask. +If you want to display a custom HTML error page for a given status code, you can add a +file to an `/error` folder. Error pages can either be static HTML (that is, added under +any of the static resource folders) or built with templates. The name of the file should +be the exact status code or a series mask. -For example, to map `404` to a static HTML file, your folder structure would be as follows: +For example, to map `404` to a static HTML file, your folder structure would be as +follows: [source,indent=0,subs="verbatim,quotes,attributes"] ---- @@ -2513,7 +2538,8 @@ For example, to map `404` to a static HTML file, your folder structure would be +- ---- -To map all `5xx` errors by using a Mustache template, your folder structure would be as follows: +To map all `5xx` errors by using a Mustache template, your folder structure would be as +follows: [source,indent=0,subs="verbatim,quotes,attributes"] ---- @@ -2533,14 +2559,14 @@ To map all `5xx` errors by using a Mustache template, your folder structure woul [[boot-features-jersey]] === JAX-RS and Jersey If you prefer the JAX-RS programming model for REST endpoints, you can use one of the -available implementations instead of Spring MVC. Jersey 1.x and Apache CXF work quite -well out of the box if you register their `Servlet` or `Filter` as a `@Bean` in your +available implementations instead of Spring MVC. Jersey 1.x and Apache CXF work quite well +out of the box if you register their `Servlet` or `Filter` as a `@Bean` in your application context. Jersey 2.x has some native Spring support, so we also provide auto-configuration support for it in Spring Boot, together with a starter. -To get started with Jersey 2.x, include the `spring-boot-starter-jersey` as a -dependency and then you need one `@Bean` of type `ResourceConfig` in which you register -all the endpoints, as shown in the following example: +To get started with Jersey 2.x, include the `spring-boot-starter-jersey` as a dependency +and then you need one `@Bean` of type `ResourceConfig` in which you register all the +endpoints, as shown in the following example: [source,java,indent=0,subs="verbatim,quotes,attributes"] ---- @@ -2581,27 +2607,26 @@ All the registered endpoints should be `@Components` with HTTP resource annotati ---- Since the `Endpoint` is a Spring `@Component`, its lifecycle is managed by Spring and you -can use the `@Autowired` annotation to inject dependencies and use the `@Value` -annotation to inject external configuration. By default, the Jersey servlet is registered -and mapped to `/*`. You can change the mapping by adding `@ApplicationPath` to your -`ResourceConfig`. - -By default, Jersey is set up as a Servlet in a `@Bean` of type -`ServletRegistrationBean` named `jerseyServletRegistration`. By default, the servlet is -initialized lazily, but you can customize that behavior by setting -`spring.jersey.servlet.load-on-startup`. You can disable or override that bean by creating -one of your own with the same name. You can also use a filter instead of a servlet by -setting `spring.jersey.type=filter` (in which case, the `@Bean` to replace or override is -`jerseyFilterRegistration`). The filter has an `@Order`, which you can set with -`spring.jersey.filter.order`. Both the servlet and the filter registrations can be given -init parameters by using `spring.jersey.init.*` to specify a map of properties. +can use the `@Autowired` annotation to inject dependencies and use the `@Value` annotation +to inject external configuration. By default, the Jersey servlet is registered and mapped +to `/*`. You can change the mapping by adding `@ApplicationPath` to your `ResourceConfig`. + +By default, Jersey is set up as a Servlet in a `@Bean` of type `ServletRegistrationBean` +named `jerseyServletRegistration`. By default, the servlet is initialized lazily, but you +can customize that behavior by setting `spring.jersey.servlet.load-on-startup`. You can +disable or override that bean by creating one of your own with the same name. You can also +use a filter instead of a servlet by setting `spring.jersey.type=filter` (in which case, +the `@Bean` to replace or override is `jerseyFilterRegistration`). The filter has an +`@Order`, which you can set with `spring.jersey.filter.order`. Both the servlet and the +filter registrations can be given init parameters by using `spring.jersey.init.*` to +specify a map of properties. There is a {github-code}/spring-boot-samples/spring-boot-sample-jersey[Jersey sample] so that you can see how to set things up. There is also a -{github-code}/spring-boot-samples/spring-boot-sample-jersey1[Jersey 1.x sample]. Note that, -in the Jersey 1.x sample, the spring-boot maven plugin has been configured to unpack -some Jersey jars so that they can be scanned by the JAX-RS implementation (because the sample -asks for them to be scanned in its `Filter` registration). If any of your JAX-RS +{github-code}/spring-boot-samples/spring-boot-sample-jersey1[Jersey 1.x sample]. Note +that, in the Jersey 1.x sample, the spring-boot maven plugin has been configured to unpack +some Jersey jars so that they can be scanned by the JAX-RS implementation (because the +sample asks for them to be scanned in its `Filter` registration). If any of your JAX-RS resources are packaged as nested jars, you may need to do the same. @@ -2609,8 +2634,8 @@ resources are packaged as nested jars, you may need to do the same. [[boot-features-embedded-container]] === Embedded Servlet Container Support Spring Boot includes support for embedded Tomcat, Jetty, and Undertow servers. Most -developers use the appropriate '`Starter`' to obtain a fully configured -instance. By default, the embedded server listens for HTTP requests on port `8080`. +developers use the appropriate '`Starter`' to obtain a fully configured instance. By +default, the embedded server listens for HTTP requests on port `8080`. WARNING: If you choose to use Tomcat on CentOS, be aware that, by default, a temporary directory is used to store compiled JSPs, file uploads, and so on. This directory may be @@ -2624,8 +2649,8 @@ uses a different location. [[boot-features-embedded-container-servlets-filters-listeners]] ==== Servlets, Filters, and listeners When using an embedded servlet container, you can register servlets, filters, and all the -listeners (such as `HttpSessionListener`) from the Servlet spec, either by using Spring beans -or by scanning for Servlet components. +listeners (such as `HttpSessionListener`) from the Servlet spec, either by using Spring +beans or by scanning for Servlet components. [[boot-features-embedded-container-servlets-filters-listeners-beans]] @@ -2635,8 +2660,8 @@ registered with the embedded container. This can be particularly convenient if y refer to a value from your `application.properties` during configuration. By default, if the context contains only a single Servlet, it is mapped to `/`. In the -case of multiple servlet beans, the bean name is used as a path prefix. Filters -map to `+/*+`. +case of multiple servlet beans, the bean name is used as a path prefix. Filters map to +`+/*+`. If convention-based mapping is not flexible enough, you can use the `ServletRegistrationBean`, `FilterRegistrationBean`, and `ServletListenerRegistrationBean` @@ -2655,8 +2680,8 @@ inside a war may break Spring Boot applications. If you need to perform servlet context initialization in a Spring Boot application, you should register a bean that implements the `org.springframework.boot.web.servlet.ServletContextInitializer` interface. The -single `onStartup` method provides access to the `ServletContext` and, if necessary, can easily be used -as an adapter to an existing `WebApplicationInitializer`. +single `onStartup` method provides access to the `ServletContext` and, if necessary, can +easily be used as an adapter to an existing `WebApplicationInitializer`. @@ -2708,8 +2733,9 @@ possible. For those cases, dedicated namespaces offer server-specific customizat <> can be configured with specific features of the embedded servlet container. -TIP: See the {sc-spring-boot-autoconfigure}/web/ServerProperties.{sc-ext}[`ServerProperties`] -class for a complete list. +TIP: See the +{sc-spring-boot-autoconfigure}/web/ServerProperties.{sc-ext}[`ServerProperties`] class for +a complete list. @@ -2717,10 +2743,9 @@ class for a complete list. ===== Programmatic Customization If you need to programmatically configure your embedded servlet container, you can register a Spring bean that implements the `WebServerFactoryCustomizer` interface. -`WebServerFactoryCustomizer` provides access to the -`ConfigurableServletWebServerFactory`, which includes numerous customization setter -methods. Dedicated variants exist for Tomcat, Jetty and Undertow. The following example -shows programatically setting the port: +`WebServerFactoryCustomizer` provides access to the `ConfigurableServletWebServerFactory`, +which includes numerous customization setter methods. Dedicated variants exist for Tomcat, +Jetty and Undertow. The following example shows programatically setting the port: [source,java,indent=0] ---- @@ -2761,8 +2786,8 @@ If the preceding customization techniques are too limited, you can register the Setters are provided for many configuration options. Several protected method '`hooks`' are also provided should you need to do something more exotic. See the -https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/api/org/springframework/boot/web/servlet/server/ConfigurableServletWebServerFactory.html[source code documentation] -for details. +{dc-spring-boot}/web/servlet/server/ConfigurableServletWebServerFactory.{dc-ext}[source +code documentation] for details. [[boot-features-jsp-limitations]] @@ -2771,8 +2796,8 @@ When running a Spring Boot application that uses an embedded servlet container ( packaged as an executable archive), there are some limitations in the JSP support. * With Tomcat, it should work if you use war packaging. That is, an executable war works - and is also deployable to a standard container (not limited to, but including - Tomcat). An executable jar does not work because of a hard-coded file pattern in Tomcat. + and is also deployable to a standard container (not limited to, but including Tomcat). + An executable jar does not work because of a hard-coded file pattern in Tomcat. * With Jetty, it should work if you use war packaging. That is, an executable war works, and is also deployable to any standard container. @@ -2791,15 +2816,15 @@ that you can see how to set things up. [[boot-features-security]] == Security -If Spring Security is on the classpath, then web applications are secure by default -with '`basic`' authentication on all HTTP endpoints. To add method-level security to a web +If Spring Security is on the classpath, then web applications are secure by default with +'`basic`' authentication on all HTTP endpoints. To add method-level security to a web application, you can also add `@EnableGlobalMethodSecurity` with your desired settings. Additional information can be found in the {spring-security-reference}#jc-method[Spring Security Reference]. The default `AuthenticationManager` has a single user (the user name is '`user`', and the -password is random and is printed at INFO level when the application starts), as shown -in the following example: +password is random and is printed at INFO level when the application starts), as shown in +the following example: [indent=0] ---- @@ -2807,8 +2832,8 @@ in the following example: ---- NOTE: If you fine-tune your logging configuration, ensure that the -`org.springframework.boot.autoconfigure.security` category is set to log `INFO`-level messages. -Otherwise, the default password is not printed. +`org.springframework.boot.autoconfigure.security` category is set to log `INFO`-level +messages. Otherwise, the default password is not printed. You can change the password by providing a `security.user.password`. This and other useful properties are externalized via @@ -2820,20 +2845,19 @@ the classes imported from there (`SpringBootWebSecurityConfiguration` for web se and `AuthenticationManagerConfiguration` for authentication configuration, which is also relevant in non-web applications). To switch off the default web application security configuration completely, you can add a bean with `@EnableWebSecurity` (this does not -disable the authentication manager configuration or Actuator's security). -To customize it, you normally use external properties and beans of type -`WebSecurityConfigurerAdapter` (for example, to add form-based login). +disable the authentication manager configuration or Actuator's security). To customize it, +you normally use external properties and beans of type `WebSecurityConfigurerAdapter` (for +example, to add form-based login). -NOTE: If you add `@EnableWebSecurity` and also disable Actuator security, you get -the default form-based login for the entire application, unless you add a custom +NOTE: If you add `@EnableWebSecurity` and also disable Actuator security, you get the +default form-based login for the entire application, unless you add a custom `WebSecurityConfigurerAdapter`. -To also switch off the authentication manager configuration, -you can add a bean of type `AuthenticationManager` or configure the -global `AuthenticationManager` by autowiring an `AuthenticationManagerBuilder` into -a method in one of your `@Configuration` classes. There are several secure applications in -the {github-code}/spring-boot-samples/[Spring Boot samples] to get you started with common -use cases. +To also switch off the authentication manager configuration, you can add a bean of type +`AuthenticationManager` or configure the global `AuthenticationManager` by autowiring an +`AuthenticationManagerBuilder` into a method in one of your `@Configuration` classes. +There are several secure applications in the {github-code}/spring-boot-samples/[Spring +Boot samples] to get you started with common use cases. The basic features you get by default in a web application are: @@ -2948,8 +2972,8 @@ generate queries from your method names. [[boot-features-configure-datasource]] === Configure a DataSource Java's `javax.sql.DataSource` interface provides a standard method of working with -database connections. Traditionally, a DataSource uses a `URL` along with some -credentials to establish a database connection. +database connections. Traditionally, a DataSource uses a `URL` along with some credentials +to establish a database connection. TIP: See <> for more advanced examples, typically to take full control over the configuration of the @@ -2960,24 +2984,24 @@ DataSource. [[boot-features-embedded-database-support]] ==== Embedded Database Support It is often convenient to develop applications using an in-memory embedded database. -Obviously, in-memory databases do not provide persistent storage. You need to -populate your database when your application starts and be prepared to throw away -data when your application ends. +Obviously, in-memory databases do not provide persistent storage. You need to populate +your database when your application starts and be prepared to throw away data when your +application ends. TIP: The '`How-to`' section includes a <>. Spring Boot can auto-configure embedded http://www.h2database.com[H2], http://hsqldb.org/[HSQL], and http://db.apache.org/derby/[Derby] databases. You need not -provide any connection URLs. You need only include a build dependency to the embedded database -that you want to use. +provide any connection URLs. You need only include a build dependency to the embedded +database that you want to use. [NOTE] ==== If you are using this feature in your tests, you may notice that the same database is -reused by your whole test suite regardless of the number of application contexts that -you use. If you want to make sure that each context has a separate embedded database, -you should set `spring.datasource.generate-unique-name` to `true`. +reused by your whole test suite regardless of the number of application contexts that you +use. If you want to make sure that each context has a separate embedded database, you +should set `spring.datasource.generate-unique-name` to `true`. ==== For example, typical POM dependencies would be as follows: @@ -3000,18 +3024,19 @@ auto-configured. In this example, it is pulled in transitively via `spring-boot-starter-data-jpa`. TIP: If, for whatever reason, you do configure the connection URL for an embedded -database, take care to ensure that the database's automatic shutdown is -disabled. If you use H2, you should use `DB_CLOSE_ON_EXIT=FALSE` to do so. If you -use HSQLDB, you should ensure that `shutdown=true` is not used. Disabling the database's -automatic shutdown lets Spring Boot control when the database is closed, thereby -ensuring that it happens once access to the database is no longer needed. +database, take care to ensure that the database's automatic shutdown is disabled. If you +use H2, you should use `DB_CLOSE_ON_EXIT=FALSE` to do so. If you use HSQLDB, you should +ensure that `shutdown=true` is not used. Disabling the database's automatic shutdown lets +Spring Boot control when the database is closed, thereby ensuring that it happens once +access to the database is no longer needed. [[boot-features-connect-to-production-database]] ==== Connection to a Production Database -Production database connections can also be auto-configured by using a pooling `DataSource`. -Spring Boot uses the following algorithm for choosing a specific implementation: +Production database connections can also be auto-configured by using a pooling +`DataSource`. Spring Boot uses the following algorithm for choosing a specific +implementation: . We prefer HikariCP for its performance and concurrency. If HkiariCP is available, we always choose it. @@ -3019,12 +3044,12 @@ Spring Boot uses the following algorithm for choosing a specific implementation: . If neither HikariCP nor the Tomcat pooling datasource are available and if Commons DBCP2 is available, we use it. -If you use the `spring-boot-starter-jdbc` or `spring-boot-starter-data-jpa` -'`starters`', you automatically get a dependency to `HikariCP`. +If you use the `spring-boot-starter-jdbc` or `spring-boot-starter-data-jpa` '`starters`', +you automatically get a dependency to `HikariCP`. -NOTE: You can bypass that algorithm completely and specify the connection pool to use by setting -the `spring.datasource.type` property. This is especially important if you are running -your application in a Tomcat container, as `tomcat-jdbc` is provided by default. +NOTE: You can bypass that algorithm completely and specify the connection pool to use by +setting the `spring.datasource.type` property. This is especially important if you are +running your application in a Tomcat container, as `tomcat-jdbc` is provided by default. TIP: Additional connection pools can always be configured manually. If you define your own `DataSource` bean, auto-configuration does not occur. @@ -3044,13 +3069,13 @@ DataSource configuration is controlled by external configuration properties in NOTE: You should at least specify the URL by setting the `spring.datasource.url` property. Otherwise, Spring Boot tries to auto-configure an embedded database. -TIP: You often do not need to specify the `driver-class-name`, since Spring Boot can deduce -it for most databases from the `url`. +TIP: You often do not need to specify the `driver-class-name`, since Spring Boot can +deduce it for most databases from the `url`. NOTE: For a pooling `DataSource` to be created, we need to be able to verify that a valid -`Driver` class is available, so we check for that before doing anything. In other words, if you set -`spring.datasource.driver-class-name=com.mysql.jdbc.Driver` then that class has to be -loadable. +`Driver` class is available, so we check for that before doing anything. In other words, +if you set `spring.datasource.driver-class-name=com.mysql.jdbc.Driver` then that class has +to be loadable. See {sc-spring-boot-autoconfigure}/jdbc/DataSourceProperties.{sc-ext}[`DataSourceProperties`] for more of the supported options. These are the standard options that work regardless of @@ -3060,8 +3085,8 @@ settings using their respective prefix (`+spring.datasource.hikari.*+`, documentation of the connection pool implementation you are using for more details. For instance, if you use the -http://tomcat.apache.org/tomcat-8.0-doc/jdbc-pool.html#Common_Attributes[Tomcat connection pool], -you could customize many additional settings: +http://tomcat.apache.org/tomcat-8.0-doc/jdbc-pool.html#Common_Attributes[Tomcat connection +pool], you could customize many additional settings: [source,properties,indent=0] @@ -3080,9 +3105,9 @@ you could customize many additional settings: [[boot-features-connecting-to-a-jndi-datasource]] ==== Connection to a JNDI DataSource -If you deploy your Spring Boot application to an Application Server, you might want -to configure and manage your DataSource using your Application Server's built-in features -and access it by using JNDI. +If you deploy your Spring Boot application to an Application Server, you might want to +configure and manage your DataSource using your Application Server's built-in features and +access it by using JNDI. The `spring.datasource.jndi-name` property can be used as an alternative to the `spring.datasource.url`, `spring.datasource.username`, and `spring.datasource.password` @@ -3157,12 +3182,12 @@ and http://hibernate.org/orm/documentation/[Hibernate] reference documentation. [[boot-features-entity-classes]] ==== Entity Classes Traditionally, JPA '`Entity`' classes are specified in a `persistence.xml` file. With -Spring Boot, this file is not necessary and '`Entity Scanning`' is used instead. By default, -all packages below your main configuration class (the one annotated with +Spring Boot, this file is not necessary and '`Entity Scanning`' is used instead. By +default, all packages below your main configuration class (the one annotated with `@EnableAutoConfiguration` or `@SpringBootApplication`) are searched. -Any classes annotated with `@Entity`, `@Embeddable` or `@MappedSuperclass` are -considered. A typical entity class resembles the following example: +Any classes annotated with `@Entity`, `@Embeddable` or `@MappedSuperclass` are considered. +A typical entity class resembles the following example: [source,java,indent=0] ---- @@ -3209,8 +3234,8 @@ considered. A typical entity class resembles the following example: } ---- -TIP: You can customize entity scanning locations by using the `@EntityScan` annotation. See -the <> how-to. +TIP: You can customize entity scanning locations by using the `@EntityScan` annotation. +See the <> how-to. @@ -3218,8 +3243,8 @@ the <> h ==== Spring Data JPA Repositories Spring Data JPA repositories are interfaces that you can define to access data. JPA queries are created automatically from your method names. For example, a `CityRepository` -interface might declare a `findAllByState(String state)` method to find all the cities in a -given state. +interface might declare a `findAllByState(String state)` method to find all the cities in +a given state. For more complex queries, you can annotate your method with Spring Data's {spring-data-javadoc}/repository/Query.html[`Query`] annotation. @@ -3227,9 +3252,9 @@ For more complex queries, you can annotate your method with Spring Data's Spring Data repositories usually extend from the {spring-data-commons-javadoc}/repository/Repository.html[`Repository`] or {spring-data-commons-javadoc}/repository/CrudRepository.html[`CrudRepository`] interfaces. -If you use auto-configuration, repositories are searched from the package -containing your main configuration class (the one annotated with -`@EnableAutoConfiguration` or `@SpringBootApplication`) down. +If you use auto-configuration, repositories are searched from the package containing your +main configuration class (the one annotated with `@EnableAutoConfiguration` or +`@SpringBootApplication`) down. The following example shows a typical Spring Data repository interface definition: @@ -3256,10 +3281,10 @@ the http://projects.spring.io/spring-data-jpa/[Spring Data JPA reference documen [[boot-features-creating-and-dropping-jpa-databases]] ==== Creating and Dropping JPA Databases -By default, JPA databases are automatically created *only* if you use an embedded -database (H2, HSQL, or Derby). You can explicitly configure JPA settings by using -`+spring.jpa.*+` properties. For example, to create and drop tables you can add the -following line to your `application.properties`: +By default, JPA databases are automatically created *only* if you use an embedded database +(H2, HSQL, or Derby). You can explicitly configure JPA settings by using `+spring.jpa.*+` +properties. For example, to create and drop tables you can add the following line to your +`application.properties`: [indent=0] ---- @@ -3268,8 +3293,8 @@ following line to your `application.properties`: NOTE: Hibernate's own internal property name for this (if you happen to remember it better) is `hibernate.hbm2ddl.auto`. You can set it, along with other Hibernate native -properties, by using `+spring.jpa.properties.*+` (the prefix is stripped before adding them -to the entity manager). The following line shows an example of setting JPA properties +properties, by using `+spring.jpa.properties.*+` (the prefix is stripped before adding +them to the entity manager). The following line shows an example of setting JPA properties for Hibernate: [indent=0] @@ -3290,9 +3315,9 @@ Hibernate autoconfig is active, because the `ddl-auto` settings are more fine-gr ==== Open EntityManager in View If you are running a web application, Spring Boot by default registers {spring-javadoc}/orm/jpa/support/OpenEntityManagerInViewInterceptor.{dc-ext}[`OpenEntityManagerInViewInterceptor`] -to apply the "Open EntityManager in View" pattern, to allow for lazy loading in web -views. If you do not want this behavior, you should set `spring.jpa.open-in-view` to -`false` in your `application.properties`. +to apply the "Open EntityManager in View" pattern, to allow for lazy loading in web views. +If you do not want this behavior, you should set `spring.jpa.open-in-view` to `false` in +your `application.properties`. @@ -3300,8 +3325,8 @@ views. If you do not want this behavior, you should set `spring.jpa.open-in-view === Using H2's Web Console The http://www.h2database.com[H2 database] provides a http://www.h2database.com/html/quickstart.html#h2_console[browser-based console] that -Spring Boot can auto-configure for you. The console is auto-configured when the -following conditions are met: +Spring Boot can auto-configure for you. The console is auto-configured when the following +conditions are met: * You are developing a web application. * `com.h2database:h2` is on the classpath. @@ -3309,10 +3334,9 @@ following conditions are met: tools>>. TIP: If you are not using Spring Boot's developer tools but would still like to make use -of H2's console, you can configure the `spring.h2.console.enabled` -property with a value of `true`. The H2 console is only intended for use during -development, so you should take care to ensure that `spring.h2.console.enabled` is not set -to `true` in production. +of H2's console, you can configure the `spring.h2.console.enabled` property with a value +of `true`. The H2 console is only intended for use during development, so you should take +care to ensure that `spring.h2.console.enabled` is not set to `true` in production. @@ -3393,7 +3417,8 @@ the following example: TIP: The jOOQ manual tends to use a variable named `create` to hold the `DSLContext`. -You can then use the `DSLContext` to construct your queries, as shown in the following example: +You can then use the `DSLContext` to construct your queries, as shown in the following +example: [source,java,indent=0] ---- @@ -3418,8 +3443,8 @@ jOOQ. ==== Customizing jOOQ More advanced customizations can be achieved by defining your own `@Bean` definitions, -which will be used when the jOOQ `Configuration` is created. You can define beans for -the following jOOQ Types: +which will be used when the jOOQ `Configuration` is created. You can define beans for the +following jOOQ Types: * `ConnectionProvider` * `TransactionProvider` @@ -3428,8 +3453,8 @@ the following jOOQ Types: * `ExecuteListenerProvider` * `VisitListenerProvider` -You can also create your own `org.jooq.Configuration` `@Bean` if you want to take -complete control of the jOOQ configuration. +You can also create your own `org.jooq.Configuration` `@Bean` if you want to take complete +control of the jOOQ configuration. @@ -3458,12 +3483,13 @@ http://projects.spring.io/spring-data[projects.spring.io/spring-data]. http://redis.io/[Redis] is a cache, message broker, and richly-featured key-value store. Spring Boot offers basic auto-configuration for the https://github.com/lettuce-io/lettuce-core/[Lettuce] and -https://github.com/xetorthio/jedis/[Jedis] client libraries and the abstractions on top of them -provided by https://github.com/spring-projects/spring-data-redis[Spring Data Redis]. +https://github.com/xetorthio/jedis/[Jedis] client libraries and the abstractions on top of +them provided by https://github.com/spring-projects/spring-data-redis[Spring Data Redis]. There is a `spring-boot-starter-data-redis` '`Starter`' for collecting the dependencies in -a convenient way. By default, it uses https://github.com/lettuce-io/lettuce-core/[Lettuce]. -That starter handles both traditional and reactive applications. +a convenient way. By default, it uses +https://github.com/lettuce-io/lettuce-core/[Lettuce]. That starter handles both +traditional and reactive applications. @@ -3492,13 +3518,13 @@ shows an example of such a bean: ---- TIP: You can also register an arbitrary number of beans that implement -`LettuceClientConfigurationBuilderCustomizer` for more advanced customizations. If you -use Jedis, `JedisClientConfigurationBuilderCustomizer` is also available. +`LettuceClientConfigurationBuilderCustomizer` for more advanced customizations. If you use +Jedis, `JedisClientConfigurationBuilderCustomizer` is also available. -If you add your own `@Bean` of any of the auto-configured types, it replaces the -default (except in the case of `RedisTemplate`, when the exclusion is based on the bean name -'`redisTemplate`', not its type). By default, if `commons-pool2` is on the classpath, you get a -pooled connection factory. +If you add your own `@Bean` of any of the auto-configured types, it replaces the default +(except in the case of `RedisTemplate`, when the exclusion is based on the bean name +'`redisTemplate`', not its type). By default, if `commons-pool2` is on the classpath, you +get a pooled connection factory. @@ -3516,8 +3542,8 @@ several conveniences for working with MongoDB, including the ==== Connecting to a MongoDB Database To access Mongo databases, you can inject an auto-configured `org.springframework.data.mongodb.MongoDbFactory`. By default, the instance tries to -connect to a MongoDB server at `mongodb://localhost/test` The following example shows -how to connect to a MongoDB database: +connect to a MongoDB server at `mongodb://localhost/test` The following example shows how +to connect to a MongoDB database: [source,java,indent=0] ---- @@ -3568,10 +3594,9 @@ should be used to provide all of the configuration. TIP: If `spring.data.mongodb.port` is not specified, the default of `27017` is used. You could delete this line from the example shown earlier. -TIP: If you do not use Spring Data Mongo, you can inject `com.mongodb.Mongo` beans -instead of using `MongoDbFactory`. -You can also declare your own `MongoDbFactory` or `Mongo` bean if you want to take -complete control of establishing the MongoDB connection. +TIP: If you do not use Spring Data Mongo, you can inject `com.mongodb.Mongo` beans instead +of using `MongoDbFactory`. You can also declare your own `MongoDbFactory` or `Mongo` bean +if you want to take complete control of establishing the MongoDB connection. @@ -3612,12 +3637,12 @@ Javadoc] for complete details. [[boot-features-spring-data-mongo-repositories]] ==== Spring Data MongoDB Repositories Spring Data includes repository support for MongoDB. As with the JPA repositories -discussed earlier, the basic principle is that queries are constructed -automatically based on method names. +discussed earlier, the basic principle is that queries are constructed automatically based +on method names. In fact, both Spring Data JPA and Spring Data MongoDB share the same common -infrastructure. You could take the JPA example from earlier and, assuming that `City` -is now a Mongo data class rather than a JPA `@Entity`, it works in the same way, as shown +infrastructure. You could take the JPA example from earlier and, assuming that `City` is +now a Mongo data class rather than a JPA `@Entity`, it works in the same way, as shown in the following example: [source,java,indent=0] @@ -3645,8 +3670,8 @@ documentation]. [[boot-features-mongo-embedded]] ==== Embedded Mongo Spring Boot offers auto-configuration for -https://github.com/flapdoodle-oss/de.flapdoodle.embed.mongo[Embedded Mongo]. To use -it in your Spring Boot application, add a dependency on +https://github.com/flapdoodle-oss/de.flapdoodle.embed.mongo[Embedded Mongo]. To use it in +your Spring Boot application, add a dependency on `de.flapdoodle.embed:de.flapdoodle.embed.mongo`. The port that Mongo listens on can be configured by setting the `spring.data.mongodb.port` @@ -3677,8 +3702,8 @@ working with Neo4j, including the `spring-boot-starter-data-neo4j` '`Starter`'. [[boot-features-connecting-to-neo4j]] ==== Connecting to a Neo4j Database You can inject an auto-configured `Neo4jSession`, `Session`, or `Neo4jOperations` instance -as you would any other Spring Bean. By default, the instance tries to connect to a -Neo4j server at `localhost:7474`. The following example shows how to inject a Neo4j bean: +as you would any other Spring Bean. By default, the instance tries to connect to a Neo4j +server at `localhost:7474`. The following example shows how to inject a Neo4j bean: [source,java,indent=0] ---- @@ -3717,11 +3742,11 @@ properties, as shown in the following example: ==== Using the Embedded Mode If you add `org.neo4j:neo4j-ogm-embedded-driver` to the dependencies of your application, -Spring Boot automatically configures an in-process embedded instance of Neo4j that -does not persist any data when your application shuts down. You can explicitly disable -that mode by setting `spring.data.neo4j.embedded.enabled=false`. You can also enable -persistence for the embedded mode by providing a path to a database file, as shown in -the following example: +Spring Boot automatically configures an in-process embedded instance of Neo4j that does +not persist any data when your application shuts down. You can explicitly disable that +mode by setting `spring.data.neo4j.embedded.enabled=false`. You can also enable +persistence for the embedded mode by providing a path to a database file, as shown in the +following example: ---- spring.data.neo4j.uri=file://var/tmp/graph.db @@ -3731,8 +3756,8 @@ the following example: ==== The Neo4j OGM embedded driver does not provide the Neo4j kernel. Users are expected to provide this dependency manually. See -http://neo4j.com/docs/ogm-manual/current/reference/#reference:getting-started[the documentation] -for more details. +http://neo4j.com/docs/ogm-manual/current/reference/#reference:getting-started[the +documentation] for more details. ==== @@ -3740,8 +3765,9 @@ for more details. ==== Neo4jSession By default, if you are running a web application, the session is bound to the thread for -the entire processing of the request (that is, it uses the "Open Session in View" pattern). If you -do not want this behavior, add the following line to your `application.properties` file: +the entire processing of the request (that is, it uses the "Open Session in View" +pattern). If you do not want this behavior, add the following line to your +`application.properties` file: [source,properties,indent=0] ---- @@ -3754,10 +3780,9 @@ do not want this behavior, add the following line to your `application.propertie ==== Spring Data Neo4j Repositories Spring Data includes repository support for Neo4j. -In fact, both Spring Data JPA and Spring Data Neo4j share the same common -infrastructure. You could take the JPA example from earlier and, assuming that `City` -is now a Neo4j OGM `@NodeEntity` rather than a JPA `@Entity`, it works in the same -way. +In fact, both Spring Data JPA and Spring Data Neo4j share the same common infrastructure. +You could take the JPA example from earlier and, assuming that `City` is now a Neo4j OGM +`@NodeEntity` rather than a JPA `@Entity`, it works in the same way. TIP: You can customize entity scanning locations by using the `@EntityScan` annotation. @@ -3766,8 +3791,8 @@ following two annotations to your Spring configuration: [source,java,indent=0] ---- - @EnableNeo4jRepositories(basePackages = "com.example.myapp.repository") - @EnableTransactionManagement + @EnableNeo4jRepositories(basePackages = "com.example.myapp.repository") + @EnableTransactionManagement ---- ==== Repository Example @@ -3811,9 +3836,9 @@ https://github.com/spring-projects/spring-data-gemfire/blob/master/src/main/java [[boot-features-solr]] === Solr http://lucene.apache.org/solr/[Apache Solr] is a search engine. Spring Boot offers basic -auto-configuration for the Solr 5 client library and the abstractions on top of it provided by -https://github.com/spring-projects/spring-data-solr[Spring Data Solr]. There is -a `spring-boot-starter-data-solr` '`Starter`' for collecting the dependencies in a +auto-configuration for the Solr 5 client library and the abstractions on top of it +provided by https://github.com/spring-projects/spring-data-solr[Spring Data Solr]. There +is a `spring-boot-starter-data-solr` '`Starter`' for collecting the dependencies in a convenient way. @@ -3861,9 +3886,9 @@ http://projects.spring.io/spring-data-solr/[reference documentation]. [[boot-features-elasticsearch]] === Elasticsearch -http://www.elasticsearch.org/[Elasticsearch] is an open source, distributed, -real-time search and analytics engine. Spring Boot offers basic auto-configuration for -Elasticsearch and the abstractions on top of it provided by +http://www.elasticsearch.org/[Elasticsearch] is an open source, distributed, real-time +search and analytics engine. Spring Boot offers basic auto-configuration for Elasticsearch +and the abstractions on top of it provided by https://github.com/spring-projects/spring-data-elasticsearch[Spring Data Elasticsearch]. There is a `spring-boot-starter-data-elasticsearch` '`Starter`' for collecting the dependencies in a convenient way. Spring Boot also supports @@ -3886,8 +3911,8 @@ configured, as shown in the following example: ---- You can also register an arbitrary number of beans that implement -`HttpClientConfigBuilderCustomizer` for more advanced customizations. The following example -tunes additional HTTP settings: +`HttpClientConfigBuilderCustomizer` for more advanced customizations. The following +example tunes additional HTTP settings: [source,java,indent=0] ---- @@ -3927,8 +3952,8 @@ as shown in the following example: } ---- -If you add your own `ElasticsearchTemplate` or `TransportClient` `@Bean`, it -replaces the default. +If you add your own `ElasticsearchTemplate` or `TransportClient` `@Bean`, it replaces the +default. @@ -3991,8 +4016,7 @@ The following code listing shows how to inject a Cassandra bean: } ---- -If you add your own `@Bean` of type `CassandraTemplate`, it replaces the -default. +If you add your own `@Bean` of type `CassandraTemplate`, it replaces the default. @@ -4012,18 +4036,18 @@ http://docs.spring.io/spring-data/cassandra/docs/[reference documentation]. http://www.couchbase.com/[Couchbase] is an open-source, distributed multi-model NoSQL document-oriented database that is optimized for interactive applications. Spring Boot offers auto-configuration for Couchbase and the abstractions on top of it provided by -https://github.com/spring-projects/spring-data-couchbase[Spring Data Couchbase]. -There is a `spring-boot-starter-data-couchbase` '`Starter`' for collecting the -dependencies in a convenient way. +https://github.com/spring-projects/spring-data-couchbase[Spring Data Couchbase]. There is +a `spring-boot-starter-data-couchbase` '`Starter`' for collecting the dependencies in a +convenient way. [[boot-features-connecting-to-couchbase]] ==== Connecting to Couchbase -You can get a `Bucket` and `Cluster` by adding the Couchbase SDK and some -configuration. The `spring.couchbase.*` properties can be used to customize the -connection. Generally, you provide the bootstrap hosts, bucket name, and password, as -shown in the following example: +You can get a `Bucket` and `Cluster` by adding the Couchbase SDK and some configuration. +The `spring.couchbase.*` properties can be used to customize the connection. Generally, +you provide the bootstrap hosts, bucket name, and password, as shown in the following +example: [source,properties,indent=0] ---- @@ -4034,15 +4058,15 @@ shown in the following example: [TIP] ==== -You need to provide _at least_ the bootstrap host(s), in which case the bucket name -is `default` and the password is the empty String. Alternatively, you can define your -own `org.springframework.data.couchbase.config.CouchbaseConfigurer` `@Bean` to take -control over the whole configuration. +You need to provide _at least_ the bootstrap host(s), in which case the bucket name is +`default` and the password is the empty String. Alternatively, you can define your own +`org.springframework.data.couchbase.config.CouchbaseConfigurer` `@Bean` to take control +over the whole configuration. ==== -It is also possible to customize some of the `CouchbaseEnvironment` settings. For instance, -the following configuration changes the timeout to use to open a new `Bucket` and enables -SSL support: +It is also possible to customize some of the `CouchbaseEnvironment` settings. For +instance, the following configuration changes the timeout to use to open a new `Bucket` +and enables SSL support: [source,properties,indent=0] ---- @@ -4057,9 +4081,10 @@ Check the `spring.couchbase.env.*` properties for more details. [[boot-features-spring-data-couchbase-repositories]] ==== Spring Data Couchbase Repositories -Spring Data includes repository support for Couchbase. For complete details of Spring -Data Couchbase, refer to the -http://docs.spring.io/spring-data/couchbase/docs/current/reference/html/[reference documentation]. +Spring Data includes repository support for Couchbase. For complete details of Spring Data +Couchbase, refer to the +http://docs.spring.io/spring-data/couchbase/docs/current/reference/html/[reference +documentation]. You can inject an auto-configured `CouchbaseTemplate` instance as you would with any other Spring Bean, provided a _default_ `CouchbaseConfigurer` is available (which @@ -4154,10 +4179,11 @@ If you need to customize connection settings, you can use the `spring.ldap.base` ==== Spring Data LDAP Repositories Spring Data includes repository support for LDAP. For complete details of Spring Data LDAP, refer to the -http://docs.spring.io/spring-data/ldap/docs/1.0.x/reference/html/[reference documentation]. +http://docs.spring.io/spring-data/ldap/docs/1.0.x/reference/html/[reference +documentation]. -You can also inject an auto-configured `LdapTemplate` instance as you would with any -other Spring Bean, as shown in the following example: +You can also inject an auto-configured `LdapTemplate` instance as you would with any other +Spring Bean, as shown in the following example: [source,java,indent=0] @@ -4193,13 +4219,13 @@ add a dependency to `com.unboundid:unboundid-ldapsdk` and declare a `base-dn` pr By default, the server starts on a random port and triggers the regular LDAP support. There is no need to specify a `spring.ldap.urls` property. -If there is a `schema.ldif` file on your classpath, it is used to initialize the -server. If you want to load the initialization script from a different resource, you can -also use the `spring.ldap.embedded.ldif` property. +If there is a `schema.ldif` file on your classpath, it is used to initialize the server. +If you want to load the initialization script from a different resource, you can also use +the `spring.ldap.embedded.ldif` property. By default, a standard schema is used to validate `LDIF` files, you can turn off -validation altogether using the `spring.ldap.embedded.validation.enabled` property. If -you have custom attributes, you can use `spring.ldap.embedded.validation.schema` to define +validation altogether using the `spring.ldap.embedded.validation.enabled` property. If you +have custom attributes, you can use `spring.ldap.embedded.validation.schema` to define your custom attribute types or object classes. @@ -4240,8 +4266,8 @@ transparently, without any interference to the invoker. Spring Boot auto-config cache infrastructure as long as caching support is enabled via the `@EnableCaching` annotation. -NOTE: Check the {spring-reference}integration.html#cache[relevant section] of the Spring Framework -reference for more details. +NOTE: Check the {spring-reference}integration.html#cache[relevant section] of the Spring +Framework reference for more details. In a nutshell, adding caching to an operation of your service is as easy as adding the relevant annotation to its method, as shown in the following example: @@ -4263,31 +4289,31 @@ relevant annotation to its method, as shown in the following example: ---- This example demonstrates the use of caching on a potentially costly operation. Before -invoking `computePiDecimal`, the abstraction looks for an entry in the `piDecimals` -cache that matches the `i` argument. If an entry is found, the content in the cache is -immediately returned to the caller, and the method is not invoked. Otherwise, the method is -invoked, and the cache is updated before returning the value. +invoking `computePiDecimal`, the abstraction looks for an entry in the `piDecimals` cache +that matches the `i` argument. If an entry is found, the content in the cache is +immediately returned to the caller, and the method is not invoked. Otherwise, the method +is invoked, and the cache is updated before returning the value. -CAUTION: You can also use the standard JSR-107 (JCache) annotations (such as `@CacheResult`) -transparently. However, we strongly advise you to not mix and match the Spring Cache and -JCache annotations. +CAUTION: You can also use the standard JSR-107 (JCache) annotations (such as +`@CacheResult`) transparently. However, we strongly advise you to not mix and match the +Spring Cache and JCache annotations. If you do not add any specific cache library, Spring Boot auto-configures a <> that uses concurrent maps in -memory. When a cache is required (such as `piDecimals` in the preceding example), this provider -creates it for you. The simple provider is not really recommended for +memory. When a cache is required (such as `piDecimals` in the preceding example), this +provider creates it for you. The simple provider is not really recommended for production usage, but it is great for getting started and making sure that you understand the features. When you have made up your mind about the cache provider to use, please make sure to read its documentation to figure out how to configure the caches that your -application uses. Nearly all providers require you to explicitly configure every -cache that you use in the application. Some offer a way to customize the default caches -defined by the `spring.cache.cache-names` property. +application uses. Nearly all providers require you to explicitly configure every cache +that you use in the application. Some offer a way to customize the default caches defined +by the `spring.cache.cache-names` property. TIP: It is also possible to transparently {spring-reference}integration.html#cache-annotations-put[update] or {spring-reference}integration.html#cache-annotations-evict[evict] data from the cache. -NOTE: If you use the cache infrastructure with beans that are not interface-based, -make sure to enable the `proxyTargetClass` attribute of `@EnableCaching`. +NOTE: If you use the cache infrastructure with beans that are not interface-based, make +sure to enable the `proxyTargetClass` attribute of `@EnableCaching`. === Supported Cache Providers @@ -4310,14 +4336,15 @@ providers (in the indicated order): . <> . <> -TIP: It is also possible to _force_ a particular cache provider by setting the `spring.cache.type` -property. Use this property if you need to <> in certain environment (such as tests). +TIP: It is also possible to _force_ a particular cache provider by setting the +`spring.cache.type` property. Use this property if you need to +<> in certain environment +(such as tests). TIP: Use the `spring-boot-starter-cache` '`Starter`' to quickly add basic caching -dependencies. The starter brings in `spring-context-support`. If you add -dependencies manually, you must include `spring-context-support` in order to use the -JCache, EhCache 2.x, or Guava support. +dependencies. The starter brings in `spring-context-support`. If you add dependencies +manually, you must include `spring-context-support` in order to use the JCache, +EhCache 2.x, or Guava support. If the `CacheManager` is auto-configured by Spring Boot, you can further tune its configuration before it is fully initialized by exposing a bean that implements the @@ -4358,15 +4385,15 @@ is created. [[boot-features-caching-provider-jcache]] ==== JCache (JSR-107) JCache is bootstrapped via the presence of a `javax.cache.spi.CachingProvider` on the -classpath (that is, a JSR-107 compliant caching library exists on the classpath) and the `JCacheCacheManager` -provided by the `spring-boot-starter-cache` '`Starter`'. Various compliant -libraries are available, and Spring Boot provides dependency management for Ehcache 3, -Hazelcast, and Infinispan. Any other compliant library can be added as well. +classpath (that is, a JSR-107 compliant caching library exists on the classpath) and the +`JCacheCacheManager` provided by the `spring-boot-starter-cache` '`Starter`'. Various +compliant libraries are available, and Spring Boot provides dependency management for +Ehcache 3, Hazelcast, and Infinispan. Any other compliant library can be added as well. It might happen that more than one provider is present, in which case the provider must -be explicitly specified. Even if the JSR-107 standard does not enforce a standardized -way to define the location of the configuration file, Spring Boot does its best to -accommodate setting a cache with implementation details, as shown in the following example: +be explicitly specified. Even if the JSR-107 standard does not enforce a standardized way +to define the location of the configuration file, Spring Boot does its best to accommodate +setting a cache with implementation details, as shown in the following example: [source,properties,indent=0] ---- @@ -4375,25 +4402,25 @@ accommodate setting a cache with implementation details, as shown in the followi spring.cache.jcache.config=classpath:acme.xml ---- -NOTE: When a cache library offers both a native implementation and JSR-107 support, -Spring Boot prefers the JSR-107 support, so that the same features are available if -you switch to a different JSR-107 implementation. +NOTE: When a cache library offers both a native implementation and JSR-107 support, Spring +Boot prefers the JSR-107 support, so that the same features are available if you switch to +a different JSR-107 implementation. -TIP: Spring Boot has <>. If -a single `HazelcastInstance` is available, it is automatically reused for the -`CacheManager` as well, unless the `spring.cache.jcache.config` property is specified. +TIP: Spring Boot has <>. If a +single `HazelcastInstance` is available, it is automatically reused for the `CacheManager` +as well, unless the `spring.cache.jcache.config` property is specified. There are two ways to customize the underlying `javax.cache.cacheManager`: -* Caches can be created on startup by setting the `spring.cache.cache-names` property. If a - custom `javax.cache.configuration.Configuration` bean is defined, it is used to +* Caches can be created on startup by setting the `spring.cache.cache-names` property. If + a custom `javax.cache.configuration.Configuration` bean is defined, it is used to customize them. * `org.springframework.boot.autoconfigure.cache.JCacheManagerCustomizer` beans are invoked with the reference of the `CacheManager` for full customization. -TIP: If a standard `javax.cache.CacheManager` bean is defined, it is wrapped -automatically in an `org.springframework.cache.CacheManager` implementation that the -abstraction expects. No further customization is applied to it. +TIP: If a standard `javax.cache.CacheManager` bean is defined, it is wrapped automatically +in an `org.springframework.cache.CacheManager` implementation that the abstraction +expects. No further customization is applied to it. @@ -4401,9 +4428,8 @@ abstraction expects. No further customization is applied to it. ==== EhCache 2.x EhCache 2.x is used if a file named `ehcache.xml` can be found at the root of the classpath. If EhCache 2.x is found, the `EhCacheCacheManager` provided by the -`spring-boot-starter-cache` '`Starter`' is used to bootstrap -the cache manager. An alternate configuration file can be provided as well, as shown in -the following example: +`spring-boot-starter-cache` '`Starter`' is used to bootstrap the cache manager. An +alternate configuration file can be provided as well, as shown in the following example: [source,properties,indent=0] ---- @@ -4415,8 +4441,8 @@ the following example: [[boot-features-caching-provider-hazelcast]] ==== Hazelcast -Spring Boot has <>. If -a `HazelcastInstance` has been auto-configured, it is automatically wrapped in a +Spring Boot has <>. If a +`HazelcastInstance` has been auto-configured, it is automatically wrapped in a `CacheManager`. @@ -4431,27 +4457,28 @@ Otherwise, the default bootstrap is used. spring.cache.infinispan.config=infinispan.xml ---- -Caches can be created on startup by setting the `spring.cache.cache-names` property. If a custom -`ConfigurationBuilder` bean is defined, it is used to customize the caches. +Caches can be created on startup by setting the `spring.cache.cache-names` property. If a +custom `ConfigurationBuilder` bean is defined, it is used to customize the caches. [NOTE] ==== The support of Infinispan in Spring Boot is restricted to the embedded mode and is quite -basic. If you want more options, you should use the official Infinispan Spring Boot starter -instead. See -https://github.com/infinispan/infinispan-spring-boot[Infinispan's documentation] for more details. +basic. If you want more options, you should use the official Infinispan Spring Boot +starter instead. See +https://github.com/infinispan/infinispan-spring-boot[Infinispan's documentation] for more +details. ==== [[boot-features-caching-provider-couchbase]] ==== Couchbase -If the Couchbase Java client and the `couchbase-spring-cache` implementation are -available and Couchbase is <>, a -`CouchbaseCacheManager` is auto-configured. It is also possible to create additional -caches on startup by setting the `spring.cache.cache-names` property. These caches operate on -the `Bucket` that was auto-configured. You can _also_ create additional caches on another -`Bucket` by using the customizer. Assume you need two caches (`cache1` and `cache2`) on the "main" `Bucket` -) and one `cache3` cache with a custom time to live of 2 seconds on the `another` +If the Couchbase Java client and the `couchbase-spring-cache` implementation are available +and Couchbase is <>, a `CouchbaseCacheManager` is +auto-configured. It is also possible to create additional caches on startup by setting the +`spring.cache.cache-names` property. These caches operate on the `Bucket` that was +auto-configured. You can _also_ create additional caches on another `Bucket` by using the +customizer. Assume you need two caches (`cache1` and `cache2`) on the "main" `Bucket` and +one `cache3` cache with a custom time to live of 2 seconds on the "another" `Bucket`. You can create the first two caches through configuration, as follows: [source,properties,indent=0] @@ -4459,8 +4486,8 @@ the `Bucket` that was auto-configured. You can _also_ create additional caches o spring.cache.cache-names=cache1,cache2 ---- -Then you can define a `@Configuration` class to configure the extra `Bucket` and the `cache3` -cache, as follows: +Then you can define a `@Configuration` class to configure the extra `Bucket` and the +`cache3` cache, as follows: [source,java,indent=0] @@ -4497,8 +4524,8 @@ This sample configuration reuses the `Cluster` that was created via auto-configu [[boot-features-caching-provider-redis]] ==== Redis If Redis is available and configured, the `RedisCacheManager` is auto-configured. It is -also possible to create additional caches on startup by setting the `spring.cache.cache-names` -property. +also possible to create additional caches on startup by setting the +`spring.cache.cache-names` property. [NOTE] ==== @@ -4512,17 +4539,17 @@ recommend keeping this setting enabled if you create your own `RedisCacheManager [[boot-features-caching-provider-caffeine]] ==== Caffeine Caffeine is a Java 8 rewrite of Guava's cache that supersedes support for Guava. If -Caffeine is present, a `CaffeineCacheManager` (provided by the -`spring-boot-starter-cache` '`Starter`') is auto-configured. Caches can be created -on startup by setting the `spring.cache.cache-names` property and can be customized by one of the -following (in the indicated order): +Caffeine is present, a `CaffeineCacheManager` (provided by the `spring-boot-starter-cache` +'`Starter`') is auto-configured. Caches can be created on startup by setting the +`spring.cache.cache-names` property and can be customized by one of the following (in the +indicated order): . A cache spec defined by `spring.cache.caffeine.spec` . A `com.github.benmanes.caffeine.cache.CaffeineSpec` bean is defined . A `com.github.benmanes.caffeine.cache.Caffeine` bean is defined -For instance, the following configuration creates `cache1` and `cache2` caches with a maximum -size of 500 and a _time to live_ of 10 minutes +For instance, the following configuration creates `cache1` and `cache2` caches with a +maximum size of 500 and a _time to live_ of 10 minutes [source,properties,indent=0] ---- @@ -4531,9 +4558,9 @@ size of 500 and a _time to live_ of 10 minutes ---- If a `com.github.benmanes.caffeine.cache.CacheLoader` bean is defined, it is -automatically associated to the `CaffeineCacheManager`. Since the `CacheLoader` is -going to be associated with _all_ caches managed by the cache manager, it must be defined -as `CacheLoader`. The auto-configuration ignores any other generic type. +automatically associated to the `CaffeineCacheManager`. Since the `CacheLoader` is going +to be associated with _all_ caches managed by the cache manager, it must be defined as +`CacheLoader`. The auto-configuration ignores any other generic type. @@ -4542,23 +4569,24 @@ as `CacheLoader`. The auto-configuration ignores any other gener If none of the other providers can be found, a simple implementation using a `ConcurrentHashMap` as the cache store is configured. This is the default if no caching library is present in your application. By default, caches are created as needed, but you -can restrict the list of available caches by setting the `cache-names` property. For instance, -if you want only `cache1` and `cache2` caches, set the `cache-names` property as follows: +can restrict the list of available caches by setting the `cache-names` property. For +instance, if you want only `cache1` and `cache2` caches, set the `cache-names` property as +follows: [source,properties,indent=0] ---- spring.cache.cache-names=cache1,cache2 ---- -If you do so and your application uses a cache not listed, then it fails at runtime -when the cache is needed, but not on startup. This is similar to the way the "real" cache +If you do so and your application uses a cache not listed, then it fails at runtime when +the cache is needed, but not on startup. This is similar to the way the "real" cache providers behave if you use an undeclared cache. [[boot-features-caching-provider-none]] ==== None -When `@EnableCaching` is present in your configuration, a suitable cache configuration -is expected as well. If you need to disable caching altogether in certain environments, +When `@EnableCaching` is present in your configuration, a suitable cache configuration is +expected as well. If you need to disable caching altogether in certain environments, force the cache type to `none` to use a no-op implementation, as shown in the following example: @@ -4576,8 +4604,8 @@ from simplified use of the JMS API using `JmsTemplate` to a complete infrastruct receive messages asynchronously. Spring AMQP provides a similar feature set for the '`Advanced Message Queuing Protocol`'. Spring Boot also provides auto-configuration options for `RabbitTemplate` and RabbitMQ. Spring WebSocket natively includes support for -STOMP messaging, and Spring Boot has support for that through starters and a -small amount of auto-configuration. Spring Boot also has support for Apache Kafka. +STOMP messaging, and Spring Boot has support for that through starters and a small amount +of auto-configuration. Spring Boot also has support for Apache Kafka. @@ -4585,8 +4613,8 @@ small amount of auto-configuration. Spring Boot also has support for Apache Kafk === JMS The `javax.jms.ConnectionFactory` interface provides a standard method of creating a `javax.jms.Connection` for interacting with a JMS broker. Although Spring needs a -`ConnectionFactory` to work with JMS, you generally need not use it directly yourself -and can instead rely on higher level messaging abstractions. (See the +`ConnectionFactory` to work with JMS, you generally need not use it directly yourself and +can instead rely on higher level messaging abstractions. (See the {spring-reference}integration.html#jms[relevant section] of the Spring Framework reference documentation for details.) Spring Boot also auto-configures the necessary infrastructure to send and receive messages. @@ -4596,12 +4624,12 @@ to send and receive messages. [[boot-features-activemq]] ==== ActiveMQ Support When ActiveMQ is available on the classpath, Spring Boot can also configure a -`ConnectionFactory`. If the broker is present, an embedded broker is automatically -started and configured (provided no broker URL is specified through configuration). +`ConnectionFactory`. If the broker is present, an embedded broker is automatically started +and configured (provided no broker URL is specified through configuration). -NOTE: If you use `spring-boot-starter-activemq`, the necessary dependencies to -connect or embed an ActiveMQ instance are provided, as is the Spring infrastructure -to integrate with JMS. +NOTE: If you use `spring-boot-starter-activemq`, the necessary dependencies to connect or +embed an ActiveMQ instance are provided, as is the Spring infrastructure to integrate with +JMS. ActiveMQ configuration is controlled by external configuration properties in `+spring.activemq.*+`. For example, you might declare the following section in @@ -4626,11 +4654,11 @@ accordingly, as shown in the following example: TIP: See {sc-spring-boot-autoconfigure}/jms/activemq/ActiveMQProperties.{sc-ext}[`ActiveMQProperties`] -for more of the supported options. You can also register an arbitrary number of beans -that implement `ActiveMQConnectionFactoryCustomizer` for more advanced customizations. +for more of the supported options. You can also register an arbitrary number of beans that +implement `ActiveMQConnectionFactoryCustomizer` for more advanced customizations. -By default, ActiveMQ creates a destination if it does not yet exist so that destinations are -resolved against their provided names. +By default, ActiveMQ creates a destination if it does not yet exist so that destinations +are resolved against their provided names. @@ -4639,11 +4667,11 @@ resolved against their provided names. Spring Boot can auto-configure a `ConnectionFactory` when it detects that Artemis is available on the classpath. If the broker is present, an embedded broker is automatically started and configured (unless the mode property has been explicitly set). The supported -modes are `embedded` (to make explicit that an embedded broker is required and that -an error should occur if the broker is not available on the classpath) and `native` (to connect -to a broker using the `netty` transport protocol). When the latter is configured, Spring -Boot configures a `ConnectionFactory` that connects to a broker running on the local machine -with the default settings. +modes are `embedded` (to make explicit that an embedded broker is required and that an +error should occur if the broker is not available on the classpath) and `native` (to +connect to a broker using the `netty` transport protocol). When the latter is configured, +Spring Boot configures a `ConnectionFactory` that connects to a broker running on the +local machine with the default settings. NOTE: If you are using `spring-boot-starter-artemis`, the necessary dependencies to connect to an existing Artemis instance are provided, as well as the Spring infrastructure @@ -4674,9 +4702,9 @@ See {sc-spring-boot-autoconfigure}/jms/artemis/ArtemisProperties.{sc-ext}[`ArtemisProperties`] for more supported options. -No JNDI lookup is involved, and destinations are resolved against their names, -using either the '`name`' attribute in the Artemis configuration or the names provided -through configuration. +No JNDI lookup is involved, and destinations are resolved against their names, using +either the '`name`' attribute in the Artemis configuration or the names provided through +configuration. @@ -4684,9 +4712,9 @@ through configuration. ==== Using a JNDI ConnectionFactory If you are running your application in an application server, Spring Boot tries to locate a JMS `ConnectionFactory` by using JNDI. By default, the `java:/JmsXA` and -`java:/XAConnectionFactory` location are checked. You can use the -`spring.jms.jndi-name` property if you need to specify an alternative location, as shown -in the following example: +`java:/XAConnectionFactory` location are checked. You can use the `spring.jms.jndi-name` +property if you need to specify an alternative location, as shown in the following +example: [source,properties,indent=0] ---- @@ -4721,10 +4749,9 @@ beans, as shown in the following example: } ---- -NOTE: {spring-javadoc}/jms/core/JmsMessagingTemplate.{dc-ext}[`JmsMessagingTemplate`] -can be injected in a similar manner. If a `DestinationResolver` or a `MessageConverter` -bean is defined, it is associated automatically to the auto-configured -`JmsTemplate`. +NOTE: {spring-javadoc}/jms/core/JmsMessagingTemplate.{dc-ext}[`JmsMessagingTemplate`] can +be injected in a similar manner. If a `DestinationResolver` or a `MessageConverter` bean +is defined, it is associated automatically to the auto-configured `JmsTemplate`. [[boot-features-using-jms-receiving]] @@ -4735,14 +4762,13 @@ create a listener endpoint. If no `JmsListenerContainerFactory` has been defined default one is configured automatically. If a `DestinationResolver` or a `MessageConverter` beans is defined, it is associated automatically to the default factory. -By default, the default factory is transactional. If you run in an infrastructure -where a `JtaTransactionManager` is present, it is associated to the listener container -by default. If not, the `sessionTransacted` flag is enabled. In that latter scenario, -you can associate your local data store transaction to the processing of an incoming -message by adding `@Transactional` on your listener method (or a delegate thereof). This -ensures that the incoming message is acknowledged, once the local transaction has -completed. This also includes sending response messages that have been performed on the -same JMS session. +By default, the default factory is transactional. If you run in an infrastructure where a +`JtaTransactionManager` is present, it is associated to the listener container by default. +If not, the `sessionTransacted` flag is enabled. In that latter scenario, you can +associate your local data store transaction to the processing of an incoming message by +adding `@Transactional` on your listener method (or a delegate thereof). This ensures that +the incoming message is acknowledged, once the local transaction has completed. This also +includes sending response messages that have been performed on the same JMS session. The following component creates a listener endpoint on the `someQueue` destination: @@ -4763,9 +4789,10 @@ TIP: Check {spring-javadoc}/jms/annotation/EnableJms.{dc-ext}[the Javadoc of `@E for more details. If you need to create more `JmsListenerContainerFactory` instances or if you want to -override the default, Spring Boot provides a `DefaultJmsListenerContainerFactoryConfigurer` -that you can use to initialize a `DefaultJmsListenerContainerFactory` with the same -settings as the one that is auto-configured. +override the default, Spring Boot provides a +`DefaultJmsListenerContainerFactoryConfigurer` that you can use to initialize a +`DefaultJmsListenerContainerFactory` with the same settings as the one that is +auto-configured. For instance, the following example exposes another factory that uses a specific `MessageConverter`: @@ -4809,9 +4836,9 @@ Then you can use the factory in any `@JmsListener`-annotated method as follows: === AMQP The Advanced Message Queuing Protocol (AMQP) is a platform-neutral, wire-level protocol for message-oriented middleware. The Spring AMQP project applies core Spring concepts to -the development of AMQP-based messaging solutions. Spring Boot offers several -conveniences for working with AMQP through RabbitMQ, including the -`spring-boot-starter-amqp` '`Starter`'. +the development of AMQP-based messaging solutions. Spring Boot offers several conveniences +for working with AMQP through RabbitMQ, including the `spring-boot-starter-amqp` +'`Starter`'. @@ -4835,8 +4862,8 @@ RabbitMQ configuration is controlled by external configuration properties in See {sc-spring-boot-autoconfigure}/amqp/RabbitProperties.{sc-ext}[`RabbitProperties`] for more of the supported options. -TIP: See http://spring.io/blog/2010/06/14/understanding-amqp-the-protocol-used-by-rabbitmq/[Understanding AMQP, the protocol used by RabbitMQ] -for more details. +TIP: See http://spring.io/blog/2010/06/14/understanding-amqp-the-protocol-used-by-rabbitmq/[Understanding +AMQP, the protocol used by RabbitMQ] for more details. @@ -4905,21 +4932,21 @@ The following sample component creates a listener endpoint on the `someQueue` qu } ---- -TIP: See {spring-amqp-javadoc}/rabbit/annotation/EnableRabbit.{dc-ext}[the Javadoc of `@EnableRabbit`] -for more details. +TIP: See {spring-amqp-javadoc}/rabbit/annotation/EnableRabbit.{dc-ext}[the Javadoc of +`@EnableRabbit`] for more details. If you need to create more `RabbitListenerContainerFactory` instances or if you want to override the default, Spring Boot provides a `SimpleRabbitListenerContainerFactoryConfigurer` and a `DirectRabbitListenerContainerFactoryConfigurer` that you can use to initialize a -`SimpleRabbitListenerContainerFactory` and a `DirectRabbitListenerContainerFactory` with the -same settings as the factories used by the auto-configuration. +`SimpleRabbitListenerContainerFactory` and a `DirectRabbitListenerContainerFactory` with +the same settings as the factories used by the auto-configuration. TIP: It does not matter which container type you chose. Those two beans are exposed by the auto-configuration. -For instance, the following configuration class exposes another factory that uses a specific -`MessageConverter`: +For instance, the following configuration class exposes another factory that uses a +specific `MessageConverter`: [source,java,indent=0] ---- @@ -4957,16 +4984,16 @@ Then you can use the factory in any `@RabbitListener`-annotated method as follow You can enable retries to handle situations where your listener throws an exception. By default, `RejectAndDontRequeueRecoverer` is used, but you can define a `MessageRecoverer` -of your own. When retries are exhausted, the message is rejected and either dropped -or routed to a dead-letter exchange if the broker is configured to do so. By default, -retries are disabled. +of your own. When retries are exhausted, the message is rejected and either dropped or +routed to a dead-letter exchange if the broker is configured to do so. By default, retries +are disabled. IMPORTANT: By default, if retries are disabled and the listener throws an exception, the delivery is retried indefinitely. You can modify this behavior in two ways: Set the `defaultRequeueRejected` property to `false` so that zero re-deliveries are attempted or throw an `AmqpRejectAndDontRequeueException` to signal the message should be rejected. -The latter is the mechanism used when retries are enabled and the maximum delivery attempts are -reached. +The latter is the mechanism used when retries are enabled and the maximum delivery +attempts are reached. @@ -4985,8 +5012,8 @@ Kafka configuration is controlled by external configuration properties in spring.kafka.consumer.group-id=myGroup ---- -TIP: To create a topic on startup, add a bean of type `NewTopic`. If the topic -already exists, the bean is ignored. +TIP: To create a topic on startup, add a bean of type `NewTopic`. If the topic already +exists, the bean is ignored. See {sc-spring-boot-autoconfigure}/kafka/KafkaProperties.{sc-ext}[`KafkaProperties`] for more supported options. @@ -5022,8 +5049,8 @@ auto-configured `KafkaTemplate`. [[boot-features-kafka-receiving-a-message]] ==== Receiving a Message When the Apache Kafka infrastructure is present, any bean can be annotated with -`@KafkaListener` to create a listener endpoint. If no `KafkaListenerContainerFactory` -has been defined, a default one is automatically configured with keys defined in +`@KafkaListener` to create a listener endpoint. If no `KafkaListenerContainerFactory` has +been defined, a default one is automatically configured with keys defined in `spring.kafka.listener.*`. Also, if a `RecordMessageConverter` bean is defined, it is automatically associated to the default factory. @@ -5047,9 +5074,9 @@ The following component creates a listener endpoint on the `someTopic` topic: [[boot-features-kafka-extra-props]] ==== Additional Kafka Properties The properties supported by auto configuration are shown in -<>. Note that, for the most part, these properties (hyphenated or camelCase) -map directly to the Apache Kafka dotted properties. Refer to the Apache -Kafka documentation for details. +<>. Note that, for the most part, these properties +(hyphenated or camelCase) map directly to the Apache Kafka dotted properties. Refer to the +Apache Kafka documentation for details. The first few of these properties apply to both producers and consumers but can be specified at the producer or consumer level if you wish to use different values for each. @@ -5057,9 +5084,9 @@ Apache Kafka designates properties with an importance of HIGH, MEDIUM, or LOW. S auto-configuration supports all HIGH importance properties, some selected MEDIUM and LOW properties, and any properties that do not have a default value. -Only a subset of the properties supported by Kafka are available through the `KafkaProperties` -class. If you wish to configure the producer or consumer with additional properties that -are not directly supported, use the following properties: +Only a subset of the properties supported by Kafka are available through the +`KafkaProperties` class. If you wish to configure the producer or consumer with additional +properties that are not directly supported, use the following properties: [source,properties,indent=0] ---- @@ -5072,18 +5099,18 @@ This sets the common `foo.bar` Kafka property to `baz` (applies to both producer consumers), the consumer `fiz.buz` property to `qux` and the `baz.qux` producer property to `fiz`. -IMPORTANT: Properties set in this way override any configuration item that Spring -Boot explicitly supports. +IMPORTANT: Properties set in this way override any configuration item that Spring Boot +explicitly supports. [[boot-features-resttemplate]] == Calling REST Services with '`RestTemplate`' If you need to call remote REST services from your application, you can use the Spring Framework's `RestTemplate` class. Since `RestTemplate` instances often need to be customized before being used, Spring Boot does not provide any single auto-configured -`RestTemplate` bean. It does, however, auto-configure a `RestTemplateBuilder`, which can be -used to create `RestTemplate` instances when needed. The auto-configured -`RestTemplateBuilder` ensures that sensible `HttpMessageConverters` are applied -to `RestTemplate` instances. +`RestTemplate` bean. It does, however, auto-configure a `RestTemplateBuilder`, which can +be used to create `RestTemplate` instances when needed. The auto-configured +`RestTemplateBuilder` ensures that sensible `HttpMessageConverters` are applied to +`RestTemplate` instances. The following code shows a typical example: @@ -5118,15 +5145,15 @@ you want the customizations to apply. To make the scope of any customizations as narrow as possible, inject the auto-configured `RestTemplateBuilder` and then call its methods as required. Each method call returns a -new `RestTemplateBuilder` instance, so the customizations only affect this use of -the builder. +new `RestTemplateBuilder` instance, so the customizations only affect this use of the +builder. To make an application-wide, additive customization, use a `RestTemplateCustomizer` bean. -All such beans are automatically registered with the auto-configured -`RestTemplateBuilder` and are applied to any templates that are built with it. +All such beans are automatically registered with the auto-configured `RestTemplateBuilder` +and are applied to any templates that are built with it. -The following example shows a customizer that configures the use of a proxy for all hosts except -`192.168.0.5`: +The following example shows a customizer that configures the use of a proxy for all hosts +except `192.168.0.5`: [source,java,indent=0] ---- @@ -5141,15 +5168,15 @@ Finally, the most extreme (and rarely used) option is to create your own [[boot-features-webclient]] == Calling REST Services with '`WebClient`' -If you have Spring WebFlux on your classpath, you can also choose to use `WebClient` -to call remote REST services, Compared to `RestTemplate`, this client has a more -functional feel and is fully reactive. You can create your own client -instance with the builder, `WebClient.create()`. See the -{spring-reference}web.html#web-reactive-client[relevant section on WebClient]. +If you have Spring WebFlux on your classpath, you can also choose to use `WebClient` to +call remote REST services, Compared to `RestTemplate`, this client has a more functional +feel and is fully reactive. You can create your own client instance with the builder, +`WebClient.create()`. See the {spring-reference}web.html#web-reactive-client[relevant +section on WebClient]. -Spring Boot creates and pre-configures such a builder for you. For example, -client HTTP codecs are configured in the same fashion as the server ones -(see <>). +Spring Boot creates and pre-configures such a builder for you. For example, client HTTP +codecs are configured in the same fashion as the server ones (see +<>). The following code shows a typical example: @@ -5181,27 +5208,27 @@ you want the customizations to apply. To make the scope of any customizations as narrow as possible, inject the auto-configured `WebClient.Builder` and then call its methods as required. `WebClient.Builder` instances -are stateful: Any change on the builder is reflected in all clients subsequently -created with it. If you want to create several clients with the same builder, you can -also consider cloning the builder with `WebClient.Builder other = builder.clone();`. +are stateful: Any change on the builder is reflected in all clients subsequently created +with it. If you want to create several clients with the same builder, you can also +consider cloning the builder with `WebClient.Builder other = builder.clone();`. To make an application-wide, additive customization to all `WebClient.Builder` instances, -you can declare `WebClientCustomizer` beans and change the `WebClient.Builder` -locally at the point of injection. +you can declare `WebClientCustomizer` beans and change the `WebClient.Builder` locally at +the point of injection. -Finally, you can fall back to the original API and use `WebClient.create()`. In that -case, no auto-configuration or `WebClientCustomizer` is applied. +Finally, you can fall back to the original API and use `WebClient.create()`. In that case, +no auto-configuration or `WebClientCustomizer` is applied. [[boot-features-validation]] == Validation -The method validation feature supported by Bean Validation 1.1 is automatically enabled -as long as a JSR-303 implementation (such as Hibernate validator) is on the classpath. This -lets bean methods be annotated with `javax.validation` constraints on their -parameters and/or on their return value. Target classes with such annotated methods need -to be annotated with the `@Validated` annotation at the type level for their methods to -be searched for inline constraint annotations. +The method validation feature supported by Bean Validation 1.1 is automatically enabled as +long as a JSR-303 implementation (such as Hibernate validator) is on the classpath. This +lets bean methods be annotated with `javax.validation` constraints on their parameters +and/or on their return value. Target classes with such annotated methods need to be +annotated with the `@Validated` annotation at the type level for their methods to be +searched for inline constraint annotations. For instance, the following service triggers the validation of the first argument, making sure its size is between 8 and 10: @@ -5228,8 +5255,8 @@ The Spring Framework provides an easy abstraction for sending email by using the `JavaMailSender` interface, and Spring Boot provides auto-configuration for it as well as a starter module. -TIP: See the {spring-reference}integration.html#mail[reference documentation] for a detailed -explanation of how you can use `JavaMailSender`. +TIP: See the {spring-reference}integration.html#mail[reference documentation] for a +detailed explanation of how you can use `JavaMailSender`. If `spring.mail.host` and the relevant libraries (as defined by `spring-boot-starter-mail`) are available, a default `JavaMailSender` is created if none @@ -5238,8 +5265,9 @@ namespace, see the {sc-spring-boot-autoconfigure}/mail/MailProperties.{sc-ext}[`MailProperties`] for more details. -In particular, certain default timeout values are infinite, and you may want to change that -to avoid having a thread blocked by an unresponsive mail server, as shown in the following example: +In particular, certain default timeout values are infinite, and you may want to change +that to avoid having a thread blocked by an unresponsive mail server, as shown in the +following example: [source,properties,indent=0] ---- @@ -5261,8 +5289,8 @@ When a JTA environment is detected, Spring's `JtaTransactionManager` is used to manage transactions. Auto-configured JMS, DataSource, and JPA beans are upgraded to support XA transactions. You can use standard Spring idioms, such as `@Transactional`, to participate in a distributed transaction. If you are within a JTA environment and still -want to use local transactions, you can set the `spring.jta.enabled` property to `false` to -disable the JTA auto-configuration. +want to use local transactions, you can set the `spring.jta.enabled` property to `false` +to disable the JTA auto-configuration. @@ -5271,13 +5299,13 @@ disable the JTA auto-configuration. Atomikos is a popular open source transaction manager which can be embedded into your Spring Boot application. You can use the `spring-boot-starter-jta-atomikos` Starter to pull in the appropriate Atomikos libraries. Spring Boot auto-configures Atomikos and -ensures that appropriate `depends-on` settings are applied to your Spring beans for correct -startup and shutdown ordering. +ensures that appropriate `depends-on` settings are applied to your Spring beans for +correct startup and shutdown ordering. -By default Atomikos transaction logs are written to a `transaction-logs` directory in -your application home directory (the directory in which your application jar file -resides). You can customize this directory by setting a `spring.jta.log-dir` property in -your `application.properties` file. Properties starting with `spring.jta.atomikos.properties` +By default Atomikos transaction logs are written to a `transaction-logs` directory in your +application home directory (the directory in which your application jar file resides). You +can customize this directory by setting a `spring.jta.log-dir` property in your +`application.properties` file. Properties starting with `spring.jta.atomikos.properties` can also be used to customize the Atomikos `UserTransactionServiceImp`. See the {dc-spring-boot}/jta/atomikos/AtomikosProperties.{dc-ext}[`AtomikosProperties` Javadoc] for complete details. @@ -5292,25 +5320,24 @@ property with a different value for each instance of your application. [[boot-features-jta-bitronix]] === Using a Bitronix Transaction Manager -Bitronix is popular open source JTA transaction manager implementation. You can -use the `spring-boot-starter-jta-bitronix` starter to add the appropriate Bitronix -dependencies to your project. As with Atomikos, Spring Boot automatically configures -Bitronix and post-processes your beans to ensure that startup and shutdown ordering is -correct. +Bitronix is popular open source JTA transaction manager implementation. You can use the +`spring-boot-starter-jta-bitronix` starter to add the appropriate Bitronix dependencies to +your project. As with Atomikos, Spring Boot automatically configures Bitronix and +post-processes your beans to ensure that startup and shutdown ordering is correct. By default, Bitronix transaction log files (`part1.btm` and `part2.btm`) are written to a `transaction-logs` directory in your application home directory. You can customize this directory by setting the `spring.jta.log-dir` property. Properties starting with `spring.jta.bitronix.properties` are also bound to the `bitronix.tm.Configuration` bean, allowing for complete customization. See the -https://github.com/bitronix/btm/wiki/Transaction-manager-configuration[Bitronix documentation] -for details. +https://github.com/bitronix/btm/wiki/Transaction-manager-configuration[Bitronix +documentation] for details. -NOTE: To ensure that multiple transaction managers can safely coordinate the same -resource managers, each Bitronix instance must be configured with a unique ID. By default, -this ID is the IP address of the machine on which Bitronix is running. To ensure -uniqueness in production, you should configure the `spring.jta.transaction-manager-id` -property with a different value for each instance of your application. +NOTE: To ensure that multiple transaction managers can safely coordinate the same resource +managers, each Bitronix instance must be configured with a unique ID. By default, this ID +is the IP address of the machine on which Bitronix is running. To ensure uniqueness in +production, you should configure the `spring.jta.transaction-manager-id` property with a +different value for each instance of your application. @@ -5325,14 +5352,14 @@ shutdown ordering is correct. By default, Narayana transaction logs are written to a `transaction-logs` directory in your application home directory (the directory in which your application jar file resides). You can customize this directory by setting a `spring.jta.log-dir` property in -your `application.properties` file. Properties starting with `spring.jta.narayana.properties` -can also be used to customize the Narayana configuration. See the -{dc-spring-boot}/jta/narayana/NarayanaProperties.{dc-ext}[`NarayanaProperties` Javadoc] -for complete details. +your `application.properties` file. Properties starting with +`spring.jta.narayana.properties` can also be used to customize the Narayana configuration. +See the {dc-spring-boot}/jta/narayana/NarayanaProperties.{dc-ext}[`NarayanaProperties` +Javadoc] for complete details. -NOTE: To ensure that multiple transaction managers can safely coordinate the same -resource managers, each Narayana instance must be configured with a unique ID. By default, -this ID is set to `1`. To ensure uniqueness in production, you should configure the +NOTE: To ensure that multiple transaction managers can safely coordinate the same resource +managers, each Narayana instance must be configured with a unique ID. By default, this ID +is set to `1`. To ensure uniqueness in production, you should configure the `spring.jta.transaction-manager-id` property with a different value for each instance of your application. @@ -5340,15 +5367,14 @@ your application. [[boot-features-jta-javaee]] === Using a Java EE Managed Transaction Manager -If you package your Spring Boot application as a `war` or `ear` file and deploy -it to a Java EE application server, you can use your application server's built-in -transaction manager. Spring Boot tries to auto-configure a transaction manager by -looking at common JNDI locations (`java:comp/UserTransaction`, -`java:comp/TransactionManager`, and so on). If you use a transaction service provided by -your application server, you generally also want to ensure that all resources are -managed by the server and exposed over JNDI. Spring Boot tries to auto-configure -JMS by looking for a `ConnectionFactory` at the JNDI path (`java:/JmsXA` or -`java:/XAConnectionFactory`), and you can use the +If you package your Spring Boot application as a `war` or `ear` file and deploy it to a +Java EE application server, you can use your application server's built-in transaction +manager. Spring Boot tries to auto-configure a transaction manager by looking at common +JNDI locations (`java:comp/UserTransaction`, `java:comp/TransactionManager`, and so on). +If you use a transaction service provided by your application server, you generally also +want to ensure that all resources are managed by the server and exposed over JNDI. Spring +Boot tries to auto-configure JMS by looking for a `ConnectionFactory` at the JNDI path +(`java:/JmsXA` or `java:/XAConnectionFactory`), and you can use the <> to configure your `DataSource`. @@ -5393,10 +5419,10 @@ The {sc-spring-boot}/jta/XAConnectionFactoryWrapper.{sc-ext}[`XAConnectionFactor and {sc-spring-boot}/jta/XADataSourceWrapper.{sc-ext}[`XADataSourceWrapper`] interfaces can be used to support alternative embedded transaction managers. The interfaces are responsible for wrapping `XAConnectionFactory` and `XADataSource` beans and exposing them -as regular `ConnectionFactory` and `DataSource` beans, which transparently enroll in -the distributed transaction. DataSource and JMS auto-configuration use JTA variants, -provided you have a `JtaTransactionManager` bean and appropriate XA wrapper beans -registered within your `ApplicationContext`. +as regular `ConnectionFactory` and `DataSource` beans, which transparently enroll in the +distributed transaction. DataSource and JMS auto-configuration use JTA variants, provided +you have a `JtaTransactionManager` bean and appropriate XA wrapper beans registered within +your `ApplicationContext`. The {sc-spring-boot}/jta/bitronix/BitronixXAConnectionFactoryWrapper.{sc-ext}[BitronixXAConnectionFactoryWrapper] and {sc-spring-boot}/jta/bitronix/BitronixXADataSourceWrapper.{sc-ext}[BitronixXADataSourceWrapper] @@ -5411,11 +5437,11 @@ If Hazelcast is on the classpath and a suitable configuration is found, Spring B auto-configures a `HazelcastInstance` that you can inject in your application. If you define a `com.hazelcast.config.Config` bean, Spring Boot uses that. If your -configuration defines an instance name, Spring Boot tries to locate an existing instance rather -than creating a new one. +configuration defines an instance name, Spring Boot tries to locate an existing instance +rather than creating a new one. -You could also specify the `hazelcast.xml` configuration file to use via configuration, -as shown in the following example: +You could also specify the `hazelcast.xml` configuration file to use via configuration, as +shown in the following example: [source,properties,indent=0] ---- @@ -5423,13 +5449,13 @@ as shown in the following example: ---- Otherwise, Spring Boot tries to find the Hazelcast configuration from the default -locations: `hazelcast.xml` in the working directory or at the root of the -classpath. We also check if the `hazelcast.config` system property is set. See the +locations: `hazelcast.xml` in the working directory or at the root of the classpath. We +also check if the `hazelcast.config` system property is set. See the http://docs.hazelcast.org/docs/latest/manual/html-single/[Hazelcast documentation] for more details. -If `hazelcast-client` is present on the classpath, Spring Boot first attempts to -create a client by checking the following configuration options: +If `hazelcast-client` is present on the classpath, Spring Boot first attempts to create a +client by checking the following configuration options: * The presence of a `com.hazelcast.client.config.ClientConfig` bean. * A configuration file defined by the `spring.hazelcast.config` property. @@ -5449,16 +5475,16 @@ Spring Boot offers several conveniences for working with the Quartz scheduler, i the `spring-boot-starter-quartz` '`Starter`'. If Quartz is available, a `Scheduler` is auto-configured (via the `SchedulerFactoryBean` abstraction). -Beans of the following types are automatically picked up and associated with the -the `Scheduler`: +Beans of the following types are automatically picked up and associated with the the +`Scheduler`: * `JobDetail`: defines a particular Job. `JobDetail` instances can be built with the `JobBuilder` API. * `Calendar`. * `Trigger`: defines when a particular job is triggered. -By default, an in-memory `JobStore` is used. However, it is possible to configure -a JDBC-based store if a `DataSource` bean is available in your application and if the +By default, an in-memory `JobStore` is used. However, it is possible to configure a +JDBC-based store if a `DataSource` bean is available in your application and if the `spring.quartz.job-store-type` property is configured accordingly, as shown in the following example: @@ -5476,8 +5502,8 @@ following example: ---- NOTE: By default, the database is detected and initialized by using the standard scripts -provided with the Quartz library. It is also possible to provide a custom script by setting the -`spring.quartz.jdbc.schema` property. +provided with the Quartz library. It is also possible to provide a custom script by +setting the `spring.quartz.jdbc.schema` property. Quartz Scheduler configuration can be customized by using Quartz configuration properties ()`spring.quartz.properties.*`) and `SchedulerFactoryBeanCustomizer` beans, which allow @@ -5512,17 +5538,17 @@ in a similar manner, as shown in the following example: [[boot-features-integration]] == Spring Integration -Spring Boot offers several conveniences for working with Spring Integration, including -the `spring-boot-starter-integration` '`Starter`'. Spring Integration provides -abstractions over messaging and also other transports such as HTTP, TCP, and others. If Spring +Spring Boot offers several conveniences for working with Spring Integration, including the +`spring-boot-starter-integration` '`Starter`'. Spring Integration provides abstractions +over messaging and also other transports such as HTTP, TCP, and others. If Spring Integration is available on your classpath, it is initialized through the `@EnableIntegration` annotation. -Spring Boot also configures some features that are triggered by the presence of -additional Spring Integration modules. If `'spring-integration-jmx'` is also on the -classpath, message processing statistics are published over JMX . If -`'spring-integration-jdbc'` is available, the default database schema can be created -on startup, as shown in the following line: +Spring Boot also configures some features that are triggered by the presence of additional +Spring Integration modules. If `'spring-integration-jmx'` is also on the classpath, +message processing statistics are published over JMX . If `'spring-integration-jdbc'` is +available, the default database schema can be created on startup, as shown in the +following line: [source,properties,indent=0] ---- @@ -5538,8 +5564,8 @@ classes for more details. [[boot-features-session]] == Spring Session -Spring Boot provides Spring Session auto-configuration for a wide range of data stores. When -building a Servlet web application, the following stores can be auto-configured: +Spring Boot provides Spring Session auto-configuration for a wide range of data stores. +When building a Servlet web application, the following stores can be auto-configured: * JDBC * Redis @@ -5553,8 +5579,8 @@ When building a reactive web application, the following stores can be auto-confi If Spring Session is available, you must choose the {sc-spring-boot-autoconfigure}/session/StoreType.{sc-ext}[`StoreType`] that you wish to -use to store the sessions. For instance, to use JDBC as the back-end store, you can configure -your application as follows: +use to store the sessions. For instance, to use JDBC as the back-end store, you can +configure your application as follows: [source,properties,indent=0] ---- @@ -5563,8 +5589,8 @@ your application as follows: TIP: You can disable Spring Session by setting the `store-type` to `none`. -Each store has specific additional settings. For instance, it is possible to customize -the name of the table for the JDBC store, as shown in the following example: +Each store has specific additional settings. For instance, it is possible to customize the +name of the table for the JDBC store, as shown in the following example: [source,properties,indent=0] ---- @@ -5592,9 +5618,9 @@ Spring Boot provides a number of utilities and annotations to help when testing application. Test support is provided by two modules; `spring-boot-test` contains core items, and `spring-boot-test-autoconfigure` supports auto-configuration for tests. -Most developers use the `spring-boot-starter-test` '`Starter`', which -imports both Spring Boot test modules as well as JUnit, AssertJ, Hamcrest, and a number -of other useful libraries. +Most developers use the `spring-boot-starter-test` '`Starter`', which imports both Spring +Boot test modules as well as JUnit, AssertJ, Hamcrest, and a number of other useful +libraries. @@ -5607,8 +5633,8 @@ the following provided libraries: * {spring-reference}testing.html#integration-testing[Spring Test] & Spring Boot Test: Utilities and integration test support for Spring Boot applications. * http://joel-costigliola.github.io/assertj/[AssertJ]: A fluent assertion library. -* http://hamcrest.org/JavaHamcrest/[Hamcrest]: A library of matcher objects (also known - as constraints or predicates). +* http://hamcrest.org/JavaHamcrest/[Hamcrest]: A library of matcher objects (also known as + constraints or predicates). * http://mockito.org/[Mockito]: A Java mocking framework. * https://github.com/skyscreamer/JSONassert[JSONassert]: An assertion library for JSON. * https://github.com/jayway/JsonPath[JsonPath]: XPath for JSON. @@ -5625,12 +5651,12 @@ easier to unit test. You can instantiate objects using the `new` operator withou even involving Spring. You can also use _mock objects_ instead of real dependencies. Often, you need to move beyond '`unit testing`' and start '`integration testing`' (with -a Spring `ApplicationContext`). It is useful to be able -to perform integration testing without requiring deployment of your application or -needing to connect to other infrastructure. +a Spring `ApplicationContext`). It is useful to be able to perform integration testing +without requiring deployment of your application or needing to connect to other +infrastructure. -The Spring Framework includes a dedicated test module for such integration testing. -You can declare a dependency directly to `org.springframework:spring-test` or use the +The Spring Framework includes a dedicated test module for such integration testing. You +can declare a dependency directly to `org.springframework:spring-test` or use the `spring-boot-starter-test` '`Starter`' to pull it in transitively. If you have not used the `spring-test` module before, you should start by reading the @@ -5641,19 +5667,19 @@ documentation. [[boot-features-testing-spring-boot-applications]] === Testing Spring Boot Applications -A Spring Boot application is a Spring `ApplicationContext`, so nothing very special -has to be done to test it beyond what you would normally do with a vanilla Spring context. -One thing to watch out for, though, is that the external properties, logging, and other +A Spring Boot application is a Spring `ApplicationContext`, so nothing very special has to +be done to test it beyond what you would normally do with a vanilla Spring context. One +thing to watch out for, though, is that the external properties, logging, and other features of Spring Boot are installed in the context by default only if you use `SpringApplication` to create it. -Spring Boot provides a `@SpringBootTest` annotation, which can be used as an -alternative to the standard `spring-test` `@ContextConfiguration` annotation when you need -Spring Boot features. The annotation works by creating the `ApplicationContext` used -in your tests through `SpringApplication`. +Spring Boot provides a `@SpringBootTest` annotation, which can be used as an alternative +to the standard `spring-test` `@ContextConfiguration` annotation when you need Spring Boot +features. The annotation works by creating the `ApplicationContext` used in your tests +through `SpringApplication`. -You can use the `webEnvironment` attribute of `@SpringBootTest` to further refine -how your tests run: +You can use the `webEnvironment` attribute of `@SpringBootTest` to further refine how your +tests run: * `MOCK`: Loads a `WebApplicationContext` and provides a mock servlet environment. Embedded servlet containers are not started when using this annotation. If servlet @@ -5669,41 +5695,41 @@ how your tests run: * `NONE`: Loads an `ApplicationContext` by using `SpringApplication` but does not provide _any_ servlet environment (mock or otherwise). -NOTE: If your test is `@Transactional`, it rolls back the transaction at the end of -each test method by default. However, as using this arrangement with either `RANDOM_PORT` -or `DEFINED_PORT` implicitly provides a real servlet environment, the HTTP client and -server run in separate threads and, thus, in separate transactions. Any transaction -initiated on the server does not roll back in this case. +NOTE: If your test is `@Transactional`, it rolls back the transaction at the end of each +test method by default. However, as using this arrangement with either `RANDOM_PORT` or +`DEFINED_PORT` implicitly provides a real servlet environment, the HTTP client and server +run in separate threads and, thus, in separate transactions. Any transaction initiated on +the server does not roll back in this case. -NOTE: In addition to `@SpringBootTest`, a number of other annotations are also -provided for testing more specific slices of an application. You can find more detail -later in this document. +NOTE: In addition to `@SpringBootTest`, a number of other annotations are also provided +for testing more specific slices of an application. You can find more detail later in this +document. -TIP: Do not forget to add `@RunWith(SpringRunner.class)` to your test. Otherwise, -the annotations are ignored. +TIP: Do not forget to add `@RunWith(SpringRunner.class)` to your test. Otherwise, the +annotations are ignored. [[boot-features-testing-spring-boot-applications-detecting-config]] ==== Detecting Test Configuration If you are familiar with the Spring Test Framework, you may be used to using -`@ContextConfiguration(classes=...)` in order to specify which Spring `@Configuration` -to load. Alternatively, you might have often used nested `@Configuration` classes within -your test. +`@ContextConfiguration(classes=...)` in order to specify which Spring `@Configuration` to +load. Alternatively, you might have often used nested `@Configuration` classes within your +test. -When testing Spring Boot applications, this is often not required. -Spring Boot's `@*Test` annotations search for your primary configuration -automatically whenever you do not explicitly define one. +When testing Spring Boot applications, this is often not required. Spring Boot's `@*Test` +annotations search for your primary configuration automatically whenever you do not +explicitly define one. The search algorithm works up from the package that contains the test until it finds a -class annotated with `@SpringBootApplication` or `@SpringBootConfiguration`. As long as you -<> in a sensible way, your main -configuration is usually found. +class annotated with `@SpringBootApplication` or `@SpringBootConfiguration`. As long as +you <> in a sensible way, your +main configuration is usually found. NOTE: If you use a <>, you should -avoid adding configuration settings that are specific to a particular area on the +annotation to test a more specific slice of your application>>, you should avoid adding +configuration settings that are specific to a particular area on the <>. @@ -5724,11 +5750,11 @@ If your application uses component scanning, for example if you use `@SpringBootApplication` or `@ComponentScan`, you may find top-level configuration classes created only for specific tests accidentally get picked up everywhere. -As we <>, -`@TestConfiguration` can be used on an inner class of a test to customize the primary -configuration. When placed on a top-level class, `@TestConfiguration` indicates that -classes in `src/test/java` should not be picked up by scanning. You can then import that -class explicitly where it is required, as shown in the following example: +As we <>, `@TestConfiguration` can be used on an inner class of a test to customize the +primary configuration. When placed on a top-level class, `@TestConfiguration` indicates +that classes in `src/test/java` should not be picked up by scanning. You can then import +that class explicitly where it is required, as shown in the following example: [source,java,indent=0] ---- @@ -5745,8 +5771,8 @@ class explicitly where it is required, as shown in the following example: } ---- -NOTE: If you directly use `@ComponentScan` (that is, not through `@SpringBootApplication`) you -need to register the `TypeExcludeFilter` with it. See +NOTE: If you directly use `@ComponentScan` (that is, not through `@SpringBootApplication`) +you need to register the `TypeExcludeFilter` with it. See {dc-spring-boot}/context/TypeExcludeFilter.{dc-ext}[the Javadoc] for details. @@ -5755,8 +5781,8 @@ need to register the `TypeExcludeFilter` with it. See [[boot-features-testing-spring-boot-applications-working-with-random-ports]] ==== Working with Random Ports If you need to start a full running server for tests, we recommend that you use random -ports. If you use `@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)`, -an available port is picked at random each time your test runs. +ports. If you use `@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)`, an +available port is picked at random each time your test runs. The `@LocalServerPort` annotation can be used to <> into your test. @@ -5834,18 +5860,18 @@ implementation: } ---- -Additionally, you can use `@SpyBean` to wrap any existing bean with a Mockito `spy`. -See the {dc-spring-boot-test}/mock/mockito/SpyBean.{dc-ext}[Javadoc] for full details. +Additionally, you can use `@SpyBean` to wrap any existing bean with a Mockito `spy`. See +the {dc-spring-boot-test}/mock/mockito/SpyBean.{dc-ext}[Javadoc] for full details. [[boot-features-testing-spring-boot-applications-testing-autoconfigured-tests]] ==== Auto-configured Tests Spring Boot's auto-configuration system works well for applications but can sometimes be -a little too much for tests. It often helps to load only the parts of the -configuration that are required to test a '`slice`' of your application. For example, you -might want to test that Spring MVC controllers are mapping URLs correctly, and you don't -want to involve database calls in those tests, or you _might want_ to test JPA -entities, and you are not interested in the web layer when those tests run. +a little too much for tests. It often helps to load only the parts of the configuration +that are required to test a '`slice`' of your application. For example, you might want to +test that Spring MVC controllers are mapping URLs correctly, and you don't want to involve +database calls in those tests, or you _might want_ to test JPA entities, and you are not +interested in the web layer when those tests run. The `spring-boot-test-autoconfigure` module includes a number of annotations that can be used to automatically configure such '`slices`'. Each of them works in a similar way, @@ -5858,16 +5884,16 @@ exclude one of them, most `@...Test` annotations provide an `excludeAutoConfigur attribute. Alternatively, you can use `@ImportAutoConfiguration#exclude`. TIP: It is also possible to use the `@AutoConfigure...` annotations with the standard -`@SpringBootTest` annotation. You can use this combination if you are not interested - in '`slicing`' your application but you want some of the auto-configured test beans. +`@SpringBootTest` annotation. You can use this combination if you are not interested in +'`slicing`' your application but you want some of the auto-configured test beans. [[boot-features-testing-spring-boot-applications-testing-autoconfigured-json-tests]] ==== Auto-configured JSON Tests To test that object JSON serialization and deserialization is working as expected you can -use the `@JsonTest` annotation. `@JsonTest` auto-configures the available supported -JSON mapper, which can be one of the following libraries: +use the `@JsonTest` annotation. `@JsonTest` auto-configures the available supported JSON +mapper, which can be one of the following libraries: * Jackson `ObjectMapper`, any `@JsonComponent` beans and any Jackson `Modules` * `Gson` @@ -5947,8 +5973,9 @@ Often, `@WebMvcTest` is limited to a single controller and is used in combinatio `@WebMvcTest` also auto-configures `MockMvc`. Mock MVC offers a powerful way to quickly test MVC controllers without needing to start a full HTTP server. -TIP: You can also auto-configure `MockMvc` in a non-`@WebMvcTest` (such as `SpringBootTest`) -by annotating it with `@AutoConfigureMockMvc`. The following example uses `MockMvc`: +TIP: You can also auto-configure `MockMvc` in a non-`@WebMvcTest` (such as +`@SpringBootTest`) by annotating it with `@AutoConfigureMockMvc`. The following example +uses `MockMvc`: [source,java,indent=0] ---- @@ -5984,12 +6011,12 @@ by annotating it with `@AutoConfigureMockMvc`. The following example uses `MockM } ---- -TIP: If you need to configure elements of the auto-configuration (for example, when servlet -filters should be applied) you can use attributes in the `@AutoConfigureMockMvc` +TIP: If you need to configure elements of the auto-configuration (for example, when +servlet filters should be applied) you can use attributes in the `@AutoConfigureMockMvc` annotation. -If you use HtmlUnit or Selenium, auto-configuration also provides an HTMLUnit `WebClient` bean -and/or a `WebDriver` bean. The following example uses HtmlUnit: +If you use HtmlUnit or Selenium, auto-configuration also provides an HTMLUnit `WebClient` +bean and/or a `WebDriver` bean. The following example uses HtmlUnit: [source,java,indent=0] @@ -6025,10 +6052,9 @@ and/or a `WebDriver` bean. The following example uses HtmlUnit: } ---- -NOTE: By default, Spring Boot puts `WebDriver` beans in a special "`scope`" to ensure -that the driver is quit after each test and that a new instance is injected. If you do not -want this behavior, you can add `@Scope("singleton")` to your `WebDriver` `@Bean` -definition. +NOTE: By default, Spring Boot puts `WebDriver` beans in a special "`scope`" to ensure that +the driver is quit after each test and that a new instance is injected. If you do not want +this behavior, you can add `@Scope("singleton")` to your `WebDriver` `@Bean` definition. A list of the auto-configuration settings that are enabled by `@WebMvcTest` can be <>. @@ -6037,21 +6063,21 @@ A list of the auto-configuration settings that are enabled by `@WebMvcTest` can [[boot-features-testing-spring-boot-applications-testing-autoconfigured-webflux-tests]] ==== Auto-configured Spring WebFlux Tests -To test that Spring WebFlux controllers are working as expected, you can use the `@WebFluxTest` -annotation. `@WebFluxTest` auto-configures the Spring WebFlux infrastructure and limits -scanned beans to `@Controller`, `@ControllerAdvice`, `@JsonComponent`, and -`WebFluxConfigurer`. Regular `@Component` beans are not scanned when the `@WebFluxTest` -annotation is used. +To test that Spring WebFlux controllers are working as expected, you can use the +`@WebFluxTest` annotation. `@WebFluxTest` auto-configures the Spring WebFlux +infrastructure and limits scanned beans to `@Controller`, `@ControllerAdvice`, +`@JsonComponent`, and `WebFluxConfigurer`. Regular `@Component` beans are not scanned when +the `@WebFluxTest` annotation is used. Often, `@WebFluxTest` is limited to a single controller and used in combination with the `@MockBean` annotation to provide mock implementations for required collaborators. -`@WebFluxTest` also auto-configures `WebTestClient`, which offers a powerful way to quickly -test WebFlux controllers without needing to start a full HTTP server. +`@WebFluxTest` also auto-configures `WebTestClient`, which offers a powerful way to +quickly test WebFlux controllers without needing to start a full HTTP server. -TIP: You can also auto-configure `WebTestClient` in a non-`@WebFluxTest` -(such as `@SpringBootTest`) by annotating it with `@AutoConfigureWebTestClient`. The -following example shows a class that uses both `@WebFluxTest` and a `WebTestClient`: +TIP: You can also auto-configure `WebTestClient` in a non-`@WebFluxTest` (such as +`@SpringBootTest`) by annotating it with `@AutoConfigureWebTestClient`. The following +example shows a class that uses both `@WebFluxTest` and a `WebTestClient`: [source,java,indent=0] ---- @@ -6095,14 +6121,14 @@ A list of the auto-configuration that is enabled by `@WebFluxTest` can be [[boot-features-testing-spring-boot-applications-testing-autoconfigured-jpa-test]] ==== Auto-configured Data JPA Tests You can use the `@DataJpaTest` annotation to test JPA applications. By default, it -configures an in-memory embedded database, scans for `@Entity` classes, and configures Spring -Data JPA repositories. Regular `@Component` beans are not loaded into the +configures an in-memory embedded database, scans for `@Entity` classes, and configures +Spring Data JPA repositories. Regular `@Component` beans are not loaded into the `ApplicationContext`. -By default, data JPA tests are transactional and roll back at the end of each test. -See the {spring-reference}testing.html#testcontext-tx-enabling-transactions[relevant section] in the -Spring Reference Documentation for more details. If that is not what you want, you can -disable transaction management for a test or for the whole class as follows: +By default, data JPA tests are transactional and roll back at the end of each test. See +the {spring-reference}testing.html#testcontext-tx-enabling-transactions[relevant section] +in the Spring Framwork Reference Documentation for more details. If that is not what you +want, you can disable transaction management for a test or for the whole class as follows: [source,java,indent=0] ---- @@ -6123,11 +6149,11 @@ disable transaction management for a test or for the whole class as follows: Data JPA tests may also inject a {sc-spring-boot-test-autoconfigure}/orm/jpa/TestEntityManager.{sc-ext}[`TestEntityManager`] -bean, which provides an alternative to the standard JPA `EntityManager` that is specifically -designed for tests. If you want to use `TestEntityManager` outside of `@DataJpaTest` instances, you -can also use the `@AutoConfigureTestEntityManager` annotation. A `JdbcTemplate` is also -available if you need that. The following example shows the `@DataJpaTest`annotation in -use: +bean, which provides an alternative to the standard JPA `EntityManager` that is +specifically designed for tests. If you want to use `TestEntityManager` outside of +`@DataJpaTest` instances, you can also use the `@AutoConfigureTestEntityManager` +annotation. A `JdbcTemplate` is also available if you need that. The following example +shows the `@DataJpaTest`annotation in use: [source,java,indent=0] ---- @@ -6159,9 +6185,8 @@ use: ---- In-memory embedded databases generally work well for tests, since they are fast and do not -require any installation. If, however, you prefer to run tests against a real -database you can use the `@AutoConfigureTestDatabase` annotation, as shown in the -following example: +require any installation. If, however, you prefer to run tests against a real database you +can use the `@AutoConfigureTestDatabase` annotation, as shown in the following example: [source,java,indent=0] ---- @@ -6183,13 +6208,14 @@ A list of the auto-configuration settings that are enabled by `@DataJpaTest` can [[boot-features-testing-spring-boot-applications-testing-autoconfigured-jdbc-test]] ==== Auto-configured JDBC Tests `@JdbcTest` is similar to `@DataJpaTest` but for pure JDBC-related tests. By default, it -also configures an in-memory embedded database and a `JdbcTemplate`. Regular -`@Component` beans are not loaded into the `ApplicationContext`. +also configures an in-memory embedded database and a `JdbcTemplate`. Regular `@Component` +beans are not loaded into the `ApplicationContext`. By default, JDBC tests are transactional and roll back at the end of each test. -See the {spring-reference}testing.html#testcontext-tx-enabling-transactions[relevant section] in the -Spring Reference Documentation for more details. If that is not what you want, you can -disable transaction management for a test or for the whole class as follows: +See the {spring-reference}testing.html#testcontext-tx-enabling-transactions[relevant +section] in the Spring Framework Reference Documentation for more details. If that is not +what you want, you can disable transaction management for a test or for the whole class as +follows: [source,java,indent=0] ---- @@ -6209,8 +6235,8 @@ disable transaction management for a test or for the whole class as follows: ---- If you prefer your test to run against a real database, you can use the -`@AutoConfigureTestDatabase` annotation in the same way as for `DataJpaTest`. -(See <>.) +`@AutoConfigureTestDatabase` annotation in the same way as for `DataJpaTest`. (See +<>.) A list of the auto-configuration that is enabled by `@JdbcTest` can be <>. @@ -6224,9 +6250,8 @@ jOOQ relies heavily on a Java-based schema that corresponds with the database sc existing `DataSource` is used. If you want to replace it with an in-memory database, you can use `@AutoconfigureTestDatabase` to override those settings. -`@JooqTest` configures a `DSLContext`. Regular `@Component` beans are not loaded -into the `ApplicationContext`. The following example shows the `@JooqTest` annotaiton in -use: +`@JooqTest` configures a `DSLContext`. Regular `@Component` beans are not loaded into the +`ApplicationContext`. The following example shows the `@JooqTest` annotation in use: [source,java,indent=0] ---- @@ -6247,7 +6272,8 @@ use: JOOQ tests are transactional and roll back at the end of each test by default. If that is not what you want, you can disable transaction management for a test or for the whole test -class as <>. A list of the auto-configuration that is enabled by `@JooqTest` can be @@ -6257,11 +6283,11 @@ A list of the auto-configuration that is enabled by `@JooqTest` can be [[boot-features-testing-spring-boot-applications-testing-autoconfigured-mongo-test]] ==== Auto-configured Data MongoDB Tests -You can use `@DataMongoTest` to test MongoDB applications. By default, it -configures an in-memory embedded MongoDB (if available), configures a `MongoTemplate`, scans -for `@Document` classes, and configures Spring Data MongoDB repositories. Regular -`@Component` beans are not loaded into the `ApplicationContext`. The following class -shows the `@DataMongoTest` annotation in use: +You can use `@DataMongoTest` to test MongoDB applications. By default, it configures an +in-memory embedded MongoDB (if available), configures a `MongoTemplate`, scans for +`@Document` classes, and configures Spring Data MongoDB repositories. Regular `@Component` +beans are not loaded into the `ApplicationContext`. The following class shows the +`@DataMongoTest` annotation in use: [source,java,indent=0] ---- @@ -6332,9 +6358,10 @@ beans are not loaded into the `ApplicationContext`: ---- By default, Data Neo4j tests are transactional and roll back at the end of each test. -See the {spring-reference}testing.html#testcontext-tx-enabling-transactions[relevant section] in the -Spring Reference Documentation for more details. If that is not what you want, you can -disable transaction management for a test or for the whole class as follows: +See the {spring-reference}testing.html#testcontext-tx-enabling-transactions[relevant +section] in the Spring Framework Reference Documentation for more details. If that is not +what you want, you can disable transaction management for a test or for the whole class as +follows: [source,java,indent=0] ---- @@ -6361,10 +6388,10 @@ A list of the auto-configuration settings that are enabled by `@DataNeo4jTest` c [[boot-features-testing-spring-boot-applications-testing-autoconfigured-redis-test]] ==== Auto-configured Data Redis Tests -You can use `@DataRedisTest` to test Redis applications. By default, it -scans for `@RedisHash` classes and configures Spring Data Redis repositories. Regular -`@Component` beans are not loaded into the `ApplicationContext`. The follwing example -shows the `@DataRedisTest` annotation in use: +You can use `@DataRedisTest` to test Redis applications. By default, it scans for +`@RedisHash` classes and configures Spring Data Redis repositories. Regular `@Component` +beans are not loaded into the `ApplicationContext`. The follwing example shows the +`@DataRedisTest` annotation in use: [source,java,indent=0] ---- @@ -6391,10 +6418,10 @@ A list of the auto-configuration settings that are enabled by `@DataRedisTest` c [[boot-features-testing-spring-boot-applications-testing-autoconfigured-ldap-test]] ==== Auto-configured Data LDAP Tests -You can use `@DataLdapTest` to test LDAP applications. By default, it -configures an in-memory embedded LDAP (if available), configures an `LdapTemplate`, scans for `@Entry` -classes, and configures Spring Data LDAP repositories. Regular `@Component` beans are -not loaded into the `ApplicationContext`. The following example shows the `@DataLdapTest` +You can use `@DataLdapTest` to test LDAP applications. By default, it configures an +in-memory embedded LDAP (if available), configures an `LdapTemplate`, scans for `@Entry` +classes, and configures Spring Data LDAP repositories. Regular `@Component` beans are not +loaded into the `ApplicationContext`. The following example shows the `@DataLdapTest` annotation in use: [source,java,indent=0] @@ -6424,7 +6451,7 @@ following example: [source,java,indent=0] ---- import org.junit.runner.RunWith; - import org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration; + import org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration; import org.springframework.boot.test.autoconfigure.data.ldap.DataLdapTest; import org.springframework.test.context.junit4.SpringRunner; @@ -6442,11 +6469,11 @@ A list of the auto-configuration settiongs that are enabled by `@DataLdapTest` c [[boot-features-testing-spring-boot-applications-testing-autoconfigured-rest-client]] ==== Auto-configured REST Clients -You can use the `@RestClientTest` annotation to test REST clients. By default, -it auto-configures Jackson, GSON, and Jsonb support, configures a `RestTemplateBuilder`, -and adds support for `MockRestServiceServer`. The specific beans that you want to test -should be specified by using the `value` or `components` attribute of `@RestClientTest`, -as shown in the following example: +You can use the `@RestClientTest` annotation to test REST clients. By default, it +auto-configures Jackson, GSON, and Jsonb support, configures a `RestTemplateBuilder`, and +adds support for `MockRestServiceServer`. The specific beans that you want to test should +be specified by using the `value` or `components` attribute of `@RestClientTest`, as shown +in the following example: [source,java,indent=0] @@ -6480,9 +6507,8 @@ A list of the auto-configuration settings that are enabled by `@RestClientTest` [[boot-features-testing-spring-boot-applications-testing-autoconfigured-rest-docs]] ==== Auto-configured Spring REST Docs Tests -You can use the `@AutoConfigureRestDocs` annotation to use Spring REST Docs -in your tests with Mock MVC or REST Assured. It removes the need for the JUnit rule in -Spring REST Docs. +You can use the `@AutoConfigureRestDocs` annotation to use Spring REST Docs in your tests +with Mock MVC or REST Assured. It removes the need for the JUnit rule in Spring REST Docs. `@AutoConfigureRestDocs` can be used to override the default output directory (`target/generated-snippets` if you are using Maven or `build/generated-snippets` if you @@ -6492,9 +6518,9 @@ appears in any documented URIs. [[boot-features-testing-spring-boot-applications-testing-autoconfigured-rest-docs-mock-mvc]] ===== Auto-configured Spring REST Docs Tests with Mock MVC -`@AutoConfigureRestDocs` customizes the `MockMvc` bean to use Spring REST Docs. You can inject it -by using `@Autowired` and use it in your tests as you normally would when using Mock MVC and -Spring REST Docs, as shown in the following example: +`@AutoConfigureRestDocs` customizes the `MockMvc` bean to use Spring REST Docs. You can +inject it by using `@Autowired` and use it in your tests as you normally would when using +Mock MVC and Spring REST Docs, as shown in the following example: [source,java,indent=0] ---- @@ -6548,9 +6574,9 @@ can be used, as shown in the following example: ---- If you want to make use of Spring REST Docs support for a parameterized output directory, -you can create a `RestDocumentationResultHandler` bean. The auto-configuration -calls `alwaysDo` with this result handler, thereby causing each `MockMvc` call to -automatically generate the default snippets. The following example shows a +you can create a `RestDocumentationResultHandler` bean. The auto-configuration calls +`alwaysDo` with this result handler, thereby causing each `MockMvc` call to automatically +generate the default snippets. The following example shows a `RestDocumentationResultHandler` being defined: [source,java,indent=0] @@ -6571,9 +6597,10 @@ automatically generate the default snippets. The following example shows a [[boot-features-testing-spring-boot-applications-testing-autoconfigured-rest-docs-rest-assured]] ===== Auto-configured Spring REST Docs Tests with REST Assured -`@AutoConfigureRestDocs` makes a `RequestSpecification` bean, preconfigured to use Spring REST -Docs, available to your tests. You can inject it by using `@Autowired` and use it in your tests as you -normally would when using REST Assured and Spring REST Docs, as shown in the following example: +`@AutoConfigureRestDocs` makes a `RequestSpecification` bean, preconfigured to use Spring +REST Docs, available to your tests. You can inject it by using `@Autowired` and use it in +your tests as you normally would when using REST Assured and Spring REST Docs, as shown in +the following example: [source,java,indent=0] ---- @@ -6593,16 +6620,16 @@ include::{code-examples}/test/autoconfigure/restdocs/restassured/AdvancedConfigu [[boot-features-testing-spring-boot-applications-testing-user-configuration]] ==== User Configuration and Slicing -If you <> in a sensible way, -your `@SpringBootApplication` class is +If you <> in a sensible way, your +`@SpringBootApplication` class is <> as the configuration of your tests. It then becomes important not to litter the application's main class with configuration settings that are are specific to a particular area of its functionality. -Assume that you are using Spring Batch and you rely on the auto-configuration -for it. Your could define your `@SpringBootApplication` as follows: +Assume that you are using Spring Batch and you rely on the auto-configuration for it. Your +could define your `@SpringBootApplication` as follows: [source,java,indent=0] ---- @@ -6613,8 +6640,8 @@ for it. Your could define your `@SpringBootApplication` as follows: Because this class is the source configuration for the test, any slice test actually tries to start Spring Batch, which is definitely not what you want to do. A recommended -approach is to move that area-specific configuration to a separate `@Configuration` -class at the same level as your application, as shown in the following example: +approach is to move that area-specific configuration to a separate `@Configuration` class +at the same level as your application, as shown in the following example: [source,java,indent=0] ---- @@ -6625,12 +6652,12 @@ class at the same level as your application, as shown in the following example: NOTE: Depending on the complexity of your application, you may either have a single `ApplicationConfiguration` class for your customizations or one class per domain area -when it makes sense. The latter approach lets you enable it in one of your tests, -if necessary, with the `@Import` annotation. +when it makes sense. The latter approach lets you enable it in one of your tests, if +necessary, with the `@Import` annotation. -Another source of confusion is classpath scanning. Assume that, while you -structured your code in a sensible way, you need to scan an additional package. Your -application may resemble the following code: +Another source of confusion is classpath scanning. Assume that, while you structured your +code in a sensible way, you need to scan an additional package. Your application may +resemble the following code: [source,java,indent=0] ---- @@ -6646,8 +6673,8 @@ application. Again, moving the custom directive to a separate class is a good wa this issue. TIP: If this is not an option for you, you can create a `@SpringBootConfiguration` -somewhere in the hierarchy of your test so that it is used instead. Alternatively, you can specify -a source for your test, which disables the behavior of finding a default one. +somewhere in the hierarchy of your test so that it is used instead. Alternatively, you can +specify a source for your test, which disables the behavior of finding a default one. @@ -6657,15 +6684,15 @@ If you wish to use Spock to test a Spring Boot application, you should add a dep on Spock's `spock-spring` module to your application's build. `spock-spring` integrates Spring's test framework into Spock. It is recommended that you use Spock 1.1 or later to benefit from a number of improvements to Spock's Spring Framework and Spring Boot -integration. See http://spockframework.org/spock/docs/1.1/modules.html[the -documentation for Spock's Spring module] for further details. +integration. See http://spockframework.org/spock/docs/1.1/modules.html[the documentation +for Spock's Spring module] for further details. [[boot-features-test-utilities]] === Test Utilities -A few test utility classes that are generally -useful when testing your application are packaged as part of `spring-boot`. +A few test utility classes that are generally useful when testing your application are +packaged as part of `spring-boot`. @@ -6682,8 +6709,8 @@ it when you do not need the full set of features provided by `@SpringBootTest`. ---- NOTE: Using `ConfigFileApplicationContextInitializer` alone does not provide support for -`@Value("${...}")` injection. Its only job is to ensure that `application.properties` files -are loaded into Spring's `Environment`. For `@Value` support, you need to either +`@Value("${...}")` injection. Its only job is to ensure that `application.properties` +files are loaded into Spring's `Environment`. For `@Value` support, you need to either additionally configure a `PropertySourcesPlaceholderConfigurer` or use `@SpringBootTest`, where one will be auto-configured for you. @@ -6735,18 +6762,18 @@ for assertions, as follows: ==== TestRestTemplate `TestRestTemplate` is a convenience alternative to Spring's `RestTemplate` that is useful in integration tests. You can get a vanilla template or one that sends Basic HTTP -authentication (with a username and password). In either case, the template behaves -in a test-friendly way by not throwing exceptions on server-side errors. It is -recommended, but not mandatory, to use the Apache HTTP Client (version 4.3.2 or better). -If you have that on your classpath, the `TestRestTemplate` responds by configuring -the client appropriately. If you do use Apache's HTTP client, some additional test-friendly -features are enabled: +authentication (with a username and password). In either case, the template behaves in a +test-friendly way by not throwing exceptions on server-side errors. It is recommended, but +not mandatory, to use the Apache HTTP Client (version 4.3.2 or better). If you have that +on your classpath, the `TestRestTemplate` responds by configuring the client +appropriately. If you do use Apache's HTTP client, some additional test-friendly features +are enabled: * Redirects are not followed (so you can assert the response location). * Cookies are ignored (so the template is stateless). -`TestRestTemplate` can be instantiated directly in your integration tests, as shown in -the following example: +`TestRestTemplate` can be instantiated directly in your integration tests, as shown in the +following example: [source,java,indent=0] ---- @@ -6764,11 +6791,10 @@ the following example: ---- Alternatively, if you use the `@SpringBootTest` annotation with -`WebEnvironment.RANDOM_PORT` or `WebEnvironment.DEFINED_PORT`, you can just inject a -fully configured `TestRestTemplate` and start using it. If necessary, additional -customizations can be applied through the `RestTemplateBuilder` bean. Any URLs that do not -specify a host and port automatically connect to the embedded server, as shown in the -following example: +`WebEnvironment.RANDOM_PORT` or `WebEnvironment.DEFINED_PORT`, you can just inject a fully +configured `TestRestTemplate` and start using it. If necessary, additional customizations +can be applied through the `RestTemplateBuilder` bean. Any URLs that do not specify a host +and port automatically connect to the embedded server, as shown in the following example: [source,java,indent=0] ---- @@ -6805,12 +6831,11 @@ following example: [[boot-features-websockets]] == WebSockets Spring Boot provides WebSockets auto-configuration for embedded Tomcat (8 and 7), Jetty 9, -and Undertow. If you deploy a war file to a standalone container, Spring Boot -assumes that the container is responsible for the configuration of its WebSocket -support. +and Undertow. If you deploy a war file to a standalone container, Spring Boot assumes that +the container is responsible for the configuration of its WebSocket support. -Spring Framework provides {spring-reference}web.html#websocket[rich WebSocket support] that can -be easily accessed through the `spring-boot-starter-websocket` module. +Spring Framework provides {spring-reference}web.html#websocket[rich WebSocket support] +that can be easily accessed through the `spring-boot-starter-websocket` module. @@ -6829,7 +6854,7 @@ following example: [source,properties,indent=0] ---- - spring.webservices.wsdl-locations=classpath:/wsdl + spring.webservices.wsdl-locations=classpath:/wsdl ---- @@ -6846,8 +6871,8 @@ code as well as the typical libraries that you would use with it. We first cover you need to know to build your own auto-configuration and then we move on to the <>. -TIP: A https://github.com/snicoll-demos/spring-boot-master-auto-configuration[demo project] -is available to showcase how you can create a starter step-by-step. +TIP: A https://github.com/snicoll-demos/spring-boot-master-auto-configuration[demo +project] is available to showcase how you can create a starter step-by-step. @@ -6903,13 +6928,13 @@ scanning. [[boot-features-condition-annotations]] === Condition Annotations You almost always want to include one or more `@Conditional` annotations on your -auto-configuration class. The `@ConditionalOnMissingBean` annotation is one common example that is -used to allow developers to '`override`' auto-configuration if they are not happy with -your defaults. +auto-configuration class. The `@ConditionalOnMissingBean` annotation is one common example +that is used to allow developers to '`override`' auto-configuration if they are not happy +with your defaults. Spring Boot includes a number of `@Conditional` annotations that you can reuse in your own -code by annotating `@Configuration` classes or individual `@Bean` methods. These annotations -include: +code by annotating `@Configuration` classes or individual `@Bean` methods. These +annotations include: * <> * <> @@ -6922,11 +6947,11 @@ include: [[boot-features-class-conditions]] ==== Class Conditions The `@ConditionalOnClass` and `@ConditionalOnMissingClass` annotations let -configuration be included based on the presence or absence of specific classes. Due to -the fact that annotation metadata is parsed by using http://asm.ow2.org/[ASM], you can -use the `value` attribute to refer to the real class, even though that class -might not actually appear on the running application classpath. You can also use the -`name` attribute if you prefer to specify the class name by using a `String` value. +configuration be included based on the presence or absence of specific classes. Due to the +fact that annotation metadata is parsed by using http://asm.ow2.org/[ASM], you can use the +`value` attribute to refer to the real class, even though that class might not actually +appear on the running application classpath. You can also use the `name` attribute if you +prefer to specify the class name by using a `String` value. [TIP] ==== @@ -6939,8 +6964,8 @@ to the class in such a case is not handled. [[boot-features-bean-conditions]] ==== Bean Conditions -The `@ConditionalOnBean` and `@ConditionalOnMissingBean` annotations let a bean -be included based on the presence or absence of specific beans. You can use the `value` +The `@ConditionalOnBean` and `@ConditionalOnMissingBean` annotations let a bean be +included based on the presence or absence of specific beans. You can use the `value` attribute to specify beans by type or `name` to specify beans by name. The `search` attribute lets you limit the `ApplicationContext` hierarchy that should be considered when searching for beans. @@ -6964,10 +6989,10 @@ In the preceding example, the `myService` bean is going to be created if no bean `MyService` is already contained in the `ApplicationContext`. TIP: You need to be very careful about the order that bean definitions are added as these -conditions are evaluated based on what has been processed so far. For this reason, -we recommend only using `@ConditionalOnBean` and `@ConditionalOnMissingBean` annotations -on auto-configuration classes (since these are guaranteed to load after any user-defined -bean definitions have been added). +conditions are evaluated based on what has been processed so far. For this reason, we +recommend only using `@ConditionalOnBean` and `@ConditionalOnMissingBean` annotations on +auto-configuration classes (since these are guaranteed to load after any user-defined bean +definitions have been added). NOTE: `@ConditionalOnBean` and `@ConditionalOnMissingBean` do not prevent `@Configuration` classes from being created. Using these conditions at the class level is equivalent to @@ -6977,11 +7002,11 @@ marking each contained `@Bean` method with the annotation. [[boot-features-property-conditions]] ==== Property Conditions -The `@ConditionalOnProperty` annotation lets configuration be included based on a -Spring Environment property. Use the `prefix` and `name` attributes to specify the -property that should be checked. By default, any property that exists and is not equal to -`false` is matched. You can also create more advanced checks by using the `havingValue` -and `matchIfMissing` attributes. +The `@ConditionalOnProperty` annotation lets configuration be included based on a Spring +Environment property. Use the `prefix` and `name` attributes to specify the property that +should be checked. By default, any property that exists and is not equal to `false` is +matched. You can also create more advanced checks by using the `havingValue` and +`matchIfMissing` attributes. @@ -6996,9 +7021,9 @@ conventions, as shown in the following example: `file:/home/user/test.dat`. [[boot-features-web-application-conditions]] ==== Web Application Conditions The `@ConditionalOnWebApplication` and `@ConditionalOnNotWebApplication` annotations -let configuration be included depending on whether the application is a 'web -application'. A web application is any application that is using a Spring -`WebApplicationContext`, defines a `session` scope, or has a `StandardServletEnvironment`. +let configuration be included depending on whether the application is a 'web application'. +A web application is any application that is using a Spring `WebApplicationContext`, +defines a `session` scope, or has a `StandardServletEnvironment`. @@ -7025,53 +7050,53 @@ module if you do not need to separate those two concerns. [[boot-features-custom-starter-naming]] ==== Naming -You should make sure to provide a proper namespace for your starter. Do not start your module -names with `spring-boot`, even if you are using a different Maven `groupId`. We may offer an -official support for the thing you auto-configure in the future. +You should make sure to provide a proper namespace for your starter. Do not start your +module names with `spring-boot`, even if you are using a different Maven `groupId`. We may +offer an official support for the thing you auto-configure in the future. As a rule of thumb, you should name a combined module after the starter. For example, -assume that you are creating a starter for "acme" and that you name the -auto-configure module `acme-spring-boot-autoconfigure` and the starter -`acme-spring-boot-starter`. If you only have one module that combines the two, name it -`acme-spring-boot-starter`. +assume that you are creating a starter for "acme" and that you name the auto-configure +module `acme-spring-boot-autoconfigure` and the starter `acme-spring-boot-starter`. If you +only have one module that combines the two, name it `acme-spring-boot-starter`. -Also, if your starter provides configuration keys, use a proper (that is, unique) namespace for them. In -particular, do not include your keys in the namespaces that Spring Boot uses (such as -`server`, `management`, `spring`, and so on). If you use the same namespace, we may modify these namespaces -in the future in ways that break your modules. +Also, if your starter provides configuration keys, use a proper (that is, unique) +namespace for them. In particular, do not include your keys in the namespaces that Spring +Boot uses (such as `server`, `management`, `spring`, and so on). If you use the same +namespace, we may modify these namespaces in the future in ways that break your modules. Make sure to <> so that IDE assistance is available for your keys as well. You -may want to review the generated meta-data (`META-INF/spring-configuration-metadata.json`) -to make sure your keys are properly documented. +meta-data generation>> so that IDE assistance is available for your keys as well. You may +want to review the generated meta-data (`META-INF/spring-configuration-metadata.json`) to +make sure your keys are properly documented. [[boot-features-custom-starter-module-autoconfigure]] ==== `autoconfigure` Module The `autoconfigure` module contains everything that is necessary to get started with the -library. It may also contain configuration key definitions (such as `@ConfigurationProperties`) -and any callback interface that can be used to further customize how the components are -initialized. +library. It may also contain configuration key definitions (such as +`@ConfigurationProperties`) and any callback interface that can be used to further +customize how the components are initialized. TIP: You should mark the dependencies to the library as optional so that you can include -the `autoconfigure` module in your projects more easily. If you do it that way, the library -is not provided and, by default, Spring Boot backs off. +the `autoconfigure` module in your projects more easily. If you do it that way, the +library is not provided and, by default, Spring Boot backs off. [[boot-features-custom-starter-module-starter]] ==== Starter Module The starter is really an empty jar. Its only purpose is to provide the necessary -dependencies to work with the library. You can think of it as an opinionated view of what is required -to get started. +dependencies to work with the library. You can think of it as an opinionated view of what +is required to get started. Do not make assumptions about the project in which your starter is added. If the library -you are auto-configuring typically requires other starters, mention them as well. Providing -a proper set of _default_ dependencies may be hard if the number of optional dependencies -is high, as you should avoid including dependencies that are unnecessary for a typical usage of the -library. In other words, you should not include optional dependencies. +you are auto-configuring typically requires other starters, mention them as well. +Providing a proper set of _default_ dependencies may be hard if the number of optional +dependencies is high, as you should avoid including dependencies that are unnecessary for +a typical usage of the library. In other words, you should not include optional +dependencies.