MyException - 我的异常网
当前位置:我的异常网» 软件架构设计 » SpringBoot惯用配置列表

SpringBoot惯用配置列表

www.MyException.Cn  网友分享于:2018-03-16  浏览:0次
SpringBoot常用配置列表
# =================================================================== 
# 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 (ConfigFileApplicationListener) 
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....= # see class for all properties 
  
# 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.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 (ContextIdApplicationContextInitializer) 
spring.application.name= 
spring.application.index= 
  
# EMBEDDED SERVER CONFIGURATION (ServerProperties) 
server.port=8080 #配置程序端口,默认为8080
server.address= # bind to a specific NIC 
server.session-timeout= # session timeout in seconds 用户会话session过期时间,以秒为单位
server.context-parameters.*= # Servlet context init parameters, e.g. server.context-parameters.a=alpha 
server.context-path= # the context path, defaults to '/'  配置访问路径,默认为/  context-path与contextPath相同
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.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)  Tomcat是否开启压缩,默认为关闭off
server.tomcat.compressable-mime-types=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}|\\ 
        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.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  配置Tomcat编码,默认为UTF-8
server.undertow.access-log-enabled=false # if access logging is enabled 
server.undertow.access-log-pattern=common # log pattern of the access log 
server.undertow.access-log-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 
  
# 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 the content of the "default" model should be ignored redirects 
spring.view.prefix= # MVC view prefix 
spring.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 
  
# 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. 
  
# SPRING HATEOAS (HateoasProperties) 
spring.hateoas.apply-to-primary-object-mapper=true # if the primary mapper should also be configured 
  
# 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. 
  
# HTTP response compression (GzipFilterProperties) 
spring.http.gzip.buffer-size= # size of the output buffer in bytes 
spring.http.gzip.deflate-compression-level= # the level used for deflate compression (0-9) 
spring.http.gzip.deflate-no-wrap= # noWrap setting for deflate compression (true or false) 
spring.http.gzip.enabled=true # enable gzip filter support 
spring.http.gzip.excluded-agents= # comma-separated list of user agents to exclude from compression 
spring.http.gzip.exclude-agent-patterns= # comma-separated list of regular expression patterns to control user agents excluded from compression 
spring.http.gzip.exclude-paths= # comma-separated list of paths to exclude from compression 
spring.http.gzip.exclude-path-patterns= # 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.mime-types= # comma-separated list of MIME types which should be compressed 
spring.http.gzip.excluded-mime-types= # comma-separated list of MIME types to exclude from compression 
spring.http.gzip.min-gzip-size= # minimum content length required for compression to occur 
spring.http.gzip.vary= # Vary header to be sent on responses that may be compressed 
  
# 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.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 (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 
  
# FREEMARKER (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.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.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.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.prefix=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.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.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.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 
  
  
# 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=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 
  
# OAuth2 client (OAuth2ClientProperties 
spring.oauth2.client.client-id= # OAuth2 client id 
spring.oauth2.client.client-secret= # OAuth2 client secret. A random secret is generated by default 
  
# OAuth2 SSO (OAuth2SsoProperties 
spring.oauth2.sso.filter-order= # Filter order to apply if not providing an explicit WebSecurityConfigurerAdapter 
spring.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= # 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 (PersistenceExceptionTranslationAutoConfiguration) 
spring.dao.exceptiontranslation.enabled=true 
  
# MONGODB (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 (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 
  
# 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 (RepositoryRestConfiguration) 
spring.data.rest.base-path= # base path against which the exporter should calculate its links 
  
# 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.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.default-domain= # JMX domain name 
spring.jmx.enabled=true # Expose MBeans from Spring 
spring.jmx.mbean-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.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 
  
# 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.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.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 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 
  
# 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.enabled=true # enable automatic restart 
spring.devtools.restart.exclude= # patterns that should be excluding for 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) requited 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.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.pidfile= # Location of the PID file to write 
  
# 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 # 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 # 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 
  
# 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.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.diskspace.enabled=true 
management.health.diskspace.path=. 
management.health.diskspace.threshold=10485760 
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 
  
