spring连接池配置详解

Posted 2023-04-24

参考技术A

　　 数据库连接池概述

　　数据库连接是一种关键的有限的昂贵的资源 这一点在多用户的网页应用程序中体现得尤为突出 对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性 影响到程序的性能指标 数据库连接池正是针对这个问题提出来的

　　数据库连接池负责分配 管理和释放数据库连接 它允许应用程序重复使用一个现有的数据库连接 而再不是重新建立一个 释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏 这项技术能明显提高对数据库操作的性能

　　数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中 这些数据库连接的数量是由最小数据库连接数来设定的 无论这些数据库连接是否被使用 连接池都将一直保证至少拥有这么多的连接数量 连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数 当应用程序向连接池请求的连接数超过最大连接数量时 这些请求将被加入到等待队列中 数据库连接池的最小连接数和最大连接数的设置要考虑到下列几个因素

　　 ) 最小连接数是连接池一直保持的数据库连接 所以如果应用程序对数据库连接的使用量不大 将会有大量的数据库连接资源被浪费

　　 ) 最大连接数是连接池能申请的最大连接数 如果数据库连接请求超过此数 后面的数据库连接请求将被加入到等待队列中 这会影响之后的数据库操作

　　 ) 如果最小连接数与最大连接数相差太大 那么最先的连接请求将会获利 之后超过最小连接数量的连接请求等价于建立一个新的数据库连接 不过 这些大于最小连接数的数据库连接在使用完不会马上被释放 它将被放到连接池中等待重复使用或是空闲超时后被释放

　　目前常用的连接池有 C P DBCP Proxool

　　网上的评价是

　　C P 比较耗费资源 效率方面可能要低一点

　　DBCP在实践中存在BUG 在某些种情会产生很多空连接不能释放 Hibernate 已经放弃了对其的支持

　　Proxool的负面评价较少 现在比较推荐它 而且它还提供即时监控连接池状态的功能 便于发现连接泄漏的情况

　　配置如下

　　 在spring配置文件中 一般在applicationContext xml中

　　<bean id= DataSource class= logicalcobwebs proxool ProxoolDataSource destroy method= shutdown >

　　<property name= driver >

　　<value>oracle jdbc driver OracleDriver</value>

　　</property>

　　<property name= driverUrl >

　　<value>jdbc:oracle:thin:xxxx/xxxx@ XX: :server</value>

　　</property>

　　<property name= user >

　　<value>xxxx</value>

　　</property>

　　<property name= password >

　　<value>xxxx</value>

　　</property>

　　<property name= alias >

　　<value>server</value>

　　</property>

　　<property name= houseKeepingSleepTime >

　　<value> </value>

　　</property>

　　<property name= houseKeepingTestSql >

　　<value>select from dual</value>

　　</property>

　　<property name= testBeforeUse >

　　<value>true</value>

　　</property>

　　<property name= testAfterUse >

　　<value>true</value>

　　</property>

　　<property name= prototypeCount >

　　<value> </value>

　　</property>

　　<property name= maximumConnectionCount >

　　<value> </value>

　　</property>

　　<property name= minimumConnectionCount >

　　<value> </value>

　　</property>

　　<property name= statistics >

　　<value> m m d</value>

　　</property>

　　<property name= statisticsLogLevel >

　　<value>ERROR</value>

　　</property>

　　<property name= trace >

　　<value>true</value>

　　</property>

　　<property name= verbose >

　　<value>false</value>

　　</property>

　　<property name= simultaneousBuildThrottle >

　　<value> </value>

　　</property>

　　<property name= maximumActiveTime >

　　<value> </value>

　　</property>

　　<property name= jmx >

　　<value>false</value>

　　</property>

　　</bean>

　　然后注入到sessionFactory中

　　<bean id= sessionFactory class= springframework orm hibernate LocalSessionFactoryBean >

　　<property name= dataSource ref= DataSource />

　　</bean>

　　 属性列表说明:

