SpringBoot 2.X 配置文件可配置参数说明
blank
blank
发布于 2020-07-27 / 997 阅读 / 0 评论 / 0 点赞

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

#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 #是否启用关闭端点。

评论