SpringBoot相关组件详细配置信息

Hibernate

使用HibernateORM需要引入以下的包：

spring-boot-starter-data-jpa
mysql-connector-java

下面是Hibernate的详细配置信息：

#数据库使用的驱动类
hibernate.connection.driver_class=com.mysql.jdbc.Driver
#数据库连接地址
hibernate.connection.url=jdbc:mysql://localhost:3306/db
#数据库连接的用户名
hibernate.connection.username=user
#数据库连接的密码
hibernate.connection.password=password
#使用JNDI数据源连接数据库 -> 请看下一个JNDI配置
hibernate.connection.datasource=java:comp/env/jdbc/TestDb
#数据库使用的方言，将操作转为对应的SQL语句
hibernate.dialect=net.sf.hibernate.dialect.MySQLDialect
#是否打印SQL语句
hibernate.show_sql=true
javax.persistence.validation.mode=none
#在 log 和 console 中打印出更漂亮的 SQL语句
hibernate.format_sql=true
#设置在Hibernate数据库连接池中的连接数量，这里我们一般使用c3p0连接池
hibernate.connection.pool_size=3

---

JNDI数据源

在Tomcat服务器的对应lib中添加所有的数据库连接驱动包

修改Tomcat服务器中的server.xml配置文件

在server.xml文件中，添加JNDI全局数据源。

<!-- Global JNDI resources 
      Documentation at /docs/jndi-resources-howto.html
   -->
<GlobalNamingResources>
    <!-- Editable user database that can also be used by 
        UserDatabaseRealm to authenticate users 
     -->

    <Resource name="UserDatabase" auth="Container"
        type="org.apache.catalina.UserDatabase"
        description="User database that can be updated and saved"
        factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
        pathname="conf/tomcat-users.xml" />
	<!--
	|- name：表示以后要查找的名称。通过此名称可以找到DataSource，此名称任意更换，但是程序中最终要查找的就是此名称， 
	为了不与其他的名称混淆，所以使用jdbc/oracle，现在配置的是一个jdbc的关于oracle的命名服务。 
	|- auth：由容器进行授权及管理，指的用户名和密码是否可以在容器上生效 
	|- type：此名称所代表的类型，现在为javax.sql.DataSource 
	|- maxActive：表示一个数据库在此服务器上所能打开的最大连接数 
	|- maxIdle：表示一个数据库在此服务器上维持的最小连接数 
	|- maxWait：最大等待时间。10000毫秒 
	|- username：数据库连接的用户名 
	|- password：数据库连接的密码 
	|- driverClassName：数据库连接的驱动程序 
	|- url：数据库连接的地址 
	 -->

    <!--配置Oracle数据库的JNDI数据源-->
    <Resource 
        name="**jdbc/oracle**"
        auth="Container" 
        type="javax.sql.DataSource"
        maxActive="100" 
        maxIdle="30" 
        maxWait="10000"
        username="lead_oams" 
        password="p"
        driverClassName="oracle.jdbc.driver.OracleDriver"
        url="jdbc:oracle:thin:@192.168.1.229:1521:lead"/>
 
    <!--配置MySQL数据库的JNDI数据源-->
    <Resource 
        name="**jdbc/mysql**"
        auth="Container" 
        type="javax.sql.DataSource"
        maxActive="100" 
        maxIdle="30" 
        maxWait="10000"
        username="root"          password="root"
        driverClassName="com.mysql.jdbc.Driver"
        url="jdbc:mysql://192.168.1.144:3306/leadtest?useUnicode=true&amp;characterEncoding=utf-8"/>
 
    <!--配置SQLServer数据库的JNDI数据源-->
    <Resource 
        name="**jdbc/sqlserver**"
        auth="Container" 
        type="javax.sql.DataSource"
        maxActive="100" 
        maxIdle="30" 
        maxWait="10000"
        username="sa" 
        password="p@ssw0rd"
        driverClassName="com.microsoft.sqlserver.jdbc.SQLServerDriver"
        url="jdbc:sqlserver://192.168.1.51:1433;DatabaseName=demo"/>
 
