blank的编程之路


  • 首页

  • 归档

  • 搜索
consul atomikos mybatisplus druid nexus nas named bind mysqldump acme.sh Dockerfile rsync keepalived swarm kibana ubuntu linux scp bugfix https ssl certbot curl gogs adminer harbor yum portainer python kubernetes idea java springboot maven docker-compose redis nginx mysql brew git chocolatey jenkins elasticsearch docker haproxy rabbitmq centos

SpringBoot 2.X 配置文件可配置参数说明

发表于 2020-07-27 | 分类于 开发 | 0 | 阅读次数 942
#JEST (Elasticsearch HTTP客户端)(JestProperties)
spring.elasticsearch.jest.connection-timeout = 3s #连接超时。
spring.elasticsearch.jest.multi-threaded = true #是否从多个执行线程启用连接请求。
spring.elasticsearch.jest.password = #登录密码。
spring.elasticsearch.jest.proxy.host = #HTTP 客户端应使用的代理主机。
spring.elasticsearch.jest.proxy.port = #HTTP 客户端应使用的代理端口。
spring.elasticsearch.jest.read-timeout = 3s #读取超时。
spring.elasticsearch.jest.uris = http:// localhost:9200#逗号分隔的Elasticsearch实例列表。
spring.elasticsearch.jest.username = #登录用户名。

#Elasticsearch REST客户端(RestClientProperties)
spring.elasticsearch.rest.password = #凭据密码。
spring.elasticsearch.rest.uris = http:// localhost:9200 #要使用的以逗号分隔的Elasticsearch实例列表。
spring.elasticsearch.rest.username = #凭据用户名。

#H2 Web控制台(H2ConsoleProperties)
spring.h2.console.enabled = false #是否启用控制台。
spring.h2.console.path = / h2-console #控制台可用的路径。
spring.h2.console.settings.trace = false #是否启用跟踪输出。
spring.h2.console.settings.web-allow-others = false #是否启用远程访问。

#InfluxDB(InfluxDbProperties)
spring.influx.password = #登录密码。
spring.influx.url = 要连接的InfluxDB实例的URL。
spring.influx.user = #登录用户。

#JOOQ (JooqProperties)
spring.jooq.sql-dialect = #SQL 方言使用。默认情况下自动检测。

#JDBC (JdbcProperties)
spring.jdbc.template.fetch-size = -1 #需要更多行时应从数据库中提取的行数。
spring.jdbc.template.max-rows = -1 #最大行数。
spring.jdbc.template.query-timeout = #查询超时。默认是使用JDBC驱动程序的默认配置。如果未指定持续时间后缀,则将使用秒。

#JPA (JpaBaseConfiguration,HibernateJpaAutoConfiguration)
spring.data.jpa.repositories.bootstrap-mode = default #JAPA 存储库的Bootstrap模式。
spring.data.jpa.repositories.enabled = true #是否启用JPA存储库。
spring.jpa.database = #要操作的目标数据库,默认情况下自动检测。也可以使用“databasePlatform”属性进行设置。
spring.jpa.database-platform = #要操作的目标数据库的名称,默认情况下自动检测。也可以使用“Database”枚举来设置。
spring.jpa.generate-ddl = false #是否在启动时初始化架构。
spring.jpa.hibernate.ddl-auto = #DDL模式。这实际上是“hibernate.hbm2ddl.auto”属性的快捷方式。使用嵌入式数据库时未默认为“create-drop”,并且未检测到架构管理器。否则,默认为“none”。
spring.jpa.hibernate.naming.implicit-strategy = #隐式命名策略的完全限定名称。
spring.jpa.hibernate.naming.physical-strategy = #物理命名策略的完全限定名称。
spring.jpa.hibernate.use-new-id-generator-mappings = #是否将Hibernate的较新的IdentifierGenerator用于AUTO,TABLE和SEQUENCE。
spring.jpa.mapping-resources =#Mapping资源(相当于persistence.xml中的“mapping-file”条目)。
spring.jpa.open-in-view = true #注册OpenEntityManagerInViewInterceptor。将JPA EntityManager绑定到线程以进行整个请求处理。
spring.jpa.properties。* = #要在JPA提供程序上设置的其他本机属性。
spring.jpa.show -sql = false #是否启用SQL语句的日志记录。

#JTA (JtaAutoConfiguration)
 spring.jta.enabled = true #是否启用JTA支持。
spring.jta.log-dir = #Transaction logs目录。
spring.jta.transaction-manager-id = #Transaction manager唯一标识符。

#ATOMIKOS(AtomikosProperties)
 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 #借用连接的reap超时(以秒为单位)。0表示没有限制。
