＃================================================= ==================
＃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 ＃在日志記錄系統(tǒng)初始化時注冊一個關閉鉤子。
＃AOP
spring.aop.auto =真＃添加@EnableAspectJAutoProxy。
spring.aop.proxy-target-class = true ＃是否要創(chuàng)建基于子類的（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 分隔的要創(chuàng)建的緩存名稱列表（如果底層緩存管理器支持）。
spring.cache.caffeine.spec = ＃用于創(chuàng)建緩存的規(guī)范。有關規(guī)格格式的更多詳細信息，請參閱CaffeineSpec。
spring.cache.couchbase.expiration = ＃條目到期。默認情況下，條目永不過期。請注意，此值最終會轉換為秒。
spring.cache.ehcache.config = ＃用于初始化EhCache的配置文件的位置。
spring.cache.infinispan.config = ＃用于初始化Infinispan的配置文件的位置。
spring.cache.jcache.config = ＃用于初始化緩存管理器的配置文件的位置。
spring.cache.jcache.provider = #CachingProvider實現(xiàn)的完全限定名稱，用于檢索符合JSR-107的緩存管理器。僅當類路徑上有多個JSR-107實現(xiàn)時才需要。
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 類型。默認情況下，根據(jù)環(huán)境自動檢測。
#SPRING CONFIG? - 僅使用環(huán)境屬性（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名稱。設置時，優(yōu)先于其他會話設置。
spring.mail.password = #SMTP 服務器的登錄密碼。
spring.mail.port = #SMTP 服務器端口。
spring.mail.properties。* = ＃其他JavaMail會話屬性。
spring.mail.protocol = smtp ＃SMTP服務器使用的協(xié)議。
spring.mail.test-connection = false＃是否在啟動時測試郵件服務器是否可用。
spring.mail.username = #SMTP 服務器的登錄用戶。
#APICING SETTINGS（SpringApplication）
spring.main.allow-bean-definition-overriding = false ＃是否允許通過注冊與現(xiàn)有定義同名的定義來覆蓋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規(guī)則，甚至解析不帶參數(shù)的消息。
spring.messages.basename = messages ＃逗號分隔的basenames列表（本質上是一個完全限定的類路徑位置），每個都遵循ResourceBundle約定，輕松支持基于斜杠的位置。
spring.messages.cache-duration = ＃加載的資源包文件緩存持續(xù)時間。未設置時，捆綁包將永久緩存。如果未指定持續(xù)時間后綴，則將使用秒。
spring.messages.encoding = UTF-8 ＃消息包編碼。
spring.messages.fallback-to-system-locale = true ＃如果找不到特定區(qū)域設置的文件，是否回退到系統(tǒng)區(qū)域設置。
spring.messages.use-code-as-default-message = false ＃是否使用消息代碼作為默認消息而不是拋出“NoSuchMessageException”。僅在開發(fā)期間推薦。
＃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 ＃數(shù)據(jù)庫模式初始化模式。
spring.quartz.jdbc.schema = classpath：org / quartz / impl / jdbcjobstore / tables_ @ @ platform @@ .sql ＃用于初始化數(shù)據(jù)庫模式的SQL文件的路徑。
spring.quartz.job-store-type = memory ＃Quartz作業(yè)存儲類型。
spring.quartz.overwrite-existing-jobs = false ＃配置的作業(yè)是否應覆蓋現(xiàn)有的作業(yè)定義。
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 ＃是否等待在關閉時運行的作業(yè)完成。
#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 ＃是否允許核心線程超時。這可以實現(xiàn)池的動態(tài)增長和收縮。
spring.task.execution.pool.core-size = 8 ＃核心線程數(shù)。
spring.task.execution.pool.keep-alive = 60s ＃終止之前線程可能保持空閑的時間限制。
spring.task.execution.pool.max-size = ＃允許的最大線程數(shù)。如果任務正在填滿隊列，則池可以擴展到該大小以適應負載。如果隊列無限制，則忽略。
spring.task.execution.pool.queue-capacity =＃隊列容量。無限制的容量不會增加池，因此會忽略“max-size”屬性。
spring.task.execution.thread-name-prefix = task- ＃用于新創(chuàng)建的線程名稱的前綴。
#TASK SCHEDULING（TaskSchedulingProperties）
spring.task.scheduling.pool.size = 1 ＃允許的最大線程數(shù)。
spring.task.scheduling.thread-name-prefix = scheduling- ＃用于新創(chuàng)建的線程名稱的前綴。
＃----------------------------------------
＃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＃執(zhí)行壓縮所需的最小“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支持，如果當前環(huán)境支持它。
server.jetty.acceptors = -1 ＃要使用的接受者線程數(shù)。當值為-1（默認值）時，接受器的數(shù)量是從操作環(huán)境派生的。
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 = ＃請求日志的區(qū)域設置。
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＃刪除旋轉日志文件之前的天數(shù)。
server.jetty.accesslog.time-zone = GMT ＃請求日志的時區(qū)。
server.jetty.max-http-post-size = 200000B #HTTP post或put內容的最大大小。
server.jetty.selectors = -1 ＃要使用的選擇器線程數(shù)。當值為-1（默認值）時，選擇器的數(shù)量是從操作環(huán)境派生的。
server.max-http-header-size = 8KB #HTTP 郵件頭的最大大小。
server.port = 8080 ＃服務器HTTP端口。
server.server-header = ＃用于Server響應頭的值（如果為空，則不發(fā)送頭）。
server.use-forward-headers = ＃是否應將X-Forwarded- *標頭應用于HttpRequest。
server.servlet.context-parameters。* = ＃Servlet context init參數(shù)。
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參數(shù)。
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的最大年齡。如果未指定持續(xù)時間后綴，則將使用秒。
server.servlet.session.cookie.name = ＃會話cookie名稱。
server.servlet.session.cookie.path = ＃會話cookie的路徑。
server.servlet.session.cookie.secure =＃是否始終將會話cookie標記為安全。
server.servlet.session.persistent = false ＃是否在重新啟動之間保留會話數(shù)據(jù)。
server.servlet.session.store-dir = ＃用于存儲會話數(shù)據(jù)的目錄。
server.servlet.session.timeout = 30m ＃會話超時。如果未指定持續(xù)時間后綴，則將使用秒。
server.servlet.session.tracking-modes = ＃會話跟蹤模式。
server.ssl.ciphers = ＃支持的SSL密碼。
server.ssl.client-auth = ＃客戶端身份驗證模式。
server.ssl.enabled = true ＃是否啟用SSL支持。
server.ssl.enabled-protocols = ＃啟用SSL協(xié)議。
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協(xié)議。
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＃創(chuàng)建日志文件的目錄。可以絕對或相對于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地址，主機名，協(xié)議和端口的請求屬性。
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 方法調用之間的延遲。如果未指定持續(xù)時間后綴，則將使用秒。
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 ＃服務器在任何給定時間接受和處理的最大連接數(shù)。
server.tomcat.max-http-post-size = 2MB #HTTP 帖子內容的最大大小。
server.tomcat.max-swallow-size = 2MB ＃要吞咽的請求正文的最大數(shù)量。
server.tomcat.max-threads = 200 ＃最大工作線程數(shù)。
server.tomcat.min-spare-threads = 10 ＃最小工作線程數(shù)。
server.tomcat.port-header = X-Forwarded-Port＃用于覆蓋原始端口值的HTTP頭的名稱。
server.tomcat.protocol-header = ＃包含傳入協(xié)議的頭文件，通常命名為“X-Forwarded-Proto”。
server.tomcat.protocol-header-https-value = https ＃協(xié)議標頭的值，指示傳入請求是否使用SSL。
server.tomcat.redirect-context-root = true ＃是否應通過在路徑中附加/來重定向對上下文根的請求。
server.tomcat.remote-ip-header = ＃從中提取遠程IP的HTTP頭的名稱。例如，`X-FORWARDED-FOR`。
server.tomcat.resource.allow-caching = true＃是否允許此Web應用程序使用靜態(tài)資源緩存。
server.tomcat.resource.cache-ttl = ＃靜態(tài)資源緩存的生存時間。
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 = ＃每個緩沖區(qū)的大小。
server.undertow.direct-buffers = ＃是否在Java堆外部分配緩沖區(qū)。默認值源自JVM可用的最大內存量。
server.undertow.eager-filter-init = true ＃是否應在啟動時初始化servlet過濾器。
server.undertow.io-threads =＃為worker創(chuàng)建的I / O線程數(shù)。默認值源自可用處理器的數(shù)量。
server.undertow.max-http-post-size = -1B #HTTP 帖子內容的最大大小。當值為-1時，默認值為大小無限制。
server.undertow.worker-threads = ＃工作線程數(shù)。默認值是I / O線程數(shù)的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 ＃是否更喜歡文件系統(tǒng)訪問以進行模板加載。文件系統(tǒng)訪問可以熱檢測模板更改。
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響應發(fā)送給接受application / json的請求。
#HTTP （HttpProperties）
spring.http.converters.preferred-json-mapper = ＃用于HTTP消息轉換的首選JSON映射器。默認情況下，根據(jù)環(huán)境自動檢測。
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 ＃是否在文件或參數(shù)訪問時懶惰地解析多部分請求。
#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開/關功能的發(fā)電機。
spring.jackson.joda-date-time-format =#Joda日期時間格式字符串。如果未配置，如果使用格式字符串配置，則使用“date-format”作為后備。
spring.jackson.locale = ＃用于格式化的區(qū)域設置。
spring.jackson.mapper。* = #Jackson 通用開/關功能。
spring.jackson.parser。* = ＃Jackson開啟/關閉解析器的功能。
spring.jackson.property-naming-strategy = #Jackson PropertyNamingStrategy的常數(shù)之一。也可以是PropertyNamingStrategy子類的完全限定類名。
spring.jackson.serialization。* = #Jacker on / off功能會影響Java對象的序列化方式。
spring.jackson.time-zone =＃格式化日期時使用的時區(qū)。例如，“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 = ＃是否通過在輸出前添加一些特殊文本來生成不可執(zhí)行的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參數(shù)。
spring.jersey.servlet.load-on-startup = -1 ＃加載Jersey servlet的啟動優(yōu)先級。
spring.jersey.type = servlet ＃Jersey集成類型。
#SPRING LDAP（LdapProperties）
spring.ldap.anonymous-read-only = false ＃只讀操作是否應使用匿名環(huán)境。
spring.ldap.base = #Base 后綴，所有操作都應該來自該后綴。
spring.ldap.base-environment。* = #LDAP 規(guī)范設置。
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 ＃是否應使用請求參數(shù)（默認為“format”）來確定請求的媒體類型。
spring.mvc.contentnegotiation.favor-path-extension = false ＃是否應使用URL路徑中的路徑擴展來確定所請求的媒體類型。
spring.mvc.contentnegotiation.media-types。* = ＃映射內容協(xié)商的媒體類型的文件擴展名。例如，yml到text / yaml。
spring.mvc.contentnegotiation.parameter-name =＃啟用“favor-parameter”時要使用的查詢參數(shù)名稱。
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 = ＃要使用的語言環(huán)境。默認情況下，“Accept-Language”標頭會覆蓋此區(qū)域設置。
spring.mvc.locale-resolver = accept-header ＃定義應如何解析語言環(huán)境。
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的啟動優(yōu)先級。
spring.mvc.servlet.path = / ＃調度程序servlet的路徑。
spring.mvc.static-path-pattern = / ** ＃用于靜態(tài)資源的路徑模式。
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 = ＃應該緩存響應的最長時間，如果未指定持續(xù)時間后綴，則以秒為單位。
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 = ＃共享緩存應緩存響應的最長時間，如果未指定持續(xù)時間后綴，則以秒為單位。
spring.resources.cache.cachecontrol.stale-if-error = ＃遇到錯誤時可以使用響應的最長時間，如果未指定持續(xù)時間后綴，則以秒為單位。
spring.resources.cache.cachecontrol.stale-while-revalidate = ＃響應變?yōu)槭Ш罂梢皂憫淖铋L時間，如果未指定持續(xù)時間后綴，
則以秒為單位。spring.resources.cache.period = ＃資源處理程序所服務資源的緩存周期。如果未指定持續(xù)時間后綴，則將使用秒。
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 / ＃靜態(tài)資源的位置。
#SPRING SESSION（SessionProperties）
spring.session.store-type = ＃會話存儲類型。
spring.session.timeout = ＃會話超時。如果未指定持續(xù)時間后綴，則將使用秒。
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 表達式用于過期的會話清理作業(yè)。
spring.session.jdbc.initialize-schema = embedded ＃數(shù)據(jù)庫模式初始化模式。
spring.session.jdbc.schema = classpath中：組織/ springframework的/會話/ JDBC / schema- @ @ 平臺@ @ .SQL ＃的路徑SQL文件，以用于初始化數(shù)據(jù)庫架構。
spring.session.jdbc.table-name = SPRING_SESSION ＃用于存儲會話的數(shù)據(jù)庫表的名稱。
#SPRING SESSION MONGODB（MongoSessionProperties）
spring.session.mongodb.collection-name = sessions ＃用于存儲會話的集合名稱。
#SPRING SESSION REDIS（RedisSessionProperties）
spring.session.redis.cleanup-cron = 0 * * * * * #cron 表達式用于過期的會話清理作業(yè)。
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 ＃是否在呈現(xiàn)模板之前檢查模板是否存在。
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模式下執(zhí)行的唯一列表。
spring.thymeleaf.reactive.full-mode-view-names =＃逗號分隔的視圖名稱列表（允許的模式），即使設置了最大塊大小，也應該在FULL模式下執(zhí)行。
spring.thymeleaf.reactive.max-chunk-size = 0B ＃用于寫入響應的數(shù)據(jù)緩沖區(qū)的最大大小。
spring.thymeleaf.reactive.media-types = ＃視圖技術支持的媒體類型。
spring.thymeleaf.render-hidden-markers-before-checkboxes = false ＃是否應在復選框元素本身之前呈現(xiàn)隱藏的表單輸入作為復選框的標記。
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 = / ** ＃用于靜態(tài)資源的路徑模式。
#SPRING WEB SERVICES（WebServicesProperties）
spring.webservices.path = / services ＃作為服務基URI的路徑。
spring.webservices.servlet.init = ＃Servlet init參數(shù)傳遞給Spring Web Services。
spring.webservices.servlet.load-on-startup = -1 ＃加載Spring Web Services servlet的啟動優(yōu)先級。
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聲明為其頒發(fā)者標識符的URI。
＃----------------------------------------
＃DATA PROPERTIES
＃----- -----------------------------------
#FLYWAY （FlywayProperties）
spring.flyway.baseline-description = << Flyway Baseline >> ＃描述在應用基線時標記現(xiàn)有模式。
spring.flyway.baseline-on-migrate = false ＃是否在遷移非空架構時自動調用基線。
spring.flyway.baseline-version = 1 ＃用于在執(zhí)行基線時標記現(xiàn)有模式的版本。
spring.flyway.check-location = true ＃是否檢查遷移腳本位置是否存在。
spring.flyway.clean-disabled = false ＃是否禁用數(shù)據(jù)庫清理。
spring.flyway.clean-on-validation-error = false＃發(fā)生驗證錯誤時是否自動調用clean。
spring.flyway.connect-retries = 0 ＃嘗試連接數(shù)據(jù)庫時的最大重試次數(shù)。
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 = ＃在獲取連接后立即執(zhí)行以初始化連接的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 = ＃要遷移的數(shù)據(jù)庫的登錄密碼。
spring.flyway.placeholder-prefix = $ { ＃遷移腳本中占位符的前綴。
spring.flyway.placeholder-replacement = true ＃在遷移腳本中執(zhí)行占位符替換。
spring.flyway.placeholder-suffix =}＃遷移腳本中占位符的后綴。
spring.flyway.placeholders = ＃占位符及其替換應用于sql遷移腳本。
spring.flyway.repeatable-sql-migration-prefix = R ＃可重復SQL遷移的文件名前綴。
spring.flyway.schemas = ＃由
Flyway 管理的方案名稱（區(qū)分大小寫）。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 = 要遷移的數(shù)據(jù)庫的JDBC url。如果未設置，則使用主要配置的數(shù)據(jù)源。
spring.flyway.user = ＃要遷移的數(shù)據(jù)庫的登錄用戶。
spring.flyway.validate-on-migrate = true ＃是否在執(zhí)行遷移時自動調用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 ＃用于跟蹤并發(fā)Liquibase用法的表的名稱。
spring.liquibase.database-change-log-table = DATABASECHANGELOG ＃用于跟蹤更改歷史
記錄的表的名稱。spring.liquibase.default-模式= ＃默認數(shù)據(jù)庫架構。
spring.liquibase.drop-first = false ＃是否首先刪除數(shù)據(jù)庫模式。
spring.liquibase.enabled = true ＃是否啟用Liquibase支持。
spring.liquibase.labels = ＃逗號分隔的運行時標簽列表。
spring.liquibase.liquibase-schema = #Schema用于Liquibase對象。
spring.liquibase.liquibase-tablespace = ＃用于Liquibase對象的表空間。
spring.liquibase.parameters。* = ＃更改日志參數(shù)。
spring.liquibase.password = ＃要遷移的數(shù)據(jù)庫的登錄密碼。
spring.liquibase.rollback-file = ＃執(zhí)行更新時寫入回滾SQL的文件。
spring.liquibase.test-rollback-on-update = false ＃是否應在執(zhí)行更新之前測試回滾。
spring.liquibase.url = ＃JDBC要遷移的數(shù)據(jù)庫的URL。如果未設置，則使用主要配置的數(shù)據(jù)源。
spring.liquibase.user = ＃要遷移的數(shù)據(jù)庫的登錄用戶。
＃COUCHBASE（CouchbaseProperties）
spring.couchbase.bootstrap-hosts = #Couchbase 節(jié)點（主機或IP地址）來自引導程序。
spring.couchbase.bucket.name = default ＃要連接的存儲桶的名稱。
spring.couchbase.bucket.password =? ＃桶的密碼。
spring.couchbase.env.endpoints.key-value = 1 ＃針對鍵/值服務的每個節(jié)點的套接字數(shù)。
spring.couchbase.env.endpoints.queryservice.min-endpoints = 1 ＃每個節(jié)點的最小套接字數(shù)。
spring.couchbase.env.endpoints.queryservice.max-endpoints = 1 ＃每個節(jié)點的最大套接字數(shù)。
spring.couchbase.env.endpoints.viewservice.min-endpoints = 1 ＃每個節(jié)點的最小套接字數(shù)。
spring.couchbase.env.endpoints.viewservice.max-endpoints = 1 ＃每個節(jié)點的最大套接字數(shù)。
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 ＃對特定密鑰超時執(zhí)行的阻止操作。
spring.couchbase.env.timeouts.query = 7500ms ＃N1QL查詢操作超時。
spring.couchbase.env.timeouts.socket-connect = 1000ms #Socket 連接超時。
spring.couchbase.env.timeouts.view = 7500ms ＃常規(guī)和地理空間視圖操作超時。
#DAO （PersistenceExceptionTranslationAutoConfiguration）
spring.dao.exceptiontranslation.enabled = true ＃是否啟用PersistenceExceptionTranslationPostProcessor。
#CASSANDRA （CassandraProperties）
spring.data.cassandra.cluster-name = #Cassandra 集群的名稱。
spring.data.cassandra.compression = none ＃Cassandra二進制協(xié)議支持的壓縮。
spring.data.cassandra.connect-timeout = #Socket 選項：連接超時。
spring.data.cassandra.consistency-level = ＃查詢一致性級別。
spring.data.cassandra.contact-points = localhost ＃群集節(jié)點地址。
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，在此之后，在空閑連接上發(fā)送消息以確保它仍然存在。如果未指定持續(xù)時間后綴，則將使用秒。
spring.data.cassandra.pool.idle-timeout = 120s ＃刪除空閑連接之前的空閑超時。如果未指定持續(xù)時間后綴，則將使用秒。
spring.data.cassandra.pool.max隊列大小= 256 ＃如果沒有可用連接，則排隊的最大請求數(shù)。
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 ＃自動創(chuàng)建視圖和索引。
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 = ＃逗號分隔的集群節(jié)點地址列表。
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 = ＃認證數(shù)據(jù)庫名稱。
spring.data.mongodb.database = ＃數(shù)據(jù)庫名稱。
spring.data.mongodb.field-naming-strategy = ＃要使用的FieldNamingStrategy的完全限定名稱。
spring.data.mongodb.grid-fs-database = ＃GridFS數(shù)據(jù)庫名稱。
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數(shù)據(jù)庫URI。無法使用主機，端口和憑據(jù)進行設置。
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查詢字符串參數(shù)的名稱，指示一次返回多少結果。
spring.data.rest.max-page-size = ＃最大頁面大小。
spring.data.rest.page-param-name = #URL 查詢字符串參數(shù)的名稱，指示要返回的頁面。
spring.data.rest.return-body-on-create = ＃是否在創(chuàng)建實體后返回響應正文。
spring.data.rest.return-body-on-update = ＃更新實體后是否返回響應正文。
spring.data.rest.sort-param-name = #URL 查詢字符串參數(shù)的名稱，指示對結果進行排序的方向。
#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 ＃頁面索引參數(shù)名稱。
spring.data.web.pageable.prefix = ＃
常用前綴，用于頁碼和頁面大小參數(shù)。spring.data.web.pageable.qualifier-delimiter = _＃限定符與實際頁碼和大小屬性之間使用的分隔符。
spring.data.web.pageable.size-parameter = size ＃頁面大小參數(shù)名稱。
spring.data.web.sort.sort-parameter = sort ＃排序參數(shù)名稱。
#DATASOURCE （DataSourceAutoConfiguration＆DataSourceProperties）
spring.datasource.continue-on-error = false ＃初始化數(shù)據(jù)庫時是否發(fā)生錯誤時停止。
spring.datasource.data = #Data （DML）腳本資源引用。
spring.datasource.data-username = ＃用于執(zhí)行DML腳本的數(shù)據(jù)庫
的用戶名（如果不同）。spring.datasource.data-password = ＃執(zhí)行DML腳本的數(shù)據(jù)庫的密碼（如果不同）。
spring.datasource.dbcp2。* = ＃Commons DBCP2特定設置
spring.datasource.driver-class-name =#JDBC驅動程序的完全限定名稱。默認情況下，基于URL自動檢測。
spring.datasource.generate-unique-name = false ＃是否生成隨機數(shù)據(jù)源名稱。
spring.datasource.hikari。* = ＃Hikari特定設置
spring.datasource.initialization-mode = embedded ＃使用可用的DDL和DML腳本初始化數(shù)據(jù)源。
spring.datasource.jmx-enabled = false ＃是否啟用JMX支持（如果由基礎池提供）。
spring.datasource.jndi-name = ＃JNDI數(shù)據(jù)源的位置。設置時將忽略類，URL，用戶名和密碼。
spring.datasource.name =＃數(shù)據(jù)源的名稱。使用嵌入式數(shù)據(jù)庫時默認為“testdb”。
spring.datasource.password = ＃數(shù)據(jù)庫的登錄密碼。
spring.datasource.platform = all ＃在DDL或DML腳本中使用的平臺（例如架構 -? $ {platform} .sql或data? -? $ {platform} .sql）。
spring.datasource.schema = #Schema （DDL）腳本資源引用。
spring.datasource.schema-username = ＃執(zhí)行DDL腳本的數(shù)據(jù)庫
的用戶名（如果不同）。spring.datasource.schema-password = ＃執(zhí)行DDL腳本的數(shù)據(jù)庫的密碼（如果不同）。
spring.datasource.separator =;#SQL初始化腳本中的語句分隔符。
spring.datasource.sql-script-encoding = #SQL 腳本編碼。
spring.datasource.tomcat。* = ＃Tomcat數(shù)據(jù)源特定設置
spring.datasource.type = ＃要使用的連接池實現(xiàn)的完全限定名稱。默認情況下，它是從類路徑中自動檢測到的。
spring.datasource.url = ＃JDBC數(shù)據(jù)庫的URL。
spring.datasource.username = ＃登錄數(shù)據(jù)庫的用戶名。
spring.datasource.xa.data-source-class-name = #XA 數(shù)據(jù)源完全限定名稱。
spring.datasource.xa.properties =＃傳遞給XA數(shù)據(jù)源的屬性。
