原创

Spring Boot2 application.properties 配置

各种属性可以在application.propertiesapplication.yml 文件中指定,或者作为命令行开关指定。本节提供了一个常用的Spring Boot属性列表以及对使用它们的基础类的引用。

[注意]

属性贡献可能来自类路径上的其他jar文件,因此您不应将其视为详尽的列表。定义自己的属性也是完全合法的。

[警告]

此示例文件仅作为指导。难道不是复制/粘贴整个内容到你的应用; 而只选择你需要的属性。

#================================================= ================== 
#COMMON SPRING BOOT PROPERTIES 
##
此示例文件作为指导提供。请勿将其
全部内容
复制到您自己的应用程序中。^^^ #============================================== =====================

#---------------------------------------- 
#核心属性
#----- -----------------------------------

#SPRING CONFIG(ConfigFileApplicationListenerspring.config.name = #config文件名(默认为'application')
spring.config.location = #配置文件的位置

#PROFILES 
spring.profiles.active = #逗号的列表活性型材
spring.profiles.include = #无条件激活指定的逗号分隔的配置文件

#应用程序设置(SpringApplicationspring.main.sources =
 spring.main.web-environment = 默认检测
spring.main.show-banner = true
 spring.main .... = #查看所有属性的类

#测井
logging.path =在/ var /日志
 logging.file = myapp.log
 logging.config = config文件中的#位置(默认的classpath:logback.xml为的logback)
logging.level * = #级别的记录器,如“记录.level.org.springframework = DEBUG“(TRACE,DEBUG,INFO,WARN,ERROR,FATAL,OFF)

#IDENTITY ContextIdApplicationContextInitializerspring.application.name =
 spring.application.index =

#嵌入式服务器配置(ServerPropertiesserver.port = 8080
 server.address = #绑定到特定的网卡
server.session-timeout = #会话超时秒数
server.context-parameters。* = #Servlet上下文初始化参数,例如服务器。 context-parameters.a = alpha 
server.context-path = #上下文路径,默认为' 
/'server.servlet-path = #servlet路径,默认为' 
/'server.ssl.enabled = true #如果SSL支持已启用
server.ssl.client-auth = #想要或需要
server.ssl.key-alias =
server.ssl.ciphers = #支持SSL密码
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 = #访问日志的日志模式
server.tomcat.access-log-enabled = false #启用访问日志记录
server.tomcat.compression = off #启用压缩(关闭,开启或整数内容长度限制)
server.tomcat.compressableMimeTypes = text / html,text / xml,text / plain #逗号分隔的Tomcat类型的列表将压缩
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} #匹配可信IP地址的正则表达式
server.tomcat.protocol-header = x -forwarded-proto #前端代理转发头文件
server.tomcat.port-header = #前端代理端口头文件
server.tomcat.remote-ip-header = x -forwarded -for
 server.tomcat.basedir = / tmp #base dir (通常不需要,默认为tmp)
server.tomcat.background-processor-delay = 30; #in seconds 
server.tomcat.max-http-header-size = #HTTP消息头的最大字节数
server.tomcat.max-threads = 0 #协议处理程序中的线程数
server.tomcat.uri-encoding = 用于URL解码的 UTF-8 #字符编码

#SPRING MVC(WebMvcPropertiesspring.mvc.locale = #设置固定语言环境,例如en_UK 
spring.mvc.date-format = #设置固定日期格式,例如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 #如果“default”模型的内容应该被忽略,重定向为
spring.view.prefix = #MVC 视图前缀
spring.view.suffix = #...和后缀

#春季资源处理(ResourcePropertiesspring.resources.cache-period = #发送到浏览器的标题缓存超时时间
spring.resources.add-mappings = true #如果应添加默认映射

#SPRING HATEOAS(HateoasPropertiesspring.hateoas.apply-to-primary-object-mapper = true #如果还应该配置主映射器

#HTTP 编码(HttpEncodingPropertiesspring.http.encoding.charset = UTF-8 #HTTP请求/响应的编码
spring.http.encoding.enabled = true #启用http编码支持
spring.http.encoding.force = true #force配置的编码