spring.jta.atomikos.connectionfactory.unique-resource-name = jmsConnectionFactory#用于在恢复期间标识资源的唯一名称。
spring.jta.atomikos.connectionfactory.xa-connection-factory-class-name = #XAConnectionFactory的供应商特定实现。
spring.jta.atomikos.connectionfactory.xa-properties = #供应商特定的XA属性。
spring.jta.atomikos.datasource.borrow-connection-timeout = 30 #从池中借用连接的超时时间(秒)。
spring.jta.atomikos.datasource.concurrent-connection-validation = #是否使用并发连接验证。
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 #借用连接的reap超时(以秒为单位)。0表示没有限制。
spring.jta.atomikos.datasource.test-query = #用于在返回连接之前验证连接的SQL查询或语句。
spring.jta.atomikos.datasource.unique-resource-name = dataSource #用于在恢复期间标识资源的唯一名称。
spring.jta.atomikos.datasource.xa-data-source-class-name = #XAConnectionFactory的供应商特定实现。
spring.jta.atomikos.datasource.xa-properties = #供应商特定的XA属性。
spring.jta.atomikos.properties.allow-sub-transactions = true #指定是否允许子事务。
spring.jta.atomikos.properties.checkpoint-interval = 500 #检查点之间的间隔,表示为两个检查点之间的日志写入次数。
spring.jta.atomikos.properties.default -jta -timeout = 10000ms #JTA 事务的默认超时。
spring.jta.atomikos.properties.default-max-wait-time-on-shutdown = 9223372036854775807 #正常关闭(no-force)等待事务完成的时间。
spring.jta.atomikos.properties.enable-logging = true #是否启用磁盘日志记录。
spring.jta.atomikos.properties.force-shutdown-on-vm-exit = false #虚拟机关闭是否应触发事务核心的强制关闭。
spring.jta.atomikos.properties.log-base-dir = #应存储日志文件的目录。
spring.jta.atomikos.properties.log-base-name = tmlog #Transactions日志文件基名。
spring.jta.atomikos.properties.max-actives = 50 #最大活动事务数。
spring.jta.atomikos.properties.max-timeout = 300000ms #事务允许的最大超时时间。
spring.jta.atomikos.properties.recovery.delay = 10000ms #两次恢复扫描之间的延迟。
spring.jta.atomikos.properties.recovery.forget- orphaned -log-entries-delay = 86400000ms #恢复之后的延迟可以清除挂起('孤立')日志条目。
spring.jta.atomikos.properties.recovery.max-retries = 5 #在抛出异常之前提交事务的重试次数。
spring.jta.atomikos.properties.recovery.retry-interval = 10000ms #重试尝试之间的延迟。
spring.jta.atomikos.properties.serial-jta-transactions = true #是否应尽可能加入子事务。
spring.jta.atomikos.properties.service = #应该启动的事务管理器实现。
spring.jta.atomikos.properties.threaded-two-phase-commit = false #是否对参与资源使用不同(和并发)线程进行两阶段提交。
spring.jta.atomikos.properties.transaction-manager-unique-name = #事务管理器的唯一名称。

#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.class-name = #XA 资源的底层实现类名。
spring.jta.bitronix.connectionfactory.defer-connection-release = true #提供程序是否可以在同一连接上运行多个事务并支持事务交错。
spring.jta.bitronix.connectionfactory.disabled= #是否禁用此资源,这意味着暂时禁止从其池中获取连接。
spring.jta.bitronix.connectionfactory.driver-properties = #应在底层实现上设置的属性。
spring.jta.bitronix.connectionfactory.failed = #将此资源生成器标记为失败。
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#在两阶段提交期间此资源应采取的位置(始终是第一个是Integer.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和非XA事务。
spring.jta.bitronix.datasource.apply-transaction-timeout = false #是否应在XAResource登记时设置事务超时。
spring.jta.bitronix.datasource.automatic-enlisting-enabled = true #是否应自动登记和退出资源。
spring.jta.bitronix.datasource.class-name = #XA 资源的底层实现类名。
spring.jta.bitronix.datasource.cursor-holdability = #连接的默认光标可保持性。
spring.jta.bitronix.datasource.defer-connection-release = true #数据库是否可以在同一连接上运行多个事务并支持事务交错。
spring.jta.bitronix.datasource.disabled = #是否禁用此资源,这意味着暂时禁止从其池中获取连接。
spring.jta.bitronix.datasource.driver-properties = #应在底层实现上设置的属性。
spring.jta.bitronix.datasource.enable -jdbc4-connection-test = #从池中获取连接时是否调用Connection.isValid()。
spring.jta.bitronix.datasource.failed = #将此资源生成器标记为失败。
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。
spring.jta.bitronix.properties.allow-multiple-lrc = false #是否允许多个LRC资源登记到同一事务中。
spring.jta.bitronix.properties.asynchronous2-pc = false #是否启用异步执行两阶段提交。
spring.jta.bitronix.properties.background-recovery-interval-seconds = 60 #在后台运行恢复过程的时间间隔(以秒为单位)。
spring.jta.bitronix.properties.current-node-only-recovery = true #是否仅恢复当前节点。
spring.jta.bitronix.properties.debug-zero-resource-transaction = false#是否记录创建和提交没有单个登记资源的事务调用堆栈。
spring.jta.bitronix.properties.default-transaction-timeout = 60 #默认事务超时,以秒为单位。
spring.jta.bitronix.properties.disable-jmx = false #是否启用JMX支持。
spring.jta.bitronix.properties.exception-analyzer = #设置要使用的异常分析器实现的完全限定名称。
spring.jta.bitronix.properties.filter-log-status = false #是否启用日志过滤,以便只写入强制日志。
spring.jta.bitronix.properties.force-batching-enabled = true#是否批量磁盘强制。
spring.jta.bitronix.properties.forced-write-enabled = true #是否强制将日志记录到磁盘。
spring.jta.bitronix.properties.graceful-shutdown-interval = 60 #TM在关闭时中止事务之前等待事务完成的最大秒数。
spring.jta.bitronix.properties.jndi-transaction-synchronization-registry-name = #TransactionSynchronizationRegistry的JNDI名称。
spring.jta.bitronix.properties.jndi-user-transaction-name = #UserTransaction的JNDI名称。
spring.jta.bitronix.properties.journal = disk #期刊的名称。可以是'disk','null'或类名。
spring.jta.bitronix.properties.log-part1-filename = btm1.tlog #日志的第一个片段的名称。
spring.jta.bitronix.properties.log-part2-filename = btm2.tlog #日志的第二个片段的名称。
spring.jta.bitronix.properties.max-log-size-in-mb = 2 #日志片段的最大大小(兆字节)。
spring.jta.bitronix.properties.resource-configuration-filename = #ResourceLoader配置文件名。
spring.jta.bitronix.properties.server-id = #ASCII ID必须唯一标识此TM实例。默认为机器的IP地址。
spring.jta.bitronix.properties.skip-corrupted-logs = false#Skip损坏的事务日志条目。
spring.jta.bitronix.properties.warn-about-zero-resource-transaction = true #是否为没有单个登记资源的事务记录警告。

