可以在application.properties文件內(nèi)部application.yml，文件內(nèi)部或命令行開(kāi)關(guān)中指定各種屬性。本附錄提供了常見(jiàn)Spring Boot屬性的列表以及對(duì)使用它們的基礎(chǔ)類(lèi)的引用。

Spring Boot提供了各種具有高級(jí)值格式的轉(zhuǎn)換機(jī)制，請(qǐng)務(wù)必查看屬性轉(zhuǎn)換部分。

屬性貢獻(xiàn)可以來(lái)自類(lèi)路徑上的其他jar文件，因此您不應(yīng)將此視為詳盡的列表。此外，您可以定義自己的屬性。

此示例文件僅供參考。千萬(wàn)不能復(fù)制和粘貼的全部?jī)?nèi)容到應(yīng)用程序中。相反，只選擇您需要的屬性。

??????SpringBoot 2.x 配置大全（上篇）

??????SpringBoot 2.x 配置大全（下篇）

#JEST （Elasticsearch HTTP客戶(hù)端）（JestProperties）
 spring.elasticsearch.jest.connection-timeout = 3s ＃連接超時(shí)。
spring.elasticsearch.jest.multi-threaded = true ＃是否從多個(gè)執(zhí)行線(xiàn)程啟用連接請(qǐng)求。
spring.elasticsearch.jest.password = ＃登錄密碼。
spring.elasticsearch.jest.proxy.host = #HTTP 客戶(hù)端應(yīng)使用的代理主機(jī)。
spring.elasticsearch.jest.proxy.port = #HTTP 客戶(hù)端應(yīng)使用的代理端口。
spring.elasticsearch.jest.read-timeout = 3s ＃讀取超時(shí)。
spring.elasticsearch.jest.uris = http：// localhost：9200＃逗號(hào)分隔的Elasticsearch實(shí)例列表。
spring.elasticsearch.jest.username = ＃登錄用戶(hù)名。

#Elasticsearch REST客戶(hù)端（RestClientProperties）
 spring.elasticsearch.rest.password = ＃憑據(jù)密碼。
   spring.elasticsearch.rest.uris = http：// localhost：9200 ＃要使用的以逗號(hào)分隔的Elasticsearch實(shí)例列表。
   spring.elasticsearch.rest.username = ＃憑據(jù)用戶(hù)名。

＃H2 Web控制臺(tái)（H2ConsoleProperties）
 spring.h2.console.enabled = false ＃是否啟用控制臺(tái)。
spring.h2.console.path = / h2-console ?？刂婆_(tái)可用的路徑。
spring.h2.console.settings.trace = false ＃是否啟用跟蹤輸出。
spring.h2.console.settings.web-allow-others = false ＃是否啟用遠(yuǎn)程訪問(wèn)。

＃InfluxDB（InfluxDbProperties）
 spring.influx.password = ＃登錄密碼。
spring.influx.url = 要連接的InfluxDB實(shí)例的URL。
spring.influx.user = ＃登錄用戶(hù)。

＃JOOQ （JooqProperties）
 spring.jooq.sql-dialect = #SQL 方言使用。默認(rèn)情況下自動(dòng)檢測(cè)。

#JDBC （JdbcProperties）
 spring.jdbc.template.fetch-size = -1 ＃需要更多行時(shí)應(yīng)從數(shù)據(jù)庫(kù)中提取的行數(shù)。
spring.jdbc.template.max-rows = -1 ＃最大行數(shù)。
spring.jdbc.template.query-timeout = ＃查詢(xún)超時(shí)。默認(rèn)是使用JDBC驅(qū)動(dòng)程序的默認(rèn)配置。如果未指定持續(xù)時(shí)間后綴，則將使用秒。

＃JPA （JpaBaseConfiguration，HibernateJpaAutoConfiguration）
 spring.data.jpa.repositories.bootstrap-mode = default #JAPA 存儲(chǔ)庫(kù)的Bootstrap模式。
spring.data.jpa.repositories.enabled = true ＃是否啟用JPA存儲(chǔ)庫(kù)。
spring.jpa.database = ＃要操作的目標(biāo)數(shù)據(jù)庫(kù)，默認(rèn)情況下自動(dòng)檢測(cè)。也可以使用“databasePlatform”屬性進(jìn)行設(shè)置。
spring.jpa.database-platform = ＃要操作的目標(biāo)數(shù)據(jù)庫(kù)的名稱(chēng)，默認(rèn)情況下自動(dòng)檢測(cè)。也可以使用“Database”枚舉來(lái)設(shè)置。
spring.jpa.generate-ddl = false ＃是否在啟動(dòng)時(shí)初始化架構(gòu)。
spring.jpa.hibernate.ddl-auto = ＃DDL模式。這實(shí)際上是“hibernate.hbm2ddl.auto”屬性的快捷方式。使用嵌入式數(shù)據(jù)庫(kù)時(shí)未默認(rèn)為“create-drop”，并且未檢測(cè)到架構(gòu)管理器。否則，默認(rèn)為“none”。
spring.jpa.hibernate.naming.implicit-strategy = ＃隱式命名策略的完全限定名稱(chēng)。
spring.jpa.hibernate.naming.physical-strategy = ＃物理命名策略的完全限定名稱(chēng)。
spring.jpa.hibernate.use-new-id-generator-mappings = ＃是否將Hibernate的較新的IdentifierGenerator用于AUTO，TABLE和SEQUENCE。
spring.jpa.mapping-resources =＃Mapping資源（相當(dāng)于persistence.xml中的“mapping-file”條目）。
spring.jpa.open-in-view = true ＃注冊(cè)O(shè)penEntityManagerInViewInterceptor。將JPA EntityManager綁定到線(xiàn)程以進(jìn)行整個(gè)請(qǐng)求處理。
spring.jpa.properties。* = ＃要在JPA提供程序上設(shè)置的其他本機(jī)屬性。
spring.jpa.show -sql = false ＃是否啟用SQL語(yǔ)句的日志記錄。

#JTA （JtaAutoConfiguration）
 spring.jta.enabled = true ＃是否啟用JTA支持。
spring.jta.log-dir = #Transaction logs目錄。
spring.jta.transaction-manager-id = #Transaction manager唯一標(biāo)識(shí)符。

#ATOMIKOS（AtomikosProperties）
 spring.jta.atomikos.connectionfactory.borrow-connection-timeout = 30 ＃從池中借用連接的超時(shí)（以秒為單位）。