#HTTP 消息转换spring.http.converters.preferred-json-mapper = #用于HTTP消息转换的首选JSON映射器。设置为“gson”来强制使用Gson,当它和Jackson都在类路径中时。

#HTTP 响应压缩(GzipFilterPropertiesspring.http.gzip.bufferSize = 输出缓冲区的大小(以字节为单位)
spring.http.gzip.minGzipSize = #发生压缩所需的最小内容长度
spring.http.gzip.deflateCompressionLevel = #用于放缩压缩的级别(0-9)
spring.http.gzip.deflateNoWrap = #放缩压缩的设置(true或false)
spring.http.gzip.methods = #逗号分隔的启用压缩的HTTP方法列表
spring.http.gzip.mimeTypes = #应该压缩的MIME类型的逗号分隔列表
spring.http.gzip.excludedAgents = #从压缩中排除用户代理的逗号分隔列表
spring.http.gzip.excludedAgentPatterns = #正则表达式模式的列表,以控制排除压缩的用户代理
spring.http.gzip。 excludedPaths = #从压缩中排除的路径列表
spring.http.gzip.excludedPathPatterns = #控制排除压缩的路径的正则表达式模式列表
spring.http.gzip.vary = #Vary header通过可能被压缩的响应发送

#JACKSON JacksonPropertiesspring.jackson.date-format = #日期格式字符串(例如yyyy-MM-dd HH:mm:ss)或完全限定的日期格式类名(例如com.fasterxml.jackson.databind。 util.ISO8601DateFormat)
spring.jackson.property-naming-strategy = #Jackson的PropertyNamingStrategy上的常量之一(例如CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES)或PropertyNamingStrategy子类的完全限定类名
spring.jackson.deserialization。* = #请参阅Jackson的DeserializationFeature 
spring .jackson.generator。* = #请参阅Jackson的JsonGenerator.Feature 
spring.jackson.mapper。* = #请参阅Jackson的MapperFeature
spring.jackson.parser。* = #请参阅Jackson的JsonParser.Feature 
spring.jackson.serialization。* = #请参阅Jackson's SerializationFeature

#THYMELEAF(ThymeleafAutoConfigurationspring.thymeleaf.check-template-location = true
 spring.thymeleaf.prefix = classpath:/ templates /
 spring.thymeleaf.excluded-view-names = #应该排除的视图名称的逗号分隔列表解析
spring.thymeleaf.view-names = #可以解析的视图名称的逗号分隔列表
spring.thymeleaf.suffix = .html
 spring.thymeleaf.mode = HTML5
 spring.thymeleaf.encoding = UTF-8
 spring.thymeleaf.content -type = text / html #; charset = <encoding>添加了
spring.thymeleaf.cache = true#为热刷新设置为false

#FREEMARKER(FreeMarkerAutoConfigurationspring.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 / #逗号分隔列表
spring.freemarker.view-names = #可以解析的视图名称白名单

#GROOVY TEMPLATES(GroovyTemplateAutoConfigurationspring.groovy.template.cache = true
 spring.groovy.template.charset = UTF-8
 spring.groovy.template.configuration。* = #请参阅Groovy的TemplateConfiguration 
spring.groovy.template.content-type = text / html
 spring.groovy.template.prefix = classpath:/ templates /
 spring.groovy.template.suffix = .tpl
 spring.groovy.template.view-names = #可以解析的视图名称白名单

#VELOCITY TEMPLATES(VelocityAutoConfigurationspring.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#更喜欢用于模板加载的文件系统访问
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-位置 = #速度工具箱配置位置,例如“/WEB-INF/toolbox.xml” 
spring.velocity.view-名 = 视图名称的#白名单可以解析

#JERSEY JerseyPropertiesspring.jersey.type = servlet #servlet或filter 
spring.jersey.init = #init params 
spring.jersey.filter.order =