#EMBEDDED MONGODB(EmbeddedMongoProperties)
 spring.mongodb.embedded.features = sync_delay #逗号分隔的要启用的功能列表。
spring.mongodb.embedded.storage.database-dir = #用于数据存储的目录。
spring.mongodb.embedded.storage.oplog-size = #oplog的最大大小。
spring.mongodb.embedded.storage.repl-set-name = #副本集的名称。
spring.mongodb.embedded.version = 3.5.5 #要使用的Mongo版本。

#REDIS(RedisProperties)
 spring.redis.cluster.max -redirects = #在群集中执行命令时要遵循的最大重定向数。
spring.redis.cluster.nodes = #逗号分隔的“host:port”对列表引导自。
spring.redis.database = 0 #连接工厂使用的数据库索引。
spring.redis.url = #连接URL。覆盖主机,端口和密码。用户被忽略。示例:redis:// user:[email protected] :6379 
spring.redis.host = localhost #Redis服务器主机。
spring.redis.jedis.pool.max-active = 8#池在给定时间可以分配的最大连接数。使用负值无限制。
spring.redis.jedis.pool.max-idle = 8 #池中“空闲”连接的最大数量。使用负值表示无限数量的空闲连接。
spring.redis.jedis.pool.max -wait = -1ms #在池耗尽时,在抛出异常之前连接分配应该阻塞的最长时间。使用负值无限期阻止。
spring.redis.jedis.pool.min-idle = 0 #目标是池中维护的最小空闲连接数。此设置仅在其为正时才有效。
spring.redis.lettuce.pool.max-active = 8#池在给定时间可以分配的最大连接数。使用负值无限制。
spring.redis.lettuce.pool.max-idle = 8 #池中“空闲”连接的最大数量。使用负值表示无限数量的空闲连接。
spring.redis.lettuce.pool.max -wait = -1ms #在池耗尽时,在抛出异常之前连接分配应阻塞的最长时间。使用负值无限期阻止。
spring.redis.lettuce.pool.min-idle = 0 #目标是池中维护的最小空闲连接数。此设置仅在其为正时才有效。
spring.redis.lettuce.shutdown-timeout = 100ms#关机超时。
spring.redis.password = #redis服务器的登录密码。
spring.redis.port = 6379 #Redis服务器端口。
spring.redis.sentinel.master = #Redis服务器的名称。
spring.redis.sentinel.nodes = #逗号分隔的“host:port”对列表。
spring.redis.ssl = false #是否启用SSL支持。
spring.redis.timeout = #连接超时。

#TRANSACTION (TransactionProperties)
 spring.transaction.default-timeout = #默认事务超时。如果未指定持续时间后缀,则将使用秒。
spring.transaction.rollback-on-commit-failure = #是否回滚提交失败。



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

#ACTIVEMQ(ActiveMQProperties)
 spring.activemq.broker-url = ActiveMQ代理的URL。默认情况下自动生成。
spring.activemq.close-timeout = 15s #在考虑结束完成之前等待的时间。
spring.activemq.in-memory = true #默认代理URL是否应该在内存中。如果已指定显式代理,则忽略。
spring.activemq.non-blocking-redelivery = false #是否在从回滚事务重新传递消息之前停止消息传递。这意味着启用此消息顺序时不会保留消息顺序。
spring.activemq.password = #代理的登录密码。
spring.activemq.send-timeout = 0ms #等待消息发送响应的时间。将其设置为0以永远等待。
spring.activemq.user = #代理的登录用户。
spring.activemq.packages.trust-all = #是否信任所有包。
spring.activemq.packages.trusted = #逗号分隔的要信任的特定包列表(不信任所有包时)。
spring.activemq.pool.block-if-full = true #是否阻止请求连接并且池已满。将其设置为false以改为抛出“JMSException”。
spring.activemq.pool.block-if-full-timeout = -1ms#如果池仍然满,则在抛出异常之前阻塞。
spring.activemq.pool.enabled = false #是否应创建JmsPoolConnectionFactory,而不是常规ConnectionFactory。
spring.activemq.pool.idle-timeout = 30s #连接空闲超时。
spring.activemq.pool.max-connections = 1 #最大池化连接数。
spring.activemq.pool.max-sessions-per-connection = 500 #池中每个连接的最大池化会话数。
spring.activemq.pool.time-between-expiration-check = -1ms #在空闲连接驱逐线程的运行之间休眠的时间。当为负时,没有空闲连接驱逐线程运行。
spring.activemq.pool.use-anonymous-producer = true #是否只使用一个匿名“MessageProducer”实例。将其设置为false以在每次需要时创建一个“MessageProducer”。

#ARTEMIS (ArtemisProperties)
 spring.artemis.embedded.cluster-password = #群集密码。默认情况下在启动时随机生成。