</GlobalNamingResources>

引用JNDI全局数据源

在web.xml文件中添加对JNDI全局数据源的引用。

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
   
    <!-- 
	  JNDI配置的资源引用： 
	 • res-ref-name：表示引用资源的名称 
	 • res-type：此资源对应的类型为javax.sql.DataSource 
	 • res-auth：容器授权管理 
    -->

    <!--Oracle数据库JNDI数据源引用 -->
    <resource-ref>
        <description>Oracle DB Connection</description>
        <res-ref-name>**oracleDataSource**</res-ref-name>
        <res-type>javax.sql.DataSource</res-type>
        <res-auth>Container</res-auth>
    </resource-ref>
   
    <!--MySQL数据库JNDI数据源引用 -->
    <resource-ref>
        <description>MySQL DB Connection</description>
        <res-ref-name>**mysqlDataSource**</res-ref-name>
        <res-type>javax.sql.DataSource</res-type>
        <res-auth>Container</res-auth>
    </resource-ref>
   
    <!--SQLServer数据库JNDI数据源引用 -->
    <resource-ref>
        <description>SQLServer DB Connection</description>
        <res-ref-name>**sqlserverDataSource**</res-ref-name>
        <res-type>javax.sql.DataSource</res-type>
        <res-auth>Container</res-auth>
    </resource-ref>
   
</web-app>

添加虚拟映射文件目录

在Tomcat服务器的\conf\Catalina\localhost下添加与项目名称一样的xml文件。
编辑内容，如下：

<?xml version="1.0" encoding="UTF-8"?>
	<!--
    jndi配置方法（tomcat）：
    将此文件放置在tomcat\conf\Catalina\localhost下（没有目录就新建）
	-->
<!--映射JNDITest项目的虚拟目录-->
<Context docBase="D:/MyEclipse8.5/workspace/JNDITest/WebRoot" debug="0" reloadable="false">
    <!--引用Oracle数据库的JNDI数据源-->
    <ResourceLink name="**oracleDataSource**" global="**jdbc/oracle**" type="javax.sql.DataSource"/>
    <!--引用mysql数据库的JNDI数据源-->
    <ResourceLink name="**mysqlDataSource**" global="**jdbc/mysql**" type="javax.sql.DataSource"/>
    <!--引用sqlserver数据库的JNDI数据源-->
    <ResourceLink name="**sqlserverDataSource**" global="**jdbc/sqlserver**" type="javax.sql.DataSource"/>
</Context>

测试连接

配置完数据源后，可通过下面的方式进行测试：

1. 初始化名称查找上下文。
2. 通过JNDI查找数据源。
3. 通过DataSource获得到一个连接。
4. 操作数据库。
5. 关闭数据库，关闭是将连接放回连接池中。

代码：

Connection connOracle = null;
try {
    //1、初始化名称查找上下文
    Context ctx = new InitialContext(); 
    //InitialContext ctx = new InitialContext();亦可 
    //2、通过JNDI名称找到DataSource,对名称进行定位java:comp/env是必须加的,后面跟的是DataSource名
    /*
    DataSource名在web.xml文件中的<res-ref-name>oracleDataSource</res-ref-name>进行了配置
    <!--Oracle数据库JNDI数据源引用 -->
    <resource-ref>
        <description>Oracle DB Connection</description>
        <res-ref-name>oracleDataSource</res-ref-name>
        <res-type>javax.sql.DataSource</res-type>
        <res-auth>Container</res-auth>
    </resource-ref>
    */
    DataSource ds = (DataSource)ctx.lookup("java:comp/env/oracleDataSource");
    //3、通过DataSource取得一个连接
    connOracle = ds.getConnection(); 
    out.println("Oracle Connection pool connected !!");
    //4、操作数据库
} catch (NamingException e) {
    System.out.println(e.getMessage());
} catch (SQLException e) {
    e.printStackTrace();
} finally {
    //5、关闭数据库，关闭的时候是将连接放回到连接池之中
connOracle.close();
}