spring.jta.atomikos.connectionfactory.ignore-session-transacted-flag = true ＃是否在創(chuàng)建會(huì)話(huà)時(shí)忽略事務(wù)處理標(biāo)志。
spring.jta.atomikos.connectionfactory.local-transaction-mode = false ＃是否需要本地事務(wù)。
spring.jta.atomikos.connectionfactory.maintenance-interval = 60 ＃池維護(hù)線(xiàn)程運(yùn)行之間的時(shí)間（以秒為單位）。
spring.jta.atomikos.connectionfactory.max-idle-time = 60＃從池中清除連接的時(shí)間（以秒為單位）。
spring.jta.atomikos.connectionfactory.max-lifetime = 0 ＃連接在被銷(xiāo)毀之前可以合并的時(shí)間（以秒為單位）。0表示沒(méi)有限制。
spring.jta.atomikos.connectionfactory.max-pool-size = 1 ＃池的最大大小。
spring.jta.atomikos.connectionfactory.min-pool-size = 1 ＃池的最小大小。
spring.jta.atomikos.connectionfactory.reap-timeout = 0 ＃借用連接的reap超時(shí)（以秒為單位）。0表示沒(méi)有限制。
spring.jta.atomikos.connectionfactory.unique-resource-name = jmsConnectionFactory＃用于在恢復(fù)期間標(biāo)識(shí)資源的唯一名稱(chēng)。
spring.jta.atomikos.connectionfactory.xa-connection-factory-class-name = #XAConnectionFactory的供應(yīng)商特定實(shí)現(xiàn)。
spring.jta.atomikos.connectionfactory.xa-properties = ＃供應(yīng)商特定的XA屬性。
spring.jta.atomikos.datasource.borrow-connection-timeout = 30 ＃從池中借用連接的超時(shí)時(shí)間（秒）。
spring.jta.atomikos.datasource.concurrent-connection-validation = ＃是否使用并發(fā)連接驗(yàn)證。
spring.jta.atomikos.datasource.default-isolation-level = ＃池提供的連接的默認(rèn)隔離級(jí)別。
spring.jta.atomikos.datasource.login-timeout = ＃用于建立數(shù)據(jù)庫(kù)連接的超時(shí)（以秒為單位）。
spring.jta.atomikos.datasource.maintenance-interval = 60 ＃池維護(hù)線(xiàn)程運(yùn)行之間的時(shí)間（以秒為單位）。
spring.jta.atomikos.datasource.max-idle-time = 60 ＃從池中清除連接的時(shí)間（以秒為單位）。
spring.jta.atomikos.datasource.max-lifetime = 0 ＃連接在被銷(xiāo)毀之前可以合并的時(shí)間（以秒為單位）。0表示沒(méi)有限制。
spring.jta.atomikos.datasource.max-pool-size = 1 ＃池的最大大小。
spring.jta.atomikos.datasource.min-pool-size = 1＃池的最小大小。
spring.jta.atomikos.datasource.reap-timeout = 0 ＃借用連接的reap超時(shí)（以秒為單位）。0表示沒(méi)有限制。
spring.jta.atomikos.datasource.test-query = ＃用于在返回連接之前驗(yàn)證連接的SQL查詢(xún)或語(yǔ)句。
spring.jta.atomikos.datasource.unique-resource-name = dataSource ＃用于在恢復(fù)期間標(biāo)識(shí)資源的唯一名稱(chēng)。
spring.jta.atomikos.datasource.xa-data-source-class-name = #XAConnectionFactory的供應(yīng)商特定實(shí)現(xiàn)。
spring.jta.atomikos.datasource.xa-properties = ＃供應(yīng)商特定的XA屬性。
spring.jta.atomikos.properties.allow-sub-transactions = true ＃指定是否允許子事務(wù)。
spring.jta.atomikos.properties.checkpoint-interval = 500 ＃檢查點(diǎn)之間的間隔，表示為兩個(gè)檢查點(diǎn)之間的日志寫(xiě)入次數(shù)。
spring.jta.atomikos.properties.default -jta -timeout = 10000ms #JTA 事務(wù)的默認(rèn)超時(shí)。
spring.jta.atomikos.properties.default-max-wait-time-on-shutdown = 9223372036854775807 ＃正常關(guān)閉（no-force）等待事務(wù)完成的時(shí)間。
spring.jta.atomikos.properties.enable-logging = true ＃是否啟用磁盤(pán)日志記錄。
spring.jta.atomikos.properties.force-shutdown-on-vm-exit = false ＃虛擬機(jī)關(guān)閉是否應(yīng)觸發(fā)事務(wù)核心的強(qiáng)制關(guān)閉。
spring.jta.atomikos.properties.log-base-dir = ＃應(yīng)存儲(chǔ)日志文件的目錄。
spring.jta.atomikos.properties.log-base-name = tmlog ＃Transactions日志文件基名。
spring.jta.atomikos.properties.max-actives = 50 ＃最大活動(dòng)事務(wù)數(shù)。
spring.jta.atomikos.properties.max-timeout = 300000ms ＃事務(wù)允許的最大超時(shí)時(shí)間。
spring.jta.atomikos.properties.recovery.delay = 10000ms ＃兩次恢復(fù)掃描之間的延遲。
spring.jta.atomikos.properties.recovery.forget- orphaned -log-entries-delay = 86400000ms ＃恢復(fù)之后的延遲可以清除掛起（'孤立'）日志條目。
spring.jta.atomikos.properties.recovery.max-retries = 5 ＃在拋出異常之前提交事務(wù)的重試次數(shù)。
spring.jta.atomikos.properties.recovery.retry-interval = 10000ms ＃重試嘗試之間的延遲。
spring.jta.atomikos.properties.serial-jta-transactions = true ＃是否應(yīng)盡可能加入子事務(wù)。
spring.jta.atomikos.properties.service = ＃應(yīng)該啟動(dòng)的事務(wù)管理器實(shí)現(xiàn)。
spring.jta.atomikos.properties.threaded-two-phase-commit = false ＃是否對(duì)參與資源使用不同（和并發(fā)）線(xiàn)程進(jìn)行兩階段提交。
spring.jta.atomikos.properties.transaction-manager-unique-name = ＃事務(wù)管理器的唯一名稱(chēng)。