# 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.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.aggregate-key-pattern= # pattern that tells the aggregator what to do with the keys from the source repository 
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.triggers.*= # specific trigger properties per MetricWriter bean name 
  
# SENDGRID (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 
Table of Content

 

文章评论

10个调试和排错的小建议
10个调试和排错的小建议
2013年美国开发者薪资调查报告
2013年美国开发者薪资调查报告
我的丈夫是个程序员
我的丈夫是个程序员
程序员最害怕的5件事 你中招了吗?
程序员最害怕的5件事 你中招了吗?
代码女神横空出世
代码女神横空出世
“肮脏的”IT工作排行榜
“肮脏的”IT工作排行榜
聊聊HTTPS和SSL/TLS协议
聊聊HTTPS和SSL/TLS协议
程序猿的崛起——Growth Hacker
程序猿的崛起——Growth Hacker
程序员必看的十大电影
程序员必看的十大电影
2013年中国软件开发者薪资调查报告
2013年中国软件开发者薪资调查报告
鲜为人知的编程真相
鲜为人知的编程真相
亲爱的项目经理,我恨你
亲爱的项目经理,我恨你
Google伦敦新总部 犹如星级庄园
Google伦敦新总部 犹如星级庄园
5款最佳正则表达式编辑调试器
5款最佳正则表达式编辑调试器
写给自己也写给你 自己到底该何去何从
写给自己也写给你 自己到底该何去何从
不懂技术不要对懂技术的人说这很容易实现
不懂技术不要对懂技术的人说这很容易实现
什么才是优秀的用户界面设计
什么才是优秀的用户界面设计
程序员应该关注的一些事儿
程序员应该关注的一些事儿
那些性感的让人尖叫的程序员
那些性感的让人尖叫的程序员
为什么程序员都是夜猫子
为什么程序员都是夜猫子
十大编程算法助程序员走上高手之路
十大编程算法助程序员走上高手之路
中美印日四国程序员比较
中美印日四国程序员比较
做程序猿的老婆应该注意的一些事情
做程序猿的老婆应该注意的一些事情
一个程序员的时间管理
一个程序员的时间管理
我是如何打败拖延症的
我是如何打败拖延症的
程序员都该阅读的书
程序员都该阅读的书
当下全球最炙手可热的八位少年创业者
当下全球最炙手可热的八位少年创业者
那些争议最大的编程观点
那些争议最大的编程观点
Java程序员必看电影
Java程序员必看电影
“懒”出效率是程序员的美德
“懒”出效率是程序员的美德
程序员的一天:一寸光阴一寸金
程序员的一天:一寸光阴一寸金
科技史上最臭名昭著的13大罪犯
科技史上最臭名昭著的13大罪犯
Java 与 .NET 的平台发展之争
Java 与 .NET 的平台发展之争
每天工作4小时的程序员
每天工作4小时的程序员
为啥Android手机总会越用越慢?
为啥Android手机总会越用越慢?
我跳槽是因为他们的显示器更大
我跳槽是因为他们的显示器更大
团队中“技术大拿”并非越多越好
团队中“技术大拿”并非越多越好
初级 vs 高级开发者 哪个性价比更高?
初级 vs 高级开发者 哪个性价比更高?
要嫁就嫁程序猿—钱多话少死的早
要嫁就嫁程序猿—钱多话少死的早
如何区分一个程序员是“老手“还是“新手“?
如何区分一个程序员是“老手“还是“新手“?
总结2014中国互联网十大段子
总结2014中国互联网十大段子
老程序员的下场
老程序员的下场
Web开发人员为什么越来越懒了?
Web开发人员为什么越来越懒了?
编程语言是女人
编程语言是女人
 程序员的样子
程序员的样子
程序员的鄙视链
程序员的鄙视链
Web开发者需具备的8个好习惯
Web开发者需具备的8个好习惯
程序员眼里IE浏览器是什么样的
程序员眼里IE浏览器是什么样的
旅行,写作,编程
旅行,写作,编程
软件开发程序错误异常ExceptionCopyright © 2009-2015 MyException 版权所有