SpringBoot學習（一）

SpringBoot 2.x 默認配置大全（跟SpringBoot1.x有差異的，1.x屬性配置請參照官網）

＃================================================= ================== 
＃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-name = 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 = ＃逗號分隔的用戶代理列表，不該壓縮響應。
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＃執行壓縮所需的最小「Content-Length」值。
server.connection-timeout = ＃鏈接器在關閉鏈接以前等待另外一個HTTP請求的時間。未設置時，將使用鏈接器的特定於容器的默認值。使用值-1表示沒有（即無限）超時。
server.error.include-exception = false ＃包含「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.protocol = TLS ＃要使用的SSL協議。
server.ssl.trust-store = ＃持有SSL證書的信任存儲。
server.ssl.trust-store-password = ＃用於訪問信任庫的密碼。
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.pattern = common ＃訪問日誌的格式模式。
server.tomcat.accesslog.prefix = access_log ＃日誌文件名前綴。
server.tomcat.accesslog.rename-on-rotate = false ＃是否延遲在文件名中包含日期戳，直到旋轉時間。
server.tomcat.accesslog.request-attributes-enabled = 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 #backgroundProcess 方法調用之間的延遲。若是未指定持續時間後綴，則將使用秒。
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-header = 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-caching = 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-threads =＃爲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-spring-macro-helpers = true ＃是否公開一個RequestContext供Spring的宏庫使用，名稱爲「springMacroRequestContext」。
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 ＃借用鏈接的reap超時（以秒爲單位）。0表示沒有限制。
spring.jta.atomikos.connectionfactory.unique-resource-name = jmsConnectionFactory＃用於在恢復期間標識資源的惟一名稱。
spring.jta.atomikos.connectionfactory.xa-connection-factory-class-name = #XAConnectionFactory的供應商特定實現。
spring.jta.atomikos.connectionfactory.xa-properties = ＃供應商特定的XA屬性。
spring.jta.atomikos.datasource.borrow-connection-timeout = 30 ＃從池中借用鏈接的超時時間（秒）。
spring.jta.atomikos.datasource.concurrent-connection-validation = ＃是否使用併發鏈接驗證。
spring.jta.atomikos.datasource.default-isolation-level = ＃池提供的鏈接的默認隔離級別。
spring.jta.atomikos.datasource.login-timeout = ＃用於創建數據庫鏈接的超時（以秒爲單位）。
spring.jta.atomikos.datasource.maintenance-interval = 60 ＃池維護線程運行之間的時間（以秒爲單位）。
spring.jta.atomikos.datasource.max-idle-time = 60 ＃從池中清除鏈接的時間（以秒爲單位）。
spring.jta.atomikos.datasource.max-lifetime = 0 ＃鏈接在被銷燬以前能夠合併的時間（以秒爲單位）。0表示沒有限制。
spring.jta.atomikos.datasource.max-pool-size = 1 ＃池的最大大小。
spring.jta.atomikos.datasource.min-pool-size = 1＃池的最小大小。
spring.jta.atomikos.datasource.reap-timeout = 0 ＃借用鏈接的reap超時（以秒爲單位）。0表示沒有限制。
spring.jta.atomikos.datasource.test-query = ＃用於在返回鏈接以前驗證鏈接的SQL查詢或語句。
spring.jta.atomikos.datasource.unique-resource-name = dataSource ＃用於在恢復期間標識資源的惟一名稱。
spring.jta.atomikos.datasource.xa-data-source-class-name = #XAConnectionFactory的供應商特定實現。
spring.jta.atomikos.datasource.xa-properties = ＃供應商特定的XA屬性。
spring.jta.atomikos.properties.allow-sub-transactions = true ＃指定是否容許子事務。
spring.jta.atomikos.properties.checkpoint-interval = 500 ＃檢查點之間的間隔，表示爲兩個檢查點之間的日誌寫入次數。
spring.jta.atomikos.properties.default -jta -timeout = 10000ms #JTA 事務的默認超時。
spring.jta.atomikos.properties.default-max-wait-time-on-shutdown = 9223372036854775807 ＃正常關閉（no-force）等待事務完成的時間。
spring.jta.atomikos.properties.enable-logging = true ＃是否啓用磁盤日誌記錄。
spring.jta.atomikos.properties.force-shutdown-on-vm-exit = false ＃虛擬機關閉是否應觸發事務核心的強制關閉。
spring.jta.atomikos.properties.log-base-dir = ＃應存儲日誌文件的目錄。
spring.jta.atomikos.properties.log-base-name = tmlog ＃Transactions日誌文件基名。
spring.jta.atomikos.properties.max-actives = 50 ＃最大活動事務數。
spring.jta.atomikos.properties.max-timeout = 300000ms ＃事務容許的最大超時時間。
spring.jta.atomikos.properties.recovery.delay = 10000ms ＃兩次恢復掃描之間的延遲。
spring.jta.atomikos.properties.recovery.forget- orphaned -log-entries-delay = 86400000ms ＃恢復以後的延遲能夠清除掛起（'孤立'）日誌條目。
spring.jta.atomikos.properties.recovery.max-retries = 5 ＃在拋出異常以前提交事務的重試次數。
spring.jta.atomikos.properties.recovery.retry-interval = 10000ms ＃重試嘗試之間的延遲。
spring.jta.atomikos.properties.serial-jta-transactions = true ＃是否應儘量加入子事務。
spring.jta.atomikos.properties.service = ＃應該啓動的事務管理器實現。
spring.jta.atomikos.properties.threaded-two-phase-commit = false ＃是否對參與資源使用不一樣（和併發）線程進行兩階段提交。
spring.jta.atomikos.properties.transaction-manager-unique-name = ＃事務管理器的惟一名稱。

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

＃EMBEDDED MONGODB（EmbeddedMongoProperties）
 spring.mongodb.embedded.features = sync_delay ＃逗號分隔的要啓用的功能列表。
spring.mongodb.embedded.storage.database-dir = ＃用於數據存儲的目錄。
spring.mongodb.embedded.storage.oplog-size = #oplog的最大大小。
spring.mongodb.embedded.storage.repl-set-name = ＃副本集的名稱。
spring.mongodb.embedded.version = 3.5.5 ＃要使用的Mongo版本。

#REDIS（RedisProperties）
 spring.redis.cluster.max -redirects = ＃在羣集中執行命令時要遵循的最大重定向數。
spring.redis.cluster.nodes = ＃逗號分隔的「host：port」對列表引導自。
spring.redis.database = 0 ＃鏈接工廠使用的數據庫索引。
spring.redis.url = ＃鏈接URL。覆蓋主機，端口和密碼。用戶被忽略。示例：redis：// user：password@example.com ：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 打印選項。

轉載：https://www.jianshu.com/p/b4e606c1ffdd