spring.artemis.embedded.data-directory = #Journal 文件目录。如果关闭持久性,则没有必要。
spring.artemis.embedded.enabled = true #如果Artemis服务器API可用,是否启用嵌入模式。
spring.artemis.embedded.persistent = false #是否启用持久存储。
spring.artemis.embedded.queues = #逗号分隔的队列,在启动时创建。
spring.artemis.embedded.server-id =#服务器ID。默认情况下,使用自动递增的计数器。
spring.artemis.embedded.topics = #在启动时要创建的以逗号分隔的主题列表。
spring.artemis.host = localhost #Artemis broker主机。
spring.artemis.mode = #Artemis部署模式,默认情况下自动检测。
spring.artemis.password = #代理的登录密码。
spring.artemis.pool.block-if-full = true #是否在请求连接且池已满时阻止。将其设置为false以改为抛出“JMSException”。
spring.artemis.pool.block-if-full-timeout = -1ms #如果池仍然满,则在抛出异常之前阻塞。
spring.artemis.pool.enabled = false #是否应创建JmsPoolConnectionFactory,而不是常规ConnectionFactory。
spring.artemis.pool.idle-timeout = 30s #连接空闲超时。
spring.artemis.pool.max-connections = 1 #池化连接的最大数量。
spring.artemis.pool.max-sessions-per-connection = 500 #池中每个连接的最大池化会话数。
spring.artemis.pool.time-between-expiration-check = -1ms #在空闲连接驱逐线程的运行之间休眠的时间。当为负时,没有空闲连接驱逐线程运行。
spring.artemis.pool.use-anonymous-producers = true#是否只使用一个匿名“MessageProducer”实例。将其设置为false以在每次需要时创建一个“MessageProducer”。
spring.artemis.port = 61616 #Artemis 经纪人端口。
spring.artemis.user = #代理的登录用户。

#SPRING BATCH(BatchProperties)
 spring.batch.initialize-schema = embedded #数据库模式初始化模式。
spring.batch.job.enabled = true #在启动时执行上下文中的所有Spring Batch作业。
spring.batch.job.names = #逗号分隔的要在启动时执行的作业名称列表(例如,`job1,job2`)。默认情况下,将执行上下文中找到的所有作业。
spring.batch.schema = classpath中:组织/ springframework的/批号/核心/ schema- @ @ 平台@ @ .SQL #的路径SQL文件,以用于初始化数据库架构。
spring.batch.table-prefix =#所有批次元数据表的表前缀。

#SPRING INTEGRATION(IntegrationProperties)
 spring.integration.jdbc.initialize-schema = embedded #数据库模式初始化模式。
spring.integration.jdbc.schema = classpath中:组织/ springframework的/集成/ JDBC / schema- @ @ 平台@ @ .SQL #的路径SQL文件,以用于初始化数据库架构。

#JMS (JmsProperties)
 spring.jms.cache.consumers = false #是否缓存消息使用者。
spring.jms.cache.enabled = true #是否缓存会话。
spring.jms.cache.producers = true #是否缓存消息生成器。
spring.jms.cache.session-cache-size = 1 #会话缓存的大小(根据JMS会话类型)。
spring.jms.jndi-name = #连接工厂JNDI名称。设置时,优先于其他连接工厂自动配置。
spring.jms.listener.acknowledge-mode = #容器的确认模式。默认情况下,侦听器使用自动确认进行事务处理。
spring.jms.listener.auto-startup = true #启动时自动启动容器。
spring.jms.listener.concurrency = #最小并发使用者数。
spring.jms.listener.max-concurrency = #最大并发使用者数。
spring.jms.pub-sub-domain = false #默认目标类型是否为topic。
spring.jms.template.default-destination = #用于没有目标参数的发送和接收操作的默认目标。
spring.jms.template.delivery-delay = #用于发送呼叫的传递延迟。
spring.jms.template.delivery-mode =#交付模式。设置时启用QoS(服务质量)。
spring.jms.template.priority = #发送时消息的优先级。设置时启用QoS(服务质量)。
spring.jms.template.qos-enabled = #发送消息时是否启用显式QoS(服务质量)。
spring.jms.template.receive-timeout = #用于接收呼叫的超时。
spring.jms.template.time-to-live = #发送时消息的生存时间。设置时启用QoS(服务质量)。

#APACHE KAFKA(KafkaProperties)
 spring.kafka.admin.client-id = #ID 在发出请求时传递给服务器。用于服务器端日志记录。