---

Tomcat

server.tomcat.xx开头的是tomcat特有的配置。

# Maximum queue length for incoming connection requests when all possible request processing threads are in use.
# 当所有可能的请求都在使用时，传入连接请求的最大队列长度。
server.tomcat.accept-count=  
# Buffer output such that it is only flushed periodically.
# 是否定期更新刷新缓存输出。
server.tomcat.accesslog.buffered=true 
# Directory in which log files are created. Can be relative to the tomcat base dir or absolute.
# 定义日志的输出目录
server.tomcat.accesslog.directory=logs
# Enable access log.
# 是否允许访问日志。
server.tomcat.accesslog.enabled=false 
# Date format to place in log file name.
# 日志中日期的格式
server.tomcat.accesslog.file-date-format=.yyyy-MM-dd 
# Format pattern for access logs.
# 访问日志的格式模式
server.tomcat.accesslog.pattern=common 
# Log file name prefix.
# 日志文件名前缀。
server.tomcat.accesslog.prefix=access_log 
# Defer inclusion of the date stamp in the file name until rotate time.
# 延迟在文件名中包含日期戳，直至到达。
server.tomcat.accesslog.rename-on-rotate=false 
# Set request attributes for IP address, Hostname, protocol and port used for the request.
# 设置用于请求的IP地址，主机名，协议和端口的请求属性。
server.tomcat.accesslog.request-attributes-enabled=false 
# Enable access log rotation.
# 是否启用访问日志轮询。
server.tomcat.accesslog.rotate=true 
# Log file name suffix.
# 日志文件名后缀。
server.tomcat.accesslog.suffix=.log 
# Comma-separated list of additional patterns that match jars to ignore for TLD scanning.
# 以逗号分隔的其他模式列表，这些模式匹配要忽略TLD扫描的jar。
server.tomcat.additional-tld-skip-patterns= 
# Delay in seconds between the invocation of backgroundProcess methods.
# 调用backgroundProcess()方法之间的延迟时间。
server.tomcat.background-processor-delay=30 
# Tomcat base directory. If not specified a temporary directory will be used.
# Tomcat的根目录，若是未指定将使用临时目录。
server.tomcat.basedir= 
# regular expression matching trusted IP addresses.
# 正则表达式匹配可信IP地址。
server.tomcat.max-connections= # Maximum number of connections that the server will accept and process at any given time.
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} 
# Maximum size in bytes of the HTTP message header.
# HTTP头部信息的最大大小（byte）。
server.tomcat.max-http-header-size=0 
# Maximum size in bytes of the HTTP post content.
# HTTP的POST请求内容最大大小（byte）。
server.tomcat.max-http-post-size=0 
# Maximum amount of worker threads.
# 最大工作线程数。
server.tomcat.max-threads=0 
# Minimum amount of worker threads.
# 最小工作线程数。
server.tomcat.min-spare-threads=0 
# Name of the HTTP header used to override the original port value.
# 覆盖原始端口值的HTTP头部的名称。
server.tomcat.port-header=X-Forwarded-Port 
# Header that holds the incoming protocol, usually named "X-Forwarded-Proto".
# 保存传入协议的标头，通常命名为“X-Forwarded-Proto”。
server.tomcat.protocol-header= 
# Value of the protocol header that indicates that the incoming request uses SSL.
# 协议标头的值，指示传入请求使用SSL。
server.tomcat.protocol-header-https-value=https 
# Whether requests to the context root should be redirected by appending a / to the path.
# 是否来添加“/”用于重定向对上下文的请求。
server.tomcat.redirect-context-root= 
# Name of the http header from which the remote ip is extracted. For instance `X-FORWARDED-FOR`
# 从中提取远程ip的http标头的名称。
server.tomcat.remote-ip-header= 
# Character encoding to use to decode the URI.
# 解码URL的字符编码。
server.tomcat.uri-encoding=UTF-8 

