It is strongly recommended that you choose a build system that supports dependency management, and one that can consume artifacts published to the “Maven Central” repository. We would recommend that you choose Maven or Gradle. It is possible to get Spring Boot to work with other build systems (Ant for example), but they will not be particularly well supported.
Each release of Spring Boot provides a curated list of dependencies it supports. In practice, you do not need to provide a version for any of these dependencies in your build configuration as Spring Boot is managing that for you. When you upgrade Spring Boot itself, these dependencies will be upgraded as well in a consistent way.
![]() | Note |
---|---|
You can still specify a version and override Spring Boot’s recommendations if you feel that’s necessary. |
The curated list contains all the spring modules that you can use with Spring Boot as
well as a refined list of third party libraries. The list is available as a standard
Bills of Materials (spring-boot-dependencies
)
and additional dedicated support for Maven and
Gradle are available as well.
![]() | Warning |
---|---|
Each release of Spring Boot is associated with a base version of the Spring Framework so we highly recommend you to not specify its version on your own. |
Maven users can inherit from the spring-boot-starter-parent
project to obtain sensible
defaults. The parent project provides the following features:
<version>
tags for common dependencies, inherited from the
spring-boot-dependencies
POM.application.properties
and application.yml
including
profile-specific files (e.g. application-foo.properties
and application-foo.yml
)On the last point: since the default config files accept
Spring style placeholders (${…}
) the Maven filtering is changed to
use @..@
placeholders (you can override that with a Maven property
resource.delimiter
).
To configure your project to inherit from the spring-boot-starter-parent
simply set
the parent
:
<!-- Inherit defaults from Spring Boot --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.4.2.RELEASE</version> </parent>
![]() | Note |
---|---|
You should only need to specify the Spring Boot version number on this dependency. If you import additional starters, you can safely omit the version number. |
With that setup, you can also override individual dependencies by overriding a property
in your own project. For instance, to upgrade to another Spring Data release train you’d
add the following to your pom.xml
.
<properties> <spring-data-releasetrain.version>Fowler-SR2</spring-data-releasetrain.version> </properties>
![]() | Tip |
---|---|
Check the |
Not everyone likes inheriting from the spring-boot-starter-parent
POM. You may have your
own corporate standard parent that you need to use, or you may just prefer to explicitly
declare all your Maven configuration.
If you don’t want to use the spring-boot-starter-parent
, you can still keep the benefit
of the dependency management (but not the plugin management) by using a scope=import
dependency:
<dependencyManagement> <dependencies> <dependency> <!-- Import dependency management from Spring Boot --> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-dependencies</artifactId> <version>1.4.2.RELEASE</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>
That setup does not allow you to override individual dependencies using a property as
explained above. To achieve the same result, you’d need to add an entry in the
dependencyManagement
of your project before the spring-boot-dependencies
entry. For instance, to upgrade to another Spring Data release train you’d add the
following to your pom.xml
.
<dependencyManagement> <dependencies> <!-- Override Spring Data release train provided by Spring Boot --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-releasetrain</artifactId> <version>Fowler-SR2</version> <scope>import</scope> <type>pom</type> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-dependencies</artifactId> <version>1.4.2.RELEASE</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>
![]() | Note |
---|---|
In the example above, we specify a BOM but any dependency type can be overridden that way. |
The spring-boot-starter-parent
chooses fairly conservative Java compatibility. If you
want to follow our recommendation and use a later Java version you can add a
java.version
property:
<properties> <java.version>1.8</java.version> </properties>
Spring Boot includes a Maven plugin
that can package the project as an executable jar. Add the plugin to your <plugins>
section if you want to use it:
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
![]() | Note |
---|---|
If you use the Spring Boot starter parent pom, you only need to add the plugin, there is no need for to configure it unless you want to change the settings defined in the parent. |
Gradle users can directly import ‘starters’ in their dependencies
section. Unlike
Maven, there is no “super parent” to import to share some configuration.
apply plugin: 'java' repositories { jcenter() } dependencies { compile("org.springframework.boot:spring-boot-starter-web:1.4.2.RELEASE") }
The spring-boot-gradle-plugin
is also available and provides tasks to create executable
jars and run projects from source. It also provides
dependency management that, among
other capabilities, allows you to omit the version number for any dependencies that are
managed by Spring Boot:
buildscript { repositories { jcenter() } dependencies { classpath("org.springframework.boot:spring-boot-gradle-plugin:1.4.2.RELEASE") } } apply plugin: 'java' apply plugin: 'org.springframework.boot' repositories { jcenter() } dependencies { compile("org.springframework.boot:spring-boot-starter-web") testCompile("org.springframework.boot:spring-boot-starter-test") }
It is possible to build a Spring Boot project using Apache Ant+Ivy. The
spring-boot-antlib
“AntLib” module is also available to help Ant create executable
jars.
To declare dependencies a typical ivy.xml
file will look something like this:
<ivy-module version="2.0"> <info organisation="org.springframework.boot" module="spring-boot-sample-ant" /> <configurations> <conf name="compile" description="everything needed to compile this module" /> <conf name="runtime" extends="compile" description="everything needed to run this module" /> </configurations> <dependencies> <dependency org="org.springframework.boot" name="spring-boot-starter" rev="${spring-boot.version}" conf="compile" /> </dependencies> </ivy-module>
A typical build.xml
will look like this:
<project xmlns:ivy="antlib:org.apache.ivy.ant" xmlns:spring-boot="antlib:org.springframework.boot.ant" name="myapp" default="build"> <property name="spring-boot.version" value="1.3.0.BUILD-SNAPSHOT" /> <target name="resolve" description="--> retrieve dependencies with ivy"> <ivy:retrieve pattern="lib/[conf]/[artifact]-[type]-[revision].[ext]" /> </target> <target name="classpaths" depends="resolve"> <path id="compile.classpath"> <fileset dir="lib/compile" includes="*.jar" /> </path> </target> <target name="init" depends="classpaths"> <mkdir dir="build/classes" /> </target> <target name="compile" depends="init" description="compile"> <javac srcdir="src/main/java" destdir="build/classes" classpathref="compile.classpath" /> </target> <target name="build" depends="compile"> <spring-boot:exejar destfile="build/myapp.jar" classes="build/classes"> <spring-boot:lib> <fileset dir="lib/runtime" /> </spring-boot:lib> </spring-boot:exejar> </target> </project>
![]() | Tip |
---|---|
See the Section 80.10, “Build an executable archive from Ant without using spring-boot-antlib” “How-to” if
you don’t want to use the |
Starters are a set of convenient dependency descriptors that you can include in your
application. You get a one-stop-shop for all the Spring and related technology that you
need, without having to hunt through sample code and copy paste loads of dependency
descriptors. For example, if you want to get started using Spring and JPA for database
access, just include the spring-boot-starter-data-jpa
dependency in your project, and
you are good to go.
The starters contain a lot of the dependencies that you need to get a project up and running quickly and with a consistent, supported set of managed transitive dependencies.
The following application starters are provided by Spring Boot under the
org.springframework.boot
group:
Table 13.1. Spring Boot application starters
Name | Description | Pom |
---|---|---|
Starter for building MVC web applications using Thymeleaf views | ||
Starter for using Spring Web Services. Deprecated as of 1.4 in favor of | ||
Starter for using Couchbase document-oriented database and Spring Data Couchbase | ||
Starter for JMS messaging using Apache Artemis | ||
Starter for using Spring Web Services | ||
Starter for using Java Mail and Spring Framework’s email sending support | ||
Starter for using Redis key-value data store with Spring Data Redis and the Jedis client | ||
Starter for building web, including RESTful, applications using Spring MVC. Uses Tomcat as the default embedded container | ||
Starter for using GemFire distributed data store and Spring Data GemFire | ||
Starter for JMS messaging using Apache ActiveMQ | ||
Starter for using Elasticsearch search and analytics engine and Spring Data Elasticsearch | ||
Starter for using Spring Integration | ||
Starter for testing Spring Boot applications with libraries including JUnit, Hamcrest and Mockito | ||
Starter for JMS messaging using HornetQ. Deprecated as of 1.4 in favor of | ||
Starter for using JDBC with the Tomcat JDBC connection pool | ||
Starter for building web applications using Spring Mobile | ||
Starter for using Java Bean Validation with Hibernate Validator | ||
Starter for building hypermedia-based RESTful web application with Spring MVC and Spring HATEOAS | ||
Starter for building RESTful web applications using JAX-RS and Jersey. An alternative to | ||
Starter for using Neo4j graph database and Spring Data Neo4j | ||
Starter for building WebSocket applications using Spring Framework’s WebSocket support | ||
Starter for aspect-oriented programming with Spring AOP and AspectJ | ||
Starter for using Spring AMQP and Rabbit MQ | ||
Starter for using Cassandra distributed database and Spring Data Cassandra | ||
Starter for using Spring Social Facebook | ||
Starter for JTA transactions using Atomikos | ||
Starter for using Spring Security | ||
Starter for building MVC web applications using Mustache views | ||
Starter for using Spring Data JPA with Hibernate | ||
Core starter, including auto-configuration support, logging and YAML | ||
Starter for building MVC web applications using Velocity views. Deprecated since 1.4 | ||
Starter for building MVC web applications using Groovy Templates views | ||
Starter for building MVC web applications using FreeMarker views | ||
Starter for using Spring Batch | ||
Starter for using Redis key-value data store with Spring Data Redis and the Jedis client. Deprecated as of 1.4 in favor of | ||
Stater for using Spring Social LinkedIn | ||
Starter for using Spring Framework’s caching support | ||
Starter for using the Apache Solr search platform with Spring Data Solr | ||
Starter for using MongoDB document-oriented database and Spring Data MongoDB | ||
Starter for using jOOQ to access SQL databases. An alternative to | ||
Spring Boot Narayana JTA Starter | ||
Starter for using Spring Cloud Connectors which simplifies connecting to services in cloud platforms like Cloud Foundry and Heroku | ||
Starter for JTA transactions using Bitronix | ||
Starter for using Spring Social Twitter | ||
Starter for exposing Spring Data repositories over REST using Spring Data REST |
In addition to the application starters, the following starters can be used to add production ready features:
Table 13.2. Spring Boot production starters
Name | Description | Pom |
---|---|---|
Starter for using Spring Boot’s Actuator which provides production ready features to help you monitor and manage your application | ||
Starter for using the CRaSH remote shell to monitor and manage your application over SSH |
Finally, Spring Boot also includes some starters that can be used if you want to exclude or swap specific technical facets:
Table 13.3. Spring Boot technical starters
Name | Description | Pom |
---|---|---|
Starter for using Undertow as the embedded servlet container. An alternative to | ||
Starter for using Jetty as the embedded servlet container. An alternative to | ||
Starter for logging using Logback. Default logging starter | ||
Starter for using Tomcat as the embedded servlet container. Default servlet container starter used by | ||
Starter for using Log4j2 for logging. An alternative to |
![]() | Tip |
---|---|
For a list of additional community contributed starters, see the
README file in the
|