spring.kafka.admin.fail-fast = false #如果代理在启动时不可用,是否快速失败。
spring.kafka.admin.properties。* = #用于配置客户端的其他特定于管理员的属性。
spring.kafka.admin.ssl.key-password = #密钥库文件中私钥的密码。
spring.kafka.admin.ssl.key-store-location = #密钥库文件的位置。
spring.kafka.admin.ssl.key-store-password =#存储密钥库文件的密码。
spring.kafka.admin.ssl.key-store-type = #密钥库的类型。
spring.kafka.admin.ssl.protocol = #要使用的SSL协议。
spring.kafka.admin.ssl.trust-store-location = #信任库文件的位置。
spring.kafka.admin.ssl.trust-store-password = #存储信任存储文件的密码。
spring.kafka.admin.ssl.trust-store-type = #信任库的类型。
spring.kafka.bootstrap-servers = #逗号分隔的主机:端口对列表,用于建立与Kafka集群的初始连接。除非被覆盖,否则适用于所有组件。
spring.kafka.client-id = #ID 在发出请求时传递给服务器。用于服务器端日志记录。
spring.kafka.consumer.auto-commit-interval = #如果'enable.auto.commit'设置为true,则将消费者偏移自动提交给Kafka的频率。
spring.kafka.consumer.auto-offset-reset = #当Kafka中没有初始偏移量或者服务器上不再存在当前偏移量时该怎么办。
spring.kafka.consumer.bootstrap-servers = #逗号分隔的主机:端口对列表,用于建立与Kafka集群的初始连接。为消费者覆盖全球财产。
spring.kafka.consumer.client-id =#ID在发出请求时传递给服务器。用于服务器端日志记录。
spring.kafka.consumer.enable-auto-commit = #是否在后台定期提交消费者的偏移量。
spring.kafka.consumer.fetch-max-wait = #如果没有足够的数据立即满足“fetch-min-size”给出的要求,服务器在回答获取请求之前会阻塞的最长时间。
spring.kafka.consumer.fetch-min-size = #服务器应为获取请求返回的最小数据量。
spring.kafka.consumer.group-id = #唯一字符串,用于标识此使用者所属的使用者组。
spring.kafka.consumer.heartbeat间隔= #心跳与消费者协调员之间的预期时间。
spring.kafka.consumer.key-deserializer = #Deserializer 类的键。
spring.kafka.consumer.max-poll-records = #一次调用poll()时返回的最大记录数。
spring.kafka.consumer.properties。* = #用于配置客户端的其他特定于使用者的属性。
spring.kafka.consumer.ssl.key-password = #密钥库文件中私钥的密码。
spring.kafka.consumer.ssl.key-store-location = #密钥库文件的位置。
spring.kafka.consumer.ssl.key-store-password =#存储密钥库文件的密码。
spring.kafka.consumer.ssl.key-store-type = #密钥库的类型。
spring.kafka.consumer.ssl.protocol = #要使用的SSL协议。
spring.kafka.consumer.ssl.trust-store-location = #信任存储文件的位置。
spring.kafka.consumer.ssl.trust-store-password = #存储信任存储文件的密码。
spring.kafka.consumer.ssl.trust-store-type = #信任库的类型。
spring.kafka.consumer.value-deserializer = #Deserializer 类的值。
spring.kafka.jaas.control-flag = required #登录配置的控制标志。
spring.kafka.jaas.enabled = false #是否启用JAAS配置。
spring.kafka.jaas.login-module = com.sun.security.auth.module.Krb5LoginModule #登录模块。
spring.kafka.jaas.options = #其他JAAS选项。
spring.kafka.listener.ack-count = #当ackMode为“COUNT”或“COUNT_TIME”时,偏移提交之间的记录数。
spring.kafka.listener.ack-mode = #Listener AckMode。请参阅spring-kafka文档。
spring.kafka.listener.ack-time = #当ackMode为“TIME”或“COUNT_TIME”时,偏移提交之间的时间。
spring.kafka.listener.client-id =#侦听器的使用者client.id属性的前缀。
spring.kafka.listener.concurrency = #在侦听器容器中运行的线程数。
spring.kafka.listener.idle-event-interval = #发布空闲消费者事件(未收到数据)之间的时间。
spring.kafka.listener.log-container-config = #是否在初始化期间记录容器配置(INFO级别)。
spring.kafka.listener.monitor-interval = #检查无响应的消费者之间的时间。如果未指定持续时间后缀,则将使用秒。
spring.kafka.listener.no-poll-threshold =#Multiplier应用于“pollTimeout”以确定消费者是否无响应。
spring.kafka.listener.poll-timeout = #轮询消费者时使用的超时。
spring.kafka.listener.type = single #Listener类型。
spring.kafka.producer.acks = #生产者要求领导者在考虑完成请求之前收到的确认数。
spring.kafka.producer.batch-size = #默认批量大小。
spring.kafka.producer.bootstrap-servers = #逗号分隔的主机:端口对列表,用于建立与Kafka集群的初始连接。为生产者覆盖全球财产。
spring.kafka.producer.buffer-memory = #生产者可用于缓冲等待发送到服务器的记录的总内存大小。
spring.kafka.producer.client-id = #ID 在发出请求时传递给服务器。用于服务器端日志记录。
spring.kafka.producer.compression-type = #生产者生成的所有数据的压缩类型。
spring.kafka.producer.key-serializer = #密码的Serializer类。
spring.kafka.producer.properties。* = #用于配置客户端的其他特定于生产者的属性。
spring.kafka.producer.retries = #大于零时,启用重试失败的发送。
spring.kafka.producer.ssl.key-password = #密钥库文件中私钥的密码。
spring.kafka.producer.ssl.key-store-location = #密钥库文件的位置。
spring.kafka.producer.ssl.key-store-password = #存储密钥库文件的密码。
spring.kafka.producer.ssl.key-store-type = #密钥库的类型。
spring.kafka.producer.ssl.protocol = #要使用的SSL协议。
spring.kafka.producer.ssl.trust-store-location = #信任库文件的位置。
spring.kafka.producer.ssl.trust-store-password = #存储信任存储文件的密码。
spring.kafka.producer.ssl.trust-store-type = #信任库的类型。
spring.kafka.producer.transaction-id-prefix = #非空时,为生产者启用事务支持。
spring.kafka.producer.value-serializer = #Serializer 类的值。
spring.kafka.properties。* = #用于配置客户端的生产者和使用者
共有的附加属性。spring.kafka.ssl.key-password = #密钥库文件中私钥的密码。
spring.kafka.ssl.key-store-location = #密钥库文件的位置。
spring.kafka.ssl.key-store-password =#存储密钥库文件的密码。
spring.kafka.ssl.key-store-type = #密钥库的类型。
spring.kafka.ssl.protocol = #要使用的SSL协议。
spring.kafka.ssl.trust-store-location = #信任库文件的位置。
spring.kafka.ssl.trust-store-password = #存储信任存储文件的密码。
spring.kafka.ssl.trust-store-type = #信任库的类型。
spring.kafka.streams.application-id = #Kafka streams application.id property; 默认spring.application.name。
spring.kafka.streams.auto-startup = true #是否自动启动流工厂bean。
spring.kafka.streams.bootstrap-servers = #逗号分隔的主机:端口对列表,用于建立与Kafka集群的初始连接。覆盖流的全局属性。
spring.kafka.streams.cache-max-size-buffering = #用于跨所有线程缓冲的最大内存大小。
spring.kafka.streams.client-id = #ID 在发出请求时传递给服务器。用于服务器端日志记录。
spring.kafka.streams.properties。* = #用于配置流的其他Kafka属性。
spring.kafka.streams.replication-factor =#流处理应用程序创建的更改日志主题和重新分区主题的复制因子。
spring.kafka.streams.ssl.key-password = #密钥库文件中私钥的密码。
spring.kafka.streams.ssl.key-store-location = #密钥库文件的位置。
spring.kafka.streams.ssl.key-store-password = #存储密钥库文件的密码。
spring.kafka.streams.ssl.key-store-type = #密钥库的类型。
spring.kafka.streams.ssl.protocol = #要使用的SSL协议。
spring.kafka.streams.ssl.trust-store-location = #信任库文件的位置。
spring.kafka.streams.ssl.trust-store-password = #存储信任存储文件的密码。
spring.kafka.streams.ssl.trust-store-type = #信任库的类型。
spring.kafka.streams.state-dir = #状态存储的目录位置。
spring.kafka.template.default-topic = #发送消息的默认主题。