---

Servlet容器

server.xx开头的是所有servlet容器通用的配置。

application.properties

# Network address to which the server should bind to.
# 服务器绑定的地址。
server.address= 
# Server HTTP port.
# 服务器的端口。
server.port=8080 
# Value to use for the Server response header (no header is sent if empty)
# 用于服务器响应标头的值（如果为空，则不发送标头）
server.use-forward-headers= # If X-Forwarded-* headers should be applied to the HttpRequest.
server.server-header= 
# If response compression is enabled.
# 启动响应压缩。
server.compression.enabled=false 
# List of user-agents to exclude from compression.
# 从压缩中排除用户代理列表。
server.compression.excluded-user-agents= 
# Comma-separated list of MIME types that should be compressed. 
server.compression.mime-types= For instance `text/html,text/css,application/json`
# Minimum response size that is required for compression to be performed. For instance 2048
server.compression.min-response-size= 
# Time in milliseconds that connectors will wait for another HTTP request before closing the connection. When not set, the connector's container-specific default will be used. Use a value of -1 to indicate no (i.e. infinite) timeout.
# HTTP等待请求的时间。
server.connection-timeout= 
# Display name of the application.
# 服务器应用名称。
server.display-name=application 
# Maximum size in bytes of the HTTP message header.
# HTTP消息头的最大大小。
server.max-http-header-size=0 

# Include the "exception" attribute.
# 包含异常属性。
server.error.include-exception=false 
# When to include a "stacktrace" attribute.
# 何时包含stacktrace属性。
server.error.include-stacktrace=never 
# Path of the error controller.
# 异常控制类的路径
server.error.path=/error 
# Enable the default error page displayed in browsers in case of a server error.
# 如果出现服务器错误，请启用浏览器中显示的默认错误页面。
server.error.whitelabel.enabled=true 

# Number of acceptor threads to use.
# 要使用的接受者线程数。
server.jetty.acceptors= 
# Append to log.
server.jetty.accesslog.append=false 
# Timestamp format of the request log.
server.jetty.accesslog.date-format=dd/MMM/yyyy:HH:mm:ss Z 
# Enable access log.
# 附加访问日志。
server.jetty.accesslog.enabled=false 
# Enable extended NCSA format.
# 启用扩展NCSA格式。
server.jetty.accesslog.extended-format=false 
# Date format to place in log file name.
# 日期格式放在日志文件名中。
server.jetty.accesslog.file-date-format= 
# Log filename. If not specified, logs will be redirected to "System.err".
# 日志名称。
server.jetty.accesslog.filename= 
# Locale of the request log.
# 请求日志的区域设置。
server.jetty.accesslog.locale= 
# Enable logging of the request cookies.
# 启用请求cookie的记录。
server.jetty.accesslog.log-cookies=false 
# Enable logging of request processing time.
# 启用请求的时间记录。
server.jetty.accesslog.log-latency=false 
# Enable logging of the request hostname. 
# 启用请求的地址记录。
server.jetty.accesslog.log-server=false 
# Number of days before rotated log files are deleted.
# 删除轮询日志文件的天数。
server.jetty.accesslog.retention-period=31 
# Timezone of the request log.
# 请求日志的时间格式。
server.jetty.accesslog.time-zone=GMT
# Maximum size in bytes of the HTTP post or put content.
# HTTP post或put内容的最大大小（以字节为单位）。
server.jetty.max-http-post-size=0 
# Number of selector threads to use.
# 要使用的选择者线程数。
server.jetty.selectors= 

