spring-boot/spring-boot-docs/src/main/asciidoc/appendix-application-properties.adoc

:numbered!:
[appendix]
[[common-application-properties]]
== Common application properties
Various properties can be specified inside your `application.properties`/`application.yml`
file or as command line switches. This section provides a list common Spring Boot
properties and references to the underlying classes that consume them.

NOTE: Property contributions can come from additional jar files on your classpath so
you should not consider this an exhaustive list. It is also perfectly legit to define
your own properties.

WARNING: This sample file is meant as a guide only. Do **not** copy/paste the entire
content into your application; rather pick only the properties that you need.


[source,properties,indent=0,subs="verbatim,attributes,macros"]
----
	# ===================================================================
	# COMMON SPRING BOOT PROPERTIES
	#
	# This sample file is provided as a guideline. Do NOT copy it in its
	# entirety to your own application.               ^^^
	# ===================================================================

	# ----------------------------------------
	# CORE PROPERTIES
	# ----------------------------------------

	# SPRING CONFIG ({sc-spring-boot}/context/config/ConfigFileApplicationListener.{sc-ext}[ConfigFileApplicationListener])
	spring.config.name= # config file name (default to 'application')
	spring.config.location= # location of config file

	# PROFILES
	spring.profiles.active= # comma list of <<howto-set-active-spring-profiles,active profiles>>
	spring.profiles.include= # unconditionally activate the specified comma separated profiles

	# APPLICATION SETTINGS ({sc-spring-boot}/SpringApplication.{sc-ext}[SpringApplication])
	spring.main.sources=
	spring.main.web-environment= # detect by default
	spring.main.show-banner=true
	spring.main....= # see class for all properties

	# LOGGING
	logging.path=/var/logs
	logging.file=myapp.log
	logging.config= # location of config file (default classpath:logback.xml for logback)
	logging.level.*= # levels for loggers, e.g. "logging.level.org.springframework=DEBUG" (TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF)

	# IDENTITY ({sc-spring-boot}/context/ContextIdApplicationContextInitializer.{sc-ext}[ContextIdApplicationContextInitializer])
	spring.application.name=
	spring.application.index=

	# EMBEDDED SERVER CONFIGURATION ({sc-spring-boot-autoconfigure}/web/ServerProperties.{sc-ext}[ServerProperties])
	server.port=8080
	server.address= # bind to a specific NIC
	server.session-timeout= # session timeout in seconds
	server.context-parameters.*= # Servlet context init parameters, e.g. server.context-parameters.a=alpha
	server.context-path= # the context path, defaults to '/'
	server.servlet-path= # the servlet path, defaults to '/'
	server.ssl.enabled=true # if SSL support is enabled
	server.ssl.client-auth= # want or need
	server.ssl.key-alias=
	server.ssl.ciphers= # supported SSL ciphers
	server.ssl.key-password=
	server.ssl.key-store=
	server.ssl.key-store-password=
	server.ssl.key-store-provider=
	server.ssl.key-store-type=
	server.ssl.protocol=TLS
	server.ssl.trust-store=
	server.ssl.trust-store-password=
	server.ssl.trust-store-provider=
	server.ssl.trust-store-type=
	server.tomcat.access-log-pattern= # log pattern of the access log
	server.tomcat.access-log-enabled=false # is access logging enabled
	server.tomcat.compression=off # is compression enabled (off, on, or an integer content length limit)
	server.tomcat.compressableMimeTypes=text/html,text/xml,text/plain # comma-separated list of mime types that Tomcat will compress
	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} # regular expression matching trusted IP addresses
	server.tomcat.protocol-header=x-forwarded-proto # front end proxy forward header
	server.tomcat.port-header= # front end proxy port header
	server.tomcat.remote-ip-header=x-forwarded-for
	server.tomcat.basedir=/tmp # base dir (usually not needed, defaults to tmp)
	server.tomcat.background-processor-delay=30; # in seconds
	server.tomcat.max-http-header-size= # maximum size in bytes of the HTTP message header
	server.tomcat.max-threads = 0 # number of threads in protocol handler
	server.tomcat.uri-encoding = UTF-8 # character encoding to use for URL decoding

	# SPRING MVC ({sc-spring-boot-autoconfigure}/web/WebMvcProperties.{sc-ext}[WebMvcProperties])
	spring.mvc.locale= # set fixed locale, e.g. en_UK
	spring.mvc.date-format= # set fixed date format, e.g. dd/MM/yyyy
	spring.mvc.favicon.enabled=true
	spring.mvc.message-codes-resolver-format= # PREFIX_ERROR_CODE / POSTFIX_ERROR_CODE
	spring.mvc.ignore-default-model-on-redirect=true # If the the content of the "default" model should be ignored redirects
	spring.view.prefix= # MVC view prefix
	spring.view.suffix= # ... and suffix

	# SPRING RESOURCES HANDLING ({sc-spring-boot-autoconfigure}/web/ResourceProperties.{sc-ext}[ResourceProperties])
	spring.resources.cache-period= # cache timeouts in headers sent to browser
	spring.resources.add-mappings=true # if default mappings should be added

	# MULTIPART ({sc-spring-boot-autoconfigure}/web/MultipartProperties.{sc-ext}[MultipartProperties])
	multipart.enabled=true
	multipart.file-size-threshold=0 # Threshold after which files will be written to disk.
	multipart.location= # Intermediate location of uploaded files.
	multipart.max-file-size=1Mb # Max file size.
	multipart.max-request-size=10Mb # Max request size.

	# SPRING HATEOAS ({sc-spring-boot-autoconfigure}/hateoas/HateoasProperties.{sc-ext}[HateoasProperties])
	spring.hateoas.apply-to-primary-object-mapper=true # if the primary mapper should also be configured

	# HTTP encoding ({sc-spring-boot-autoconfigure}/web/HttpEncodingProperties.{sc-ext}[HttpEncodingProperties])
	spring.http.encoding.charset=UTF-8 # the encoding of HTTP requests/responses
	spring.http.encoding.enabled=true # enable http encoding support
	spring.http.encoding.force=true # force the configured encoding

	# HTTP message conversion
	spring.http.converters.preferred-json-mapper= # the preferred JSON mapper to use for HTTP message conversion. Set to "gson" to force the use of Gson when both it and Jackson are on the classpath.

	# HTTP response compression ({sc-spring-boot-autoconfigure}/web/GzipFilterProperties.{sc-ext}[GzipFilterProperties])
	spring.http.gzip.bufferSize= # size of the output buffer in bytes
	spring.http.gzip.deflateCompressionLevel= # the level used for deflate compression (0-9)
	spring.http.gzip.deflateNoWrap= # noWrap setting for deflate compression (true or false)
	spring.http.gzip.enabled=true # enable gzip filter support
	spring.http.gzip.excludedAgents= # comma-separated list of user agents to exclude from compression
	spring.http.gzip.excludedAgentPatterns= # comma-separated list of regular expression patterns to control user agents excluded from compression
	spring.http.gzip.excludedPaths= # comma-separated list of paths to exclude from compression
	spring.http.gzip.excludedPathPatterns= # comma-separated list of regular expression patterns to control the paths that are excluded from compression
	spring.http.gzip.methods= # comma-separated list of HTTP methods for which compression is enabled
	spring.http.gzip.mimeTypes= # comma-separated list of MIME types which should be compressed
	spring.http.gzip.minGzipSize= # minimum content length required for compression to occur
	spring.http.gzip.vary= # Vary header to be sent on responses that may be compressed

	# JACKSON ({sc-spring-boot-autoconfigure}/jackson/JacksonProperties.{sc-ext}[JacksonProperties])
	spring.jackson.date-format= # Date format string (e.g. yyyy-MM-dd HH:mm:ss), or a fully-qualified date format class name (e.g. com.fasterxml.jackson.databind.util.ISO8601DateFormat)
	spring.jackson.property-naming-strategy= # One of the constants on Jackson's PropertyNamingStrategy (e.g. CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES) or the fully-qualified class name of a PropertyNamingStrategy subclass
	spring.jackson.deserialization.*= # see Jackson's DeserializationFeature
	spring.jackson.generator.*= # see Jackson's JsonGenerator.Feature
	spring.jackson.mapper.*= # see Jackson's MapperFeature
	spring.jackson.parser.*= # see Jackson's JsonParser.Feature
	spring.jackson.serialization.*= # see Jackson's SerializationFeature
	spring.jackson.serialization-inclusion= # Controls the inclusion of properties during serialization (see Jackson's JsonInclude.Include)

	# THYMELEAF ({sc-spring-boot-autoconfigure}/thymeleaf/ThymeleafAutoConfiguration.{sc-ext}[ThymeleafAutoConfiguration])
	spring.thymeleaf.check-template-location=true
	spring.thymeleaf.prefix=classpath:/templates/
	spring.thymeleaf.excluded-view-names= # comma-separated list of view names that should be excluded from resolution
	spring.thymeleaf.view-names= # comma-separated list of view names that can be resolved
	spring.thymeleaf.suffix=.html
	spring.thymeleaf.mode=HTML5
	spring.thymeleaf.encoding=UTF-8
	spring.thymeleaf.content-type=text/html # ;charset=<encoding> is added
	spring.thymeleaf.cache=true # set to false for hot refresh

	# FREEMARKER ({sc-spring-boot-autoconfigure}/freemarker/FreeMarkerAutoConfiguration.{sc-ext}[FreeMarkerAutoConfiguration])
	spring.freemarker.allow-request-override=false
	spring.freemarker.cache=true
	spring.freemarker.check-template-location=true
	spring.freemarker.charset=UTF-8
	spring.freemarker.content-type=text/html
	spring.freemarker.expose-request-attributes=false
	spring.freemarker.expose-session-attributes=false
	spring.freemarker.expose-spring-macro-helpers=false
	spring.freemarker.prefix=
	spring.freemarker.request-context-attribute=
	spring.freemarker.settings.*=
	spring.freemarker.suffix=.ftl
	spring.freemarker.template-loader-path=classpath:/templates/ # comma-separated list
	spring.freemarker.view-names= # whitelist of view names that can be resolved

	# GROOVY TEMPLATES ({sc-spring-boot-autoconfigure}/groovy/template/GroovyTemplateAutoConfiguration.{sc-ext}[GroovyTemplateAutoConfiguration])
	spring.groovy.template.cache=true
	spring.groovy.template.charset=UTF-8
	spring.groovy.template.configuration.*= # See Groovy's TemplateConfiguration
	spring.groovy.template.content-type=text/html
	spring.groovy.template.prefix=classpath:/templates/
	spring.groovy.template.suffix=.tpl
	spring.groovy.template.view-names= # whitelist of view names that can be resolved

	# VELOCITY TEMPLATES ({sc-spring-boot-autoconfigure}/velocity/VelocityAutoConfiguration.{sc-ext}[VelocityAutoConfiguration])
	spring.velocity.allow-request-override=false
	spring.velocity.cache=true
	spring.velocity.check-template-location=true
	spring.velocity.charset=UTF-8
	spring.velocity.content-type=text/html
	spring.velocity.date-tool-attribute=
	spring.velocity.expose-request-attributes=false
	spring.velocity.expose-session-attributes=false
	spring.velocity.expose-spring-macro-helpers=false
	spring.velocity.number-tool-attribute=
	spring.velocity.prefer-file-system-access=true # prefer file system access for template loading
	spring.velocity.prefix=
	spring.velocity.properties.*=
	spring.velocity.request-context-attribute=
	spring.velocity.resource-loader-path=classpath:/templates/
	spring.velocity.suffix=.vm
	spring.velocity.toolbox-config-location= # velocity Toolbox config location, for example "/WEB-INF/toolbox.xml"
	spring.velocity.view-names= # whitelist of view names that can be resolved

	# JERSEY ({sc-spring-boot-autoconfigure}}/jersey/JerseyProperties.{sc-ext}[JerseyProperties])
	spring.jersey.type=servlet # servlet or filter
	spring.jersey.init= # init params
	spring.jersey.filter.order=

	# INTERNATIONALIZATION ({sc-spring-boot-autoconfigure}/MessageSourceAutoConfiguration.{sc-ext}[MessageSourceAutoConfiguration])
	spring.messages.basename=messages
	spring.messages.cache-seconds=-1
	spring.messages.encoding=UTF-8

	[[common-application-properties-security]]
	# SECURITY ({sc-spring-boot-autoconfigure}/security/SecurityProperties.{sc-ext}[SecurityProperties])
	security.user.name=user # login username
	security.user.password= # login password
	security.user.role=USER # role assigned to the user
	security.require-ssl=false # advanced settings ...
	security.enable-csrf=false
	security.basic.enabled=true
	security.basic.realm=Spring
	security.basic.path= # /**
	security.basic.authorize-mode= # ROLE, AUTHENTICATED, NONE
	security.filter-order=0
	security.headers.xss=false
	security.headers.cache=false
	security.headers.frame=false
	security.headers.content-type=false
	security.headers.hsts=all # none / domain / all
	security.sessions=stateless # always / never / if_required / stateless
	security.ignored= # Comma-separated list of paths to exclude from the default secured paths

	# DATASOURCE ({sc-spring-boot-autoconfigure}/jdbc/DataSourceAutoConfiguration.{sc-ext}[DataSourceAutoConfiguration] & {sc-spring-boot-autoconfigure}/jdbc/DataSourceProperties.{sc-ext}[DataSourceProperties])
	spring.datasource.name= # name of the data source
	spring.datasource.initialize=true # populate using data.sql
	spring.datasource.schema= # a schema (DDL) script resource reference
	spring.datasource.data= # a data (DML) script resource reference
	spring.datasource.sql-script-encoding= # a charset for reading SQL scripts
	spring.datasource.platform= # the platform to use in the schema resource (schema-${platform}.sql)
	spring.datasource.continue-on-error=false # continue even if can't be initialized
	spring.datasource.separator=; # statement separator in SQL initialization scripts
	spring.datasource.driver-class-name= # JDBC Settings...
	spring.datasource.url=
	spring.datasource.username=
	spring.datasource.password=
	spring.datasource.jndi-name= # For JNDI lookup (class, url, username & password are ignored when set)
	spring.datasource.max-active=100 # Advanced configuration...
	spring.datasource.max-idle=8
	spring.datasource.min-idle=8
	spring.datasource.initial-size=10
	spring.datasource.validation-query=
	spring.datasource.test-on-borrow=false
	spring.datasource.test-on-return=false
	spring.datasource.test-while-idle=
	spring.datasource.time-between-eviction-runs-millis=
	spring.datasource.min-evictable-idle-time-millis=
	spring.datasource.max-wait=
	spring.datasource.jmx-enabled=false # Export JMX MBeans (if supported)

	# DAO ({sc-spring-boot-autoconfigure}/dao/PersistenceExceptionTranslationAutoConfiguration.{sc-ext}[PersistenceExceptionTranslationAutoConfiguration])
	spring.dao.exceptiontranslation.enabled=true

	# MONGODB ({sc-spring-boot-autoconfigure}/mongo/MongoProperties.{sc-ext}[MongoProperties])
	spring.data.mongodb.host= # the db host
	spring.data.mongodb.port=27017 # the connection port (defaults to 27107)
	spring.data.mongodb.uri=mongodb://localhost/test # connection URL
	spring.data.mongodb.database=
	spring.data.mongodb.authentication-database=
	spring.data.mongodb.grid-fs-database=
	spring.data.mongodb.username=
	spring.data.mongodb.password=
	spring.data.mongodb.repositories.enabled=true # if spring data repository support is enabled

	# JPA ({sc-spring-boot-autoconfigure}/orm/jpa/JpaBaseConfiguration.{sc-ext}[JpaBaseConfiguration], {sc-spring-boot-autoconfigure}/orm/jpa/HibernateJpaAutoConfiguration.{sc-ext}[HibernateJpaAutoConfiguration])
	spring.jpa.properties.*= # properties to set on the JPA connection
	spring.jpa.open-in-view=true
	spring.jpa.show-sql=true
	spring.jpa.database-platform=
	spring.jpa.database=
	spring.jpa.generate-ddl=false # ignored by Hibernate, might be useful for other vendors
	spring.jpa.hibernate.naming-strategy= # naming classname
	spring.jpa.hibernate.ddl-auto= # defaults to create-drop for embedded dbs
	spring.data.jpa.repositories.enabled=true # if spring data repository support is enabled

	# JTA ({sc-spring-boot-autoconfigure}/jta/JtaAutoConfiguration.{sc-ext}[JtaAutoConfiguration])
	spring.jta.log-dir= # transaction log dir
	spring.jta.*= # technology specific configuration

	# ATOMIKOS
	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 or not to ignore the transacted flag when creating session
	spring.jta.atomikos.connectionfactory.local-transaction-mode=false # Whether or not local transactions are desired
	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.datasource.borrow-connection-timeout=30 # Timeout, in seconds, for borrowing connections from the pool
	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

	# 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 or not the transaction manager should allow mixing XA and non-XA transactions
	spring.jta.bitronix.connectionfactory.apply-transaction-timeout=false # Whether or not the transaction timeout should be set on the XAResource when it is enlisted
	spring.jta.bitronix.connectionfactory.automatic-enlisting-enabled=true # Whether or not resources should be enlisted and delisted automatically
	spring.jta.bitronix.connectionfactory.cache-producers-consumers=true # Whether or not produces and consumers should be cached
	spring.jta.bitronix.connectionfactory.defer-connection-release=true # Whether or not the provider can run many transactions on the same connection and supports transaction interleaving
	spring.jta.bitronix.connectionfactory.ignore-recovery-failures=false # Whether or not 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
	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 or not connections in the ACCESSIBLE state can be shared within the context of a transaction
	spring.jta.bitronix.connectionfactory.test-connections=true # Whether or not connections should be tested when acquired from the pool
	spring.jta.bitronix.connectionfactory.two-pc-ordering-position=1 # The postion 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 or not 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 or not the transaction manager should allow mixing XA and non-XA transactions
	spring.jta.bitronix.datasource.apply-transaction-timeout=false # Whether or not the transaction timeout should be set on the XAResource when it is enlisted
	spring.jta.bitronix.datasource.automatic-enlisting-enabled=true # Whether or not resources should be enlisted and delisted automatically
	spring.jta.bitronix.datasource.cursor-holdability= # The default cursor holdability for connections
	spring.jta.bitronix.datasource.defer-connection-release=true # Whether or not the database can run many transactions on the same connection and supports transaction interleaving
	spring.jta.bitronix.datasource.enable-jdbc4-connection-test # Whether or not Connection.isValid() is called when acquiring a connection from the pool
	spring.jta.bitronix.datasource.ignore-recovery-failures=false # Whether or not 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
	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 or not 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 postion that this resource should take during two-phase commit (always first is Integer.MIN_VALUE, 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 or not TMJOIN should be used when starting XAResources

	# SOLR ({sc-spring-boot-autoconfigure}/solr/SolrProperties.{sc-ext}[SolrProperties])
	spring.data.solr.host=http://127.0.0.1:8983/solr
	spring.data.solr.zk-host=
	spring.data.solr.repositories.enabled=true # if spring data repository support is enabled

	# ELASTICSEARCH ({sc-spring-boot-autoconfigure}/elasticsearch/ElasticsearchProperties.{sc-ext}[ElasticsearchProperties])
	spring.data.elasticsearch.cluster-name= # The cluster name (defaults to elasticsearch)
	spring.data.elasticsearch.cluster-nodes= # The address(es) of the server node (comma-separated; if not specified starts a client node)
	spring.data.elasticsearch.properties.*= # Additional properties used to configure the client
	spring.data.elasticsearch.repositories.enabled=true # if spring data repository support is enabled

	# DATA REST ({spring-data-rest-javadoc}/core/config/RepositoryRestConfiguration.{dc-ext}[RepositoryRestConfiguration])
	spring.data.rest.base-uri= # base URI against which the exporter should calculate its links

	# FLYWAY ({sc-spring-boot-autoconfigure}/flyway/FlywayProperties.{sc-ext}[FlywayProperties])
	flyway.check-location=false # check that migration scripts location exists
	flyway.locations=classpath:db/migration # locations of migrations scripts
	flyway.schemas= # schemas to update
	flyway.init-version= 1 # version to start migration
	flyway.init-sqls= # SQL statements to execute to initialize a connection immediately after obtaining it
	flyway.sql-migration-prefix=V
	flyway.sql-migration-suffix=.sql
	flyway.enabled=true
	flyway.url= # JDBC url if you want Flyway to create its own DataSource
	flyway.user= # JDBC username if you want Flyway to create its own DataSource
	flyway.password= # JDBC password if you want Flyway to create its own DataSource

	# LIQUIBASE ({sc-spring-boot-autoconfigure}/liquibase/LiquibaseProperties.{sc-ext}[LiquibaseProperties])
	liquibase.change-log=classpath:/db/changelog/db.changelog-master.yaml
	liquibase.check-change-log-location=true # check the change log location exists
	liquibase.contexts= # runtime contexts to use
	liquibase.default-schema= # default database schema to use
	liquibase.drop-first=false
	liquibase.enabled=true
	liquibase.url= # specific JDBC url (if not set the default datasource is used)
	liquibase.user= # user name for liquibase.url
	liquibase.password= # password for liquibase.url

	# JMX
	spring.jmx.enabled=true # Expose MBeans from Spring

	# RABBIT ({sc-spring-boot-autoconfigure}/amqp/RabbitProperties.{sc-ext}[RabbitProperties])
	spring.rabbitmq.host= # connection host
	spring.rabbitmq.port= # connection port
	spring.rabbitmq.addresses= # connection addresses (e.g. myhost:9999,otherhost:1111)
	spring.rabbitmq.username= # login user
	spring.rabbitmq.password= # login password
	spring.rabbitmq.virtual-host=
	spring.rabbitmq.dynamic=

	# REDIS ({sc-spring-boot-autoconfigure}/redis/RedisProperties.{sc-ext}[RedisProperties])
	spring.redis.database= # database name
	spring.redis.host=localhost # server host
	spring.redis.password= # server password
	spring.redis.port=6379 # connection port
	spring.redis.pool.max-idle=8 # pool settings ...
	spring.redis.pool.min-idle=0
	spring.redis.pool.max-active=8
	spring.redis.pool.max-wait=-1
	spring.redis.sentinel.master= # name of Redis server
	spring.redis.sentinel.nodes= # comma-separated list of host:port pairs

	# ACTIVEMQ ({sc-spring-boot-autoconfigure}/jms/activemq/ActiveMQProperties.{sc-ext}[ActiveMQProperties])
	spring.activemq.broker-url=tcp://localhost:61616 # connection URL
	spring.activemq.user=
	spring.activemq.password=
	spring.activemq.in-memory=true # broker kind to create if no broker-url is specified
	spring.activemq.pooled=false

	# HornetQ ({sc-spring-boot-autoconfigure}/jms/hornetq/HornetQProperties.{sc-ext}[HornetQProperties])
	spring.hornetq.mode= # connection mode (native, embedded)
	spring.hornetq.host=localhost # hornetQ host (native mode)
	spring.hornetq.port=5445 # hornetQ port (native mode)
	spring.hornetq.embedded.enabled=true # if the embedded server is enabled (needs hornetq-jms-server.jar)
	spring.hornetq.embedded.server-id= # auto-generated id of the embedded server (integer)
	spring.hornetq.embedded.persistent=false # message persistence
	spring.hornetq.embedded.data-directory= # location of data content (when persistence is enabled)
	spring.hornetq.embedded.queues= # comma-separated queues to create on startup
	spring.hornetq.embedded.topics= # comma-separated topics to create on startup
	spring.hornetq.embedded.cluster-password= # customer password (randomly generated by default)

	# JMS ({sc-spring-boot-autoconfigure}/jms/JmsProperties.{sc-ext}[JmsProperties])
	spring.jms.jndi-name= # JNDI location of a JMS ConnectionFactory
	spring.jms.pub-sub-domain= # false for queue (default), true for topic

	# Email ({sc-spring-boot-autoconfigure}/mail/MailProperties.{sc-ext}[MailProperties])
	spring.mail.host=smtp.acme.org # mail server host
	spring.mail.port= # mail server port
	spring.mail.username=
	spring.mail.password=
	spring.mail.default-encoding=UTF-8 # encoding to use for MimeMessages
	spring.mail.properties.*= # properties to set on the JavaMail session

	# SPRING BATCH ({sc-spring-boot-autoconfigure}/batch/BatchDatabaseInitializer.{sc-ext}[BatchDatabaseInitializer])
	spring.batch.job.names=job1,job2
	spring.batch.job.enabled=true
	spring.batch.initializer.enabled=true
	spring.batch.schema= # batch schema to load

	# AOP
	spring.aop.auto=
	spring.aop.proxy-target-class=

	# FILE ENCODING ({sc-spring-boot}/context/FileEncodingApplicationListener.{sc-ext}[FileEncodingApplicationListener])
	spring.mandatory-file-encoding=false

	# SPRING SOCIAL ({sc-spring-boot-autoconfigure}/social/SocialWebAutoConfiguration.{sc-ext}[SocialWebAutoConfiguration])
	spring.social.auto-connection-views=true # Set to true for default connection views or false if you provide your own

	# SPRING SOCIAL FACEBOOK ({sc-spring-boot-autoconfigure}/social/FacebookAutoConfiguration.{sc-ext}[FacebookAutoConfiguration])
	spring.social.facebook.app-id= # your application's Facebook App ID
	spring.social.facebook.app-secret= # your application's Facebook App Secret

	# SPRING SOCIAL LINKEDIN ({sc-spring-boot-autoconfigure}/social/LinkedInAutoConfiguration.{sc-ext}[LinkedInAutoConfiguration])
	spring.social.linkedin.app-id= # your application's LinkedIn App ID
	spring.social.linkedin.app-secret= # your application's LinkedIn App Secret

	# SPRING SOCIAL TWITTER ({sc-spring-boot-autoconfigure}/social/TwitterAutoConfiguration.{sc-ext}[TwitterAutoConfiguration])
	spring.social.twitter.app-id= # your application's Twitter App ID
	spring.social.twitter.app-secret= # your application's Twitter App Secret

	# SPRING MOBILE SITE PREFERENCE ({sc-spring-boot-autoconfigure}/mobile/SitePreferenceAutoConfiguration.{sc-ext}[SitePreferenceAutoConfiguration])
	spring.mobile.sitepreference.enabled=true # enabled by default

	# SPRING MOBILE DEVICE VIEWS ({sc-spring-boot-autoconfigure}/mobile/DeviceDelegatingViewResolverAutoConfiguration.{sc-ext}[DeviceDelegatingViewResolverAutoConfiguration])
	spring.mobile.devicedelegatingviewresolver.enabled=true # disabled by default
	spring.mobile.devicedelegatingviewresolver.normal-prefix=
	spring.mobile.devicedelegatingviewresolver.normal-suffix=
	spring.mobile.devicedelegatingviewresolver.mobile-prefix=mobile/
	spring.mobile.devicedelegatingviewresolver.mobile-suffix=
	spring.mobile.devicedelegatingviewresolver.tablet-prefix=tablet/
	spring.mobile.devicedelegatingviewresolver.tablet-suffix=

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

	# MANAGEMENT HTTP SERVER ({sc-spring-boot-actuator}/autoconfigure/ManagementServerProperties.{sc-ext}[ManagementServerProperties])
	management.port= # defaults to 'server.port'
	management.address= # bind to a specific NIC
	management.context-path= # default to '/'
	management.add-application-context-header= # default to true
	management.security.enabled=true # enable security
	management.security.role=ADMIN # role required to access the management endpoint
	management.security.sessions=stateless # session creating policy to use (always, never, if_required, stateless)

	# PID FILE ({sc-spring-boot-actuator}/system/ApplicationPidFileWriter.{sc-ext}[ApplicationPidFileWriter])
	spring.pidfile= # Location of the PID file to write

	# ENDPOINTS ({sc-spring-boot-actuator}/endpoint/AbstractEndpoint.{sc-ext}[AbstractEndpoint] subclasses)
	endpoints.autoconfig.id=autoconfig
	endpoints.autoconfig.sensitive=true
	endpoints.autoconfig.enabled=true
	endpoints.beans.id=beans
	endpoints.beans.sensitive=true
	endpoints.beans.enabled=true
	endpoints.configprops.id=configprops
	endpoints.configprops.sensitive=true
	endpoints.configprops.enabled=true
	endpoints.configprops.keys-to-sanitize=password,secret,key # suffix or regex
	endpoints.dump.id=dump
	endpoints.dump.sensitive=true
	endpoints.dump.enabled=true
	endpoints.env.id=env
	endpoints.env.sensitive=true
	endpoints.env.enabled=true
	endpoints.env.keys-to-sanitize=password,secret,key # suffix or regex
	endpoints.health.id=health
	endpoints.health.sensitive=true
	endpoints.health.enabled=true
	endpoints.health.mapping.*= # mapping of health statuses to HttpStatus codes
	endpoints.health.time-to-live=1000
	endpoints.info.id=info
	endpoints.info.sensitive=false
	endpoints.info.enabled=true
	endpoints.mappings.enabled=true
	endpoints.mappings.id=mappings
	endpoints.mappings.sensitive=true
	endpoints.metrics.id=metrics
	endpoints.metrics.sensitive=true
	endpoints.metrics.enabled=true
	endpoints.shutdown.id=shutdown
	endpoints.shutdown.sensitive=true
	endpoints.shutdown.enabled=false
	endpoints.trace.id=trace
	endpoints.trace.sensitive=true
	endpoints.trace.enabled=true

	# HEALTH INDICATORS (previously health.*)
	management.health.db.enabled=true
	management.health.elasticsearch.enabled=true
	management.health.elasticsearch.response-timeout=100 # the time, in milliseconds, to wait for a response from the cluster
	management.health.diskspace.enabled=true
	management.health.diskspace.path=.
	management.health.diskspace.threshold=10485760
	management.health.mongo.enabled=true
	management.health.rabbit.enabled=true
	management.health.redis.enabled=true
	management.health.solr.enabled=true
	management.health.status.order=DOWN, OUT_OF_SERVICE, UNKNOWN, UP

	# MVC ONLY ENDPOINTS
	endpoints.jolokia.path=jolokia
	endpoints.jolokia.sensitive=true
	endpoints.jolokia.enabled=true # when using Jolokia

	# JMX ENDPOINT ({sc-spring-boot-actuator}/autoconfigure/EndpointMBeanExportProperties.{sc-ext}[EndpointMBeanExportProperties])
	endpoints.jmx.enabled=true
	endpoints.jmx.domain= # the JMX domain, defaults to 'org.springboot'
	endpoints.jmx.unique-names=false
	endpoints.jmx.static-names=

	# JOLOKIA ({sc-spring-boot-actuator}/autoconfigure/JolokiaProperties.{sc-ext}[JolokiaProperties])
	jolokia.config.*= # See Jolokia manual

	# REMOTE SHELL
	shell.auth=simple # jaas, key, simple, spring
	shell.command-refresh-interval=-1
	shell.command-path-patterns= # classpath*:/commands/**, classpath*:/crash/commands/**
	shell.config-path-patterns= # classpath*:/crash/*
	shell.disabled-commands=jpa*,jdbc*,jndi* # comma-separated list of commands to disable
	shell.disabled-plugins=false # don't expose plugins
	shell.ssh.enabled= # ssh settings ...
	shell.ssh.key-path=
	shell.ssh.port=
	shell.telnet.enabled= # telnet settings ...
	shell.telnet.port=
	shell.auth.jaas.domain= # authentication settings ...
	shell.auth.key.path=
	shell.auth.simple.user.name=
	shell.auth.simple.user.password=
	shell.auth.spring.roles=

	# SENDGRID ({sc-spring-boot-autoconfigure}/sendgrid/SendGridAutoConfiguration.{sc-ext}[SendGridAutoConfiguration])
	spring.sendgrid.username= # SendGrid account username
	spring.sendgrid.password= # SendGrid account password
	spring.sendgrid.proxy.host= # SendGrid proxy host
	spring.sendgrid.proxy.port= # SendGrid proxy port

	# GIT INFO
	spring.git.properties= # resource ref to generated git info properties file
----