#RABBIT(RabbitProperties)
 spring.rabbitmq.addresses = #逗号分隔的客户端应连接的地址列表。
spring.rabbitmq.cache.channel.checkout-timeout = #达到缓存大小后等待获取通道的持续时间。
spring.rabbitmq.cache.channel.size = #要在缓存中保留的通道数。
spring.rabbitmq.cache.connection.mode = channel #连接工厂缓存模式。
spring.rabbitmq.cache.connection.size = #缓存的连接数。
spring.rabbitmq.connection-timeout = #连接超时。将其设置为零以永远等待。
spring.rabbitmq.dynamic = true #是否创建AmqpAdmin bean。
spring.rabbitmq.host = localhost #RabbitMQ主机。
spring.rabbitmq.listener.direct.acknowledge-mode = #容器的确认模式。
spring.rabbitmq.listener.direct.auto-startup = true #是否在启动时自动启动容器。
spring.rabbitmq.listener.direct.consumers-per-queue = #每个队列的消费者数量。
spring.rabbitmq.listener.direct.default-requeue-rejected = #默认情况下,拒绝的交付是否重新排队。
spring.rabbitmq.listener.direct.idle-event-interval =#应该发布空闲容器事件的频率。
spring.rabbitmq.listener.direct.missing-queues-fatal = false #如果容器声明的队列在代理上不可用,则是否失败。
spring.rabbitmq.listener.direct.prefetch = #每个消费者可能未完成的未确认消息的最大数量。
spring.rabbitmq.listener.direct.retry.enabled = false #是否启用发布重试。
spring.rabbitmq.listener.direct.retry.initial-interval = 1000ms #第一次和第二次尝试传递消息之间的持续时间。
spring.rabbitmq.listener.direct.retry.max-attempts = 3#传递邮件的最大尝试次数。
spring.rabbitmq.listener.direct.retry.max -interval = 10000ms #尝试之间的最长持续时间。
spring.rabbitmq.listener.direct.retry.multiplier = 1 #乘数应用于先前的重试间隔。
spring.rabbitmq.listener.direct.retry.stateless = true #重试是无状态还是有状态。
spring.rabbitmq.listener.simple.acknowledge-mode = #容器的确认模式。
spring.rabbitmq.listener.simple.auto-startup = true #是否在启动时自动启动容器。
spring.rabbitmq.listener.simple.concurrency =#侦听器调用者线程的最小数量。
spring.rabbitmq.listener.simple.default-requeue-rejected = #默认情况下,拒绝的交付是否重新排队。
spring.rabbitmq.listener.simple.idle-event-interval = #应该发布空闲容器事件的频率。
spring.rabbitmq.listener.simple.max-concurrency = #侦听器调用者线程的最大数量。
spring.rabbitmq.listener.simple.missing-queues-fatal = true #如果容器声明的队列在代理上不可用,则是否失败和/或如果在运行时删除一个或多个队列,是否停止容器。
spring.rabbitmq.listener.simple.prefetch =#每个消费者可能未完成的未确认消息的最大数量。
spring.rabbitmq.listener.simple.retry.enabled = false #是否启用发布重试。
spring.rabbitmq.listener.simple.retry.initial-interval = 1000ms #第一次和第二次尝试传递消息之间的持续时间。
spring.rabbitmq.listener.simple.retry.max-attempts = 3 #传递邮件的最大尝试次数。
spring.rabbitmq.listener.simple.retry.max -interval = 10000ms #尝试之间的最长持续时间。
spring.rabbitmq.listener.simple.retry.multiplier = 1 #乘数应用于上一个重试间隔。
spring.rabbitmq.listener.simple.retry.stateless = true #重试是无状态还是有状态。
spring.rabbitmq.listener.simple.transaction-size = #确认模式为AUTO时要在acks之间处理的消息数。如果大于预取,则预取将增加到此值。
spring.rabbitmq.listener.type = simple #Listener容器类型。
spring.rabbitmq.password = guest #登录以对代理进行身份验证。
spring.rabbitmq.port = 5672 #RabbitMQ端口。
spring.rabbitmq.publisher-confirms = false #是否启用发布者确认。
spring.rabbitmq.publisher-returns = false#是否启用发布者返回。
spring.rabbitmq.requested-heartbeat = #请求心跳超时; 零,没有。如果未指定持续时间后缀,则将使用秒。
spring.rabbitmq.ssl.algorithm = #SSL 算法使用。默认情况下,由Rabbit客户端库配置。
spring.rabbitmq.ssl.enabled = false #是否启用SSL支持。
spring.rabbitmq.ssl.key-store = #保存SSL证书的密钥库的路径。
spring.rabbitmq.ssl.key-store-password = #用于访问密钥库的密码。
spring.rabbitmq.ssl.key-store-type = PKCS12 #密钥库类型。
spring.rabbitmq.ssl.trust-store = #持有SSL证书的信任存储。
spring.rabbitmq.ssl.trust-store-password = #用于访问信任库的密码。
spring.rabbitmq.ssl.trust-store-type = JKS #Trust store type。
spring.rabbitmq.ssl.validate-server-certificate = true #是否启用服务器端证书验证。
spring.rabbitmq.ssl.verify-hostname = true #是否启用主机名验证。
spring.rabbitmq.template.default-receive-queue = #从明确指定none时接收消息的默认队列的名称。
spring.rabbitmq.template.exchange =#用于发送操作的默认交换的名称。
spring.rabbitmq.template.mandatory = #是否启用强制消息。
spring.rabbitmq.template.receive-timeout = #receive()`操作的超时。
spring.rabbitmq.template.reply-timeout = #outoutout用于`sendAndReceive()`操作。
spring.rabbitmq.template.retry.enabled = false #是否启用发布重试。
spring.rabbitmq.template.retry.initial-interval = 1000ms #第一次和第二次尝试传递消息之间的持续时间。
spring.rabbitmq.template.retry.max-attempts = 3 #传递邮件的最大尝试次数。
spring.rabbitmq.template.retry.max -interval = 10000ms #尝试之间的最长持续时间。
spring.rabbitmq.template.retry.multiplier = 1 #乘数应用于先前的重试间隔。
spring.rabbitmq.template.routing-key = #用于发送操作的默认路由密钥的值。
spring.rabbitmq.username = guest #登录用户以对代理进行身份验证。
spring.rabbitmq.virtual-host = #连接到代理时使用的虚拟主机。


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