# Servlet context init parameters
# Servlet上下文init参数
server.servlet.context-parameters.*= 
# Context path of the application.
# 应用的路径。
server.servlet.context-path= 
# The class name of the JSP servlet.
# JSP servelt的类名称。
server.servlet.jsp.class-name=org.apache.jasper.servlet.JspServlet 
# Init parameters used to configure the JSP servlet.
# 配置JSP servlet的init参数。
server.servlet.jsp.init-parameters.*= 
# Whether or not the JSP servlet is registered.
# 是否注册了JSP servlet。
server.servlet.jsp.registered=true 
# Path of the main dispatcher servlet.
# 默认的匹配servlet路径。
server.servlet.path=/ 

# Comment for the session cookie.
server.session.cookie.comment= 
# Domain for the session cookie.
# 会话cookie的域名。
server.session.cookie.domain= 
# "HttpOnly" flag for the session cookie.
server.session.cookie.http-only= 
# Maximum age of the session cookie in seconds.
# 会话cookie的最大年龄
server.session.cookie.max-age= 
# Session cookie name.
# 会话cookie的名称。
server.session.cookie.name= 
# Path of the session cookie.
# 会话cookie的路径。
server.session.cookie.path= 
# "Secure" flag for the session cookie.
server.session.cookie.secure= 
# Persist session data between restarts.
# 重新启动之间保留会话数据。
server.session.persistent=false 
# Session repository filter order.
server.session.servlet.filter-order=-2147483598 
# Session repository filter dispatcher types.
server.session.servlet.filter-dispatcher-types=ASYNC, ERROR, REQUEST 
# Directory used to store session data.
# 存储会话cookie数据的文件地址
server.session.store-dir= 
# Session timeout in seconds.
# 会话cookie过期时间。
server.session.timeout= 
# Session tracking modes (one or more of the following: "cookie", "url", "ssl").
server.session.tracking-modes= 

# Supported SSL ciphers.
# 支持的SSL密码。
server.ssl.ciphers= 
# Whether client authentication is wanted ("want") or needed ("need"). Requires a trust store.
# 是否需要客户端身份验证（“想要”）或需要（“需要”）。
server.ssl.client-auth= 
# Enable SSL support.
# 启用SSL支持。
server.ssl.enabled= 
# Enabled SSL protocols.
# 启用SSL协议。
server.ssl.enabled-protocols= 
# Alias that identifies the key in the key store.
# 标识密钥库中密钥的别名。
server.ssl.key-alias= 
# Password used to access the key in the key store.
# 用于访问密钥库中密钥的密码。
server.ssl.key-password= 
# Path to the key store that holds the SSL certificate (typically a jks file).
# 保存SSL证书的密钥库的路径（通常是jks文件）。
server.ssl.key-store= 
# Password used to access the key store.
# 用于访问密钥库的密码。
server.ssl.key-store-password= 
# Provider for the key store.
# 密钥库的提供商。
server.ssl.key-store-provider= 
# Type of the key store.
# 密钥库的类型。
server.ssl.key-store-type= 
# SSL protocol to use.
# 使用SSL的协议。
server.ssl.protocol=TLS 
# Trust store that holds SSL certificates.
# 持有SSL证书的信任存储。
server.ssl.trust-store= 
# Password used to access the trust store.
# 用于访问信任库的密码。
server.ssl.trust-store-password= 
# Provider for the trust store.
# 信托商店的提供商。
server.ssl.trust-store-provider= 
# Type of the trust store.
# 信托商店的类型。
server.ssl.trust-store-type= 

# 配置数据源 
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource 
# 使用file存储数据 
spring.datasource.url = jdbc:h2:file:~/.h2/spring-boot;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE  
# 存储在内存中  
# spring.datasource.url = jdbc:h2:mem:~/.h2/spring-boot;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE 
# 用户名和密码
spring.datasource.username = sa 
spring.datasource.password = 
# 驱动 
spring.datasource.driverClassName = org.h2.Driver
# 导入数据库结构
spring.datasource.schema = classpath:sql/schema.sql
# 导入数据文件
spring.datasource.data = classpath:sql/data.sql
# 导入编码 
spring.datasource.sql-script-encoding=UTF-8 
spring.datasource.continue-on-error=false

