Spring Boot Reference Guide
   Next

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

1.2.0.RC2

Copyright © 2013-2014

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. Installing Spring Boot
9.1. Installation instructions for the Java developer
9.1.1. Maven installation
9.1.2. Gradle installation
9.2. Installing the Spring Boot CLI
9.2.1. Manual installation
9.2.2. Installation with GVM
9.2.3. OSX Homebrew installation
9.2.4. Command-line completion
9.2.5. Quick start Spring CLI example
9.3. Upgrading from an earlier version of Spring Boot
10. Developing your first Spring Boot application
10.1. Creating the POM
10.2. Adding classpath dependencies
10.3. Writing the code
10.3.1. The @RestController and @RequestMapping annotations
10.3.2. The @EnableAutoConfiguration annotation
10.3.3. The “main” method
10.4. Running the example
10.5. Creating an executable jar
11. What to read next
III. Using Spring Boot
12. Build systems
12.1. Maven
12.1.1. Inheriting the starter parent
12.1.2. Using Spring Boot without the parent POM
12.1.3. Changing the Java version
12.1.4. Using the Spring Boot Maven plugin
12.2. Gradle
12.3. Ant
12.4. Starter POMs
13. Structuring your code
13.1. Using the “default” package
13.2. Locating the main application class
14. Configuration classes
14.1. Importing additional configuration classes
14.2. Importing XML configuration
15. Auto-configuration
15.1. Gradually replacing auto-configuration
15.2. Disabling specific auto-configuration
16. Spring Beans and dependency injection
17. Using the @SpringBootApplication annotation
18. Running your application
18.1. Running from an IDE
18.2. Running as a packaged application
18.3. Using the Maven plugin
18.4. Using the Gradle plugin
18.5. Hot swapping
19. Packaging your application for production
20. What to read next
IV. Spring Boot features
21. SpringApplication
21.1. Customizing the Banner
21.2. Customizing SpringApplication
21.3. Fluent builder API
21.4. Application events and listeners
21.5. Web environment
21.6. Using the CommandLineRunner
21.7. Application exit
22. Externalized Configuration
22.1. Accessing command line properties
22.2. Application property files
22.3. Profile specific properties
22.4. Placeholders in properties
22.5. Using YAML instead of Properties
22.5.1. Loading YAML
22.5.2. Exposing YAML as properties in the Spring Environment
22.5.3. Multi-profile YAML documents
22.5.4. YAML shortcomings
22.6. Typesafe Configuration Properties
22.6.1. Relaxed binding
22.6.2. @ConfigurationProperties Validation
23. Profiles
23.1. Adding active profiles
23.2. Programmatically setting profiles
23.3. Profile specific configuration files
24. Logging
24.1. Log format
24.2. Console output
24.3. File output
24.4. Log Levels
24.5. Custom log configuration
25. Developing web applications
25.1. The ‘Spring Web MVC framework’
25.1.1. Spring MVC auto-configuration
25.1.2. HttpMessageConverters
25.1.3. MessageCodesResolver
25.1.4. Static Content
25.1.5. Template engines
25.1.6. Error Handling
Error Handling on WebSphere Application Server
25.2. JAX-RS and Jersey
25.3. Embedded servlet container support
25.3.1. Servlets and Filters
25.3.2. The EmbeddedWebApplicationContext
25.3.3. Customizing embedded servlet containers
Programmatic customization
Customizing ConfigurableEmbeddedServletContainer directly
25.3.4. JSP limitations
26. Security
27. Working with SQL databases
27.1. Configure a DataSource
27.1.1. Embedded Database Support
27.1.2. Connection to a production database
27.1.3. Connection to a JNDI DataSource
27.2. Using JdbcTemplate
27.3. JPA and ‘Spring Data’
27.3.1. Entity Classes
27.3.2. Spring Data JPA Repositories
27.3.3. Creating and dropping JPA databases
28. Working with NoSQL technologies
28.1. Redis
28.1.1. Connecting to Redis
28.2. MongoDB
28.2.1. Connecting to a MongoDB database
28.2.2. MongoTemplate
28.2.3. Spring Data MongoDB repositories
28.3. Gemfire
28.4. Solr
28.4.1. Connecting to Solr
28.4.2. Spring Data Solr repositories
28.5. Elasticsearch
28.5.1. Connecting to Elasticsearch
28.5.2. Spring Data Elasticsearch repositories
29. Messaging
29.1. JMS
29.1.1. HornetQ support
29.1.2. ActiveMQ support
29.1.3. Using a JNDI ConnectionFactory
29.1.4. Sending a message
29.1.5. Receiving a message
30. Sending email
31. Distributed Transactions with JTA
31.1. Using an Atomikos transaction manager
31.2. Using a Bitronix transaction manager
31.3. Using a Java EE managed transaction manager
31.4. Mixing XA and non-XA JMS connections
31.5. Supporting an alternative embedded transaction manager
32. Spring Integration
33. Monitoring and management over JMX
34. Testing
34.1. Test scope dependencies
34.2. Testing Spring applications
34.3. Testing Spring Boot applications
34.3.1. Using Spock to test Spring Boot applications
34.4. Test utilities
34.4.1. ConfigFileApplicationContextInitializer
34.4.2. EnvironmentTestUtils
34.4.3. OutputCapture
34.4.4. TestRestTemplate
35. Developing auto-configuration and using conditions
35.1. Understanding auto-configured beans
35.2. Locating auto-configuration candidates
35.3. Condition annotations
35.3.1. Class conditions
35.3.2. Bean conditions
35.3.3. Resource conditions
35.3.4. Web Application Conditions
35.3.5. SpEL expression conditions
36. WebSockets
37. What to read next
V. Spring Boot Actuator: Production-ready features
38. Enabling production-ready features.
39. Endpoints
39.1. Customizing endpoints
39.2. Custom health information
39.3. Custom application info information
39.3.1. Automatically expand info properties at build time
Automatic property expansion using Maven
Automatic property expansion using Gradle
39.3.2. Git commit information
40. Monitoring and management over HTTP
40.1. Exposing sensitive endpoints
40.2. Customizing the management server context path
40.3. Customizing the management server port
40.4. Customizing the management server address
40.5. Disabling HTTP endpoints
41. Monitoring and management over JMX
41.1. Customizing MBean names
41.2. Disabling JMX endpoints
41.3. Using Jolokia for JMX over HTTP
41.3.1. Customizing Jolokia
41.3.2. Disabling Jolokia
42. Monitoring and management using a remote shell
42.1. Connecting to the remote shell
42.1.1. Remote shell credentials
42.2. Extending the remote shell
42.2.1. Remote shell commands
42.2.2. Remote shell plugins
43. Metrics
43.1. DataSource metrics
43.2. Recording your own metrics
43.3. Adding your own public metrics
43.4. Metric repositories
43.5. Coda Hale Metrics
43.6. Message channel integration
44. Auditing
45. Tracing
45.1. Custom tracing
46. Process monitoring
46.1. Extend configuration
46.2. Programmatically
47. What to read next
VI. Deploying to the cloud
48. Cloud Foundry
48.1. Binding to services
49. Heroku
50. CloudBees
51. Openshift
52. Google App Engine
53. What to read next
VII. Spring Boot CLI
54. Installing the CLI
55. Using the CLI
55.1. Running applications using the CLI
55.2. Adding dependencies to the CLI
55.2.1. Deduced “grab” dependencies
55.2.2. Deduced “grab” coordinates
Custom “grab” metadata
55.2.3. Default import statements
55.2.4. Automatic main method
55.3. Testing your code
55.4. Applications with multiple source files
55.5. Packaging your application
55.6. Initialize a new project
55.7. Using the embedded shell
56. Developing application with the Groovy beans DSL
57. What to read next
VIII. Build tool plugins
58. Spring Boot Maven plugin
58.1. Including the plugin
58.2. Packaging executable jar and war files
59. Spring Boot Gradle plugin
59.1. Including the plugin
59.2. Declaring dependencies without versions
59.2.1. Custom version management
59.3. Default exclude rules
59.4. Packaging executable jar and war files
59.5. Running a project in-place
59.6. Spring Boot plugin configuration
59.7. Repackage configuration
59.8. Repackage with custom Gradle configuration
59.8.1. Configuration options
59.9. Understanding how the Gradle plugin works
59.10. Publishing artifacts to a Maven repository using Gradle
59.10.1. Configuring Gradle to produce a pom that inherits dependency management
59.10.2. Configuring Gradle to produce a pom that imports dependency management
60. Supporting other build systems
60.1. Repackaging archives
60.2. Nested libraries
60.3. Finding a main class
60.4. Example repackage implementation
61. What to read next
IX. ‘How-to’ guides
62. Spring Boot application
62.1. Troubleshoot auto-configuration
62.2. Customize the Environment or ApplicationContext before it starts
62.3. Build an ApplicationContext hierarchy (adding a parent or root context)
62.4. Create a non-web application
63. Properties & configuration
63.1. Externalize the configuration of SpringApplication
63.2. Change the location of external properties of an application
63.3. Use ‘short’ command line arguments
63.4. Use YAML for external properties
63.5. Set the active Spring profiles
63.6. Change configuration depending on the environment
63.7. Discover built-in options for external properties
64. Embedded servlet containers
64.1. Add a Servlet, Filter or ServletContextListener to an application
64.2. Change the HTTP port
64.3. Use a random unassigned HTTP port
64.4. Discover the HTTP port at runtime
64.5. Configure SSL
64.6. Configure Tomcat
64.7. Enable Multiple Connectors with Tomcat
64.8. Use Tomcat behind a front-end proxy server
64.9. Use Jetty instead of Tomcat
64.10. Configure Jetty
64.11. Use Undertow instead of Tomcat
64.12. Configure Undertow
64.13. Use Tomcat 7
64.14. Use Jetty 8
64.15. Create WebSocket endpoints using @ServerEndpoint
65. Spring MVC
65.1. Write a JSON REST service
65.2. Write an XML REST service
65.3. Customize the Jackson ObjectMapper
65.4. Customize the @ResponseBody rendering
65.5. Handling Multipart File Uploads
65.6. Switch off the Spring MVC DispatcherServlet
65.7. Switch off the Default MVC configuration
65.8. Customize ViewResolvers
66. Logging
66.1. Configure Logback for logging
66.2. Configure Log4j for logging
67. Data Access
67.1. Configure a DataSource
67.2. Configure Two DataSources
67.3. Use Spring Data repositories
67.4. Separate @Entity definitions from Spring configuration
67.5. Configure JPA properties
67.6. Use a custom EntityManagerFactory
67.7. Use Two EntityManagers
67.8. Use a traditional persistence.xml
67.9. Use Spring Data JPA and Mongo repositories
68. Database initialization
68.1. Initialize a database using JPA
68.2. Initialize a database using Hibernate
68.3. Initialize a database using Spring JDBC
68.4. Initialize a Spring Batch database
68.5. Use a higher level database migration tool
68.5.1. Execute Flyway database migrations on startup
68.5.2. Execute Liquibase database migrations on startup
69. Batch applications
69.1. Execute Spring Batch jobs on startup
70. Actuator
70.1. Change the HTTP port or address of the actuator endpoints
70.2. Customize the ‘whitelabel’ error page
71. Security
71.1. Switch off the Spring Boot security configuration
71.2. Change the AuthenticationManager and add user accounts
71.3. Enable HTTPS when running behind a proxy server
72. Hot swapping
72.1. Reload static content
72.2. Reload Thymeleaf templates without restarting the container
72.3. Reload FreeMarker templates without restarting the container
72.4. Reload Groovy templates without restarting the container
72.5. Reload Velocity templates without restarting the container
72.6. Reload Java classes without restarting the container
72.6.1. Configuring Spring Loaded for use with Maven
72.6.2. Configuring Spring Loaded for use with Gradle and IntelliJ
73. Build
73.1. Customize dependency versions with Maven
73.2. Create an executable JAR with Maven
73.3. Create an additional executable JAR
73.4. Extract specific libraries when an executable jar runs
73.5. Create a non-executable JAR with exclusions
73.6. Remote debug a Spring Boot application started with Maven
73.7. Remote debug a Spring Boot application started with Gradle
73.8. Build an executable archive with Ant
74. Traditional deployment
74.1. Create a deployable war file
74.2. Create a deployable war file for older servlet containers
74.3. Convert an existing application to Spring Boot
74.4. Deploying a WAR in an Old (Servlet 2.5) Container
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. Repeated meta-data items
B.2. Generating your own meta-data using the annotation processor
B.2.1. Nested properties
B.2.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. The executable jar format
D.1. Nested JARs
D.1.1. The executable jar file structure
D.1.2. The executable war file structure
D.2. Spring Boot’s “JarFile” class
D.2.1. Compatibility with the standard Java “JarFile”
D.3. Launching executable jars
D.3.1. Launcher manifest
D.3.2. Exploded archives
D.4. PropertiesLauncher Features
D.5. Executable jar restrictions
D.5.1. Zip entry compression
D.5.2. System ClassLoader
D.6. Alternative single jar solutions
E. Dependency versions
   Next
   Part I. Spring Boot Documentation