#INTERNATIONALIZATION MessageSourceAutoConfigurationspring.messages.basename = messages
 spring.messages.cache-seconds = -1
 spring.messages.encoding = UTF-8


#安全(SecurityPropertiessecurity.user.name =用户#登录用户名
security.user.password = #登录密码
security.user.role = USER #分配给用户的角色
security.require-ssl = false #高级设置... 
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 = #从逗号分隔的默认安全路径中排除的路径列表

#DATASOURCE DataSourceAutoConfigurationDataSourcePropertiesspring.datasource.name = #数据源的名称
spring.datasource.initialize = true #使用data.sql填充
spring.datasource.schema = #模式(DDL)脚本资源参考
spring.datasource .data = #a data(DML)脚本资源参考
spring.datasource.sql-script-encoding = #读取SQL脚本的字符集
spring.datasource.platform = #在模式资源中使用的平台(schema  -  $ {platform } .sql)
spring.datasource.continue-on-error = false#即使无法初始化,也继续
spring.datasource.separator =; SQL初始化脚本中的#语句分隔符
spring.datasource.driver-class-name = #JDBC设置... 
spring.datasource.url =
 spring.datasource.username =
 spring.datasource.password =
 spring.datasource.jndi-name = #对于JNDI查找(类,url,用户名和密码在设置时会被忽略)
spring.datasource.max-active = 100 #高级配置... 
spring.datasource.max-idle = 8
 spring.datasource.min-idle = 8
 spring .datasource.initial-size = 10
spring.datasource.validation查询 =
 spring.datasource.test上借入 =假
 spring.datasource.test上回报 =假
 spring.datasource.test,而空闲 =
 spring.datasource.time之间,eviction- runs-millis =
 spring.datasource.min-evictable-idle-time-millis =
 spring.datasource.max-wait =
 spring.datasource.jmx-enabled = false #导出JMX MBean(如果支持)

#DAO PersistenceExceptionTranslationAutoConfigurationspring.dao.exceptiontranslation.enabled = true

#MONGODB(MongoPropertiesspring.data.mongodb.host = #分贝主机
spring.data.mongodb.port = 27017 #连接端口(默认为27107)
spring.data.mongodb.uri = mongodb:// localhost / test #连接网址
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 #如果启用了弹簧数据存储库支持

#JPA JpaBaseConfigurationHibernateJpaAutoConfigurationspring.jpa.properties。* = #在JPA连接上设置的属性
spring.jpa.open-in-view = true
 spring.jpa.show-sql = true
 spring.jpa.database-platform =
 spring.jpa.database =
 spring.jpa.generate-ddl = false #被Hibernate忽略,可能对其他供应商有用
spring.jpa.hibernate.naming-strategy = #命名classname 
spring.jpa.hibernate.ddl-auto = #默认为嵌入式
数据库的创建 - 删除spring.data.jpa.repositories.enabled = true#如果启用了弹簧数据存储库支持

#JTA JtaAutoConfigurationspring.jta.log-dir = #事务日志dir 
spring.jta。* = #技术特定配置