# Undertow access log directory.
# 取消访问日志目录。
server.undertow.accesslog.dir= 
# Enable access log.
# 启用访问日志。
server.undertow.accesslog.enabled=false 
# Format pattern for access logs.
# 访问日志格式模式。
server.undertow.accesslog.pattern=common 
# Log file name prefix.
# 日志文件名称前缀。
server.undertow.accesslog.prefix=access_log. 
# Enable access log rotation.
# 启用轮询日志。
server.undertow.accesslog.rotate=true 
# Log file name suffix.
# 日志文件名后缀。
server.undertow.accesslog.suffix=log 
# Size of each buffer in bytes.
# 缓存大小。
server.undertow.buffer-size= 
# Allocate buffers outside the Java heap.
# 在Java堆外部分配缓冲区。
server.undertow.direct-buffers= 
# Number of I/O threads to create for the worker.
# 为worker创建的I/O线程数。
server.undertow.io-threads= 
# Whether servlet filters should be initialized on startup.
# 是否应在启动时初始化servlet过滤器。
server.undertow.eager-filter-init=true 
# Maximum size in bytes of the HTTP post content.
# HTTP发布内容的最大大小
server.undertow.max-http-post-size=0 
# Number of worker threads.
# 工作线程数。
server.undertow.worker-threads= 

代码配置容器

通过直接实现EmbeddedServletContainerCustomizer这个接口也可以实现配置对应的属性。

@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties
        implements EmbeddedServletContainerCustomizer, EnvironmentAware, Ordered {
}

当然Tomcat、Jetty和Undertow也有特定的容器类：

// Jetty
org.springframework.boot.context.embedded.jetty.JettyEmbeddedServletContainerFactory

// Tomcat
org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory

// Undertow
org.springframework.boot.context.embedded.undertow.UndertowEmbeddedServletContainerFactory

---

Druid

Druid提供了一个高效、功能强大、可扩展性好的数据库连接池。

需要引入的包

druid-spring-boot-starter

在Application.properties中添加配置信息

## 数据源配置
# spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf-8&useSSL=false
# spring.datasource.username=root
# spring.datasource.password=root
# spring.datasource.driver-class-name=com.mysql.jdbc.Driver

# 这4个参数key里不带druid也可以，即可以还用上面的这个4个参数
spring.datasource.druid.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.druid.username=root
spring.datasource.druid.password=root
spring.datasource.druid.driver-class-name=com.mysql.jdbc.Driver

# 初始化时建立物理连接的个数
spring.datasource.druid.initial-size=5
# 最大连接池数量
spring.datasource.druid.max-active=30
# 最小连接池数量
spring.datasource.druid.min-idle=5
# 获取连接时最大等待时间，单位毫秒
spring.datasource.druid.max-wait=60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.datasource.druid.time-between-eviction-runs-millis=60000
# 连接保持空闲而不被驱逐的最小时间
spring.datasource.druid.min-evictable-idle-time-millis=300000
# 用来检测连接是否有效的sql，要求是一个查询语句
spring.datasource.druid.validation-query=SELECT 1 FROM DUAL
# 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
spring.datasource.druid.test-while-idle=true
# 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
spring.datasource.druid.test-on-borrow=false
# 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
spring.datasource.druid.test-on-return=false
# 是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。
spring.datasource.druid.pool-prepared-statements=false
# 要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。
spring.datasource.druid.max-pool-prepared-statement-per-connection-size=50
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计
spring.datasource.druid.filters=stat,wall
# 通过connectProperties属性来打开mergeSql功能；慢SQL记录
spring.datasource.druid.connection-properties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
# 合并多个DruidDataSource的监控数据
spring.datasource.druid.use-global-data-source-stat=true

