ActiveNET

By Suryanarayana

98 48 111 2 88

Spring Boot
1) Introduction to Spring Boot
Spring Release History
Spring Projects
Spring Projects in Incubation
Spring Projects in the Attic
Spring Boot
2) Your First Spring Boot Application
Installing Spring Boot CLI
Spring Boot with Maven
Spring Boot using External Tools
Your First Spring Boot Application
3) Spring Boot Auto-Configuration, Features and More
Auto Configuration
@EnableAutoConfiguration and @Enable<Technology> Annotations
Spring Boot Features
Application Configuration
4) Spring Boot CLI
Spring Boot CLI
5) Spring with Spring Boot
Spring Web MVC Applications
Using Spring with Spring Boot
Using Spring Technologies in Spring Boot
6) Testing with Spring Boot
Testing Spring Boot

1
 Web Testing
7) Data Access with Spring Boot
SQL Databases
NoSQL Databases
8) Web Development with Spring Boot
Spring MVC
Spring Boot Web Applications
Playing with the HAL Browser
9) Security with Spring Boot
Simple Security for Spring Boot
Spring Boot with OAuth2
10) Messaging with Spring Boot
What is Messaging
JMS with Spring Boot
RabbitMQ with Spring Boot
Redis Messaging with Spring Boot
Web Sockets with Spring Boot
11) Spring Boot Actuator
Spring Boot Actuator
Sensitive Endpoints
Changing the Endpoint ID
Actuator CORS Support
Changing the Management Endpoints Path
Using Spring Boot Actuator in a Non-Web Application
12) Deploying Spring Boot
Setting up the Spring Boot Journal App
Testing SSL
Creating Executable JARs
Creating Executable and Deployable WARs
Creating Spring Boot Apps as a Service
Spring Boot with Docker
13) Spring Boot in the Cloud
The Cloud and Cloud-Native Architectures
Twelve-Factor Applications
Microservices
Cloud Foundry
Pivotal Cloud Foundry
14) Extending Spring Boot Apps
Custom Spring Boot Module
Custom Health Indicator

2
Chapter 1# Introduction to Spring Boot
I started in Struts in 2003, Hibernate in 2004 and Spring 1.2 in 2005. It is almost 13 years Spring
released. It underwent various additions in modules and various releases. The first version of Spring
is written by Rod Johnson.

Spring Releases history

Version Date
1.0 2004
2.0 2006
3.0 2009
4.0 2013
5.0 2017

Spring 1.0 released in March 2004 milestone releases in Sept 2004 and Mar 2005.

Spring 1.2.6 released in 2006.

Spring 2.0 released in Oct 2006.

Spring 2.5 in Nov 2007.

Spring 3.0 in Dec 2009.

Spring 3.1 in Dec 2011.

Spring 3.2.5 in Nov 2013.

Spring 4.0 released in Dec 2013.

Spring 4.0 supports Java SE 8 Groovy 2, Java EE 7.0 and Web Socket.

Spring 4.2.0 released in 31st July 2015 and was immediately upgraded to 4.2.1 released on 1st
Sept 2015.

Spring 4.3 released in 10th June 2016.

Spring 5 is announced to be built upon Reactive Streams compatible Reactor Core.
Spring Framework includes several modules:
 Spring Core Container Module
o Contains IoC (Inversion of Control which supports Dependency Injection over
Dependency Lookup). With this IoC feature we can achieve Light Weight Component
Development, Loose Coupling between components. Spring Core Container / IoC

3
 Container is responsible for such Dependency Injection through Constructor
Injection/Setter Injection.
 Spring AOP (Aspect Oriented Programming)
o Contains Aspects, Advices, Join points, Pointcuts, Advisors, AOP Proxy, Proxy Factory
 Spring Data
o Relational Databases
 Spring JDBC DAO Module
• Simplified JDBC API is given with Declarative Exception Handling
capability and Transaction Management support.
 Spring ORM Module
• Supports various ORM frameworks such as Hibernate, JPA, TopLink,
Eclipse Link, iBatis, JDO, Apache OJB, Apache Cayenne.
o No SQL
 MongoDB: A Document Store
 Neo4J: A Graph database
 Redis: A Key/Value Store
 CouchDB
o Big Data
 Spring for Apache Hadoop
 Analyzing Data with Hadoop
 Integrating Big Data Pipelines with Spring Batch and Spring Integration
o Data Grids
 GemFire: A Distributed Data Grid
 Spring Web MVC
o Springs own Web Application Framework given in-built in this module.
 Spring Web
o Integration with Struts 1.x, JSF, Web Work, Porlets
 Spring Context Module
o Remote Method Invocation/Remote Access Framework (RMI, Hessian-Burlup HTTP
Invoker)
o CORBA
o EJB
o Web Services (SOAP & REST) Apache Axis, Apache CXF
o JMS Messaging
o Emails
o Scheduler
 Spring Security (Authentication & Authorization)
o Standards, Protocols, Tools (Acegi Security)
 Convention over Configuration
o Spring Boot
 Spring Boot is a Convention over Configuration for solution for creating
stand-alone, production-grade spring-based applications that you can just-
run. It is pre configured with the Spring’s “opinionated view” of the best
configuration and use of the Spring platform and third party libraries so you
can “Get started with minimum effort”.

4
 Convention over Configuration (Coding by Convention) is a software
paradigm used by the software frameworks that attempt to decrease the
number of decisions that a developer using the framework is required to
make without necessarily losing flexibility. The phrase essentially means a
developer only needs to specify unconventional aspects f the application. Fr
example if there is a class Sales in the model, the corresponding table in the
database is called “sales” by default.
If framework is Opinionated, it locks or guides you into their way of doing
things. PERL, PHP .net are Un-opinionated softwares.
 Most Spring Boot applications need very little Spring Configuration. Features
include:
• Creates stand-alone Spring applications.
• Embedded Tomcat or Jetty directly (no need to deploy WAR files).
• Provide opinionated starter POM (Project Object Models) to simplify
your Maven Configuration.
• Automatically configure Spring whenever possible.
• Provide production-ready features such as metrics, health checks
and externalized configuration.
• Absolutely no code generation and no requirement for XML
configuration.
o Spring Roo
 A Rapid Application Development solution for Spring based enterprise
applications.
 Spring Roo provides an alternative, code-generation based approach at
using convention-over-configuration to rapidly build applications in Java. It
currently supports Spring Framework, Spring Security and Spring Web Flow.
 Spring Transaction Management
o Support of Programmatic, Declarative, Schema based and Annotation based TX
management for Local and Distributed TX management.
 Spring Testing
o Supports classes for writing Unit Testing and Integration Testing
 Spring Integration Framework
o Spring Integration is a framework for Enterprise Application Integration that
provides reusable functions essential to messaging or event-driven architectures.
 Routers – routes a message to a message channel based on conditions.
 Transformers – Converts/Transforms/Changes the message payload and
creates a new message with transformed payload.
 Adapters – To integrate with other technologies and systems (HTTP, AMQ
(Advanced Message Queuing), JMS, XMPP (eXtensible Messaging and
Presence Protocol), SMTP (Simple Mail Transfer Protocol), IMAP (Internet
Message Access Protocol), FTP (File Transfer Protocol) as well as FTPS/SFTP
file systems etc).
 Filters – Filters a message based on criteria. If the criteria are not met, the
message is dropped.
 Service Activators – Invoke an operation on a service object.

5
  Management and Auditing
o Spring Integration supports pipes-and-filter based Architectural Pattern. - POSA
 Spring Batch Framework
o Spring Batch is a framework for batch processing that provides reusable functions
that are essential in processing large volumes of records, including:
 Logging/Tracing
 Transaction Management
 Job Processing Statistics
 Job Restart
o Execution of series of extremely high-volume, high-performance batch Jobs through
optimizations and partitioning techniques. Each step consists of READ-PROCESS-
WRITE task or single operation task (tasklet).
o The READ-PROCESS-WRITE process consists of these steps: “read data” from a
resource (comma separated values – CSV, XML or database), “process it” and then
write it to other resources (CSV, XML, DB). Spring Batch provides many classes to
read/write CSV, XML, Data base.

Spring Projects (69):

Spring Boot Spring Framework Spring Data Spring Cloud Data
https://projects.spring.io/spring- https://projects.spring.io/sprin https://projects.spring.io/sprin Flow
boot/ g-framework/ g-data/ https://cloud.spring.io/spring-
cloud-dataflow/

Spring Session Spring HATEOAS Spring Batch Spring for Android

https://projects.spring.io/spring- https://projects.spring.io/sprin https://projects.spring.io/sprin https://projects.spring.io/sprin
session/ g-hateoas/ g-batch/ g-android/

Spring Cloud Cluster Spring Cloud Config Spring Cloud Consul Spring Cloud Data
https://cloud.spring.io/spring- https://cloud.spring.io/spring- https://cloud.spring.io/spring- Flow for Cloud
cloud-cluster cloud-config/ cloud-consul/ Foundry
https://cloud.spring.io/spring-
cloud-dataflow-server-
cloudfoundry/

Spring Cloud Data Flow Spring Cloud Function Spring Cloud GCP Spring Cloud Open
for Apache Mesos https://cloud.spring.io/spring- https://cloud.spring.io/spring- Service Broker
https://cloud.spring.io/spring- cloud-function/ cloud-gcp/ https://cloud.spring.io/spring-
cloud-dataflow-server-mesos/ cloud-open-service-broker/

Spring Cloud Skipper Spring Cloud Spring Cloud Task Spring Cloud Vault
https://cloud.spring.io/spring- Spinnaker https://cloud.spring.io/spring- https://cloud.spring.io/spring-
cloud-skipper/ https://cloud.spring.io/spring- cloud-task/ cloud-vault/
cloud-spinnaker/

Spring CredHub Spring Data Envers Spring Data JDBC Spring Data JPA
https://projects.spring.io/spring- https://projects.spring.io/sprin https://projects.spring.io/sprin https://projects.spring.io/sprin
credhub/ g-data-envers/ g-data-jdbc/ g-data-jpa/

Spring Data MongoDB Spring Data Redis Spring Data for Spring LDAP
https://projects.spring.io/spring- https://projects.spring.io/sprin Apache Solr https://projects.spring.io/sprin
data-mongodb/ g-data-redis/ https://projects.spring.io/sprin g-ldap/
g-data-solr/

6
Spring Roo Spring Security OAuth Spring Shell Spring Social Facebook
https://projects.spring.io/spring- https://projects.spring.io/sprin https://projects.spring.io/sprin https://projects.spring.io/sprin
roo/ g-security-oauth/ g-shell/ g-social-facebook/

Spring Statemachine Spring Vault Spring Web Services Spring Cloud Stream
https://projects.spring.io/spring- https://projects.spring.io/sprin https://projects.spring.io/sprin https://cloud.spring.io/spring-
statemachine/ g-vault/ g-ws/ cloud-stream/

Spring IO Platform Spring Cloud Spring Security Spring Integration

https://platform.spring.io/platfor https://projects.spring.io/sprin https://projects.spring.io/sprin https://projects.spring.io/sprin
m/ g-cloud/ g-security/ g-integration/

Spring REST Docs Spring AMQP Spring Cloud CLI Spring Cloud
https://projects.spring.io/spring- https://projects.spring.io/sprin https://cloud.spring.io/spring- Commons
restdocs/ g-amqp/ cloud-cli/ https://cloud.spring.io/spring-
cloud-commons/

Spring Cloud Connectors Spring Cloud Contract Spring Data Flow for Spring Cloud Gateway
http://cloud.spring.io/spring- https://cloud.spring.io/spring- Apache YARN https://cloud.spring.io/spring-
cloud-connectors/ cloud-contract/ https://cloud.spring.io/spring- cloud-gateway/
cloud-dataflow-server-yarn/

Spring Cloud Netflix Spring Cloud Pipelines Spring Cloud Sleuth Spring Cloud Stream
https://cloud.spring.io/spring- https://cloud.spring.io/spring- https://cloud.spring.io/spring- App Starters
cloud-netflix/ cloud-pipelines/ cloud-sleuth/ https://cloud.spring.io/spring-
cloud-stream-app-starters/

Spring Cloud Task App Spring Cloud Spring Data Commons Spring Data GemFire
Starters Zookeeper https://projects.spring.io/sprin https://projects.spring.io/sprin
http://cloud.spring.io/spring- https://cloud.spring.io/spring- g-data-commons g-data-gemfire/
cloud-task-app-starters/ cloud-zookeeper/

Spring Data JDBC Spring Data LDAP Spring Data Neo4J Spring Data REST
Extensions https://projects.spring.io/sprin https://projects.spring.io/sprin https://projects.spring.io/sprin
https://projects.spring.io/spring- g-data-ldap/ g-data-neo4j/ g-data-rest/
data-jdbc-ext/

Spring for Apache Spring Mobile Spring Security Spring Session

Hadoop https://projects.spring.io/sprin Kerberos MongoDB
https://projects.spring.io/spring- g-mobile/ https://projects.spring.io/sprin https://projects.spring.io/sprin
hadoop/ g-security-kerberos/ g-session-data-mongodb/

Spring Social Spring Social Twitter Spring Test HtmlUnit Spring Web Flow
https://projects.spring.io/spring- https://projects.spring.io/sprin https://projects.spring.io/sprin https://projects.spring.io/sprin
social/ g-social-twitter/ g-test-htmlunit/ g-webflow/

Spring Cloud Data for

Kubernetes
https://cloud.spring.io/spring-
cloud-dataflow-server-
kubernetes/

Spring Projects in Incubation (16):

Spring Cloud Bus Spring Cloud Data Spring Data for Apache Spring Data for Elastic
https://cloud.spring.io/spring https://cloud.spring.io/spring- Cassandra Search
-cloud-bus/ cloud-data https://projects.spring.io/spring https://projects.spring.io/spring

7
 -data-cassandra/ -data-elasticsearch/

Spring Integration Spring for Apache Kafka Spring Security SAML Spring Social LinkedIn
Groovy DSL https://projects.spring.io/spring http://projects.spring.io/spring- https://projects.spring.io/spring
-kafka/ security-saml/ -social-linkedin/

Spring Cloud for Spring Cloud Security Spring Data Couchbase Spring Flo
Cloud Foundry https://cloud.spring.io/spring- https://projects.spring.io/spring https://projects.spring.io/spring
https://cloud.spring.io/spring cloud-security/ -data-couchbase/ -flo/
-cloud-cloudfoundry/

Spring Integration Spring plugin Spring Social GitHub Spring Social Triplt
Scala DSL https://projects.spring.io/spring https://projects.spring.io/spring https://projects.spring.io/spring
-plugin -social-github/ -social-tripit/

Spring Projects in the Attic (6):

Spring Cloud Foundry Spring Flex Spring Test MVC Spring Data Graph
Service Broker https://projects.spring.io/spring-
https://cloud.spring.io/spring-cloud- flex
cloudfoundry-service-broker

Spring Scala Spring XD

https://hub.darcs.net/psnively/spring- https://projects.spring.io/spring-
scala xd/

Spring Boot
Is Spring Boot replacement to Spring Framework?
 No Spring Boot is new way to create Spring application with ease of development and use.
 It makes easy to create a production-ready Spring based applications that you can just-run.
 You can create standalone applications that use an embedded server, making them 100%
runnable applications.
 Spring is a Opinionated technology in that it will help you follow the best practices for
creating robust, extensible and scalable Spring applications.
You can find Spring Boot Project at http://projects.spring.io/spring-boot and its extensive
documentation is available at http://projects.spring.io/spring-
boot/doc/current/reference/htmlsingle.

Spring Applications
If you are a Java Web Application Developer you know how to create a simple web application isn’t.
The steps are:
Create a Web Application Directory Structure:
Webapp1
.html, .css .js, .jpg
WEB-INF
web.xml (configure DispatcherServlet here)

8
 disp-servlet.xml (disp is the name of the servlet-name of DispatcherServlet)
classes
Place user defined .class files
lib
Place 3rd party jar files

The way to make .war file and to deploy it into web server/application server is using:
• jar –cvf WebApp1.war *.html *.css *.js *.jpg WEB-INF
• Apache ANT
• Apache Maven
• Gradle
The Web Server/Application Servers are:
• Tomcat
• JBoss
• WebLogic
• WebSphere

But building (creating directory structure, compile classes, placing files in respective folder making
war) and deploying web application using above said options is painful to developer. Isn’t it?
Hence use tools/IDEs like STS (Spring Tool Suite), YEOMAN etc.
Though we use tools like STS we need to add dependencies in Maven pom.xml file if we want to use
additional services like Persistence, Messaging, Security, Logging, Validators etc. Then during
pom.xml file execution all the dependent jar files are included in our project. Even adding
dependencies in pom.xml file by developer is an additional effort.
Then what is the best solution that automatically creates directory structure, placing files in
respective folders, download all the service required dependent jar files, compile java classes,
make war and to deploy it into web server/ application server.

Yes. You got the Answer. The hero of our current topic Spring Boot.
Instead of reading more about Spring Boot and how it is easy to use it, take a look at simple Spring
web application.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class SimpleWebApp {
public static void main(String[] args) {
SpringApplication.run(SimpleWebApp.class, args);
}
}

Shows the entry point for a Spring Boot Application in Java. It’s using SpringBootApplication
annotation and the SpringApplication singleton class in the main method that will execute the
application. The run method accepts two arguments – the class that actually contains the annotated
@SpringBootApplication and the application’s arguments.

9
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class SimpleWebController {
@RequestMapping("/")
public String greetings(){
return "<h1> Spring Boot Rocks in Java too!</h1>";
}
}

Shows you the typical Spring Web MVC Controller class, where you use the @RestController and
@RequestMapping annotations to tell Spring to use the SimpeWebController class as a web controller
and to use the method greetings as an entry point for a HTTP request. You can run this example by
using Spring CLI.
E:\active\spring 4.4\boot applications> spring run *.java
Note: The Spring CLI installation, how to use STS to run the application will be covered in the next
Chapter.
Spring Boot Features:
 The SpringApplication singleton class acts as a Spring Boot application by calling run()
method.
 Spring Boot allows you to create a applications without requiring any XML configuration.
Spring Boot doesn’t generate code.
 Spring Boot provides a fluent builder API through the SpringApplicationBuilder singleton class
that allows you to create hierarchies with multiple application contexts.
 Spring Boot offers you more ways to configure the Spring application events and listeners.
 As discussed earlier Spring is an Opinionated technology which means the spring boot will
attempt to create the right type of application, either a web application (embedding Tomcat
or Jetty Container) or a single application.
 The ApplicationArguments interface allows you to accept any number of arguments. This is
useful when we want to run your application with some parameters. For example we can use
-- debug mylog.txt or -- audit=true and have access to those values.
 Spring Boot allows you to execute code after the application has started. The only thing you
need to do is implement the CommandLineRunner interface and provide the implementation
of the run(String... args) method.
 Spring Boot allows you to externalize configurations by using an application.properties or
application.yaml file.
 You can add administration-related features, normally through JMX. You can do this simply by
enabling the spring.application.admin.enabled property in application.properties file.
 Spring Boot allows you to have profiles that will help your application run in different
environments.
 Spring Boot allows you to configure and use logging very simply.
 Spring Boot provides a simple way to configure and manage your dependencies by using
starter poms. In other words if you are going to create a web application you only need to
include the spring-boot-start-web dependency in your Maven POM or Gradle build file.
 Spring Boot provides out-of-the-box on-functional requirements by using the Spring Boot
Actuator, so you can see the health memory and so on, of your application.

10
 Spring Boot provides @Enable<feature> annotations that help you to include, configure and
use technologies like (SQL and NoSQL), caching, scheduling, messaging, spring Integration,
batching and more.

11
Chapter 2# Your First Spring Boot Application
You can create Spring Boot Applications by using the Spring Boot Command Line Interface or by using
Maven, Gradle, Apache ANT or STS.

Installing Spring Boot CLI

Before installing Spring Boot CLI we need to check JDK is installed or not, java PATH and CLASSPATH
are updated or not, JAVA_HOME environment variable is set or not”. After that you must down
following .zip file from internet.
• https://repo.spring.io/release/org/springframework/boot/spring-boot-
cli/1.4.2.RELEASE/spring-boot-cli-1.4.2.RELEASE-bin.zip
• Extract zip file into local directory structure.
• Create SPRING_HOME environment variable up to spring-boot-cli installation directory of
extracted folder.
• Update PATH environment variable also up to bin directory of extracted folder.
• Update CLASSPATH environment variable up to extracted lib directory \ (back slash) spring-
boot-cli-1.4.2.RELEASE.jar
Run the following command in above classes placed directory:
E:\active\spring 4.4\boot applications> spring run *.java
Suppose if you want to create a base or minimal project:
E:\active\spring 4.4\boot applications> spring init - - build maven demo
This command will call the web service at https://start.spring.io and will create a folder named demo.
demo/
-.gitignore
-mvnw
-mvnw.cmd
-pomxml
-.mvn
wrapper
maven-wrapper.properties
maven-wrapper.jar
-src
|- - - - - main
| |- - - - - java
| |- - - - - com
| |- - - - - example
| |- - - - - demo
| DemoApplication.java
|- - - - - resources
| |- - - - - application.properties
|- - - - - test
| - - - - - java

12
 |- - - - - com
|- - - - - example
|- - - - - demo
|- - - - - DemoApplicationTests.java

Above diagram shows Spring Boot Project directory structure created when you execute spring init
command. If you want to add more features such as web, JPA, and Maven Projects - you can execute
following command:
spring init –dweb,data-jpa,h2,thymeleaf - - build maven demo1 - - force
The above command creates Spring Boot Maven Project and will include all the necessary
dependencies in pom.xml file. The last - -force overrides the previous demo directory or you can
change the name.

Spring Boot with Maven

If you already use Maven then we can Jump start with Spring Boot applications.
Using Maven
Below file shows the pom.xml file that you use every time you need to create a Spring Boot app.
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">

<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>demo</artifactId>
<version>0.0.1-SNAPSHOT</version>

<!-- Spring Boot Parent Dependencies-->

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.3.1.RELEASE</version>
</parent>

<!-- Add dependencies: starter poms -->

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>

<!-- Spring Boot Plugin for creating JAR/WAR files -->

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>

13
 </build>
</project>

• If you take a closer look at parent tag section you need to include spring-boot-starter-parent
artifact. This dependency includes all you need to run you application such as spring-core,
spring-test.
• Another section is starter poms in this we will include other dependencies required such as
for web application
<!-- Add dependencies: starter poms -->
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>

This dependency includes spring-core, spring-web, spring-webmvc, embedded tomcat web server and
other libraries required to build web application.

Spring Boot using External Tools

Spring Boot using the Spring Initializr:

To get the above we page just type http://start.spring.io url on the browser

14
The above interface shows where you can create your Spring Boot Application. You can include all the
dependencies using by just typing web, security, jpa. If you click Generate Project button, you will get
a zip file that contains the structure of the pom.xml file.
Notice: Click on switch to the full version hyperlink to see more options and all the Spring Boot
dependences, check required checkboxes and click on Generate Project.

Spring Boot using the “Spring Tool Suite”/STS:

STS is a eclipse based IDE bundled with Spring projects capability Neither we can include STS plugin to
Eclipse nor we can download STS from https://spring.io/tools/all.

Download the Windows ZIP file, extract it, in the installation directory you will find sts.exe file. Now
you must see File-> New-> the Spring Starter Project option.

15
You can see the Spring Starter Project wizard

App: Creating an Spring Boot JdbcTemplate Application

16
Click on Finish
The project directory structure looks as below:

17
I added following files to run JdbcTemplate Application:

First of all we need to update pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

18
 <groupId>com.example</groupId>
<artifactId>simple-jdbc-app</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>jdbc</name>
<description>Demo project for Spring Boot</description>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.0.RELEASE</version>
<relativePath /> <!-- lookup parent from repository -->
</parent>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-
8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

Then we will add properties in src/main/resources/application.properties

spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
spring.datasource.url=jdbc:oracle:thin:@localhost:1521:XE
spring.datasource.username=active
spring.datasource.password=activenet

Followed by we will add Java Bean/@Entity class to the project

package com.example.spring;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Journal {
private Long id;

19
private String title;
private Date created;
private String summary;
private SimpleDateFormat format = new SimpleDateFormat("MM/dd/yyyy");

public Journal(Long id, String title, String summary, Date date) {

this.id = id;
this.title = title;
this.summary = summary;
this.created = date;
}

Journal() {
}

public Long getId() {

return id;
}

public void setId(Long id) {

this.id = id;
}

public String getTitle() {

return title;
}

public void setTitle(String title) {

this.title = title;
}

public Date getCreated() {

return created;
}

public void setCreated(Date created) {

this.created = created;
}

public String getSummary() {

return summary;
}

public void setSummary(String summary) {

this.summary = summary;
}

public String getCreatedAsShort() {

return format.format(created);
}

20
 public String toString() {
StringBuilder value = new StringBuilder("* JournalEntry(");
value.append("Id: ");
value.append(id);
value.append(",Title: ");
value.append(title);
value.append(",Summary: ");
value.append(summary);
value.append(",Created: ");
value.append(getCreatedAsShort());
value.append(")");
return value.toString();
}
}

