SpringBoot常用属性配置

 SpringBoot常用属性配置

• Application.properties

# =================================================================== 
# 通用SpringBoot属性
# =================================================================== 


# ---------------------------------------- 
# 核心属性
# ---------------------------------------- 
debug=false #启用调试日志。.
trace=false # 启用跟踪日志. 

#日志记录
#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.path=#日志文件的位置。例如，`/var/log`。
#logging.pattern.console=#将模式输出到控制台。仅支持默认的日志恢复设置。
#logging.pattern.date format=yyyy-mm-dd hh:mm:ss.sss#日志日期格式的追加器模式。仅支持默认的日志恢复设置。
#logging.pattern.file=#输出到文件的追加程序模式。仅支持默认的日志恢复设置。#logging.pattern.level=%5p#日志级别的追加程序模式。仅支持默认的日志恢复设置。#logging.register shutdown hook=false#在日志系统初始化时为其注册一个关闭钩子。

# AOP 
#spring.aop.auto=true #添加@enablespectjautoproxy。
#spring.aop.proxy-target-class＝True #是否创建基于子类的（CGLIB）代理，而不是基于JAVA标准接口代理（FALSE）。

# IDENTITY (ContextIdApplicationContextInitializer) 
spring.application.name= # 应用程序名称. 

# ADMIN (SpringApplicationAdminJmxAutoConfiguration) 
spring.application.admin.enabled=false # 是否为应用程序启用管理功能. 
spring.application.admin.jmx-name=org.springframework.boot:type=Admin,name=SpringApplication #应用程序admin mbean的jmx名称. 

# 自动配置 
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= #横幅图像的高度（以字符为单位）（默认值基于图像高度）. 
spring.banner.image.margin=2 # 以字符表示的左侧图像边距. 
spring.banner.image.invert=false # 是否应为深色终端主题反转图像. 

# Spring核心 
spring.beaninfo.ignore=true # 是否跳过beaninfo类的搜索. 

# Spring缓存 (缓存配置) 
spring.cache.cache-names= # 要创建的缓存名称的逗号分隔列表（如果基础缓存管理器支持）spring.cache.caffeine.spec= # 用于创建缓存的规范。有关规范格式的详细信息，请参见caffinespec. 
spring.cache.couchbase.expiration= # 条目过期。默认情况下，条目永不过期。请注意，此值最终转换为秒. 
spring.cache.ehcache.config= # 用于初始化ehcache的配置文件的位置. 
spring.cache.infinispan.config= # 用于初始化infinispan的配置文件的位置. 
spring.cache.jcache.config= # 用于初始化缓存管理器的配置文件的位置. 
spring.cache.jcache.provider= # 用于检索符合jsr-107的缓存管理器的cachingprovider实现的完全限定名。仅当类路径上有多个jsr-107实现可用时才需要. 
spring.cache.redis.cache-null-values=true # 允许缓存空值. 
spring.cache.redis.key-prefix= # Key 前缀. 
spring.cache.redis.time-to-live= #条目过期。默认情况下，条目永不过期. 
spring.cache.redis.use-key-prefix=true # 写入redis时是否使用key前缀. 
spring.cache.type= # 缓存类型。默认情况下，根据环境自动检测. 

# Spring配置 - 仅使用环境属性 (ConfigFileApplicationListener) 
spring.config.additional-location= # 除了默认值之外，还使用配置文件位置. 
spring.config.location= # 替换默认值的配置文件位置. 
spring.config.name=application # 配置文件名称. 

# HAZELCAST (Hazelcast配置) 
spring.hazelcast.config= # 用于初始化Hazelcast的配置文件的位置. 

#项目信息（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=classpath:git.properties #生成的git.properties文件的位置. 

# JMX 
spring.jmx.default-domain= # JMX域名. 
spring.jmx.enabled=true #向jmx域公开管理bean. 
spring.jmx.server=mbeanServer # MBeanServer bean名称. 
spring.jmx.unique-names=false #是否应确保唯一的运行时对象名. 

# Email (MailProperties) 
spring.mail.default-encoding=UTF-8 # Default MimeMessage 编码. 
spring.mail.host= # SMTP服务器主机。例如, `smtp.example.com`. 
spring.mail.jndi-name= # Session 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服务器的登录用户. 