# druid连接池监控，可以通过http://localhost:8080/druid 查看具体的监控信息
spring.datasource.druid.stat-view-servlet.login-username=admin
spring.datasource.druid.stat-view-servlet.login-password=123
# 排除一些静态资源，以提高效率
spring.datasource.druid.web-stat-filter.exclusions=*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*

---

### Log4j

简介

Apache Log4j is a Java-based logging utility.

配置信息

log4j.rootLogger=DEBUG,console,dailyFile,rollingFile,logFile
log4j.additivity.org.apache=true

# 控制台(console)
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.ImmediateFlush=true
log4j.appender.console.Target=System.err
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%p] %m%n

# 日志文件(logFile)
#log4j.appender.logFile=org.apache.log4j.FileAppender
#log4j.appender.logFile.Threshold=DEBUG
#log4j.appender.logFile.ImmediateFlush=true
#log4j.appender.logFile.Append=true
#log4j.appender.logFile.File=F:/logs/log.log4j
#log4j.appender.logFile.layout=org.apache.log4j.PatternLayout
#log4j.appender.logFile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%p] %m%n

# 滚动文件(rollingFile)
#log4j.appender.rollingFile=org.apache.log4j.RollingFileAppender
#log4j.appender.rollingFile.Threshold=DEBUG
#log4j.appender.rollingFile.ImmediateFlush=true
#log4j.appender.rollingFile.Append=true
#log4j.appender.rollingFile.File=F:/logs/log.log4j
#log4j.appender.rollingFile.MaxFileSize=200KB
#log4j.appender.rollingFile.MaxBackupIndex=50
#log4j.appender.rollingFile.layout=org.apache.log4j.PatternLayout
#log4j.appender.rollingFile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%p] %m%n

# 定期滚动日志文件(dailyFile)
#log4j.appender.dailyFile=org.apache.log4j.DailyRollingFileAppender
#log4j.appender.dailyFile.Threshold=DEBUG
#log4j.appender.dailyFile.ImmediateFlush=true
#log4j.appender.dailyFile.Append=true
#log4j.appender.dailyFile.File=F:/logs/log.log4j
#log4j.appender.dailyFile.DatePattern='.'yyyy-MM-dd
#log4j.appender.dailyFile.layout=org.apache.log4j.PatternLayout
#log4j.appender.dailyFile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%p] %m%n

---

Dubbo

Dubbo支持的四种配置方式

XML 配置

我们可以使用XML 对Dubbo 进行配置，因为Dubbo 是使用Spring 的Schema 进行扩展标签和解析配置的，所以我们可以像使用Spring 的XML 配置方式一样进行配置。
比如之前Hello World程序中暴露服务的配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
        http://code.alibabatech.com/schema/dubbo
        http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
    <!--提供者的应用名-->
    <dubbo:application name="dubbo-server" />
    <!--使用Zookeeper注册中心的地址-->
    <dubbo:registry address="zookeeper://127.0.0.1:2181" />
    <!--使用Dubbo协议在20880端口暴露服务-->
    <dubbo:protocol name="dubbo" port="20880" />
    <!--声明需要暴露的服务接口-->
    <dubbo:service interface="cn.vgbhfive.vid.vid_rpc.api.IHelloService" ref="IdService" />
    <!--和本地Bean一样实现服务-->
    <bean id="IdService" class="cn.vgbhfive.vid.vid_rpc.server.impl.RPCService" />
</beans>

在以上配置中使用了Dubbo扩展的dubbo:application、dubbo:registry、dubbo:service等标签。

Dubbo的配置标签及他们之间的关系：

这些标签的用途和解释：

