SpringBoot 配置文件 application.yml(application.properties) 配置大全

參考網址：https://docs.spring.io/spring-boot/docs/current/reference/html/common-application-properties.html

可以在application.properties文件內部application.yml，文件內部或命令行開關中指定各種屬性。本附錄提供了常見Spring Boot屬性的列表以及對使用它們的基礎類的引用。

＃=================================================================== 
＃COMMON SPRING BOOT PROPERTIES 
##
此樣本文件作爲指南提供。不要將它的#complete複製
到您自己的應用程序中。^^^
＃===================================================================
＃----------------------------------------
#CORE PROPERTIES
＃----- ----------------------------------- 
debug=false ＃啓用調試日誌。
trace=false ＃啓用跟蹤日誌。
#logGING
logging.config=＃日誌配置文件的位置。例如，Logback的`classpath：logback.xml`。
logging.exception-conversion-word=％wEx ＃記錄異常時使用的轉換字。
logging.file=＃日誌文件名（例如，`myapp.log`）。名稱可以是精確位置或相對於當前目錄。
logging.file.max-history=0 ＃要保留的歸檔日誌文件的最大值。僅支持默認的logback設置。
logging.file.max-size=10MB ＃最大日誌文件大小。僅支持默認的logback設置。
logging.group.*=＃記錄組以同時快速更改多個記錄器。例如，`logging.level.db = org.hibernate，org.springframework.jdbc`。
logging.level.*=＃日誌級別嚴重性映射。例如，`logging.level.org.springframework = DEBUG`。
logging.path=＃日誌文件的位置。例如，`/ var / log`。
logging.pattern.console=＃用於輸出到控制檯的Appender模式。僅支持默認的Logback設置。
logging.pattern.dateformat=yyyy-MM-dd HH：mm：ss.SSS ＃日誌日期格式的Appender模式。僅支持默認的Logback設置。
logging.pattern.file=＃用於輸出到文件的Appender模式。僅支持默認的Logback設置。
logging.pattern.level=％5p ＃日誌級別的Appender模式。僅支持默認的Logback設置。
logging.register-shutdown-hook=false ＃在日誌記錄系統初始化時註冊一個關閉鉤子。
＃AOP
spring.aop.auto=真＃添加@EnableAspectJAutoProxy。
spring.aop.proxy-target-class=true ＃是否要創建基於子類的（CGLIB）代理（true），而不是基於標準Java接口的代理（false）。
#IDENTITY （ContextIdApplicationContextInitializer）
spring.application.name=#Application name.
#DINAND （SpringApplicationAdminJmxAutoConfiguration）
spring.application.admin.enabled=false ＃是否爲應用程序啓用管理功能。
spring.application.admin.jmx-name=org.springframework.boot：type = Admin，name = SpringApplication #JMX 應用程序管理員MBean的名稱。
#AUTO-CONFIGURATION
spring.autoconfigure.exclude=＃要排除的自動配置類。
＃BANNER
spring.banner.charset=UTF-8 ＃橫幅文件編碼。
spring.banner.location=classpath：banner.txt ＃橫幅文本資源位置。
spring.banner.image.location=classpath：banner.gif ＃橫幅圖像文件位置（也可以使用jpg或png）。
spring.banner.image.width=76 ＃字符中的橫幅圖像的寬度。
spring.banner.image.height=#crs 中橫幅圖像的高度（默認基於圖像高度）。
spring.banner.image.margin=2 ＃字符中的左手圖像邊距。
spring.banner.image.invert=false ＃是否應針對暗終端主題反轉圖像。
#SPRING CORE spring.beaninfo.ignore = true ＃是否跳過BeanInfo類的搜索。
#SPRING CACHE（CacheProperties）
spring.cache.cache-names=#Cmama 分隔的要創建的緩存名稱列表（如果底層緩存管理器支持）。
spring.cache.caffeine.spec=＃用於創建緩存的規範。有關規格格式的更多詳細信息，請參閱CaffeineSpec。
spring.cache.couchbase.expiration=＃條目到期。默認情況下，條目永不過期。請注意，此值最終會轉換爲秒。
spring.cache.ehcache.config=＃用於初始化EhCache的配置文件的位置。
spring.cache.infinispan.config=＃用於初始化Infinispan的配置文件的位置。
spring.cache.jcache.config=＃用於初始化緩存管理器的配置文件的位置。
spring.cache.jcache.provider=#CachingProvider實現的完全限定名稱，用於檢索符合JSR-107的緩存管理器。僅當類路徑上有多個JSR-107實現時才需要。
spring.cache.redis.cache-null-values=true ＃允許緩存空值。
spring.cache.redis.key-prefix=＃鍵前綴。
spring.cache.redis.time-to-live=＃條目到期。默認情況下，條目永不過期。
spring.cache.redis.use-key-prefix=true＃寫入Redis時是否使用密鑰前綴。
spring.cache.type=#Cache 類型。默認情況下，根據環境自動檢測。
#SPRING CONFIG  - 僅使用環境屬性（ConfigFileApplicationListener）
spring.config.additional-location=＃配置除默認值之外使用的文件位置。
spring.config.location=＃配置替換默認值的文件位置。
spring.config.name=application ＃配置文件名。
#HAZELCAST（HazelcastProperties）
spring.hazelcast.config=＃用於初始化Hazelcast的配置文件的位置。
#PROJECT INFORMATION（ProjectInfoProperties）
spring.info.build.encoding=UTF-8 ＃文件編碼。
spring.info.build.location=classpath：META-INF/build-info.properties ＃生成的build-info.properties文件的位置。
spring.info.git.encoding=UTF-8 ＃文件編碼。
spring.info.git.location=類路徑：git.properties 生成的git.properties文件＃所在。
＃JMX
spring.jmx.default域=＃JMX域名。
spring.jmx.enabled=true ＃將管理bean公開給JMX域。
spring.jmx.server=mbeanServer ＃MBeanServer bean name。
spring.jmx.unique-names=false ＃是否應確保唯一的運行時對象名稱。
#Email （MailProperties）
spring.mail.default-encoding=UTF-8 ＃默認MimeMessage編碼。
spring.mail.host=#SMTP 服務器主機。例如，`smtp.example.com`。
spring.mail.jndi-name=＃會話JNDI名稱。設置時，優先於其他會話設置。
spring.mail.password=#SMTP 服務器的登錄密碼。
spring.mail.port=#SMTP 服務器端口。
spring.mail.properties.*=＃其他JavaMail會話屬性。
spring.mail.protocol=smtp ＃SMTP服務器使用的協議。
spring.mail.test-connection=false＃是否在啓動時測試郵件服務器是否可用。
spring.mail.username=#SMTP 服務器的登錄用戶。
#APICING SETTINGS（SpringApplication）
spring.main.allow-bean-definition-overriding=false ＃是否允許通過註冊與現有定義同名的定義來覆蓋bean定義。
spring.main.banner-mode=console ＃模式用於在應用程序運行時顯示橫幅。
spring.main.sources=# 要包含在ApplicationContext中的Sources （類名，包名或XML資源位置）。
spring.main.web-application-type=＃用於顯式請求特定類型的Web應用程序的標誌。如果未設置，則基於類路徑自動檢測。
#FILE ENCODING（FileEncodingApplicationListener）
spring.mandatory-file-encoding=＃應用程序必須使用的預期字符編碼。
#INTERINGIZATION （MessageSourceProperties）
spring.messages.always-use-message-format=false ＃是否始終應用MessageFormat規則，甚至解析不帶參數的消息。
spring.messages.basename=messages ＃逗號分隔的basenames列表（本質上是一個完全限定的類路徑位置），每個都遵循ResourceBundle約定，輕鬆支持基於斜槓的位置。
spring.messages.cache-duration=＃加載的資源包文件緩存持續時間。未設置時，捆綁包將永久緩存。如果未指定持續時間後綴，則將使用秒。
spring.messages.encoding=UTF-8 ＃消息包編碼。
spring.messages.fallback-to-system-locale=true ＃如果找不到特定區域設置的文件，是否回退到系統區域設置。
spring.messages.use-code-as-default-message=false ＃是否使用消息代碼作爲默認消息而不是拋出“NoSuchMessageException”。僅在開發期間推薦。
＃OUTPUT
spring.output.ansi.enabled=檢測＃配置的ANSI輸出。
#PID FILE（ApplicationPidFileWriter）
spring.pid.fail-on-write-error=＃如果使用ApplicationPidFileWriter但它無法寫入PID文件，則失敗。
spring.pid.file=＃要寫入的PID文件的位置（如果使用ApplicationPidFileWriter）。
＃PROFILES
spring.profiles.active=＃逗號分隔的有源配置文件列表。可以通過命令行開關覆蓋。
spring.profiles.include=＃無條件地激活指定的逗號分隔的配置文件列表（如果使用YAML，則激活配置文件列表）。
＃Quartz調度器（QuartzProperties）
spring.quartz.auto-啓動=真＃是否自動啓動初始化後的調度。
spring.quartz.jdbc.comment-prefix=- #SQL 初始化腳本中單行註釋的前綴。
spring.quartz.jdbc.initialize-schema=embedded ＃數據庫模式初始化模式。
spring.quartz.jdbc.schema=classpath：org/quartz/impl/jdbcjobstore/tables_ @ @ platform @@ .sql ＃用於初始化數據庫模式的SQL文件的路徑。
spring.quartz.job-store-type=memory ＃Quartz作業存儲類型。
spring.quartz.overwrite-existing-jobs=false ＃配置的作業是否應覆蓋現有的作業定義。
spring.quartz.properties.*=＃其他Quartz Scheduler屬性。
spring.quartz.scheduler名=quartzScheduler ＃調度程序的名稱。
spring.quartz.startup-delay=0s ＃一旦初始化完成，調度程序啓動之後的延遲。
spring.quartz.wait-for-jobs-to-complete-on-shutdown=false ＃是否等待在關閉時運行的作業完成。
#REACTOR （ReactorCoreProperties）
spring.reactor.stacktrace -mode.enabled = false #Reactor 是否應該在運行時收集堆棧跟蹤信息。
#SENDGRID（SendGridAutoConfiguration）
spring.sendgrid.api-key=＃SendGrid API密鑰。
spring.sendgrid.proxy.host=＃SendGrid代理主機。
spring.sendgrid.proxy.port=＃SendGrid代理端口。
#TASK EXECUTION（TaskExecutionProperties）
spring.task.execution.pool.allow-core-thread-timeout=true ＃是否允許核心線程超時。這可以實現池的動態增長和收縮。
spring.task.execution.pool.core-size=8 ＃核心線程數。
spring.task.execution.pool.keep-alive=60s ＃終止之前線程可能保持空閒的時間限制。
spring.task.execution.pool.max-size=＃允許的最大線程數。如果任務正在填滿隊列，則池可以擴展到該大小以適應負載。如果隊列無限制，則忽略。
spring.task.execution.pool.queue-capacity=＃隊列容量。無限制的容量不會增加池，因此會忽略“max-size”屬性。
spring.task.execution.thread-name-prefix=task- ＃用於新創建的線程名稱的前綴。
#TASK SCHEDULING（TaskSchedulingProperties）
spring.task.scheduling.pool.size=1 ＃允許的最大線程數。
spring.task.scheduling.thread-name-prefix=scheduling- ＃用於新創建的線程名稱的前綴。
＃----------------------------------------
＃WEB PROPERTIES 
＃----- -----------------------------------
#EmbEDDED SERVER CONFIGURATION（ServerProperties）
server.address=＃服務器應綁定到的網絡地址。
server.compression.enabled=false ＃是否啓用了響應壓縮。
server.compression.excluded-user-agents=＃最低“Content-Length”值，用於執行壓縮。
server.connection-timeout = ＃連接器在關閉連接之前等待另一個HTTP請求的時間。未設置時，將使用連接器的特定於容器的默認值。使用值-1表示沒有（即無限）超時。
server.error.include-exception = false＃逗號分隔的用戶代理列表，不應壓縮響應。
server.compression.mime-types=text / html，text / xml，text / plain，text / css，text / javascript，application / javascript，application / json，application / xml ＃逗號分隔的MIME類型列表應該是壓縮。
server.compression.min-response-size=2KB
＃包含“exception”屬性。
server.error.include-stacktrace=never ＃何時包含“stacktrace”屬性。
server.error.path=/ error ＃錯誤控制器的路徑。
server.error.whitelabel.enabled=true＃是否在服務器出錯時啓用瀏覽器中顯示的默認錯誤頁面。
server.http2.enabled=false ＃是否啓用HTTP / 2支持，如果當前環境支持它。
server.jetty.acceptors=-1 ＃要使用的接受者線程數。當值爲-1（默認值）時，接受器的數量是從操作環境派生的。
server.jetty.accesslog.append=false ＃追加到日誌。
server.jetty.accesslog.date-format=dd / MMM / yyyy：HH：mm：ss Z ＃請求日誌的時間戳格式。
server.jetty.accesslog.enabled=false ＃啓用訪問日誌。
server.jetty.accesslog.extended-format=false＃啓用擴展NCSA格式。
server.jetty.accesslog.file-date-format=＃日期文件名中的日期格式。
server.jetty.accesslog.filename=＃日誌文件名。如果未指定，則日誌重定向到“System.err”。
server.jetty.accesslog.locale=＃請求日誌的區域設置。
server.jetty.accesslog.log-cookies=false ＃啓用請求cookie的記錄。
server.jetty.accesslog.log-latency=false ＃啓用請求處理時間的記錄。
server.jetty.accesslog.log-server=false ＃啓用請求主機名的日誌記錄。
server.jetty.accesslog.retention-period=31＃刪除旋轉日誌文件之前的天數。
server.jetty.accesslog.time-zone=GMT ＃請求日誌的時區。
server.jetty.max-http-post-size=200000B #HTTP post或put內容的最大大小。
server.jetty.selectors=-1 ＃要使用的選擇器線程數。當值爲-1（默認值）時，選擇器的數量是從操作環境派生的。
server.max-http-header-size=8KB #HTTP 郵件頭的最大大小。
server.port=8080 ＃服務器HTTP端口。
server.server-header=＃用於Server響應頭的值（如果爲空，則不發送頭）。
server.use-forward-headers=＃是否應將X-Forwarded- *標頭應用於HttpRequest。
server.servlet.context-parameters.*=＃Servlet context init參數。
server.servlet.context-path=＃應用程序的上下文路徑。
server.servlet.application-display-name=application ＃顯示應用程序的名稱。
server.servlet.jsp.class-name=org.apache.jasper.servlet.JspServlet ＃用於JSP的servlet的類名。
server.servlet.jsp.init-parameters.*=＃用於配置JSP servlet的Init參數。
server.servlet.jsp.registered=true＃是否已註冊JSP servlet。
server.servlet.session.cookie.comment=＃會話cookie的評論。
server.servlet.session.cookie.domain=＃會話cookie的域名。
server.servlet.session.cookie.http-only=＃是否對會話cookie使用“HttpOnly”cookie。
server.servlet.session.cookie.max-age=＃會話cookie的最大年齡。如果未指定持續時間後綴，則將使用秒。
server.servlet.session.cookie.name=＃會話cookie名稱。
server.servlet.session.cookie.path=＃會話cookie的路徑。
server.servlet.session.cookie.secure=＃是否始終將會話cookie標記爲安全。
server.servlet.session.persistent=false ＃是否在重新啓動之間保留會話數據。
server.servlet.session.store-dir=＃用於存儲會話數據的目錄。
server.servlet.session.timeout=30m ＃會話超時。如果未指定持續時間後綴，則將使用秒。
server.servlet.session.tracking-modes=＃會話跟蹤模式。
server.ssl.ciphers=＃支持的SSL密碼。
server.ssl.client-auth=＃客戶端身份驗證模式。
server.ssl.enabled=true ＃是否啓用SSL支持。
server.ssl.enabled-protocols=＃啓用SSL協議。
server.ssl.key-alias=＃標識密鑰庫中密鑰的別名。
server.ssl.key-password=＃用於訪問密鑰庫中密鑰的密碼。
server.ssl.key-store=＃保存SSL證書的密鑰庫的路徑（通常是jks文件）。
server.ssl.key-store-password=＃用於訪問密鑰庫的密碼。
server.ssl.key-store-provider=＃密鑰庫的提供者。
server.ssl.key-store-type=＃密鑰庫的類型。
server.ssl.trust-store=＃持有SSL證書的信任存儲。
server.ssl.trust-store-password=#訪問trust store的密碼.店密碼
server.ssl.protocol = TLS ＃要使用的SSL協議。
server.ssl.trust-store-provider=＃信任存儲的提供者。
server.ssl.trust-store-type=＃信任庫的類型。
server.tomcat.accept-count=100 ＃當所有可能的請求處理線程都在使用時，傳入連接請求的最大隊列長度。
server.tomcat.accesslog.buffered=true＃是否緩衝輸出，使其僅定期刷新。
server.tomcat.accesslog.directory=logs＃創建日誌文件的目錄。可以絕對或相對於Tomcat基礎目錄。
server.tomcat.accesslog.enabled=false ＃啓用訪問日誌。
server.tomcat.accesslog.file-date-format=.yyyy-MM-dd ＃要放在日誌文件名中的日期格式。
server.tomcat.accesslog.request-attributes-enabled=false ＃是否延遲在文件名中包含日期戳，直到旋轉時間。
server.tomcat.accesslog.pattern = common ＃訪問日誌的格式模式。
server.tomcat.accesslog.prefix=access_log ＃日誌文件名前綴。
server.tomcat.accesslog.rename-on-rotate=false ＃設置用於請求的IP地址，主機名，協議和端口的請求屬性。
server.tomcat.accesslog.rotate = true ＃是否啓用訪問日誌輪換。
server.tomcat.accesslog.suffix = .log ＃日誌文件名後綴。
server.tomcat.additional-tld-skip-patterns = ＃逗號分隔的其他模式列表，這些模式匹配要忽略的TLD掃描的jar。
server.tomcat.background-processor-delay = 10s #方法調用之間的延遲。如果未指定持續時間後綴，則將使用秒。
server.tomcat.basedir=#Tomcat 基目錄。如果未指定，則使用臨時目錄。
server.tomcat.internal-proxies=10 \\。\\ d {1,3} \\。\\ d {1,3} \\。\\ d {1,3} | \\
。192 \\ 168 \\ d {1,3} \\ d {1,3} | \\
。169 \\ 254 \\ d {1,3} \\ d {1,3} | \\
。127 \\ d {1,3} \\ d {1,3} \\ d {1,3} | \\
172 \\ 1 [6-9] {1} \\ d {1,3} \\ d {1,3} |。。\\
172 \\ 2 [0-9] {1} \\ d {1,3} \\ d {1,3} |。。\\
172 \\。3 [0-1] {1} \\。\\ d {1,3} \\。\\ d {1,3} \\
0：0：0：0：0：0：0：1 \\
::1 ＃正則表達式匹配要信任的代理。
server.tomcat.max-connections=10000 ＃服務器在任何給定時間接受和處理的最大連接數。
server.tomcat.max-http-post-size=2MB #HTTP 帖子內容的最大大小。
server.tomcat.max-swallow-size=2MB ＃要吞嚥的請求正文的最大數量。
server.tomcat.max-threads=200 ＃最大工作線程數。
server.tomcat.min-spare-threads=10 ＃最小工作線程數。
server.tomcat.port頭=X-Forwarded-Port＃用於覆蓋原始端口值的HTTP頭的名稱。
server.tomcat.protocol-header=＃包含傳入協議的頭文件，通常命名爲“X-Forwarded-Proto”。
server.tomcat.protocol-header-https-value=https ＃協議標頭的值，指示傳入請求是否使用SSL。
server.tomcat.redirect-context-root=true ＃是否應通過在路徑中附加/來重定向對上下文根的請求。
server.tomcat.remote-ip-header=＃從中提取遠程IP的HTTP頭的名稱。例如，`X-FORWARDED-FOR`。
server.tomcat.resource.allow緩存=true＃是否允許此Web應用程序使用靜態資源緩存。
server.tomcat.resource.cache-ttl=＃靜態資源緩存的生存時間。
server.tomcat.uri-encoding=UTF-8 ＃用於解碼URI的字符編碼。
server.tomcat.use-relative-redirects=＃通過調用sendRedirect生成的HTTP 1.1和更高版本的位置標頭是使用相對還是絕對重定向。
server.undertow.accesslog.dir=#Undertow 訪問日誌目錄。
server.undertow.accesslog.enabled=false ＃是否啓用訪問日誌。
server.undertow.accesslog.pattern=common ＃訪問日誌的格式模式。
server.undertow.accesslog.prefix=access_log。＃日誌文件名前綴。
server.undertow.accesslog.rotate=true ＃是否啓用訪問日誌輪換。
server.undertow.accesslog.suffix=log ＃日誌文件名後綴。
server.undertow.buffer-size=＃每個緩衝區的大小。
server.undertow.direct-buffers=＃是否在Java堆外部分配緩衝區。默認值源自JVM可用的最大內存量。
server.undertow.eager-filter-init=true ＃是否應在啓動時初始化servlet過濾器。
server.undertow.io線程=＃爲worker創建的I / O線程數。默認值源自可用處理器的數量。
server.undertow.max-http-post-size=-1B #HTTP 帖子內容的最大大小。當值爲-1時，默認值爲大小無限制。
server.undertow.worker-threads=＃工作線程數。默認值是I / O線程數的8倍。
#FREEMARKER（FreeMarkerProperties）
spring.freemarker.allow-request-override=false ＃是否允許HttpServletRequest屬性覆蓋（隱藏）控制器生成的同名模型屬性。
spring.freemarker.allow-session-override=false ＃是否允許HttpSession屬性覆蓋（隱藏）控制器生成的同名模型屬性。
spring.freemarker.cache=false ＃是否啓用模板緩存。
spring.freemarker.charset=UTF-8 ＃模板編碼。
spring.freemarker.check-template-location=true ＃是否檢查模板位置是否存在。
spring.freemarker.content-type=text / html ＃Content-Type value。
spring.freemarker.enabled=true ＃是否爲此技術啓用MVC視圖分辨率。
spring.freemarker.expose-request-attributes=false ＃是否應在與模板合併之前將所有請求屬性添加到模型中。
spring.freemarker.expose-session-attributes=false ＃是否應在與模板合併之前將所有HttpSession屬性添加到模型中。
spring.freemarker.expose-彈簧宏觀傭工=真＃是否公開的名稱爲“springMacroRequestContext”下通過Spring的宏庫使用的RequestContext。
spring.freemarker.prefer-file-system-access=true ＃是否更喜歡文件系統訪問以進行模板加載。文件系統訪問可以熱檢測模板更改。
spring.freemarker.prefix=＃在構建URL時添加前綴以查看名稱的前綴。
spring.freemarker.request-context-attribute=＃所有視圖的
RequestContext屬性的名稱。spring.freemarker.settings。*=＃衆所周知的FreeMarker密鑰，傳遞給FreeMarker的配置。
spring.freemarker.suffix=.ftl ＃在構建URL時附加到視圖名稱的後綴。
spring.freemarker.template-loader-path=classpath：/ templates /＃逗號分隔的模板路徑列表。
spring.freemarker.view-names=＃可以解析的視圖名稱的白名單。
#GLOVY TEMPLATES（GroovyTemplateProperties）
spring.groovy.template.allow-request-override=false ＃是否允許HttpServletRequest屬性覆蓋（隱藏）控制器生成的同名模型屬性。
spring.groovy.template.allow-session-override=false ＃是否允許HttpSession屬性覆蓋（隱藏）控制器生成的同名模型屬性。
spring.groovy.template.cache=false ＃是否啓用模板緩存。
spring.groovy.template.charset=UTF-8 ＃模板編碼。
spring.groovy.template.check-template-location=true＃是否檢查模板位置是否存在。
spring.groovy.template.configuration。*=＃請參閱GroovyMarkupConfigurer 
spring.groovy.template.content-type=text / html ＃Content-Type value。
spring.groovy.template.enabled=true ＃是否爲此技術啓用MVC視圖分辨率。
spring.groovy.template.expose-request-attributes=false ＃是否應在與模板合併之前將所有請求屬性添加到模型中。
spring.groovy.template.expose-session-attributes=false ＃在與模板合併之前是否應將所有HttpSession屬性添加到模型中。
spring.groovy.template.expose-spring-macro-helpers=true＃是否公開一個RequestContext供Spring的宏庫使用，名稱爲“springMacroRequestContext”。
spring.groovy.template.prefix=＃在構建URL時添加前綴以查看名稱的前綴。
spring.groovy.template.request-context-attribute=＃所有視圖的RequestContext屬性的名稱。
spring.groovy.template.resource-loader-path=classpath：/ templates / ＃Template path。
spring.groovy.template.suffix=.tpl ＃在構建URL時附加到視圖名稱的後綴。
spring.groovy.template.view-names=＃可以解析的視圖名稱的白名單。
#SPRING HATEOAS（HateoasProperties）
spring.hateoas.use-hal-as-default-json-media-type=true ＃是否應將application / hal + json響應發送給接受application / json的請求。
#HTTP （HttpProperties）
spring.http.converters.preferred-json-mapper=＃用於HTTP消息轉換的首選JSON映射器。默認情況下，根據環境自動檢測。
spring.http.encoding.charset=UTF-8 #HTTP 請求和響應的字符集。如果未明確設置，則添加到“Content-Type”標頭。
spring.http.encoding.enabled=true ＃是否啓用http編碼支持。
spring.http.encoding.force=＃是否在HTTP請求和響應上強制編碼到已配置的字符集。
spring.http.encoding.force-request=＃是否在HTTP請求中強制編碼到配置的字符集。如果未指定“force”，則默認爲true。
spring.http.encoding.force-response=＃是否在HTTP響應中強制編碼到配置的字符集。
spring.http.encoding.mapping=＃用於編碼映射的Locale。
spring.http.log-request-details=false ＃是否允許在DEBUG和TRACE級別記錄（可能敏感的）請求詳細信息。
#MULTIPART （MultipartProperties）
spring.servlet.multipart.enabled=true ＃是否啓用分段上傳支持。
spring.servlet.multipart.file-size-threshold=0B ＃將文件寫入磁盤後的閾值。
spring.servlet.multipart.location=＃上傳文件的中間位置。
spring.servlet.multipart.max-file-size=1MB ＃最大文件大小。
spring.servlet.multipart.max-request-size=10MB ＃最大請求大小。
spring.servlet.multipart.resolve-lazily=false ＃是否在文件或參數訪問時懶惰地解析多部分請求。
#JACKSON （JacksonProperties）
spring.jackson.date-format=＃日期格式字符串或完全限定的日期格式類名。例如，`yyyy-MM-dd HH：mm：ss`。
spring.jackson.default-property-inclusion=＃控制序列化期間包含的屬性。配置了Jackson的JsonInclude.Include枚舉中的一個值。
spring.jackson.deserialization.*=#Jackson on / off功能會影響Java對象的反序列化方式。
spring.jackson.generator.*=＃Jackson開/關功能的發電機。
spring.jackson.joda-date-time-format=#Joda日期時間格式字符串。如果未配置，如果使用格式字符串配置，則使用“date-format”作爲後備。
spring.jackson.locale=＃用於格式化的區域設置。
spring.jackson.mapper.*=#Jackson 通用開/關功能。
spring.jackson.parser.*=＃Jackson開啓/關閉解析器的功能。
spring.jackson.property-naming-strategy=#Jackson PropertyNamingStrategy的常數之一。也可以是PropertyNamingStrategy子類的完全限定類名。
spring.jackson.serialization.*=#Jacker on / off功能會影響Java對象的序列化方式。
spring.jackson.time-zone=＃格式化日期時使用的時區。例如，“America / Los_Angeles”或“GMT + 10”。
spring.jackson.visibility.*=#Jackson 可見性閾值，可用於限制自動檢測哪些方法（和字段）。
#GSON（GsonProperties）
spring.gson.date-format=＃序列化Date對象時使用的格式。
spring.gson.disable -html-escaping = ＃是否禁用HTML字符的轉義，例如'<'，'>'等
spring.gson.disable-inner-class-serialization=＃是否在內容類中排除內部類序列化。
spring.gson.enable-complex-map-key-serialization=＃是否啓用複雜映射鍵（即非基元）的序列化。
spring.gson.exclude-fields-without-expose-annotation=＃是否排除所有不考慮序列化或反序列化但沒有“Expose”註釋的字段。
spring.gson.field-naming-policy=＃在序列化和反序列化期間應該應用於對象字段的命名策略。
spring.gson.generate-non-executable-json=＃是否通過在輸出前添加一些特殊文本來生成不可執行的JSON。
spring.gson.lenient=＃是否寬容解析不符合RFC 4627的
JSON.chring.gson.long-serialization-policy=＃長和長類型的序列化策略。
spring.gson.pretty-printing=＃是否輸出適合頁面的序列化JSON以進行漂亮的打印。
spring.gson.serialize-nulls=＃是否序列化空字段。
#JERSEY （JerseyProperties）
spring.jersey.application-path=＃作爲應用程序基URI的路徑。如果指定，則覆蓋“@ApplicationPath”的值。
spring.jersey.filter.order=0 ＃Jersey過濾鏈順序。
spring.jersey.init.*=＃通過servlet或過濾器傳遞給Jersey的Init參數。
spring.jersey.servlet.load-on-startup=-1 ＃加載Jersey servlet的啓動優先級。
spring.jersey.type=servlet ＃Jersey集成類型。
#SPRING LDAP（LdapProperties）
spring.ldap.anonymous-read-only=false ＃只讀操作是否應使用匿名環境。
spring.ldap.base=#Base 後綴，所有操作都應該來自該後綴。
spring.ldap.base-environment.*=#LDAP 規範設置。
spring.ldap.password=＃服務器的登錄密碼。
spring.ldap.urls=＃服務器的LDAP URL。
spring.ldap.username=＃登錄服務器的用戶名。
＃EMBEDDED LDAP（EmbeddedLdapProperties）
spring.ldap.embedded.base-dn=＃基本DN列表。
spring.ldap.embedded.credential.username=＃嵌入式LDAP用戶名。
spring.ldap.embedded.credential.password=＃嵌入式LDAP密碼。
spring.ldap.embedded.ldif=classpath：schema.ldif #Schema （LDIF）腳本資源引用。
spring.ldap.embedded.port=0 ＃嵌入式LDAP端口。
spring.ldap.embedded.validation.enabled=true ＃是否啓用LDAP模式驗證。
spring.ldap.embedded.validation.schema=＃自定義架構的路徑。
#MUSTACHE TEMPLATES（MustacheAutoConfiguration）
spring.mustache.allow-request-override=false ＃是否允許HttpServletRequest屬性覆蓋（隱藏）控制器生成的同名模型屬性。
spring.mustache.allow-session-override=false ＃是否允許HttpSession屬性覆蓋（隱藏）控制器生成的同名模型屬性。
spring.mustache.cache=false ＃是否啓用模板緩存。
spring.mustache.charset=UTF-8 ＃模板編碼。
spring.mustache.check-template-location=true ＃是否檢查模板位置是否存在。
spring.mustache.content-type=text / html ＃Content-Type value。
spring.mustache.enabled=true ＃是否爲此技術啓用MVC視圖分辨率。
spring.mustache.expose-request-attributes=false ＃在與模板合併之前是否應將所有請求屬性添加到模型中。
spring.mustache.expose-session-attributes=false ＃在與模板合併之前是否應將所有HttpSession屬性添加到模型中。
spring.mustache.expose-spring-macro-helpers=true ＃是否公開一個RequestContext供Spring的宏庫使用，名稱爲“springMacroRequestContext”。
spring.mustache.prefix=classpath：/ templates / ＃適用於模板名稱的前綴。
spring.mustache.request-context-attribute=＃所有視圖的
RequestContext屬性的名稱。spring.mustache.suffix=.mustache ＃後綴應用於模板名稱。
spring.mustache.view-names=＃可以解析的視圖名稱的白名單。
#SPRING MVC（WebMvcProperties）
spring.mvc.async.request-timeout=＃異步請求處理
超時之前的時間。spring.mvc.contentnegotiation.favor-parameter=false ＃是否應使用請求參數（默認爲“format”）來確定請求的媒體類型。
spring.mvc.contentnegotiation.favor-path-extension=false ＃是否應使用URL路徑中的路徑擴展來確定請求的媒體類型。
spring.mvc.contentnegotiation.media-types。*=＃映射內容協商的媒體類型的文件擴展名。例如，yml到text / yaml。
spring.mvc.contentnegotiation.parameter-name=＃啓用“favor-parameter”時要使用的查詢參數名稱。
spring.mvc.date-format=＃要使用的日期格式。例如，`dd / MM / yyyy`。
spring.mvc.dispatch-trace-request=false ＃是否將TRACE請求分派給FrameworkServlet doService方法。
spring.mvc.dispatch-options-request=true ＃是否將OPTIONS請求分派給FrameworkServlet doService方法。
spring.mvc.favicon.enabled=true ＃是否啓用favicon.ico的解析。
spring.mvc.formcontent.filter.enabled=true ＃是否啓用Spring的FormContentFilter。
spring.mvc.hiddenmethod.filter.enabled=true＃是否啓用Spring的HiddenHttpMethodFilter。
spring.mvc.ignore-default-model-on-redirect=true ＃在重定向場景中是否應忽略“默認”模型的內容。
spring.mvc.locale=＃要使用的語言環境。默認情況下，“Accept-Language”標頭會覆蓋此區域設置。
spring.mvc.locale-resolver=accept-header ＃定義應如何解析語言環境。
spring.mvc.log-resolved-exception=false ＃是否啓用由“HandlerExceptionResolver”解析的異常的警告日誌記錄，“DefaultHandlerExceptionResolver”除外。
spring.mvc.message-codes-resolver-format=＃格式化消息代碼的策略。例如，`PREFIX_ERROR_CODE`。
spring.mvc.pathmatch.use-registered-suffix-pattern=false ＃後綴模式匹配是否僅適用於使用“spring.mvc.contentnegotiation.media-types。*”註冊的擴展。
spring.mvc.pathmatch.use-suffix-pattern=false ＃將模式與請求匹配時是否使用後綴模式匹配（“。*”）。
spring.mvc.servlet.load-on-startup=-1 ＃加載調度程序servlet的啓動優先級。
spring.mvc.servlet.path=/ ＃調度程序servlet的路徑。
spring.mvc.static-path-pattern=/ ** ＃用於靜態資源的路徑模式。
spring.mvc.throw-exception-if-no-handler-found=false ＃如果沒有找到Handler來處理請求，是否應該拋出“NoHandlerFoundException”。
spring.mvc.view.prefix=#Spring MVC視圖前綴。
spring.mvc.view.suffix=#Spring MVC視圖後綴。
#SPRING RESOURCES HANDLING（ResourceProperties）
spring.resources.add-mappings=true ＃是否啓用默認資源處理。
spring.resources.cache.cachecontrol.cache-private=＃表示響應消息僅供單個用戶使用，不得由共享高速緩存存儲。
spring.resources.cache.cachecontrol.cache-public=＃表示任何緩存都可以存儲響應。
spring.resources.cache.cachecontrol.max-age=＃應該緩存響應的最長時間，如果未指定持續時間後綴，則以秒爲單位。
spring.resources.cache.cachecontrol.must-revalidate=＃表示一旦它變得陳舊，緩存一定不能使用響應而不用服務器重新驗證它。
spring.resources.cache.cachecontrol.no-cache=＃表示只有在與服務器重新驗證時才能重用緩存的響應。
spring.resources.cache.cachecontrol.no-store=＃表示在任何情況下都不緩存響應。
spring.resources.cache.cachecontrol.no-transform=＃表明他們不應該轉換響應內容的中介（緩存和其他人）。
spring.resources.cache.cachecontrol.proxy-revalidate=＃與“must-revalidate”指令的含義相同，但它不適用於私有緩存。
spring.resources.cache.cachecontrol.s-max-age=＃共享緩存應緩存響應的最長時間，如果未指定持續時間後綴，則以秒爲單位。
spring.resources.cache.cachecontrol.stale-if-error=＃遇到錯誤時可以使用響應的最長時間，如果未指定持續時間後綴，則以秒爲單位。
spring.resources.cache.cachecontrol.stale-while-revalidate=＃響應變爲失效後可以響應的最長時間，如果未指定持續時間後綴，則以秒爲單位。
spring.resources.cache.period=＃資源處理程序所服務資源的緩存週期。如果未指定持續時間後綴，則將使用秒。
spring.resources.chain.cache=true ＃是否在資源鏈中啓用緩存。
spring.resources.chain.compressed=false ＃是否啓用已壓縮資源的解析（gzip，brotli）。
spring.resources.chain.enabled=＃是否啓用Spring資源處理鏈。默認情況下，禁用，除非至少啓用了一個策略。
spring.resources.chain.html-application-cache=false ＃是否啓用HTML5應用程序緩存清單重寫。
spring.resources.chain.strategy.content.enabled=false ＃是否啓用內容版本策略。
spring.resources.chain.strategy.content.paths=/ **＃逗號分隔的模式列表，應用於內容版本策略。
spring.resources.chain.strategy.fixed.enabled=false ＃是否啓用固定版本策略。
spring.resources.chain.strategy.fixed.paths=/ ** ＃以逗號分隔的模式列表應用於固定版本策略。
spring.resources.chain.strategy.fixed.version=＃用於固定版本策略的版本字符串。
spring.resources.static-locations=classpath：/ META-INF / resources /，classpath：/ resources /，classpath：/ static /，classpath：/ public / ＃靜態資源的位置。
#SPRING SESSION（SessionProperties）
spring.session.store-type=＃會話存儲類型。
spring.session.timeout=＃會話超時。如果未指定持續時間後綴，則將使用秒。
spring.session.servlet.filter-order=-2147483598 ＃會話存儲庫過濾順序。
spring.session.servlet.filter-dispatcher-types=async，error，request ＃會話存儲庫過濾器調度程序類型。
#SPRING SESSION HAZELCAST（HazelcastSessionProperties）
spring.session.hazelcast.flush-mode=on-save #sessions flush mode。
spring.session.hazelcast.map-name=spring：session：sessions ＃用於存儲會話的地圖的名稱。
#SPRING SESSION JDBC（JdbcSessionProperties）
spring.session.jdbc.cleanup-cron=0 * * * * * #cron 表達式用於過期的會話清理作業。
spring.session.jdbc.initialize-schema=embedded ＃數據庫模式初始化模式。
spring.session.jdbc.schema=classpath中：組織/ springframework的/會話/ JDBC / schema- @ @ 平臺@ @ .SQL ＃的路徑SQL文件，以用於初始化數據庫架構。
spring.session.jdbc.table-name=SPRING_SESSION ＃用於存儲會話的數據庫表的名稱。
#SPRING SESSION MONGODB（MongoSessionProperties）
spring.session.mongodb.collection-name=sessions ＃用於存儲會話的集合名稱。
#SPRING SESSION REDIS（RedisSessionProperties）
spring.session.redis.cleanup-cron=0 * * * * * #cron 表達式用於過期的會話清理作業。
spring.session.redis.flush-mode=on-save #sessions flush mode。
spring.session.redis.namespace=spring：session ＃用於存儲會話的密鑰的命名空間。
#THYMELEAF（ThymeleafAutoConfiguration）
spring.thymeleaf.cache=true ＃是否啓用模板緩存。
spring.thymeleaf.check-template=true ＃是否在呈現模板之前檢查模板是否存在。
spring.thymeleaf.check-template-location=true ＃是否檢查模板位置是否存在。
spring.thymeleaf.enabled=true ＃是否爲Web框架啓用Thymeleaf視圖解析。
spring.thymeleaf.enable-spring-el-compiler=false ＃在SpringEL表達式中啓用SpringEL編譯器。
spring.thymeleaf.encoding=UTF-8 ＃模板文件編碼。
spring.thymeleaf.excluded-view-names=＃逗號分隔的視圖名稱列表（允許的模式）應從分辨率中排除。
spring.thymeleaf.mode=HTML ＃要應用於模板的模板模式。另請參見Thymeleaf的TemplateMode枚舉。
spring.thymeleaf.prefix=classpath：/ templates / ＃在構建URL時添加前綴以查看名稱的前綴。
spring.thymeleaf.reactive.chunked-mode-view-names=＃逗號分隔的視圖名稱列表（允許的模式），當設置了最大塊大小時，它應該是在CHUNKED模式下執行的唯一列表。
spring.thymeleaf.reactive.full-mode-view-names=＃逗號分隔的視圖名稱列表（允許的模式），即使設置了最大塊大小，也應該在FULL模式下執行。
spring.thymeleaf.reactive.max-chunk-size=0B ＃用於寫入響應的數據緩衝區的最大大小。
spring.thymeleaf.reactive.media-types=＃視圖技術支持的媒體類型。
spring.thymeleaf.render-hidden-markers-before-checkboxes=false ＃是否應在複選框元素本身之前呈現隱藏的表單輸入作爲複選框的標記。
spring.thymeleaf.servlet.content-type=text / html ＃Content-Type寫入HTTP響應的值。
spring.thymeleaf.servlet.produce-partial-output-while-processing=true#Thymeleaf是否應儘快開始編寫部分輸出或緩衝直到模板處理完成。
spring.thymeleaf.suffix=.html ＃在構建URL時附加到視圖名稱的後綴。
spring.thymeleaf.template-resolver-order=＃鏈中模板解析器的順序。
spring.thymeleaf.view-names=＃逗號分隔的視圖名稱列表（允許的模式），可以解析。
#SPRING WEBFLUX（WebFluxProperties）
spring.webflux.date-format=＃要使用的日期格式。例如，`dd / MM / yyyy`。
spring.webflux.hiddenmethod.filter.enabled=true ＃是否啓用Spring的HiddenHttpMethodFilter。
spring.webflux.static-path-pattern=/ ** ＃用於靜態資源的路徑模式。
#SPRING WEB SERVICES（WebServicesProperties）
spring.webservices.path=/ services ＃作爲服務基URI的路徑。
spring.webservices.servlet.init=＃Servlet init參數傳遞給Spring Web Services。
spring.webservices.servlet.load-on-startup=-1 ＃加載Spring Web Services servlet的啓動優先級。
spring.webservices.wsdl-locations=＃逗號分隔的WSDL位置列表以及要作爲bean公開的隨附XSD。
＃----------------------------------------
＃SECURITY PROPERTIES 
＃----- ----------------------------------- 
＃SECURITY（SecurityProperties）
spring.security.filter.order=-100 ＃安全過濾器鏈順序。
spring.security.filter.dispatcher-types=async，error，request ＃安全過濾器鏈調度程序類型。
spring.security.user.name=user ＃默認用戶名。
spring.security.user.password=＃默認用戶名的密碼。
spring.security.user.roles=＃授予默認用戶名的角色。
＃SECURITY OAUTH2 CLIENT（OAuth2ClientProperties）
spring.security.oauth2.client.provider。*=＃OAuth提供商詳細信息。
spring.security.oauth2.client.registration。*=＃OAuth客戶註冊。
＃SECURITY OAUTH2 RESOURCE SERVER（OAuth2ResourceServerProperties）
spring.security.oauth2.resourceserver.jwt.jwk-set-uri=＃JSON用於驗證JWT令牌的Web Key URI。
spring.security.oauth2.resourceserver.jwt.issuer-uri=OpenID Connect Provider聲明爲其頒發者標識符的URI。
＃----------------------------------------
＃DATA PROPERTIES 
＃----- -----------------------------------
#FLYWAY （FlywayProperties）
spring.flyway.baseline-description=<< Flyway Baseline >> ＃描述在應用基線時標記現有模式。
spring.flyway.baseline-on-migrate=false ＃是否在遷移非空架構時自動調用基線。
spring.flyway.baseline-version=1 ＃用於在執行基線時標記現有模式的版本。
spring.flyway.check-location=true ＃是否檢查遷移腳本位置是否存在。
spring.flyway.clean-disabled=false ＃是否禁用數據庫清理。
spring.flyway.clean-on-validation-error=false＃發生驗證錯誤時是否自動調用clean。
spring.flyway.connect-retries=0 ＃嘗試連接數據庫時的最大重試次數。
spring.flyway.enabled=true ＃是否啓用flyway。
spring.flyway.encoding=UTF-8 #SQL 遷移的編碼。
spring.flyway.group=false ＃是否在應用它們時在同一事務中將所有掛起的遷移組合在一起。
spring.flyway.ignore-future-migrations=true ＃在讀取架構歷史記錄表時是否忽略未來的遷移。
spring.flyway.ignore-ignored-migrations=false＃是否在讀取模式歷史記錄表時忽略忽略的遷移。
spring.flyway.ignore-missing-migrations=false ＃在讀取模式歷史記錄表時是否忽略缺少的遷移。
spring.flyway.ignore-pending-migrations=false ＃在讀取架構歷史記錄表時是否忽略掛起的遷移。
spring.flyway.init-sqls=＃在獲取連接後立即執行以初始化連接的SQL語句。
spring.flyway.installed-by=＃用戶名在架構歷史記錄表中記錄爲已應用遷移。
spring.flyway.locations=classpath：db / migration＃遷移腳本的位置。可以包含特殊的“{vendor}”佔位符以使用特定於供應商的位置。
spring.flyway.mixed=false ＃是否允許在同一遷移中混合事務和非事務語句。
spring.flyway.out-of-order=false ＃是否允許遷移無序運行。
spring.flyway.password=＃要遷移的數據庫的登錄密碼。
spring.flyway.placeholder-prefix=$ { ＃遷移腳本中佔位符的前綴。
spring.flyway.placeholder-replacement=true ＃在遷移腳本中執行佔位符替換。
spring.flyway.placeholder-suffix=}＃遷移腳本中佔位符的後綴。
spring.flyway.placeholders=＃佔位符及其替換應用於sql遷移腳本。
spring.flyway.repeatable-sql-migration-prefix=R ＃可重複SQL遷移的文件名前綴。
spring.flyway.schemas=＃由Flyway 管理的方案名稱（區分大小寫）。
spring.flyway.skip-default-callbacks = false ＃是否跳過默認回調。如果爲true，則僅使用自定義回調。
spring.flyway.skip-default-resolvers=false ＃是否跳過默認的解析器。如果爲true，則僅使用自定義解析程序。
spring.flyway.sql-migration-prefix=V.#SQL遷移的文件名前綴。
spring.flyway.sql-migration-separator=__ #SQL遷移的文件名分隔符。
spring.flyway.sql-migration-suffixes=.sql #SQL遷移的文件名後綴。
spring.flyway.table=flyway_schema_history ＃將由 Flyway 使用的架構架構歷史記錄表的名稱。
spring.flyway.target = ＃應考慮遷移的目標版本。
spring.flyway.url=要遷移的數據庫的JDBC url。如果未設置，則使用主要配置的數據源。
spring.flyway.user=＃要遷移的數據庫的登錄用戶。
spring.flyway.validate-on-migrate=true ＃是否在執行遷移時自動調用validate。
#LIQUIBASE（LiquibaseProperties）
spring.liquibase.change-log=classpath：/db/changelog/db.changelog-master.yaml# 更改日誌配置路徑。
spring.liquibase.check-change-log-location=true ＃是否檢查更改日誌位置是否存在。
spring.liquibase.contexts=＃逗號分隔的運行時上下文列表。
spring.liquibase.database-change-log-lock-table=DATABASECHANGELOGLOCK ＃用於跟蹤併發Liquibase用法的表的名稱。
spring.liquibase.database-change-log-table=DATABASECHANGELOG ＃用於跟蹤更改歷史記錄的表的名稱。
spring.liquibase.default-模式=＃默認數據庫架構。
spring.liquibase.drop-first=false ＃是否首先刪除數據庫模式。
spring.liquibase.enabled=true ＃是否啓用Liquibase支持。
spring.liquibase.labels=＃逗號分隔的運行時標籤列表。
spring.liquibase.liquibase-schema=#Schema用於Liquibase對象。
spring.liquibase.liquibase-tablespace=＃用於Liquibase對象的表空間。
spring.liquibase.parameters.*=＃更改日誌參數。
spring.liquibase.password=＃要遷移的數據庫的登錄密碼。
spring.liquibase.rollback-file=＃執行更新時寫入回滾SQL的文件。
spring.liquibase.test-rollback-on-update=false ＃是否應在執行更新之前測試回滾。
spring.liquibase.url=＃JDBC要遷移的數據庫的URL。如果未設置，則使用主要配置的數據源。
spring.liquibase.user=＃要遷移的數據庫的登錄用戶。
＃COUCHBASE（CouchbaseProperties）
spring.couchbase.bootstrap-hosts=#Couchbase 節點（主機或IP地址）來自引導程序。
spring.couchbase.bucket.name=default ＃要連接的存儲桶的名稱。
spring.couchbase.bucket.password=＃桶的密碼。
spring.couchbase.env.endpoints.key-value=1 ＃針對鍵/值服務的每個節點的套接字數。
spring.couchbase.env.endpoints.queryservice.min-endpoints=1 ＃每個節點的最小套接字數。
spring.couchbase.env.endpoints.queryservice.max-endpoints=1 ＃每個節點的最大套接字數。
spring.couchbase.env.endpoints.viewservice.min-endpoints=1 ＃每個節點的最小套接字數。
spring.couchbase.env.endpoints.viewservice.max-endpoints=1 ＃每個節點的最大套接字數。
spring.couchbase.env.ssl.enabled=＃是否啓用SSL支持。除非另有說明，否則在提供“keyStore”時自動啓用。
spring.couchbase.env.ssl.key-store=＃保存證書的JVM密鑰庫的路徑。
spring.couchbase.env.ssl.key-store-password=＃用於訪問密鑰庫的密碼。
spring.couchbase.env.timeouts.connect=5000ms ＃桶連接超時。
spring.couchbase.env.timeouts.key-value=2500ms ＃對特定密鑰超時執行的阻止操作。
spring.couchbase.env.timeouts.query=7500ms ＃N1QL查詢操作超時。
spring.couchbase.env.timeouts.socket-connect=1000ms #Socket 連接超時。
spring.couchbase.env.timeouts.view=7500ms ＃常規和地理空間視圖操作超時。
#DAO （PersistenceExceptionTranslationAutoConfiguration）
spring.dao.exceptiontranslation.enabled=true ＃是否啓用PersistenceExceptionTranslationPostProcessor。
#CASSANDRA （CassandraProperties）
spring.data.cassandra.cluster-name=#Cassandra 集羣的名稱。
spring.data.cassandra.compression=none ＃Cassandra二進制協議支持的壓縮。
spring.data.cassandra.connect-timeout=#Socket 選項：連接超時。
spring.data.cassandra.consistency-level=＃查詢一致性級別。
spring.data.cassandra.contact-points=localhost ＃羣集節點地址。
spring.data.cassandra.fetch-size=＃查詢默認提取大小。
spring.data.cassandra.jmx-enabled=false＃是否啓用JMX報告。
spring.data.cassandra.keyspace-name=＃要使用的Keyspace名稱。
spring.data.cassandra.port=#Cassandra 服務器的端口。
spring.data.cassandra.password=＃服務器的登錄密碼。
spring.data.cassandra.pool.heartbeat-interval=30s #Heartbeat interval，在此之後，在空閒連接上發送消息以確保它仍然存在。如果未指定持續時間後綴，則將使用秒。
spring.data.cassandra.pool.idle-timeout=120s ＃刪除空閒連接之前的空閒超時。如果未指定持續時間後綴，則將使用秒。
spring.data.cassandra.pool.max隊列大小=256 ＃如果沒有可用連接，則排隊的最大請求數。
spring.data.cassandra.pool.pool-timeout=5000ms ＃嘗試從主機池獲取連接時的池超時。
spring.data.cassandra.read-timeout=#Socket 選項：讀取超時。
spring.data.cassandra.repositories.type=auto ＃要啓用的Cassandra存儲庫的類型。
spring.data.cassandra.serial-consistency-level=＃查詢串行一致性級別。
spring.data.cassandra.schema-action=none ＃啓動時要採取的架構操作。
spring.data.cassandra.ssl=false ＃啓用SSL支持。
spring.data.cassandra.username=＃服務器的登錄用戶。
#DATA COUCHBASE（CouchbaseDataProperties）
spring.data.couchbase.auto-index=false ＃自動創建視圖和索引。
spring.data.couchbase.consistency=read-your-own-writes ＃在生成的查詢中默認應用的一致性。
spring.data.couchbase.repositories.type=auto ＃要啓用的Couchbase存儲庫的類型。
#ELASTICSEARCH（ElasticsearchProperties）
spring.data.elasticsearch.cluster-name=elasticsearch ＃Elasticsearch集羣名稱。
spring.data.elasticsearch.cluster-nodes=＃逗號分隔的集羣節點地址列表。
spring.data.elasticsearch.properties。*=＃用於配置客戶端的其他屬性。
spring.data.elasticsearch.repositories.enabled=true ＃是否啓用Elasticsearch存儲庫。
#DATA JDBC spring.data.jdbc.repositories.enabled = true ＃是否啓用JDBC存儲庫。
#DATA LDAP spring.data.ldap.repositories.enabled = true ＃是否啓用LDAP存儲庫。
#MONGODB（MongoProperties）
spring.data.mongodb.authentication-database=＃認證數據庫名稱。
spring.data.mongodb.database=＃數據庫名稱。
spring.data.mongodb.field-naming-strategy=＃要使用的FieldNamingStrategy的完全限定名稱。
spring.data.mongodb.grid-fs-database=＃GridFS數據庫名稱。
spring.data.mongodb.host=#Mongo 服務器主機。無法使用URI設置。
spring.data.mongodb.password=#mongo 服務器的登錄密碼。無法使用URI設置。
spring.data.mongodb.port=#Mongo 服務器端口。無法使用URI設置。
spring.data.mongodb.repositories.type=auto ＃要啓用的Mongo存儲庫的類型。
spring.data.mongodb.uri=mongodb：// localhost / test ＃Mongo數據庫URI。無法使用主機，端口和憑據進行設置。
spring.data.mongodb.username=#mongo 服務器的登錄用戶。無法使用URI設置。
#DATA REDIS
spring.data.redis.repositories.enabled=true ＃是否啓用Redis存儲庫。
＃NEO4J（Neo4jProperties）
spring.data.neo4j.auto-index=none ＃自動索引模式。
spring.data.neo4j.embedded.enabled=true ＃如果嵌入式驅動程序可用，是否啓用嵌入模式。
spring.data.neo4j.open-in-view=true ＃註冊OpenSessionInViewInterceptor。將Neo4j會話綁定到線程以進行整個請求處理。
spring.data.neo4j.password=＃服務器的登錄密碼。
spring.data.neo4j.repositories.enabled=true ＃是否啓用Neo4j存儲庫。
spring.data.neo4j.uri=驅動程序使用的#URL 。默認情況下自動檢測。
spring.data.neo4j.username=＃服務器的登錄用戶。
#DATA REST（RepositoryRestProperties）
spring.data.rest.base-path=#Spring Data REST用於公開存儲庫資源的基本路徑。
spring.data.rest.default-media-type=＃未指定時用作默認值的內容類型。
spring.data.rest.default-page-size=＃默認頁面大小。
spring.data.rest.detection-strategy=default ＃用於確定暴露哪些存儲庫的策略。
spring.data.rest.enable-enum-translation=＃是否通過Spring Data REST默認資源包啓用枚舉值轉換。
spring.data.rest.limit-param-name=#URL查詢字符串參數的名稱，指示一次返回多少結果。
spring.data.rest.max-page-size=＃最大頁面大小。
spring.data.rest.page-param-name=#URL 查詢字符串參數的名稱，指示要返回的頁面。
spring.data.rest.return-body-on-create=＃是否在創建實體後返回響應正文。
spring.data.rest.return-body-on-update=＃更新實體後是否返回響應正文。
spring.data.rest.sort-param-name=#URL 查詢字符串參數的名稱，指示對結果進行排序的方向。
#SOLR （SolrProperties）
spring.data.solr.host=http：//127.0.0.1：8983 / solr #Solr host。如果設置了“zk-host”，則忽略。
spring.data.solr.repositories.enabled=true ＃是否啓用Solr存儲庫。
spring.data.solr.zk-host=＃ZooKeeper主機地址，格式爲HOST：PORT。
＃DATA WEB（SpringDataWebProperties）
spring.data.web.pageable.default頁大小=20 ＃缺省頁大小。
spring.data.web.pageable.max-page-size=2000 ＃要接受的最大頁面大小。
spring.data.web.pageable.one-indexed-parameters=false ＃是否公開和假設從1開始的頁碼索引。
spring.data.web.pageable.page-parameter=page ＃頁面索引參數名稱。
spring.data.web.pageable.prefix=＃常用前綴，用於頁碼和頁面大小參數。
spring.data.web.pageable.qualifier-delimiter=_＃限定符與實際頁碼和大小屬性之間使用的分隔符。
spring.data.web.pageable.size-parameter=size ＃頁面大小參數名稱。
spring.data.web.sort.sort-parameter=sort ＃排序參數名稱。
#DATASOURCE （DataSourceAutoConfiguration＆DataSourceProperties）
spring.datasource.continue-on-error=false ＃初始化數據庫時是否發生錯誤時停止。
spring.datasource.data=#Data （DML）腳本資源引用。
spring.datasource.data-username=＃用於執行DML腳本的數據庫的用戶名（如果不同）。
spring.datasource.data-password=＃執行DML腳本的數據庫的密碼（如果不同）。
spring.datasource.dbcp2.*=＃Commons DBCP2特定設置
spring.datasource.driver-class-name=#JDBC驅動程序的完全限定名稱。默認情況下，基於URL自動檢測。
spring.datasource.generate-unique-name=false ＃是否生成隨機數據源名稱。
spring.datasource.hikari.*=＃Hikari特定設置
spring.datasource.initialization-mode=embedded ＃使用可用的DDL和DML腳本初始化數據源。
spring.datasource.jmx-enabled=false ＃是否啓用JMX支持（如果由基礎池提供）。
spring.datasource.jndi-name=＃JNDI數據源的位置。設置時將忽略類，URL，用戶名和密碼。
spring.datasource.name=＃數據源的名稱。使用嵌入式數據庫時默認爲“testdb”。
spring.datasource.password=＃數據庫的登錄密碼。
spring.datasource.platform=all ＃在DDL或DML腳本中使用的平臺（例如架構 -  $ {platform} .sql或data  -  $ {platform} .sql）。
spring.datasource.schema=#Schema （DDL）腳本資源引用。
spring.datasource.schema-username=＃執行DDL腳本的數據庫的用戶名（如果不同）。
spring.datasource.schema-password=＃執行DDL腳本的數據庫的密碼（如果不同）。
spring.datasource.separator=;#SQL初始化腳本中的語句分隔符。
spring.datasource.sql-script-encoding=#SQL 腳本編碼。
spring.datasource.tomcat.*=＃Tomcat數據源特定設置
spring.datasource.type=＃要使用的連接池實現的完全限定名稱。默認情況下，它是從類路徑中自動檢測到的。
spring.datasource.url=＃JDBC數據庫的URL。
spring.datasource.username=＃登錄數據庫的用戶名。
spring.datasource.xa.data-source-class-name=#XA 數據源完全限定名稱。
spring.datasource.xa.properties=＃傳遞給XA數據源的屬性。
#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 ＃借用連接的超時（以秒爲單位）。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=true ＃是否使用併發連接驗證。
spring.jta.atomikos.datasource.default-isolation-level=＃池提供的連接的默認隔離級別。
spring.jta.atomikos.datasource.login-timeout=0 ＃建立數據庫連接的超時時間（秒）。
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子交易=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#VM是否應該關閉事務核心的強制關閉。
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孤兒的日誌條目延遲=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=false ＃事務管理器是否應該允許混合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=false ＃是否禁用此資源，這意味着暫時禁止從其池中獲取連接。
spring.jta.bitronix.connectionfactory.driver-properties=＃應在底層實現上設置的屬性。
spring.jta.bitronix.connectionfactory.ignore-recovery-failures=false ＃是否應忽略恢復失敗。
spring.jta.bitronix.connectionfactory.max-idle-time=60 ＃從池中清除連接的時間（以秒爲單位）。
spring.jta.bitronix.connectionfactory.max-pool-size=0 ＃池的最大大小。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=false ＃從池中獲取時是否應測試連接。
spring.jta.bitronix.connectionfactory.two-pc-ordering-position=1 ＃此資源在兩階段提交期間應該採取的位置（始終首先是Integer.MIN_VALUE，總是最後一個是Integer.MAX_VALUE）。
spring.jta.bitronix.connectionfactory.unique名=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=false ＃事務管理器是否應該允許混合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=false ＃是否禁用此資源，這意味着暫時禁止從其池中獲取連接。
spring.jta.bitronix.datasource.driver-properties=＃應在底層實現上設置的屬性。
spring.jta.bitronix.datasource.enable -jdbc4-connection-test = false ＃從池中獲取連接時是否調用Connection.isValid（）。
spring.jta.bitronix.datasource.ignore-recovery-failures=false ＃是否應忽略恢復失敗。
spring.jta.bitronix.datasource.isolation-level=＃連接的默認隔離級別。
spring.jta.bitronix.datasource.local-auto-commit=＃本地事務的默認自動提交模式。
spring.jta.bitronix.datasource.login-timeout=＃用於建立數據庫連接的超時（以秒爲單位）。
spring.jta.bitronix.datasource.max-idle-time=60 ＃從池中清除連接的時間（以秒爲單位）。
spring.jta.bitronix.datasource.max-pool-size=0 ＃池的最大大小。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 ＃跳過損壞的事務日誌條目。
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 ＃是否啓用關閉端點。
#THREAD DUMP ENDPOINT（ThreadDumpEndpoint）
management.endpoint.threaddump.cache.time-to-live=0ms ＃可以緩存響應的最長時間。
management.endpoint.threaddump.enabled=true ＃是否啓用threaddump端點。
＃HEALTH INDICATORS 
management.health.db.enabled=true ＃是否啓用數據庫運行狀況檢查。
management.health.cassandra.enabled=true ＃是否啓用Cassandra運行狀況檢查。
management.health.couchbase.enabled=true ＃是否啓用Couchbase運行狀況檢查。
management.health.defaults.enabled=true ＃是否啓用默認健康指標。
management.health.diskspace.enabled=true ＃是否啓用磁盤空間運行狀況檢查。
management.health.diskspace.path=＃用於計算可用磁盤空間的路徑。
management.health.diskspace.threshold=10MB＃應該可用的最小磁盤空間。
management.health.elasticsearch.enabled=true ＃是否啓用Elasticsearch運行狀況檢查。
management.health.elasticsearch.indices=＃逗號分隔的索引名稱。
management.health.elasticsearch.response-timeout=100ms ＃等待集羣響應的時間。
management.health.influxdb.enabled=true ＃是否啓用InfluxDB運行狀況檢查。
management.health.jms.enabled=true ＃是否啓用JMS運行狀況檢查。
management.health.ldap.enabled=true ＃是否啓用LDAP運行狀況檢查。
management.health.mail.enabled=true＃是否啓用郵件健康檢查。
management.health.mongo.enabled=true ＃是否啓用MongoDB運行狀況檢查。
management.health.neo4j.enabled=true ＃是否啓用Neo4j運行狀況檢查。
management.health.rabbit.enabled=true ＃是否啓用RabbitMQ運行狀況檢查。
management.health.redis.enabled=true ＃是否啓用Redis運行狀況檢查。
management.health.solr.enabled=true ＃是否啓用Solr運行狀況檢查。
management.health.status.http-mapping=＃將健康狀態映射到HTTP狀態代碼。默認情況下，已註冊的運行狀況映射到合理的默認值（例如，UP映射到200）。
management.health.status.order=DOWN，OUT_OF_SERVICE，UP，UNKNOWN ＃逗號分隔的健康狀態列表，按嚴重程度排序。
#HTTP TRACING（HttpTraceProperties）
management.trace.http.enabled=true ＃是否啓用HTTP請求 - 響應跟蹤。
management.trace.http.include=請求標頭，響應標頭，cookie，錯誤＃要包含在跟蹤中的項目。
#INFO CONTRIBUTORS（InfoContributorProperties）
management.info.build.enabled=true ＃是否啓用構建信息。
management.info.defaults.enabled=true ＃是否啓用默認信息貢獻者。
management.info.env.enabled=true ＃是否啓用環境信息。
management.info.git.enabled=true ＃是否啓用git信息。
management.info.git.mode=simple ＃用於公開git信息的模式。
#METRICS
management.metrics.distribution.maximum-expected-value。*=＃預計將以指定名稱開始計量ID的最大值。
management.metrics.distribution.minimum-expected-value。*=＃預計將以指定名稱開始的儀表ID的最小值。
management.metrics.distribution.percentiles.*=＃特定計算的非可聚合百分位數，用於以指定名稱開始的儀表ID發送到後端。
management.metrics.distribution.percentiles-histogram。*=＃是否以指定名稱開頭的米ID應發佈百分位直方圖。
management.metrics.distribution.sla.*=＃以指定名稱開頭的儀表ID的特定SLA邊界。最長的比賽獲勝。
management.metrics.enable.*=＃應啓用是否以指定名稱開始的儀表ID。最長的匹配獲勝，關鍵的“all”也可以用於配置所有的米。
management.metrics.export.appoptics.api-token=#AppOptics API令牌。
management.metrics.export.appoptics.batch-size=500 ＃每個請求用於此後端的度量數。如果找到更多測量值，則將發出多個請求。
management.metrics.export.appoptics.connect-timeout=5s ＃對此後端的請求的連接超時。
management.metrics.export.appoptics.enabled=true ＃是否啓用將度量標準導出到此後端。
management.metrics.export.appoptics.host-tag=instance ＃將指標發送到AppOptics時將映射到“@host”的標記。
management.metrics.export.appoptics.num-threads=2 ＃指標發佈計劃程序使用的線程數。
management.metrics.export.appoptics.read-timeout=10s ＃讀取此後端請求的超時時間。
management.metrics.export.appoptics.step=1m ＃要使用的步長（即報告頻率）。
management.metrics.export.appoptics.uri=https://api.appoptics.com/v1/measurements# 將指標發送到的URI。
management.metrics.export.atlas.batch-size=10000 ＃每個請求用於此後端的度量數。如果找到更多測量值，則將發出多個請求。
management.metrics.export.atlas.config-refresh-frequency=10s ＃從LWC服務刷新配置設置的頻率。
management.metrics.export.atlas.config-time-to-live=150s #LWC服務訂閱的生存時間。
management.metrics.export.atlas.config-uri=http：// localhost：7101 / lwc / api / v1 / expressions / local-dev #Atlas LWC端點的URI，用於檢索當前訂閱。
management.metrics.export.atlas.connect-timeout=1s＃對此後端的請求的連接超時。
management.metrics.export.atlas.enabled=true ＃是否啓用將度量標準導出到此後端。
management.metrics.export.atlas.eval-uri=http：// localhost：7101 / lwc / api / v1 / evaluate ＃用於評估訂閱數據的Atlas LWC端點的URI。
management.metrics.export.atlas.lwc-enabled=false ＃是否啓用流式傳輸到Atlas LWC。
management.metrics.export.atlas.meter-time-to-live=15m ＃沒有任何活動的米的生存時間。在此期間之後，儀表將被視爲已過期且不會報告。
management.metrics.export.atlas.num-threads=2＃指標發佈計劃程序使用的線程數。
management.metrics.export.atlas.read-timeout=10s ＃讀取此後端請求的超時時間。
management.metrics.export.atlas.step=1m ＃要使用的步長（即報告頻率）。
management.metrics.export.atlas.uri=http：// localhost：7101 / api / v1 / publish #Atlas服務器的URI。
management.metrics.export.datadog.api-key=＃Datadog API密鑰。
management.metrics.export.datadog.application-key=＃Datadog應用程序密鑰。不是嚴格要求，但通過向Datadog發送儀表描述，類型和基本單位來改進Datadog體驗。
management.metrics.export.datadog.batch-size=10000 ＃每個請求用於此後端的度量數。如果找到更多測量值，則將發出多個請求。
management.metrics.export.datadog.connect-timeout=1s ＃對此後端的請求的連接超時。
management.metrics.export.datadog.descriptions=true ＃是否將描述元數據發佈到Datadog。將其關閉以最小化發送的元數據量。
management.metrics.export.datadog.enabled=true ＃是否啓用將度量標準導出到此後端。
management.metrics.export.datadog.host-tag=instance＃將指標發送到Datadog時將映射到“主機”的標記。
management.metrics.export.datadog.num-threads=2 ＃指標發佈計劃程序使用的線程數。
management.metrics.export.datadog.read-timeout=10s ＃讀取此後端請求的超時時間。
management.metrics.export.datadog.step=1m ＃要使用的步長（即報告頻率）。
management.metrics.export.datadog.uri=https://app.datadoghq.com# 將指標發送到的URI。如果需要將指標發佈到到Datadog的內部代理，則可以使用此方法定義代理的位置。
management.metrics.export.dynatrace.api-token=#Dynatrace身份驗證令牌。
management.metrics.export.dynatrace.batch-size=10000 ＃每個請求用於此後端的度量數。如果找到更多測量值，則將發出多個請求。
management.metrics.export.dynatrace.connect-timeout=1s ＃對此後端的請求的連接超時。
management.metrics.export.dynatrace.device-id=將度量標準導出到Dynatrace的自定義設備的ID。
management.metrics.export.dynatrace.enabled=true ＃是否啓用將度量標準導出到此後端。
management.metrics.export.dynatrace.num-threads=2＃指標發佈計劃程序使用的線程數。
management.metrics.export.dynatrace.read-timeout=10s ＃讀取此後端請求的超時時間。
management.metrics.export.dynatrace.step=1m ＃要使用的步長（即報告頻率）。
management.metrics.export.dynatrace.technology-type=java ＃導出的指標的技術類型。用於在Dynatrace UI中對邏輯技術名稱下的度量標準進行分組。
management.metrics.export.dynatrace.uri=將指標發送到的URI。應該用於SaaS，自我管理的實例或通過內部代理途徑。
management.metrics.export.elastic.auto-create-index=true＃是否自動創建索引（如果不存在）。
management.metrics.export.elastic.batch-size=10000 ＃每個請求用於此後端的度量數。如果找到更多測量值，則將發出多個請求。
management.metrics.export.elastic.connect-timeout=1s ＃對此後端的請求的連接超時。
management.metrics.export.elastic.enabled=true ＃是否啓用將度量標準導出到此後端。
management.metrics.export.elastic.host=http：// localhost：9200 ＃將指標導出到的主機。
management.metrics.export.elastic.index=metrics ＃將指標導出到的索引。
management.metrics.export.elastic.index-date-format=yyyy-MM ＃用於滾動索引的索引日期格式。附加到索引名稱後面加一個' - '。
management.metrics.export.elastic.num-threads=2 ＃指標發佈計劃程序使用的線程數。
management.metrics.export.elastic.password=＃彈性服務器的登錄密碼。
management.metrics.export.elastic.read-timeout=10s ＃讀取此後端請求的超時時間。
management.metrics.export.elastic.step=1m ＃要使用的步長（即報告頻率）。
management.metrics.export.elastic.timestamp-field-name=@ timestamp ＃時間戳字段的名稱。 
management.metrics.export.elastic.user-name=＃彈性服務器的登錄用戶。
management.metrics.export.ganglia.addressing-mode=multicast ＃UDP尋址模式，單播或多播。
management.metrics.export.ganglia.duration- units =毫秒＃用於報告持續時間的基本時間單位。
management.metrics.export.ganglia.enabled=true ＃是否啓用向Ganglia導出指標。
management.metrics.export.ganglia.host=localhost ＃Ganglia服務器的主機，用於接收導出的指標。
management.metrics.export.ganglia.port=8649 ＃Ganglia服務器端口，用於接收導出的指標。
management.metrics.export.ganglia.protocol-version=3.1 ＃Ganglia協議版本。必須是3.1或3.0。
management.metrics.export.ganglia.rate- units = seconds ＃用於報告費率的基本時間單位。
management.metrics.export.ganglia.step=1m ＃要使用的步長（即報告頻率）。
management.metrics.export.ganglia.time-to-live=1 ＃生活在Ganglia上的指標的時間。將多播生存時間設置爲大於主機之間的跳數（路由器）的數量。
management.metrics.export.graphite.duration-units=毫秒＃用於報告持續時間的基本時間單位。
management.metrics.export.graphite.enabled=true＃是否啓用將指標導出到Graphite。
management.metrics.export.graphite.host=localhost ＃Graphite服務器的主機，用於接收導出的指標。
management.metrics.export.graphite.port=2004 ＃Graphite服務器的端口，用於接收導出的指標。
management.metrics.export.graphite.protocol=pickled ＃在將數據發送到Graphite時使用的協議。
management.metrics.export.graphite.rate-units=seconds ＃用於報告費率的基本時間單位。
management.metrics.export.graphite.step=1m ＃要使用的步長（即報告頻率）。
management.metrics.export.graphite.tags-as-prefix=＃對於默認命名約定，將指定的標記鍵轉換爲度量標準前綴的一部分。
management.metrics.export.humio.api-token=＃Humio API令牌。
management.metrics.export.humio.batch-size=10000 ＃每個請求用於此後端的度量數。如果找到更多測量值，則將發出多個請求。
management.metrics.export.humio.connect-timeout=5s ＃對此後端的請求的連接超時。
management.metrics.export.humio.enabled=true ＃是否啓用將度量標準導出到此後端。
management.metrics.export.humio.num-threads=2 ＃指標發佈計劃程序使用的線程數。
management.metrics.export.humio.read-timeout=10s ＃讀取此後端請求的超時時間。
management.metrics.export.humio.repository=sandbox ＃要將指標發佈到的存儲庫的名稱。
management.metrics.export.humio.step=1m ＃要使用的步長（即報告頻率）。
management.metrics.export.humio.tags.*=＃Humio標籤，用於描述將存儲指標的數據源。Humio標籤是與Micrometer標籤不同的概念。千分尺的標籤用於沿尺寸邊界劃分度量。
management.metrics.export.humio.uri=https://cloud.humio.com#idex將指標發送到。如果您需要將指標發佈到Humio的內部代理，您可以使用此方法定義代理的位置。
management.metrics.export.influx.auto-create-db=true ＃在嘗試向其發佈指標之前，是否創建Influx數據庫是否存在。
management.metrics.export.influx.batch-size=10000 ＃每個請求用於此後端的度量數。如果找到更多測量值，則將發出多個請求。
management.metrics.export.influx.compressed=true ＃是否對發佈到Influx的度量批次啓用GZIP壓縮。
management.metrics.export.influx.connect-timeout=1s＃對此後端的請求的連接超時。
management.metrics.export.influx.consistency=one ＃爲每個點寫一致性。
management.metrics.export.influx.db=mydb ＃將指標發送到Influx時將映射到“主機”的標記。
management.metrics.export.influx.enabled=true ＃是否啓用將度量標準導出到此後端。
management.metrics.export.influx.num-threads=2 ＃指標發佈計劃程序使用的線程數。
management.metrics.export.influx.password=＃Influx服務器的登錄密碼。
management.metrics.export.influx.read-timeout=10s＃讀取此後端請求的超時時間。
management.metrics.export.influx.retention-duration=＃Influx應在當前數據庫中保留數據的時間段。
management.metrics.export.influx.retention-shard-duration=＃分片組覆蓋的時間範圍。
management.metrics.export.influx.retention-policy=＃要使用的保留策略（如果未指定，則Influx寫入DEFAULT保留策略）。
management.metrics.export.influx.retention-replication-factor=＃在羣集中存儲了多少份數據副本。
management.metrics.export.influx.step=1m ＃要使用的步長（即報告頻率）。
management.metrics.export.influx.uri=http：// localhost：8086 ＃Influx服務器的URI。
management.metrics.export.influx.user-name=＃Influx服務器的登錄用戶。
management.metrics.export.jmx.domain=metrics ＃Metrics JMX域名。
management.metrics.export.jmx.enabled=true ＃是否已啓用將度量標準導出到JMX。
management.metrics.export.jmx.step=1m ＃要使用的步長（即報告頻率）。
management.metrics.export.kairos.batch-size=10000 ＃每個請求用於此後端的度量數。如果找到更多測量值，則將發出多個請求。
management.metrics.export.kairos.connect-timeout=1s ＃對此後端的請求的連接超時。
management.metrics.export.kairos.enabled=true ＃是否啓用將度量標準導出到此後端。
management.metrics.export.kairos.num-threads=2 ＃指標發佈計劃程序使用的線程數。
management.metrics.export.kairos.password=#KairosDB服務器的登錄密碼。
management.metrics.export.kairos.read-timeout=10s ＃讀取此後端請求的超時時間。
management.metrics.export.kairos.step=1m ＃要使用的步長（即報告頻率）。
management.metrics.export.kairos.uri=localhost：8080 / api / v1 /  datapoints #KairosDB服務器的URI。
management.metrics.export.kairos.user-name=#KairosDB服務器的登錄用戶。
management.metrics.export.newrelic.account-id=＃新Relic帳戶ID。
management.metrics.export.newrelic.api-key=#New Relic API密鑰。
management.metrics.export.newrelic.batch-size=10000 ＃每個請求用於此後端的度量數。如果找到更多測量值，則將發出多個請求。
management.metrics.export.newrelic.connect-timeout=1s ＃對此後端的請求的連接超時。
management.metrics.export.newrelic.enabled=true ＃是否啓用將度量標準導出到此後端。
management.metrics.export.newrelic.num-threads=2 ＃指標發佈計劃程序使用的線程數。
management.metrics.export.newrelic.read-timeout=10s ＃讀取此後端請求的超時時間。
management.metrics.export.newrelic.step=1m ＃要使用的步長（即報告頻率）。
management.metrics.export.newrelic.uri=https：//insights-collector.newrelic.com #idex 將指標發送到。
management.metrics.export.prometheus.descriptions=true＃是否將發佈描述作爲scrape有效負載的一部分啓用到Prometheus。將其關閉以最小化每次刮擦發送的數據量。
management.metrics.export.prometheus.enabled=true ＃是否啓用將指標導出到Prometheus。
management.metrics.export.prometheus.step=1m ＃要使用的步長（即報告頻率）。
management.metrics.export.prometheus.pushgateway.base-url=localhost：9091 ＃Pushgateway的基本URL。
management.metrics.export.prometheus.pushgateway.enabled=false ＃通過Prometheus Pushgateway啓用發佈。
management.metrics.export.prometheus.pushgateway.grouping-key=＃爲推送的指標分組鍵。
management.metrics.export.prometheus.pushgateway.job=＃此應用程序實例的作業標識符。
management.metrics.export.prometheus.pushgateway.push-rate=1m ＃用於推送指標的頻率。
management.metrics.export.prometheus.pushgateway.shutdown-operation=＃應該在關機時執行的操作。
management.metrics.export.signalfx.access-token=#SignalFX訪問令牌。
management.metrics.export.signalfx.batch-size=10000 ＃每個請求用於此後端的度量數。如果找到更多測量值，則將發出多個請求。
management.metrics.export.signalfx.connect-timeout=1s ＃對此後端的請求的連接超時。
management.metrics.export.signalfx.enabled=true ＃是否啓用將度量標準導出到此後端。
management.metrics.export.signalfx.num-threads=2 ＃指標發佈計劃程序使用的線程數。
management.metrics.export.signalfx.read-timeout=10s ＃讀取此後端請求的超時時間。
management.metrics.export.signalfx.source=＃唯一標識正在向SignalFx發佈指標的應用實例。默認爲本地主機名。
management.metrics.export.signalfx.step=10s＃步驟大小（即報告頻率）使用。
management.metrics.export.signalfx.uri=https：//ingest.signalfx.com# 將指標發送到的URI。
management.metrics.export.simple.enabled=true ＃在沒有任何其他導出程序的情況下，是否啓用將指標導出到內存後端。
management.metrics.export.simple.mode=累積＃計數模式。
management.metrics.export.simple.step=1m ＃要使用的步長（即報告頻率）。
management.metrics.export.statsd.enabled=true ＃是否啓用將度量標準導出到StatsD。
management.metrics.export.statsd.flavor=datadog#StatsD線路協議使用。
management.metrics.export.statsd.host=localhost ＃StatsD服務器的主機，用於接收導出的指標。
management.metrics.export.statsd.max-packet-length=1400 ＃單個有效負載的總長度應保持在網絡的MTU中。
management.metrics.export.statsd.polling-frequency=10s ＃測量儀表的頻率。輪詢儀表時，將重新計算其值，如果值已更改（或者publishUnchangedMeters爲true），則將其發送到StatsD服務器。
management.metrics.export.statsd.port=8125 ＃StatsD服務器的端口，用於接收導出的指標。
management.metrics.export.statsd.publish-不變米=true ＃是否將未更改的計量表發送到StatsD服務器。
management.metrics.export.wavefront.api-token=＃將指標直接發佈到Wavefront API主機時使用的API令牌。
management.metrics.export.wavefront.batch-size=10000 ＃每個請求用於此後端的度量數。如果找到更多測量值，則將發出多個請求。
management.metrics.export.wavefront.connect-timeout=1s ＃對此後端的請求的連接超時。
management.metrics.export.wavefront.enabled=true ＃是否啓用將度量標準導出到此後端。
management.metrics.export.wavefront.global-prefix=＃全局前綴用於將源自此應用程序的白盒工具的度量標準與在Wavefront UI中查看時源自其他Wavefront集成的度量標準分開。
management.metrics.export.wavefront.num-threads=2 ＃與度量標準發佈計劃程序一起使用的線程數。
management.metrics.export.wavefront.read-timeout=10s ＃讀取此後端請求的超時時間。
management.metrics.export.wavefront.source=＃應用程序實例的唯一標識符，該實例是發佈到Wavefront的度量標準的來源。默認爲本地主機名。
management.metrics.export.wavefront.step=10s ＃要使用的步長（即報告頻率）。
management.metrics.export.wavefront.uri=https://longboard.wavefront.com# 將指標發送到的URI。
management.metrics.use-global-registry=true ＃是否應將自動配置的MeterRegistry實現綁定到Metrics上的全局靜態註冊表。
management.metrics.tags.*=＃應用於每個儀表的公共標籤。
management.metrics.web.client.max-uri-tags=100 ＃允許的唯一URI標記值的最大數量。達到最大標記值數後，過濾器將拒絕具有其他標記值的度量標準。
management.metrics.web.client.requests-metric-name=http.client.requests ＃已發送請求的度量標準的名稱。
management.metrics.web.server.auto-time-requests=true ＃是否應自動爲Spring MVC，WebFlux或Jersey處理的請求定時。
management.metrics.web.server.max-uri-tags=100 ＃允許的唯一URI標記值的最大數量。達到最大標記值數後，過濾器將拒絕具有其他標記值的度量標準。
management.metrics.web.server.requests-metric-name=http.server.requests ＃已接收請求的度量標準的名稱。
＃----------------------------------------
#DEDTOOLS PROPERTIES
＃----- -----------------------------------
#DESTOOLS（DevToolsProperties）
spring.devtools.add-properties=true ＃是否啓用開發屬性默認值。
spring.devtools.livereload.enabled=true ＃是否啓用livereload.com兼容服務器。
spring.devtools.livereload.port=35729 ＃服務器端口。
spring.devtools.restart.additional-exclude=＃應該從觸發完全重啓中排除的其他模式。
spring.devtools.restart.additional-paths=＃要監視更改的其他路徑。
spring.devtools.restart.enabled=true ＃是否啓用自動重啓。
spring.devtools.restart.exclude=META-INF /行家/ **，META-INF /資源/ **，資源/ **，靜態/ **，公共/ **，模板/ **，** / *的Test.class，** / * Tests.class，git.properties，META-INF / build-info.properties ＃應該從觸發完全重啓中排除的模式。
spring.devtools.restart.log-condition-evaluation-delta=true ＃是否在重新啓動時記錄條件評估增量。
spring.devtools.restart.poll-interval=1s ＃輪詢類路徑更改之間等待的時間。
spring.devtools.restart.quiet-period=400ms ＃觸發重啓之前沒有任何類路徑更改所需的安靜時間量。
spring.devtools.restart.trigger-file=＃特定文件的名稱，當更改時，觸發重新啓動檢查。如果未指定，則任何類路徑文件更改都會觸發重新啓動。
#remote DEVTOOLS（RemoteDevToolsProperties）
spring.devtools.remote.context-path=/。~~ spring-boot！〜＃用於處理遠程連接的上下文路徑。
spring.devtools.remote.proxy.host=＃用於連接遠程應用程序的代理主機。
spring.devtools.remote.proxy.port=＃用於連接遠程應用程序的代理端口。
spring.devtools.remote.restart.enabled=true ＃是否啓用遠程重啓。
spring.devtools.remote.secret=＃建立連接所需的共享密鑰（啓用遠程支持所需）。
spring.devtools.remote.secret頭名=X-AUTH-TOKEN ＃用於傳輸共享密鑰的HTTP頭。
＃----------------------------------------
#TESTING PROPERTIES
＃----- -----------------------------------
spring.test.database.replace=any ＃要替換的現有DataSource的類型。
spring.test.mockmvc.print=默認#MVC 打印選項。