# 应用设置 (SpringApplication) 
spring.main.allow-bean-definition-overriding=false # 是否允许通过定义与现有定义同名的定义来定义bean定义。. 
spring.main.banner-mode=console # 用于在应用程序运行时显示横幅的模式. 
spring.main.sources= # 要包含在applicationcontext中的源（类名、包名或xml资源位置）. 
spring.main.web-application-type= # 用于显式请求特定类型的Web应用程序的标志。如果未设置，则根据类路径自动检测。 

# 文件字符编码 (FileEncodingApplicationListener) 
spring.mandatory-file-encoding= # 应用程序必须使用的预期字符编码. 

# 国际化（MessageSourceProperties）
spring.messages.always-use-message-format=false # 是否始终应用MessageFormat规则，甚至解析没有参数的消息。. 
spring.messages.basename=messages # 以逗号分隔的基名列表（本质上是一个完全限定的类路径位置），每个基名都遵循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”。仅在开发期间推荐. 

# 输出 
spring.output.ansi.enabled=detect # 配置ANSI输出 

# PID文件（ApplicationPidFileWriter）
spring.pid.fail-on-write-error= # 如果使用applicationpidfilewriter但无法写入pid文件，则失败. 
spring.pid.file= # 要写入的pid文件的位置（如果使用applicationpidfilewriter）。 

# 配置文件 
spring.profiles.active= # 活动配置文件的逗号分隔列表。可由命令行开关重写. 
spring.profiles.include= # 无条件激活指定的以逗号分隔的配置文件列表（如果使用yaml，则为配置文件列表）. 

# 定时调度 (QuartzProperties) 
spring.quartz.auto-startup=true # 初始化后是否自动启动计划程序. 
spring.quartz.jdbc.comment-prefix=-- # SQL初始化脚本中单行注释的前缀. 
spring.quartz.jdbc.initialize-schema=embedded # Database schema 初始化模式. 
spring.quartz.jdbc.schema=classpath:org/quartz/impl/jdbcjobstore/tables_@@platform@@.sql #用于初始化Database schema的SQL文件的路径. 
spring.quartz.job-store-type=memory # 定时作业存储类型. 
spring.quartz.overwrite-existing-jobs=false #配置的作业是否应覆盖现有作业定义. 
spring.quartz.properties.*= #其他定时调度程序属性. 
spring.quartz.scheduler-name=quartzScheduler #调度员名称. 
spring.quartz.startup-delay=0s #初始化完成后启动计划程序的延迟. 
spring.quartz.wait-for-jobs-to-complete-on-shutdown=false #是否等待关闭时运行的作业完成. 

# 反应器 (ReactorCoreProperties) 
spring.reactor.stacktrace-mode.enabled=false # reactor是否应该在运行时收集stacktrace信息. 

#发送网格(SendGridAutoConfiguration) 
spring.sendgrid.api-key= # SendGrid API密钥. 
spring.sendgrid.proxy.host= # SendGrid代理主机. 
spring.sendgrid.proxy.port= # SendGrid代理端口. 

#任务执行(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= #队列容量。无限容量不会增加池，因此会忽略“最大-大小”属性。 
spring.task.execution.thread-name-prefix=task- #用于新创建线程的名称的前缀。. 

#任务调度(TaskSchedulingProperties) 
spring.task.scheduling.pool.size=1 #允许的最大线程数. 
spring.task.scheduling.thread-name-prefix=scheduling- #用于新创建线程名称的前缀. 

# ---------------------------------------- 
# Web属性 配置
# ---------------------------------------- 

#嵌入式服务器配置(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 #执行压缩所需的最小“内容-长度”值. 
server.connection-timeout= #连接器在关闭连接之前等待另一个http请求的时间。未设置时，将使用连接器的容器特定默认值。使用-1值表示没有（即无限）超时. 
server.error.include-exception=false #包含“异常”属性. 
server.error.include-stacktrace=never #何时包含“stacktrace”属性. 
server.error.path=/error #错误控制器的路径 
server.error.whitelabel.enabled=true #服务器出错时是否启用浏览器中显示的默认错误页. 
server.http2.enabled=false #如果当前环境支持，是否启用http/2支持. 

