13. Build systems

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.

13.1 Dependency management

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.

13.2 Maven

Maven users can inherit from the spring-boot-starter-parent project to obtain sensible defaults. The parent project provides the following features:

  • Java 1.6 as the default compiler level.

  • UTF-8 source encoding.

  • A Dependency Management section, allowing you to omit <version> tags for common dependencies, inherited from the spring-boot-dependencies POM.

  • Sensible resource filtering.

  • Sensible plugin configuration (exec plugin, surefire, Git commit ID, shade).

  • Sensible resource filtering for 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 @[email protected] placeholders (you can override that with a Maven property resource.delimiter ).

13.2.1 Inheriting the starter parent

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.5.9.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 spring-boot-dependencies pom for a list of supported properties.

13.2.2 Using Spring Boot without the parent POM

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.5.9.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.5.9.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.

13.2.3 Changing the Java version

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>

13.2.4 Using the Spring Boot Maven plugin

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.

13.3 Gradle

Gradle users can directly import ‘starters’ in their dependencies section. Unlike Maven, there is no “super parent” to import to share some configuration.

repositories {
    jcenter()
}

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web:1.5.9.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:

plugins {
    id 'org.springframework.boot' version '1.5.9.RELEASE'
    id 'java'
}

repositories {
    jcenter()
}

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web")
    testCompile("org.springframework.boot:spring-boot-starter-test")
}

13.4 Ant

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.5.9.RELEASE" />

    <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 84.10, “Build an executable archive from Ant without using spring-boot-antlib” “How-to” if you don’t want to use the spring-boot-antlib module.

13.5 Starters

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.

What’s in a name

All official starters follow a similar naming pattern; spring-boot-starter-* , where * is a particular type of application. This naming structure is intended to help when you need to find a starter. The Maven integration in many IDEs allow you to search dependencies by name. For example, with the appropriate Eclipse or STS plugin installed, you can simply hit ctrl-space in the POM editor and type “spring-boot-starter” for a complete list.

As explained in the Creating your own starter section, third party starters should not start with spring-boot as it is reserved for official Spring Boot artifacts. A third-party starter for acme will be typically named acme-spring-boot-starter .

The following application starters are provided by Spring Boot under the org.springframework.boot group:

Table 13.1. Spring Boot application starters

NameDescriptionPom
spring-boot-starterCore starter, including auto-configuration support, logging and YAMLPom
spring-boot-starter-activemqStarter for JMS messaging using Apache ActiveMQPom
spring-boot-starter-amqpStarter for using Spring AMQP and Rabbit MQPom
spring-boot-starter-aopStarter for aspect-oriented programming with Spring AOP and AspectJPom
spring-boot-starter-artemisStarter for JMS messaging using Apache ArtemisPom
spring-boot-starter-batchStarter for using Spring BatchPom
spring-boot-starter-cacheStarter for using Spring Framework’s caching supportPom
spring-boot-starter-cloud-connectorsStarter for using Spring Cloud Connectors which simplifies connecting to services in cloud platforms like Cloud Foundry and HerokuPom
spring-boot-starter-data-cassandraStarter for using Cassandra distributed database and Spring Data CassandraPom
spring-boot-starter-data-couchbaseStarter for using Couchbase document-oriented database and Spring Data CouchbasePom
spring-boot-starter-data-elasticsearchStarter for using Elasticsearch search and analytics engine and Spring Data ElasticsearchPom
spring-boot-starter-data-gemfireStarter for using GemFire distributed data store and Spring Data GemFirePom
spring-boot-starter-data-jpaStarter for using Spring Data JPA with HibernatePom
spring-boot-starter-data-ldapStarter for using Spring Data LDAPPom
spring-boot-starter-data-mongodbStarter for using MongoDB document-oriented database and Spring Data MongoDBPom
spring-boot-starter-data-neo4jStarter for using Neo4j graph database and Spring Data Neo4jPom
spring-boot-starter-data-redisStarter for using Redis key-value data store with Spring Data Redis and the Jedis clientPom
spring-boot-starter-data-restStarter for exposing Spring Data repositories over REST using Spring Data RESTPom
spring-boot-starter-data-solrStarter for using the Apache Solr search platform with Spring Data SolrPom
spring-boot-starter-freemarkerStarter for building MVC web applications using FreeMarker viewsPom
spring-boot-starter-groovy-templatesStarter for building MVC web applications using Groovy Templates viewsPom
spring-boot-starter-hateoasStarter for building hypermedia-based RESTful web application with Spring MVC and Spring HATEOASPom
spring-boot-starter-integrationStarter for using Spring IntegrationPom
spring-boot-starter-jdbcStarter for using JDBC with the Tomcat JDBC connection poolPom
spring-boot-starter-jerseyStarter for building RESTful web applications using JAX-RS and Jersey. An alternative to spring-boot-starter-webPom
spring-boot-starter-jooqStarter for using jOOQ to access SQL databases. An alternative to spring-boot-starter-data-jpa or spring-boot-starter-jdbcPom
spring-boot-starter-jta-atomikosStarter for JTA transactions using AtomikosPom
spring-boot-starter-jta-bitronixStarter for JTA transactions using BitronixPom
spring-boot-starter-jta-narayanaSpring Boot Narayana JTA StarterPom
spring-boot-starter-mailStarter for using Java Mail and Spring Framework’s email sending supportPom
spring-boot-starter-mobileStarter for building web applications using Spring MobilePom
spring-boot-starter-mustacheStarter for building MVC web applications using Mustache viewsPom
spring-boot-starter-securityStarter for using Spring SecurityPom
spring-boot-starter-social-facebookStarter for using Spring Social FacebookPom
spring-boot-starter-social-linkedinStater for using Spring Social LinkedInPom
spring-boot-starter-social-twitterStarter for using Spring Social TwitterPom
spring-boot-starter-testStarter for testing Spring Boot applications with libraries including JUnit, Hamcrest and MockitoPom
spring-boot-starter-thymeleafStarter for building MVC web applications using Thymeleaf viewsPom
spring-boot-starter-validationStarter for using Java Bean Validation with Hibernate ValidatorPom
spring-boot-starter-webStarter for building web, including RESTful, applications using Spring MVC. Uses Tomcat as the default embedded containerPom
spring-boot-starter-web-servicesStarter for using Spring Web ServicesPom
spring-boot-starter-websocketStarter for building WebSocket applications using Spring Framework’s WebSocket supportPom

In addition to the application starters, the following starters can be used to add production ready features:

Table 13.2. Spring Boot production starters

NameDescriptionPom
spring-boot-starter-actuatorStarter for using Spring Boot’s Actuator which provides production ready features to help you monitor and manage your applicationPom
spring-boot-starter-remote-shellStarter for using the CRaSH remote shell to monitor and manage your application over SSH. Deprecated since 1.5Pom

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

NameDescriptionPom
spring-boot-starter-jettyStarter for using Jetty as the embedded servlet container. An alternative to spring-boot-starter-tomcatPom
spring-boot-starter-log4j2Starter for using Log4j2 for logging. An alternative to spring-boot-starter-loggingPom
spring-boot-starter-loggingStarter for logging using Logback. Default logging starterPom
spring-boot-starter-tomcatStarter for using Tomcat as the embedded servlet container. Default servlet container starter used by spring-boot-starter-webPom
spring-boot-starter-undertowStarter for using Undertow as the embedded servlet container. An alternative to spring-boot-starter-tomcatPom

Tip

For a list of additional community contributed starters, see the README file in the spring-boot-starters module on GitHub.