Then we will create JournalService class

package com.example.spring;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;

@Service
public class JournalService {
private static final Logger log =
LoggerFactory.getLogger(JournalService.class);
@Autowired
JdbcTemplate jdbcTemplate;

public void insertData(){

log.info("> Table creation");
jdbcTemplate.execute("CREATE TABLE JOURNAL(id number, title
VARCHAR2(255), summary VARCHAR2(255), created DATE)");
log.info("> Inserting data...");
jdbcTemplate.execute("INSERT INTO JOURNAL(id,title,summary,created)
VALUES(5, 'Get to know Spring Boot','Today I will learn Spring Boot','01-Jan-
2018')");
jdbcTemplate.execute("INSERT INTO JOURNAL(id,title,summary,created)
VALUES(6, 'Simple Spring Boot Project','I will do my first Spring Boot
project','01-Jan-2018')");
jdbcTemplate.execute("INSERT INTO JOURNAL(id,title,summary,created)
VALUES(7, 'Spring Boot Reading','Read more about Spring Boot', '01-Jan-2018')");
jdbcTemplate.execute("INSERT INTO JOURNAL(id,title,summary,created)
VALUES(8, 'Spring Boot in the Cloud','Learn Spring Boot using Cloud Foundry','01-
Jan-2018')");

21
 log.info("> Done.");
}

public List<Journal> findAll() {

List<Journal> entries = new ArrayList<>();
jdbcTemplate
.query("SELECT * FROM JOURNAL",
new Object[] {}, (rs, row) -> new
Journal(rs.getLong("id"), rs.getString("title"), rs.getString("summary"), new
Date(rs.getTimestamp("created").getTime()))).forEach(entry -> entries.add(entry));
return entries;
}
}

At last i will include one class called SimpleJdbcApplication

package com.example.spring;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SimpleJdbcAppApplication implements CommandLineRunner {
private static final Logger log =
LoggerFactory.getLogger(SimpleJdbcAppApplication.class);
@Autowired
JournalService service;

public static void main(String[] args) {

SpringApplication.run(SimpleJdbcAppApplication.class, args);
}

@Override
public void run(String... arg0) throws Exception {
log.info("@@ Inserting Data....");
service.insertData();
log.info("@@ findAll() call...");
service.findAll().forEach(entry -> log.info(entry.toString()));
}
}

Now right click on the SimpleJdbcApplication and run it as “Spring Boot

App”. We will notice table, creation record insertion, and records
retrieval on the console screen.

22
App: The next Example is on Spring, JPA, Web MVC to display all the list of
Journals

23
The directory structure looks like as follows:

24
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.example</groupId>
<artifactId>simple-jpa-app</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>spring-boot-jpa-journal</name>
<description>Demo project for Spring Boot</description>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.0.RELEASE</version>
<relativePath /> <!-- lookup parent from repository -->
</parent>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-
8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

25
The above is the pom.xml file. The important point is the dependencies section which contains all the
poms that you selected in the wizard.
 spring-boot-starter-web – ours is a web application
 spring-boot-starter-thymeleaf – a template engine
 spring-boot-starter-data-jpa – a Data technology takes care of persistence
 spring-boot-starter-test – a test nit framework

application.properties
server.port=65000
spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
spring.datasource.url=jdbc:oracle:thin:@localhost:1521:XE
spring.datasource.username=active
spring.datasource.password=activenet

// Journal.java
package com.example.spring;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Transient;

@Entity
public class Journal {
@Id
// @GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String title;
private Date created;
private String summary;
@Transient
private SimpleDateFormat format = new SimpleDateFormat("MM/dd/yyyy");

public Journal(Long id, String title, String summary, String date) throws
ParseException {
this.id = id;
this.title = title;
this.summary = summary;
this.created = format.parse(date);
}

Journal() {
}

public Long getId() {

return id;
}

26
 public void setId(Long id) {
this.id = id;
}

public String getTitle() {

return title;
}

public void setTitle(String title) {

this.title = title;
}

public Date getCreated() {

return created;
}

public void setCreated(Date created) {

this.created = created;
}

public String getSummary() {

return summary;
}

public void setSummary(String summary) {

this.summary = summary;
}

public String getCreatedAsShort() {

return format.format(created);
}

public String toString() {

StringBuilder value = new StringBuilder("JournalEntry(");
value.append("Id: ");
value.append(id);
value.append(",Title: ");
value.append(title);
value.append(",Summary: ");
value.append(summary);
value.append(",Created: ");
value.append(getCreatedAsShort());
value.append(")");
return value.toString();
}
}

// JournalRepostory.java
package com.example.spring;
import org.springframework.data.jpa.repository.JpaRepository;
public interface JournalRepository extends JpaRepository<Journal, Long> { }

27
// JournalController.java
package com.example.spring;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class JournalController {
@Autowired
JournalRepository repo;

@RequestMapping("/")
public String index(Model model) {
model.addAttribute("journal", repo.findAll());
return "index";
}
}

// SpringBootJpaJournalApplication.java
package com.example.spring;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class SpringBootJpaJournalApplication {

@Bean
InitializingBean saveData(JournalRepository repo) {
return () -> {
repo.save(new Journal(13L, "Get to know Spring Boot", "Today I
will learn Spring Boot", "01/01/2016"));
repo.save(new Journal(14L, "Simple Spring Boot Project", "I
will do my first Spring Boot Project", "01/02/2016"));
repo.save(new Journal(15L, "Spring Boot Reading", "Read more
about Spring Boot", "02/01/2016"));
repo.save(new Journal(16L, "Spring Boot in the Cloud", "Spring
Boot using Cloud Foundry", "03/01/2016"));
};
}

public static void main(String[] args) {

SpringApplication.run(SpringBootJpaJournalApplication.class, args);
}
}
index.html
<!doctype html>
<html lang="en-US" xmlns:th="http://www.thymeleaf.org">
<head>

28
<meta charset="utf-8"></meta>
<meta http-equiv="Content-Type" content="text/html"></meta>
<title>Spring Boot Journal</title>
<link rel="stylesheet" type="text/css" media="all"
href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css
"></link>
<link rel="stylesheet" type="text/css" media="all"
href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap-
glyphicons.css">
</link>
<link rel="stylesheet" type="text/css" media="all" href="css/styles.css"></link>
</head>
<body>
<div class="container">
<h1>Spring Boot Journal</h1>
<ul class="timeline">
<div th:each="entry,status : ${journal}">
<li th:attr="class=${status.odd}?'timeline-
inverted':''">
<div class="tl-circ"></div>
<div class="timeline-panel">
<div class="tl-heading">
<h4>
<span
th:text="${entry.title}">TITLE</span>
</h4>
<p>
<small class="text-muted"><i
class="glyphicon
glyphicon-time"></i> <span

th:text="${entry.createdAsShort}">CREATED</span> </small>
</p>
</div>
<div class="tl-body">
<p>
<span
th:text="${entry.summary}">SUMMARY</span>
</p>
</div>
</div>
</li>
</div>
</ul>
</div>
</body>
</html>

Right click on SpringBootJpaJournalApplication.java class and RunsAs “Spring Boot App”.

Open browser and http://localhost:65000

29
Chapter 3# Spring Boot Auto-Configuration, Features, and More
In this chapter we will see how Spring Boot features that involve configuration. Shows how
@EnableAutoConfiguration works, how to externalize configuration properties, enable and disable
features.

Auto Configuration
@SpringBootApplication inherits @EnableAutoConfiguration, @Configuration, @ComponentScan,
which is why we can use exclude parameter in @SpringBootApplication.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import
org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration;

@SpringBootApplication(exclude={ActiveMQAutoConfiguration.class,DataSourceAutoConf
iguration.class})

public class DemoApplication {

public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}

On the command prompt we can type spring run DemoApplication.java - - debug

@EnableAutoConfiguration and @Enable<Technology> Annotations

You will find that in some of the Spring modules like Spring Core, Spring Data, Spring Security, Spring
AMQP, and Spring Integration provide @Enable<Technology> annotations. For example
@EnableTransactionManagement, @EnableRabbit, @EnableIntegration. Within Spring applications
we can use these annotations to follow the pattern “convention over configuration” thus makes
your apps even easier to develop and maintain without worrying too much about configuration.
Spring Boot can also take advantage of these annotations. These annotations are used in the
@EnableAutoConfiguration annotation to do the auto-configuration. Take a closer look
@EnableAutoConfiguration annotation to see the logic behind it. You will see where the
@Enable<Technology> annotation fit.

Spring Boot Features

Application Configuration

30
Chapter 4# Spring Boot CLI
The run command
The run command will allow you to run Java Spring Boot applications.
Syntax: spring run [options] <files> [--] ] [args]
Example: spring run WebApp.java
// WebApp.java
package com.apress.spring;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@SpringBootApplication

public class WebApp {

@RequestMapping("/")
public String greetings(){
return "Spring Boot Rocks in Java too!";
}
public static void main(String[] args) {
SpringApplication.run(WebApp.class, args);
}
}

The test command

The test command runs Spring Java tests.
Syntax: spring test [options] <files> [- -] ] [args]
Example: spring test MyTest.java
// MyTest.java
import org.junit.Rule;
import org.junit.Test;
import org.springframework.boot.test.OutputCapture;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.*;

public class MyTest {

@Rule
public OutputCapture capture = new OutputCapture();

@Test
public void stringTest() throws Exception {

System.out.println("Spring Boot Test works in Java too!");

assertThat(capture.toString(), containsString("Spring Boot Test

works in Java too!"));
}
}

31
The grab command
The grab command will download all the Spring Java dependencies to the ./repository directory.
Syntax: spring grab [options] <files> [- -] ] [args]
Example: spring grab MyTest.java

The jar command

The jar command will create a self contained executable JAR file.
Syntax: spring jar [options] <jar-name> <files>
Example: spring jar app.jar
java -jar app.jar

The war command

This is very similar to previous command. The war command will create a self contained executable
WAR file from Java Script.
Syntax: spring war [options] <war-name> <files>
Example: spring war app.war
java –jar app.war

The install command

The install command is very similar to grab command. The only difference is we need to specify the
library we want to install.
Syntax: spring install [options] <coordinates>
Example: spring install org.spockframework:spock-core:1.0-groovy-2.4

The uninstall command

The uninstall command uninstalls all the dependencies from the lib directory.
Syntax: spring uninstall [options] <coordinates>
Example: spring uninstall org.spockframework:spock-core:1.0-groovy-2.4

The init command

The init command will help you initialize a new project by using Spring Initializr without using IDE
Syntax: spring init [options] [location]
Example: shown in previous chapter

The shell command

The shell command will start an embedded shell.
Example: spring shell

32
The help command
Example: spring help init

33
Chapter 5# Spring with Spring Boot
• Spring Web MVC Applications
• Using Spring with Spring Boot
• Using Spring Technologies in Spring Boot
Spring Web MVC Applications
The Spring Framework brought a new way to develop web applications by introducing a MVC pattern
into the framework that is easy to setup and use. MVC first time termed by “Smalltalk” ( a
Programming Language) developer “Trygve Reenskaug” in Smalltalk-76. In 1980 “Jim Althoff” and
others implemented MVC library in Smalltalk-80 library for developing GUIs. Later supported and
promoted by “Kent Beck”. He is also a chief contributor of “eXtreme Programmng” also called as XP
software development methodology. He is also one of the 17 original signatories of “Agile
Development Methodology”.
MVC pattern subsequently evolved, giving raise to variants such as HMVC (Hierarchical MVC), MVA
(Model-View-Adapter), MVVM (Model-View-ViewModel) and other MVC adopted patterns.
Advantages of MVC are:
• Simultaneous development – Multiple developers can work simultaneously on the model,
controller and views
• High cohesion – MVC enables logical grouping related actions on a controller together.
• Low Coupling – The very nature of MVC is that there is low coupling among models, views,
controllers
• Ease of modification – Because of the separation of responsibilities, further development of
modifications is easier.
• Multiple views for a model – Models can have multiple views
Disadvantages of MVC are:
• Code navigability – The framework navigation can be complex because of introduces new
layers of abstraction and requires users to adapt to the composition criteria of MVC.
• Multi-artifact consistency – Decomposing a feature into three artifacts cause scattering. Thus
requiring developers to maintain the consistency of multiple representations at once.
• Pronounced learning curve – Knowledge on multiple technologies become the norm.
Developers using MVC need to be skilled in multiple technologies.
But the Spring team did an excellent job using this pattern as a base model for every web application
by simplifying its functionality.
Let’s look at Spring MVC application using Maven archetype;
mvn archetype:create –DgroupID=com.example.spring –DartifactId=simple-web-spring-
app –DarchetypeArtifcatId=maven-archetype-webapp

The above maven archetype is useful just for creating files and directory structure.
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

34
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">

<modelVersion>4.0.0</modelVersion>
<groupId>org.springframework.samples.service.service</groupId>
<artifactId>simple-web-spring-app</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>

<properties>
<!-- Generic properties -->
<java.version>1.8</java.version>
<!-- Web -->
<jsp.version>2.2</jsp.version>
<jstl.version>1.2</jstl.version>
<servlet.version>2.5</servlet.version>
<!-- Spring -->
<spring-framework.version>3.2.3.RELEASE</spring-framework.version>
</properties>

<dependencies>
<!-- Spring MVC -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring-framework.version}</version>
</dependency>
<!-- Other Web dependencies -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>${jstl.version}</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>${servlet.version}</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>${jsp.version}</version>
<scope>provided</scope>
</dependency>
</dependencies>

<build>
<finalName>simple-web-spring-app</finalName>
</build>
</project>
src/main/webapp/WEB-INF/web.xml
<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"

35
id="WebApp_ID" version="2.5">

<display-name>simple-web-spring-app</display-name>
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-
class>org.springframework.web.servlet.DispatcherServlet</servlet-
class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/mvc-config.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
src/main/webapp/WEB-INF/mvc-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

<bean name="/showMessage.html"
class="com.example.spring.SimpleController"/>

<bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/view/"/>
<property name="suffix" value=".jsp"/>
</bean>
</beans>
src/main/java/com/apress/spring/SimpleController.java
package com.apress.spring;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;

public class SimpleController extends AbstractController{

@Override
public ModelAndView handleRequestInternal(HttpServletRequest request,
HttpServletResponse response) throws Exception {
ModelAndView model = new ModelAndView("showMessage");
model.addObject("message", "Spring MVC Web Application");
return model;
}
}

36
src/main/webapp/WEB-INF/view/showMessage.jsp
<!DOCTYPE html>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-
8"%>
<html>
<head>
<meta charset="utf-8">
<title>Welcome</title>
</head>
<body>
<h2>${message}</h2>
</body>
</html>
Type mvc clean package

We will have the target/simple-web-spring-app.war file. Now we can deploy this web application into
any favourite J2EE web server/application servers like Tomcat/WebLogic/WebSphere/JBoss. Start the
J2EE server and type URL as http://localhost:65535/smple-web-spring-app/showMessage.html.
If you already know Spring MVC, you may notice that the example we saw is a old way of doing it.
Spring version 2.5, 3, 4 allows you add annotations to avoid extending from other classes and have
more mapping in one single class. Below is the example of implementing Controller using
Annotations.
src/main/java/com/apress/spring/SimpleController.java using annotations
package com.example.spring;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

@Controller
@RequestMapping("/showMessage.html")

public class HelloWorldController{

@RequestMapping(method = RequestMethod.GET)
public ModelAndView helloWorld(){
ModelAndView model = new ModelAndView("showMessage");
model.addObject("message", "Spring MVC Web App with annotations");
return model;
}
}
src/main/webapp/WEB-INF/mvc-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

<context:component-scan base-package="com.example.spring" />

37
 <bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/view/"/>
<property name="suffix" value=".jsp"/>
</bean>
</beans>

Deploy and run this web application on any interested J2EE server and run from browser.

Now we create a simple Spring Boot Application

Create a directory for spring boot web project and type following Spring CLI command to
create a Spring Boot Project:
spring init –d=web –g=com.example.spring –a=simple-web-spring-boot –package-
name=com.example.spring –name=simple-web-spring-boot –x

Now the application directory structure looks as follows:

.
mvnw
mvnw.cmd
pom.xml
src
main
java
com
example
spring
SimpleWebSpringBootApplication.java
resources
application.properties
static
templates
test
java
com
example
spring
SimpleWebSpringBootApplicationTest.java
Now open SimpleWebSpringBootApplication.java class and modify as:
src/main/java/com/apress/spring/SimpleWebSpringBootApplication.java
package com.apress.spring;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;
@RestController
@SpringBootApplication
public class SimpleWebSpringBootApplication {
@RequestMapping("/showMessage.html")
public String index(){

38
 return "Spring Boot Rocks!";
}
public static void main(String[] args) {
SpringApplication.run(SimpleWebSpringBootApplication.class, args);
}
}

Type spring-boot:run

Look at another example on Spring Boot with Web, JPA

Spring Web MVC, REST with JPA CRUD Example

39
40
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.example</groupId>
<artifactId>easy-note</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>spring-boot-mvc-rest</name>
<description>Demo project for Spring Boot</description>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.0.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-
8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>

41
 <dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
// EasyNotesApplication.java
package com.example.spring;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;

@SpringBootApplication
@EnableJpaAuditing
public class EasyNotesApplication {

public static void main(String[] args) {

SpringApplication.run(EasyNotesApplication.class, args);
}
}

It contains a simple annotation called @SpringBootApplication which is a combination of the

following more specific spring annotations -

• @Configuration : Any class annotated with @Configuration annotation is bootstrapped by

Spring and is also considered as a source of other bean definitions.

• @EnableAutoConfiguration : This annotation tells Spring to automatically configure your

application based on the dependencies that you have added in the pom.xml file.

For example, If spring-data-jpa is in the classpath, then it automatically tries to configure

a DataSource by reading the database properties from application.properties file.

42
 • @ComponentScan : It tells Spring to scan and bootstrap other components defined in the
current package (com.example.easynotes) and all the sub-packages.

The main() method calls Spring Boot’s SpringApplication.run() method to launch the application.

2. resources/

This directory, as the name suggests, is dedicated to all the static resources, templates and property
files.

• resources/static - contains static resources such as css, js and images.

• resources/templates - contains server-side templates which are rendered by Spring.

• resources/application.properties - This file is very important. It contains application-wide

properties. Spring reads the properties defined in this file to configure your application. You can
define server’s default port, server’s context path, database URLs etc, in this file.

You can refer this page for common application properties used in Spring Boot.

3. EasyNotesApplicationTests - Define unit and integration tests here.

4. pom.xml - contains all the project dependencies

src/main/resources/application.properties
spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
spring.datasource.url=jdbc:oracle:thin:@localhost:1521:XE
spring.datasource.username=active
spring.datasource.password=activenet

## Hibernate Properties
# The SQL dialect makes Hibernate generate better SQL for the chosen database
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.OracleDialect

# Hibernate ddl auto (create, create-drop, validate, update)

spring.jpa.hibernate.ddl-auto = update
server.port=65000

// Note.java
package com.example.spring;

import java.io.Serializable;
import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EntityListeners;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

43
import javax.validation.constraints.NotBlank;

import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@Entity
@Table(name = "notes")
@EntityListeners(AuditingEntityListener.class)
@JsonIgnoreProperties(value = {"createdAt", "updatedAt"}, allowGetters = true)
public class Note implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@NotBlank
private String title;

@NotBlank
private String content;

@Column(nullable = false, updatable = false)

@Temporal(TemporalType.TIMESTAMP)
@CreatedDate
private Date createdAt;

@Column(nullable = false)
@Temporal(TemporalType.TIMESTAMP)
@LastModifiedDate
private Date updatedAt;

public Note() {
super();
// TODO Auto-generated constructor stub
}

public Note(Long id, @NotBlank String title, @NotBlank String content, Date
createdAt, Date updatedAt) {
super();
this.id = id;
this.title = title;
this.content = content;
this.createdAt = createdAt;
this.updatedAt = updatedAt;
}

public Long getId() {

return id;
}

public void setId(Long id) {

this.id = id;
}

public String getTitle() {

return title;
}

44
 public void setTitle(String title) {
this.title = title;
}

public String getContent() {

return content;
}

public void setContent(String content) {

this.content = content;
}

public Date getCreatedAt() {

return createdAt;
}

public void setCreatedAt(Date createdAt) {

this.createdAt = createdAt;
}

public Date getUpdatedAt() {

return updatedAt;
}

public void setUpdatedAt(Date updatedAt) {

this.updatedAt = updatedAt;
}
}

// NoteRepository.java
package com.example.spring;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface NoteRepository extends JpaRepository<Note, Long> {
}

// ResourceNotFoundException.java
package com.example.spring;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

@ResponseStatus(value = HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException {
private String resourceName;
private String fieldName;
private Object fieldValue;

public ResourceNotFoundException( String resourceName, String fieldName,

Object fieldValue) {
super(String.format("%s not found with %s : '%s'", resourceName,
fieldName, fieldValue));
this.resourceName = resourceName;
this.fieldName = fieldName;

45
 this.fieldValue = fieldValue;
}

public String getResourceName() {

return resourceName;
}

public String getFieldName() {

return fieldName;
}

public Object getFieldValue() {

return fieldValue;
}
}
// NoteController.java
package com.example.spring;

import java.util.List;

import javax.validation.Valid;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class NoteController {

@Autowired
NoteRepository noteRepository;

// Get All Notes

@GetMapping("/notes")
public List<Note> getAllNotes() {
return noteRepository.findAll();
}

// Create a new Note

@RequestMapping(path="/notes",method=RequestMethod.POST,consumes=MediaType.APPLICA
TION_JSON_VALUE)
public Note createNote(@Valid @RequestBody Note note) {
return noteRepository.save(note);
}

// Get a Single Note

@GetMapping("/notes/{id}")
public Note getNoteById(@PathVariable(value = "id") Long noteId) {
return noteRepository.findById(noteId)

46
 .orElseThrow(() -> new ResourceNotFoundException("Note", "id",
noteId));
}

// Update a Note
@PutMapping("/notes/{id}")
public Note updateNote(@PathVariable(value = "id") Long noteId,
@Valid @RequestBody Note noteDetails)
{

Note note = noteRepository.findById(noteId)

.orElseThrow(() -> new ResourceNotFoundException("Note", "id",
noteId));

note.setTitle(noteDetails.getTitle());
note.setContent(noteDetails.getContent());

Note updatedNote = noteRepository.save(note);

return updatedNote;
}

// Delete a Note
@DeleteMapping("/notes/{id}")
public ResponseEntity<?> deleteNote(@PathVariable(value = "id") Long noteId) {
Note note = noteRepository.findById(noteId)
.orElseThrow(() -> new ResourceNotFoundException("Note", "id",
noteId));

noteRepository.delete(note);

return ResponseEntity.ok().build();
}
}
Posting a new Note using POST method call from POSTMAN

47
Retrieving all the Notes using GET method call from POSTMAN

Retrieving single Note using GET method call from POSTMAN

48
Requesting PUT method to update existing Note

49
50
Chapter 6# Testing with Spring Boot
This chapter will be covered later updation of the material.

51
Chapter 7# Data Access with Spring Boot
SQL Databases
Data Access using JdbcTemplate with Spring Boot
Data Access using JPA with Spring Boot
Note: the above JdbcTemplate example and JPA examples are covered in previous
chapter.

No SQL Databases
No SQLL Databases are another way to persist data, but in different way from the tabular
relationships of the relational databases. You can find it based on its data model.
• Column (Cassandra, HBase etc)
• Document (CouchDB, MongoDB etc)
• Key-Value (Redis, Riak etc)
• Graph (Neo4J, Virtuoso etc)
• Multi-model (Orient DB, ArangoDB etc)
As you can see we have many options. I think the most important kind of feature here nowadays is to
find a database that is scalable and can handle millions of records easily. In this section we will discuss
MongoDB a No SQL document database.
Install and run mongodb database. Download ZIP file from https://www.mongodb.org, extract zip file,
double click on C:\Program Files\MongoDB\Server\3.2\bin\mongod.exe
Create a Spring Boot Project using Spring CLI:
spring init –d=data-mongodb –g=com.example.spring –a=simple-mongo-app –
package=com.example.spring –n=simple-mongo-app –x
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">

<modelVersion>4.0.0</modelVersion>

<groupId>com.example.spring</groupId>
<artifactId>simple-mongo-app</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>simple-mongo-app</name>
<description>Demo project for Spring Boot</description>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.3.2.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->

52
 </parent>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.8</java.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
src/main/java/com/example/spring/domain/Journal.java
package com.example.spring.domain;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.Transient;
public class Journal {
@Id
private String id;
private String title;
private Date created;
private String summary;
@Transient
private SimpleDateFormat format = new SimpleDateFormat("MM/dd/yyyy");

public Journal(String title, String summary, String date) throws

ParseException{
this.title = title;
this.summary = summary;
this.created = format.parse(date);
}

Journal(){}

public String getId() {

return id;
}
public void setId(String id) {
this.id = id;
}

53
 public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public Date getCreated() {
return created;
}
public void setCreated(Date created) {
this.created = created;
}
public String getSummary() {
return summary;
}
public void setSummary(String summary) {
this.summary = summary;
}
public String getCreatedAsShort(){
return format.format(created);
}
public String toString(){
StringBuilder value = new StringBuilder("* JournalEntry(");
value.append("Id: ");
value.append(id);
value.append(",Title: ");
value.append(title);
value.append(",Summary: ");
value.append(summary);
value.append(",Created: ");
value.append(getCreatedAsShort());
value.append(")");
return value.toString();
}
}
src/main/java/com/apress/spring/repository/JournalRepository.java
package com.example.spring.repository;
import java.util.List;
import org.springframework.data.mongodb.repository.MongoRepository;
import com.apress.spring.domain.Journal;

public interface JournalRepository extends MongoRepository<Journal, String> {

public List<Journal> findByTitleLike(String word);
}
src/main/java/com/example/spring/SimpleMongoAppApplication.java
package com.example.spring;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import com.apress.spring.domain.Journal;
import com.apress.spring.repository.JournalRepository;

@SpringBootApplication
public class SimpleMongoAppApplication {

54
 private static final Logger log =
LoggerFactory.getLogger(SimpleMongoAppApplication.class);

public static void main(String[] args) {

SpringApplication.run(SimpleMongoAppApplication.class, args);
}
@Bean
CommandLineRunner start(JournalRepository repo){
return args -> {
log.info("> Deleting existing data...");

repo.deleteAll();

log.info("> Inserting new data...");

repo.save(new Journal("Get to know Spring Boot","Today I will

learn Spring Boot","01/02/2016"));

repo.save(new Journal("Simple Spring Boot Project","I will do

my first Spring Boot Project","01/03/2016"));

repo.save(new Journal("Spring Boot Reading","Read more about

Spring Boot","02/02/2016"));

repo.save(new Journal("Spring Boot in the Cloud","Spring Boot

using Cloud Foundry","03/01/2016"));

log.info("> Getting all data...");

repo.findAll().forEach(entry -> log.info(entry.toString()));

log.info("> Getting data using like...");

repo.findByTitleLike("Cloud").forEach(entry ->
log.info(entry.toString()));
};
}
}

mvnw spring-boot:run
You will see the following output:
> Deleting existing data...
> Inserting new data...
> Getting all data...
* JournalEntry(Id: 56b192d377c83f89cae51f5f,Title: Get to know Spring
Boot,Summary: Today I will learn Spring Boot,Created: 01/02/2016)
* JournalEntry(Id: 56b192d377c83f89cae51f60,Title: Simple Spring Boot
Project,Summary: I will do my first Spring Boot Project,Created: 01/03/2016)
* JournalEntry(Id: 56b192d377c83f89cae51f61,Title: Spring Boot Reading,Summary:
Read more about Spring Boot,Created: 02/02/2016)
* JournalEntry(Id: 56b192d377c83f89cae51f62,Title: Spring Boot in the
Cloud,Summary: Spring Boot using Cloud Foundry,Created: 03/01/2016)
> Getting data using like...
* JournalEntry(Id: 56b192d377c83f89cae51f62,Title: Spring Boot in the
Cloud,Summary: Spring Boot using Cloud Foundry,Created: 03/01/2016)

55
If you want to see the actual data in your MongoDB server, you can open terminal and execute the
following commands:
$ mongo
MongoDB shell version: 3.2.1
connecting to: test

> show collections

blog
journal
system.indexes

> db.journal.find()
{ "_id" : ObjectId("56b192d377c83f89cae51f5f"), "_class" :
"com.apress.spring.domain.
Journal", "title" : "Get to know Spring Boot", "created" : ISODate("2016-01-
02T07:00:00Z"),
"summary" : "Today I will learn Spring Boot" }
{ "_id" : ObjectId("56b192d377c83f89cae51f60"), "_class" :
"com.apress.spring.domain.
Journal", "title" : "Simple Spring Boot Project", "created" : ISODate("2016-01-
03T07:00:00Z"), "summary" : "I will do my first Spring Boot Project" }
{ "_id" : ObjectId("56b192d377c83f89cae51f61"), "_class" :
"com.apress.spring.domain.
Journal", "title" : "Spring Boot Reading", "created" : ISODate("2016-02-
02T07:00:00Z"),
"summary" : "Read more about Spring Boot" }
{ "_id" : ObjectId("56b192d377c83f89cae51f62"), "_class" :
"com.apress.spring.domain.
Journal", "title" : "Spring Boot in the Cloud", "created" : ISODate("2016-03-
01T07:00:00Z"),
"summary" : "Spring Boot using Cloud Foundry" }

When you use the mongo client shell, you will be connected directly to the test database, which is
what Spring Boot will use as main database to create the document collection. In this case, it’s the
name of the Java class: journal . Then you can use the db.journal.find() query to get all the data.
Spring Boot allows you to define the name of your database if you don’t want to use the default one.
You only need to add the following property to the src/main/resources/application.properties file:
spring.data.mongodb.database=myjournal
Then the M ongoRepository w ill create the database using the m yjournal name and will create the
journal collection as well.
You can take a peek at the MongoDB server by using its client. You can see the database, the
collection, and the data with the following commands:
$ mongo
MongoDB shell version: 3.2.3
connecting to: test

> show databases;

local 0.078GB
myjournal 0.078GB
test 0.203GB

> use myjournal

switched to db myjournal

56
> show collections
journal
system.indexes

> db.journal.find()
{ "_id" : ObjectId("56b0ef2d77c8a628197f0aa4"), "_class" :
"com.apress.spring.domain.
Journal", "title" : "Get to know Spring Boot", "created" : ISODate("2016-01-
02T07:00:00Z"),
"summary" : "Today I will learn Spring Boot" }
{ "_id" : ObjectId("56b0ef2d77c8a628197f0aa5"), "_class" :
"com.apress.spring.domain.
Journal", "title" : "Simple Spring Boot Project", "created" : ISODate("2016-01-
03T07:00:00Z"), "summary" : "I will do my first Spring Boot Project" }
{ "_id" : ObjectId("56b0ef2d77c8a628197f0aa6"), "_class" :
"com.apress.spring.domain.
Journal", "title" : "Spring Boot Reading", "created" : ISODate("2016-02-
02T07:00:00Z"),
"summary" : "Read more about Spring Boot" }
{ "_id" : ObjectId("56b0ef2d77c8a628197f0aa7"), "_class" :
"com.apress.spring.domain.
Journal", "title" : "Spring Boot in the Cloud", "created" : ISODate("2016-03-
01T07:00:00Z"),
"summary" : "Spring Boot using Cloud Foundry" }
>
Note: Remaining Databases are also covered in next updations of this
material.

57
Chapter 8# Web Development with Spring Boot
Spring MVC
Spring Boot Web Applications
Playing with the HAL Browser

58
Chapter 9# Security with Spring Boot
Simple Security for Spring Boot
Spring Boot with OAuth2

This chapter shows how to use Spring Security in Spring Boot Application in order to secure web
application. Web will learn “Basic Security” to “OAuth”. Security has become a primary and
important factor for desktop, web and mobile applications. Security is little hard to learn because we
need to learn “Cross Site Scripting”, “Authentication”, “Authorization”, “Secure Sessions”,
“Identification”, “Encryption” and lot more.
Spring security is centred around AuthenticationProvider and UserDetailService; it also provides
integration with Identity Service Provider Systems such as LDAP, Active Directory, Kerberos, PAM,
OAuth and so on.

Simple Security for Spring Boot

md spring-boot-journal-secure
cd spring-boot-journal-secure
spring init
-d=web, thymeleaf, data-jpa, data-rest, mysql, security
-g=com.example.spring
-a=spring-boot-journal-secure
--package-name=com.example.spring
-name=spring-boot-journal-secure
–x
Now we review pom.xml file:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/
XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/
maven-4.0.0.xsd">

<modelVersion>4.0.0</modelVersion>
<groupId>com.apress.spring</groupId>
<artifactId>spring-boot-journal-secure</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>spring-boot-journal-secure</name>
<description>Demo project for Spring Boot</description>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.3.2.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.8</java.version>

59
 </properties>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

Copy all the Journal classes (src/main/java), all the web, SQL, and property files
(/src/main/resources) from the previous chapter. The directory structure looks as below.
-mvnw
-mvnw.cmd
-pom.xml
-src
-main
-java
-com
-example
-spring

60
 -SpringBootJournalSecureApplication.java
-domain
-JournalEntry.java
-repository
-JournalRepository.java
-utils
-JsonDataSerializer.java
-web
-JournaController.java
-resources
-application.properties
-data.sql
-static
-css
-bootstrap-glyphicons.css
-bootstrap.min.css
-styles.css
-templates
-index.html
-test
-java
-com
-example
-spring
-SpringBootJournalSecureApplicationTests.java
Now lets run with mvnw spring-boot:run
After executing the command you should be able to see a new line about the
AuthenticationManagerConfiguration class. That shows something like as below:
...
INFO 29387 --- [] .e.DelegatingFilterProxyRegistrationBean : Mapping filter:
'springSecurityFilterChain' to: [/*]
INFO 29387 --- [] o.s.b.c.e.ServletRegistrationBean : Mapping servlet:
'dispatcherServlet' to [/]
INFO 29387 --- [] b.a.s.AuthenticationManagerConfiguration :
Using default security password: f3f818e9-a36f-48ca-9b44-5ed4b3224384
INFO 29387 --- [] o.s.s.web.DefaultSecurityFilterChain : Creating filter chain:
Ant [pattern='/css/**'], []
INFO 29387 --- [] o.s.s.web.DefaultSecurityFilterChain : Creating filter chain:
Ant [pattern='/js/**'], []
...

In the console, you should see the text: "Using default security password: xxx-xxxx-xxx ..." with a
GUID (Global Unique ID) that you will use to authenticate. If you go to your browser and visit
http://localhost:65535, you should see something similar to Figure given below.

61
Shows basic security window, fields are empty by default, enter user and password and submit. By
default AuthenticationManager interface implementation has a single username called user. So in
the username box enter username as user and password as GUID shown on the logs – a random
password. This example uses f3f818e9-a36f-48ca-9b44-5ed4b3224384 GUID. This GUID
changes every time when you run the application.
That’s it. That is the easiest and most basic security you can add to your web application ad the only
thing you did was add the spring-boot-starter-security pom. When Spring Boot app starts
the auto configuration will identify that you have the web and the security dependencies and it will
create the basic security authentication. Of course, this is not very useful with production apps.
Security using the application.properties file:
src/main/resources/application.properties
spring.datasource.url = jdbc:mysql://localhost:3306/journal
spring.datasource.username = springboot
spring.datasource.password = springboot
spring.datasource.testWhileIdle = true
spring.datasource.validationQuery = SELECT 1

spring.jpa.show-sql = true
spring.jpa.hibernate.ddl-auto = create-drop
spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.ImprovedNamingStrategy
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect

spring.data.rest.basePath=/api

# Security
security.user.name = springboot
security.user.password = isawesome
Now again run mvnw spring-boot:run and then access the application using
http://localhost:655535, enter username as springboot and password as isawesome and see the
result. You can use cURL to access your /api and make sure it is also secured with
On command prompt type: curl -i http://springboot:isawesome@locahost:65535/api
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
X-Frame-Options: DENY
Strict-Transport-Security: max-age=31536000 ; includeSubDomains
Content-Type: application/hal+json;charset=UTF-8

62
Transfer-Encoding: chunked
Date: Sat, 06 Feb 2016 23:00:29 GMT
{
"_links" : {
"entry" : {
"href" : "http://localhost:8080/api/journal{?page,size,sort}",
"templated" : true
},
"profile" : {
"href" : "http://localhost:8080/api/profile"
}
}
}
Using this command, you can see that passing the username:password gives you access to the REST
API. You can stop your application now.
In-Memory Security
Using the application.properties file isn’t a real solution. Let’s see how you can use in-memory
security. You are going to create a new
src/main/java/com/example/spring/config/InMemorySecurityConfiguration.java file.
src/main/java/com/apress/spring/config/InMemorySecurityConfiguration.java
package com.example.spring.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.
AuthenticationManagerBuilder;

import
org.springframework.security.config.annotation.authentication.configuration.
EnableGlobalAuthentication;

@Configuration
@EnableGlobalAuthentication
public class InMemorySecurityConfiguration {
@Autowired
public void configureGlobal(AuthenticationManagerBuilder auth) throws
Exception {
auth.inMemoryAuthentication().withUser("user").password("password").
roles("USER")
.and().withUser("admin").password("password").
roles("USER", "ADMIN");
}
}
Below shows the InMemorySecurityConfiguration.java class . Let’s dig into it:
• @Configuration . This annotation tells the Spring Boot to use it as part of the configuration; it’s
similar to using XML files.
• @EnableGlobalAuthentication . This annotation marks the class and configures all the necessary
beans to activate the security on the application; it signals that the annotated class can be used to
configure a global instance of the AuthenticationManagerBuilder .
• @Autowired/configureGlobal(AuthenticationManagerBuilder auth) .
This method is called to auto-wire the AuthenticationManagerBuilder. The
AuthenticationManagerBuilder allows you to easily build your authentication by adding
UserDetailsService and the authentication providers. You are going to learn more about the options

63
in the following sections. In this case, it will use in-memory because it’s calling the
inMemoryAuthentication method and setting up two users with their passwords and roles.
Before you run the application, comment out the security.user.name and security.user.password
properties from the src/main/resources/application.properties file. Just add a # sign in front of
them, like this:

#security.user.name=springboot
#security.user.password=isawesome
Now you can run the journal app as usual:
mvnw spring-boot:run
Run this on browser using http://localhost:65535, enter username as “user”, password as
“password”.
Security using a Database
Using the in-memory isn’t a real solution either, but there are alternatives. How about using
a database? Normally this is one of the most common approaches to saving users. Let’s see
what you need to modify in order to use a database as a security mechanism.
You are using MySQL/Oracle as a database engine, so let’s continue using that. First you are
going to create a security configuration. Create the
src/main/java/example/spring/config/JdbcSecurityConfiguration.java file.
package com.example.spring.config;

import java.sql.ResultSet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.security.config.annotation.authentication.builders.
AuthenticationManagerBuilder;
import
org.springframework.security.config.annotation.authentication.configuration.
EnableGlobalAuthentication;
import org.springframework.security.config.annotation.authentication.configurers.
GlobalAuthenticationConfigurerAdapter;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;

@Configuration
@EnableGlobalAuthentication

public class JdbcSecurityConfiguration extends

GlobalAuthenticationConfigurerAdapter{

@Bean
public UserDetailsService userDetailsService(JdbcTemplate jdbcTemplate) {
RowMapper<User> userRowMapper = (ResultSet rs, int i) ->
new User(
rs.getString("ACCOUNT_NAME"),
rs.getString("PASSWORD"),
rs.getBoolean("ENABLED"),

64
 rs.getBoolean("ENABLED"),
rs.getBoolean("ENABLED"),
rs.getBoolean("ENABLED"),
AuthorityUtils.createAuthorityList("ROLE_USER", "ROLE_ADMIN"));
return username ->
jdbcTemplate.queryForObject("SELECT * from ACCOUNT where
ACCOUNT_NAME = ?",
userRowMapper, username);
}

@Autowired
private UserDetailsService userDetailsService;

@Override
public void init(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(this.userDetailsService);
}
}
Below shows shows the Jdbc SecurityConfiguration.java class . Let’s examine it:
• @Configuration . The JdbcSecurityConfiguration.java class is marked with the
@Configuration , which allows Spring Boot to recognize this class as another configuration
file where normally you declare your beans. It’s the same as using an XML file.
• @EnableGlobalAuthentication . This annotation marks the class and configures all the
necessary beans to activate the security on the application.
• GlobalAuthenticationConfigurerAdapter . The JdbcSecurityConfiguration.java class extends
from the GlobalAuthenticationConfigurerAdapter abstract class. This class also implements
the SecurityConfigurer interface and exposes an init method that will be overridden in the
JdbcSecurityConfiguration.java class.
• init(AuthenticationManagerBuilder) . Overrides the GlobalAuthenticationConfigurerAdapter
init method. In this method, the AuthenticationManagerBuilder instance is used to build in-
memory, LDAP, or JDBC-based authentication by setting up a UserDetailsService instance.
• @Bean/userDetailsService(JdbcTemplate) . This method will set up a JdbcTemplate instance
that will create a new org.springframework.security.core.userdetails.User instance after a
ResultSet is returned by using RowMapper that will match its constructor ( User ). This User
instance accepts the username , password , enabled , accountNonExpired ,
credentialsNonExpired , accountNonLocked , and authorities collections as the constructor’s
parameters. How the ResultSet will match the RowMapper ? Well, the Spring Security team
• provides a SQL schema that will work by adding the users. Don’t worry, as you are going to
see the SQL schema in just a moment. If you wonder where this is, you can go to
https://docs.spring.io/spring-security/site/docs/current/reference/html/appendix-
schema.html .
• @Autowired/userDetailsService . This instance is retrieved from the userDetailsService
method because it's declared as a bean.
Remember that you have the InMemorySecurityConfiguration class, so this means that only one can
be used, not both. So you can leave it and the JdbcSecurityConfiguration will take precedence and all
the users will be in the MySQL database. Another option is that you can comment out the main
annotation (@Configuration and @EnableGlobalAuthentication) and it will be the same. The best
solution is to use profiles, by using the @Profile annotation and activating the profiles at run time
with -Dspring.active.profiles=memory or whatever name you give to the profile.
Because this is a JDBC security, you need to add the table with its data to the src/main/resources/
schema.sql file. Here it will be for the table description and for the src/main/resources/data.sql .
src/main/resources/schema.sql

65
-- SECURITY: USER ACCOUNT
DROP TABLE IF EXISTS account;
CREATE TABLE account ( ACCOUNT_NAME VARCHAR(255) NOT NULL,
PASSWORD VARCHAR(255 ) NOT NULL,
ID SERIAL,
ENABLED BOOL DEFAULT true) ;
-- JOURNAL TABLE: ENTRY
DROP TABLE IF EXISTS entry;
CREATE TABLE entry (
ID BIGINT(20) NOT NULL AUTO_INCREMENT,
CREATED DATETIME DEFAULT NULL,
SUMMARY VARCHAR(255) DEFAULT NULL,
TITLE VARCHAR(255) DEFAULT NULL,
PRIMARY KEY (ID)
);
src/main/resources/data.sql
-- USERS IN JOURNAL
INSERT INTO ACCOUNT(account_name , password) VALUES('springboot', 'isawesome');
INSERT INTO ACCOUNT(account_name , password) VALUES('springsecurity',
'isawesometoo');

-- JOURNAL DATA
INSERT INTO ENTRY(title,summary,created) VALUES('Get to know Spring Boot','Today I
will learn Spring Boot','2016-01-02 00:00:00.00');
INSERT INTO ENTRY(title,summary,created) VALUES('Simple Spring Boot Project','I
will do my first Spring Boot project','2016-01-03 00:00:00.00');
INSERT INTO ENTRY(title,summary,created) VALUES('Spring Boot Reading','Read more
about Spring Boot','2016-02-02 00:00:00.00');
INSERT INTO ENTRY(title,summary,created) VALUES('Spring Boot in the Cloud','Learn
Spring Boot using Cloud Foundry','2016-02-05 00:00:00.00');
mvnw spring-boot:run
After executing the command, you can go to http://localhost:8080 and use the springsecurity
username and the isawesometoo password. That’s it; it’s very easy to implement JDBC security.

Some REST Security configurations and Spring Boot with OAuth2 documentation and examples are
left to complete Spring Security.

Spring Boot with OAuth2

66
Chapter 10# Messaging with Spring Boot
What is Messaging
JMS with Spring Boot
RabbitMQ with Spring Boot
Redis Messaging with Spring Boot
Web Sockets with Spring Boot
Chapter 11# Spring Boot Actuator
Spring Boot Actuator
Sensitive Endpoints
Changing the Endpoint ID
Actuator CORS Support
Changing the Management Endpoints Path
Using Spring Boot Actuator in a Non-Web Application
Chapter 12# Deploying Spring Boot
Setting up the Spring Boot Journal App
Testing SSL
Creating Executable JARs
Creating Executable and Deployable WARs
Creating Spring Boot Apps as a Service
Spring Boot with Docker
Chapter 13# Spring Boot in the Cloud
The Cloud and Cloud-Native Architectures
Twelve-Factor Applications
Microservices
Cloud Foundry
Pivotal Cloud Foundry
Chapter 14# Extending Spring Boot Apps
Custom Spring Boot Module
Custom Health Indicator

Spring Boot Starters

Spring Boot Starter dependencies greatly simplify the dependencies section of your project’s build
specification by aggregating commonly used dependencies under more coarse-grained (having a
large) dependencies. Your build will transitively resolve the dependencies that are declared in the
starter dependency. Your build will transitively resolve the dependencies that are declared in the
starter dependency.
Not only do starter dependencies keep the dependencies section of the build smaller, they are
typically organized by the type of functionality they bring to an application. For example rather than

67
specify libraries required for validation (such as Hibernate Validator and Tomcat embedded
expression language), you can simply add the spring-boot-starter-validator starter as a dependency.
Below table shows list of Spring Boot starter dependencies along with the dependencies that they
transitively declare.
Starter Transitively depends on
(Group ID: org.springframework.boot)
spring-boot-starter org.springframework.boot:spring-boot
org.springframework.boot:spring-boot-
autoconfigure
org.springframework.boot:spring-boot-
starter-logging
org.springframework:spring-core
(excludes commons-logging:commons-logging
org.yaml:snakeyaml
spring-boot-starter-actuator org.springframework.boot:spring-boot-
starter
org.springframework.boot:spring-boot-
actuator
spring-boot-starter-amqp org.springframework.boot:spring-boot-
starter
■ org.springframework:spring-messaging
■ org.springframework.amqp:spring-rabbit
spring-boot-starter-aop org.springframework.boot:spring-boot-
starter
■ org.springframework:spring-aop
■ org.aspectj:aspectjrt
■ org.aspectj:aspectjweaver
spring-boot-starter-artemis org.springframework.boot:spring-boot-
starter
■ org.springframework:spring-jms
■ org.apache.activemq:artemis-jms-client
spring-boot-starter-batch org.springframework.boot:spring-boot-
starter
■ org.hsqldb:hsqldb
■ org.springframework:spring-jdbc
■ org.springframework.batch:spring-batch-
core
spring-boot-starter-cache org.springframework.boot:spring-boot-
starter
■ org.springframework:spring-context
■ org.springframework:spring-context-
support
spring-boot-starter-cloud-connectors org.springframework.boot:spring-boot-
starter
■ org.springframework.cloud:spring-
cloud-spring-service-connector
■ org.springframework.cloud:spring-
cloud-cloudfoundry-connector
■ org.springframework.cloud:spring-
cloud-heroku-connector

68
 ■ org.springframework.cloud:spring-cloud-
localconfig-connector
spring-boot-starter-data-elasticsearch org.springframework.boot:spring-boot-
starter
■ org.springframework.data:spring-data-
elasticsearch
spring-boot-starter-data-gemfire org.springframework.boot:spring-boot-
starter
■ com.gemstone.gemfire:gemfire
(excludes commons-logging:commons-
logging)
■ org.springframework.data:spring-data-
gemfire
spring-boot-starter-data-jpa org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-aop
■ org.springframework.boot:spring-boot-
starter-jdbc
■ org.hibernate:hibernate-entitymanager
(excludes
org.jboss.spec.javax.transaction:jboss-
transaction-api_1.2_spec)
■ javax.transaction:javax.transaction-
api
■ org.springframework.data:spring-data-
jpa
■ org.springframework:spring-aspects
spring-boot-starter-data-mongodb org.springframework.boot:spring-boot-
starter
■ org.mongodb:mongo-java-driver
■ org.springframework.data:spring-data-
mongodb
spring-boot-starter-data-rest org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-web
■ com.fasterxml.jackson.core:jackson-
annotations
■ com.fasterxml.jackson.core:jackson-
databind
■ org.springframework.data:spring-data-
rest-webmvc
spring-boot-starter-data-solr org.springframework.boot:spring-boot-
starter
■ org.apache.solr:solr-solrj (excludes
log4j:log4j)
■ org.springframework.data:spring-data-
solr
■ org.apache.httpcomponents:httpmime
spring-boot-starter-freemarker org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-web
■ org.freemarker:freemarker

69
 ■ org.springframework:spring-context-
support
spring-boot-starter-groovy-templates org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-web
■ org.codehaus.groovy:groovy-templates
spring-boot-starter-hateoas org.springframework.boot:spring-boot-
starter-web
■ org.springframework.hateoas:spring-
hateoas
■ org.springframework.plugin:spring-
plugin-core
spring-boot-starter-hornetq org.springframework.boot:spring-boot-
starter
■ org.springframework:spring-jms
■ org.hornetq:hornetq-jms-client
spring-boot-starter-integration org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-aop
■
org.springframework.integration:spring-
integration-core
■
org.springframework.integration:spring-
integration-file
■
org.springframework.integration:spring-
integration-http
■
org.springframework.integration:spring-
integration-ip
■ org.springframework.integration:spring-
integration-stream
spring-boot-starter-jdbc org.springframework.boot:spring-boot-
starter
■ org.apache.tomcat:tomcat-jdbc
■ org.springframework:spring-jdbc
spring-boot-starter-jersey org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-tomcat
■ org.springframework.boot:spring-boot-
starter-validation
■ com.fasterxml.jackson.core:jackson-
databind
■ org.springframework:spring-web
■ org.glassfish.jersey.core:jersey-
server
■
org.glassfish.jersey.containers:jersey-
container-servlet-core
■
org.glassfish.jersey.containers:jersey-
container-servlet

70
 ■ org.glassfish.jersey.ext:jersey-bean-
validation
(excludes javax.el:javax.el-api,
org.glassfish.web:javax.el)
■ org.glassfish.jersey.ext:jersey-
spring3
■ org.glassfish.jersey.media:jersey-
media-json-jackson
spring-boot-starter-jetty org.eclipse.jetty:jetty-servlets
■ org.eclipse.jetty:jetty-webapp
■ org.eclipse.jetty.websocket:websocket-
server
■ org.eclipse.jetty.websocket:javax-
websocket-server-impl
spring-boot-starter-jooq org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-jdbc
■ org.springframework:spring-tx
■ org.jooq:jooq
spring-boot-starter-jta-atomikos org.springframework.boot:spring-boot-
starter
■ com.atomikos:transactions-jms
■ com.atomikos:transactions-jta
(excludes
org.apache.geronimo.specs:geronimo-
jta_1.0.1B_spec)
■ com.atomikos:transactions-jdbc
■ javax.transaction:javax.transaction-api
spring-boot-starter-jta-bitronix org.springframework.boot:spring-boot-
starter
■ javax.jms:jms-api
■ javax.transaction:javax.transaction-
api
■ org.codehaus.btm:btm (excludes
javax.transaction:jta)
spring-boot-starter-log4j org.slf4j:jcl-over-slf4j
■ org.slf4j:jul-to-slf4j
■ org.slf4j:slf4j-log4j12
■ log4j:log4j
spring-boot-starter-log4j2 org.apache.logging.log4j:log4j-slf4j-
impl
■ org.apache.logging.log4j:log4j-api
■ org.apache.logging.log4j:log4j-core
■ org.slf4j:jcl-over-slf4j
■ org.slf4j:jul-to-slf4j
spring-boot-starter-logging ch.qos.logback:logback-classic
■ org.slf4j:jcl-over-slf4j
■ org.slf4j:jul-to-slf4j
■ org.slf4j:log4j-over-slf4j
spring-boot-starter-mail org.springframework.boot:spring-boot-
starter
■ org.springframework:spring-context
■ org.springframework:spring-context-
support

71
 ■ com.sun.mail:javax.mail
spring-boot-starter-mobile org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-web
■ org.springframework.mobile:spring-
mobile-device
spring-boot-starter-mustache org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-web
■ com.samskivert:jmustache
spring-boot-starter-redis org.springframework.boot:spring-boot-
starter
■ org.springframework.data:spring-data-
redis
■ redis.clients:jedis
spring-boot-starter-remote-shell org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-actuator
■ org.crashub:crash.cli
■ org.crashub:crash.connectors.ssh
(excludes org.codehaus.groovy:groovy-
all)
■ org.crashub:crash.connectors.telnet
(excludes javax.servlet:servlet-api,
log4j
:log4j, commons-logging:commons-logging)
■ org.crashub:crash.embed.spring
(excludes org.springframework:spring-
web, org.codehaus.groovy:groovy-all)
■ org.crashub:crash.plugins.cron
(excludes org.codehaus.groovy:groovy-
all)
■ org.crashub:crash.plugins.mail
(excludes org.codehaus.groovy:groovy-
all)
■ org.crashub:crash.shell (excludes
org.codehaus.groovy:groovy-all)
■ org.codehaus.groovy:groovy
spring-boot-starter-security org.springframework.boot:spring-boot-
starter
■ org.springframework:spring-aop
■ org.springframework.security:spring-
security-config
■ org.springframework.security:spring-
security-web
spring-boot-starter-social-facebook org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-web
■ org.springframework.social:spring-
social-config
■ org.springframework.social:spring-
social-core

72
 ■ org.springframework.social:spring-
social-web
■ org.springframework.social:spring-
social-facebook
spring-boot-starter-social-linkedin org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-web
■ org.springframework.social:spring-
social-config
■ org.springframework.social:spring-
social-core
■ org.springframework.social:spring-
social-web
■ org.springframework.social:spring-
social-linkedin
spring-boot-starter-social-twitter org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-web
■ org.springframework.social:spring-
social-config
■ org.springframework.social:spring-
social-core
■ org.springframework.social:spring-
social-web
■ org.springframework.social:spring-
social-twitter
spring-boot-starter-test junit:junit
■ org.mockito:mockito-core
■ org.hamcrest:hamcrest-core
■ org.hamcrest:hamcrest-library
■ org.springframework:spring-core
(excludes commons-logging:commons-
logging)
■ org.springframework:spring-test
spring-boot-starter-thymeleaf org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-web
■ org.thymeleaf:thymeleaf-spring4
■ nz.net.ultraq.thymeleaf:thymeleaf-
layout-dialect
spring-boot-starter-tomcat org.apache.tomcat.embed:tomcat-embed-
core
■ org.apache.tomcat.embed:tomcat-embed-
el
■ org.apache.tomcat.embed:tomcat-embed-
logging-juli
■ org.apache.tomcat.embed:tomcat-embed-
websocket
spring-boot-starter-undertow io.undertow:undertow-core
■ io.undertow:undertow-servlet
(excludes
org.jboss.spec.javax.servlet:jboss-
servlet-api_3.1_spec)

73
 ■ io.undertow:undertow-websockets-jsr
■ javax.servlet:javax.servlet-api
■ org.glassfish:javax.el
spring-boot-starter-validation org.springframework.boot:spring-boot-
starter
■ org.apache.tomcat.embed:tomcat-embed-
el
■ org.hibernate:hibernate-validator
spring-boot-starter-velocity org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-web
■ commons-beanutils:commons-beanutils
■ commons-collections:commons-
collections
■ commons-digester:commons-digester
■ org.apache.velocity:velocity
■ org.apache.velocity:velocity-tools
■ org.springframework:spring-context-
support
spring-boot-starter-web org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-tomcat
■ org.springframework.boot:spring-boot-
starter-validation
■ com.fasterxml.jackson.core:jackson-
databind
■ org.springframework:spring-web
■ org.springframework:spring-webmvc
spring-boot-starter-websocket org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-web
■ org.springframework:spring-messaging
■ org.springframework:spring-websocket
spring-boot-starter-ws org.springframework.boot:spring-boot-
starter
■ org.springframework.boot:spring-boot-
starter-web
■ org.springframework:spring-jms
■ org.springframework:spring-oxm
■ org.springframework.ws:spring-ws-core
■ org.springframework.ws:spring-ws-
support

74
Spring application.properties file properties (This is for
off-line reference)
# ===================================================================
# COMMON SPRING BOOT PROPERTIES
#
# This sample file is provided as a guideline. Do NOT copy it in its
# entirety to your own application. ^^^
# ===================================================================

# ----------------------------------------

75
# CORE PROPERTIES
# ----------------------------------------
debug=false # Enable debug logs.
trace=false # Enable trace logs.

# LOGGING
logging.config= # Location of the logging configuration file. For instance,
`classpath:logback.xml` for Logback.
logging.exception-conversion-word=%wEx # Conversion word used when logging
exceptions.
logging.file= # Log file name (for instance, `myapp.log`). Names can be an
exact location or relative to the current directory.
logging.file.max-history=0 # Maximum of archive log files to keep. Only
supported with the default logback setup.
logging.file.max-size=10MB # Maximum log file size. Only supported with the
default logback setup.
logging.level.*= # Log levels severity mapping. For instance,
`logging.level.org.springframework=DEBUG`.
logging.path= # Location of the log file. For instance, `/var/log`.
logging.pattern.console= # Appender pattern for output to the console.
Supported only with the default Logback setup.
logging.pattern.dateformat=yyyy-MM-dd HH:mm:ss.SSS # Appender pattern for
log date format. Supported only with the default Logback setup.
logging.pattern.file= # Appender pattern for output to a file. Supported
only with the default Logback setup.
logging.pattern.level=%5p # Appender pattern for log level. Supported only
with the default Logback setup.
logging.register-shutdown-hook=false # Register a shutdown hook for the
logging system when it is initialized.

# AOP
spring.aop.auto=true # Add @EnableAspectJAutoProxy.
spring.aop.proxy-target-class=true # Whether subclass-based (CGLIB) proxies
are to be created (true), as opposed to standard Java interface-based
proxies (false).

# IDENTITY (ContextIdApplicationContextInitializer)
spring.application.name= # Application name.

# ADMIN (SpringApplicationAdminJmxAutoConfiguration)
spring.application.admin.enabled=false # Whether to enable admin features
for the application.
spring.application.admin.jmx-
name=org.springframework.boot:type=Admin,name=SpringApplication # JMX name
of the application admin MBean.

# AUTO-CONFIGURATION
spring.autoconfigure.exclude= # Auto-configuration classes to exclude.

# BANNER
spring.banner.charset=UTF-8 # Banner file encoding.
spring.banner.location=classpath:banner.txt # Banner text resource
location.
spring.banner.image.location=classpath:banner.gif # Banner image file
location (jpg or png can also be used).
spring.banner.image.width=76 # Width of the banner image in chars.
spring.banner.image.height= # Height of the banner image in chars (default
based on image height).
spring.banner.image.margin=2 # Left hand image margin in chars.
spring.banner.image.invert=false # Whether images should be inverted for
dark terminal themes.

76
# SPRING CORE
spring.beaninfo.ignore=true # Whether to skip search of BeanInfo classes.

# SPRING CACHE (CacheProperties)

spring.cache.cache-names= # Comma-separated list of cache names to create
if supported by the underlying cache manager.
spring.cache.caffeine.spec= # The spec to use to create caches. See
CaffeineSpec for more details on the spec format.
spring.cache.couchbase.expiration=0ms # Entry expiration. By default the
entries never expire. Note that this value is ultimately converted to
seconds.
spring.cache.ehcache.config= # The location of the configuration file to
use to initialize EhCache.
spring.cache.infinispan.config= # The location of the configuration file to
use to initialize Infinispan.
spring.cache.jcache.config= # The location of the configuration file to use
to initialize the cache manager.
spring.cache.jcache.provider= # Fully qualified name of the CachingProvider
implementation to use to retrieve the JSR-107 compliant cache manager.
Needed only if more than one JSR-107 implementation is available on the
classpath.
spring.cache.redis.cache-null-values=true # Allow caching null values.
spring.cache.redis.key-prefix= # Key prefix.
spring.cache.redis.time-to-live=0ms # Entry expiration. By default the
entries never expire.
spring.cache.redis.use-key-prefix=true # Whether to use the key prefix when
writing to Redis.
spring.cache.type= # Cache type. By default, auto-detected according to the
environment.

# SPRING CONFIG - using environment property only

(ConfigFileApplicationListener)
spring.config.additional-location= # Config file locations used in addition
to the defaults.
spring.config.location= # Config file locations that replace the defaults.
spring.config.name=application # Config file name.

# HAZELCAST (HazelcastProperties)
spring.hazelcast.config= # The location of the configuration file to use to
initialize Hazelcast.

# PROJECT INFORMATION (ProjectInfoProperties)

spring.info.build.location=classpath:META-INF/build-info.properties #
Location of the generated build-info.properties file.
spring.info.git.location=classpath:git.properties # Location of the
generated git.properties file.

# JMX
spring.jmx.default-domain= # JMX domain name.
spring.jmx.enabled=true # Expose management beans to the JMX domain.
spring.jmx.server=mbeanServer # MBeanServer bean name.

# Email (MailProperties)
spring.mail.default-encoding=UTF-8 # Default MimeMessage encoding.
spring.mail.host= # SMTP server host. For instance, `smtp.example.com`.
spring.mail.jndi-name= # Session JNDI name. When set, takes precedence over
other mail settings.
spring.mail.password= # Login password of the SMTP server.
spring.mail.port= # SMTP server port.
spring.mail.properties.*= # Additional JavaMail session properties.

77
spring.mail.protocol=smtp # Protocol used by the SMTP server.
spring.mail.test-connection=false # Whether to test that the mail server is
available on startup.
spring.mail.username= # Login user of the SMTP server.

# APPLICATION SETTINGS (SpringApplication)

spring.main.banner-mode=console # Mode used to display the banner when the
application runs.
spring.main.sources= # Sources (class names, package names, or XML resource
locations) to include in the ApplicationContext.
spring.main.web-application-type= # Flag to explicitly request a specific
type of web application. If not set, auto-detected based on the classpath.

# FILE ENCODING (FileEncodingApplicationListener)

spring.mandatory-file-encoding= # Expected character encoding the
application must use.

# INTERNATIONALIZATION (MessageSourceProperties)
spring.messages.always-use-message-format=false # Whether to always apply
the MessageFormat rules, parsing even messages without arguments.
spring.messages.basename=messages # Comma-separated list of basenames
(essentially a fully-qualified classpath location), each following the
ResourceBundle convention with relaxed support for slash based locations.
spring.messages.cache-duration= # Loaded resource bundle files cache
duration. When not set, bundles are cached forever. If a duration suffix is
not specified, seconds will be used.
spring.messages.encoding=UTF-8 # Message bundles encoding.
spring.messages.fallback-to-system-locale=true # Whether to fall back to
the system Locale if no files for a specific Locale have been found.
spring.messages.use-code-as-default-message=false # Whether to use the
message code as the default message instead of throwing a
"NoSuchMessageException". Recommended during development only.

# OUTPUT
spring.output.ansi.enabled=detect # Configures the ANSI output.

# PID FILE (ApplicationPidFileWriter)

spring.pid.fail-on-write-error= # Fails if ApplicationPidFileWriter is used
but it cannot write the PID file.
spring.pid.file= # Location of the PID file to write (if
ApplicationPidFileWriter is used).

# PROFILES
spring.profiles.active= # Comma-separated list of active profiles. Can be
overridden by a command line switch.
spring.profiles.include= # Unconditionally activate the specified comma-
separated list of profiles (or list of profiles if using YAML).

# QUARTZ SCHEDULER (QuartzProperties)

spring.quartz.jdbc.initialize-schema=embedded # Database schema
initialization mode.
spring.quartz.jdbc.schema=classpath:org/quartz/impl/jdbcjobstore/tables_@@p
latform@@.sql # Path to the SQL file to use to initialize the database
schema.
spring.quartz.job-store-type=memory # Quartz job store type.
spring.quartz.properties.*= # Additional Quartz Scheduler properties.

# REACTOR (ReactorCoreProperties)
spring.reactor.stacktrace-mode.enabled=false # Whether Reactor should
collect stacktrace information at runtime.

78
# SENDGRID (SendGridAutoConfiguration)
spring.sendgrid.api-key= # SendGrid API key.
spring.sendgrid.proxy.host= # SendGrid proxy host.
spring.sendgrid.proxy.port= # SendGrid proxy port.

# ----------------------------------------
# WEB PROPERTIES
# ----------------------------------------

# EMBEDDED SERVER CONFIGURATION (ServerProperties)

server.address= # Network address to which the server should bind.
server.compression.enabled=false # Whether response compression is enabled.
server.compression.excluded-user-agents= # List of user-agents to exclude
from compression.
server.compression.mime-
types=text/html,text/xml,text/plain,text/css,text/javascript,application/ja
vascript # Comma-separated list of MIME types that should be compressed.
server.compression.min-response-size=2048 # Minimum "Content-Length" value
that is required for compression to be performed.
server.connection-timeout= # Time that connectors wait for another HTTP
request before closing the connection. When not set, the connector's
container-specific default is used. Use a value of -1 to indicate no (that
is, an infinite) timeout.
server.error.include-exception=false # Include the "exception" attribute.
server.error.include-stacktrace=never # When to include a "stacktrace"
attribute.
server.error.path=/error # Path of the error controller.
server.error.whitelabel.enabled=true # Whether to enable the default error
page displayed in browsers in case of a server error.
server.http2.enabled=false # Whether to enable HTTP/2 support, if the
current environment supports it.
server.jetty.acceptors= # Number of acceptor threads to use.
server.jetty.accesslog.append=false # Append to log.
server.jetty.accesslog.date-format=dd/MMM/yyyy:HH:mm:ss Z # Timestamp
format of the request log.
server.jetty.accesslog.enabled=false # Enable access log.
server.jetty.accesslog.extended-format=false # Enable extended NCSA format.
server.jetty.accesslog.file-date-format= # Date format to place in log file
name.
server.jetty.accesslog.filename= # Log filename. If not specified, logs
redirect to "System.err".
server.jetty.accesslog.locale= # Locale of the request log.
server.jetty.accesslog.log-cookies=false # Enable logging of the request
cookies.
server.jetty.accesslog.log-latency=false # Enable logging of request
processing time.
server.jetty.accesslog.log-server=false # Enable logging of the request
hostname.
server.jetty.accesslog.retention-period=31 # Number of days before rotated
log files are deleted.
server.jetty.accesslog.time-zone=GMT # Timezone of the request log.
server.jetty.max-http-post-size=0 # Maximum size, in bytes, of the HTTP
post or put content.
server.jetty.selectors= # Number of selector threads to use.
server.max-http-header-size=0 # Maximum size, in bytes, of the HTTP message
header.
server.port=8080 # Server HTTP port.
server.server-header= # Value to use for the Server response header (if
empty, no header is sent).

79
server.use-forward-headers= # Whether X-Forwarded-* headers should be
applied to the HttpRequest.
server.servlet.context-parameters.*= # Servlet context init parameters.
server.servlet.context-path= # Context path of the application.
server.servlet.application-display-name=application # Display name of the
application.
server.servlet.jsp.class-name=org.apache.jasper.servlet.JspServlet # The
class name of the JSP servlet.
server.servlet.jsp.init-parameters.*= # Init parameters used to configure
the JSP servlet.
server.servlet.jsp.registered=true # Whether the JSP servlet is registered.
server.servlet.path=/ # Path of the main dispatcher servlet.
server.servlet.session.cookie.comment= # Comment for the session cookie.
server.servlet.session.cookie.domain= # Domain for the session cookie.
server.servlet.session.cookie.http-only= # "HttpOnly" flag for the session
cookie.
server.servlet.session.cookie.max-age= # Maximum age of the session cookie.
If a duration suffix is not specified, seconds will be used.
server.servlet.session.cookie.name= # Session cookie name.
server.servlet.session.cookie.path= # Path of the session cookie.
server.servlet.session.cookie.secure= # "Secure" flag for the session
cookie.
server.servlet.session.persistent=false # Whether to persist session data
between restarts.
server.servlet.session.store-dir= # Directory used to store session data.
server.servlet.session.timeout= # Session timeout. If a duration suffix is
not specified, seconds will be used.
server.servlet.session.tracking-modes= # Session tracking modes (one or
more of the following: "cookie", "url", "ssl").
server.ssl.ciphers= # Supported SSL ciphers.
server.ssl.client-auth= # Whether client authentication is wanted ("want")
or needed ("need"). Requires a trust store.
server.ssl.enabled= # Enable SSL support.
server.ssl.enabled-protocols= # Enabled SSL protocols.
server.ssl.key-alias= # Alias that identifies the key in the key store.
server.ssl.key-password= # Password used to access the key in the key
store.
server.ssl.key-store= # Path to the key store that holds the SSL
certificate (typically a jks file).
server.ssl.key-store-password= # Password used to access the key store.
server.ssl.key-store-provider= # Provider for the key store.
server.ssl.key-store-type= # Type of the key store.
server.ssl.protocol=TLS # SSL protocol to use.
server.ssl.trust-store= # Trust store that holds SSL certificates.
server.ssl.trust-store-password= # Password used to access the trust store.
server.ssl.trust-store-provider= # Provider for the trust store.
server.ssl.trust-store-type= # Type of the trust store.
server.tomcat.accept-count=0 # Maximum queue length for incoming connection
requests when all possible request processing threads are in use.
server.tomcat.accesslog.buffered=true # Whether to buffer output such that
it is flushed only periodically.
server.tomcat.accesslog.directory=logs # Directory in which log files are
created. Can be absolute or relative to the Tomcat base dir.
server.tomcat.accesslog.enabled=false # Enable access log.
server.tomcat.accesslog.file-date-format=.yyyy-MM-dd # Date format to place
in the log file name.
server.tomcat.accesslog.pattern=common # Format pattern for access logs.
server.tomcat.accesslog.prefix=access_log # Log file name prefix.
server.tomcat.accesslog.rename-on-rotate=false # Whether to defer inclusion
of the date stamp in the file name until rotate time.

80
server.tomcat.accesslog.request-attributes-enabled=false # Set request
attributes for the IP address, Hostname, protocol, and port used for the
request.
server.tomcat.accesslog.rotate=true # Whether to enable access log
rotation.
server.tomcat.accesslog.suffix=.log # Log file name suffix.
server.tomcat.additional-tld-skip-patterns= # Comma-separated list of
additional patterns that match jars to ignore for TLD scanning.
server.tomcat.background-processor-delay=30s # Delay between the invocation
of backgroundProcess methods. If a duration suffix is not specified,
seconds will be used.
server.tomcat.basedir= # Tomcat base directory. If not specified, a
temporary directory is used.
server.tomcat.internal-proxies=10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}|\\
192\\.168\\.\\d{1,3}\\.\\d{1,3}|\\
169\\.254\\.\\d{1,3}\\.\\d{1,3}|\\
127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}|\\
172\\.1[6-9]{1}\\.\\d{1,3}\\.\\d{1,3}|\\
172\\.2[0-9]{1}\\.\\d{1,3}\\.\\d{1,3}|\\
172\\.3[0-1]{1}\\.\\d{1,3}\\.\\d{1,3} # Regular expression
matching trusted IP addresses.
server.tomcat.max-connections=0 # Maximum number of connections that the
server accepts and processes at any given time.
server.tomcat.max-http-header-size=0 # Maximum size, in bytes, of the HTTP
message header.
server.tomcat.max-http-post-size=0 # Maximum size, in bytes, of the HTTP
post content.
server.tomcat.max-threads=0 # Maximum number of worker threads.
server.tomcat.min-spare-threads=0 # Minimum number of worker threads.
server.tomcat.port-header=X-Forwarded-Port # Name of the HTTP header used
to override the original port value.
server.tomcat.protocol-header= # Header that holds the incoming protocol,
usually named "X-Forwarded-Proto".
server.tomcat.protocol-header-https-value=https # Value of the protocol
header indicating whether the incoming request uses SSL.
server.tomcat.redirect-context-root= # Whether requests to the context root
should be redirected by appending a / to the path.
server.tomcat.remote-ip-header= # Name of the HTTP header from which the
remote IP is extracted. For instance, `X-FORWARDED-FOR`.
server.tomcat.resource.cache-ttl= # Time-to-live of the static resource
cache.
server.tomcat.uri-encoding=UTF-8 # Character encoding to use to decode the
URI.
server.tomcat.use-relative-redirects= # Whether HTTP 1.1 and later location
headers generated by a call to sendRedirect will use relative or absolute
redirects.
server.undertow.accesslog.dir= # Undertow access log directory.
server.undertow.accesslog.enabled=false # Whether to enable the access log.
server.undertow.accesslog.pattern=common # Format pattern for access logs.
server.undertow.accesslog.prefix=access_log. # Log file name prefix.
server.undertow.accesslog.rotate=true # Whether to enable access log
rotation.
server.undertow.accesslog.suffix=log # Log file name suffix.
server.undertow.buffer-size= # Size of each buffer, in bytes.
server.undertow.direct-buffers= # Whether to allocate buffers outside the
Java heap.
server.undertow.io-threads= # Number of I/O threads to create for the
worker.
server.undertow.eager-filter-init=true # Whether servlet filters should be
initialized on startup.

81
server.undertow.max-http-post-size=0 # Maximum size, in bytes, of the HTTP
post content.
server.undertow.worker-threads= # Number of worker threads.

# FREEMARKER (FreeMarkerProperties)
spring.freemarker.allow-request-override=false # Whether HttpServletRequest
attributes are allowed to override (hide) controller generated model
attributes of the same name.
spring.freemarker.allow-session-override=false # Whether HttpSession
attributes are allowed to override (hide) controller generated model
attributes of the same name.
spring.freemarker.cache=false # Whether to enable template caching.
spring.freemarker.charset=UTF-8 # Template encoding.
spring.freemarker.check-template-location=true # Whether to check that the
templates location exists.
spring.freemarker.content-type=text/html # Content-Type value.
spring.freemarker.enabled=true # Whether to enable MVC view resolution for
this technology.
spring.freemarker.expose-request-attributes=false # Whether all request
attributes should be added to the model prior to merging with the template.
spring.freemarker.expose-session-attributes=false # Whether all HttpSession
attributes should be added to the model prior to merging with the template.
spring.freemarker.expose-spring-macro-helpers=true # Whether to expose a
RequestContext for use by Spring's macro library, under the name
"springMacroRequestContext".
spring.freemarker.prefer-file-system-access=true # Whether to prefer file
system access for template loading. File system access enables hot
detection of template changes.
spring.freemarker.prefix= # Prefix that gets prepended to view names when
building a URL.
spring.freemarker.request-context-attribute= # Name of the RequestContext
attribute for all views.
spring.freemarker.settings.*= # Well-known FreeMarker keys which are passed
to FreeMarker's Configuration.
spring.freemarker.suffix=.ftl # Suffix that gets appended to view names
when building a URL.
spring.freemarker.template-loader-path=classpath:/templates/ # Comma-
separated list of template paths.
spring.freemarker.view-names= # White list of view names that can be
resolved.

# GROOVY TEMPLATES (GroovyTemplateProperties)

spring.groovy.template.allow-request-override=false # Whether
HttpServletRequest attributes are allowed to override (hide) controller
generated model attributes of the same name.
spring.groovy.template.allow-session-override=false # Whether HttpSession
attributes are allowed to override (hide) controller generated model
attributes of the same name.
spring.groovy.template.cache=false # Whether to enable template caching.
spring.groovy.template.charset=UTF-8 # Template encoding.
spring.groovy.template.check-template-location=true # Whether to check that
the templates location exists.
spring.groovy.template.configuration.*= # See GroovyMarkupConfigurer
spring.groovy.template.content-type=text/html # Content-Type value.
spring.groovy.template.enabled=true # Whether to enable MVC view resolution
for this technology.
spring.groovy.template.expose-request-attributes=false # Whether all
request attributes should be added to the model prior to merging with the
template.

82
spring.groovy.template.expose-session-attributes=false # Whether all
HttpSession attributes should be added to the model prior to merging with
the template.
spring.groovy.template.expose-spring-macro-helpers=true # Whether to expose
a RequestContext for use by Spring's macro library, under the name
"springMacroRequestContext".
spring.groovy.template.prefix= # Prefix that gets prepended to view names
when building a URL.
spring.groovy.template.request-context-attribute= # Name of the
RequestContext attribute for all views.
spring.groovy.template.resource-loader-path=classpath:/templates/ #
Template path.
spring.groovy.template.suffix=.tpl # Suffix that gets appended to view
names when building a URL.
spring.groovy.template.view-names= # White list of view names that can be
resolved.

# SPRING HATEOAS (HateoasProperties)

spring.hateoas.use-hal-as-default-json-media-type=true # Whether
application/hal+json responses should be sent to requests that accept
application/json.

# HTTP message conversion

spring.http.converters.preferred-json-mapper= # Preferred JSON mapper to
use for HTTP message conversion. By default, auto-detected according to the
environment.

# HTTP encoding (HttpEncodingProperties)

spring.http.encoding.charset=UTF-8 # Charset of HTTP requests and
responses. Added to the "Content-Type" header if not set explicitly.
spring.http.encoding.enabled=true # Whether to enable http encoding
support.
spring.http.encoding.force= # Whether to force the encoding to the
configured charset on HTTP requests and responses.
spring.http.encoding.force-request= # Whether to force the encoding to the
configured charset on HTTP requests. Defaults to true when "force" has not
been specified.
spring.http.encoding.force-response= # Whether to force the encoding to the
configured charset on HTTP responses.
spring.http.encoding.mapping= # Locale in which to encode mapping.

# MULTIPART (MultipartProperties)
spring.servlet.multipart.enabled=true # Whether to enable support of
multipart uploads.
spring.servlet.multipart.file-size-threshold=0 # Threshold after which
files are written to disk. Values can use the suffixes "MB" or "KB" to
indicate megabytes or kilobytes, respectively.
spring.servlet.multipart.location= # Intermediate location of uploaded
files.
spring.servlet.multipart.max-file-size=1MB # Max file size. Values can use
the suffixes "MB" or "KB" to indicate megabytes or kilobytes, respectively.
spring.servlet.multipart.max-request-size=10MB # Max request size. Values
can use the suffixes "MB" or "KB" to indicate megabytes or kilobytes,
respectively.
spring.servlet.multipart.resolve-lazily=false # Whether to resolve the
multipart request lazily at the time of file or parameter access.

# JACKSON (JacksonProperties)
spring.jackson.date-format= # Date format string or a fully-qualified date
format class name. For instance, `yyyy-MM-dd HH:mm:ss`.

83
spring.jackson.default-property-inclusion= # Controls the inclusion of
properties during serialization. Configured with one of the values in
Jackson's JsonInclude.Include enumeration.
spring.jackson.deserialization.*= # Jackson on/off features that affect the
way Java objects are deserialized.
spring.jackson.generator.*= # Jackson on/off features for generators.
spring.jackson.joda-date-time-format= # Joda date time format string. If
not configured, "date-format" is used as a fallback if it is configured
with a format string.
spring.jackson.locale= # Locale used for formatting.
spring.jackson.mapper.*= # Jackson general purpose on/off features.
spring.jackson.parser.*= # Jackson on/off features for parsers.
spring.jackson.property-naming-strategy= # One of the constants on
Jackson's PropertyNamingStrategy. Can also be a fully-qualified class name
of a PropertyNamingStrategy subclass.
spring.jackson.serialization.*= # Jackson on/off features that affect the
way Java objects are serialized.
spring.jackson.time-zone= # Time zone used when formatting dates. For
instance, "America/Los_Angeles" or "GMT+10".

# GSON (GsonProperties)
spring.gson.date-format= # Format to use when serializing Date objects.
spring.gson.disable-html-escaping= # Whether to disable the escaping of
HTML characters such as '<', '>', etc.
spring.gson.disable-inner-class-serialization= # Whether to exclude inner
classes during serialization.
spring.gson.enable-complex-map-key-serialization= # Whether to enable
serialization of complex map keys (i.e. non-primitives).
spring.gson.exclude-fields-without-expose-annotation= # Whether to exclude
all fields from consideration for serialization or deserialization that do
not have the "Expose" annotation.
spring.gson.field-naming-policy= # Naming policy that should be applied to
an object's field during serialization and deserialization.
spring.gson.generate-non-executable-json= # Whether to generate non
executable JSON by prefixing the output with some special text.
spring.gson.lenient= # Whether to be lenient about parsing JSON that
doesn't conform to RFC 4627.
spring.gson.long-serialization-policy= # Serialization policy for Long and
long types.
spring.gson.pretty-printing= # Whether to output serialized JSON that fits
in a page for pretty printing.
spring.gson.serialize-nulls= # Whether to serialize null fields.

# JERSEY (JerseyProperties)
spring.jersey.application-path= # Path that serves as the base URI for the
application. If specified, overrides the value of "@ApplicationPath".
spring.jersey.filter.order=0 # Jersey filter chain order.
spring.jersey.init.*= # Init parameters to pass to Jersey through the
servlet or filter.
spring.jersey.servlet.load-on-startup=-1 # Load on startup priority of the
Jersey servlet.
spring.jersey.type=servlet # Jersey integration type.

# SPRING LDAP (LdapProperties)

spring.ldap.anonymous-read-only=false # Whether read-only operations should
use an anonymous environment.
spring.ldap.base= # Base suffix from which all operations should originate.
spring.ldap.base-environment.*= # LDAP specification settings.
spring.ldap.password= # Login password of the server.
spring.ldap.urls= # LDAP URLs of the server.
spring.ldap.username= # Login username of the server.

84
# EMBEDDED LDAP (EmbeddedLdapProperties)
spring.ldap.embedded.base-dn= # List of base DNs.
spring.ldap.embedded.credential.username= # Embedded LDAP username.
spring.ldap.embedded.credential.password= # Embedded LDAP password.
spring.ldap.embedded.ldif=classpath:schema.ldif # Schema (LDIF) script
resource reference.
spring.ldap.embedded.port=0 # Embedded LDAP port.
spring.ldap.embedded.validation.enabled=true # Whether to enable LDAP
schema validation.
spring.ldap.embedded.validation.schema= # Path to the custom schema.

# MUSTACHE TEMPLATES (MustacheAutoConfiguration)

spring.mustache.allow-request-override=false # Whether HttpServletRequest
attributes are allowed to override (hide) controller generated model
attributes of the same name.
spring.mustache.allow-session-override=false # Whether HttpSession
attributes are allowed to override (hide) controller generated model
attributes of the same name.
spring.mustache.cache=false # Whether to enable template caching.
spring.mustache.charset=UTF-8 # Template encoding.
spring.mustache.check-template-location=true # Whether to check that the
templates location exists.
spring.mustache.content-type=text/html # Content-Type value.
spring.mustache.enabled=true # Whether to enable MVC view resolution for
this technology.
spring.mustache.expose-request-attributes=false # Whether all request
attributes should be added to the model prior to merging with the template.
spring.mustache.expose-session-attributes=false # Whether all HttpSession
attributes should be added to the model prior to merging with the template.
spring.mustache.expose-spring-macro-helpers=true # Whether to expose a
RequestContext for use by Spring's macro library, under the name
"springMacroRequestContext".
spring.mustache.prefix=classpath:/templates/ # Prefix to apply to template
names.
spring.mustache.request-context-attribute= # Name of the RequestContext
attribute for all views.
spring.mustache.suffix=.mustache # Suffix to apply to template names.
spring.mustache.view-names= # White list of view names that can be
resolved.

# SPRING MVC (WebMvcProperties)

spring.mvc.async.request-timeout= # Amount of time before asynchronous
request handling times out.
spring.mvc.contentnegotiation.favor-parameter=false # Whether a request
parameter ("format" by default) should be used to determine the requested
media type.
spring.mvc.contentnegotiation.favor-path-extension=false # Whether the path
extension in the URL path should be used to determine the requested media
type.
spring.mvc.contentnegotiation.media-types.*= # Map file extensions to media
types for content negotiation. For instance, yml to text/yaml.
spring.mvc.contentnegotiation.parameter-name= # Query parameter name to use
when "favor-parameter" is enabled.
spring.mvc.date-format= # Date format to use. For instance, `dd/MM/yyyy`.
spring.mvc.dispatch-trace-request=false # Whether to dispatch TRACE
requests to the FrameworkServlet doService method.
spring.mvc.dispatch-options-request=true # Whether to dispatch OPTIONS
requests to the FrameworkServlet doService method.
spring.mvc.favicon.enabled=true # Whether to enable resolution of
favicon.ico.

85
spring.mvc.formcontent.putfilter.enabled=true # Whether to enable Spring's
HttpPutFormContentFilter.
spring.mvc.ignore-default-model-on-redirect=true # Whether the content of
the "default" model should be ignored during redirect scenarios.
spring.mvc.locale= # Locale to use. By default, this locale is overridden
by the "Accept-Language" header.
spring.mvc.locale-resolver=accept-header # Define how the locale should be
resolved.
spring.mvc.log-resolved-exception=false # Whether to enable warn logging of
exceptions resolved by a "HandlerExceptionResolver".
spring.mvc.message-codes-resolver-format= # Formatting strategy for message
codes. For instance, `PREFIX_ERROR_CODE`.
spring.mvc.pathmatch.use-registered-suffix-pattern=false # Whether suffix
pattern matching should work only against extensions registered with
"spring.mvc.contentnegotiation.media-types.*".
spring.mvc.pathmatch.use-suffix-pattern=false # Whether to use suffix
pattern match (".*") when matching patterns to requests.
spring.mvc.servlet.load-on-startup=-1 # Load on startup priority of the
dispatcher servlet.
spring.mvc.static-path-pattern=/** # Path pattern used for static
resources.
spring.mvc.throw-exception-if-no-handler-found=false # Whether a
"NoHandlerFoundException" should be thrown if no Handler was found to
process a request.
spring.mvc.view.prefix= # Spring MVC view prefix.
spring.mvc.view.suffix= # Spring MVC view suffix.

# SPRING RESOURCES HANDLING (ResourceProperties)

spring.resources.add-mappings=true # Whether to enable default resource
handling.
spring.resources.cache.cachecontrol.cache-private= # Indicate that the
response message is intended for a single user and must not be stored by a
shared cache.
spring.resources.cache.cachecontrol.cache-public= # Indicate that any cache
may store the response.
spring.resources.cache.cachecontrol.max-age= # Maximum time the response
should be cached, in seconds if no duration suffix is not specified.
spring.resources.cache.cachecontrol.must-revalidate= # Indicate that once
it has become stale, a cache must not use the response without re-
validating it with the server.
spring.resources.cache.cachecontrol.no-cache= # Indicate that the cached
response can be reused only if re-validated with the server.
spring.resources.cache.cachecontrol.no-store= # Indicate to not cache the
response in any case.
spring.resources.cache.cachecontrol.no-transform= # Indicate intermediaries
(caches and others) that they should not transform the response content.
spring.resources.cache.cachecontrol.proxy-revalidate= # Same meaning as the
"must-revalidate" directive, except that it does not apply to private
caches.
spring.resources.cache.cachecontrol.s-max-age= # Maximum time the response
should be cached by shared caches, in seconds if no duration suffix is not
specified.
spring.resources.cache.cachecontrol.stale-if-error= # Maximum time the
response may be used when errors are encountered, in seconds if no duration
suffix is not specified.
spring.resources.cache.cachecontrol.stale-while-revalidate= # Maximum time
the response can be served after it becomes stale, in seconds if no
duration suffix is not specified.
spring.resources.cache.period= # Cache period for the resources served by
the resource handler. If a duration suffix is not specified, seconds will
be used.

86
spring.resources.chain.cache=true # Whether to enable caching in the
Resource chain.
spring.resources.chain.enabled= # Whether to enable the Spring Resource
Handling chain. By default, disabled unless at least one strategy has been
enabled.
spring.resources.chain.gzipped=false # Whether to enable resolution of
already gzipped resources.
spring.resources.chain.html-application-cache=false # Whether to enable
HTML5 application cache manifest rewriting.
spring.resources.chain.strategy.content.enabled=false # Whether to enable
the content Version Strategy.
spring.resources.chain.strategy.content.paths=/** # Comma-separated list of
patterns to apply to the content Version Strategy.
spring.resources.chain.strategy.fixed.enabled=false # Whether to enable the
fixed Version Strategy.
spring.resources.chain.strategy.fixed.paths=/** # Comma-separated list of
patterns to apply to the fixed Version Strategy.
spring.resources.chain.strategy.fixed.version= # Version string to use for
the fixed Version Strategy.
spring.resources.static-locations=classpath:/META-
INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/
# Locations of static resources.

# SPRING SESSION (SessionProperties)

spring.session.store-type= # Session store type.
spring.session.servlet.filter-order=-2147483598 # Session repository filter
order.
spring.session.servlet.filter-dispatcher-types=async,error,request #
Session repository filter dispatcher types.

# SPRING SESSION HAZELCAST (HazelcastSessionProperties)

spring.session.hazelcast.flush-mode=on-save # Sessions flush mode.
spring.session.hazelcast.map-name=spring:session:sessions # Name of the map
used to store sessions.

# SPRING SESSION JDBC (JdbcSessionProperties)

spring.session.jdbc.cleanup-cron=0 * * * * * # Cron expression for expired
session cleanup job.
spring.session.jdbc.initialize-schema=embedded # Database schema
initialization mode.
spring.session.jdbc.schema=classpath:org/springframework/session/jdbc/schem
a-@@platform@@.sql # Path to the SQL file to use to initialize the database
schema.
spring.session.jdbc.table-name=SPRING_SESSION # Name of the database table
used to store sessions.

# SPRING SESSION MONGODB (MongoSessionProperties)

spring.session.mongodb.collection-name=sessions # Collection name used to
store sessions.

# SPRING SESSION REDIS (RedisSessionProperties)

spring.session.redis.cleanup-cron=0 * * * * * # Cron expression for expired
session cleanup job.
spring.session.redis.flush-mode=on-save # Sessions flush mode.
spring.session.redis.namespace=spring:session # Namespace for keys used to
store sessions.

# THYMELEAF (ThymeleafAutoConfiguration)
spring.thymeleaf.cache=true # Whether to enable template caching.
spring.thymeleaf.check-template=true # Whether to check that the template
exists before rendering it.

87
spring.thymeleaf.check-template-location=true # Whether to check that the
templates location exists.
spring.thymeleaf.enabled=true # Whether to enable Thymeleaf view resolution
for Web frameworks.
spring.thymeleaf.enable-spring-el-compiler=false # Enable the SpringEL
compiler in SpringEL expressions.
spring.thymeleaf.encoding=UTF-8 # Template files encoding.
spring.thymeleaf.excluded-view-names= # Comma-separated list of view names
(patterns allowed) that should be excluded from resolution.
spring.thymeleaf.mode=HTML # Template mode to be applied to templates. See
also Thymeleaf's TemplateMode enum.
spring.thymeleaf.prefix=classpath:/templates/ # Prefix that gets prepended
to view names when building a URL.
spring.thymeleaf.reactive.chunked-mode-view-names= # Comma-separated list
of view names (patterns allowed) that should be the only ones executed in
CHUNKED mode when a max chunk size is set.
spring.thymeleaf.reactive.full-mode-view-names= # Comma-separated list of
view names (patterns allowed) that should be executed in FULL mode even if
a max chunk size is set.
spring.thymeleaf.reactive.max-chunk-size=0 # Maximum size of data buffers
used for writing to the response, in bytes.
spring.thymeleaf.reactive.media-types= # Media types supported by the view
technology.
spring.thymeleaf.servlet.content-type=text/html # Content-Type value
written to HTTP responses.
spring.thymeleaf.suffix=.html # Suffix that gets appended to view names
when building a URL.
spring.thymeleaf.template-resolver-order= # Order of the template resolver
in the chain.
spring.thymeleaf.view-names= # Comma-separated list of view names (patterns
allowed) that can be resolved.

# SPRING WEBFLUX (WebFluxProperties)

spring.webflux.date-format= # Date format to use. For instance,
`dd/MM/yyyy`.
spring.webflux.static-path-pattern=/** # Path pattern used for static
resources.

# SPRING WEB SERVICES (WebServicesProperties)

spring.webservices.path=/services # Path that serves as the base URI for
the services.
spring.webservices.servlet.init= # Servlet init parameters to pass to
Spring Web Services.
spring.webservices.servlet.load-on-startup=-1 # Load on startup priority of
the Spring Web Services servlet.
spring.webservices.wsdl-locations= # Comma-separated list of locations of
WSDLs and accompanying XSDs to be exposed as beans.

# ----------------------------------------
# SECURITY PROPERTIES
# ----------------------------------------
# SECURITY (SecurityProperties)
spring.security.filter.order=-100 # Security filter chain order.
spring.security.filter.dispatcher-types=async,error,request # Security
filter chain dispatcher types.
spring.security.user.name=user # Default user name.
spring.security.user.password= # Password for the default user name.
spring.security.user.roles= # Granted roles for the default user name.

88
# SECURITY OAUTH2 CLIENT (OAuth2ClientProperties)
spring.security.oauth2.client.provider.*= # OAuth provider details.
spring.security.oauth2.client.registration.*= # OAuth client registrations.

# ----------------------------------------
# DATA PROPERTIES
# ----------------------------------------

# FLYWAY (FlywayProperties)
spring.flyway.baseline-description= #
spring.flyway.baseline-on-migrate= #
spring.flyway.baseline-version=1 # Version to start migration
spring.flyway.check-location=true # Whether to check that migration scripts
location exists.
spring.flyway.clean-disabled= #
spring.flyway.clean-on-validation-error= #
spring.flyway.dry-run-output= #
spring.flyway.enabled=true # Whether to enable flyway.
spring.flyway.encoding= #
spring.flyway.error-handlers= #
spring.flyway.group= #
spring.flyway.ignore-future-migrations= #
spring.flyway.ignore-missing-migrations= #
spring.flyway.init-sqls= # SQL statements to execute to initialize a
connection immediately after obtaining it.
spring.flyway.installed-by= #
spring.flyway.locations=classpath:db/migration # The locations of
migrations scripts.
spring.flyway.mixed= #
spring.flyway.out-of-order= #
spring.flyway.password= # JDBC password to use if you want Flyway to create
its own DataSource.
spring.flyway.placeholder-prefix= #
spring.flyway.placeholder-replacement= #
spring.flyway.placeholder-suffix= #
spring.flyway.placeholders.*= #
spring.flyway.repeatable-sql-migration-prefix= #
spring.flyway.schemas= # schemas to update
spring.flyway.skip-default-callbacks= #
spring.flyway.skip-default-resolvers= #
spring.flyway.sql-migration-prefix=V #
spring.flyway.sql-migration-separator= #
spring.flyway.sql-migration-suffix=.sql #
spring.flyway.sql-migration-suffixes= #
spring.flyway.table= #
spring.flyway.target= #
spring.flyway.undo-sql-migration-prefix= #
spring.flyway.url= # JDBC url of the database to migrate. If not set, the
primary configured data source is used.
spring.flyway.user= # Login user of the database to migrate.
spring.flyway.validate-on-migrate= #

# LIQUIBASE (LiquibaseProperties)
spring.liquibase.change-log=classpath:/db/changelog/db.changelog-
master.yaml # Change log configuration path.
spring.liquibase.check-change-log-location=true # Whether to check that the
change log location exists.
spring.liquibase.contexts= # Comma-separated list of runtime contexts to
use.
spring.liquibase.default-schema= # Default database schema.

89
spring.liquibase.drop-first=false # Whether to first drop the database
schema.
spring.liquibase.enabled=true # Whether to enable Liquibase support.
spring.liquibase.labels= # Comma-separated list of runtime labels to use.
spring.liquibase.parameters.*= # Change log parameters.
spring.liquibase.password= # Login password of the database to migrate.
spring.liquibase.rollback-file= # File to which rollback SQL is written
when an update is performed.
spring.liquibase.url= # JDBC URL of the database to migrate. If not set,
the primary configured data source is used.
spring.liquibase.user= # Login user of the database to migrate.

# COUCHBASE (CouchbaseProperties)
spring.couchbase.bootstrap-hosts= # Couchbase nodes (host or IP address) to
bootstrap from.
spring.couchbase.bucket.name=default # Name of the bucket to connect to.
spring.couchbase.bucket.password= # Password of the bucket.
spring.couchbase.env.endpoints.key-value=1 # Number of sockets per node
against the key/value service.
spring.couchbase.env.endpoints.query=1 # Number of sockets per node against
the query (N1QL) service.
spring.couchbase.env.endpoints.view=1 # Number of sockets per node against
the view service.
spring.couchbase.env.ssl.enabled= # Whether to enable SSL support. Enabled
automatically if a "keyStore" is provided unless specified otherwise.
spring.couchbase.env.ssl.key-store= # Path to the JVM key store that holds
the certificates.
spring.couchbase.env.ssl.key-store-password= # Password used to access the
key store.
spring.couchbase.env.timeouts.connect=5000ms # Bucket connections timeouts.
spring.couchbase.env.timeouts.key-value=2500ms # Blocking operations
performed on a specific key timeout.
spring.couchbase.env.timeouts.query=7500ms # N1QL query operations timeout.
spring.couchbase.env.timeouts.socket-connect=1000ms # Socket connect
connections timeout.
spring.couchbase.env.timeouts.view=7500ms # Regular and geospatial view
operations timeout.

# DAO (PersistenceExceptionTranslationAutoConfiguration)
spring.dao.exceptiontranslation.enabled=true # Whether to enable the
PersistenceExceptionTranslationPostProcessor.

# CASSANDRA (CassandraProperties)
spring.data.cassandra.cluster-name= # Name of the Cassandra cluster.
spring.data.cassandra.compression=none # Compression supported by the
Cassandra binary protocol.
spring.data.cassandra.connect-timeout= # Socket option: connection time
out.
spring.data.cassandra.consistency-level= # Queries consistency level.
spring.data.cassandra.contact-points=localhost # Cluster node addresses.
spring.data.cassandra.fetch-size= # Queries default fetch size.
spring.data.cassandra.keyspace-name= # Keyspace name to use.
spring.data.cassandra.load-balancing-policy= # Class name of the load
balancing policy.
spring.data.cassandra.port= # Port of the Cassandra server.
spring.data.cassandra.password= # Login password of the server.
spring.data.cassandra.pool.heartbeat-interval=30s # Heartbeat interval
after which a message is sent on an idle connection to make sure it's still
alive. If a duration suffix is not specified, seconds will be used.

90
spring.data.cassandra.pool.idle-timeout=120s # Idle timeout before an idle
connection is removed. If a duration suffix is not specified, seconds will
be used.
spring.data.cassandra.pool.max-queue-size=256 # Maximum number of requests
that get queued if no connection is available.
spring.data.cassandra.pool.pool-timeout=5000ms # Pool timeout when trying
to acquire a connection from a host's pool.
spring.data.cassandra.read-timeout= # Socket option: read time out.
spring.data.cassandra.reconnection-policy= # Reconnection policy class.
spring.data.cassandra.repositories.type=auto # Type of Cassandra
repositories to enable.
spring.data.cassandra.retry-policy= # Class name of the retry policy.
spring.data.cassandra.serial-consistency-level= # Queries serial
consistency level.
spring.data.cassandra.schema-action=none # Schema action to take at
startup.
spring.data.cassandra.ssl=false # Enable SSL support.
spring.data.cassandra.username= # Login user of the server.

# DATA COUCHBASE (CouchbaseDataProperties)

spring.data.couchbase.auto-index=false # Automatically create views and
indexes.
spring.data.couchbase.consistency=read-your-own-writes # Consistency to
apply by default on generated queries.
spring.data.couchbase.repositories.type=auto # Type of Couchbase
repositories to enable.

# ELASTICSEARCH (ElasticsearchProperties)
spring.data.elasticsearch.cluster-name=elasticsearch # Elasticsearch
cluster name.
spring.data.elasticsearch.cluster-nodes= # Comma-separated list of cluster
node addresses.
spring.data.elasticsearch.properties.*= # Additional properties used to
configure the client.
spring.data.elasticsearch.repositories.enabled=true # Whether to enable
Elasticsearch repositories.

# DATA LDAP
spring.data.ldap.repositories.enabled=true # Whether to enable LDAP
repositories.

# MONGODB (MongoProperties)
spring.data.mongodb.authentication-database= # Authentication database
name.
spring.data.mongodb.database= # Database name.
spring.data.mongodb.field-naming-strategy= # Fully qualified name of the
FieldNamingStrategy to use.
spring.data.mongodb.grid-fs-database= # GridFS database name.
spring.data.mongodb.host= # Mongo server host. Cannot be set with URI.
spring.data.mongodb.password= # Login password of the mongo server. Cannot
be set with URI.
spring.data.mongodb.port= # Mongo server port. Cannot be set with URI.
spring.data.mongodb.repositories.type=auto # Type of Mongo repositories to
enable.
spring.data.mongodb.uri=mongodb://localhost/test # Mongo database URI.
Cannot be set with host, port and credentials.
spring.data.mongodb.username= # Login user of the mongo server. Cannot be
set with URI.

# DATA REDIS

91
spring.data.redis.repositories.enabled=true # Whether to enable Redis
repositories.

# NEO4J (Neo4jProperties)
spring.data.neo4j.auto-index=none # Auto index mode.
spring.data.neo4j.embedded.enabled=true # Whether to enable embedded mode
if the embedded driver is available.
spring.data.neo4j.open-in-view=true # Register
OpenSessionInViewInterceptor. Binds a Neo4j Session to the thread for the
entire processing of the request.
spring.data.neo4j.password= # Login password of the server.
spring.data.neo4j.repositories.enabled=true # Whether to enable Neo4j
repositories.
spring.data.neo4j.uri= # URI used by the driver. Auto-detected by default.
spring.data.neo4j.username= # Login user of the server.

# DATA REST (RepositoryRestProperties)

spring.data.rest.base-path= # Base path to be used by Spring Data REST to
expose repository resources.
spring.data.rest.default-media-type= # Content type to use as a default
when none is specified.
spring.data.rest.default-page-size= # Default size of pages.
spring.data.rest.detection-strategy=default # Strategy to use to determine
which repositories get exposed.
spring.data.rest.enable-enum-translation= # Whether to enable enum value
translation through the Spring Data REST default resource bundle.
spring.data.rest.limit-param-name= # Name of the URL query string parameter
that indicates how many results to return at once.
spring.data.rest.max-page-size= # Maximum size of pages.
spring.data.rest.page-param-name= # Name of the URL query string parameter
that indicates what page to return.
spring.data.rest.return-body-on-create= # Whether to return a response body
after creating an entity.
spring.data.rest.return-body-on-update= # Whether to return a response body
after updating an entity.
spring.data.rest.sort-param-name= # Name of the URL query string parameter
that indicates what direction to sort results.

# SOLR (SolrProperties)
spring.data.solr.host=http://127.0.0.1:8983/solr # Solr host. Ignored if
"zk-host" is set.
spring.data.solr.repositories.enabled=true # Whether to enable Solr
repositories.
spring.data.solr.zk-host= # ZooKeeper host address in the form HOST:PORT.

# DATA WEB (SpringDataWebProperties)

spring.data.web.pageable.default-page-size=20 # Default page size.
spring.data.web.pageable.max-page-size=2000 # Maximum page size to be
accepted.
spring.data.web.pageable.one-indexed-parameters=false # Whether to expose
and assume 1-based page number indexes.
spring.data.web.pageable.page-parameter=page # Page index parameter name.
spring.data.web.pageable.prefix= # General prefix to be prepended to the
page number and page size parameters.
spring.data.web.pageable.qualifier-delimiter=_ # Delimiter to be used
between the qualifier and the actual page number and size properties.
spring.data.web.pageable.size-parameter=size # Page size parameter name.
spring.data.web.sort.sort-parameter=sort # Sort parameter name.

# DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)

92
spring.datasource.continue-on-error=false # Whether to stop if an error
occurs while initializing the database.
spring.datasource.data= # Data (DML) script resource references.
spring.datasource.data-username= # Username of the database to execute DML
scripts (if different).
spring.datasource.data-password= # Password of the database to execute DML
scripts (if different).
spring.datasource.dbcp2.*= # Commons DBCP2 specific settings
spring.datasource.driver-class-name= # Fully qualified name of the JDBC
driver. Auto-detected based on the URL by default.
spring.datasource.generate-unique-name=false # Whether to generate a random
datasource name.
spring.datasource.hikari.*= # Hikari specific settings
spring.datasource.initialization-mode=embedded # Initialize the datasource
with available DDL and DML scripts.
spring.datasource.jmx-enabled=false # Whether to enable JMX support (if
provided by the underlying pool).
spring.datasource.jndi-name= # JNDI location of the datasource. Class, url,
username & password are ignored when set.
spring.datasource.name= # Name of the datasource. Default to "testdb" when
using an embedded database.
spring.datasource.password= # Login password of the database.
spring.datasource.platform=all # Platform to use in the DDL or DML scripts
(such as schema-${platform}.sql or data-${platform}.sql).
spring.datasource.schema= # Schema (DDL) script resource references.
spring.datasource.schema-username= # Username of the database to execute
DDL scripts (if different).
spring.datasource.schema-password= # Password of the database to execute
DDL scripts (if different).
spring.datasource.separator=; # Statement separator in SQL initialization
scripts.
spring.datasource.sql-script-encoding= # SQL scripts encoding.
spring.datasource.tomcat.*= # Tomcat datasource specific settings
spring.datasource.type= # Fully qualified name of the connection pool
implementation to use. By default, it is auto-detected from the classpath.
spring.datasource.url= # JDBC URL of the database.
spring.datasource.username= # Login username of the database.
spring.datasource.xa.data-source-class-name= # XA datasource fully
qualified name.
spring.datasource.xa.properties= # Properties to pass to the XA data
source.

# JEST (Elasticsearch HTTP client) (JestProperties)

spring.elasticsearch.jest.connection-timeout=3s # Connection timeout.
spring.elasticsearch.jest.multi-threaded=true # Whether to enable
connection requests from multiple execution threads.
spring.elasticsearch.jest.password= # Login password.
spring.elasticsearch.jest.proxy.host= # Proxy host the HTTP client should
use.
spring.elasticsearch.jest.proxy.port= # Proxy port the HTTP client should
use.
spring.elasticsearch.jest.read-timeout=3s # Read timeout.
spring.elasticsearch.jest.uris=http://localhost:9200 # Comma-separated list
of the Elasticsearch instances to use.
spring.elasticsearch.jest.username= # Login username.

# H2 Web Console (H2ConsoleProperties)

spring.h2.console.enabled=false # Whether to enable the console.
spring.h2.console.path=/h2-console # Path at which the console is
available.
spring.h2.console.settings.trace=false # Whether to enable trace output.

93
spring.h2.console.settings.web-allow-others=false # Whether to enable
remote access.

# InfluxDB (InfluxDbProperties)
spring.influx.password= # Login password.
spring.influx.url= # URL of the InfluxDB instance to which to connect.
spring.influx.user= # Login user.

# JOOQ (JooqProperties)
spring.jooq.sql-dialect= # SQL dialect to use. Auto-detected by default.

# JDBC (JdbcProperties)
spring.jdbc.template.fetch-size=-1 # Number of rows that should be fetched
from the database when more rows are needed.
spring.jdbc.template.max-rows=-1 # Maximum number of rows.
spring.jdbc.template.query-timeout= # Query timeout. Default is to use the
JDBC driver's default configuration. If a duration suffix is not specified,
seconds will be used.

# JPA (JpaBaseConfiguration, HibernateJpaAutoConfiguration)

spring.data.jpa.repositories.enabled=true # Whether to enable JPA
repositories.
spring.jpa.database= # Target database to operate on, auto-detected by
default. Can be alternatively set using the "databasePlatform" property.
spring.jpa.database-platform= # Name of the target database to operate on,
auto-detected by default. Can be alternatively set using the "Database"
enum.
spring.jpa.generate-ddl=false # Whether to initialize the schema on
startup.
spring.jpa.hibernate.ddl-auto= # DDL mode. This is actually a shortcut for
the "hibernate.hbm2ddl.auto" property. Defaults to "create-drop" when using
an embedded database and no schema manager was detected. Otherwise,
defaults to "none".
spring.jpa.hibernate.naming.implicit-strategy= # Fully qualified name of
the implicit naming strategy.
spring.jpa.hibernate.naming.physical-strategy= # Fully qualified name of
the physical naming strategy.
spring.jpa.hibernate.use-new-id-generator-mappings= # Whether to use
Hibernate's newer IdentifierGenerator for AUTO, TABLE and SEQUENCE.
spring.jpa.mapping-resources= # Mapping resources (equivalent to "mapping-
file" entries in persistence.xml).
spring.jpa.open-in-view=true # Register OpenEntityManagerInViewInterceptor.
Binds a JPA EntityManager to the thread for the entire processing of the
request.
spring.jpa.properties.*= # Additional native properties to set on the JPA
provider.
spring.jpa.show-sql=false # Whether to enable logging of SQL statements.

# JTA (JtaAutoConfiguration)
spring.jta.enabled=true # Whether to enable JTA support.
spring.jta.log-dir= # Transaction logs directory.
spring.jta.transaction-manager-id= # Transaction manager unique identifier.

# ATOMIKOS (AtomikosProperties)
spring.jta.atomikos.connectionfactory.borrow-connection-timeout=30 #
Timeout, in seconds, for borrowing connections from the pool.
spring.jta.atomikos.connectionfactory.ignore-session-transacted-flag=true #
Whether to ignore the transacted flag when creating session.
spring.jta.atomikos.connectionfactory.local-transaction-mode=false #
Whether local transactions are desired.

94
spring.jta.atomikos.connectionfactory.maintenance-interval=60 # The time,
in seconds, between runs of the pool's maintenance thread.
spring.jta.atomikos.connectionfactory.max-idle-time=60 # The time, in
seconds, after which connections are cleaned up from the pool.
spring.jta.atomikos.connectionfactory.max-lifetime=0 # The time, in
seconds, that a connection can be pooled for before being destroyed. 0
denotes no limit.
spring.jta.atomikos.connectionfactory.max-pool-size=1 # The maximum size of
the pool.
spring.jta.atomikos.connectionfactory.min-pool-size=1 # The minimum size of
the pool.
spring.jta.atomikos.connectionfactory.reap-timeout=0 # The reap timeout, in
seconds, for borrowed connections. 0 denotes no limit.
spring.jta.atomikos.connectionfactory.unique-resource-
name=jmsConnectionFactory # The unique name used to identify the resource
during recovery.
spring.jta.atomikos.connectionfactory.xa-connection-factory-class-name= #
Vendor-specific implementation of XAConnectionFactory.
spring.jta.atomikos.connectionfactory.xa-properties= # Vendor-specific XA
properties.
spring.jta.atomikos.datasource.borrow-connection-timeout=30 # Timeout, in
seconds, for borrowing connections from the pool.
spring.jta.atomikos.datasource.concurrent-connection-validation= # Whether
to use concurrent connection validation.
spring.jta.atomikos.datasource.default-isolation-level= # Default isolation
level of connections provided by the pool.
spring.jta.atomikos.datasource.login-timeout= # Timeout, in seconds, for
establishing a database connection.
spring.jta.atomikos.datasource.maintenance-interval=60 # The time, in
seconds, between runs of the pool's maintenance thread.
spring.jta.atomikos.datasource.max-idle-time=60 # The time, in seconds,
after which connections are cleaned up from the pool.
spring.jta.atomikos.datasource.max-lifetime=0 # The time, in seconds, that
a connection can be pooled for before being destroyed. 0 denotes no limit.
spring.jta.atomikos.datasource.max-pool-size=1 # The maximum size of the
pool.
spring.jta.atomikos.datasource.min-pool-size=1 # The minimum size of the
pool.
spring.jta.atomikos.datasource.reap-timeout=0 # The reap timeout, in
seconds, for borrowed connections. 0 denotes no limit.
spring.jta.atomikos.datasource.test-query= # SQL query or statement used to
validate a connection before returning it.
spring.jta.atomikos.datasource.unique-resource-name=dataSource # The unique
name used to identify the resource during recovery.
spring.jta.atomikos.datasource.xa-data-source-class-name= # Vendor-specific
implementation of XAConnectionFactory.
spring.jta.atomikos.datasource.xa-properties= # Vendor-specific XA
properties.
spring.jta.atomikos.properties.allow-sub-transactions=true # Specify
whether sub-transactions are allowed.
spring.jta.atomikos.properties.checkpoint-interval=500 # Interval between
checkpoints, expressed as the number of log writes between two checkpoint.
spring.jta.atomikos.properties.default-jta-timeout=10000ms # Default
timeout for JTA transactions.
spring.jta.atomikos.properties.default-max-wait-time-on-
shutdown=9223372036854775807 # How long should normal shutdown (no-force)
wait for transactions to complete.
spring.jta.atomikos.properties.enable-logging=true # Whether to enable disk
logging.
spring.jta.atomikos.properties.force-shutdown-on-vm-exit=false # Whether a
VM shutdown should trigger forced shutdown of the transaction core.

95
spring.jta.atomikos.properties.log-base-dir= # Directory in which the log
files should be stored.
spring.jta.atomikos.properties.log-base-name=tmlog # Transactions log file
base name.
spring.jta.atomikos.properties.max-actives=50 # Maximum number of active
transactions.
spring.jta.atomikos.properties.max-timeout=300000ms # Maximum timeout that
can be allowed for transactions.
spring.jta.atomikos.properties.recovery.delay=10000ms # Delay between two
recovery scans.
spring.jta.atomikos.properties.recovery.forget-orphaned-log-entries-
delay=86400000ms # Delay after which recovery can cleanup pending
('orphaned') log entries.
spring.jta.atomikos.properties.recovery.max-retries=5 # Number of retry
attempts to commit the transaction before throwing an exception.
spring.jta.atomikos.properties.recovery.retry-interval=10000ms # Delay
between retry attempts.
spring.jta.atomikos.properties.serial-jta-transactions=true # Whether sub-
transactions should be joined when possible.
spring.jta.atomikos.properties.service= # Transaction manager
implementation that should be started.
spring.jta.atomikos.properties.threaded-two-phase-commit=false # Whether to
use different (and concurrent) threads for two-phase commit on the
participating resources.
spring.jta.atomikos.properties.transaction-manager-unique-name= # The
transaction manager's unique name.

# BITRONIX
spring.jta.bitronix.connectionfactory.acquire-increment=1 # Number of
connections to create when growing the pool.
spring.jta.bitronix.connectionfactory.acquisition-interval=1 # Time, in
seconds, to wait before trying to acquire a connection again after an
invalid connection was acquired.
spring.jta.bitronix.connectionfactory.acquisition-timeout=30 # Timeout, in
seconds, for acquiring connections from the pool.
spring.jta.bitronix.connectionfactory.allow-local-transactions=true #
Whether the transaction manager should allow mixing XA and non-XA
transactions.
spring.jta.bitronix.connectionfactory.apply-transaction-timeout=false #
Whether the transaction timeout should be set on the XAResource when it is
enlisted.
spring.jta.bitronix.connectionfactory.automatic-enlisting-enabled=true #
Whether resources should be enlisted and delisted automatically.
spring.jta.bitronix.connectionfactory.cache-producers-consumers=true #
Whether producers and consumers should be cached.
spring.jta.bitronix.connectionfactory.class-name= # Underlying
implementation class name of the XA resource.
spring.jta.bitronix.connectionfactory.defer-connection-release=true #
Whether the provider can run many transactions on the same connection and
supports transaction interleaving.
spring.jta.bitronix.connectionfactory.disabled= # Whether this resource is
disabled, meaning it's temporarily forbidden to acquire a connection from
its pool.
spring.jta.bitronix.connectionfactory.driver-properties= # Properties that
should be set on the underlying implementation.
spring.jta.bitronix.connectionfactory.failed= # Mark this resource producer
as failed.
spring.jta.bitronix.connectionfactory.ignore-recovery-failures=false #
Whether recovery failures should be ignored.
spring.jta.bitronix.connectionfactory.max-idle-time=60 # The time, in
seconds, after which connections are cleaned up from the pool.

96
spring.jta.bitronix.connectionfactory.max-pool-size=10 # The maximum size
of the pool. 0 denotes no limit.
spring.jta.bitronix.connectionfactory.min-pool-size=0 # The minimum size of
the pool.
spring.jta.bitronix.connectionfactory.password= # The password to use to
connect to the JMS provider.
spring.jta.bitronix.connectionfactory.share-transaction-connections=false #
Whether connections in the ACCESSIBLE state can be shared within the
context of a transaction.
spring.jta.bitronix.connectionfactory.test-connections=true # Whether
connections should be tested when acquired from the pool.
spring.jta.bitronix.connectionfactory.two-pc-ordering-position=1 # The
position that this resource should take during two-phase commit (always
first is Integer.MIN_VALUE, always last is Integer.MAX_VALUE).
spring.jta.bitronix.connectionfactory.unique-name=jmsConnectionFactory #
The unique name used to identify the resource during recovery.
spring.jta.bitronix.connectionfactory.use-tm-join=true # Whether TMJOIN
should be used when starting XAResources.
spring.jta.bitronix.connectionfactory.user= # The user to use to connect to
the JMS provider.
spring.jta.bitronix.datasource.acquire-increment=1 # Number of connections
to create when growing the pool.
spring.jta.bitronix.datasource.acquisition-interval=1 # Time, in seconds,
to wait before trying to acquire a connection again after an invalid
connection was acquired.
spring.jta.bitronix.datasource.acquisition-timeout=30 # Timeout, in
seconds, for acquiring connections from the pool.
spring.jta.bitronix.datasource.allow-local-transactions=true # Whether the
transaction manager should allow mixing XA and non-XA transactions.
spring.jta.bitronix.datasource.apply-transaction-timeout=false # Whether
the transaction timeout should be set on the XAResource when it is
enlisted.
spring.jta.bitronix.datasource.automatic-enlisting-enabled=true # Whether
resources should be enlisted and delisted automatically.
spring.jta.bitronix.datasource.class-name= # Underlying implementation
class name of the XA resource.
spring.jta.bitronix.datasource.cursor-holdability= # The default cursor
holdability for connections.
spring.jta.bitronix.datasource.defer-connection-release=true # Whether the
database can run many transactions on the same connection and supports
transaction interleaving.
spring.jta.bitronix.datasource.disabled= # Whether this resource is
disabled, meaning it's temporarily forbidden to acquire a connection from
its pool.
spring.jta.bitronix.datasource.driver-properties= # Properties that should
be set on the underlying implementation.
spring.jta.bitronix.datasource.enable-jdbc4-connection-test= # Whether
Connection.isValid() is called when acquiring a connection from the pool.
spring.jta.bitronix.datasource.failed= # Mark this resource producer as
failed.
spring.jta.bitronix.datasource.ignore-recovery-failures=false # Whether
recovery failures should be ignored.
spring.jta.bitronix.datasource.isolation-level= # The default isolation
level for connections.
spring.jta.bitronix.datasource.local-auto-commit= # The default auto-commit
mode for local transactions.
spring.jta.bitronix.datasource.login-timeout= # Timeout, in seconds, for
establishing a database connection.
spring.jta.bitronix.datasource.max-idle-time=60 # The time, in seconds,
after which connections are cleaned up from the pool.

97
spring.jta.bitronix.datasource.max-pool-size=10 # The maximum size of the
pool. 0 denotes no limit.
spring.jta.bitronix.datasource.min-pool-size=0 # The minimum size of the
pool.
spring.jta.bitronix.datasource.prepared-statement-cache-size=0 # The target
size of the prepared statement cache. 0 disables the cache.
spring.jta.bitronix.datasource.share-transaction-connections=false #
Whether connections in the ACCESSIBLE state can be shared within the
context of a transaction.
spring.jta.bitronix.datasource.test-query= # SQL query or statement used to
validate a connection before returning it.
spring.jta.bitronix.datasource.two-pc-ordering-position=1 # The position
that this resource should take during two-phase commit (always first is
Integer.MIN_VALUE, and always last is Integer.MAX_VALUE).
spring.jta.bitronix.datasource.unique-name=dataSource # The unique name
used to identify the resource during recovery.
spring.jta.bitronix.datasource.use-tm-join=true # Whether TMJOIN should be
used when starting XAResources.
spring.jta.bitronix.properties.allow-multiple-lrc=false # Whether to allow
multiple LRC resources to be enlisted into the same transaction.
spring.jta.bitronix.properties.asynchronous2-pc=false # Whether to enable
asynchronously execution of two phase commit.
spring.jta.bitronix.properties.background-recovery-interval-seconds=60 #
Interval in seconds at which to run the recovery process in the background.
spring.jta.bitronix.properties.current-node-only-recovery=true # Whether to
recover only the current node.
spring.jta.bitronix.properties.debug-zero-resource-transaction=false #
Whether to log the creation and commit call stacks of transactions executed
without a single enlisted resource.
spring.jta.bitronix.properties.default-transaction-timeout=60 # Default
transaction timeout, in seconds.
spring.jta.bitronix.properties.disable-jmx=false # Whether to enable JMX
support.
spring.jta.bitronix.properties.exception-analyzer= # Set the fully
qualified name of the exception analyzer implementation to use.
spring.jta.bitronix.properties.filter-log-status=false # Whether to enable
filtering of logs so that only mandatory logs are written.
spring.jta.bitronix.properties.force-batching-enabled=true # Whether disk
forces are batched.
spring.jta.bitronix.properties.forced-write-enabled=true # Whether logs are
forced to disk.
spring.jta.bitronix.properties.graceful-shutdown-interval=60 # Maximum
amount of seconds the TM waits for transactions to get done before aborting
them at shutdown time.
spring.jta.bitronix.properties.jndi-transaction-synchronization-registry-
name= # JNDI name of the TransactionSynchronizationRegistry.
spring.jta.bitronix.properties.jndi-user-transaction-name= # JNDI name of
the UserTransaction.
spring.jta.bitronix.properties.journal=disk # Name of the journal. Can be
'disk', 'null', or a class name.
spring.jta.bitronix.properties.log-part1-filename=btm1.tlog # Name of the
first fragment of the journal.
spring.jta.bitronix.properties.log-part2-filename=btm2.tlog # Name of the
second fragment of the journal.
spring.jta.bitronix.properties.max-log-size-in-mb=2 # Maximum size in
megabytes of the journal fragments.
spring.jta.bitronix.properties.resource-configuration-filename= #
ResourceLoader configuration file name.
spring.jta.bitronix.properties.server-id= # ASCII ID that must uniquely
identify this TM instance. Defaults to the machine's IP address.

98
spring.jta.bitronix.properties.skip-corrupted-logs=false # Skip corrupted
transactions log entries.
spring.jta.bitronix.properties.warn-about-zero-resource-transaction=true #
Whether to log a warning for transactions executed without a single
enlisted resource.

# NARAYANA (NarayanaProperties)
spring.jta.narayana.default-timeout=60s # Transaction timeout. If a
duration suffix is not specified, seconds will be used.
spring.jta.narayana.expiry-
scanners=com.arjuna.ats.internal.arjuna.recovery.ExpiredTransactionStatusMa
nagerScanner # Comma-separated list of expiry scanners.
spring.jta.narayana.log-dir= # Transaction object store directory.
spring.jta.narayana.one-phase-commit=true # Whether to enable one phase
commit optimization.
spring.jta.narayana.periodic-recovery-period=120s # Interval in which
periodic recovery scans are performed. If a duration suffix is not
specified, seconds will be used.
spring.jta.narayana.recovery-backoff-period=10s # Back off period between
first and second phases of the recovery scan. If a duration suffix is not
specified, seconds will be used.
spring.jta.narayana.recovery-db-pass= # Database password to be used by the
recovery manager.
spring.jta.narayana.recovery-db-user= # Database username to be used by the
recovery manager.
spring.jta.narayana.recovery-jms-pass= # JMS password to be used by the
recovery manager.
spring.jta.narayana.recovery-jms-user= # JMS username to be used by the
recovery manager.
spring.jta.narayana.recovery-modules= # Comma-separated list of recovery
modules.
spring.jta.narayana.transaction-manager-id=1 # Unique transaction manager
id.
spring.jta.narayana.xa-resource-orphan-filters= # Comma-separated list of
orphan filters.

# EMBEDDED MONGODB (EmbeddedMongoProperties)

spring.mongodb.embedded.features=sync_delay # Comma-separated list of
features to enable.
spring.mongodb.embedded.storage.database-dir= # Directory used for data
storage.
spring.mongodb.embedded.storage.oplog-size= # Maximum size of the oplog, in
megabytes.
spring.mongodb.embedded.storage.repl-set-name= # Name of the replica set.
spring.mongodb.embedded.version=3.2.2 # Version of Mongo to use.

# REDIS (RedisProperties)
spring.redis.cluster.max-redirects= # Maximum number of redirects to follow
when executing commands across the cluster.
spring.redis.cluster.nodes= # Comma-separated list of "host:port" pairs to
bootstrap from.
spring.redis.database=0 # Database index used by the connection factory.
spring.redis.url= # Connection URL. Overrides host, port, and password.
User is ignored. Example: redis://user:[email protected]:6379
spring.redis.host=localhost # Redis server host.
spring.redis.jedis.pool.max-active=8 # Maximum number of connections that
can be allocated by the pool at a given time. Use a negative value for no
limit.
spring.redis.jedis.pool.max-idle=8 # Maximum number of "idle" connections
in the pool. Use a negative value to indicate an unlimited number of idle
connections.

99
spring.redis.jedis.pool.max-wait=-1ms # Maximum amount of time a connection
allocation should block before throwing an exception when the pool is
exhausted. Use a negative value to block indefinitely.
spring.redis.jedis.pool.min-idle=0 # Target for the minimum number of idle
connections to maintain in the pool. This setting only has an effect if it
is positive.
spring.redis.lettuce.pool.max-active=8 # Maximum number of connections that
can be allocated by the pool at a given time. Use a negative value for no
limit.
spring.redis.lettuce.pool.max-idle=8 # Maximum number of "idle" connections
in the pool. Use a negative value to indicate an unlimited number of idle
connections.
spring.redis.lettuce.pool.max-wait=-1ms # Maximum amount of time a
connection allocation should block before throwing an exception when the
pool is exhausted. Use a negative value to block indefinitely.
spring.redis.lettuce.pool.min-idle=0 # Target for the minimum number of
idle connections to maintain in the pool. This setting only has an effect
if it is positive.
spring.redis.lettuce.shutdown-timeout=100ms # Shutdown timeout.
spring.redis.password= # Login password of the redis server.
spring.redis.port=6379 # Redis server port.
spring.redis.sentinel.master= # Name of the Redis server.
spring.redis.sentinel.nodes= # Comma-separated list of "host:port" pairs.
spring.redis.ssl=false # Whether to enable SSL support.
spring.redis.timeout= # Connection timeout.

# TRANSACTION (TransactionProperties)
spring.transaction.default-timeout= # Default transaction timeout. If a
duration suffix is not specified, seconds will be used.
spring.transaction.rollback-on-commit-failure= # Whether to roll back on
commit failures.

# ----------------------------------------
# INTEGRATION PROPERTIES
# ----------------------------------------

# ACTIVEMQ (ActiveMQProperties)
spring.activemq.broker-url= # URL of the ActiveMQ broker. Auto-generated by
default.
spring.activemq.close-timeout=15s # Time to wait before considering a close
complete.
spring.activemq.in-memory=true # Whether the default broker URL should be
in memory. Ignored if an explicit broker has been specified.
spring.activemq.non-blocking-redelivery=false # Whether to stop message
delivery before re-delivering messages from a rolled back transaction. This
implies that message order is not preserved when this is enabled.
spring.activemq.password= # Login password of the broker.
spring.activemq.send-timeout=0ms # Time to wait on message sends for a
response. Set it to 0 to wait forever.
spring.activemq.user= # Login user of the broker.
spring.activemq.packages.trust-all= # Whether to trust all packages.
spring.activemq.packages.trusted= # Comma-separated list of specific
packages to trust (when not trusting all packages).
spring.activemq.pool.block-if-full=true # Whether to block when a
connection is requested and the pool is full. Set it to false to throw a
"JMSException" instead.
spring.activemq.pool.block-if-full-timeout=-1ms # Blocking period before
throwing an exception if the pool is still full.

100
spring.activemq.pool.create-connection-on-startup=true # Whether to create
a connection on startup. Can be used to warm up the pool on startup.
spring.activemq.pool.enabled=false # Whether a PooledConnectionFactory
should be created, instead of a regular ConnectionFactory.
spring.activemq.pool.expiry-timeout=0ms # Connection expiration timeout.
spring.activemq.pool.idle-timeout=30s # Connection idle timeout.
spring.activemq.pool.max-connections=1 # Maximum number of pooled
connections.
spring.activemq.pool.maximum-active-session-per-connection=500 # Maximum
number of active sessions per connection.
spring.activemq.pool.reconnect-on-exception=true # Reset the connection
when a "JMSException" occurs.
spring.activemq.pool.time-between-expiration-check=-1ms # Time to sleep
between runs of the idle connection eviction thread. When negative, no idle
connection eviction thread runs.
spring.activemq.pool.use-anonymous-producers=true # Whether to use only one
anonymous "MessageProducer" instance. Set it to false to create one
"MessageProducer" every time one is required.

# ARTEMIS (ArtemisProperties)
spring.artemis.embedded.cluster-password= # Cluster password. Randomly
generated on startup by default.
spring.artemis.embedded.data-directory= # Journal file directory. Not
necessary if persistence is turned off.
spring.artemis.embedded.enabled=true # Whether to enable embedded mode if
the Artemis server APIs are available.
spring.artemis.embedded.persistent=false # Whether to enable persistent
store.
spring.artemis.embedded.queues= # Comma-separated list of queues to create
on startup.
spring.artemis.embedded.server-id= # Server ID. By default, an auto-
incremented counter is used.
spring.artemis.embedded.topics= # Comma-separated list of topics to create
on startup.
spring.artemis.host=localhost # Artemis broker host.
spring.artemis.mode= # Artemis deployment mode, auto-detected by default.
spring.artemis.password= # Login password of the broker.
spring.artemis.port=61616 # Artemis broker port.
spring.artemis.user= # Login user of the broker.

# SPRING BATCH (BatchProperties)

spring.batch.initialize-schema=embedded # Database schema initialization
mode.
spring.batch.job.enabled=true # Execute all Spring Batch jobs in the
context on startup.
spring.batch.job.names= # Comma-separated list of job names to execute on
startup (for instance, `job1,job2`). By default, all Jobs found in the
context are executed.
spring.batch.schema=classpath:org/springframework/batch/core/schema-
@@platform@@.sql # Path to the SQL file to use to initialize the database
schema.
spring.batch.table-prefix= # Table prefix for all the batch meta-data
tables.

# SPRING INTEGRATION (IntegrationProperties)

spring.integration.jdbc.initialize-schema=embedded # Database schema
initialization mode.
spring.integration.jdbc.schema=classpath:org/springframework/integration/jd
bc/schema-@@platform@@.sql # Path to the SQL file to use to initialize the
database schema.

101
# JMS (JmsProperties)
spring.jms.jndi-name= # Connection factory JNDI name. When set, takes
precedence to others connection factory auto-configurations.
spring.jms.listener.acknowledge-mode= # Acknowledge mode of the container.
By default, the listener is transacted with automatic acknowledgment.
spring.jms.listener.auto-startup=true # Start the container automatically
on startup.
spring.jms.listener.concurrency= # Minimum number of concurrent consumers.
spring.jms.listener.max-concurrency= # Maximum number of concurrent
consumers.
spring.jms.pub-sub-domain=false # Whether the default destination type is
topic.
spring.jms.template.default-destination= # Default destination to use on
send and receive operations that do not have a destination parameter.
spring.jms.template.delivery-delay= # Delivery delay to use for send calls.
spring.jms.template.delivery-mode= # Delivery mode. Enables QoS (Quality of
Service) when set.
spring.jms.template.priority= # Priority of a message when sending. Enables
QoS (Quality of Service) when set.
spring.jms.template.qos-enabled= # Whether to enable explicit QoS (Quality
of Service) when sending a message.
spring.jms.template.receive-timeout= # Timeout to use for receive calls.
spring.jms.template.time-to-live= # Time-to-live of a message when sending.
Enables QoS (Quality of Service) when set.

# APACHE KAFKA (KafkaProperties)

spring.kafka.admin.client-id= # ID to pass to the server when making
requests. Used for server-side logging.
spring.kafka.admin.fail-fast=false # Whether to fail fast if the broker is
not available on startup.
spring.kafka.admin.properties.*= # Additional admin-specific properties
used to configure the client.
spring.kafka.admin.ssl.key-password= # Password of the private key in the
key store file.
spring.kafka.admin.ssl.keystore-location= # Location of the key store file.
spring.kafka.admin.ssl.keystore-password= # Store password for the key
store file.
spring.kafka.admin.ssl.truststore-location= # Location of the trust store
file.
spring.kafka.admin.ssl.truststore-password= # Store password for the trust
store file.
spring.kafka.bootstrap-servers= # Comma-delimited list of host:port pairs
to use for establishing the initial connection to the Kafka cluster.
spring.kafka.client-id= # ID to pass to the server when making requests.
Used for server-side logging.
spring.kafka.consumer.auto-commit-interval= # Frequency with which the
consumer offsets are auto-committed to Kafka if 'enable.auto.commit' is set
to true.
spring.kafka.consumer.auto-offset-reset= # What to do when there is no
initial offset in Kafka or if the current offset no longer exists on the
server.
spring.kafka.consumer.bootstrap-servers= # Comma-delimited list of
host:port pairs to use for establishing the initial connection to the Kafka
cluster.
spring.kafka.consumer.client-id= # ID to pass to the server when making
requests. Used for server-side logging.
spring.kafka.consumer.enable-auto-commit= # Whether the consumer's offset
is periodically committed in the background.
spring.kafka.consumer.fetch-max-wait= # Maximum amount of time the server
blocks before answering the fetch request if there isn't sufficient data to
immediately satisfy the requirement given by "fetch.min.bytes".

102
spring.kafka.consumer.fetch-min-size= # Minimum amount of data, in bytes,
the server should return for a fetch request.
spring.kafka.consumer.group-id= # Unique string that identifies the
consumer group to which this consumer belongs.
spring.kafka.consumer.heartbeat-interval= # Expected time between
heartbeats to the consumer coordinator.
spring.kafka.consumer.key-deserializer= # Deserializer class for keys.
spring.kafka.consumer.max-poll-records= # Maximum number of records
returned in a single call to poll().
spring.kafka.consumer.properties.*= # Additional consumer-specific
properties used to configure the client.
spring.kafka.consumer.ssl.key-password= # Password of the private key in
the key store file.
spring.kafka.consumer.ssl.keystore-location= # Location of the key store
file.
spring.kafka.consumer.ssl.keystore-password= # Store password for the key
store file.
spring.kafka.consumer.ssl.truststore-location= # Location of the trust
store file.
spring.kafka.consumer.ssl.truststore-password= # Store password for the
trust store file.
spring.kafka.consumer.value-deserializer= # Deserializer class for values.
spring.kafka.jaas.control-flag=required # Control flag for login
configuration.
spring.kafka.jaas.enabled=false # Whether to enable JAAS configuration.
spring.kafka.jaas.login-module=com.sun.security.auth.module.Krb5LoginModule
# Login module.
spring.kafka.jaas.options= # Additional JAAS options.
spring.kafka.listener.ack-count= # Number of records between offset commits
when ackMode is "COUNT" or "COUNT_TIME".
spring.kafka.listener.ack-mode= # Listener AckMode. See the spring-kafka
documentation.
spring.kafka.listener.ack-time= # Time between offset commits when ackMode
is "TIME" or "COUNT_TIME".
spring.kafka.listener.client-id= # Prefix for the listener's consumer
client.id property.
spring.kafka.listener.concurrency= # Number of threads to run in the
listener containers.
spring.kafka.listener.idle-event-interval= # Time between publishing idle
consumer events (no data received).
spring.kafka.listener.log-container-config= # Whether to log the container
configuration during initialization (INFO level).
spring.kafka.listener.monitor-interval= # Time between checks for non-
responsive consumers. If a duration suffix is not specified, seconds will
be used.
spring.kafka.listener.no-poll-threshold= # Multiplier applied to
"pollTimeout" to determine if a consumer is non-responsive.
spring.kafka.listener.poll-timeout= # Timeout to use when polling the
consumer.
spring.kafka.listener.type=single # Listener type.
spring.kafka.producer.acks= # Number of acknowledgments the producer
requires the leader to have received before considering a request complete.
spring.kafka.producer.batch-size= # Number of records to batch before
sending.
spring.kafka.producer.bootstrap-servers= # Comma-delimited list of
host:port pairs to use for establishing the initial connection to the Kafka
cluster.
spring.kafka.producer.buffer-memory= # Total bytes of memory the producer
can use to buffer records waiting to be sent to the server.
spring.kafka.producer.client-id= # ID to pass to the server when making
requests. Used for server-side logging.

103
spring.kafka.producer.compression-type= # Compression type for all data
generated by the producer.
spring.kafka.producer.key-serializer= # Serializer class for keys.
spring.kafka.producer.properties.*= # Additional producer-specific
properties used to configure the client.
spring.kafka.producer.retries= # When greater than zero, enables retrying
of failed sends.
spring.kafka.producer.ssl.key-password= # Password of the private key in
the key store file.
spring.kafka.producer.ssl.keystore-location= # Location of the key store
file.
spring.kafka.producer.ssl.keystore-password= # Store password for the key
store file.
spring.kafka.producer.ssl.truststore-location= # Location of the trust
store file.
spring.kafka.producer.ssl.truststore-password= # Store password for the
trust store file.
spring.kafka.producer.transaction-id-prefix= # When non empty, enables
transaction support for producer.
spring.kafka.producer.value-serializer= # Serializer class for values.
spring.kafka.properties.*= # Additional properties, common to producers and
consumers, used to configure the client.
spring.kafka.ssl.key-password= # Password of the private key in the key
store file.
spring.kafka.ssl.keystore-location= # Location of the key store file.
spring.kafka.ssl.keystore-password= # Store password for the key store
file.
spring.kafka.ssl.truststore-location= # Location of the trust store file.
spring.kafka.ssl.truststore-password= # Store password for the trust store
file.
spring.kafka.template.default-topic= # Default topic to which messages are
sent.

# RABBIT (RabbitProperties)
spring.rabbitmq.addresses= # Comma-separated list of addresses to which the
client should connect.
spring.rabbitmq.cache.channel.checkout-timeout= # Duration to wait to
obtain a channel if the cache size has been reached.
spring.rabbitmq.cache.channel.size= # Number of channels to retain in the
cache.
spring.rabbitmq.cache.connection.mode=channel # Connection factory cache
mode.
spring.rabbitmq.cache.connection.size= # Number of connections to cache.
spring.rabbitmq.connection-timeout= # Connection timeout. Set it to zero to
wait forever.
spring.rabbitmq.dynamic=true # Whether to create an AmqpAdmin bean.
spring.rabbitmq.host=localhost # RabbitMQ host.
spring.rabbitmq.listener.direct.acknowledge-mode= # Acknowledge mode of
container.
spring.rabbitmq.listener.direct.auto-startup=true # Whether to start the
container automatically on startup.
spring.rabbitmq.listener.direct.consumers-per-queue= # Number of consumers
per queue.
spring.rabbitmq.listener.direct.default-requeue-rejected= # Whether
rejected deliveries are re-queued by default.
spring.rabbitmq.listener.direct.idle-event-interval= # How often idle
container events should be published.
spring.rabbitmq.listener.direct.prefetch= # Number of messages to be
handled in a single request. It should be greater than or equal to the
transaction size (if used).

104
spring.rabbitmq.listener.direct.retry.enabled=false # Whether publishing
retries are enabled.
spring.rabbitmq.listener.direct.retry.initial-interval=1000ms # Duration
between the first and second attempt to deliver a message.
spring.rabbitmq.listener.direct.retry.max-attempts=3 # Maximum number of
attempts to deliver a message.
spring.rabbitmq.listener.direct.retry.max-interval=10000ms # Maximum
duration between attempts.
spring.rabbitmq.listener.direct.retry.multiplier=1 # Multiplier to apply to
the previous retry interval.
spring.rabbitmq.listener.direct.retry.stateless=true # Whether retries are
stateless or stateful.
spring.rabbitmq.listener.simple.acknowledge-mode= # Acknowledge mode of
container.
spring.rabbitmq.listener.simple.auto-startup=true # Whether to start the
container automatically on startup.
spring.rabbitmq.listener.simple.concurrency= # Minimum number of listener
invoker threads.
spring.rabbitmq.listener.simple.default-requeue-rejected= # Whether
rejected deliveries are re-queued by default.
spring.rabbitmq.listener.simple.idle-event-interval= # How often idle
container events should be published.
spring.rabbitmq.listener.simple.max-concurrency= # Maximum number of
listener invoker threads.
spring.rabbitmq.listener.simple.prefetch= # Number of messages to be
handled in a single request. It should be greater than or equal to the
transaction size (if used).
spring.rabbitmq.listener.simple.retry.enabled=false # Whether publishing
retries are enabled.
spring.rabbitmq.listener.simple.retry.initial-interval=1000ms # Duration
between the first and second attempt to deliver a message.
spring.rabbitmq.listener.simple.retry.max-attempts=3 # Maximum number of
attempts to deliver a message.
spring.rabbitmq.listener.simple.retry.max-interval=10000ms # Maximum
duration between attempts.
spring.rabbitmq.listener.simple.retry.multiplier=1 # Multiplier to apply to
the previous retry interval.
spring.rabbitmq.listener.simple.retry.stateless=true # Whether retries are
stateless or stateful.
spring.rabbitmq.listener.simple.transaction-size= # Number of messages to
be processed in a transaction. That is, the number of messages between
acks. For best results, it should be less than or equal to the prefetch
count.
spring.rabbitmq.listener.type=simple # Listener container type.
spring.rabbitmq.password=guest # Login to authenticate against the broker.
spring.rabbitmq.port=5672 # RabbitMQ port.
spring.rabbitmq.publisher-confirms=false # Whether to enable publisher
confirms.
spring.rabbitmq.publisher-returns=false # Whether to enable publisher
returns.
spring.rabbitmq.requested-heartbeat= # Requested heartbeat timeout; zero
for none. If a duration suffix is not specified, seconds will be used.
spring.rabbitmq.ssl.enabled=false # Whether to enable SSL support.
spring.rabbitmq.ssl.key-store= # Path to the key store that holds the SSL
certificate.
spring.rabbitmq.ssl.key-store-password= # Password used to access the key
store.
spring.rabbitmq.ssl.key-store-type=PKCS12 # Key store type.
spring.rabbitmq.ssl.trust-store= # Trust store that holds SSL certificates.
spring.rabbitmq.ssl.trust-store-password= # Password used to access the
trust store.

105
spring.rabbitmq.ssl.trust-store-type=JKS # Trust store type.
spring.rabbitmq.ssl.algorithm= # SSL algorithm to use. By default,
configured by the Rabbit client library.
spring.rabbitmq.template.exchange= # Name of the default exchange to use
for send operations.
spring.rabbitmq.template.mandatory= # Whether to enable mandatory messages.
spring.rabbitmq.template.receive-timeout= # Timeout for `receive()`
operations.
spring.rabbitmq.template.reply-timeout= # Timeout for `sendAndReceive()`
operations.
spring.rabbitmq.template.retry.enabled=false # Whether publishing retries
are enabled.
spring.rabbitmq.template.retry.initial-interval=1000ms # Duration between
the first and second attempt to deliver a message.
spring.rabbitmq.template.retry.max-attempts=3 # Maximum number of attempts
to deliver a message.
spring.rabbitmq.template.retry.max-interval=10000ms # Maximum duration
between attempts.
spring.rabbitmq.template.retry.multiplier=1 # Multiplier to apply to the
previous retry interval.
spring.rabbitmq.template.routing-key= # Value of a default routing key to
use for send operations.
spring.rabbitmq.username=guest # Login user to authenticate to the broker.
spring.rabbitmq.virtual-host= # Virtual host to use when connecting to the
broker.

# ----------------------------------------
# ACTUATOR PROPERTIES
# ----------------------------------------

# MANAGEMENT HTTP SERVER (ManagementServerProperties)

management.server.add-application-context-header=false # Add the "X-
Application-Context" HTTP header in each response.
management.server.address= # Network address to which the management
endpoints should bind. Requires a custom management.server.port.
management.server.port= # Management endpoint HTTP port (uses the same port
as the application by default). Configure a different port to use
management-specific SSL.
management.server.servlet.context-path= # Management endpoint context-path
(for instance, `/management`). Requires a custom management.server.port.
management.server.ssl.ciphers= # Supported SSL ciphers. Requires a custom
management.port.
management.server.ssl.client-auth= # Whether client authentication is
wanted ("want") or needed ("need"). Requires a trust store. Requires a
custom management.server.port.
management.server.ssl.enabled= # Whether to enable SSL support. Requires a
custom management.server.port.
management.server.ssl.enabled-protocols= # Enabled SSL protocols. Requires
a custom management.server.port.
management.server.ssl.key-alias= # Alias that identifies the key in the key
store. Requires a custom management.server.port.
management.server.ssl.key-password= # Password used to access the key in
the key store. Requires a custom management.server.port.
management.server.ssl.key-store= # Path to the key store that holds the SSL
certificate (typically a jks file). Requires a custom
management.server.port.
management.server.ssl.key-store-password= # Password used to access the key
store. Requires a custom management.server.port.
management.server.ssl.key-store-provider= # Provider for the key store.
Requires a custom management.server.port.

106
management.server.ssl.key-store-type= # Type of the key store. Requires a
custom management.server.port.
management.server.ssl.protocol=TLS # SSL protocol to use. Requires a custom
management.server.port.
management.server.ssl.trust-store= # Trust store that holds SSL
certificates. Requires a custom management.server.port.
management.server.ssl.trust-store-password= # Password used to access the
trust store. Requires a custom management.server.port.
management.server.ssl.trust-store-provider= # Provider for the trust store.
Requires a custom management.server.port.
management.server.ssl.trust-store-type= # Type of the trust store. Requires
a custom management.server.port.

# CLOUDFOUNDRY
management.cloudfoundry.enabled=true # Whether to enable extended Cloud
Foundry actuator endpoints.
management.cloudfoundry.skip-ssl-validation=false # Whether to skip SSL
verification for Cloud Foundry actuator endpoint security calls.

# ENDPOINTS GENERAL CONFIGURATION

management.endpoints.enabled-by-default= # Whether to enable or disable all
endpoints by default.

# ENDPOINTS JMX CONFIGURATION (JmxEndpointProperties)

management.endpoints.jmx.domain=org.springframework.boot # Endpoints JMX
domain name. Fallback to 'spring.jmx.default-domain' if set.
management.endpoints.jmx.exposure.include=* # Endpoint IDs that should be
included or '*' for all.
management.endpoints.jmx.exposure.exclude= # Endpoint IDs that should be
excluded.
management.endpoints.jmx.static-names= # Additional static properties to
append to all ObjectNames of MBeans representing Endpoints.
management.endpoints.jmx.unique-names=false # Whether to ensure that
ObjectNames are modified in case of conflict.

# ENDPOINTS WEB CONFIGURATION (WebEndpointProperties)

management.endpoints.web.exposure.include=health,info # Endpoint IDs that
should be included or '*' for all.
management.endpoints.web.exposure.exclude= # Endpoint IDs that should be
excluded.
management.endpoints.web.base-path=/actuator # Base path for Web endpoints.
Relative to server.servlet.context-path or
management.server.servlet.context-path if management.server.port is
configured.
management.endpoints.web.path-mapping= # Mapping between endpoint IDs and
the path that should expose them.

# ENDPOINTS CORS CONFIGURATION (CorsEndpointProperties)

management.endpoints.web.cors.allow-credentials= # Whether credentials are
supported. When not set, credentials are not supported.
management.endpoints.web.cors.allowed-headers= # Comma-separated list of
headers to allow in a request. '*' allows all headers.
management.endpoints.web.cors.allowed-methods= # Comma-separated list of
methods to allow. '*' allows all methods. When not set, defaults to GET.
management.endpoints.web.cors.allowed-origins= # Comma-separated list of
origins to allow. '*' allows all origins. When not set, CORS support is
disabled.
management.endpoints.web.cors.exposed-headers= # Comma-separated list of
headers to include in a response.

107
management.endpoints.web.cors.max-age=1800s # How long the response from a
pre-flight request can be cached by clients. If a duration suffix is not
specified, seconds will be used.

# AUDIT EVENTS ENDPOINT (AuditEventsEndpoint)

management.endpoint.auditevents.cache.time-to-live=0ms # Maximum time that
a response can be cached.
management.endpoint.auditevents.enabled=true # Whether to enable the
auditevents endpoint.

# BEANS ENDPOINT (BeansEndpoint)

management.endpoint.beans.cache.time-to-live=0ms # Maximum time that a
response can be cached.
management.endpoint.beans.enabled=true # Whether to enable the beans
endpoint.

# CONDITIONS REPORT ENDPOINT (ConditionsReportEndpoint)

management.endpoint.conditions.cache.time-to-live=0ms # Maximum time that a
response can be cached.
management.endpoint.conditions.enabled=true # Whether to enable the
conditions endpoint.

# CONFIGURATION PROPERTIES REPORT ENDPOINT

(ConfigurationPropertiesReportEndpoint,
ConfigurationPropertiesReportEndpointProperties)
management.endpoint.configprops.cache.time-to-live=0ms # Maximum time that
a response can be cached.
management.endpoint.configprops.enabled=true # Whether to enable the
configprops endpoint.
management.endpoint.configprops.keys-to-
sanitize=password,secret,key,token,.*credentials.*,vcap_services # Keys
that should be sanitized. Keys can be simple strings that the property ends
with or regular expressions.

# ENVIRONMENT ENDPOINT (EnvironmentEndpoint, EnvironmentEndpointProperties)

management.endpoint.env.cache.time-to-live=0ms # Maximum time that a
response can be cached.
management.endpoint.env.enabled=true # Whether to enable the env endpoint.
management.endpoint.env.keys-to-
sanitize=password,secret,key,token,.*credentials.*,vcap_services # Keys
that should be sanitized. Keys can be simple strings that the property ends
with or regular expressions.

# FLYWAY ENDPOINT (FlywayEndpoint)

management.endpoint.flyway.cache.time-to-live=0ms # Maximum time that a
response can be cached.
management.endpoint.flyway.enabled=true # Whether to enable the flyway
endpoint.

# HEALTH ENDPOINT (HealthEndpoint, HealthEndpointProperties)

management.endpoint.health.cache.time-to-live=0ms # Maximum time that a
response can be cached.
management.endpoint.health.enabled=true # Whether to enable the health
endpoint.
management.endpoint.health.roles= # Roles used to determine whether or not
a user is authorized to be shown details. When empty, all authenticated
users are authorized.
management.endpoint.health.show-details=never # When to show full health
details.

# HEAP DUMP ENDPOINT (HeapDumpWebEndpoint)

108
management.endpoint.heapdump.cache.time-to-live=0ms # Maximum time that a
response can be cached.
management.endpoint.heapdump.enabled=true # Whether to enable the heapdump
endpoint.

# HTTP TRACE ENDPOINT (HttpTraceEndpoint)

management.endpoint.httptrace.cache.time-to-live=0ms # Maximum time that a
response can be cached.
management.endpoint.httptrace.enabled=true # Whether to enable the
httptrace endpoint.

# INFO ENDPOINT (InfoEndpoint)

info= # Arbitrary properties to add to the info endpoint.
management.endpoint.info.cache.time-to-live=0ms # Maximum time that a
response can be cached.
management.endpoint.info.enabled=true # Whether to enable the info
endpoint.

# JOLOKIA ENDPOINT (JolokiaProperties)

management.endpoint.jolokia.config.*= # Jolokia settings. Refer to the
documentation of Jolokia for more details.
management.endpoint.jolokia.enabled=true # Whether to enable the jolokia
endpoint.

# LIQUIBASE ENDPOINT (LiquibaseEndpoint)

management.endpoint.liquibase.cache.time-to-live=0ms # Maximum time that a
response can be cached.
management.endpoint.liquibase.enabled=true # Whether to enable the
liquibase endpoint.

# LOG FILE ENDPOINT (LogFileWebEndpoint, LogFileWebEndpointProperties)

management.endpoint.logfile.cache.time-to-live=0ms # Maximum time that a
response can be cached.
management.endpoint.logfile.enabled=true # Whether to enable the logfile
endpoint.
management.endpoint.logfile.external-file= # External Logfile to be
accessed. Can be used if the logfile is written by output redirect and not
by the logging system itself.

# LOGGERS ENDPOINT (LoggersEndpoint)

management.endpoint.loggers.cache.time-to-live=0ms # Maximum time that a
response can be cached.
management.endpoint.loggers.enabled=true # Whether to enable the loggers
endpoint.

# REQUEST MAPPING ENDPOINT (MappingsEndpoint)

management.endpoint.mappings.cache.time-to-live=0ms # Maximum time that a
response can be cached.
management.endpoint.mappings.enabled=true # Whether to enable the mappings
endpoint.

# METRICS ENDPOINT (MetricsEndpoint)

management.endpoint.metrics.cache.time-to-live=0ms # Maximum time that a
response can be cached.
management.endpoint.metrics.enabled=true # Whether to enable the metrics
endpoint.

# PROMETHEUS ENDPOINT (PrometheusScrapeEndpoint)

management.endpoint.prometheus.cache.time-to-live=0ms # Maximum time that a
response can be cached.

109
management.endpoint.prometheus.enabled=true # Whether to enable the
prometheus endpoint.

# SCHEDULED TASKS ENDPOINT (ScheduledTasksEndpoint)

management.endpoint.scheduledtasks.cache.time-to-live=0ms # Maximum time
that a response can be cached.
management.endpoint.scheduledtasks.enabled=true # Whether to enable the
scheduledtasks endpoint.

# SESSIONS ENDPOINT (SessionsEndpoint)

management.endpoint.sessions.enabled=true # Whether to enable the sessions
endpoint.

# SHUTDOWN ENDPOINT (ShutdownEndpoint)

management.endpoint.shutdown.enabled=false # Whether to enable the shutdown
endpoint.

# THREAD DUMP ENDPOINT (ThreadDumpEndpoint)

management.endpoint.threaddump.cache.time-to-live=0ms # Maximum time that a
response can be cached.
management.endpoint.threaddump.enabled=true # Whether to enable the
threaddump endpoint.

# HEALTH INDICATORS
management.health.db.enabled=true # Whether to enable database health
check.
management.health.cassandra.enabled=true # Whether to enable Cassandra
health check.
management.health.couchbase.enabled=true # Whether to enable Couchbase
health check.
management.health.defaults.enabled=true # Whether to enable default health
indicators.
management.health.diskspace.enabled=true # Whether to enable disk space
health check.
management.health.diskspace.path= # Path used to compute the available disk
space.
management.health.diskspace.threshold=0 # Minimum disk space, in bytes,
that should be available.
management.health.elasticsearch.enabled=true # Whether to enable
Elasticsearch health check.
management.health.elasticsearch.indices= # Comma-separated index names.
management.health.elasticsearch.response-timeout=100ms # Time to wait for a
response from the cluster.
management.health.influxdb.enabled=true # Whether to enable InfluxDB health
check.
management.health.jms.enabled=true # Whether to enable JMS health check.
management.health.ldap.enabled=true # Whether to enable LDAP health check.
management.health.mail.enabled=true # Whether to enable Mail health check.
management.health.mongo.enabled=true # Whether to enable MongoDB health
check.
management.health.neo4j.enabled=true # Whether to enable Neo4j health
check.
management.health.rabbit.enabled=true # Whether to enable RabbitMQ health
check.
management.health.redis.enabled=true # Whether to enable Redis health
check.
management.health.solr.enabled=true # Whether to enable Solr health check.
management.health.status.http-mapping= # Mapping of health statuses to HTTP
status codes. By default, registered health statuses map to sensible
defaults (for example, UP maps to 200).

110
management.health.status.order=DOWN,OUT_OF_SERVICE,UP,UNKNOWN # Comma-
separated list of health statuses in order of severity.

# HTTP TRACING (HttpTraceProperties)

management.trace.http.enabled=true # Whether to enable HTTP request-
response tracing.
management.trace.http.include=request-headers,response-
headers,cookies,errors # Items to be included in the trace.

# INFO CONTRIBUTORS (InfoContributorProperties)

management.info.build.enabled=true # Whether to enable build info.
management.info.defaults.enabled=true # Whether to enable default info
contributors.
management.info.env.enabled=true # Whether to enable environment info.
management.info.git.enabled=true # Whether to enable git info.
management.info.git.mode=simple # Mode to use to expose git information.

# METRICS
management.metrics.binders.files.enabled=true # Whether to enable files
metrics.
management.metrics.binders.integration.enabled=true # Whether to enable
Spring Integration metrics.
management.metrics.binders.jvm.enabled=true # Whether to enable JVM
metrics.
management.metrics.binders.logback.enabled=true # Whether to enable Logback
metrics.
management.metrics.binders.processor.enabled=true # Whether to enable
processor metrics.
management.metrics.binders.uptime.enabled=true # Whether to enable uptime
metrics.
management.metrics.distribution.percentiles-histogram.*= # Whether meter
IDs starting-with the specified name should be publish percentile
histograms.
management.metrics.distribution.percentiles.*= # Specific computed non-
aggregable percentiles to ship to the backend for meter IDs starting-with
the specified name.
management.metrics.distribution.sla.*= # Specific SLA boundaries for meter
IDs starting-with the specified name. The longest match wins, the key `all`
can also be used to configure all meters.
management.metrics.enable.*= # Whether meter IDs starting-with the
specified name should be enabled. The longest match wins, the key `all` can
also be used to configure all meters.
management.metrics.export.atlas.batch-size=10000 # Number of measurements
per request to use for this backend. If more measurements are found, then
multiple requests will be made.
management.metrics.export.atlas.config-refresh-frequency=10s # Frequency
for refreshing config settings from the LWC service.
management.metrics.export.atlas.config-time-to-live=150s # Time to live for
subscriptions from the LWC service.
management.metrics.export.atlas.config-
uri=http://localhost:7101/lwc/api/v1/expressions/local-dev # URI for the
Atlas LWC endpoint to retrieve current subscriptions.
management.metrics.export.atlas.connect-timeout=1s # Connection timeout for
requests to this backend.
management.metrics.export.atlas.enabled=true # Whether exporting of metrics
to this backend is enabled.
management.metrics.export.atlas.eval-
uri=http://localhost:7101/lwc/api/v1/evaluate # URI for the Atlas LWC
endpoint to evaluate the data for a subscription.
management.metrics.export.atlas.lwc-enabled=false # Whether to enable
streaming to Atlas LWC.

111
management.metrics.export.atlas.meter-time-to-live=15m # Time to live for
meters that do not have any activity. After this period the meter will be
considered expired and will not get reported.
management.metrics.export.atlas.num-threads=2 # Number of threads to use
with the metrics publishing scheduler.
management.metrics.export.atlas.read-timeout=10s # Read timeout for
requests to this backend.
management.metrics.export.atlas.step=1m # Step size (i.e. reporting
frequency) to use.
management.metrics.export.atlas.uri=http://localhost:7101/api/v1/publish #
URI of the Atlas server.
management.metrics.export.datadog.api-key= # Datadog API key.
management.metrics.export.datadog.application-key= # Datadog application
key. Not strictly required, but improves the Datadog experience by sending
meter descriptions, types, and base units to Datadog.
management.metrics.export.datadog.batch-size=10000 # Number of measurements
per request to use for this backend. If more measurements are found, then
multiple requests will be made.
management.metrics.export.datadog.connect-timeout=1s # Connection timeout
for requests to this backend.
management.metrics.export.datadog.descriptions=true # Whether to publish
descriptions metadata to Datadog. Turn this off to minimize the amount of
metadata sent.
management.metrics.export.datadog.enabled=true # Whether exporting of
metrics to this backend is enabled.
management.metrics.export.datadog.host-tag=instance # Tag that will be
mapped to "host" when shipping metrics to Datadog.
management.metrics.export.datadog.num-threads=2 # Number of threads to use
with the metrics publishing scheduler.
management.metrics.export.datadog.read-timeout=10s # Read timeout for
requests to this backend.
management.metrics.export.datadog.step=1m # Step size (i.e. reporting
frequency) to use.
management.metrics.export.datadog.uri=https://app.datadoghq.com # URI to
ship metrics to. If you need to publish metrics to an internal proxy en-
route to Datadog, you can define the location of the proxy with this.
management.metrics.export.ganglia.addressing-mode=multicast # UDP
addressing mode, either unicast or multicast.
management.metrics.export.ganglia.duration-units=milliseconds # Base time
unit used to report durations.
management.metrics.export.ganglia.enabled=true # Whether exporting of
metrics to Ganglia is enabled.
management.metrics.export.ganglia.host=localhost # Host of the Ganglia
server to receive exported metrics.
management.metrics.export.ganglia.port=8649 # Port of the Ganglia server to
receive exported metrics.
management.metrics.export.ganglia.protocol-version=3.1 # Ganglia protocol
version. Must be either 3.1 or 3.0.
management.metrics.export.ganglia.rate-units=seconds # Base time unit used
to report rates.
management.metrics.export.ganglia.step=1m # Step size (i.e. reporting
frequency) to use.
management.metrics.export.ganglia.time-to-live=1 # Time to live for metrics
on Ganglia. Set the multi-cast Time-To-Live to be one greater than the
number of hops (routers) between the hosts.
management.metrics.export.graphite.duration-units=milliseconds # Base time
unit used to report durations.
management.metrics.export.graphite.enabled=true # Whether exporting of
metrics to Graphite is enabled.
management.metrics.export.graphite.host=localhost # Host of the Graphite
server to receive exported metrics.

112
management.metrics.export.graphite.port=2004 # Port of the Graphite server
to receive exported metrics.
management.metrics.export.graphite.protocol=pickled # Protocol to use while
shipping data to Graphite.
management.metrics.export.graphite.rate-units=seconds # Base time unit used
to report rates.
management.metrics.export.graphite.step=1m # Step size (i.e. reporting
frequency) to use.
management.metrics.export.graphite.tags-as-prefix= # For the default naming
convention, turn the specified tag keys into part of the metric prefix.
management.metrics.export.influx.auto-create-db=true # Whether to create
the Influx database if it does not exist before attempting to publish
metrics to it.
management.metrics.export.influx.batch-size=10000 # Number of measurements
per request to use for this backend. If more measurements are found, then
multiple requests will be made.
management.metrics.export.influx.compressed=true # Whether to enable GZIP
compression of metrics batches published to Influx.
management.metrics.export.influx.connect-timeout=1s # Connection timeout
for requests to this backend.
management.metrics.export.influx.consistency=one # Write consistency for
each point.
management.metrics.export.influx.db=mydb # Tag that will be mapped to
"host" when shipping metrics to Influx.
management.metrics.export.influx.enabled=true # Whether exporting of
metrics to this backend is enabled.
management.metrics.export.influx.num-threads=2 # Number of threads to use
with the metrics publishing scheduler.
management.metrics.export.influx.password= # Login password of the Influx
server.
management.metrics.export.influx.read-timeout=10s # Read timeout for
requests to this backend.
management.metrics.export.influx.retention-policy= # Retention policy to
use (Influx writes to the DEFAULT retention policy if one is not
specified).
management.metrics.export.influx.step=1m # Step size (i.e. reporting
frequency) to use.
management.metrics.export.influx.uri=http://localhost:8086 # URI of the
Influx server.
management.metrics.export.influx.user-name= # Login user of the Influx
server.
management.metrics.export.jmx.enabled=true # Whether exporting of metrics
to JMX is enabled.
management.metrics.export.jmx.step=1m # Step size (i.e. reporting
frequency) to use.
management.metrics.export.newrelic.account-id= # New Relic account ID.
management.metrics.export.newrelic.api-key= # New Relic API key.
management.metrics.export.newrelic.batch-size=10000 # Number of
measurements per request to use for this backend. If more measurements are
found, then multiple requests will be made.
management.metrics.export.newrelic.connect-timeout=1s # Connection timeout
for requests to this backend.
management.metrics.export.newrelic.enabled=true # Whether exporting of
metrics to this backend is enabled.
management.metrics.export.newrelic.num-threads=2 # Number of threads to use
with the metrics publishing scheduler.
management.metrics.export.newrelic.read-timeout=10s # Read timeout for
requests to this backend.
management.metrics.export.newrelic.step=1m # Step size (i.e. reporting
frequency) to use.

113
management.metrics.export.newrelic.uri=https://insights-
collector.newrelic.com # URI to ship metrics to.
management.metrics.export.prometheus.descriptions=true # Whether to enable
publishing descriptions as part of the scrape payload to Prometheus. Turn
this off to minimize the amount of data sent on each scrape.
management.metrics.export.prometheus.enabled=true # Whether exporting of
metrics to Prometheus is enabled.
management.metrics.export.prometheus.step=1m # Step size (i.e. reporting
frequency) to use.
management.metrics.export.signalfx.access-token= # SignalFX access token.
management.metrics.export.signalfx.batch-size=10000 # Number of
measurements per request to use for this backend. If more measurements are
found, then multiple requests will be made.
management.metrics.export.signalfx.connect-timeout=1s # Connection timeout
for requests to this backend.
management.metrics.export.signalfx.enabled=true # Whether exporting of
metrics to this backend is enabled.
management.metrics.export.signalfx.num-threads=2 # Number of threads to use
with the metrics publishing scheduler.
management.metrics.export.signalfx.read-timeout=10s # Read timeout for
requests to this backend.
management.metrics.export.signalfx.source= # Uniquely identifies the app
instance that is publishing metrics to SignalFx. Defaults to the local host
name.
management.metrics.export.signalfx.step=10s # Step size (i.e. reporting
frequency) to use.
management.metrics.export.signalfx.uri=https://ingest.signalfx.com # URI to
ship metrics to.
management.metrics.export.simple.enabled=true # Whether, in the absence of
any other exporter, exporting of metrics to an in-memory backend is
enabled.
management.metrics.export.simple.mode=cumulative # Counting mode.
management.metrics.export.simple.step=1m # Step size (i.e. reporting
frequency) to use.
management.metrics.export.statsd.enabled=true # Whether exporting of
metrics to StatsD is enabled.
management.metrics.export.statsd.flavor=datadog # StatsD line protocol to
use.
management.metrics.export.statsd.host=localhost # Host of the StatsD server
to receive exported metrics.
management.metrics.export.statsd.max-packet-length=1400 # Total length of a
single payload should be kept within your network's MTU.
management.metrics.export.statsd.polling-frequency=10s # How often gauges
will be polled. When a gauge is polled, its value is recalculated and if
the value has changed (or publishUnchangedMeters is true), it is sent to
the StatsD server.
management.metrics.export.statsd.port=8125 # Port of the StatsD server to
receive exported metrics.
management.metrics.export.statsd.publish-unchanged-meters=true # Whether to
send unchanged meters to the StatsD server.
management.metrics.export.statsd.queue-size=2147483647 # Maximum size of
the queue of items waiting to be sent to the StatsD server.
management.metrics.export.wavefront.api-token= # API token used when
publishing metrics directly to the Wavefront API host.
management.metrics.export.wavefront.batch-size=10000 # Number of
measurements per request to use for this backend. If more measurements are
found, then multiple requests will be made.
management.metrics.export.wavefront.connect-timeout=1s # Connection timeout
for requests to this backend.
management.metrics.export.wavefront.enabled=true # Whether exporting of
metrics to this backend is enabled.

114
management.metrics.export.wavefront.global-prefix= # Global prefix to
separate metrics originating from this app's white box instrumentation from
those originating from other Wavefront integrations when viewed in the
Wavefront UI.
management.metrics.export.wavefront.num-threads=2 # Number of threads to
use with the metrics publishing scheduler.
management.metrics.export.wavefront.read-timeout=10s # Read timeout for
requests to this backend.
management.metrics.export.wavefront.source= # Unique identifier for the app
instance that is the source of metrics being published to Wavefront.
Defaults to the local host name.
management.metrics.export.wavefront.step=10s # Step size (i.e. reporting
frequency) to use.
management.metrics.export.wavefront.uri=https://longboard.wavefront.com #
URI to ship metrics to.
management.metrics.use-global-registry=true # Whether auto-configured
MeterRegistry implementations should be bound to the global static registry
on Metrics.
management.metrics.web.client.max-uri-tags=100 # Maximum number of unique
URI tag values allowed. After the max number of tag values is reached,
metrics with additional tag values are denied by filter.
management.metrics.web.client.requests-metric-name=http.client.requests #
Name of the metric for sent requests.
management.metrics.web.server.auto-time-requests=true # Whether requests
handled by Spring MVC or WebFlux should be automatically timed.
management.metrics.web.server.requests-metric-name=http.server.requests #
Name of the metric for received requests.

# ----------------------------------------
# DEVTOOLS PROPERTIES
# ----------------------------------------

# DEVTOOLS (DevToolsProperties)
spring.devtools.livereload.enabled=true # Whether to enable a
livereload.com-compatible server.
spring.devtools.livereload.port=35729 # Server port.
spring.devtools.restart.additional-exclude= # Additional patterns that
should be excluded from triggering a full restart.
spring.devtools.restart.additional-paths= # Additional paths to watch for
changes.
spring.devtools.restart.enabled=true # Whether to enable automatic restart.
spring.devtools.restart.exclude=META-INF/maven/**,META-
INF/resources/**,resources/**,static/**,public/**,templates/**,**/*Test.cla
ss,**/*Tests.class,git.properties,META-INF/build-info.properties # Patterns
that should be excluded from triggering a full restart.
spring.devtools.restart.log-condition-evaluation-delta=true # Whether to
log the condition evaluation delta upon restart.
spring.devtools.restart.poll-interval=1s # Amount of time to wait between
polling for classpath changes.
spring.devtools.restart.quiet-period=400ms # Amount of quiet time required
without any classpath changes before a restart is triggered.
spring.devtools.restart.trigger-file= # Name of a specific file that, when
changed, triggers the restart check. If not specified, any classpath file
change triggers the restart.

# REMOTE DEVTOOLS (RemoteDevToolsProperties)

spring.devtools.remote.context-path=/.~~spring-boot!~ # Context path used
to handle the remote connection.
spring.devtools.remote.proxy.host= # The host of the proxy to use to
connect to the remote application.

115
spring.devtools.remote.proxy.port= # The port of the proxy to use to
connect to the remote application.
spring.devtools.remote.restart.enabled=true # Whether to enable remote
restart.
spring.devtools.remote.secret= # A shared secret required to establish a
connection (required to enable remote support).
spring.devtools.remote.secret-header-name=X-AUTH-TOKEN # HTTP header used
to transfer the shared secret.

# ----------------------------------------
# TESTING PROPERTIES
# ----------------------------------------

spring.test.database.replace=any # Type of existing DataSource to replace.

spring.test.mockmvc.print=default # MVC Print option.

116