＃BITRONIX 
spring.jta.bitronix.connectionfactory.acquire-increment = 1 ＃在增長(zhǎng)池時(shí)創(chuàng)建的連接數(shù)。
spring.jta.bitronix.connectionfactory.acquisition-interval = 1 ＃獲取無(wú)效連接后再次嘗試獲取連接之前等待的時(shí)間（以秒為單位）。
spring.jta.bitronix.connectionfactory.acquisition-timeout = 30 ＃從池中獲取連接的超時(shí)時(shí)間（秒）。
spring.jta.bitronix.connectionfactory.allow-local-transactions = true ＃事務(wù)管理器是否應(yīng)該允許混合XA和非XA事務(wù)。
spring.jta.bitronix.connectionfactory.apply-transaction-timeout = false＃是否應(yīng)在登記時(shí)在XAResource上設(shè)置事務(wù)超時(shí)。
spring.jta.bitronix.connectionfactory.automatic-enlisting-enabled = true ＃是否應(yīng)自動(dòng)登記和退出資源。
spring.jta.bitronix.connectionfactory.cache-producer-consumers = true ＃是否應(yīng)該緩存生產(chǎn)者和消費(fèi)者。
spring.jta.bitronix.connectionfactory.class-name = #XA 資源的底層實(shí)現(xiàn)類(lèi)名。
spring.jta.bitronix.connectionfactory.defer-connection-release = true ＃提供程序是否可以在同一連接上運(yùn)行多個(gè)事務(wù)并支持事務(wù)交錯(cuò)。
spring.jta.bitronix.connectionfactory.disabled= ＃是否禁用此資源，這意味著暫時(shí)禁止從其池中獲取連接。
spring.jta.bitronix.connectionfactory.driver-properties = ＃應(yīng)在底層實(shí)現(xiàn)上設(shè)置的屬性。
spring.jta.bitronix.connectionfactory.failed = ＃將此資源生成器標(biāo)記為失敗。
spring.jta.bitronix.connectionfactory.ignore-recovery-failures = false ＃是否應(yīng)忽略恢復(fù)失敗。
spring.jta.bitronix.connectionfactory.max-idle-time = 60 ＃從池中清除連接的時(shí)間（以秒為單位）。
spring.jta.bitronix.connectionfactory.max-pool-size = 10＃池的最大大小。0表示沒(méi)有限制。
spring.jta.bitronix.connectionfactory.min-pool-size = 0 ＃池的最小大小。
spring.jta.bitronix.connectionfactory.password = ＃用于連接JMS提供程序的密碼。
spring.jta.bitronix.connectionfactory.share-transaction-connections = false ＃是否可以在事務(wù)上下文中共享處于ACCESSIBLE狀態(tài)的連接。
spring.jta.bitronix.connectionfactory.test-connections = true ＃從池中獲取時(shí)是否應(yīng)測(cè)試連接。
spring.jta.bitronix.connectionfactory.two-pc-ordering-position = 1＃在兩階段提交期間此資源應(yīng)采取的位置（始終是第一個(gè)是Integer.MIN_VALUE，總是最后一個(gè)是Integer.MAX_VALUE）。
spring.jta.bitronix.connectionfactory.unique-name = jmsConnectionFactory ＃用于在恢復(fù)期間標(biāo)識(shí)資源的唯一名稱(chēng)。
spring.jta.bitronix.connectionfactory.use -tm 
-join = true ＃啟動(dòng)XAResources時(shí)是否應(yīng)該使用TMJOIN。spring.jta.bitronix.connectionfactory.user = ＃用于連接到JMS提供程序的用戶(hù)。
spring.jta.bitronix.datasource.acquire-increment = 1 ＃在增長(zhǎng)池時(shí)創(chuàng)建的連接數(shù)。
spring.jta.bitronix.datasource.acquisition-interval = 1＃在獲取無(wú)效連接后再次嘗試獲取連接之前等待的時(shí)間（以秒為單位）。
spring.jta.bitronix.datasource.acquisition-timeout = 30 ＃從池中獲取連接的超時(shí)時(shí)間（秒）。
spring.jta.bitronix.datasource.allow-local-transactions = true ＃事務(wù)管理器是否應(yīng)該允許混合XA和非XA事務(wù)。
spring.jta.bitronix.datasource.apply-transaction-timeout = false ＃是否應(yīng)在XAResource登記時(shí)設(shè)置事務(wù)超時(shí)。
spring.jta.bitronix.datasource.automatic-enlisting-enabled = true ＃是否應(yīng)自動(dòng)登記和退出資源。
spring.jta.bitronix.datasource.class-name = #XA 資源的底層實(shí)現(xiàn)類(lèi)名。
spring.jta.bitronix.datasource.cursor-holdability = ＃連接的默認(rèn)光標(biāo)可保持性。
spring.jta.bitronix.datasource.defer-connection-release = true ＃數(shù)據(jù)庫(kù)是否可以在同一連接上運(yùn)行多個(gè)事務(wù)并支持事務(wù)交錯(cuò)。
spring.jta.bitronix.datasource.disabled = ＃是否禁用此資源，這意味著暫時(shí)禁止從其池中獲取連接。
spring.jta.bitronix.datasource.driver-properties = ＃應(yīng)在底層實(shí)現(xiàn)上設(shè)置的屬性。
spring.jta.bitronix.datasource.enable -jdbc4-connection-test = ＃從池中獲取連接時(shí)是否調(diào)用Connection.isValid（）。
spring.jta.bitronix.datasource.failed = ＃將此資源生成器標(biāo)記為失敗。
spring.jta.bitronix.datasource.ignore-recovery-failures = false ＃是否應(yīng)忽略恢復(fù)失敗。
spring.jta.bitronix.datasource.isolation-level = ＃連接的默認(rèn)隔離級(jí)別。
spring.jta.bitronix.datasource.local-auto-commit = ＃本地事務(wù)的默認(rèn)自動(dòng)提交模式。
spring.jta.bitronix.datasource.login-timeout =＃建立數(shù)據(jù)庫(kù)連接的超時(shí)時(shí)間（秒）。
spring.jta.bitronix.datasource.max-idle-time = 60 ＃從池中清除連接的時(shí)間（以秒為單位）。
spring.jta.bitronix.datasource.max-pool-size = 10 ＃池的最大大小。0表示沒(méi)有限制。
spring.jta.bitronix.datasource.min-pool-size = 0 ＃池的最小大小。
spring.jta.bitronix.datasource.prepared-statement-cache-size = 0 ＃
預(yù)準(zhǔn)備語(yǔ)句緩存的目標(biāo)大小。0禁用緩存。spring.jta.bitronix.datasource.share-transaction-connections = false＃是否可以在事務(wù)上下文中共享處于ACCESSIBLE狀態(tài)的連接。
spring.jta.bitronix.datasource.test-query = ＃用于在返回連接之前驗(yàn)證連接的SQL查詢(xún)或語(yǔ)句。
spring.jta.bitronix.datasource.two-pc-ordering-position = 1 ＃此資源在兩階段提交期間應(yīng)采取的位置（始終首先是Integer.MIN_VALUE，并且始終是最后一個(gè)是Integer.MAX_VALUE）。
spring.jta.bitronix.datasource.unique-name = dataSource ＃用于在恢復(fù)期間標(biāo)識(shí)資源的唯一名稱(chēng)。
spring.jta.bitronix.datasource.use -tm -join = true ＃啟動(dòng)XAResources時(shí)是否應(yīng)該使用TMJOIN。
spring.jta.bitronix.properties.allow-multiple-lrc = false ＃是否允許多個(gè)LRC資源登記到同一事務(wù)中。
spring.jta.bitronix.properties.asynchronous2-pc = false ＃是否啟用異步執(zhí)行兩階段提交。
spring.jta.bitronix.properties.background-recovery-interval-seconds = 60 ＃在后臺(tái)運(yùn)行恢復(fù)過(guò)程的時(shí)間間隔（以秒為單位）。
spring.jta.bitronix.properties.current-node-only-recovery = true ＃是否僅恢復(fù)當(dāng)前節(jié)點(diǎn)。
spring.jta.bitronix.properties.debug-zero-resource-transaction = false＃是否記錄創(chuàng)建和提交沒(méi)有單個(gè)登記資源的事務(wù)調(diào)用堆棧。
spring.jta.bitronix.properties.default-transaction-timeout = 60 ＃默認(rèn)事務(wù)超時(shí)，以秒為單位。
spring.jta.bitronix.properties.disable-jmx = false ＃是否啟用JMX支持。
spring.jta.bitronix.properties.exception-analyzer = ＃設(shè)置要使用的異常分析器實(shí)現(xiàn)的完全限定名稱(chēng)。
spring.jta.bitronix.properties.filter-log-status = false ＃是否啟用日志過(guò)濾，以便只寫(xiě)入強(qiáng)制日志。
spring.jta.bitronix.properties.force-batching-enabled = true＃是否批量磁盤(pán)強(qiáng)制。
spring.jta.bitronix.properties.forced-write-enabled = true ＃是否強(qiáng)制將日志記錄到磁盤(pán)。
spring.jta.bitronix.properties.graceful-shutdown-interval = 60 ＃TM在關(guān)閉時(shí)中止事務(wù)之前等待事務(wù)完成的最大秒數(shù)。
spring.jta.bitronix.properties.jndi-transaction-synchronization-registry-name = ＃TransactionSynchronizationRegistry的JNDI名稱(chēng)。
spring.jta.bitronix.properties.jndi-user-transaction-name = ＃UserTransaction的JNDI名稱(chēng)。
spring.jta.bitronix.properties.journal = disk ＃期刊的名稱(chēng)?？梢允?disk'，'null'或類(lèi)名。
spring.jta.bitronix.properties.log-part1-filename = btm1.tlog ＃日志的第一個(gè)片段的名稱(chēng)。
spring.jta.bitronix.properties.log-part2-filename = btm2.tlog ＃日志的第二個(gè)片段的名稱(chēng)。
spring.jta.bitronix.properties.max-log-size-in-mb = 2 ＃日志片段的最大大?。ㄕ鬃止?jié)）。
spring.jta.bitronix.properties.resource-configuration-filename = ＃ResourceLoader配置文件名。
spring.jta.bitronix.properties.server-id = #ASCII ID必須唯一標(biāo)識(shí)此TM實(shí)例。默認(rèn)為機(jī)器的IP地址。
spring.jta.bitronix.properties.skip-corrupted-logs = false#Skip損壞的事務(wù)日志條目。
spring.jta.bitronix.properties.warn-about-zero-resource-transaction = true ＃是否為沒(méi)有單個(gè)登記資源的事務(wù)記錄警告。

＃EMBEDDED MONGODB（EmbeddedMongoProperties）
 spring.mongodb.embedded.features = sync_delay ＃逗號(hào)分隔的要啟用的功能列表。
spring.mongodb.embedded.storage.database-dir = ＃用于數(shù)據(jù)存儲(chǔ)的目錄。
spring.mongodb.embedded.storage.oplog-size = #oplog的最大大小。
spring.mongodb.embedded.storage.repl-set-name = ＃副本集的名稱(chēng)。
spring.mongodb.embedded.version = 3.5.5 ＃要使用的Mongo版本。

#REDIS（RedisProperties）
 spring.redis.cluster.max -redirects = ＃在群集中執(zhí)行命令時(shí)要遵循的最大重定向數(shù)。
spring.redis.cluster.nodes = ＃逗號(hào)分隔的“host：port”對(duì)列表引導(dǎo)自。
spring.redis.database = 0 ＃連接工廠使用的數(shù)據(jù)庫(kù)索引。
spring.redis.url = ＃連接URL。覆蓋主機(jī)，端口和密碼。用戶(hù)被忽略。示例：redis：// user：password@example.com ：6379 
spring.redis.host = localhost ＃Redis服務(wù)器主機(jī)。
spring.redis.jedis.pool.max-active = 8＃池在給定時(shí)間可以分配的最大連接數(shù)。使用負(fù)值無(wú)限制。
spring.redis.jedis.pool.max-idle = 8 ＃池中“空閑”連接的最大數(shù)量。使用負(fù)值表示無(wú)限數(shù)量的空閑連接。
spring.redis.jedis.pool.max -wait = -1ms ＃在池耗盡時(shí)，在拋出異常之前連接分配應(yīng)該阻塞的最長(zhǎng)時(shí)間。使用負(fù)值無(wú)限期阻止。
spring.redis.jedis.pool.min-idle = 0 ＃目標(biāo)是池中維護(hù)的最小空閑連接數(shù)。此設(shè)置僅在其為正時(shí)才有效。
spring.redis.lettuce.pool.max-active = 8＃池在給定時(shí)間可以分配的最大連接數(shù)。使用負(fù)值無(wú)限制。
spring.redis.lettuce.pool.max-idle = 8 ＃池中“空閑”連接的最大數(shù)量。使用負(fù)值表示無(wú)限數(shù)量的空閑連接。
spring.redis.lettuce.pool.max -wait = -1ms ＃在池耗盡時(shí)，在拋出異常之前連接分配應(yīng)阻塞的最長(zhǎng)時(shí)間。使用負(fù)值無(wú)限期阻止。
spring.redis.lettuce.pool.min-idle = 0 ＃目標(biāo)是池中維護(hù)的最小空閑連接數(shù)。此設(shè)置僅在其為正時(shí)才有效。
spring.redis.lettuce.shutdown-timeout = 100ms＃關(guān)機(jī)超時(shí)。
spring.redis.password = ＃redis服務(wù)器的登錄密碼。
spring.redis.port = 6379 #Redis服務(wù)器端口。
spring.redis.sentinel.master = #Redis服務(wù)器的名稱(chēng)。
spring.redis.sentinel.nodes = ＃逗號(hào)分隔的“host：port”對(duì)列表。
spring.redis.ssl = false ＃是否啟用SSL支持。
spring.redis.timeout = ＃連接超時(shí)。