#ATOMIKOS 
spring.jta.atomikos.connectionfactory.borrow-connection-timeout = 30 #用于从池中借用连接的超时,以秒为单位
spring.jta.atomikos.connectionfactory.ignore-session-transacted-flag = true #是否在创建会话时忽略事务标记
spring.jta.atomikos.connectionfactory.local-transaction-mode = false #是否需要本地事务
spring.jta.atomikos.connectionfactory.maintenance-interval = 60 #以秒为单位的时间,在游泳池的维护线程的运行之间
spring.jta.atomikos.connectionfactory.max-idle-time = 60#从连接池中清除连接之后的时间(以秒为单位)
spring.jta.atomikos.connectionfactory.max-lifetime = 0 #以秒为单位的连接在被销毁之前汇集的时间。0表示没有限制。
spring.jta.atomikos.connectionfactory.max-pool-size = 1 
的最大尺寸spring.jta.atomikos.connectionfactory.min-pool-size = 1 #池的最小尺寸
spring.jta.atomikos。 connectionfactory.reap-timeout = 0 #借用连接的收获超时(以秒为单位)。0表示没有限制。
spring.jta.atomikos.connectionfactory.unique-resource-name = jmsConnectionFactory#在恢复过程中用于识别资源的唯一名称
spring.jta.atomikos.datasource.borrow-connection-timeout = 30 #从池中借用连接的超时时间
spring.jta.atomikos.datasource.default-isolation- level = #由池提供的连接的默认隔离级别
spring.jta.atomikos.datasource.login-timeout = #建立数据库连接
的超时时间(以秒为单位)spring.jta.atomikos.datasource.maintenance-interval = 60 #时间,以秒为单位,在池的维护线程之间运行
spring.jta.atomikos.datasource.max-idle-time = 60#从池中清除连接之后的时间(以秒为单位)
spring.jta.atomikos.datasource.max-lifetime = 0 #以秒为单位的连接在被销毁之前汇集的时间。0表示没有限制。
spring.jta.atomikos.datasource.max-pool-size = 1 
的最大尺寸spring.jta.atomikos.datasource.min-pool-size = 1 #池的最小尺寸
spring.jta.atomikos。 datasource.reap-timeout = 0 #借用连接的收获超时(以秒为单位)。0表示没有限制。
spring.jta.atomikos.datasource.test-query = #返回之前用于验证连接的SQL查询或语句
spring.jta.atomikos.datasource.unique-resource-name = dataSource #用于在恢复期间识别资源的唯一名称

#BITRONIX 
spring.jta.bitronix.connectionfactory.acquire-increment = 1 #在增长池时创建的连接数
spring.jta.bitronix.connectionfactory.acquisition-interval = 1 #尝试获取之前要等待的时间(秒)在获取无效连接后再次发生连接
spring.jta.bitronix.connectionfactory.acquisition-timeout = 30 #以秒为单位超时获取池中的连接
spring.jta.bitronix.connectionfactory.allow-local-transactions = true #事务管理器是否应该允许混合XA和非XA事务
spring.jta.bitronix.connectionfactory.apply-transaction-timeout = false#是否应该在入伍时在XAResource上设置事务超时
spring.jta.bitronix.connectionfactory.automatic-enlisting-enabled = true #是否应该自动登记和去除资源
spring.jta.bitronix.connectionfactory .cache-producer-consumers = true 
生产者和消费者是否应该被缓存spring.jta.bitronix.connectionfactory.defer-connection-release = true #提供者是否可以在同一个连接上运行多个事务并支持事务交错
spring.jta.bitronix.connectionfactory.ignore-recovery-failures = false #是否应该忽略恢复失败
spring.jta.bitronix.connectionfactory.max-idle-time = 60 #从池中清理连接之后的时间,以秒为单位
spring.jta.bitronix.connectionfactory.max-pool-size = 10 #最大大小的游泳池。0表示没有限制
spring.jta.bitronix.connectionfactory.min-pool-size = 0 
的最小大小spring.jta.bitronix.connectionfactory.password = #用于连接JMS提供程序的密码
spring.jta .bitronix.connectionfactory.share-transaction-connections = false #是否可以在事务上下文中共享ACCESSIBLE状态下的
连接spring.jta.bitronix.connectionfactory.test-connections= true #在从池中获取时是否测试连接
spring.jta.bitronix.connectionfactory.two-pc-ordering-position = 1 #这个资源在两阶段提交期间应该采用的位置(总是首先是整数.MIN_VALUE,总是最后一个是Integer.MAX_VALUE)
spring.jta.bitronix.connectionfactory.unique-name = jmsConnectionFactory #在恢复期间用于标识资源的唯一名称
spring.jta.bitronix.connectionfactory.use-tm-join = true是否或者在启动XAResources时不应该使用TMJOIN
 spring.jta.bitronix.connectionfactory.user = #用于连接到JMS提供程序的用户
