13. Build systems

13. Build systems
Prev	Part III. Using Spring Boot	Next

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

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

13.1.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.2.3.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.

13.1.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.2.3.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

13.1.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.1.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.2 Gradle

Gradle users can directly import “starter POMs” 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.2.3.RELEASE")
}

The spring-boot-gradle-plugin is also available and provides tasks to create executable jars and run projects from source. It also adds a ResolutionStrategy that enables you to omit the version number for “blessed” dependencies:

buildscript {
    repositories { jcenter() }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:1.2.3.RELEASE")
    }
}

apply plugin: 'java'
apply plugin: 'spring-boot'

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

13.3 Ant

It is possible to build a Spring Boot project using Apache Ant, however, no special support or plugins are provided. Ant scripts can use the Ivy dependency system to import starter POMs.

See the Section 73.8, “Build an executable archive with Ant” “How-to” for more complete instructions.

13.4 Starter POMs

Starter POMs 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
`spring-boot-starter`	The core Spring Boot starter, including auto-configuration support, logging and YAML.
`spring-boot-starter-actuator`	Production ready features to help you monitor and manage your application.
`spring-boot-starter-amqp`	Support for the “Advanced Message Queuing Protocol” via `spring-rabbit`.
`spring-boot-starter-aop`	Support for aspect-oriented programming including `spring-aop` and AspectJ.
`spring-boot-starter-batch`	Support for “Spring Batch” including HSQLDB database.
`spring-boot-starter-cloud-connectors`	Support for “Spring Cloud Connectors” which simplifies connecting to services in cloud platforms like Cloud Foundry and Heroku.
`spring-boot-starter-data-elasticsearch`	Support for the Elasticsearch search and analytics engine including `spring-data-elasticsearch`.
`spring-boot-starter-data-gemfire`	Support for the GemFire distributed data store including `spring-data-gemfire`.
`spring-boot-starter-data-jpa`	Support for the “Java Persistence API” including `spring-data-jpa`, `spring-orm` and Hibernate.
`spring-boot-starter-data-mongodb`	Support for the MongoDB NoSQL Database, including `spring-data-mongodb`.
`spring-boot-starter-data-rest`	Support for exposing Spring Data repositories over REST via `spring-data-rest-webmvc`.
`spring-boot-starter-data-solr`	Support for the Apache Solr search platform, including `spring-data-solr`.
`spring-boot-starter-freemarker`	Support for the FreeMarker templating engine.
`spring-boot-starter-groovy-templates`	Support for the Groovy templating engine.
`spring-boot-starter-hateoas`	Support for HATEOAS-based RESTful services via `spring-hateoas`.
`spring-boot-starter-hornetq`	Support for “Java Message Service API” via HornetQ.
`spring-boot-starter-integration`	Support for common `spring-integration` modules.
`spring-boot-starter-jdbc`	Support for JDBC databases.
`spring-boot-starter-jersey`	Support for the Jersey RESTful Web Services framework.
`spring-boot-starter-jta-atomikos`	Support for JTA distributed transactions via Atomikos.
`spring-boot-starter-jta-bitronix`	Support for JTA distributed transactions via Bitronix.
`spring-boot-starter-mail`	Support for `javax.mail`.
`spring-boot-starter-mobile`	Support for `spring-mobile`.
`spring-boot-starter-mustache`	Support for the Mustache templating engine.
`spring-boot-starter-redis`	Support for the REDIS key-value data store, including `spring-redis`.
`spring-boot-starter-security`	Support for `spring-security`.
`spring-boot-starter-social-facebook`	Support for `spring-social-facebook`.
`spring-boot-starter-social-linkedin`	Support for `spring-social-linkedin`.
`spring-boot-starter-social-twitter`	Support for `spring-social-twitter`.
`spring-boot-starter-test`	Support for common test dependencies, including JUnit, Hamcrest and Mockito along with the `spring-test` module.
`spring-boot-starter-thymeleaf`	Support for the Thymeleaf templating engine, including integration with Spring.
`spring-boot-starter-velocity`	Support for the Velocity templating engine.
`spring-boot-starter-web`	Support for full-stack web development, including Tomcat and `spring-webmvc`.
`spring-boot-starter-websocket`	Support for WebSocket development.
`spring-boot-starter-ws`	Support for Spring Web Services.

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

Table 13.2. Spring Boot production ready starters

Name	Description
`spring-boot-starter-actuator`	Adds production ready features such as metrics and monitoring.
`spring-boot-starter-remote-shell`	Adds remote `ssh` shell support.

Finally, Spring Boot 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
`spring-boot-starter-jetty`	Imports the Jetty HTTP engine (to be used as an alternative to Tomcat).
`spring-boot-starter-log4j`	Support the Log4J logging framework.
`spring-boot-starter-logging`	Import Spring Boot’s default logging framework (Logback).
`spring-boot-starter-tomcat`	Import Spring Boot’s default HTTP engine (Tomcat).
`spring-boot-starter-undertow`	Imports the Undertow HTTP engine (to be used as an alternative to Tomcat).

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