#MANAGEMENT HTTP SERVER(ManagementServerProperties)
 management.server.add-application-context-header = false #在每个响应中添加“X-Application-Context”HTTP标头。
management.server.address = #管理端点应绑定到的网络地址。需要自定义management.server.port。
management.server.port = #管理端点HTTP端口(默认情况下使用与应用程序相同的端口)。配置其他端口以使用特定于管理的SSL。
management.server.servlet.context-path = #管理端点context-path(例如,`/ management`)。需要自定义management.server.port。
management.server.ssl.ciphers= #支持的SSL密码。
management.server.ssl.client-auth = #客户端身份验证模式。
management.server.ssl.enabled = true #是否启用SSL支持。
management.server.ssl.enabled-protocols = #启用SSL协议。
management.server.ssl.key-alias = #标识密钥库中密钥的别名。
management.server.ssl.key-password = #用于访问密钥库中密钥的密码。
management.server.ssl.key-store = #保存SSL证书的密钥库的路径(通常是jks文件)。
management.server.ssl.key-store-password =#用于访问密钥库的密码。
management.server.ssl.key-store-provider = #密钥库的提供者。
management.server.ssl.key-store-type = #密钥库的类型。
management.server.ssl.protocol = TLS #要使用的SSL协议。
management.server.ssl.trust-store = #持有SSL证书的信任存储。
management.server.ssl.trust-store-password = #用于访问信任库的密码。
management.server.ssl.trust-store-provider = #信任存储的提供者。
management.server.ssl.trust-store-type = #信任库的类型。

#CLOUDFOUNDRY 
management.cloudfoundry.enabled = true #是否启用扩展的Cloud Foundry执行器端点。
management.cloudfoundry.skip-ssl-validation = false #是否跳过Cloud Foundry执行器端点安全调用的SSL验证。

#ENDPOINTS GENERAL CONFIGURATION 
management.endpoints.enabled-by-default = #默认情况下是否启用或禁用所有端点。

#ENDPOINTS JMX CONFIGURATION(JmxEndpointProperties)
 management.endpoints.jmx.domain = org.springframework.boot #Endpoints JMX域名。如果设置,则回退到'spring.jmx.default-domain'。
management.endpoints.jmx.exposure.include = * #应包含的端点ID或所有的“*”。
management.endpoints.jmx.exposure.exclude = #应排除的端点ID或所有的'*'。
management.endpoints.jmx.static-names = #附加的静态属性,附加到表示端点的MBean的所有ObjectName。

#ENDPOINTS WEB CONFIGURATION(WebEndpointProperties)
 management.endpoints.web.exposure.include = health,info #应包含的端点ID或所有的“*”。
management.endpoints.web.exposure.exclude = #应排除的端点ID或所有的'*'。
management.endpoints.web.base-path = / actuator #Web端点的基本路径。相对于server.servlet.context-path或management.server.servlet.context-path,如果配置了management.server.port。
management.endpoints.web.path-mapping = #端点ID与应公开它们的路径之间的映射。

#ENDPOINTS CORS CONFIGURATION(CorsEndpointProperties)
 management.endpoints.web.cors.allow-credentials = #是否支持凭据。未设置时,不支持凭据。
management.endpoints.web.cors.allowed-headers = #逗号分隔的请求中允许的标头列表。'*'允许所有标题。
management.endpoints.web.cors.allowed-methods = #逗号分隔的允许方法列表。'*'允许所有方法。未设置时,默认为GET。
management.endpoints.web.cors.allowed-origins = #逗号分隔的原始列表允许。'*'允许所有来源。未设置时,将禁用CORS支持。
management.endpoints.web.cors.exposed-headers = #逗号分隔的标题列表,包含在响应中。
management.endpoints.web.cors.max-age = 1800s #客户端缓存来自飞行前请求的响应的时间。如果未指定持续时间后缀,则将使用秒。

