anchor.diff:  
   
   [[howto-use-custom-entity-manager]]
  -=== Use a custom EntityManagerFactory
  +=== Use a Custom EntityManagerFactory
   To take full control of the configuration of the `EntityManagerFactory`, you need to add
   a `@Bean` named '`entityManagerFactory`'. Spring Boot auto-configuration switches off its
  -entity manager based on the presence of a bean of that type.
  +entity manager in the presence of a bean of that type.
   
   
   
   [[howto-use-two-entity-managers]]
   === Use Two EntityManagers
  -Even if the default `EntityManagerFactory` works fine, you will need to define a new one
  -because otherwise the presence of the second bean of that type will switch off the
  -default. To make it easy to do that you can use the convenient `EntityManagerBuilder`
  -provided by Spring Boot, or if you prefer you can just use the
  -`LocalContainerEntityManagerFactoryBean` directly from Spring ORM.
  -
  -Example:
  +Even if the default `EntityManagerFactory` works fine, you need to define a new one.
  +Otherwise, the presence of the second bean of that type switches off the
  +default. To make it easy to do, you can use the convenient `EntityManagerBuilder`
  +provided by Spring Boot. Alternatively, you can just the
  +`LocalContainerEntityManagerFactoryBean` directly from Spring ORM, as shown in the
  +following example:
   
   [source,java,indent=0,subs="verbatim,quotes,attributes"]
   ----
  
positive.code: 	</plugin>
  ----
  
  NOTE: The `useDefaultDelimiters` property is important if you are using standard Spring
  placeholders in your configuration (e.g. `${foo}`). These may be expanded by the build if
  that property is not set to `false`.
  
  
  
  [[howto-automatic-expansion-gradle]]
  ==== Automatic property expansion using Gradle
  You can automatically expand properties from the Gradle project by configuring the
  Java plugin's `processResources` task to do so:
  
  [source,groovy,indent=0]
  ----
  
negative.code: 
  For example, to enable pretty print, set `spring.jackson.serialization.indent_output=true`.
  Note that, thanks to the use of <<boot-features-external-config-relaxed-binding,
  relaxed binding>>, the case of `indent_output` does not have to match the case of the
  corresponding enum constant, which is `INDENT_OUTPUT`.
  
  This environment-based configuration is applied to the auto-configured
  `Jackson2ObjectMapperBuilder` bean and applies to any mappers created by
  using the builder, including the auto-configured `ObjectMapper` bean.
  
  The context's `Jackson2ObjectMapperBuilder` can be customized by one or more
  `Jackson2ObjectMapperBuilderCustomizer` beans. Such customizer beans can be ordered
  (Boot's own customizer has an order of 0), letting additional customization be applied
  both before and after Boot's customization.
  
  Any beans of type `com.fasterxml.jackson.databind.Module` are automatically registered
  with the auto-configured `Jackson2ObjectMapperBuilder` and are applied to any `ObjectMapper`
  instances that it creates. This provides a global mechanism for contributing custom
  modules when you add new features to your application.
  
  If you want to replace the default `ObjectMapper` completely, either define a `@Bean` of
  that type and mark it as `@Primary` or, if you prefer the builder-based
  approach, define a `Jackson2ObjectMapperBuilder` `@Bean`. Note that, in either case,
  doing so disables all auto-configuration of the `ObjectMapper`.
  
  If you provide any `@Beans` of type `MappingJackson2HttpMessageConverter`,
  they replace the default value in the MVC configuration. Also, a convenience bean of type
  `HttpMessageConverters` is provided (always available if you use the default MVC
  configuration). It has some useful methods to access the default and user-enhanced
  message converters.
  
  See the "`<<howto-customize-the-responsebody-rendering>>`" section and the
  {sc-spring-boot-autoconfigure}/web/servlet/WebMvcAutoConfiguration.{sc-ext}[`WebMvcAutoConfiguration`]
  source code for more details.
  
  
  
  [[howto-customize-the-responsebody-rendering]]
  === Customize the @ResponseBody Rendering
  Spring uses `HttpMessageConverters` to render `@ResponseBody` (or responses from
  `@RestController`). You can contribute additional converters by adding beans of the
  appropriate type in a Spring Boot context. If a bean you add is of a type that would have been
  included by default anyway (such as `MappingJackson2HttpMessageConverter` for JSON
  conversions), it replaces the default value. A convenience bean of
  type `HttpMessageConverters` is provided and is always available if you use the default MVC configuration.
  It has some useful methods to access the default and user-enhanced message converters
  (For example, it can be useful if you want to manually inject them into a custom `RestTemplate`).
  
  As in normal MVC usage, any `WebMvcConfigurer` beans that you provide can also
  contribute converters by overriding the `configureMessageConverters` method. However, unlike
  with normal MVC, you can supply only additional converters that you need (because Spring
  Boot uses the same mechanism to contribute its defaults). Finally, if you opt out of the
  Spring Boot default MVC configuration by providing your own `@EnableWebMvc` configuration,
  you can take control completely and do everything manually by using
  `getMessageConverters` from `WebMvcConfigurationSupport`.
  
  See the {sc-spring-boot-autoconfigure}/web/servlet/WebMvcAutoConfiguration.{sc-ext}[`WebMvcAutoConfiguration`]
  