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.

# ===================================================================
# 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
# ----------------------------------------
# BANNER
banner.charset=UTF-8 # banner file encoding
banner.location=classpath:banner.txt # banner file location
# SPRING CONFIG (ConfigFileEnvironmentPostProcessor)
spring.config.name= # config file name (default to 'application')
spring.config.location= # location of config file
# PROFILES
spring.profiles.active= # comma list of active profiles
spring.profiles.include= # unconditionally activate the specified comma separated profiles
# APPLICATION SETTINGS (SpringApplication)
spring.main.sources= # sources (class name, package name or XML resource location) to include
spring.main.web-environment= # detect by default
spring.main.show-banner=true
spring.main.banner-mode=console # mode used to display the banner when the application runs (console, off, or log)
spring.main....= # see class for all properties
# AUTO-CONFIGURATION
spring.autoconfigure.exclude= # comma-separated list of auto-configuration classes to exclude
# ADMIN (SpringApplicationAdminJmxAutoConfiguration)
spring.application.admin.enabled=false # 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
# OUTPUT
spring.output.ansi.enabled=detect # Configure the ANSI output ("detect", "always", "never")
# LOGGING
logging.config= # location of config file (default classpath:logback.xml for logback)
logging.exception-conversion-word=%rEx # conversion word used when logging exceptions
logging.file=myapp.log
logging.level.*= # levels for loggers, e.g. "logging.level.org.springframework=DEBUG" (TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF)
logging.path=/var/log
logging.pattern.console= # appender pattern for output to the console (only supported with the default logback setup)
logging.pattern.file= # appender pattern for output to the file (only supported with the default logback setup)
logging.pattern.level= # appender pattern for the log level (default %5p, only supported with the default logback setup)
logging.register-shutdown-hook=false # register a shutdown hook for the logging system when it is initialized
# IDENTITY (ContextIdApplicationContextInitializer)
spring.application.name=
spring.application.index=
# EMBEDDED SERVER CONFIGURATION (ServerProperties)
server.port=8080
server.address= # bind to a specific NIC
server.compression.enabled=false # if 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 # comma-separated list of MIME types that should be compressed
server.compression.min-response-size=2048 # minimum response size that is required for compression to be performed
server.context-parameters.*= # Servlet context init parameters, e.g. server.context-parameters.a=alpha
server.context-path= # the context path, defaults to '/'
server.jsp-servlet.class-name=org.apache.jasper.servlet.JspServlet # The class name of the JSP servlet
server.jsp-servlet.init-parameters.*= # Init parameters used to configure the JSP servlet
server.jsp-servlet.registered=true # Whether or not the JSP servlet is registered
server.servlet-path= # the servlet path, defaults to '/'
server.display-name= # the display name of the application
server.use-forward-headers= # if X-Forwarded-* headers should be used (default is off unless running in a known cloud)
server.session.persistent=false # true if session should be saved across restarts
server.session.store-dir= # dir used to save session data
server.session.timeout= # session timeout in seconds
server.session.tracking-modes= # tracking modes (one or more of "cookie" ,"url", "ssl")
server.session.cookie.name= # session cookie name
server.session.cookie.domain= # domain for the session cookie
server.session.cookie.path= # path of the session cookie
server.session.cookie.comment= # comment for the session cookie
server.session.cookie.http-only= # "HttpOnly" flag for the session cookie
server.session.cookie.secure= # "Secure" flag for the session cookie
server.session.cookie.max-age= # maximum age of the session cookie in seconds
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.accesslog.directory=logs # directory in which log files are created
server.tomcat.accesslog.enabled=false # is access logging enabled
server.tomcat.accesslog.pattern= # log pattern of the access log
server.tomcat.accesslog.prefix=access_log # log file name prefix
server.tomcat.accesslog.suffix=.log # log file name suffix
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.protocol-header=x-forwarded-proto # front end proxy forward header
server.tomcat.protocol-header-https-value=https # value of the protocol header that indicates that the incoming request uses SSL
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
server.undertow.accesslog.enabled=false # if access logging is enabled
server.undertow.accesslog.pattern=common # log pattern of the access log
server.undertow.accesslog.dir=logs # access logs directory
server.undertow.buffer-size= # size of each buffer in bytes
server.undertow.buffers-per-region= # number of buffer per region
server.undertow.direct-buffers=false # allocate buffers outside the Java heap
server.undertow.io-threads= # number of I/O threads to create for the worker
server.undertow.worker-threads= # number of worker threads
# ERROR HANDLING (ErrorProperties)
server.error.path=/error # the error path
server.error.include-stacktrace=never # when to include a stacktrace attribute (never/alway/on-trace-param)
server.error.whitelabel.enabled=true # enable the default error page displayed in browsers in case of a server error
# SPRING MVC (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 content of the "default" model should be ignored redirects
spring.mvc.throw-exception-if-no-handler-found=false # if a "NoHandlerFoundException" should be thrown if no Handler was found to process a request
spring.mvc.async.request-timeout= # async request timeout in milliseconds
spring.mvc.view.prefix= # MVC view prefix
spring.mvc.view.suffix= # ... and suffix
# SPRING RESOURCES HANDLING (ResourceProperties)
spring.resources.cache-period= # cache timeouts in headers sent to browser
spring.resources.add-mappings=true # if default mappings should be added
spring.resources.static-locations= # comma-separated list of the locations that serve static content (e.g. 'classpath:/resources/')
spring.resources.chain.enabled=false # enable the Spring Resource Handling chain (enabled automatically if at least a strategy is enabled)
spring.resources.chain.cache=false # enable in-memory caching of resource resolution
spring.resources.chain.html-application-cache=false # enable HTML5 appcache manifest rewriting
spring.resources.chain.strategy.content.enabled=false # enable a content version strategy
spring.resources.chain.strategy.content.paths= # comma-separated list of regular expression patterns to apply the version strategy to
spring.resources.chain.strategy.fixed.enabled=false # enable a fixed version strategy
spring.resources.chain.strategy.fixed.paths= # comma-separated list of regular expression patterns to apply the version strategy to
spring.resources.chain.strategy.fixed.version= # version string to use for this version strategy
# MULTIPART (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.
# H2 Web Console (H2ConsoleProperties)
spring.h2.console.enabled=false # Enable the console
spring.h2.console.path=/h2-console # Path at which the console can be accessed
# SPRING HATEOAS (HateoasProperties)
spring.hateoas.use-hal-as-default-json-media-type=true # if application/hal+json responses should be sent in response to requests for application/json
# HTTP encoding (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.
# JACKSON (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.joda-date-time-format= # Joda date time format string
spring.jackson.locale= # locale used for formatting
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)
spring.jackson.time-zone= # Time zone used when formatting dates. Configured using any recognized time zone identifier, for example "America/Los_Angeles" or "GMT+10"
# THYMELEAF (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.enabled=true # enable MVC view resolution
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
spring.thymeleaf.template-resolver-order= #  order of the template resolver in the chain
# FREEMARKER (FreeMarkerAutoConfiguration)
spring.freemarker.allow-request-override=false
spring.freemarker.allow-session-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.enabled=true # enable MVC view resolution
spring.freemarker.expose-request-attributes=false
spring.freemarker.expose-session-attributes=false
spring.freemarker.expose-spring-macro-helpers=false
spring.freemarker.prefix=
spring.freemarker.prefer-file-system-access=true # prefer file system access for template loading
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 (GroovyTemplateAutoConfiguration)
spring.groovy.template.allow-request-override=false
spring.groovy.template.allow-session-override=false
spring.groovy.template.cache=true
spring.groovy.template.charset=UTF-8
spring.groovy.template.check-template-location=true # check that the templates location exists
spring.groovy.template.configuration.*= # See GroovyMarkupConfigurer
spring.groovy.template.content-type=text/html
spring.groovy.template.enabled=true # enable MVC view resolution
spring.groovy.template.expose-request-attributes=false
spring.groovy.template.expose-session-attributes=false
spring.groovy.template.expose-spring-macro-helpers=false
spring.groovy.template.prefix=
spring.groovy.template.request-context-attribute=
spring.groovy.template.resource-loader-path=classpath:/templates/
spring.groovy.template.suffix=.tpl
spring.groovy.template.view-names= # whitelist of view names that can be resolved
# VELOCITY TEMPLATES (VelocityAutoConfiguration)
spring.velocity.allow-request-override=false
spring.velocity.allow-session-override=false
spring.velocity.cache=true
spring.velocity.check-template-location=true
spring.velocity.charset=UTF-8 # charset for input and output encoding
spring.velocity.content-type=text/html
spring.velocity.date-tool-attribute=
spring.velocity.enabled=true # enable MVC view resolution
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
# MUSTACHE TEMPLATES (MustacheAutoConfiguration)
spring.mustache.cache=true
spring.mustache.charset=UTF-8
spring.mustache.check-template-location=true
spring.mustache.content-type=UTF-8
spring.mustache.enabled=true # enable MVC view resolution
spring.mustache.prefix=
spring.mustache.suffix=.html
spring.mustache.view-names= # whitelist of view names that can be resolved
# JERSEY (JerseyProperties)
spring.jersey.application-path # path that serves as the base URI for the application
spring.jersey.type=servlet # servlet or filter
spring.jersey.init= # init params
spring.jersey.filter.order=
# INTERNATIONALIZATION (MessageSourceAutoConfiguration)
spring.messages.basename=messages
spring.messages.cache-seconds=-1
spring.messages.encoding=UTF-8
spring.messages.fallback-to-system-locale=true # set whether to fall back to the system Locale
# SECURITY (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=true
security.headers.cache=true
security.headers.frame=true
security.headers.content-type=true
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
# SECURITY OAUTH2 CLIENT (OAuth2ClientProperties
security.oauth2.client.client-id= # OAuth2 client id
security.oauth2.client.client-secret= # OAuth2 client secret. A random secret is generated by default
# SECURITY OAUTH2 SSO (OAuth2SsoProperties
security.oauth2.sso.filter-order= # Filter order to apply if not providing an explicit WebSecurityConfigurerAdapter
security.oauth2.sso.login-path= # Path to the login page, i.e. the one that triggers the redirect to the OAuth2 Authorization Server
# DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.name=testdb # 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.type= # fully qualified name of the connection pool implementation to use
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 (PersistenceExceptionTranslationAutoConfiguration)
spring.dao.exceptiontranslation.enabled=true
# CASSANDRA (CassandraProperties)
spring.data.cassandra.cluster-name= # the cluster name
spring.data.cassandra.contact-points=localhost # comma-list of cluster node addresses
spring.data.cassandra.keyspace-name= # the keyspace name
spring.data.cassandra.port= # the connection port
spring.data.cassandra.compression= # compression method (none/snappy/lz4)
spring.data.cassandra.load-balancing-policy= # class name for a LoadBalancingPolicy
spring.data.cassandra.consistency-level= # consistency level (any/one/two/three/quorum/all...)
spring.data.cassandra.serial-consistency-level= # serial consistency level (any/one/two/three/quorum/all...)
spring.data.cassandra.fetch-size=
spring.data.cassandra.reconnection-policy= # class name for a ReconnectionPolicy
spring.data.cassandra.retry-policy= # class name for a RetryPolicy
spring.data.cassandra.connect-timeout-millis= # connect timeout (ms)
spring.data.cassandra.read-timeout-millis= # read timeout (ms)
spring.data.cassandra.ssl=false
# MONGODB (MongoProperties)
spring.data.mongodb.host= # the db host
spring.data.mongodb.port=27017 # the connection port (defaults to 27017)
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
spring.data.mongodb.field-naming-strategy= # fully qualified name of the FieldNamingStrategy to use
# EMBEDDED MONGODB (EmbeddedMongoProperties)
spring.mongodb.embedded.version=2.6.10 # version of Mongo to use
spring.mongodb.embedded.features=SYNC_DELAY # comma-separated list of features to enable
# JPA (JpaBaseConfiguration, 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 (JtaAutoConfiguration)
spring.jta.log-dir= # transaction log dir
spring.jta.*= # technology specific configuration
# JOOQ (JooqAutoConfiguration)
spring.jooq.sql-dialect=
# 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 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.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 (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 (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 (RepositoryRestProperties)
spring.data.rest.base-path= # base path to be used by Spring Data REST to expose repository resources
spring.data.rest.default-page-size= # default size of pages
spring.data.rest.enable-enum-translation= # enable enum value translation via 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= # return a response body after creating an entity
spring.data.rest.return-body-on-update= # 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
# FLYWAY (FlywayProperties)
flyway.*= # Any public property available on the auto-configured `Flyway` object
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 (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.labels= # runtime labels 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
liquibase.parameters= # change log parameters
# JMX
spring.jmx.default-domain= # JMX domain name
spring.jmx.enabled=true # Expose MBeans from Spring
spring.jmx.server=mbeanServer # MBeanServer bean name
# RABBIT (RabbitProperties)
spring.rabbitmq.addresses= # connection addresses (e.g. myhost:9999,otherhost:1111)
spring.rabbitmq.dynamic=true # create an AmqpAdmin bean
spring.rabbitmq.host= # connection host
spring.rabbitmq.port= # connection port
spring.rabbitmq.password= # login password
spring.rabbitmq.requested-heartbeat= # requested heartbeat timeout, in seconds; zero for none
spring.rabbitmq.listener.acknowledge-mode= # acknowledge mode of container
spring.rabbitmq.listener.auto-startup=true # start the container automatically on startup
spring.rabbitmq.listener.concurrency= # minimum number of consumers
spring.rabbitmq.listener.max-concurrency= # maximum number of consumers
spring.rabbitmq.listener.prefetch= # number of messages to be handled in a single request
spring.rabbitmq.listener.transaction-size= # number of messages to be processed in a transaction
spring.rabbitmq.ssl.enabled=false # 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.trust-store= # trust store that holds SSL certificates
spring.rabbitmq.ssl.trust-store-password= # password used to access the trust store
spring.rabbitmq.username= # login user
spring.rabbitmq.virtual-host= # virtual host to use when connecting to the broker
# REDIS (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
spring.redis.timeout= # connection timeout in milliseconds
# ACTIVEMQ (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
# ARTEMIS (ArtemisProperties)
spring.artemis.mode= # connection mode (native, embedded)
spring.artemis.host=localhost # hornetQ host (native mode)
spring.artemis.port=5445 # hornetQ port (native mode)
spring.artemis.embedded.enabled=true # if the embedded server is enabled (needs hornetq-jms-server.jar)
spring.artemis.embedded.server-id= # auto-generated id of the embedded server (integer)
spring.artemis.embedded.persistent=false # message persistence
spring.artemis.embedded.data-directory= # location of data content (when persistence is enabled)
spring.artemis.embedded.queues= # comma-separated queues to create on startup
spring.artemis.embedded.topics= # comma-separated topics to create on startup
spring.artemis.embedded.cluster-password= # customer password (randomly generated by default)
# HORNETQ (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 (JmsProperties)
spring.jms.jndi-name= # JNDI location of a JMS ConnectionFactory
spring.jms.listener.acknowledge-mode= # session acknowledgment mode
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 for queue (default), true for topic
# Email (MailProperties)
spring.mail.host=smtp.acme.org # mail server host
spring.mail.port= # mail server port
spring.mail.protocol=smtp # mail server protocol
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.mail.jndi-name= # JNDI location of a Mail Session
spring.mail.test-connection=false # Test that the mail server is available on startup
# SPRING BATCH (BatchProperties)
spring.batch.job.names=job1,job2
spring.batch.job.enabled=true
spring.batch.initializer.enabled=true
spring.batch.schema= # batch schema to load
spring.batch.table-prefix= # table prefix for all the batch meta-data tables
# SPRING CACHE (CacheProperties)
spring.cache.type= # generic, ehcache, hazelcast, infinispan, jcache, redis, guava, simple, none
spring.cache.cache-names= # cache names to create on startup
spring.cache.ehcache.config= # location of the ehcache configuration
spring.cache.hazelcast.config= # location of the hazelcast configuration
spring.cache.infinispan.config= # location of the infinispan configuration
spring.cache.jcache.config= # location of jcache configuration
spring.cache.jcache.provider= # fully qualified name of the CachingProvider implementation to use
spring.cache.guava.spec= # guava specs
# HAZELCAST (HazelcastProperties)
spring.hazelcast.config= # location of the hazelcast configuration
# AOP
spring.aop.auto=
spring.aop.proxy-target-class=
# FILE ENCODING (FileEncodingApplicationListener)
spring.mandatory-file-encoding= # Expected character encoding the application must use
# SPRING SOCIAL (SocialWebAutoConfiguration)
spring.social.auto-connection-views=true # Set to true for default connection views or false if you provide your own
# SPRING SOCIAL FACEBOOK (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 (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 (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 (SitePreferenceAutoConfiguration)
spring.mobile.sitepreference.enabled=true # enabled by default
# SPRING MOBILE DEVICE VIEWS (DeviceDelegatingViewResolverAutoConfiguration)
spring.mobile.devicedelegatingviewresolver.enabled=true # disabled by default
spring.mobile.devicedelegatingviewresolver.enable-fallback= # enable support for fallback resolution, default to false.
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=
# ----------------------------------------
# DEVTOOLS PROPERTIES
# ----------------------------------------
# DEVTOOLS (DevToolsProperties)
spring.devtools.restart.additional-paths= # additional paths to watch for changes
spring.devtools.restart.enabled=true # enable automatic restart
spring.devtools.restart.exclude= # patterns that should be excluded from triggering a full restart
spring.devtools.restart.additional-exclude= # additional patterns that should be excluded from triggering a full restart
spring.devtools.restart.poll-interval= # amount of time (in milliseconds) to wait between polling for classpath changes
spring.devtools.restart.quiet-period= # amount of quiet time (in milliseconds) required without any classpath changes before a restart is triggered
spring.devtools.restart.trigger-file= # name of a specific file that when changed will trigger the restart
spring.devtools.livereload.enabled=true # enable a livereload.com compatible server
spring.devtools.livereload.port=35729 # server port.
# REMOTE DEVTOOLS (RemoteDevToolsProperties)
spring.devtools.remote.context-path=/.~~spring-boot!~ # context path used to handle the remote connection
spring.devtools.remote.debug.enabled=true # enable remote debug support
spring.devtools.remote.debug.local-port=8000 # local remote debug server port
spring.devtools.remote.proxy.host= # the host of the proxy to use to connect to the remote application
spring.devtools.remote.proxy.port= # the port of the proxy to use to connect to the remote application
spring.devtools.remote.restart.enabled=true # enable remote restart
spring.devtools.remote.secret= # a shared secret required to establish a connection
spring.devtools.remote.secret-header-name=X-AUTH-TOKEN # HTTP header used to transfer the shared secret
# ----------------------------------------
# ACTUATOR PROPERTIES
# ----------------------------------------
# MANAGEMENT HTTP SERVER (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 (ApplicationPidFileWriter)
spring.pid.file= # Location of the PID file to write
spring.pid.fail-on-write-error= # Fail if the PID file cannot be written
# ENDPOINTS (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,.*credentials.*,vcap_services # suffix or regex
endpoints.dump.id=dump
endpoints.dump.sensitive=true
endpoints.dump.enabled=true
endpoints.enabled=true # enable all endpoints
endpoints.env.id=env
endpoints.env.sensitive=true
endpoints.env.enabled=true
endpoints.env.keys-to-sanitize=password,secret,key,.*credentials.*,vcap_services # 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.logfile.path=/logfile
endpoints.logfile.sensitive=true
endpoints.logfile.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
# HYPERMEDIA ENDPOINTS
endpoints.actuator.enabled=true
endpoints.actuator.path=/actuator
endpoints.actuator.sensitive=false
endpoints.docs.curies.enabled=false
endpoints.docs.enabled=true
endpoints.docs.path=/docs
endpoints.docs.sensitive=false
endpoints.flyway.enabled=true
endpoints.flyway.id=flyway
endpoints.flyway.sensitive=true
endpoints.liquibase.enabled=true
endpoints.liquibase.id=liquibase
endpoints.liquibase.sensitive=false
# ENDPOINTS CORS CONFIGURATION (MvcEndpointCorsProperties)
endpoints.cors.allow-credentials= # set whether user credentials are support. When not set, credentials are not supported.
endpoints.cors.allowed-origins= # comma-separated list of origins to allow. * allows all origins. When not set, CORS support is disabled.
endpoints.cors.allowed-methods= # comma-separated list of methods to allow. * allows all methods. When not set, defaults to GET.
endpoints.cors.allowed-headers= # comma-separated list of headers to allow in a request. * allows all headers.
endpoints.cors.exposed-headers= # comma-separated list of headers to include in a response.
endpoints.cors.max-age=1800 # how long, in seconds, the response from a pre-flight request can be cached by clients.
# HEALTH INDICATORS (previously health.*)
management.health.db.enabled=true
management.health.defaults.enabled=true # enable default health indicators
management.health.diskspace.enabled=true
management.health.diskspace.path=.
management.health.diskspace.threshold=10485760
management.health.elasticsearch.enabled=true
management.health.elasticsearch.indices=  # comma-separated index names
management.health.elasticsearch.response-timeout=100 # the time, in milliseconds, to wait for a response from the cluster
management.health.jms.enabled=true
management.health.mail.enabled=true
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
# TRACING ((TraceProperties)
management.trace.include=request-headers,response-headers,errors # See TraceProperties.Include for options
# MVC ONLY ENDPOINTS
endpoints.jolokia.path=/jolokia
endpoints.jolokia.sensitive=true
endpoints.jolokia.enabled=true # when using Jolokia
# JMX ENDPOINT (EndpointMBeanExportProperties)
endpoints.jmx.enabled=true # enable JMX export of all endpoints
endpoints.jmx.domain= # the JMX domain, defaults to 'org.springboot'
endpoints.jmx.unique-names=false
endpoints.jmx.static-names=
# JOLOKIA (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=
# METRICS EXPORT (MetricExportProperties)
spring.metrics.export.aggregate.key-pattern= # pattern that tells the aggregator what to do with the keys from the source repository
spring.metrics.export.aggregate.prefix= # prefix for global repository if active
spring.metrics.export.enabled=true # flag to disable all metric exports (assuming any MetricWriters are available)
spring.metrics.export.delay-millis=5000 # delay in milliseconds between export ticks
spring.metrics.export.send-latest=true # flag to switch off any available optimizations based on not exporting unchanged metric values
spring.metrics.export.includes= # list of patterns for metric names to include
spring.metrics.export.excludes= # list of patterns for metric names to exclude. Applied after the includes
spring.metrics.export.redis.prefix=spring.metrics # prefix for redis repository if active
spring.metrics.export.redis.key=keys.spring.metrics # key for redis repository export (if active)
spring.metrics.export.statsd.host= # host of the statsd server
spring.metrics.export.statsd.port=8125 # port of the statsd server
spring.metrics.export.statsd.prefix= # prefix for exported metrics
spring.metrics.export.triggers.*= # specific trigger properties per MetricWriter bean name
# SENDGRID (SendGridAutoConfiguration)
spring.sendgrid.username= # SendGrid account username
spring.sendgrid.password= # SendGrid account password