mysql数据库连接池使用(二)实现自己的数据库连接池-阿里云开发者社区

开发者社区> 分享达人> 正文

mysql数据库连接池使用(二)实现自己的数据库连接池

简介: 上一个章节,我们讲了xml文件的解析框架XMLConfiguration的使用,不懂的可以参考 Apache Commons Configuration读取xml配置具体使用。
+关注继续查看

上一个章节,我们讲了xml文件的解析框架XMLConfiguration的使用,不懂的可以参考

Apache Commons Configuration读取xml配置具体使用。

这个章节主要实现自己的数据库连接池,封装自己的BasicDataSource类。实现自己业务的数据池。下面开始我们的项目构建。

1.1.1. maven依赖。

<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-dbcp2</artifactId>
<version>2.1.1</version>
<exclusions>
<exclusion>
<artifactId>commons-logging</artifactId>
<groupId>commons-logging</groupId>
</exclusion>
</exclusions>
</dependency>
 <dependency>
        <groupId>commons-configuration</groupId>
        <artifactId>commons-configuration</artifactId>
        <version>1.8</version>
    </dependency>
    <dependency>
        <groupId>commons-beanutils</groupId>
        <artifactId>commons-beanutils</artifactId>
        <version>1.8.0</version>
    </dependency>
    <dependency>
        <groupId>commons-jxpath</groupId>
        <artifactId>commons-jxpath</artifactId>
        <version>1.3</version>
</dependency>


1.1.2. 配置文件

数据库采用读写分离,所以定义了2个数据源配置,配置文件da2s.xml存放在src根目录下具体的配置如下:

<?xml version="1.0" encoding="UTF-8"?>
<da2s-configuration>
<DefaultConnectionPool>3000</DefaultConnectionPool>
<connectionPool name="3000">
<dbtype>MYSQL</dbtype>
<driverClassName>com.mysql.jdbc.Driver</driverClassName>
<url>jdbc:mysql://localhost:3306/springok</url>
<username>root</username>
<password></password>
<datasourceProperty>
<defaultAutoCommit>false</defaultAutoCommit>
<initialSize>10</initialSize>
<maxActive>10</maxActive>
<maxIdle>5</maxIdle>
<minIdle>5</minIdle>
<maxWait>3000</maxWait>
<validationQuery>select 1</validationQuery>
<testOnBorrow>true</testOnBorrow>
<removeAbandoned>true</removeAbandoned>
<removeAbandonedTimeout>180</removeAbandonedTimeout>
<logAbandoned>true</logAbandoned>
</datasourceProperty>
</connectionPool>
<connectionPool name="5000">
<dbtype>MYSQL</dbtype>
<driverClassName>com.mysql.jdbc.Driver</driverClassName>
<url>jdbc:mysql://localhost:3306/springok</url>
<username>root</username>
<password></password>
<datasourceProperty>
<defaultAutoCommit>false</defaultAutoCommit>
<initialSize>10</initialSize>
<maxActive>10</maxActive>
<maxIdle>5</maxIdle>
<minIdle>5</minIdle>
<maxWait>3000</maxWait>
<validationQuery>select 1</validationQuery>
<testOnBorrow>true</testOnBorrow>
<removeAbandoned>true</removeAbandoned>
<removeAbandonedTimeout>180</removeAbandonedTimeout>
<logAbandoned>true</logAbandoned>
</datasourceProperty>
</connectionPool>
</da2s-configuration>


1.1.3. DataSourceManager的实现(核心部分)

package cn.xhgg.test;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLClientInfoException;
import java.sql.SQLException;
import java.util.Enumeration;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
 
import javax.sql.DataSource;
 
import org.apache.commons.configuration.XMLConfiguration;
import org.apache.commons.dbcp2.BasicDataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.google.common.base.Preconditions;
 