server.max-http-header-size=8KB # http消息头的最大大小. 
server.port=8080 #服务器http端口。. 
server.server-header= #用于服务器响应头的值（如果为空，则不发送头）。. 
server.use-forward-headers= #是否应将x-forwarded-*头应用于httprequest。. 
server.servlet.context-parameters.*= # Servlet上下文初始化参数. 
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= # session cookie的注释. 
server.servlet.session.cookie.domain= # session cookie的域. 
server.servlet.session.cookie.http-only= #是否对session cookies使用“httponly”cookies. 
server.servlet.session.cookie.max-age= # session cookie的最长使用期限。如果未指定持续时间后缀，则将使用秒数。 
server.servlet.session.cookie.name= # Session cookie 名称. 
server.servlet.session.cookie.path= # session cookie的路径. 
server.servlet.session.cookie.secure= #是否始终将session 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.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-Port #包含传入协议的头，通常命名为“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= #访问日志目录下. 
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= #要为工作线程创建的I/O线程数。默认值来自可用处理器的数量。server.undertow.max-http-post-size=-1B # http post内容的最大大小。默认值为-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 #内容类型值. 
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 #是否以“spring macro requestcontext”的名称公开requestcontext供spring的宏库使用 
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= #可以解析的视图名称的白名单。. 

# 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= #要在其中编码映射的区域设置. 
spring.http.log-request-details=false #是否允许在调试和跟踪级别记录（可能敏感的）请求详细信息。. 

# 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's 财产管理的一个常数。也可以是propertynamingstrategy子类的完全限定类名. 
spring.jackson.serialization.*= # jackson on/off特性影响java对象的序列化方式 
spring.jackson.time-zone= #格式化日期时使用的时区。例如，“中国/北京”或“GMT+8”. 
spring.jackson.visibility.*= # jackson可见性阈值，可用于限制自动检测哪些方法（和字段）. 

# GSON (GsonProperties) 
spring.gson.date-format= #序列化日期对象时使用的格式. 
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是否宽容. 
spring.gson.long-serialization-policy= # Long 类型和long 类型的序列化策略. 
spring.gson.pretty-printing= #是否输出适合页面打印的序列化json. 
spring.gson.serialize-nulls= #是否序列化空字段. 

# JERSEY (JerseyProperties) 
spring.jersey.application-path= # Path that serves as the base URI for the application. If specified, overrides the value of "@ApplicationPath". 
spring.jersey.filter.order=0 # Jersey filter chain order. 
spring.jersey.init.*= # Init parameters to pass to Jersey through the servlet or filter. 
spring.jersey.servlet.load-on-startup=-1 # Load on startup priority of the Jersey servlet. 
spring.jersey.type=servlet # Jersey integration type. 

# SPRING LDAP (LdapProperties) 
spring.ldap.anonymous-read-only=false #只读操作是否应使用匿名环境. 
spring.ldap.base= #所有操作都应源自的基本后缀. 
spring.ldap.base-environment.*= # LDAP规范设置. 
spring.ldap.password= #服务器登录密码. 
spring.ldap.urls= #服务器的LDAP URL. 
spring.ldap.username= #服务器的登录用户名. 

#嵌入的LDAP (EmbeddedLdapProperties) 
spring.ldap.embedded.base-dn= #基本DNS列表. 
spring.ldap.embedded.credential.username= #嵌入式LDAP用户名. 
spring.ldap.embedded.credential.password= #嵌入式LDAP密码. 
spring.ldap.embedded.ldif=classpath:schema.ldif #架构（LDIF）脚本资源引用。spring.ldap.embedded.port=0#嵌入式LDAP端口. 
spring.ldap.embedded.validation.enabled=true #是否启用LDAP架构验证. 
spring.ldap.embedded.validation.schema= #自定义架构的路径. 


