Spring Boot Reference Guide
Table of Contents
Part 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
Part 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
Maven installation
Gradle installation
10.2 Installing the Spring Boot CLI
Manual installation
Installation with SDKMAN!
OSX Homebrew installation
MacPorts installation
Command-line completion
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
The @RestController and @RequestMapping annotations
The @EnableAutoConfiguration annotation
The “main” method
11.4 Running the example
11.5 Creating an executable jar
12. What to read next
Part III. Using Spring Boot
13. Build systems
13.1 Dependency management
13.2 Maven
Inheriting the starter parent
Using Spring Boot without the parent POM
Changing the Java version
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
Excluding resources
Watching additional paths
Disabling restart
Using a trigger file
Customizing the restart classloader
Known limitations
20.3 LiveReload
20.4 Global settings
20.5 Remote applications
Running the remote client application
Remote update
Remote debug tunnel
21. Packaging your application for production
22. What to read next
Part 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
Loading YAML
Exposing YAML as properties in the Spring Environment
Multi-profile YAML documents
YAML shortcomings
Merging YAML lists
24.7 Type-safe Configuration Properties
Third-party configuration
Relaxed binding
Properties conversion
@ConfigurationProperties Validation
@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
Color-coded output
26.3 File output
26.4 Log Levels
26.5 Custom log configuration
26.6 Logback extensions
Profile-specific configuration
Environment properties
27. Developing web applications
27.1 The ‘Spring Web MVC framework’
Spring MVC auto-configuration
HttpMessageConverters
Custom JSON Serializers and Deserializers
MessageCodesResolver
Static Content
Custom Favicon
ConfigurableWebBindingInitializer
Template engines
Error Handling
Custom error pages
Mapping error pages outside of Spring MVC
Error Handling on WebSphere Application Server
Spring HATEOAS
CORS support
27.2 JAX-RS and Jersey
27.3 Embedded servlet container support
Servlets, Filters, and listeners
Registering Servlets, Filters, and listeners as Spring beans
Servlet Context Initialization
Scanning for Servlets, Filters, and listeners
The EmbeddedWebApplicationContext
Customizing embedded servlet containers
Programmatic customization
Customizing ConfigurableEmbeddedServletContainer directly
JSP limitations
28. Security
28.1 OAuth2
Authorization Server
Resource Server
28.2 Token Type in User Info
28.3 Customizing the User Info RestTemplate
Client
Single Sign On
28.4 Actuator Security
29. Working with SQL databases
29.1 Configure a DataSource
Embedded Database Support
Connection to a production database
Connection to a JNDI DataSource
29.2 Using JdbcTemplate
29.3 JPA and ‘Spring Data’
Entity Classes
Spring Data JPA Repositories
Creating and dropping JPA databases
Open EntityManager in View
29.4 Using H2’s web console
Changing the H2 console’s path
Securing the H2 console
29.5 Using jOOQ
Code Generation
Using DSLContext
Customizing jOOQ
30. Working with NoSQL technologies
30.1 Redis
Connecting to Redis
30.2 MongoDB
Connecting to a MongoDB database
MongoTemplate
Spring Data MongoDB repositories
Embedded Mongo
30.3 Neo4j
Connecting to a Neo4j database
Using the embedded mode
Neo4jSession
Spring Data Neo4j repositories
Repository example
30.4 Gemfire
30.5 Solr
Connecting to Solr
Spring Data Solr repositories
30.6 Elasticsearch
Connecting to Elasticsearch using Jest
Connecting to Elasticsearch using Spring Data
Spring Data Elasticsearch repositories
30.7 Cassandra
Connecting to Cassandra
Spring Data Cassandra repositories
30.8 Couchbase
Connecting to Couchbase
Spring Data Couchbase repositories
30.9 LDAP
Connecting to an LDAP server
Spring Data LDAP repositories
Embedded in-memory LDAP server
31. Caching
31.1 Supported cache providers
Generic
JCache (JSR-107)
EhCache 2.x
Hazelcast
Infinispan
Couchbase
Redis
Caffeine
Guava (deprecated)
Simple
None
32. Messaging
32.1 JMS
ActiveMQ support
Artemis support
Using a JNDI ConnectionFactory
Sending a message
Receiving a message
32.2 AMQP
RabbitMQ support
Sending a message
Receiving a message
32.3 Apache Kafka Support
Sending a Message
Receiving a Message
Additional Kafka Properties
33. Calling REST services
33.1 RestTemplate customization
34. Validation
35. Sending email
36. Distributed Transactions with JTA
36.1 Using an Atomikos transaction manager
36.2 Using a Bitronix transaction manager
36.3 Using a Narayana transaction manager
36.4 Using a Java EE managed transaction manager
36.5 Mixing XA and non-XA JMS connections
36.6 Supporting an alternative embedded transaction manager
37. Hazelcast
38. Spring Integration
39. Spring Session
40. Monitoring and management over JMX
41. Testing
41.1 Test scope dependencies
41.2 Testing Spring applications
41.3 Testing Spring Boot applications
Detecting test configuration
Excluding test configuration
Working with random ports
Using JMX
Mocking and spying beans
Auto-configured tests
Auto-configured JSON tests
Auto-configured Spring MVC tests
Auto-configured Data JPA tests
Auto-configured JDBC tests
Auto-configured Data MongoDB tests
Auto-configured REST clients
Auto-configured Spring REST Docs tests
User configuration and slicing
Using Spock to test Spring Boot applications
41.4 Test utilities
ConfigFileApplicationContextInitializer
EnvironmentTestUtils
OutputCapture
TestRestTemplate
42. WebSockets
43. Web Services
44. Creating your own auto-configuration
44.1 Understanding auto-configured beans
44.2 Locating auto-configuration candidates
44.3 Condition annotations
Class conditions
Bean conditions
Property conditions
Resource conditions
Web application conditions
SpEL expression conditions
44.4 Creating your own starter
Naming
Autoconfigure module
Starter module
45. What to read next
Part V. Spring Boot Actuator: Production-ready features
46. Enabling production-ready features
47. Endpoints
47.1 Customizing endpoints
47.2 Hypermedia for actuator MVC endpoints
47.3 CORS support
47.4 Adding custom endpoints
47.5 Health information
47.6 Security with HealthIndicators
Auto-configured HealthIndicators
Writing custom HealthIndicators
47.7 Application information
Auto-configured InfoContributors
Custom application info information
Git commit information
Build information
Writing custom InfoContributors
48. Monitoring and management over HTTP
48.1 Accessing sensitive endpoints
48.2 Customizing the management endpoint paths
48.3 Customizing the management server port
48.4 Configuring management-specific SSL
48.5 Customizing the management server address
48.6 Disabling HTTP endpoints
48.7 HTTP health endpoint format and access restrictions
49. Monitoring and management over JMX
49.1 Customizing MBean names
49.2 Disabling JMX endpoints
49.3 Using Jolokia for JMX over HTTP
Customizing Jolokia
Disabling Jolokia
50. Monitoring and management using a remote shell (deprecated)
50.1 Connecting to the remote shell
Remote shell credentials
50.2 Extending the remote shell
Remote shell commands
Remote shell plugins
51. Loggers
51.1 Configure a Logger
52. Metrics
52.1 System metrics
52.2 DataSource metrics
52.3 Cache metrics
52.4 Tomcat session metrics
52.5 Recording your own metrics
52.6 Adding your own public metrics
52.7 Special features with Java 8
52.8 Metric writers, exporters and aggregation
Example: Export to Redis
Example: Export to Open TSDB
Example: Export to Statsd
Example: Export to JMX
52.9 Aggregating metrics from multiple sources
52.10 Dropwizard Metrics
52.11 Message channel integration
53. Auditing
54. Tracing
54.1 Custom tracing
55. Process monitoring
55.1 Extend configuration
55.2 Programmatically
56. Cloud Foundry support
56.1 Disabling extended Cloud Foundry actuator support
56.2 Cloud Foundry self signed certificates
56.3 Custom security configuration
57. What to read next
Part VI. Deploying Spring Boot applications
58. Deploying to the cloud
58.1 Cloud Foundry
Binding to services
58.2 Heroku
58.3 OpenShift
58.4 Amazon Web Services (AWS)
AWS Elastic Beanstalk
Using the Tomcat platform
Using the Java SE platform
Best practices
Uploading binaries instead of sources
Reduce costs by setting the environment type
Summary
58.5 Boxfuse and Amazon Web Services
58.6 Google Cloud
59. Installing Spring Boot applications
59.1 Supported operating systems
59.2 Unix/Linux services
Installation as an init.d service (System V)
Securing an init.d service
Installation as a systemd service
Customizing the startup script
Customizing script when it’s written
Customizing script when it runs
59.3 Microsoft Windows services
60. What to read next
Part VII. Spring Boot CLI
61. Installing the CLI
62. Using the CLI
62.1 Running applications using the CLI
Deduced “grab” dependencies
Deduced “grab” coordinates
Default import statements
Automatic main method
Custom dependency management
62.2 Testing your code
62.3 Applications with multiple source files
62.4 Packaging your application
62.5 Initialize a new project
62.6 Using the embedded shell
62.7 Adding extensions to the CLI
63. Developing application with the Groovy beans DSL
64. Configuring the CLI with settings.xml
65. What to read next
Part VIII. Build tool plugins
66. Spring Boot Maven plugin
66.1 Including the plugin
66.2 Packaging executable jar and war files
67. Spring Boot Gradle plugin
67.1 Including the plugin
67.2 Gradle dependency management
67.3 Packaging executable jar and war files
67.4 Running a project in-place
67.5 Spring Boot plugin configuration
67.6 Repackage configuration
67.7 Repackage with custom Gradle configuration
Configuration options
Available layouts
Using a custom layout
67.8 Understanding how the Gradle plugin works
67.9 Publishing artifacts to a Maven repository using Gradle
Configuring Gradle to produce a pom that inherits dependency management
Configuring Gradle to produce a pom that imports dependency management
68. Spring Boot AntLib module
68.1 Spring Boot Ant tasks
spring-boot:exejar
Examples
68.2 spring-boot:findmainclass
Examples
69. Supporting other build systems
69.1 Repackaging archives
69.2 Nested libraries
69.3 Finding a main class
69.4 Example repackage implementation
70. What to read next
Part IX. ‘How-to’ guides
71. Spring Boot application
71.1 Create your own FailureAnalyzer
71.2 Troubleshoot auto-configuration
71.3 Customize the Environment or ApplicationContext before it starts
71.4 Build an ApplicationContext hierarchy (adding a parent or root context)
71.5 Create a non-web application
72. Properties & configuration
72.1 Automatically expand properties at build time
Automatic property expansion using Maven
Automatic property expansion using Gradle
72.2 Externalize the configuration of SpringApplication
72.3 Change the location of external properties of an application
72.4 Use ‘short’ command line arguments
72.5 Use YAML for external properties
72.6 Set the active Spring profiles
72.7 Change configuration depending on the environment
72.8 Discover built-in options for external properties
73. Embedded servlet containers
73.1 Add a Servlet, Filter or Listener to an application
Add a Servlet, Filter or Listener using a Spring bean
Disable registration of a Servlet or Filter
Add Servlets, Filters, and Listeners using classpath scanning
73.2 Change the HTTP port
73.3 Use a random unassigned HTTP port
73.4 Discover the HTTP port at runtime
73.5 Configure SSL
73.6 Configure Access Logging
73.7 Use behind a front-end proxy server
Customize Tomcat’s proxy configuration
73.8 Configure Tomcat
73.9 Enable Multiple Connectors with Tomcat
73.10 Use Tomcat’s LegacyCookieProcessor
73.11 Use Jetty instead of Tomcat
73.12 Configure Jetty
73.13 Use Undertow instead of Tomcat
73.14 Configure Undertow
73.15 Enable Multiple Listeners with Undertow
73.16 Use Tomcat 7.x or 8.0
Use Tomcat 7.x or 8.0 with Maven
Use Tomcat 7.x or 8.0 with Gradle
73.17 Use Jetty 9.2
Use Jetty 9.2 with Maven
Use Jetty 9.2 with Gradle
73.18 Use Jetty 8
Use Jetty 8 with Maven
Use Jetty 8 with Gradle
73.19 Create WebSocket endpoints using @ServerEndpoint
73.20 Enable HTTP response compression
74. Spring MVC
74.1 Write a JSON REST service
74.2 Write an XML REST service
74.3 Customize the Jackson ObjectMapper
74.4 Customize the @ResponseBody rendering
74.5 Handling Multipart File Uploads
74.6 Switch off the Spring MVC DispatcherServlet
74.7 Switch off the Default MVC configuration
74.8 Customize ViewResolvers
74.9 Use Thymeleaf 3
75. Jersey
75.1 Secure Jersey endpoints with Spring Security
76. HTTP clients
76.1 Configure RestTemplate to use a proxy
77. Logging
77.1 Configure Logback for logging
Configure logback for file only output
77.2 Configure Log4j for logging
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
78.13 Configure jOOQ with Two DataSources
79. Database initialization
79.1 Initialize a database using JPA
79.2 Initialize a database using Hibernate
79.3 Initialize a database
79.4 Initialize a Spring Batch database
79.5 Use a higher-level database migration tool
Execute Flyway database migrations on startup
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 Sanitize sensible values
82.4 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
Thymeleaf templates
FreeMarker templates
Groovy templates
84.3 Fast application restarts
84.4 Reload Java classes without restarting the container
Configuring Spring Loaded for use with Maven
Configuring Spring Loaded for use with Gradle and IntelliJ IDEA
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 Remote debug a Spring Boot application started with Gradle
85.10 Build an executable archive from Ant without using spring-boot-antlib
85.11 How to use Java 6
Embedded servlet container compatibility
Jackson
JTA API compatibility
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
Part X. Appendices
Appendix A. Common application properties
Appendix B. Configuration meta-data
B.1 Meta-data format
Group Attributes
Property Attributes
Hint Attributes
Repeated meta-data items
B.2 Providing manual hints
Value hint
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
Nested properties
Adding additional meta-data
Appendix C. Auto-configuration classes
C.1 From the “spring-boot-autoconfigure” module
C.2 From the “spring-boot-actuator” module
Appendix D. Test auto-configuration annotations
Appendix E. The executable jar format
E.1 Nested JARs
The executable jar file structure
The executable war file structure
E.2 Spring Boot’s “JarFile” class
Compatibility with the standard Java “JarFile”
E.3 Launching executable jars
Launcher manifest
Exploded archives
E.4 PropertiesLauncher Features
E.5 Executable jar restrictions
Zip entry compression
System ClassLoader
E.6 Alternative single jar solutions
Appendix F. Dependency versions