#TRANSACTION （TransactionProperties）
 spring.transaction.default-timeout = ＃默認(rèn)事務(wù)超時(shí)。如果未指定持續(xù)時(shí)間后綴，則將使用秒。
spring.transaction.rollback-on-commit-failure = ＃是否回滾提交失敗。



＃---------------------------------------- 
＃INTEGRATION PROPERTIES 
＃----- -----------------------------------

#ACTIVEMQ（ActiveMQProperties）
 spring.activemq.broker-url = ActiveMQ代理的URL。默認(rèn)情況下自動(dòng)生成。
spring.activemq.close-timeout = 15s ＃在考慮結(jié)束完成之前等待的時(shí)間。
spring.activemq.in-memory = true ＃默認(rèn)代理URL是否應(yīng)該在內(nèi)存中。如果已指定顯式代理，則忽略。
spring.activemq.non-blocking-redelivery = false ＃是否在從回滾事務(wù)重新傳遞消息之前停止消息傳遞。這意味著啟用此消息順序時(shí)不會(huì)保留消息順序。
spring.activemq.password = ＃代理的登錄密碼。
spring.activemq.send-timeout = 0ms ＃等待消息發(fā)送響應(yīng)的時(shí)間。將其設(shè)置為0以永遠(yuǎn)等待。
spring.activemq.user = ＃代理的登錄用戶(hù)。
spring.activemq.packages.trust-all = ＃是否信任所有包。
spring.activemq.packages.trusted = ＃逗號(hào)分隔的要信任的特定包列表（不信任所有包時(shí)）。
spring.activemq.pool.block-if-full = true ＃是否阻止請(qǐng)求連接并且池已滿(mǎn)。將其設(shè)置為false以改為拋出“JMSException”。
spring.activemq.pool.block-if-full-timeout = -1ms＃如果池仍然滿(mǎn)，則在拋出異常之前阻塞。
spring.activemq.pool.enabled = false ＃是否應(yīng)創(chuàng)建JmsPoolConnectionFactory，而不是常規(guī)ConnectionFactory。
spring.activemq.pool.idle-timeout = 30s ＃連接空閑超時(shí)。
spring.activemq.pool.max-connections = 1 ＃最大池化連接數(shù)。
spring.activemq.pool.max-sessions-per-connection = 500 ＃池中每個(gè)連接的最大池化會(huì)話(huà)數(shù)。
spring.activemq.pool.time-between-expiration-check = -1ms ＃在空閑連接驅(qū)逐線(xiàn)程的運(yùn)行之間休眠的時(shí)間。當(dāng)為負(fù)時(shí)，沒(méi)有空閑連接驅(qū)逐線(xiàn)程運(yùn)行。
spring.activemq.pool.use-anonymous-producer = true ＃是否只使用一個(gè)匿名“MessageProducer”實(shí)例。將其設(shè)置為false以在每次需要時(shí)創(chuàng)建一個(gè)“MessageProducer”。

#ARTEMIS （ArtemisProperties）
 spring.artemis.embedded.cluster-password = ＃群集密碼。默認(rèn)情況下在啟動(dòng)時(shí)隨機(jī)生成。
spring.artemis.embedded.data-directory = #Journal 文件目錄。如果關(guān)閉持久性，則沒(méi)有必要。
spring.artemis.embedded.enabled = true ＃如果Artemis服務(wù)器API可用，是否啟用嵌入模式。
spring.artemis.embedded.persistent = false ＃是否啟用持久存儲(chǔ)。
spring.artemis.embedded.queues = ＃逗號(hào)分隔的隊(duì)列，在啟動(dòng)時(shí)創(chuàng)建。
spring.artemis.embedded.server-id =＃服務(wù)器ID。默認(rèn)情況下，使用自動(dòng)遞增的計(jì)數(shù)器。
spring.artemis.embedded.topics = ＃在啟動(dòng)時(shí)要?jiǎng)?chuàng)建的以逗號(hào)分隔的主題列表。
spring.artemis.host = localhost ＃Artemis broker主機(jī)。
spring.artemis.mode = ＃Artemis部署模式，默認(rèn)情況下自動(dòng)檢測(cè)。
spring.artemis.password = ＃代理的登錄密碼。
spring.artemis.pool.block-if-full = true ＃是否在請(qǐng)求連接且池已滿(mǎn)時(shí)阻止。將其設(shè)置為false以改為拋出“JMSException”。
spring.artemis.pool.block-if-full-timeout = -1ms ＃如果池仍然滿(mǎn)，則在拋出異常之前阻塞。
spring.artemis.pool.enabled = false ＃是否應(yīng)創(chuàng)建JmsPoolConnectionFactory，而不是常規(guī)ConnectionFactory。
spring.artemis.pool.idle-timeout = 30s ＃連接空閑超時(shí)。
spring.artemis.pool.max-connections = 1 ＃池化連接的最大數(shù)量。
spring.artemis.pool.max-sessions-per-connection = 500 ＃池中每個(gè)連接的最大池化會(huì)話(huà)數(shù)。
spring.artemis.pool.time-between-expiration-check = -1ms ＃在空閑連接驅(qū)逐線(xiàn)程的運(yùn)行之間休眠的時(shí)間。當(dāng)為負(fù)時(shí)，沒(méi)有空閑連接驅(qū)逐線(xiàn)程運(yùn)行。
spring.artemis.pool.use-anonymous-producers = true＃是否只使用一個(gè)匿名“MessageProducer”實(shí)例。將其設(shè)置為false以在每次需要時(shí)創(chuàng)建一個(gè)“MessageProducer”。
spring.artemis.port = 61616 #Artemis 經(jīng)紀(jì)人端口。
spring.artemis.user = ＃代理的登錄用戶(hù)。

#SPRING BATCH（BatchProperties）
 spring.batch.initialize-schema = embedded ＃數(shù)據(jù)庫(kù)模式初始化模式。
spring.batch.job.enabled = true ＃在啟動(dòng)時(shí)執(zhí)行上下文中的所有Spring Batch作業(yè)。
spring.batch.job.names = ＃逗號(hào)分隔的要在啟動(dòng)時(shí)執(zhí)行的作業(yè)名稱(chēng)列表（例如，`job1，job2`）。默認(rèn)情況下，將執(zhí)行上下文中找到的所有作業(yè)。
spring.batch.schema = classpath中：組織/ springframework的/批號(hào)/核心/ schema- @ @ 平臺(tái)@ @ .SQL ＃的路徑SQL文件，以用于初始化數(shù)據(jù)庫(kù)架構(gòu)。
spring.batch.table-prefix =＃所有批次元數(shù)據(jù)表的表前綴。

#SPRING INTEGRATION（IntegrationProperties）
 spring.integration.jdbc.initialize-schema = embedded ＃數(shù)據(jù)庫(kù)模式初始化模式。
spring.integration.jdbc.schema = classpath中：組織/ springframework的/集成/ JDBC / schema- @ @ 平臺(tái)@ @ .SQL ＃的路徑SQL文件，以用于初始化數(shù)據(jù)庫(kù)架構(gòu)。

#JMS （JmsProperties）
 spring.jms.cache.consumers = false ＃是否緩存消息使用者。
spring.jms.cache.enabled = true ＃是否緩存會(huì)話(huà)。
spring.jms.cache.producers = true ＃是否緩存消息生成器。
spring.jms.cache.session-cache-size = 1 ＃會(huì)話(huà)緩存的大?。ǜ鶕?jù)JMS會(huì)話(huà)類(lèi)型）。
spring.jms.jndi-name = ＃連接工廠JNDI名稱(chēng)。設(shè)置時(shí)，優(yōu)先于其他連接工廠自動(dòng)配置。
spring.jms.listener.acknowledge-mode = ＃容器的確認(rèn)模式。默認(rèn)情況下，偵聽(tīng)器使用自動(dòng)確認(rèn)進(jìn)行事務(wù)處理。
spring.jms.listener.auto-startup = true ＃啟動(dòng)時(shí)自動(dòng)啟動(dòng)容器。
spring.jms.listener.concurrency = ＃最小并發(fā)使用者數(shù)。
spring.jms.listener.max-concurrency = ＃最大并發(fā)使用者數(shù)。
spring.jms.pub-sub-domain = false ＃默認(rèn)目標(biāo)類(lèi)型是否為topic。
spring.jms.template.default-destination = ＃用于沒(méi)有目標(biāo)參數(shù)的發(fā)送和接收操作的默認(rèn)目標(biāo)。
spring.jms.template.delivery-delay = ＃用于發(fā)送呼叫的傳遞延遲。
spring.jms.template.delivery-mode =＃交付模式。設(shè)置時(shí)啟用QoS（服務(wù)質(zhì)量）。
spring.jms.template.priority = ＃發(fā)送時(shí)消息的優(yōu)先級(jí)。設(shè)置時(shí)啟用QoS（服務(wù)質(zhì)量）。
spring.jms.template.qos-enabled = ＃發(fā)送消息時(shí)是否啟用顯式QoS（服務(wù)質(zhì)量）。
spring.jms.template.receive-timeout = ＃用于接收呼叫的超時(shí)。
spring.jms.template.time-to-live = ＃發(fā)送時(shí)消息的生存時(shí)間。設(shè)置時(shí)啟用QoS（服務(wù)質(zhì)量）。