spring.jta.bitronix.datasource.acquire-increment= 1 #增长池时创建的连接数
spring.jta.bitronix.datasource.acquisition-interval = 1 #在获取无效连接
spring.jta 之后尝试重新获取连接之前等待的时间(以秒为单位)。 bitronix.datasource.acquisition-timeout = 30 #以秒为单位超时获取池中的连接
spring.jta.bitronix.datasource.allow-local-transactions = true #事务管理器是否应该允许混合XA和non- XA事务
spring.jta.bitronix.datasource.apply-transaction-timeout = false #当Xeesource被登记时是否应该设置事务超时
spring.jta.bitronix.datasource.automatic-enlisting-enabled = true #资源是否应该自动登陆并自动删除
spring.jta.bitronix.datasource.cursor-holdability = #连接的默认光标可保存性
spring.jta.bitronix .datasource.defer-connection-release = true #数据库是否可以在同一连接上运行多个事务并支持事务交错 
spring.jta.bitronix.datasource.enable -jdbc4-connection-test #是否Connection.isValid ()在从池中获取连接时调用
spring.jta.bitronix.datasource.ignore-recovery-failures = false #是否应该忽略恢复失败
spring.jta.bitronix.datasource.isolation-level = #连接的默认隔离级别 
spring.jta.bitronix.datasource.local-auto-commit #本地事务的默认自动提交模式
spring.jta.bitronix.datasource。 login-timeout = #建立数据库连接
的超时时间(以秒为单位)spring.jta.bitronix.datasource.max-idle-time = 60 #连接从池
spring.jta 中清除之后的时间,以秒为单位。 bitronix.datasource.max-pool-size = 10 #池的最大大小。0表示没有限制
spring.jta.bitronix.datasource.min-pool-size = 0 #池的最小大小
spring.jta.bitronix.datasource.prepared-statement-cache-size = 0 #准备好的语句缓存的目标大小。0禁用缓存
spring.jta.bitronix.datasource.share-transaction-connections = false #ACCESSIBLE状态下的连接是否可以在事务上下文中共享 
spring.jta.bitronix.datasource.test-query #SQL查询或语句用于在返回之前验证连接
spring.jta.bitronix.datasource.two-pc-ordering-position = 1 #此资源在两阶段提交期间应该采用的位置(始终首先是Integer.MIN_VALUE,始终最后是Integer.MAX_VALUE)
spring.jta.bitronix.datasource.unique-name = dataSource#恢复期间用于标识资源的唯一名称
spring.jta.bitronix.datasource.use-tm-join = true在启动XAResources时是否应使用TMJOIN

#SOLR SolrPropertiesspring.data.solr.host = http://127.0.0.1:8983 / solr
 spring.data.solr.zk-host =
 spring.data.solr.repositories.enabled = true #如果弹簧数据存储库支持已启用

#ELASTICSEARCH(ElasticsearchPropertiesspring.data.elasticsearch.cluster-name = #集群名称(默认为
elasticsearch spring.data.elasticsearch.cluster-nodes = #服务器节点的地址(逗号分隔; if未指定将启动客户机节点)
spring.data.elasticsearch.properties。* = #用于配置客户机的其他属性
spring.data.elasticsearch.repositories.enabled = true #如果启用了弹簧数据存储库支持

#数据REST(RepositoryRestConfigurationspring.data.rest.base-uri = #出口商应根据哪个URI计算其链接

#FLYWAY FlywayPropertiesflyway.check-location = false #检查是否存在迁移脚本位置
flyway.locations = classpath:db / migration #迁移脚本位置
flyway.schemas = #更新
flyway.init-version = 1的模式版本开始迁移
flyway.init-sqls = #执行以在获取它之后立即初始化连接的SQL语句
flyway.sql-migration-prefix = V
 flyway.sql-migration-suffix = .sql
 flyway.enabled = true
 flyway.url =
#JDBC url如果你想让Flyway 创建自己的DataSource flyway.user = #JDBC用户名如果​​你想让
Flyway 创建自己的DataSource flyway.password = #JDBC密码如果你想让Flyway 创建自己的DataSource