public class DataSourceManager {
private final static Logger log = LoggerFactory.getLogger(DataSourceManager.class);
static private ConcurrentHashMap<String, DataSource> pools = new ConcurrentHashMap<>();
static private ConcurrentHashMap<String, String> dbTypes = new ConcurrentHashMap<>();
static private String catalina_base = System.getProperty("catalina.base");
static private String log_file_name = "dbcp2_exception.log";
 
static private String DefaultConnectionPoolName = null;
/**
 * 建构函数私有以防止其它对象创建本类实例
 */
private DataSourceManager() {
initDataSource();
}
 
/**
 * 返回唯一实例.如果是第一次调用此方法,则创建实例
 *
 * @return DBConnectionManager 唯一实例
 */
static public DataSourceManager getInstance() {
return DataSourceManager2Holder.instance;
}
 
/** 该类的一个对象,整个系统公用这一个对象。 */
private static class DataSourceManager2Holder {
private static DataSourceManager instance = new DataSourceManager();
}
 
/**
 * 根据指定属性创建连接池实例.
 *
 * @param props
 *            连接池属性
 */
private void initDataSource() {
XMLConfiguration config;
try {
config = new XMLConfiguration("da2s.xml");
config.setThrowExceptionOnMissing(false);
} catch (org.apache.commons.configuration.ConfigurationException exc) {
log.error("GlobalConfigurationException", exc);
throw new RuntimeException(exc);
}
 
DefaultConnectionPoolName = config.getString("DefaultConnectionPool");
// 该项未配置,则值为null
log.debug("DefaultConnectionPoolName is " + DefaultConnectionPoolName + "...");
List<?> poolList = config.getList("connectionPool.dbtype");
String connPoolName = new String();
String dbtype = new String();
String driverClassName = new String();
String url = new String();
String username = new String();
String password = new String();
boolean defaultAutoCommit = false;
boolean defaultReadOnly = false;
int initialSize = 0;
int maxActive = 0;
int maxIdle = 0;
int minIdle = 0;
long maxWait = 0;
String validationQuery = new String();
boolean testOnBorrow = true;
boolean removeAbandoned = true;
int removeAbandonedTimeout = 0;
boolean logAbandoned = true;
long maxConnLifetimeMillis = 0;
 
try {
for (int i = 0, j = poolList.size(); i < j; i++) {
connPoolName = config.getString("connectionPool(" + i + ")[@name]");
dbtype = config.getString("connectionPool(" + i + ").dbtype");
driverClassName = config.getString("connectionPool(" + i + ").driverClassName");
url = config.getString("connectionPool(" + i + ").url");
username = config.getString("connectionPool(" + i + ").username");
password = config.getString("connectionPool(" + i + ").password");
defaultAutoCommit = config.getBoolean("connectionPool(" + i + ").datasourceProperty.defaultAutoCommit", false);
defaultReadOnly = config.getBoolean("connectionPool(" + i + ").datasourceProperty.defaultReadOnly", false);
initialSize = config.getInt("connectionPool(" + i + ").datasourceProperty.initialSize", 3);
maxActive = config.getInt("connectionPool(" + i + ").datasourceProperty.maxActive", 50);
maxIdle = config.getInt("connectionPool(" + i + ").datasourceProperty.maxIdle", 20);
minIdle = config.getInt("connectionPool(" + i + ").datasourceProperty.minIdle", 5);
maxWait = config.getLong("connectionPool(" + i + ").datasourceProperty.maxWait", 3000);
maxConnLifetimeMillis = config.getLong("connectionPool(" + i + ").datasourceProperty.maxLifetime", 600000);// 10分钟
validationQuery = config.getString("connectionPool(" + i + ").datasourceProperty.validationQuery", "select 1");
testOnBorrow = config.getBoolean("connectionPool(" + i + ").datasourceProperty.testOnBorrow", true);
removeAbandoned = config.getBoolean("connectionPool(" + i + ").datasourceProperty.removeAbandoned", true);
removeAbandonedTimeout = config.getInt("connectionPool(" + i + ").datasourceProperty.removeAbandonedTimeout", 180);
logAbandoned = config.getBoolean("connectionPool(" + i + ").datasourceProperty.logAbandoned", true);
 
BasicDataSource bds2 = new BasicDataSource();
bds2.setDriverClassName(driverClassName);
bds2.setUrl(url);
bds2.setUsername(username);
bds2.setPassword(password);
bds2.setDefaultAutoCommit(defaultAutoCommit);
bds2.setDefaultReadOnly(defaultReadOnly);
bds2.setDefaultTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
// 初始化连接数
bds2.setInitialSize(initialSize);
// 最小空闲连接
bds2.setMinIdle(minIdle);
// 最大空闲连接
bds2.setMaxIdle(maxIdle);
// 超时回收时间(以毫秒为单位)
bds2.setMaxWaitMillis(maxWait);
// 最大连接数
bds2.setMaxTotal(maxActive);
bds2.setTestOnBorrow(testOnBorrow);
bds2.setValidationQuery(validationQuery);
// 一个连接的最大存活毫秒数。如果超过这个时间,则连接在下次激活、钝化、校验时都将会失败。如果设置为0或小于0的值,则连接的存活时间是无限的。
bds2.setMaxConnLifetimeMillis(maxConnLifetimeMillis);
 
// 空闲对象驱逐线程运行时的休眠毫秒数,如果设置为非正数,则不运行空闲对象驱逐线程。
long timeBetweenEvictionRunsMillis = 1000;
bds2.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
 
// 超时取回
bds2.setLogAbandoned(logAbandoned);
bds2.setAbandonedUsageTracking(logAbandoned);
bds2.setRemoveAbandonedOnMaintenance(removeAbandoned);
bds2.setRemoveAbandonedOnBorrow(removeAbandoned);
bds2.setRemoveAbandonedTimeout(removeAbandonedTimeout);
pools.put(connPoolName, bds2);
dbTypes.put(connPoolName, dbtype);
log.debug("Init DataSource " + connPoolName + "...");
 
}
} catch (Exception e) {
log.error("Init DataSource " + connPoolName + "...ERROR", e);
throw new RuntimeException(e);
}
}
 
/**
 * 动态添加连接池
 */
public boolean addDataSource(String key, DataSource datasource) {
pools.put(key, datasource);
return true;
}
/**
 * 动态删除连接池
 */
public void removeDataSource(String key) {
if (key == null)
return;
BasicDataSource cds = (BasicDataSource) pools.remove(key);
try {
cds.close();
} catch (SQLException e) {
log.error("Close DS Error key={}", key, e);
}
cds = null;
}
/**
 * 获取一个默认的可用连接.
 *
 * @return DataSource
 */
public DataSource getDataSource() {
if (DefaultConnectionPoolName == null || DefaultConnectionPoolName.trim().isEmpty())
return null;
else
return (DataSource) pools.get(DefaultConnectionPoolName);
}
 
/**
 * 获取一个可用连接.
 *
 * @param name
 *            连接池名字
 * @return DataSource
 */
public DataSource getDataSource(String name) {
return (DataSource) pools.get(name);
}
 
/**
 * close all connection. <br>
 * 关闭所有闲置连接.
 */
 
public synchronized void shutdown() {
Enumeration<String> allkeys = pools.keys();
 
while (allkeys.hasMoreElements()) {
String poolName = (String) allkeys.nextElement();
log.warn("DataSourceManager shutdown pool[{}]...", poolName);
BasicDataSource cpds = (BasicDataSource) pools.remove(poolName);
try {
cpds.close();
} catch (SQLException e) {
log.error("Close DS Error key={}", poolName, e);
}
cpds = null;
dbTypes.remove(poolName);
}
}
 
public String getDefaultDataSourceName() {
return DefaultConnectionPoolName;
}
 
public String getDBType(String name) {
return (String) dbTypes.get(name);
}
public Set<String> getPoolNames() {
return pools.keySet();
}
 
/**
 * 获取一个默认的可用连接.
 *
 * @return DataSource
 */
public Connection getConnection() {
return getConnection(DefaultConnectionPoolName);
}
 
/**
 * 获取一个可用连接.
 *
 * @param name
 *            连接池名字
 * @return DataSource
 */
public Connection getConnection(String name) {
// Objects.requireNonNull(name, "PoolName should not be null");
Preconditions.checkNotNull(name, "PoolName should not be null");
Preconditions.checkArgument(!name.trim().isEmpty(), "PoolName should not be empty");
 
BasicDataSource thisDS = (BasicDataSource)pools.get(name);
//String dbType = dbTypes.get(name);
Preconditions.checkState(thisDS != null, "DataSource " + name + " is null");
Preconditions.checkState(!thisDS.isClosed(), "DataSource " + name + " has closed");
try {
Connection conn = thisDS.getConnection();
//setCallerInfo(conn);
return conn;
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
/**
 * 获取直接的数据库conn
 * 
 * @param driverClassName
 * @param dbUrl
 * @param userName
 * @param password
 * @return
 * @throws InstantiationException
 * @throws IllegalAccessException
 * @throws ClassNotFoundException
 * @throws SQLException
 */
public static Connection getDirectJDBCConnection(String driverClassName, String dbUrl, String userName, String password) throws InstantiationException,
IllegalAccessException, ClassNotFoundException, SQLException {
 
Class.forName(driverClassName).newInstance();
Connection conn = DriverManager.getConnection(dbUrl, userName, password);
return conn;
}
 
}


1.1.4. JdbcUtils工具类实现

package cn.xhgg.test;
import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;
 
public class JdbcUtils {
// 使用ThreadLocal存储当前线程中的Connection对象
private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();
 
/**
 * 获取读数据源
 * @return
 * @throws SQLException
 */
public static DataSource getReadDataSource(){
return DataSourceManager.getInstance().getDataSource("3000");
}
/**
 * 获取写数据源
 * @return
 */
public static DataSource getWriteDataSource(){
return DataSourceManager.getInstance().getDataSource("3000");
}
 
public static Connection getConnection() throws SQLException {
// 从当前线程中获取Connection
Connection conn = threadLocal.get();
if (conn == null) {
throw new SQLException("no connection init");
}
return conn;
}
public static Connection getConnection(boolean isCreate) throws SQLException {
// 从当前线程中获取Connection
Connection conn = threadLocal.get();
if (conn == null&&isCreate) {
 loadReadConnection();
}
return getConnection();
}
 
/**
 * @Method: startTransaction
 * @Description: 开启事务
 *
 */
public static void loadReadConnection() {
try {
Connection conn = threadLocal.get();
if (conn == null) {
conn = getReadDataSource().getConnection();
// 把 conn绑定到当前线程上
threadLocal.set(conn);
}
// 开启事务
conn.setAutoCommit(false);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
 * @Method: startTransaction
 * @Description: 开启事务
 *
 */
public static void startTransaction() {
try {
Connection conn = threadLocal.get();
if (conn == null) {
conn = getWriteDataSource().getConnection();
// 把 conn绑定到当前线程上
threadLocal.set(conn);
}
// 开启事务
conn.setAutoCommit(false);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
 
/**
 * @Method: rollback
 * @Description:回滚事务
 *
 */
public static void rollback() {
try {
// 从当前线程中获取Connection
Connection conn = threadLocal.get();
if (conn != null) {
// 回滚事务
conn.rollback();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
 
/**
 * @Method: commit
 * @Description:提交事务
 *
 */
public static void commit() {
try {
// 从当前线程中获取Connection
Connection conn = threadLocal.get();
if (conn != null) {
conn.commit();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
 
/**
 * @Method: close
 * @Description:关闭数据库连接(注意,并不是真的关闭,而是把连接还给数据库连接池)
 *
 */
public static void close() {
try {
// 从当前线程中获取Connection
Connection conn = threadLocal.get();
if (conn != null) {
conn.close();
// 解除当前线程上绑定conn
threadLocal.remove();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static boolean isClosed(){
try {
// 从当前线程中获取Connection
Connection conn = threadLocal.get();
if (conn != null) {
return false;
}
} catch (Exception e) {
throw new RuntimeException(e);
}
return true;
}
 
}


1.1.5. 测试

Connection connection = JdbcUtils.getConnection(true);
System.out.println(connection);


输出如下图:

 

测试OK

1.1.6. 思考获取数据库连接与ThreadLocal

用户的请求处理过程: controller-->>service-->>dao层。

所以先实例化controller层并初始化service实例对象,调用service方法,service实例化依赖的dao层。并进行数据库的操作。然后依次返回。

OpenSessionInView模式不就是解决session关闭,不能在层之间传递的问题。

逻辑如下图:

 


 

 

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
ECS远程连接和ECS控制台使用
使用好ECS控制台,可以让ECS的使用事半功倍。
661 0
阿里云ECS连接数据库教程方法
阿里云ECS云服务器如何连接RDS云数据库?云吞铺子总结首先将ECS加入到RDS白名单,然后获取到RDS的连接地址、RDS的数据库用户名、密码及数据库名即可连接,云吞铺子分享详细的操作方法: 将ECS添加到RDS的白名单中 出于安全考虑,RDS默认自带了白名单规则,想要让ECS连接RDS数据库必须.
4569 0
Tomcat使用线程池配置高并发连接
Tomcat使用线程池配置高并发连接1:配置executor属性 打开/conf/server.xml文件,在Connector之前配置一个线程池: namePrefix="tomcatThreadPool-" maxThreads="1000" maxIdleTime="300000" minSpareThreads="200"/> 重要参数说明:name:共享线程池的名字。
1054 0
在ArcGIS中如何使用直连方式连接Oracle数据库
1.      背景 直连方式比使用SDE方式更加稳定,特别是在大数据量处理的应用中,不易出场由SDE连接进程造成的gsvr错误。
1051 0
如何使用 Workbench 远程连接到 MySQL 数据库 -MySQL Workbench 使用教程
MySQL Workbench 是一款专门为 MySQL 设计的可视化数据库 GUI 管理工具,我们可以在自己的计算机上,使用图形化界面(GUI)远程管理 MySQL 数据库。有关 MySQL 远程管理软件,你可以选择 Windows 下的 HeidiSQL,MacOS 下的 Sequel Ace 或者 MySQL 官方推出的跨平台客户端 MySQL Workbench
359 0
关于java连接SQL数据库
版权声明:本文为博主原创文章,转载请注明出处。 https://blog.csdn.net/twilight_karl/article/details/53307371 1 .
685 0
阿里云MySQL云数据库和Redis6.0数据库使用体验
阿里云MySQL云数据库和Redis6.0数据库使用体验
1611 0
MySQL---数据库从入门走向大神系列(十四)-ComboPooledDataSource(C3P0连接池配置)
需要准备的jar包: MySQL的jar包mysql-connector-java-5.1.39-bin目前是5.1.39版本: http://dev.mysql.com/downloads/connector/j/ C3p0的2个包: https://sourceforge.
1181 0
+关注
分享达人
开源爱好者,喜欢钻研新技术。Activiti权威指南一书作者。
131
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
《2021云上架构与运维峰会演讲合集》
立即下载
《零基础CSS入门教程》
立即下载
《零基础HTML入门教程》
立即下载