#APACHE KAFKA（KafkaProperties）
 spring.kafka.admin.client-id = #ID 在發(fā)出請(qǐng)求時(shí)傳遞給服務(wù)器。用于服務(wù)器端日志記錄。
spring.kafka.admin.fail-fast = false ＃如果代理在啟動(dòng)時(shí)不可用，是否快速失敗。
spring.kafka.admin.properties。* = ＃用于配置客戶(hù)端的其他特定于管理員的屬性。
spring.kafka.admin.ssl.key-password = ＃密鑰庫(kù)文件中私鑰的密碼。
spring.kafka.admin.ssl.key-store-location = ＃密鑰庫(kù)文件的位置。
spring.kafka.admin.ssl.key-store-password =＃存儲(chǔ)密鑰庫(kù)文件的密碼。
spring.kafka.admin.ssl.key-store-type = ＃密鑰庫(kù)的類(lèi)型。
spring.kafka.admin.ssl.protocol = ＃要使用的SSL協(xié)議。
spring.kafka.admin.ssl.trust-store-location = ＃信任庫(kù)文件的位置。
spring.kafka.admin.ssl.trust-store-password = ＃存儲(chǔ)信任存儲(chǔ)文件的密碼。
spring.kafka.admin.ssl.trust-store-type = ＃信任庫(kù)的類(lèi)型。
spring.kafka.bootstrap-servers = ＃逗號(hào)分隔的主機(jī)：端口對(duì)列表，用于建立與Kafka集群的初始連接。除非被覆蓋，否則適用于所有組件。
spring.kafka.client-id = #ID 在發(fā)出請(qǐng)求時(shí)傳遞給服務(wù)器。用于服務(wù)器端日志記錄。
spring.kafka.consumer.auto-commit-interval = ＃如果'enable.auto.commit'設(shè)置為true，則將消費(fèi)者偏移自動(dòng)提交給Kafka的頻率。
spring.kafka.consumer.auto-offset-reset = ＃當(dāng)Kafka中沒(méi)有初始偏移量或者服務(wù)器上不再存在當(dāng)前偏移量時(shí)該怎么辦。
spring.kafka.consumer.bootstrap-servers = ＃逗號(hào)分隔的主機(jī)：端口對(duì)列表，用于建立與Kafka集群的初始連接。為消費(fèi)者覆蓋全球財(cái)產(chǎn)。
spring.kafka.consumer.client-id =#ID在發(fā)出請(qǐng)求時(shí)傳遞給服務(wù)器。用于服務(wù)器端日志記錄。
spring.kafka.consumer.enable-auto-commit = ＃是否在后臺(tái)定期提交消費(fèi)者的偏移量。
spring.kafka.consumer.fetch-max-wait = ＃如果沒(méi)有足夠的數(shù)據(jù)立即滿(mǎn)足“fetch-min-size”給出的要求，服務(wù)器在回答獲取請(qǐng)求之前會(huì)阻塞的最長(zhǎng)時(shí)間。
spring.kafka.consumer.fetch-min-size = ＃服務(wù)器應(yīng)為獲取請(qǐng)求返回的最小數(shù)據(jù)量。
spring.kafka.consumer.group-id = ＃唯一字符串，用于標(biāo)識(shí)此使用者所屬的使用者組。
spring.kafka.consumer.heartbeat間隔= ＃心跳與消費(fèi)者協(xié)調(diào)員之間的預(yù)期時(shí)間。
spring.kafka.consumer.key-deserializer = #Deserializer 類(lèi)的鍵。
spring.kafka.consumer.max-poll-records = ＃一次調(diào)用poll（）時(shí)返回的最大記錄數(shù)。
spring.kafka.consumer.properties。* = ＃用于配置客戶(hù)端的其他特定于使用者的屬性。
spring.kafka.consumer.ssl.key-password = ＃密鑰庫(kù)文件中私鑰的密碼。
spring.kafka.consumer.ssl.key-store-location = ＃密鑰庫(kù)文件的位置。
spring.kafka.consumer.ssl.key-store-password =＃存儲(chǔ)密鑰庫(kù)文件的密碼。
spring.kafka.consumer.ssl.key-store-type = ＃密鑰庫(kù)的類(lèi)型。
spring.kafka.consumer.ssl.protocol = ＃要使用的SSL協(xié)議。
spring.kafka.consumer.ssl.trust-store-location = ＃信任存儲(chǔ)文件的位置。
spring.kafka.consumer.ssl.trust-store-password = ＃存儲(chǔ)信任存儲(chǔ)文件的密碼。
spring.kafka.consumer.ssl.trust-store-type = ＃信任庫(kù)的類(lèi)型。
spring.kafka.consumer.value-deserializer = #Deserializer 類(lèi)的值。
spring.kafka.jaas.control-flag = required ＃登錄配置的控制標(biāo)志。
spring.kafka.jaas.enabled = false ＃是否啟用JAAS配置。
spring.kafka.jaas.login-module = com.sun.security.auth.module.Krb5LoginModule ＃登錄模塊。
spring.kafka.jaas.options = ＃其他JAAS選項(xiàng)。
spring.kafka.listener.ack-count = ＃當(dāng)ackMode為“COUNT”或“COUNT_TIME”時(shí)，偏移提交之間的記錄數(shù)。
spring.kafka.listener.ack-mode = ＃Listener AckMode。請(qǐng)參閱spring-kafka文檔。
spring.kafka.listener.ack-time = ＃當(dāng)ackMode為“TIME”或“COUNT_TIME”時(shí)，偏移提交之間的時(shí)間。
spring.kafka.listener.client-id =＃偵聽(tīng)器的使用者client.id屬性的前綴。
spring.kafka.listener.concurrency = ＃在偵聽(tīng)器容器中運(yùn)行的線(xiàn)程數(shù)。
spring.kafka.listener.idle-event-interval = ＃發(fā)布空閑消費(fèi)者事件（未收到數(shù)據(jù)）之間的時(shí)間。
spring.kafka.listener.log-container-config = ＃是否在初始化期間記錄容器配置（INFO級(jí)別）。
spring.kafka.listener.monitor-interval = ＃檢查無(wú)響應(yīng)的消費(fèi)者之間的時(shí)間。如果未指定持續(xù)時(shí)間后綴，則將使用秒。
spring.kafka.listener.no-poll-threshold =#Multiplier應(yīng)用于“pollTimeout”以確定消費(fèi)者是否無(wú)響應(yīng)。
spring.kafka.listener.poll-timeout = ＃輪詢(xún)消費(fèi)者時(shí)使用的超時(shí)。
spring.kafka.listener.type = single ＃Listener類(lèi)型。
spring.kafka.producer.acks = ＃生產(chǎn)者要求領(lǐng)導(dǎo)者在考慮完成請(qǐng)求之前收到的確認(rèn)數(shù)。
spring.kafka.producer.batch-size = ＃默認(rèn)批量大小。
spring.kafka.producer.bootstrap-servers = ＃逗號(hào)分隔的主機(jī)：端口對(duì)列表，用于建立與Kafka集群的初始連接。為生產(chǎn)者覆蓋全球財(cái)產(chǎn)。
spring.kafka.producer.buffer-memory = ＃生產(chǎn)者可用于緩沖等待發(fā)送到服務(wù)器的記錄的總內(nèi)存大小。
spring.kafka.producer.client-id = #ID 在發(fā)出請(qǐng)求時(shí)傳遞給服務(wù)器。用于服務(wù)器端日志記錄。
spring.kafka.producer.compression-type = ＃生產(chǎn)者生成的所有數(shù)據(jù)的壓縮類(lèi)型。
spring.kafka.producer.key-serializer = ＃密碼的Serializer類(lèi)。
spring.kafka.producer.properties。* = ＃用于配置客戶(hù)端的其他特定于生產(chǎn)者的屬性。
spring.kafka.producer.retries = ＃大于零時(shí)，啟用重試失敗的發(fā)送。
spring.kafka.producer.ssl.key-password = ＃密鑰庫(kù)文件中私鑰的密碼。
spring.kafka.producer.ssl.key-store-location = ＃密鑰庫(kù)文件的位置。
spring.kafka.producer.ssl.key-store-password = ＃存儲(chǔ)密鑰庫(kù)文件的密碼。
spring.kafka.producer.ssl.key-store-type = ＃密鑰庫(kù)的類(lèi)型。
spring.kafka.producer.ssl.protocol = ＃要使用的SSL協(xié)議。
spring.kafka.producer.ssl.trust-store-location = ＃信任庫(kù)文件的位置。
spring.kafka.producer.ssl.trust-store-password = ＃存儲(chǔ)信任存儲(chǔ)文件的密碼。
spring.kafka.producer.ssl.trust-store-type = ＃信任庫(kù)的類(lèi)型。
spring.kafka.producer.transaction-id-prefix = ＃非空時(shí)，為生產(chǎn)者啟用事務(wù)支持。
spring.kafka.producer.value-serializer = #Serializer 類(lèi)的值。
spring.kafka.properties。* = ＃用于配置客戶(hù)端的生產(chǎn)者和使用者
共有的附加屬性。spring.kafka.ssl.key-password = ＃密鑰庫(kù)文件中私鑰的密碼。
spring.kafka.ssl.key-store-location = ＃密鑰庫(kù)文件的位置。
spring.kafka.ssl.key-store-password =＃存儲(chǔ)密鑰庫(kù)文件的密碼。
spring.kafka.ssl.key-store-type = ＃密鑰庫(kù)的類(lèi)型。
spring.kafka.ssl.protocol = ＃要使用的SSL協(xié)議。
spring.kafka.ssl.trust-store-location = ＃信任庫(kù)文件的位置。
spring.kafka.ssl.trust-store-password = ＃存儲(chǔ)信任存儲(chǔ)文件的密碼。
spring.kafka.ssl.trust-store-type = ＃信任庫(kù)的類(lèi)型。
spring.kafka.streams.application-id = #Kafka streams application.id property; 默認(rèn)spring.application.name。
spring.kafka.streams.auto-startup = true ＃是否自動(dòng)啟動(dòng)流工廠bean。
spring.kafka.streams.bootstrap-servers = ＃逗號(hào)分隔的主機(jī)：端口對(duì)列表，用于建立與Kafka集群的初始連接。覆蓋流的全局屬性。
spring.kafka.streams.cache-max-size-buffering = ＃用于跨所有線(xiàn)程緩沖的最大內(nèi)存大小。
spring.kafka.streams.client-id = #ID 在發(fā)出請(qǐng)求時(shí)傳遞給服務(wù)器。用于服務(wù)器端日志記錄。
spring.kafka.streams.properties。* = ＃用于配置流的其他Kafka屬性。
spring.kafka.streams.replication-factor =＃流處理應(yīng)用程序創(chuàng)建的更改日志主題和重新分區(qū)主題的復(fù)制因子。
spring.kafka.streams.ssl.key-password = ＃密鑰庫(kù)文件中私鑰的密碼。
spring.kafka.streams.ssl.key-store-location = ＃密鑰庫(kù)文件的位置。
spring.kafka.streams.ssl.key-store-password = ＃存儲(chǔ)密鑰庫(kù)文件的密碼。
spring.kafka.streams.ssl.key-store-type = ＃密鑰庫(kù)的類(lèi)型。
spring.kafka.streams.ssl.protocol = ＃要使用的SSL協(xié)議。
spring.kafka.streams.ssl.trust-store-location = ＃信任庫(kù)文件的位置。
spring.kafka.streams.ssl.trust-store-password = ＃存儲(chǔ)信任存儲(chǔ)文件的密碼。
spring.kafka.streams.ssl.trust-store-type = ＃信任庫(kù)的類(lèi)型。
spring.kafka.streams.state-dir = ＃狀態(tài)存儲(chǔ)的目錄位置。
spring.kafka.template.default-topic = ＃發(fā)送消息的默認(rèn)主題。