#LIQUIBASE(LiquibasePropertiesliquibase.change-log = classpath:/db/changelog/db.changelog-master.yaml
 liquibase.check-change-log-location = true #检查更改日志位置是否存在
liquibase.contexts = #运行时环境使用
liquibase.default-schema = #默认数据库模式来使用
liquibase.drop-first = false
 liquibase.enabled = true
 liquibase.url = #特定JDBC url(如果未设置,使用默认数据源)
liquibase.user = #user liquibase.url的名称
liquibase.password = #liquibase.url的密码

#JMX 
spring.jmx.enabled =真#从春天暴露的MBean

#兔(RabbitPropertiesspring.rabbitmq.host = #连接主机
spring.rabbitmq.port = #连接端口
spring.rabbitmq.addresses = #连接地址(例如为myhost:9999,OTHERHOST:1111)
spring.rabbitmq.username = #登录用户
spring.rabbitmq.password = #登录密码
spring.rabbitmq.virtual-host =
 spring.rabbitmq.dynamic =

#Redis的(RedisPropertiesspring.redis.database = #数据库名称
spring.redis.host =本地主机#服务器主机
spring.redis.password = #服务器密码
spring.redis.port = 6379 #连接端口
spring.redis.pool.max -idle = 8 #池设置... 
spring.redis.pool.min-idle = 0
 spring.redis.pool.max-active = 8
 spring.redis.pool.max-wait = -1
 spring.redis.sentinel。 master = #Redis服务器的名称
spring.redis.sentinel.nodes = #主机:端口对的逗号分隔列表

#ACTIVEMQ(ActiveMQPropertiesspring.activemq.broker-url = tcp:// localhost:61616 #connection URL 
spring.activemq.user =
 spring.activemq.password =
 spring.activemq.in-memory = true #要创建的代理种类if没有指定broker-url 
spring.activemq.pooled = false

#HornetQ HornetQPropertiesspring.hornetq.mode = #连接模式(native,嵌入)
spring.hornetq.host = localhost #hornetQ主机(native模式)
spring.hornetq.port = 5445 #hornetQ端口(native模式)
spring.hornetq .embedded.enabled = true #如果嵌入式服务器已启用(需要hornetq-jms-server.jar)
spring.hornetq.embedded.server-id = #嵌入式服务器的自动生成ID(整数)
spring.hornetq.embedded .persistent = false #消息持久性
spring.hornetq.embedded.data-directory = #数据内容的位置(启用持久性时)
spring.hornetq.embedded.queues = #启动时创建的逗号分隔队列
spring.hornetq.embedded.topics = 
在启动时创建的逗号分隔主题spring.hornetq.embedded.cluster-password = #客户密码(随机生成默认)

#JMS JmsPropertiesspring.jms.jndi-name = #JMS ConnectionFactory的JNDI位置
spring.jms.pub-sub-domain = 队列的默认值为false(默认值),对于主题为true

#电子邮件(MailPropertiesspring.mail.host = smtp.acme.org #邮件服务器主机
spring.mail.port = #邮件服务器端口
spring.mail.username =
 spring.mail.password =
 spring.mail.default-encoding = 用于MimeMessages的
 UTF-8 #编码spring.mail.properties。* = 要在JavaMail会话中设置的属性

#SPRING BATCH(BatchDatabaseInitializerspring.batch.job.names = job1,job2
 spring.batch.job.enabled = true
 spring.batch.initializer.enabled = true
 spring.batch.schema = #要加载的批处理模式

#AOP 
spring.aop.auto =
 spring.aop.proxy目标级 =

#FILE ENCODING(FileEncodingApplicationListenerspring.mandatory-file-encoding = false

#SPRING SOCIAL(SocialWebAutoConfigurationspring.social.auto-connection-views = true #对于默认连接视图,设置为true;如果您提供自己的连接视图,则设置为false

#SPRING SOCIAL FACEBOOK(FacebookAutoConfigurationspring.social.facebook.app-id = #你的应用的Facebook应用ID 
Spring.social.facebook.app-secret = #你的应用的Facebook应用密码

