Spring Boot Reference Guide

Authors

Phillip Webb, Dave Syer, Josh Long, Stéphane Nicoll, Rob Winch, Andy Wilkinson, Marcel Overdijk, Christian Dupuis, Sébastien Deleuze, Michael Simons, Vedran Pavić

2.0.0.BUILD-SNAPSHOT

Copies of this document may be made for your own use and for distribution to others, provided that you do not charge any fee for such copies and further provided that each copy contains this Copyright Notice, whether distributed in print or electronically.


Table of Contents

I. Spring Boot Documentation
1. About the documentation
2. Getting help
3. First steps
4. Working with Spring Boot
5. Learning about Spring Boot features
6. Moving to production
7. Advanced topics
II. Getting started
8. Introducing Spring Boot
9. System Requirements
9.1. Servlet containers
10. Installing Spring Boot
10.1. Installation instructions for the Java developer
10.1.1. Maven installation
10.1.2. Gradle installation
10.2. Installing the Spring Boot CLI
10.2.1. Manual installation
10.2.2. Installation with SDKMAN!
10.2.3. OSX Homebrew installation
10.2.4. MacPorts installation
10.2.5. Command-line completion
10.2.6. Quick start Spring CLI example
10.3. Upgrading from an earlier version of Spring Boot
11. Developing your first Spring Boot application
11.1. Creating the POM
11.2. Adding classpath dependencies
11.3. Writing the code
11.3.1. The @RestController and @RequestMapping annotations
11.3.2. The @EnableAutoConfiguration annotation
11.3.3. The “main” method
11.4. Running the example
11.5. Creating an executable jar
12. What to read next
III. Using Spring Boot
13. Build systems
13.1. Dependency management
13.2. Maven
13.2.1. Inheriting the starter parent
13.2.2. Using Spring Boot without the parent POM
13.2.3. Using the Spring Boot Maven plugin
13.3. Gradle
13.4. Ant
13.5. Starters
14. Structuring your code
14.1. Using the “default” package
14.2. Locating the main application class
15. Configuration classes
15.1. Importing additional configuration classes
15.2. Importing XML configuration
16. Auto-configuration
16.1. Gradually replacing auto-configuration
16.2. Disabling specific auto-configuration
17. Spring Beans and dependency injection
18. Using the @SpringBootApplication annotation
19. Running your application
19.1. Running from an IDE
19.2. Running as a packaged application
19.3. Using the Maven plugin
19.4. Using the Gradle plugin
19.5. Hot swapping
20. Developer tools
20.1. Property defaults
20.2. Automatic restart
20.2.1. Excluding resources
20.2.2. Watching additional paths
20.2.3. Disabling restart
20.2.4. Using a trigger file
20.2.5. Customizing the restart classloader
20.2.6. Known limitations
20.3. LiveReload
20.4. Global settings
20.5. Remote applications
20.5.1. Running the remote client application
20.5.2. Remote update
21. Packaging your application for production
22. What to read next
IV. Spring Boot features
23. SpringApplication
23.1. Startup failure
23.2. Customizing the Banner
23.3. Customizing SpringApplication
23.4. Fluent builder API
23.5. Application events and listeners
23.6. Web environment
23.7. Accessing application arguments
23.8. Using the ApplicationRunner or CommandLineRunner
23.9. Application exit
23.10. Admin features
24. Externalized Configuration
24.1. Configuring random values
24.2. Accessing command line properties
24.3. Application property files
24.4. Profile-specific properties
24.5. Placeholders in properties
24.6. Using YAML instead of Properties
24.6.1. Loading YAML
24.6.2. Exposing YAML as properties in the Spring Environment
24.6.3. Multi-profile YAML documents
24.6.4. YAML shortcomings
24.6.5. Merging YAML lists
24.7. Type-safe Configuration Properties
24.7.1. Third-party configuration
24.7.2. Relaxed binding
24.7.3. Properties conversion
24.7.4. @ConfigurationProperties Validation
24.7.5. @ConfigurationProperties vs. @Value
25. Profiles
25.1. Adding active profiles
25.2. Programmatically setting profiles
25.3. Profile-specific configuration files
26. Logging
26.1. Log format
26.2. Console output
26.2.1. Color-coded output
26.3. File output
26.4. Log Levels
26.5. Custom log configuration
26.6. Logback extensions
26.6.1. Profile-specific configuration
26.6.2. Environment properties
27. Developing web applications
27.1. The ‘Spring Web MVC framework’
27.1.1. Spring MVC auto-configuration
27.1.2. HttpMessageConverters
27.1.3. Custom JSON Serializers and Deserializers
27.1.4. MessageCodesResolver
27.1.5. Static Content
27.1.6. Custom Favicon
27.1.7. ConfigurableWebBindingInitializer
27.1.8. Template engines
27.1.9. Error Handling
Custom error pages
Mapping error pages outside of Spring MVC
Error Handling on WebSphere Application Server
27.1.10. Spring HATEOAS
27.1.11. CORS support
27.2. The ‘Spring WebFlux framework’
27.2.1. Spring WebFlux auto-configuration
27.2.2. HTTP codecs with HttpMessageReaders and HttpMessageWriters
27.2.3. Static Content
27.2.4. Template engines
27.3. JAX-RS and Jersey
27.4. Embedded servlet container support
27.4.1. Servlets, Filters, and listeners
Registering Servlets, Filters, and listeners as Spring beans
27.4.2. Servlet Context Initialization
Scanning for Servlets, Filters, and listeners
27.4.3. The ServletWebServerApplicationContext
27.4.4. Customizing embedded servlet containers
Programmatic customization
Customizing ConfigurableServletWebServerFactory directly
27.4.5. JSP limitations
28. Security
28.1. OAuth2
28.1.1. Authorization Server
28.1.2. Resource Server
28.2. Token Type in User Info
28.3. Customizing the User Info RestTemplate
28.3.1. Client
28.3.2. Single Sign On
28.4. Actuator Security
29. Working with SQL databases
29.1. Configure a DataSource
29.1.1. Embedded Database Support
29.1.2. Connection to a production database
29.1.3. Connection to a JNDI DataSource
29.2. Using JdbcTemplate
29.3. JPA and ‘Spring Data’
29.3.1. Entity Classes
29.3.2. Spring Data JPA Repositories
29.3.3. Creating and dropping JPA databases
29.3.4. Open EntityManager in View
29.4. Using H2’s web console
29.4.1. Changing the H2 console’s path
29.4.2. Securing the H2 console
29.5. Using jOOQ
29.5.1. Code Generation
29.5.2. Using DSLContext
29.5.3. jOOQ SQL dialect
29.5.4. Customizing jOOQ
30. Working with NoSQL technologies
30.1. Redis
30.1.1. Connecting to Redis
30.2. MongoDB
30.2.1. Connecting to a MongoDB database
30.2.2. MongoTemplate
30.2.3. Spring Data MongoDB repositories
30.2.4. Embedded Mongo
30.3. Neo4j
30.3.1. Connecting to a Neo4j database
30.3.2. Using the embedded mode
30.3.3. Neo4jSession
30.3.4. Spring Data Neo4j repositories
30.3.5. Repository example
30.4. Gemfire
30.5. Solr
30.5.1. Connecting to Solr
30.5.2. Spring Data Solr repositories
30.6. Elasticsearch
30.6.1. Connecting to Elasticsearch using Jest
30.6.2. Connecting to Elasticsearch using Spring Data
30.6.3. Spring Data Elasticsearch repositories
30.7. Cassandra
30.7.1. Connecting to Cassandra
30.7.2. Spring Data Cassandra repositories
30.8. Couchbase
30.8.1. Connecting to Couchbase
30.8.2. Spring Data Couchbase repositories
30.9. LDAP
30.9.1. Connecting to an LDAP server
30.9.2. Spring Data LDAP repositories
30.9.3. Embedded in-memory LDAP server
30.10. InfluxDB
30.10.1. Connecting to InfluxDB
31. Caching
31.1. Supported cache providers
31.1.1. Generic
31.1.2. JCache (JSR-107)
31.1.3. EhCache 2.x
31.1.4. Hazelcast
31.1.5. Infinispan
31.1.6. Couchbase
31.1.7. Redis
31.1.8. Caffeine
31.1.9. Simple
31.1.10. None
32. Messaging
32.1. JMS
32.1.1. ActiveMQ support
32.1.2. Artemis support
32.1.3. Using a JNDI ConnectionFactory
32.1.4. Sending a message
32.1.5. Receiving a message
32.2. AMQP
32.2.1. RabbitMQ support
32.2.2. Sending a message
32.2.3. Receiving a message
32.3. Apache Kafka Support
32.3.1. Sending a Message
32.3.2. Receiving a Message
32.3.3. Additional Kafka Properties
33. Calling REST services with ‘RestTemplate’
33.1. RestTemplate customization
34. Calling REST services with ‘WebClient’
34.1. WebClient customization
35. Validation
36. Sending email
37. Distributed Transactions with JTA
37.1. Using an Atomikos transaction manager
37.2. Using a Bitronix transaction manager
37.3. Using a Narayana transaction manager
37.4. Using a Java EE managed transaction manager
37.5. Mixing XA and non-XA JMS connections
37.6. Supporting an alternative embedded transaction manager
38. Hazelcast
39. Quartz Scheduler
40. Spring Integration
41. Spring Session
42. Monitoring and management over JMX
43. Testing
43.1. Test scope dependencies
43.2. Testing Spring applications
43.3. Testing Spring Boot applications
43.3.1. Detecting test configuration
43.3.2. Excluding test configuration
43.3.3. Working with random ports
43.3.4. Mocking and spying beans
43.3.5. Auto-configured tests
43.3.6. Auto-configured JSON tests
43.3.7. Auto-configured Spring MVC tests
43.3.8. Auto-configured Spring WebFlux tests
43.3.9. Auto-configured Data JPA tests
43.3.10. Auto-configured JDBC tests
43.3.11. Auto-configured jOOQ tests
43.3.12. Auto-configured Data MongoDB tests
43.3.13. Auto-configured Data Neo4j tests
43.3.14. Auto-configured Data Redis tests
43.3.15. Auto-configured Data LDAP tests
43.3.16. Auto-configured REST clients
43.3.17. Auto-configured Spring REST Docs tests
43.3.18. Using Spock to test Spring Boot applications
43.4. Test utilities
43.4.1. ConfigFileApplicationContextInitializer
43.4.2. EnvironmentTestUtils
43.4.3. OutputCapture
43.4.4. TestRestTemplate
44. WebSockets
45. Web Services
46. Creating your own auto-configuration
46.1. Understanding auto-configured beans
46.2. Locating auto-configuration candidates
46.3. Condition annotations
46.3.1. Class conditions
46.3.2. Bean conditions
46.3.3. Property conditions
46.3.4. Resource conditions
46.3.5. Web application conditions
46.3.6. SpEL expression conditions
46.4. Creating your own starter
46.4.1. Naming
46.4.2. Autoconfigure module
46.4.3. Starter module
47. What to read next
V. Spring Boot Actuator: Production-ready features
48. Enabling production-ready features
49. Endpoints
49.1. Securing endpoints
49.2. Customizing endpoints
49.3. Hypermedia for actuator MVC endpoints
49.4. CORS support
49.5. Adding custom endpoints
49.6. Health information
49.6.1. Auto-configured HealthIndicators
49.6.2. Writing custom HealthIndicators
49.7. Application information
49.7.1. Auto-configured InfoContributors
49.7.2. Custom application info information
49.7.3. Git commit information
49.7.4. Build information
49.7.5. Writing custom InfoContributors
50. Monitoring and management over HTTP
50.1. Customizing the management endpoint paths
50.2. Customizing the management server port
50.3. Configuring management-specific SSL
50.4. Customizing the management server address
50.5. Disabling HTTP endpoints
50.6. HTTP health endpoint format and access restrictions
51. Monitoring and management over JMX
51.1. Customizing MBean names
51.2. Disabling JMX endpoints
51.3. Using Jolokia for JMX over HTTP
51.3.1. Customizing Jolokia
51.3.2. Disabling Jolokia
52. Loggers
52.1. Configure a Logger
53. Metrics
53.1. System metrics
53.2. DataSource metrics
53.3. Cache metrics
53.4. Tomcat session metrics
53.5. Recording your own metrics
53.6. Adding your own public metrics
53.7. Metric writers, exporters and aggregation
53.7.1. Example: Export to Redis
53.7.2. Example: Export to Open TSDB
53.7.3. Example: Export to Statsd
53.7.4. Example: Export to JMX
53.8. Aggregating metrics from multiple sources
53.9. Dropwizard Metrics
53.10. Message channel integration
54. Auditing
55. Tracing
55.1. Custom tracing
56. Process monitoring
56.1. Extend configuration
56.2. Programmatically
57. Cloud Foundry support
57.1. Disabling extended Cloud Foundry actuator support
57.2. Cloud Foundry self signed certificates
57.3. Custom security configuration
58. What to read next
VI. Deploying Spring Boot applications
59. Deploying to the cloud
59.1. Cloud Foundry
59.1.1. Binding to services
59.2. Heroku
59.3. OpenShift
59.4. Amazon Web Services (AWS)
59.4.1. AWS Elastic Beanstalk
Using the Tomcat platform
Using the Java SE platform
Best practices
59.4.2. Summary
59.5. Boxfuse and Amazon Web Services
59.6. Google Cloud
60. Installing Spring Boot applications
60.1. Supported operating systems
60.2. Unix/Linux services
60.2.1. Installation as an init.d service (System V)
Securing an init.d service
60.2.2. Installation as a systemd service
60.2.3. Customizing the startup script
Customizing script when it’s written
Customizing script when it runs
60.3. Microsoft Windows services
61. What to read next
VII. Spring Boot CLI
62. Installing the CLI
63. Using the CLI
63.1. Running applications using the CLI
63.1.1. Deduced “grab” dependencies
63.1.2. Deduced “grab” coordinates
63.1.3. Default import statements
63.1.4. Automatic main method
63.1.5. Custom dependency management
63.2. Applications with multiple source files
63.3. Packaging your application
63.4. Initialize a new project
63.5. Using the embedded shell
63.6. Adding extensions to the CLI
64. Developing application with the Groovy beans DSL
65. Configuring the CLI with settings.xml
66. What to read next
VIII. Build tool plugins
67. Spring Boot Maven plugin
67.1. Including the plugin
67.2. Packaging executable jar and war files
68. Spring Boot Gradle plugin
69. Spring Boot AntLib module
69.1. Spring Boot Ant tasks
69.1.1. spring-boot:exejar
69.1.2. Examples
69.2. spring-boot:findmainclass
69.2.1. Examples
70. Supporting other build systems
70.1. Repackaging archives
70.2. Nested libraries
70.3. Finding a main class
70.4. Example repackage implementation
71. What to read next
IX. ‘How-to’ guides
72. Spring Boot application
72.1. Create your own FailureAnalyzer
72.2. Troubleshoot auto-configuration
72.3. Customize the Environment or ApplicationContext before it starts
72.4. Build an ApplicationContext hierarchy (adding a parent or root context)
72.5. Create a non-web application
73. Properties & configuration
73.1. Automatically expand properties at build time
73.1.1. Automatic property expansion using Maven
73.1.2. Automatic property expansion using Gradle
73.2. Externalize the configuration of SpringApplication
73.3. Change the location of external properties of an application
73.4. Use ‘short’ command line arguments
73.5. Use YAML for external properties
73.6. Set the active Spring profiles
73.7. Change configuration depending on the environment
73.8. Discover built-in options for external properties
74. Embedded Web servers
74.1. Use another Web server
74.2. Configure Jetty
74.3. Add a Servlet, Filter or Listener to an application
74.3.1. Add a Servlet, Filter or Listener using a Spring bean
Disable registration of a Servlet or Filter
74.3.2. Add Servlets, Filters, and Listeners using classpath scanning
74.4. Change the HTTP port
74.5. Use a random unassigned HTTP port
74.6. Discover the HTTP port at runtime
74.7. Configure SSL
74.8. Configure Access Logging
74.9. Use behind a front-end proxy server
74.9.1. Customize Tomcat’s proxy configuration
74.10. Configure Tomcat
74.11. Enable Multiple Connectors with Tomcat
74.12. Use Tomcat’s LegacyCookieProcessor
74.13. Configure Undertow
74.14. Enable Multiple Listeners with Undertow
74.15. Create WebSocket endpoints using @ServerEndpoint
74.16. Enable HTTP response compression
75. Spring MVC
75.1. Write a JSON REST service
75.2. Write an XML REST service
75.3. Customize the Jackson ObjectMapper
75.4. Customize the @ResponseBody rendering
75.5. Handling Multipart File Uploads
75.6. Switch off the Spring MVC DispatcherServlet
75.7. Switch off the Default MVC configuration
75.8. Customize ViewResolvers
76. HTTP clients
76.1. Configure RestTemplate to use a proxy
77. Logging
77.1. Configure Logback for logging
77.1.1. Configure logback for file only output
77.2. Configure Log4j for logging
77.2.1. Use YAML or JSON to configure Log4j 2
78. Data Access
78.1. Configure a custom DataSource
78.2. Configure Two DataSources
78.3. Use Spring Data repositories
78.4. Separate @Entity definitions from Spring configuration
78.5. Configure JPA properties
78.6. Configure Hibernate Naming Strategy
78.7. Use a custom EntityManagerFactory
78.8. Use Two EntityManagers
78.9. Use a traditional persistence.xml
78.10. Use Spring Data JPA and Mongo repositories
78.11. Expose Spring Data repositories as REST endpoint
78.12. Configure a component that is used by JPA
79. Database initialization
79.1. Initialize a database using JPA
79.2. Initialize a database using Hibernate
79.3. Initialize a database using Spring JDBC
79.4. Initialize a Spring Batch database
79.5. Use a higher-level database migration tool
79.5.1. Execute Flyway database migrations on startup
79.5.2. Execute Liquibase database migrations on startup
80. Messaging
80.1. Disable transacted JMS session
81. Batch applications
81.1. Execute Spring Batch jobs on startup
82. Actuator
82.1. Change the HTTP port or address of the actuator endpoints
82.2. Customize the ‘whitelabel’ error page
82.3. Actuator and Jersey
83. Security
83.1. Switch off the Spring Boot security configuration
83.2. Change the AuthenticationManager and add user accounts
83.3. Enable HTTPS when running behind a proxy server
84. Hot swapping
84.1. Reload static content
84.2. Reload templates without restarting the container
84.2.1. Thymeleaf templates
84.2.2. FreeMarker templates
84.2.3. Groovy templates
84.3. Fast application restarts
84.4. Reload Java classes without restarting the container
85. Build
85.1. Generate build information
85.2. Generate git information
85.3. Customize dependency versions
85.4. Create an executable JAR with Maven
85.5. Use a Spring Boot application as a dependency
85.6. Extract specific libraries when an executable jar runs
85.7. Create a non-executable JAR with exclusions
85.8. Remote debug a Spring Boot application started with Maven
85.9. Build an executable archive from Ant without using spring-boot-antlib
86. Traditional deployment
86.1. Create a deployable war file
86.2. Create a deployable war file for older servlet containers
86.3. Convert an existing application to Spring Boot
86.4. Deploying a WAR to WebLogic
86.5. Deploying a WAR in an Old (Servlet 2.5) Container
86.6. Use Lettuce instead of Jedis
X. Appendices
A. Common application properties
B. Configuration meta-data
B.1. Meta-data format
B.1.1. Group Attributes
B.1.2. Property Attributes
B.1.3. Hint Attributes
B.1.4. Repeated meta-data items
B.2. Providing manual hints
B.2.1. Value hint
B.2.2. Value provider
Any
Class reference
Handle As
Logger name
Spring bean reference
Spring profile name
B.3. Generating your own meta-data using the annotation processor
B.3.1. Nested properties
B.3.2. Adding additional meta-data
C. Auto-configuration classes
C.1. From the “spring-boot-autoconfigure” module
C.2. From the “spring-boot-actuator” module
D. Test auto-configuration annotations
E. The executable jar format
E.1. Nested JARs
E.1.1. The executable jar file structure
E.1.2. The executable war file structure
E.2. Spring Boot’s “JarFile” class
E.2.1. Compatibility with the standard Java “JarFile”
E.3. Launching executable jars
E.3.1. Launcher manifest
E.3.2. Exploded archives
E.4. PropertiesLauncher Features
E.5. Executable jar restrictions
E.5.1. Zip entry compression
E.5.2. System ClassLoader
E.6. Alternative single jar solutions
F. Dependency versions