#RABBIT（RabbitProperties）
 spring.rabbitmq.addresses = ＃逗號(hào)分隔的客戶(hù)端應(yīng)連接的地址列表。
spring.rabbitmq.cache.channel.checkout-timeout = ＃達(dá)到緩存大小后等待獲取通道的持續(xù)時(shí)間。
spring.rabbitmq.cache.channel.size = ＃要在緩存中保留的通道數(shù)。
spring.rabbitmq.cache.connection.mode = channel ＃連接工廠緩存模式。
spring.rabbitmq.cache.connection.size = ＃緩存的連接數(shù)。
spring.rabbitmq.connection-timeout = ＃連接超時(shí)。將其設(shè)置為零以永遠(yuǎn)等待。
spring.rabbitmq.dynamic = true ＃是否創(chuàng)建AmqpAdmin bean。
spring.rabbitmq.host = localhost ＃RabbitMQ主機(jī)。
spring.rabbitmq.listener.direct.acknowledge-mode = ＃容器的確認(rèn)模式。
spring.rabbitmq.listener.direct.auto-startup = true ＃是否在啟動(dòng)時(shí)自動(dòng)啟動(dòng)容器。
spring.rabbitmq.listener.direct.consumers-per-queue = ＃每個(gè)隊(duì)列的消費(fèi)者數(shù)量。
spring.rabbitmq.listener.direct.default-requeue-rejected = ＃默認(rèn)情況下，拒絕的交付是否重新排隊(duì)。
spring.rabbitmq.listener.direct.idle-event-interval =＃應(yīng)該發(fā)布空閑容器事件的頻率。
spring.rabbitmq.listener.direct.missing-queues-fatal = false ＃如果容器聲明的隊(duì)列在代理上不可用，則是否失敗。
spring.rabbitmq.listener.direct.prefetch = ＃每個(gè)消費(fèi)者可能未完成的未確認(rèn)消息的最大數(shù)量。
spring.rabbitmq.listener.direct.retry.enabled = false ＃是否啟用發(fā)布重試。
spring.rabbitmq.listener.direct.retry.initial-interval = 1000ms ＃第一次和第二次嘗試傳遞消息之間的持續(xù)時(shí)間。
spring.rabbitmq.listener.direct.retry.max-attempts = 3＃傳遞郵件的最大嘗試次數(shù)。
spring.rabbitmq.listener.direct.retry.max -interval = 10000ms ＃嘗試之間的最長(zhǎng)持續(xù)時(shí)間。
spring.rabbitmq.listener.direct.retry.multiplier = 1 ＃乘數(shù)應(yīng)用于先前的重試間隔。
spring.rabbitmq.listener.direct.retry.stateless = true ＃重試是無(wú)狀態(tài)還是有狀態(tài)。
spring.rabbitmq.listener.simple.acknowledge-mode = ＃容器的確認(rèn)模式。
spring.rabbitmq.listener.simple.auto-startup = true ＃是否在啟動(dòng)時(shí)自動(dòng)啟動(dòng)容器。
spring.rabbitmq.listener.simple.concurrency =＃偵聽(tīng)器調(diào)用者線(xiàn)程的最小數(shù)量。
spring.rabbitmq.listener.simple.default-requeue-rejected = ＃默認(rèn)情況下，拒絕的交付是否重新排隊(duì)。
spring.rabbitmq.listener.simple.idle-event-interval = ＃應(yīng)該發(fā)布空閑容器事件的頻率。
spring.rabbitmq.listener.simple.max-concurrency = ＃偵聽(tīng)器調(diào)用者線(xiàn)程的最大數(shù)量。
spring.rabbitmq.listener.simple.missing-queues-fatal = true ＃如果容器聲明的隊(duì)列在代理上不可用，則是否失敗和/或如果在運(yùn)行時(shí)刪除一個(gè)或多個(gè)隊(duì)列，是否停止容器。
spring.rabbitmq.listener.simple.prefetch =＃每個(gè)消費(fèi)者可能未完成的未確認(rèn)消息的最大數(shù)量。
spring.rabbitmq.listener.simple.retry.enabled = false ＃是否啟用發(fā)布重試。
spring.rabbitmq.listener.simple.retry.initial-interval = 1000ms ＃第一次和第二次嘗試傳遞消息之間的持續(xù)時(shí)間。
spring.rabbitmq.listener.simple.retry.max-attempts = 3 ＃傳遞郵件的最大嘗試次數(shù)。
spring.rabbitmq.listener.simple.retry.max -interval = 10000ms ＃嘗試之間的最長(zhǎng)持續(xù)時(shí)間。
spring.rabbitmq.listener.simple.retry.multiplier = 1 ＃乘數(shù)應(yīng)用于上一個(gè)重試間隔。
spring.rabbitmq.listener.simple.retry.stateless = true ＃重試是無(wú)狀態(tài)還是有狀態(tài)。
spring.rabbitmq.listener.simple.transaction-size = ＃確認(rèn)模式為AUTO時(shí)要在acks之間處理的消息數(shù)。如果大于預(yù)取，則預(yù)取將增加到此值。
spring.rabbitmq.listener.type = simple ＃Listener容器類(lèi)型。
spring.rabbitmq.password = guest ＃登錄以對(duì)代理進(jìn)行身份驗(yàn)證。
spring.rabbitmq.port = 5672 ＃RabbitMQ端口。
spring.rabbitmq.publisher-confirms = false ＃是否啟用發(fā)布者確認(rèn)。
spring.rabbitmq.publisher-returns = false＃是否啟用發(fā)布者返回。
spring.rabbitmq.requested-heartbeat = ＃請(qǐng)求心跳超時(shí); 零，沒(méi)有。如果未指定持續(xù)時(shí)間后綴，則將使用秒。
spring.rabbitmq.ssl.algorithm = #SSL 算法使用。默認(rèn)情況下，由Rabbit客戶(hù)端庫(kù)配置。
spring.rabbitmq.ssl.enabled = false ＃是否啟用SSL支持。
spring.rabbitmq.ssl.key-store = ＃保存SSL證書(shū)的密鑰庫(kù)的路徑。
spring.rabbitmq.ssl.key-store-password = ＃用于訪問(wèn)密鑰庫(kù)的密碼。
spring.rabbitmq.ssl.key-store-type = PKCS12 ＃密鑰庫(kù)類(lèi)型。
spring.rabbitmq.ssl.trust-store = ＃持有SSL證書(shū)的信任存儲(chǔ)。
spring.rabbitmq.ssl.trust-store-password = ＃用于訪問(wèn)信任庫(kù)的密碼。
spring.rabbitmq.ssl.trust-store-type = JKS #Trust store type。
spring.rabbitmq.ssl.validate-server-certificate = true ＃是否啟用服務(wù)器端證書(shū)驗(yàn)證。
spring.rabbitmq.ssl.verify-hostname = true ＃是否啟用主機(jī)名驗(yàn)證。
spring.rabbitmq.template.default-receive-queue = ＃從明確指定none時(shí)接收消息的默認(rèn)隊(duì)列的名稱(chēng)。
spring.rabbitmq.template.exchange =＃用于發(fā)送操作的默認(rèn)交換的名稱(chēng)。
spring.rabbitmq.template.mandatory = ＃是否啟用強(qiáng)制消息。
spring.rabbitmq.template.receive-timeout = ＃receive（）`操作的超時(shí)。
spring.rabbitmq.template.reply-timeout = #outoutout用于`sendAndReceive（）`操作。
spring.rabbitmq.template.retry.enabled = false ＃是否啟用發(fā)布重試。
spring.rabbitmq.template.retry.initial-interval = 1000ms ＃第一次和第二次嘗試傳遞消息之間的持續(xù)時(shí)間。
spring.rabbitmq.template.retry.max-attempts = 3 ＃傳遞郵件的最大嘗試次數(shù)。
spring.rabbitmq.template.retry.max -interval = 10000ms ＃嘗試之間的最長(zhǎng)持續(xù)時(shí)間。
spring.rabbitmq.template.retry.multiplier = 1 ＃乘數(shù)應(yīng)用于先前的重試間隔。
spring.rabbitmq.template.routing-key = ＃用于發(fā)送操作的默認(rèn)路由密鑰的值。
spring.rabbitmq.username = guest ＃登錄用戶(hù)以對(duì)代理進(jìn)行身份驗(yàn)證。
spring.rabbitmq.virtual-host = ＃連接到代理時(shí)使用的虛擬主機(jī)。


＃---------------------------------------- 
＃ACTUATOR PROPERTIES 
＃----- -----------------------------------

#MANAGEMENT HTTP SERVER（ManagementServerProperties）
 management.server.add-application-context-header = false ＃在每個(gè)響應(yīng)中添加“X-Application-Context”HTTP標(biāo)頭。
management.server.address = ＃管理端點(diǎn)應(yīng)綁定到的網(wǎng)絡(luò)地址。需要自定義management.server.port。
management.server.port = ＃管理端點(diǎn)HTTP端口（默認(rèn)情況下使用與應(yīng)用程序相同的端口）。配置其他端口以使用特定于管理的SSL。
management.server.servlet.context-path = ＃管理端點(diǎn)context-path（例如，`/ management`）。需要自定義management.server.port。
management.server.ssl.ciphers= ＃支持的SSL密碼。
management.server.ssl.client-auth = ?？蛻?hù)端身份驗(yàn)證模式。
management.server.ssl.enabled = true ＃是否啟用SSL支持。
management.server.ssl.enabled-protocols = ＃啟用SSL協(xié)議。
management.server.ssl.key-alias = ＃標(biāo)識(shí)密鑰庫(kù)中密鑰的別名。
management.server.ssl.key-password = ＃用于訪問(wèn)密鑰庫(kù)中密鑰的密碼。
management.server.ssl.key-store = ＃保存SSL證書(shū)的密鑰庫(kù)的路徑（通常是jks文件）。
management.server.ssl.key-store-password =＃用于訪問(wèn)密鑰庫(kù)的密碼。
management.server.ssl.key-store-provider = ＃密鑰庫(kù)的提供者。
management.server.ssl.key-store-type = ＃密鑰庫(kù)的類(lèi)型。
management.server.ssl.protocol = TLS ＃要使用的SSL協(xié)議。
management.server.ssl.trust-store = ＃持有SSL證書(shū)的信任存儲(chǔ)。
management.server.ssl.trust-store-password = ＃用于訪問(wèn)信任庫(kù)的密碼。
management.server.ssl.trust-store-provider = ＃信任存儲(chǔ)的提供者。
management.server.ssl.trust-store-type = ＃信任庫(kù)的類(lèi)型。

#CLOUDFOUNDRY 
management.cloudfoundry.enabled = true ＃是否啟用擴(kuò)展的Cloud Foundry執(zhí)行器端點(diǎn)。
management.cloudfoundry.skip-ssl-validation = false ＃是否跳過(guò)Cloud Foundry執(zhí)行器端點(diǎn)安全調(diào)用的SSL驗(yàn)證。

#ENDPOINTS GENERAL CONFIGURATION 
management.endpoints.enabled-by-default = ＃默認(rèn)情況下是否啟用或禁用所有端點(diǎn)。

#ENDPOINTS JMX CONFIGURATION（JmxEndpointProperties）
 management.endpoints.jmx.domain = org.springframework.boot #Endpoints JMX域名。如果設(shè)置，則回退到'spring.jmx.default-domain'。
management.endpoints.jmx.exposure.include = * ＃應(yīng)包含的端點(diǎn)ID或所有的“*”。
management.endpoints.jmx.exposure.exclude = ＃應(yīng)排除的端點(diǎn)ID或所有的'*'。
management.endpoints.jmx.static-names = ＃附加的靜態(tài)屬性，附加到表示端點(diǎn)的MBean的所有ObjectName。

#ENDPOINTS WEB CONFIGURATION（WebEndpointProperties）
 management.endpoints.web.exposure.include = health，info ＃應(yīng)包含的端點(diǎn)ID或所有的“*”。
management.endpoints.web.exposure.exclude = ＃應(yīng)排除的端點(diǎn)ID或所有的'*'。
management.endpoints.web.base-path = / actuator #Web端點(diǎn)的基本路徑。相對(duì)于server.servlet.context-path或management.server.servlet.context-path，如果配置了management.server.port。
management.endpoints.web.path-mapping = ＃端點(diǎn)ID與應(yīng)公開(kāi)它們的路徑之間的映射。

#ENDPOINTS CORS CONFIGURATION（CorsEndpointProperties）
 management.endpoints.web.cors.allow-credentials = ＃是否支持憑據(jù)。未設(shè)置時(shí)，不支持憑據(jù)。
management.endpoints.web.cors.allowed-headers = ＃逗號(hào)分隔的請(qǐng)求中允許的標(biāo)頭列表。'*'允許所有標(biāo)題。
management.endpoints.web.cors.allowed-methods = ＃逗號(hào)分隔的允許方法列表。'*'允許所有方法。未設(shè)置時(shí)，默認(rèn)為GET。
management.endpoints.web.cors.allowed-origins = ＃逗號(hào)分隔的原始列表允許。'*'允許所有來(lái)源。未設(shè)置時(shí)，將禁用CORS支持。
management.endpoints.web.cors.exposed-headers = ＃逗號(hào)分隔的標(biāo)題列表，包含在響應(yīng)中。
management.endpoints.web.cors.max-age = 1800s ?？蛻?hù)端緩存來(lái)自飛行前請(qǐng)求的響應(yīng)的時(shí)間。如果未指定持續(xù)時(shí)間后綴，則將使用秒。

#AUDIT EVENTS ENDPOINT（AuditEventsEndpoint）
 management.endpoint.auditevents.cache.time-to-live = 0ms ?？梢跃彺骓憫?yīng)的最長(zhǎng)時(shí)間。
management.endpoint.auditevents.enabled = true ＃是否啟用auditevents端點(diǎn)。

#BEANS ENDPOINT（BeansEndpoint）
 management.endpoint.beans.cache.time-to-live = 0ms ?？梢跃彺骓憫?yīng)的最長(zhǎng)時(shí)間。
management.endpoint.beans.enabled = true ＃是否啟用beans端點(diǎn)。

#CACHES ENDPOINT（CachesEndpoint）
 management.endpoint.caches.cache.time-to-live = 0ms ?？梢跃彺骓憫?yīng)的最長(zhǎng)時(shí)間。
management.endpoint.caches.enabled = true ＃是否啟用緩存端點(diǎn)。

＃條件報(bào)告ENDPOINT（ConditionsReportEndpoint）
 management.endpoint.conditions.cache.time-to-live = 0ms ?？梢跃彺骓憫?yīng)的最長(zhǎng)時(shí)間。
management.endpoint.conditions.enabled = true ＃是否啟用條件端點(diǎn)。

#CONFIGURATION PROPERTIES REPORT ENDPOINT（ConfigurationPropertiesReportEndpoint，ConfigurationPropertiesReportEndpointProperties）
 management.endpoint.configprops.cache.time-to-live = 0ms ?？梢跃彺骓憫?yīng)的最長(zhǎng)時(shí)間。
management.endpoint.configprops.enabled = true ＃是否啟用configprops端點(diǎn)。
management.endpoint.configprops.keys-to-sanitize = password，secret，key，token，。* credentials。*，vcap_services，sun.java.command ＃應(yīng)該清理的密鑰。鍵可以是屬性結(jié)尾的簡(jiǎn)單字符串或正則表達(dá)式。

#ENVEST ENDPOINT（EnvironmentEndpoint，EnvironmentEndpointProperties）
 management.endpoint.env.cache.time-to-live = 0ms ＃可以緩存響應(yīng)的最長(zhǎng)時(shí)間。
management.endpoint.env.enabled = true ＃是否啟用env端點(diǎn)。
management.endpoint.env.keys-to-sanitize = password，secret，key，token，。* credentials。*，vcap_services，sun.java.command ＃應(yīng)該清理的密鑰。鍵可以是屬性結(jié)尾的簡(jiǎn)單字符串或正則表達(dá)式。

#FLYWAY ENDPOINT（FlywayEndpoint）
 management.endpoint.flyway.cache.time-to-live = 0ms ＃可以緩存響應(yīng)的最長(zhǎng)時(shí)間。
management.endpoint.flyway.enabled = true ＃是否啟用flyway端點(diǎn)。

#HEEC ENDPOINT（HealthEndpoint，HealthEndpointProperties）
 management.endpoint.health.cache.time-to-live = 0ms ＃可以緩存響應(yīng)的最長(zhǎng)時(shí)間。
management.endpoint.health.enabled = true ＃是否啟用運(yùn)行狀況端點(diǎn)。
management.endpoint.health.roles = ＃用于確定是否授權(quán)用戶(hù)顯示詳細(xì)信息的角色。為空時(shí)，所有經(jīng)過(guò)身份驗(yàn)證的用戶(hù)都被授權(quán)。
management.endpoint.health.show-details = never ＃何時(shí)顯示完整的健康詳細(xì)信息。

#HEAP DUMP ENDPOINT（HeapDumpWebEndpoint）
 management.endpoint.heapdump.cache.time-to-live = 0ms ?？梢跃彺骓憫?yīng)的最長(zhǎng)時(shí)間。
management.endpoint.heapdump.enabled = true ＃是否啟用heapdump端點(diǎn)。

#HTTP TRACE ENDPOINT（HttpTraceEndpoint）
 management.endpoint.httptrace.cache.time-to-live = 0ms ＃可以緩存響應(yīng)的最長(zhǎng)時(shí)間。
management.endpoint.httptrace.enabled = true ＃是否啟用httptrace端點(diǎn)。

#INFO ENDPOINT（InfoEndpoint）
 info = ＃要添加到信息端點(diǎn)的任意屬性。
management.endpoint.info.cache.time-to-live = 0ms ?？梢跃彺骓憫?yīng)的最長(zhǎng)時(shí)間。
management.endpoint.info.enabled = true ＃是否啟用信息端點(diǎn)。

#INTEGRATION GRAPH ENDPOINT（IntegrationGraphEndpoint）
 management.endpoint.integrationgraph.cache.time-to-live = 0ms ?？梢跃彺骓憫?yīng)的最長(zhǎng)時(shí)間。
management.endpoint.integrationgraph.enabled = true ＃是否啟用集成圖終結(jié)點(diǎn)。

#JOLOKIA ENDPOINT（JolokiaProperties）
 management.endpoint.jolokia.config。* = ＃Jolokia設(shè)置。有關(guān)更多詳細(xì)信息，請(qǐng)參閱Jolokia的文檔。
management.endpoint.jolokia.enabled = true ＃是否啟用jolokia端點(diǎn)。

#LIQUIBASE ENDPOINT（LiquibaseEndpoint）
 management.endpoint.liquibase.cache.time-to-live = 0ms ?？梢跃彺骓憫?yīng)的最長(zhǎng)時(shí)間。
management.endpoint.liquibase.enabled = true ＃是否啟用liquibase端點(diǎn)。

＃LOG FILE ENDPOINT（LogFileWebEndpoint，LogFileWebEndpointProperties）
 management.endpoint.logfile.cache.time-to-live = 0ms ?？梢跃彺骓憫?yīng)的最長(zhǎng)時(shí)間。
management.endpoint.logfile.enabled = true ＃是否啟用日志文件端點(diǎn)。
management.endpoint.logfile.external-file = ＃要訪問(wèn)的外部日志文件。如果日志文件由輸出重定向而不是日志記錄系統(tǒng)本身寫(xiě)入，則可以使用。

＃LOGGERS ENDPOINT（LoggersEndpoint）
 management.endpoint.loggers.cache.time-to-live = 0ms ?？梢跃彺骓憫?yīng)的最長(zhǎng)時(shí)間。
management.endpoint.loggers.enabled = true ＃是否啟用記錄器端點(diǎn)。

#REQUEST MAPPING ENDPOINT（MappingsEndpoint）
 management.endpoint.mappings.cache.time-to-live = 0ms ?？梢跃彺骓憫?yīng)的最長(zhǎng)時(shí)間。
management.endpoint.mappings.enabled = true ＃是否啟用映射端點(diǎn)。

#METRICS ENDPOINT（MetricsEndpoint）
 management.endpoint.metrics.cache.time-to-live = 0ms ?？梢跃彺骓憫?yīng)的最長(zhǎng)時(shí)間。
management.endpoint.metrics.enabled = true ＃是否啟用指標(biāo)端點(diǎn)。

#PROMETHEUS ENDPOINT（PrometheusScrapeEndpoint）
 management.endpoint.prometheus.cache.time-to-live = 0ms ?？梢跃彺骓憫?yīng)的最長(zhǎng)時(shí)間。
management.endpoint.prometheus.enabled = true ＃是否啟用prometheus端點(diǎn)。

#STEEDEDED TASKS ENDPOINT（ScheduledTasksEndpoint）
 management.endpoint.scheduledtasks.cache.time-to-live = 0ms ?？梢跃彺骓憫?yīng)的最長(zhǎng)時(shí)間。
management.endpoint.scheduledtasks.enabled = true ＃是否啟用scheduledtasks端點(diǎn)。

#SESSIONS ENDPOINT（SessionsEndpoint）
 management.endpoint.sessions.enabled = true ＃是否啟用會(huì)話(huà)端點(diǎn)。

#SHUTDOWN ENDPOINT（ShutdownEndpoint）
 management.endpoint.shutdown.enabled = false ＃是否啟用關(guān)閉端點(diǎn)。

SpringBoot 整合 Dubbo + Zookeeper ：https://github.com/i-Javan/springboot
SpringBoot 整合 Reids ：https://github.com/i-Javan/springboot/tree/master/movebrick-mybatis-annotation
SpringBoot 整合 Mybatis ：https://github.com/i-Javan/springboot/tree/master/movebrick-mybatis
SpringBoot 整合 MybatisPlus ：https://github.com/i-Javan/springboot/tree/master/movebrick-mybatisPlus
SpringBoot 整合 MybatisAnnotation ：https://github.com/i-Javan/springboot/tree/master/movebrick-mybatis-annotation
SpringBoot 整合 Elasticsearch：https://github.com/i-Javan/springboot/tree/master/movebrick-elasticsearch
SpringBoot 整合 ActiveMQ：https://github.com/i-Javan/springboot/tree/master/movebrick-activeMQ