# 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 # 是否将跟踪请求分派到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 # 重定向场景期间是否应忽略“default”模型的内容. 
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= # 消息代码的格式化策略。例如，“前缀错误代码”`. 
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 # dispatcher servlet的启动时加载优先级. 
spring.mvc.servlet.path=/ #调度伺服路径. 
spring.mvc.static-path-pattern=/** #用于静态资源的路径模式. 
spring.mvc.throw-exception-if-no-handler-found=false #如果找不到处理请求的处理程序，是否应引发“Nohandlerfoundexception. 
spring.mvc.view.prefix= # Spring MVC视图前缀. 
spring.mvc.view.suffix= # Spring MVC 视图后缀. 

# Spring 资源处理 (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 #会话刷新模式. 
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 # Database schema初始化模式. 
spring.session.jdbc.schema=classpath:org/springframework/session/jdbc/schema-@@platform@@.sql # 用于初始化Database schema的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 # 会话刷新模式. 
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 # 在springeEL表达式中启用springeEL编译器. 
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= # 以逗号分隔的视图名称列表（允许模式），在设置最大块大小时，该列表应是在分块模式下执行的唯一视图名称. 
spring.thymeleaf.reactive.full-mode-view-names= # 即使设置了最大块大小，也应在完整模式下执行的以逗号分隔的视图名称列表（允许模式）. 
spring.thymeleaf.reactive.max-chunk-size=0B # 用于写入响应的数据缓冲区的最大大小. 
spring.thymeleaf.reactive.media-types= # 视图技术支持的媒体类型. 
spring.thymeleaf.render-hidden-markers-before-checkboxes=false # 作为复选框标记的隐藏表单输入是否应在checkbox元素本身之前呈现. 
spring.thymeleaf.servlet.content-type=text/html # 写入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= # 要传递给spring web服务的servlet init参数. 
spring.webservices.servlet.load-on-startup=-1 # spring web服务servlet的启动时加载优先级. 
spring.webservices.wsdl-locations= # 以逗号分隔的wsdl和将作为bean公开的随附xsd的位置列表. 


# ---------------------------------------- 
# 安全属性配置 
# ---------------------------------------- 
# 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 客户端 (OAuth2ClientProperties) 
spring.security.oauth2.client.provider.*= # OAuth提供程序详细信息. 
spring.security.oauth2.client.registration.*= # OAuth客户端注册. 

# Security OAUTH2 资源服务器 (OAuth2ResourceServerProperties) 
spring.security.oauth2.resourceserver.jwt.jwk-set-uri= #用于验证jwt令牌的json web密钥uri. 
spring.security.oauth2.resourceserver.jwt.issuer-uri= # OpenID 连接提供程序断言为其颁发者标识符的uri。. 

# ---------------------------------------- 
# DATA PROPERTIES 
# ---------------------------------------- 

# ELASTICSEARCH (ElasticsearchProperties) 
spring.data.elasticsearch.cluster-name=elasticsearch # Elasticsearch cluster name. 
spring.data.elasticsearch.cluster-nodes= # Comma-separated list of cluster node addresses. 
spring.data.elasticsearch.properties.*= # Additional properties used to configure the client. 
spring.data.elasticsearch.repositories.enabled=true # Whether to enable Elasticsearch repositories. 

# 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存储库. 

# Data Rest (RepositoryRestProperties) 
spring.data.rest.base-path= # spring数据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. Ignored if "zk-host" is set. 
spring.data.solr.repositories.enabled=true # Whether to enable Solr repositories. 
spring.data.solr.zk-host= # ZooKeeper host address in the form HOST:PORT. 

# Data Web (SpringDataWebProperties) 
spring.data.web.pageable.default-page-size=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 #排序参数名称. 

# DataSources (DataSourceAutoConfiguration & DataSourceProperties) 
spring.datasource.continue-on-error=false #如果初始化数据库时出错，是否停止. 
spring.datasource.data= #数据（DML）脚本资源引用. 
spring.datasource.data-username= #执行DML脚本的数据库的用户名（如果不同）. 
spring.datasource.data-password= #执行DML脚本的数据库密码（如果不同）. 
spring.datasource.dbcp2.*= # 通用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脚本中使用的平台（例如schema-${platform}.sql或data-${platform}.sql）. 
spring.datasource.schema= # Schema (DDL) （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 client) (JestProperties) 
spring.elasticsearch.jest.connection-timeout=3s # Connection timeout. 
spring.elasticsearch.jest.multi-threaded=true # Whether to enable connection requests from multiple execution threads. 
spring.elasticsearch.jest.password= # Login password. 
spring.elasticsearch.jest.proxy.host= # Proxy host the HTTP client should use. 
spring.elasticsearch.jest.proxy.port= # Proxy port the HTTP client should use. 
spring.elasticsearch.jest.read-timeout=3s # Read timeout. 
spring.elasticsearch.jest.uris=http://localhost:9200 # Comma-separated list of the Elasticsearch instances to use. 
spring.elasticsearch.jest.username= # Login username. 

# Elasticsearch REST clients (RestClientProperties) 
spring.elasticsearch.rest.password= # Credentials password. 
spring.elasticsearch.rest.uris=http://localhost:9200 # Comma-separated list of the Elasticsearch instances to use. 
spring.elasticsearch.rest.username= # Credentials username. 

# H2 Web Console (H2ConsoleProperties) 
spring.h2.console.enabled=false # Whether to enable the console. 
spring.h2.console.path=/h2-console # Path at which the console is available. 
spring.h2.console.settings.trace=false # Whether to enable trace output. 
spring.h2.console.settings.web-allow-others=false # Whether to enable remote access. 

# InfluxDB (InfluxDbProperties) 
spring.influx.password= # Login password. 
spring.influx.url= # URL of the InfluxDB instance to which to connect. 
spring.influx.user= # Login user. 

# JOOQ (JooqProperties) 
spring.jooq.sql-dialect= # SQL dialect to use. Auto-detected by default. 

# 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 # jpa存储库的引导模式. 
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= #映射资源（相当于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 # Whether to enable JTA support. 
spring.jta.log-dir= # Transaction logs directory. 
spring.jta.transaction-manager-id= # Transaction manager unique identifier. 


# REDIS (RedisProperties) 
spring.redis.cluster.max-redirects= # Maximum number of redirects to follow when executing commands across the cluster. 
spring.redis.cluster.nodes= # Comma-separated list of "host:port" pairs to bootstrap from. 
spring.redis.database=0 # Database index used by the connection factory. 
spring.redis.url= # Connection URL. Overrides host, port, and password. User is ignored. Example: redis://user:password@example.com:6379 
spring.redis.host=localhost # Redis server host. 
spring.redis.jedis.pool.max-active=8 # Maximum number of connections that can be allocated by the pool at a given time. Use a negative value for no limit. 
spring.redis.jedis.pool.max-idle=8 # Maximum number of "idle" connections in the pool. Use a negative value to indicate an unlimited number of idle connections. 
spring.redis.jedis.pool.max-wait=-1ms # Maximum amount of time a connection allocation should block before throwing an exception when the pool is exhausted. Use a negative value to block indefinitely. 
spring.redis.jedis.pool.min-idle=0 # Target for the minimum number of idle connections to maintain in the pool. This setting only has an effect if it is positive. 
spring.redis.lettuce.pool.max-active=8 # Maximum number of connections that can be allocated by the pool at a given time. Use a negative value for no limit. 
spring.redis.lettuce.pool.max-idle=8 # Maximum number of "idle" connections in the pool. Use a negative value to indicate an unlimited number of idle connections. 
spring.redis.lettuce.pool.max-wait=-1ms # Maximum amount of time a connection allocation should block before throwing an exception when the pool is exhausted. Use a negative value to block indefinitely. 
spring.redis.lettuce.pool.min-idle=0 # Target for the minimum number of idle connections to maintain in the pool. This setting only has an effect if it is positive. 
spring.redis.lettuce.shutdown-timeout=100ms # Shutdown timeout. 
spring.redis.password= # Login password of the redis server. 
spring.redis.port=6379 # Redis server port. 
spring.redis.sentinel.master= # Name of the Redis server. 
spring.redis.sentinel.nodes= # Comma-separated list of "host:port" pairs. 
spring.redis.ssl=false # Whether to enable SSL support. 
spring.redis.timeout= # Connection timeout. 

# 事务 (TransactionProperties) 
spring.transaction.default-timeout= #默认事务超时。如果未指定持续时间后缀，则将使用秒. 
spring.transaction.rollback-on-commit-failure= #是否在提交失败时回滚. 



# ---------------------------------------- 
# INTEGRATION PROPERTIES 
# ---------------------------------------- 

# ACTIVEMQ (ActiveMQProperties) 
spring.activemq.broker-url= # URL of the ActiveMQ broker. Auto-generated by default. 
spring.activemq.close-timeout=15s # Time to wait before considering a close complete. 
spring.activemq.in-memory=true # Whether the default broker URL should be in memory. Ignored if an explicit broker has been specified. 
spring.activemq.non-blocking-redelivery=false # Whether to stop message delivery before re-delivering messages from a rolled back transaction. This implies that message order is not preserved when this is enabled. 
spring.activemq.password= # Login password of the broker. 
spring.activemq.send-timeout=0ms # Time to wait on message sends for a response. Set it to 0 to wait forever. 
spring.activemq.user= # Login user of the broker. 
spring.activemq.packages.trust-all= # Whether to trust all packages. 
spring.activemq.packages.trusted= # Comma-separated list of specific packages to trust (when not trusting all packages). 
spring.activemq.pool.block-if-full=true # Whether to block when a connection is requested and the pool is full. Set it to false to throw a "JMSException" instead. 
spring.activemq.pool.block-if-full-timeout=-1ms # Blocking period before throwing an exception if the pool is still full. 
spring.activemq.pool.enabled=false # Whether a JmsPoolConnectionFactory should be created, instead of a regular ConnectionFactory. 
spring.activemq.pool.idle-timeout=30s # Connection idle timeout. 
spring.activemq.pool.max-connections=1 # Maximum number of pooled connections. 
spring.activemq.pool.max-sessions-per-connection=500 # Maximum number of pooled sessions per connection in the pool. 
spring.activemq.pool.time-between-expiration-check=-1ms # Time to sleep between runs of the idle connection eviction thread. When negative, no idle connection eviction thread runs. 
spring.activemq.pool.use-anonymous-producers=true # Whether to use only one anonymous "MessageProducer" instance. Set it to false to create one "MessageProducer" every time one is required. 

# JMS (JmsProperties) 
spring.jms.cache.consumers=false # Whether to cache message consumers. 
spring.jms.cache.enabled=true # Whether to cache sessions. 
spring.jms.cache.producers=true # Whether to cache message producers. 
spring.jms.cache.session-cache-size=1 # Size of the session cache (per JMS Session type). 
spring.jms.jndi-name= # Connection factory JNDI name. When set, takes precedence to others connection factory auto-configurations. 
spring.jms.listener.acknowledge-mode= # Acknowledge mode of the container. By default, the listener is transacted with automatic acknowledgment. 
spring.jms.listener.auto-startup=true # Start the container automatically on startup. 
spring.jms.listener.concurrency= # Minimum number of concurrent consumers. 
spring.jms.listener.max-concurrency= # Maximum number of concurrent consumers. 
spring.jms.pub-sub-domain=false # Whether the default destination type is topic. 
spring.jms.template.default-destination= # Default destination to use on send and receive operations that do not have a destination parameter. 
spring.jms.template.delivery-delay= # Delivery delay to use for send calls. 
spring.jms.template.delivery-mode= # Delivery mode. Enables QoS (Quality of Service) when set. 
spring.jms.template.priority= # Priority of a message when sending. Enables QoS (Quality of Service) when set. 
spring.jms.template.qos-enabled= # Whether to enable explicit QoS (Quality of Service) when sending a message. 
spring.jms.template.receive-timeout= # Timeout to use for receive calls. 
spring.jms.template.time-to-live= # Time-to-live of a message when sending. Enables QoS (Quality of Service) when set. 


# RABBIT (RabbitProperties) 
spring.rabbitmq.addresses= # Comma-separated list of addresses to which the client should connect. 
spring.rabbitmq.cache.channel.checkout-timeout= # Duration to wait to obtain a channel if the cache size has been reached. 
spring.rabbitmq.cache.channel.size= # Number of channels to retain in the cache. 
spring.rabbitmq.cache.connection.mode=channel # Connection factory cache mode. 
spring.rabbitmq.cache.connection.size= # Number of connections to cache. 
spring.rabbitmq.connection-timeout= # Connection timeout. Set it to zero to wait forever. 
spring.rabbitmq.dynamic=true # Whether to create an AmqpAdmin bean. 
spring.rabbitmq.host=localhost # RabbitMQ host. 
spring.rabbitmq.listener.direct.acknowledge-mode= # Acknowledge mode of container. 
spring.rabbitmq.listener.direct.auto-startup=true # Whether to start the container automatically on startup. 
spring.rabbitmq.listener.direct.consumers-per-queue= # Number of consumers per queue. 
spring.rabbitmq.listener.direct.default-requeue-rejected= # Whether rejected deliveries are re-queued by default. 
spring.rabbitmq.listener.direct.idle-event-interval= # How often idle container events should be published. 
spring.rabbitmq.listener.direct.missing-queues-fatal=false # Whether to fail if the queues declared by the container are not available on the broker. 
spring.rabbitmq.listener.direct.prefetch= # Maximum number of unacknowledged messages that can be outstanding at each consumer. 
spring.rabbitmq.listener.direct.retry.enabled=false # Whether publishing retries are enabled. 
spring.rabbitmq.listener.direct.retry.initial-interval=1000ms # Duration between the first and second attempt to deliver a message.
spring.rabbitmq.listener.direct.retry.max-attempts=3 # Maximum number of attempts to deliver a message. 
spring.rabbitmq.listener.direct.retry.max-interval=10000ms # Maximum duration between attempts. 
spring.rabbitmq.listener.direct.retry.multiplier=1 # Multiplier to apply to the previous retry interval. 
spring.rabbitmq.listener.direct.retry.stateless=true # Whether retries are stateless or stateful. 
spring.rabbitmq.listener.simple.acknowledge-mode= # Acknowledge mode of container. 
spring.rabbitmq.listener.simple.auto-startup=true # Whether to start the container automatically on startup. 
spring.rabbitmq.listener.simple.concurrency= # Minimum number of listener invoker threads. 
spring.rabbitmq.listener.simple.default-requeue-rejected= # Whether rejected deliveries are re-queued by default. 
spring.rabbitmq.listener.simple.idle-event-interval= # How often idle container events should be published. 
spring.rabbitmq.listener.simple.max-concurrency= # Maximum number of listener invoker threads. 
spring.rabbitmq.listener.simple.missing-queues-fatal=true # Whether to fail if the queues declared by the container are not available on the broker and/or whether to stop the container if one or more queues are deleted at runtime. 
spring.rabbitmq.listener.simple.prefetch= # Maximum number of unacknowledged messages that can be outstanding at each consumer. 
spring.rabbitmq.listener.simple.retry.enabled=false # Whether publishing retries are enabled. 
spring.rabbitmq.listener.simple.retry.initial-interval=1000ms # Duration between the first and second attempt to deliver a message. 
spring.rabbitmq.listener.simple.retry.max-attempts=3 # Maximum number of attempts to deliver a message. 
spring.rabbitmq.listener.simple.retry.max-interval=10000ms # Maximum duration between attempts. 
spring.rabbitmq.listener.simple.retry.multiplier=1 # Multiplier to apply to the previous retry interval. 
spring.rabbitmq.listener.simple.retry.stateless=true # Whether retries are stateless or stateful. 
spring.rabbitmq.listener.simple.transaction-size= # Number of messages to be processed between acks when the acknowledge mode is AUTO. If larger than prefetch, prefetch will be increased to this value. 
spring.rabbitmq.listener.type=simple # Listener container type. 
spring.rabbitmq.password=guest # Login to authenticate against the broker. 
spring.rabbitmq.port=5672 # RabbitMQ port. 
spring.rabbitmq.publisher-confirms=false # Whether to enable publisher confirms. 
spring.rabbitmq.publisher-returns=false # Whether to enable publisher returns. 
spring.rabbitmq.requested-heartbeat= # Requested heartbeat timeout; zero for none. If a duration suffix is not specified, seconds will be used. 
spring.rabbitmq.ssl.algorithm= # SSL algorithm to use. By default, configured by the Rabbit client library. 
spring.rabbitmq.ssl.enabled=false # Whether to enable SSL support. 
spring.rabbitmq.ssl.key-store= # Path to the key store that holds the SSL certificate. 
spring.rabbitmq.ssl.key-store-password= # Password used to access the key store. 
spring.rabbitmq.ssl.key-store-type=PKCS12 # Key store type. 
spring.rabbitmq.ssl.trust-store= # Trust store that holds SSL certificates. 
spring.rabbitmq.ssl.trust-store-password= # Password used to access the trust store. 
spring.rabbitmq.ssl.trust-store-type=JKS # Trust store type. 
spring.rabbitmq.ssl.validate-server-certificate=true # Whether to enable server side certificate validation. 
spring.rabbitmq.ssl.verify-hostname=true # Whether to enable hostname verification. 
spring.rabbitmq.template.default-receive-queue= # Name of the default queue to receive messages from when none is specified explicitly. 
spring.rabbitmq.template.exchange= # Name of the default exchange to use for send operations. 
spring.rabbitmq.template.mandatory= # Whether to enable mandatory messages. 
spring.rabbitmq.template.receive-timeout= # Timeout for `receive()` operations. 
spring.rabbitmq.template.reply-timeout= # Timeout for `sendAndReceive()` operations. 
spring.rabbitmq.template.retry.enabled=false # Whether publishing retries are enabled. 
spring.rabbitmq.template.retry.initial-interval=1000ms # Duration between the first and second attempt to deliver a message. 
spring.rabbitmq.template.retry.max-attempts=3 # Maximum number of attempts to deliver a message. 
spring.rabbitmq.template.retry.max-interval=10000ms # Maximum duration between attempts. 
spring.rabbitmq.template.retry.multiplier=1 # Multiplier to apply to the previous retry interval. 
spring.rabbitmq.template.routing-key= # Value of a default routing key to use for send operations. 
spring.rabbitmq.username=guest # Login user to authenticate to the broker. 
spring.rabbitmq.virtual-host= # Virtual host to use when connecting to the broker. 



# ---------------------------------------- 
# DEVTOOLS PROPERTIES 
# ---------------------------------------- 

# DEVTOOLS (DevToolsProperties) 
spring.devtools.add-properties=true # Whether to enable development property defaults. 
spring.devtools.livereload.enabled=true # Whether to enable a livereload.com-compatible server. 
spring.devtools.livereload.port=35729 # Server port. 
spring.devtools.restart.additional-exclude= # Additional patterns that should be excluded from triggering a full restart. 
spring.devtools.restart.additional-paths= # Additional paths to watch for changes. 
spring.devtools.restart.enabled=true # Whether to enable automatic restart. 
spring.devtools.restart.exclude=META-INF/maven/**,META-INF/resources/**,resources/**,static/**,public/**,templates/**,**/*Test.class,**/*Tests.class,git.properties,META-INF/build-info.properties # Patterns that should be excluded from triggering a full restart. 
spring.devtools.restart.log-condition-evaluation-delta=true # Whether to log the condition evaluation delta upon restart. 
spring.devtools.restart.poll-interval=1s # Amount of time to wait between polling for classpath changes. 
spring.devtools.restart.quiet-period=400ms # Amount of quiet time required without any classpath changes before a restart is triggered. 
spring.devtools.restart.trigger-file= # Name of a specific file that, when changed, triggers the restart check. If not specified, any classpath file change triggers the restart. 

# REMOTE DEVTOOLS (RemoteDevToolsProperties) 
spring.devtools.remote.context-path=/.~~spring-boot!~ # Context path used to handle the remote connection. 
spring.devtools.remote.proxy.host= # The host of the proxy to use to connect to the remote application. 
spring.devtools.remote.proxy.port= # The port of the proxy to use to connect to the remote application. 
spring.devtools.remote.restart.enabled=true # Whether to enable remote restart. 
spring.devtools.remote.secret= # A shared secret required to establish a connection (required to enable remote support). 
spring.devtools.remote.secret-header-name=X-AUTH-TOKEN # HTTP header used to transfer the shared secret. 


# ---------------------------------------- 
# TESTING PROPERTIES 
# ---------------------------------------- 

spring.test.database.replace=any # Type of existing DataSource to replace. 
spring.test.mockmvc.print=default # MVC Print option.