#SPRING SOCIAL LINKEDIN(LinkedInAutoConfigurationspring.social.linkedin.app-id = #您的应用程序的LinkedIn应用程序ID 
spring.social.linkedin.app-secret = #您的应用程序的LinkedIn应用程序秘诀

#SPRING SOCIAL TWITTER(TwitterAutoConfigurationspring.social.twitter.app-id = #您的应用程序的Twitter应用程序ID 
spring.social.twitter.app-secret = #您的应用程序的Twitter App Secret

#SPRING MOBILE SITE PREFERENCE(SitePreferenceAutoConfigurationspring.mobile.sitepreference.enabled = true #默认启用

#SPRING MOBILE DEVICE VIEWS(DeviceDelegatingViewResolverAutoConfigurationspring.mobile.devicedelegatingviewresolver.enabled = true #默认情况下禁用
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 
#----- -----------------------------------

#管理HTTP服务器(ManagementServerPropertiesmanagement.port = #默认为'server.port' 
management.address = #绑定到特定的NIC 
management.context路径 = #默认为'/' 
management.add-应用上下文报头 = #默认为true 
management.security.enabled = true #启用security 
management.security.role = ADMIN #访问管理端点所需的角色
management.security.sessions =无状态#session创建要使用的策略(always,never,if_required,无国籍)

#PID FILE(ApplicationPidFileWriterspring.pidfile = #要写入的PID文件的位置

#ENDPOINTS(AbstractEndpoint子类)
 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 =密码,秘密,密钥#后缀或正则表达式
endpoints.dump.id =转储
 endpoints.dump.sensitive =真
endpoints.dump.enabled = true
 endpoints.env.id = env
 endpoints.env.sensitive = true
 endpoints.env.enabled = true
 endpoints.env.keys-to-sanitize =密码,秘密,密钥#后缀或正则表达式
endpoints.health .id = health
 endpoints.health.sensitive = true
 endpoints.health.enabled = true
 endpoints.health.mapping。* = #健康状态到HttpStatus代码的映射
endpoints.health.time-live = 1000
 endpoints.info.id = info
 endpoints.info.sensitive = false
 endpoints.info.enabled = true
 endpoints.mappings.enabled= true
 endpoints.mappings.id =映射
 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

#健康指标(以前健康状况*)
management.health.db.enabled = true
 management.health.diskspace.enabled = true
 management.health.mongo.enabled = true
 management.health.rabbit.enabled = true
 management.health.redis .enabled = true
 management.health.solr.enabled = true
 management.health.diskspace.path =。
management.health.diskspace.threshold = 10485760
 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 #使用Jolokia时

#JMX ENDPOINT(EndpointMBeanExportPropertiesendpoints.jmx.enabled = true
 endpoints.jmx.domain = #JMX域,默认为'org.springboot'endpoints.jmx.unique 
-names = false
 endpoints.jmx.static-names =

#JOLOKIA(JolokiaPropertiesjolokia.config。* = #请参阅Jolokia手册


#REMOTE SHELL shell.auth = simple #jaas,key,simple,spring 
shell.command-refresh-interval = -1
 shell.command-path-patterns = #classpath *:/ commands / **,classpath *:/ crash /命令/ ** 
shell.config -path -patterns = #classpath *:/ crash / * 
shell.disabled-commands = jpa *,jdbc *,jndi * #以逗号分隔的要禁用的命令列表
shell.disabled-plugins = false #不要公开插件
shell.ssh.enabled = #ssh设置... 
shell.ssh.key-path =
 shell.ssh.port =
 shell.telnet.enabled = #telnet设置...
shell.telnet.port =
 shell.auth.jaas.domain = #认证设置... 
shell.auth.key.path =
 shell.auth.simple.user.name =
 shell.auth.simple.user.password =
 shell。 auth.spring.roles =


#GIT INFO spring.git.properties = #资源引用来生成git信息属性文件
链接:https://docs.spring.io/spring-boot/docs/2.1.x-SNAPSHOT/reference/html/common-application-properties.html
正文到此结束
Loading...