标签	用途	解释
<dubbo:service/>	服务配置	用于暴露一个服务，定义服务的元信息，一个服务可以被多个协议暴露，一个服务也可以注册多个到注册中心。
<dubbo:reference/>	引用配置	用于创建一个远程服务代理，一个引用可以指向多个注册中心。
<dubbo:protocol/>	协议配置	用于配置提供服务的协议信息，协议由提供者指定，消费者被动接收。
<dubbo:application/>	引用配置	用于配置当前的应用信息，不管是消费者还是提供者。
<dubbo:module/>	模块配置	用于配置当前的模块信息。
<dubbo:registry/>	注册中心配置	用于配置连接到注册中心相关的信息。
<dubbo:monitor/>	监控中心配置	用于配置连接到监控中心相关的信息。
<dubbo:provider/>	服务者配置	当ProtocolConfig 和ServiceConfig 的某属性没有配置时，采用此默认值。
<dubbo:consumer/>	提供者配置	当ReferenceConfig 的某属性值没有配置时，采用此默认值。
<dubbo:method/>	方法配置	用于ServiceConfig 和RefernceConfig 指定方法级的配置信息。
<dubbo:argument/>	参数配置	用于指定方法参数的配置信息。

配置的覆盖优先级：

各优先级关系简单可总结为：

• 方法级优先，接口级次之，全局配置再次之。
• 如果级别一样，则消费者优先，提供者次之。

属性配置

我们还可以对Dubbo 使用properties 文件进行配置。
配置示例：

dubbo.application.name = dubbo-server
dubbo.application.owner = test
dubbo.registry.address = zookeeper://127.0.0.1:2181

属性的配置规则遵循以下约定：

• 将XML配置的标签名加属性名，用点分隔，将多个属性拆分成多行。
• 如果XML有多行同名标签，则可用id 号区分，如果没有id 号，则将对所有同名标签生效。

各配置方式的覆盖优先级策略：

• JVM 启动-D 参数优先，这样可以使用户在部署和启动时进行参数重写。比如改写端口。
• XML 次之，如果在XML中有配置，则dubbo.properties 中的配置项则无效。
• Properties 最后，相当于默认值，只有XML没有被配置时，dubbo.prperties 的相应配置才会生效，通常用于共享公共配置。

API 配置

API 属性与XML 配置项是一一对应的。如下：

ApplicationConfig.setName("dubbo-server") => 
<dubbo:application name="dubbo-server">

注解配置

通过注解方式对Dubbo 进行配置，这样可以节省大量的XML 配置和属性配置。
对服务提供者配置如下：

@Configuration
public class DubboConfiguration {
    @Bean
    public ApplicationConfig applicationConfig() {
        ApplicationConfig applicationConfig = new ApplicationConfig();
        applicationConfig.setName("dubbo-server");
        return applicationConfig;
    }

    @Bean
    public RegistryConfig registryConfig() {
        RegistryConfig registryConfig = new RegistryConfig();
        registryConfig.setAddress("zookeeper://127.0.0.1:2181");
        registryConfig.setClient("curator");
        return registryConfig;
    }
}

使用@Service 注解暴露服务。
指定Dubbo 的扫描路径。
对服务消费者配置如下：

@Configuration
public class DubboConfiguration {
   @Bean    public ApplicationConfig applicationConfig() {
       ApplicationConfig applicationConfig = new ApplicationConfig();
       applicationConfig.setName("dubbo-client");
       return applicationConfig;
   }

   @Bean
   public ConsumerConfig consumerConfig() {
       ConsumerConfig consumerConfig = new ConsumerConfig();
       consumerConfig.setTimeout(3000);
       return consumerConfig;
   }

   @Bean
   public RegistryConfig registryConfig() {
       RegistryConfig registeryConfig = new RegistryConfig();
       registryConfig.setAddress("zookeeper://127.0.0.1:2181");
       registryConfig.setClient("curator");
       return registryConfig;
   }
}

使用@Reference 注解应用服务。
指定Dubbo 的扫描路径。

RabbitMQ

Redis

剩余的其他组件配置信息，会慢慢更新。。。。