　　fatal sql exception: 它是一个逗号分割的信息片段 当一个SQL异常发生时 他的异常信息将与这个信息片段进行比较 如果在片段中存在 那么这个异常将被认为是个致命错误(Fatal SQL Exception ) 这种情况下 数据库连接将要被放弃 无论发生什么 这个异常将会被重掷以提供给消费者 用户最好自己配置一个不同的异常来抛出

　　fatal sql exception wrapper class:正如上面所说 你最好配置一个不同的异常来重掷 利用这个属性 用户可以包装SQLException 使他变成另外一个异常 这个异常或者继承QLException或者继承字RuntimeException proxool自带了 个实现: logicalcobwebs proxool FatalSQLException 和 logicalcobwebs proxool FatalRuntimeException 后者更合适

　　house keeping sleep time: house keeper 保留线程处于睡眠状态的最长时间 house keeper 的职责就是检查各个连接的状态 并判断是否需要销毁或者创建

　　house keeping test sql:  如果发现了空闲的数据库连接 house keeper 将会用这个语句来测试 这个语句最好非常快的被执行 如果没有定义 测试过程将会被忽略

　　injectable connection interface: 允许proxool实现被代理的connection对象的方法

　　injectable statement interface: 允许proxool实现被代理的Statement 对象方法

　　injectable prepared statement interface: 允许proxool实现被代理的PreparedStatement 对象方法

　　injectable callable statement interface: 允许proxool实现被代理的CallableStatement 对象方法

　　jmx: 如果属性为true 就会注册一个消息Bean到jms服务 消息Bean对象名: Proxool:type=Pool name=<alias> 默认值为false