#AUDIT EVENTS ENDPOINT(AuditEventsEndpoint)
 management.endpoint.auditevents.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.auditevents.enabled = true #是否启用auditevents端点。

#BEANS ENDPOINT(BeansEndpoint)
 management.endpoint.beans.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.beans.enabled = true #是否启用beans端点。

#CACHES ENDPOINT(CachesEndpoint)
 management.endpoint.caches.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.caches.enabled = true #是否启用缓存端点。

#条件报告ENDPOINT(ConditionsReportEndpoint)
 management.endpoint.conditions.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.conditions.enabled = true #是否启用条件端点。

#CONFIGURATION PROPERTIES REPORT ENDPOINT(ConfigurationPropertiesReportEndpoint,ConfigurationPropertiesReportEndpointProperties)
 management.endpoint.configprops.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.configprops.enabled = true #是否启用configprops端点。
management.endpoint.configprops.keys-to-sanitize = password,secret,key,token,。* credentials。*,vcap_services,sun.java.command #应该清理的密钥。键可以是属性结尾的简单字符串或正则表达式。

#ENVEST ENDPOINT(EnvironmentEndpoint,EnvironmentEndpointProperties)
 management.endpoint.env.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.env.enabled = true #是否启用env端点。
management.endpoint.env.keys-to-sanitize = password,secret,key,token,。* credentials。*,vcap_services,sun.java.command #应该清理的密钥。键可以是属性结尾的简单字符串或正则表达式。

#FLYWAY ENDPOINT(FlywayEndpoint)
 management.endpoint.flyway.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.flyway.enabled = true #是否启用flyway端点。

#HEEC ENDPOINT(HealthEndpoint,HealthEndpointProperties)
 management.endpoint.health.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.health.enabled = true #是否启用运行状况端点。
management.endpoint.health.roles = #用于确定是否授权用户显示详细信息的角色。为空时,所有经过身份验证的用户都被授权。
management.endpoint.health.show-details = never #何时显示完整的健康详细信息。

#HEAP DUMP ENDPOINT(HeapDumpWebEndpoint)
 management.endpoint.heapdump.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.heapdump.enabled = true #是否启用heapdump端点。

#HTTP TRACE ENDPOINT(HttpTraceEndpoint)
 management.endpoint.httptrace.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.httptrace.enabled = true #是否启用httptrace端点。

#INFO ENDPOINT(InfoEndpoint)
 info = #要添加到信息端点的任意属性。
management.endpoint.info.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.info.enabled = true #是否启用信息端点。

#INTEGRATION GRAPH ENDPOINT(IntegrationGraphEndpoint)
 management.endpoint.integrationgraph.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.integrationgraph.enabled = true #是否启用集成图终结点。

#JOLOKIA ENDPOINT(JolokiaProperties)
 management.endpoint.jolokia.config。* = #Jolokia设置。有关更多详细信息,请参阅Jolokia的文档。
management.endpoint.jolokia.enabled = true #是否启用jolokia端点。

#LIQUIBASE ENDPOINT(LiquibaseEndpoint)
 management.endpoint.liquibase.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.liquibase.enabled = true #是否启用liquibase端点。

#LOG FILE ENDPOINT(LogFileWebEndpoint,LogFileWebEndpointProperties)
 management.endpoint.logfile.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.logfile.enabled = true #是否启用日志文件端点。
management.endpoint.logfile.external-file = #要访问的外部日志文件。如果日志文件由输出重定向而不是日志记录系统本身写入,则可以使用。

#LOGGERS ENDPOINT(LoggersEndpoint)
 management.endpoint.loggers.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.loggers.enabled = true #是否启用记录器端点。

#REQUEST MAPPING ENDPOINT(MappingsEndpoint)
 management.endpoint.mappings.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.mappings.enabled = true #是否启用映射端点。

#METRICS ENDPOINT(MetricsEndpoint)
 management.endpoint.metrics.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.metrics.enabled = true #是否启用指标端点。

#PROMETHEUS ENDPOINT(PrometheusScrapeEndpoint)
 management.endpoint.prometheus.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.prometheus.enabled = true #是否启用prometheus端点。

#STEEDEDED TASKS ENDPOINT(ScheduledTasksEndpoint)
 management.endpoint.scheduledtasks.cache.time-to-live = 0ms #可以缓存响应的最长时间。
management.endpoint.scheduledtasks.enabled = true #是否启用scheduledtasks端点。

#SESSIONS ENDPOINT(SessionsEndpoint)
 management.endpoint.sessions.enabled = true #是否启用会话端点。

#SHUTDOWN ENDPOINT(ShutdownEndpoint)
 management.endpoint.shutdown.enabled = false #是否启用关闭端点。
  • 本文作者: blank
  • 本文链接: https://blankhang.com/2020/07/27/spring-boot-properties
  • 版权声明: 本博客所有文章除特别声明外,均采用CC BY-NC-SA 3.0 许可协议。转载请注明出处!
# consul # atomikos # mybatisplus # druid # nexus # nas # named # bind # mysqldump # acme.sh # Dockerfile # rsync # keepalived # swarm # kibana # ubuntu # linux # scp # bugfix # https # ssl # certbot # curl # gogs # adminer # harbor # yum # portainer # python # kubernetes # idea # java # springboot # maven # docker-compose # redis # nginx # mysql # brew # git # chocolatey # jenkins # elasticsearch # docker # haproxy # rabbitmq # centos
提升IDEA开发效率
SpringBoot 2.3 + Druid + MybatisPlus + Atomikos 分布式事务
© 2023 blank
Everything is energy and everything has a frequency