　　jmx agent id: 一个逗号分隔的JMX代理列表(如使用MBeanServerFactory findMBeanServer(String agentId)注册的连接池 ）这个属性是仅当 jmx 属性设置为 true 才有效 所有注册jmx服务器使用这个属性是不确定的

　　jndi name: 数据源的名称

　　maximum active time: 如果housekeeper 检测到某个线程的活动时间大于这个数值 它将会杀掉这个线程 所以确认一下你的服务器的带宽 然后定一个合适的值 默认是 分钟

　　maximum connection count: 最大的数据库连接数

　　maximum connection lifetime: 一个线程的最大寿命

　　minimum connection count: 最小的数据库连接数

　　overload without refusal lifetime: 这可以帮助我们确定连接池的状态 如果我们已经拒绝了一个连接在这个设定值(毫秒) 然后被认为是超载 默认为 秒

　　prototype count: 连接池中可用的连接数量 如果当前的连接池中的连接少于这个数值 新的连接将被建立(假设没有超过最大可用数) 例如 我们有 个活动连接 个可用连接 而我们的prototype count是 那么数据库连接池将试图建立另外 个连接 这和 minimum connection count不同 minimum connection count把活动的连接也计算在内 prototype count 是spare connections 的数量

　　recently started threshold: 这可以帮助我们确定连接池的状态 连接数少还是多或超载 只要至少有一个连接已开始在此值(毫秒)内 或者有一些多余的可用连接 那么我们假设连接池是开启的 默认为 秒

　　simultaneous build throttle: 这是我们可一次建立的最大连接数 那就是新增的连接请求 但还没有可供使用的连接 由于连接可以使用多线程 在有限的时间之间建立联系从而带来可用连接 但是我们需要通过一些方式确认一些线程并不是立即响应连接请求的 默认是

　　statistics:  连接池使用状况统计 参数 s m d

　　statistics log level: 日志统计跟踪类型 参数 ERROR 或 INFO

　　test before use: 如果为true 在每个连接被测试前都会服务这个连接 如果一个连接失败 那么将被丢弃 另一个连接将会被处理 如果所有连接都失败 一个新的连接将会被建立 否则将会抛出一个SQLException异常

　　test after use: 如果为true 在每个连接被测试后都会服务这个连接 使其回到连接池中 如果连接失败 那么将被废弃

　　trace: 如果为true 那么每个被执行的SQL语句将会在执行期被log记录(DEBUG LEVEL) 你也可以注册一个ConnectionListener (参看ProxoolFacade)得到这些信息

lishixinzhi/Article/program/Java/ky/201311/28572

SpringBoot 整合 MongoDB 连接池配置详解

目录

• 前言
• 一、引入依赖
• • 1.1 Maven
  • 1.2 Gradle
• 二、配置文件
• 三、MongoConfig配置类
• 四、总结

前言

SpringBoot为方便整合MongoDB，提供了相应的启动器，即spring-boot-starter-data-mongodb。然后我们就可以用它提供的MongoTemplate类来操作数据库了。

当然，SpringBoot也提供了相应的类让我们能自定义配置连接池。我们在配置类中主要与MongoClientOptions、MongoCredential、ServerAddress、MongoClient、MongoDbFactory等打交道。最终的目的就是配置一个MongoDbFactory的bean交由Spring管理，SpringBoot会拿这个MongoDbFactory工厂bean来new一个MongoTemplate（在MongoDbFactoryDependentConfiguration类中）。当然，我们也可以自己new这个MongoTemplate实例，这样我们可以对MongoTemplate这个bean做额外处理，再交给Spring容器。

一、引入依赖

1.1 Maven

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

1.2 Gradle

implementation 'org.springframework.boot:spring-boot-starter-data-mongodb'

二、配置文件

spring.application.name=springboot-mongo

#基础连接参数
#要连接的数据库
mongodb.database=nobody
#用户名
mongodb.username=
#密码
mongodb.password=
#IP和端口（host:port），例如127.0.0.1:27017。集群模式用,分隔开，例如host1:port1,host2:port2
mongodb.address=127.0.0.1:27017
#设置认证数据库，如果有的话
mongodb.authenticationDatabase=

# 客户端连接池参数
#客户端的标识，用于定位请求来源等，一般用程序名
mongodb.clientName=$spring.application.name
#TCP（socket）连接超时时间，毫秒
mongodb.connectionTimeoutMs=5000
#TCP（socket）连接闲置时间，毫秒
mongodb.maxConnectionIdleTimeMs=60000
#TCP（socket）连接最多可以使用多久，毫秒
mongodb.maxConnectionLifeTimeMs=300000
#TCP（socket）读取超时时间，毫秒
mongodb.readTimeoutMs=15000
#当连接池无可用连接时客户端阻塞等待的最大时长，毫秒
mongodb.maxWaitTimeMs=5000
#心跳检测发送频率，毫秒
mongodb.heartbeatFrequencyMs=20000
#最小的心跳检测发送频率，毫秒
mongodb.minHeartbeatFrequencyMs=8000
#心跳检测连接超时时间，毫秒
mongodb.heartbeatConnectionTimeoutMs=10000
#心跳检测读取超时时间，毫秒
mongodb.heartbeatReadTimeoutMs=15000
#线程池允许的最大连接数
mongodb.connectionsPerHost=100
#线程池空闲时保持的最小连接数
mongodb.minConnectionsPerHost=20
#计算允许多少个线程阻塞等待时的乘数，算法：threadsAllowedToBlockForConnectionMultiplier*maxConnectionsPerHost
mongodb.threadsAllowedToBlockForConnectionMultiplier=10

三、MongoConfig配置类

注意：项目中使用了lombok依赖，这样可以减少写getter、Setter等方法。

package com.nobody.mongo.config;

import com.mongodb.*;
import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
import org.springframework.data.mongodb.core.convert.*;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
import org.springframework.util.StringUtils;
import org.springframework.validation.annotation.Validated;

import javax.validation.constraints.Min;
import javax.validation.constraints.NotEmpty;
import java.util.ArrayList;
import java.util.List;

/**
 * @Description mongo配置类
 * @Author Mr.nobody
 * @Date 2020/11/7
 * @Version 1.0
 */
@Configuration
// 将带有@ConfigurationProperties注解的类注入为Spring容器的Bean，
// 任何被@ConfigurationProperties注解的beans将自动被Environment属性配置。
@EnableConfigurationProperties(MongoConfig.MongoClientOptionProperties.class)
public class MongoConfig 

    /**
     * 此Bean也是可以不显示定义的，如果我们没有显示定义生成MongoTemplate实例，
     * SpringBoot利用我们配置好的MongoDbFactory在配置类中生成一个MongoTemplate，
     * 之后我们就可以在项目代码中直接@Autowired了。因为用于生成MongoTemplate
     * 的MongoDbFactory是我们自己在MongoConfig配置类中生成的，所以我们自定义的连接池参数也就生效了。
     *
     * @param mongoDbFactory mongo工厂
     * @param converter      转换器
     * @return MongoTemplate实例
     */
    @Bean
    public MongoTemplate mongoTemplate(MongoDbFactory mongoDbFactory, MappingMongoConverter converter) 
        MongoTemplate mongoTemplate = new MongoTemplate(mongoDbFactory, converter);
        // 设置读从库优先
        mongoTemplate.setReadPreference(ReadPreference.secondaryPreferred());
        return mongoTemplate;
    

    /**
     * 转换器
     * MappingMongoConverter可以自定义mongo转换器，主要自定义存取mongo数据时的一些操作，例如 mappingConverter.setTypeMapper(new
     * DefaultMongoTypeMapper(null)) 方法会将mongo数据中的_class字段去掉。
     *
     * @param factory     mongo工厂
     * @param context     上下文
     * @param conversions 自定义转换器
     * @return 转换器对象
     */
    @Bean
    public MappingMongoConverter mappingMongoConverter(MongoDbFactory factory, MongoMappingContext context,
                                                       MongoCustomConversions conversions) 
        DbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);
        MappingMongoConverter mappingConverter = new MappingMongoConverter(dbRefResolver, context);
        mappingConverter.setCustomConversions(conversions);
        // remove _class field
        mappingConverter.setTypeMapper(new DefaultMongoTypeMapper(null));
        return mappingConverter;
    

    /**
     * 自定义mongo连接池
     *
     * @param properties 属性配置类
     * @return MongoDbFactory对象
     */
    @Bean
    public MongoDbFactory mongoDbFactory(MongoClientOptionProperties properties) 

        MongoClient mongoClient;

        // 创建客户端参数
        MongoClientOptions mongoClientOptions = mongoClientOptions(properties);

        // 解析获取mongo服务地址
        List<ServerAddress> serverAddressList = getServerAddress(properties.getAddress());

        // 创建认证
        MongoCredential mongoCredential = getCredential(properties);

        // 创建客户端
        if (null == mongoCredential) 
            mongoClient = new MongoClient(serverAddressList, mongoClientOptions);
         else 
            mongoClient = new MongoClient(serverAddressList, mongoCredential, mongoClientOptions);
        

        return new SimpleMongoDbFactory(mongoClient, properties.getDatabase());
    

    /**
     * 创建认证
     *
     * @param properties 属性配置类
     * @return 认证对象
     */
    private MongoCredential getCredential(MongoClientOptionProperties properties) 
        if (!StringUtils.isEmpty(properties.getUsername()) && !StringUtils.isEmpty(properties.getPassword())) 
            // 没有专用认证数据库则取当前数据库
            String database = StringUtils.isEmpty(properties.getAuthenticationDatabase()) ?
                    properties.getDatabase() : properties.getAuthenticationDatabase();
            return MongoCredential.createCredential(properties.getUsername(), database,
                    properties.getPassword().toCharArray());
        
        return null;
    

    /**
     * 获取数据库服务地址
     *
     * @param mongoAddress 地址字符串
     * @return 服务地址数组
     */
    private List<ServerAddress> getServerAddress(String mongoAddress) 
        String[] mongoAddressArray = mongoAddress.trim().split(",");
        List<ServerAddress> serverAddressList = new ArrayList<>(4);
        for (String address : mongoAddressArray) 
            String[] hostAndPort = address.split(":");
            serverAddressList.add(new ServerAddress(hostAndPort[0], Integer.parseInt(hostAndPort[1])));
        
        return serverAddressList;
    

    /**
     * mongo客户端参数配置
     *
     * @param properties 属性配置类
     * @return mongo客户端参数配置对象
     */
    private MongoClientOptions mongoClientOptions(MongoClientOptionProperties properties) 
        return MongoClientOptions.builder().applicationName(properties.getClientName()).
                connectTimeout(properties.getConnectionTimeoutMs())
                .maxConnectionIdleTime(properties.getMaxConnectionIdleTimeMs())
                .maxConnectionLifeTime(properties.getMaxConnectionLifeTimeMs())
                .socketTimeout(properties.getReadTimeoutMs())
                .maxWaitTime(properties.getMaxWaitTimeMs())
                .heartbeatFrequency(properties.getHeartbeatFrequencyMs())
                .minHeartbeatFrequency(properties.getMinHeartbeatFrequencyMs())
                .heartbeatConnectTimeout(properties.getHeartbeatConnectionTimeoutMs())
                .heartbeatSocketTimeout(properties.getHeartbeatReadTimeoutMs())
                .connectionsPerHost(properties.getConnectionsPerHost())
                .minConnectionsPerHost(properties.getMinConnectionsPerHost())
                .threadsAllowedToBlockForConnectionMultiplier(properties.getThreadsAllowedToBlockForConnectionMultiplier())
                .readPreference(ReadPreference.secondaryPreferred())
                .build();
    

    @Getter
    @Setter
    @Validated
    @ConfigurationProperties(prefix = "mongodb")
    public static class MongoClientOptionProperties 

        /**
         * 基础连接参数
         */
        @NotEmpty
        private String database; // 要连接的数据库
        private String username; // 用户名
        private String password; // 密码
        @NotEmpty
        private String address; // IP和端口（host:port），例如127.0.0.1:27017。集群模式用,分隔开，例如host1:port1,host2:port2
        private String authenticationDatabase; // 设置认证数据库，如果有的话

        /**
         * 客户端连接池参数
         */
        @NotEmpty
        private String clientName; // 客户端的标识，用于定位请求来源等，一般用程序名
        @Min(value = 1)
        private int connectionTimeoutMs; // TCP（socket）连接超时时间，毫秒
        @Min(value = 1)
        private int maxConnectionIdleTimeMs; // TCP（socket）连接闲置时间，毫秒
        @Min(value = 1)
        private int maxConnectionLifeTimeMs; // TCP（socket）连接最多可以使用多久，毫秒
        @Min(value = 1)
        private int readTimeoutMs; // TCP（socket）读取超时时间，毫秒
        @Min(value = 1)
        private int maxWaitTimeMs; // 当连接池无可用连接时客户端阻塞等待的最大时长，毫秒
        @Min(value = 2000)
        private int heartbeatFrequencyMs; // 心跳检测发送频率，毫秒
        @Min(value = 300)
        private int minHeartbeatFrequencyMs; // 最小的心跳检测发送频率，毫秒
        @Min(value = 200)
        private int heartbeatConnectionTimeoutMs; // 心跳检测连接超时时间，毫秒
        @Min(value = 200)
        private int heartbeatReadTimeoutMs; // 心跳检测读取超时时间，毫秒
        @Min(value = 1)
        private int connectionsPerHost; // 线程池允许的最大连接数
        @Min(value = 1)
        private int minConnectionsPerHost; // 线程池空闲时保持的最小连接数
        @Min(value = 1)
        // 计算允许多少个线程阻塞等待时的乘数，算法：threadsAllowedToBlockForConnectionMultiplier*maxConnectionsPerHost
        private int threadsAllowedToBlockForConnectionMultiplier;
    

四、总结

Mongo连接池常用的参数配置一般是一下几种，一般根据自己具体业务进行数值配置，达到最优效果。

• connectionTimeoutMs：TCP（socket）连接超时时间，毫秒
• maxConnectionIdleTimeMs：TCP（socket）连接闲置时间，毫秒
• maxConnectionLifeTimeMs：TCP（socket）连接最多可以使用多久，毫秒
• readTimeoutMs：TCP（socket）读取超时时间，毫秒
• maxWaitTimeMs：当连接池无可用连接时客户端阻塞等待的最大时长，毫秒
• connectionsPerHost：线程池允许的最大连接数
• minConnectionsPerHost：线程池空闲时保持的最小连接数