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

上一个章节，我们讲了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关闭，不能在层之间传递的问题。

逻辑如下图：

 

 

 

时间： 2024-10-28 19:11:14

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

PHP将MYSQL内容读到二维数组并按指定列输出

PHP将MYSQL内容读到二维数组并按指定列输出 <? $host = "localhost";   //主机名 $user = "root";        //mysql用户名 $password = "";    //mysql密码 $database = "doc";  //mysql数据库名 $tables = "mclass";  //表名 $conn=mysql_connect(&quo

【JAVA秒会技术之玩转SQL】MySQL优化技术（二）

MySQL优化技术(二) [前文连接]MySQL优化技术(一) (五)常用SQL优化 1.默认情况,在使用group by 分组查询时,会先分组,其后还会默认对组内其他条件进行默认的排序,可能会降低速度.这与在查询中指定order by col1, col2类似. 如果查询中包括group by但用户想要避免排序结果的消耗,则可以使用order by null禁止排序. 例子:   2.尽量使用左连接(或右连接)来替代普通多表联查.因为使用JOIN,MySQL不需要在内存中创建临时表.    s

Mysql学习笔记（二）数据类型 补充

原文:Mysql学习笔记(二)数据类型 补充 PS:简单的补充一下数据类型里的String类型以及列类型... 学习内容: 1.String类型 2.列类型存储需求   String类型: i.char与varchar char与varchar的类型相似,但是他们的保存方式和检索方式不同... char的存储结构是固定长度的存储...即指定了几个字节,那么就占用几个字节,如char(4),那么无论存入的是什么字串,那么都占用四个字节...char的 可表示长度范围为0-255的任何值,当保存的字

tomcat-web编程数据库连接池jdbc的一个问题，连接池感觉弄好了，还是不行哪里错了

问题描述 web编程数据库连接池jdbc的一个问题,连接池感觉弄好了,还是不行哪里错了 org.apache.jasper.JasperException: An exception occurred processing JSP page /exa7_7.jsp at line 18 15: Context initCtx = new InitialContext(); //这里四句是连接池的关键语句,见教材 16: Context envCtx = (Context) initCtx.loo

我的MYSQL学习心得（二）

原文:我的MYSQL学习心得(二) 我的MYSQL学习心得(二) 我的MYSQL学习心得(一) 我的MYSQL学习心得(三) 我的MYSQL学习心得(四) 我的MYSQL学习心得(五) 我的MYSQL学习心得(六) 显示宽度   MYSQL中的整数型数据类型都可以指定显示宽度,而SQLSERVER不行     创建一个表 CREATE TABLE tb_emp( id BIGINT(1)) id字段的数据类型为BIGINT(1),注意到后面的数字1,这表示的是该数据类型指定的显示宽度,指定能够显

可以介绍一下c3p0连接池和自己写的向量连接池的区别么？

问题描述 可以介绍一下c3p0连接池和自己写的向量连接池的区别么? 可以介绍一下c3p0连接池和自己写的Vector向量连接池的区别么? 解决方案 一个是系统的 一个是自定义的

MySQL系列教程（二）

mySQL执行计划 语法  explain <sql语句> 例如:  explain select * from t3 where id=3952602; explain输出解释 +----+-------------+-------+-------+-------------------+---------+---------+-------+------+-------+| id | select_type | table | type  | possible_keys     | key

mysql dba系统学习（15）mysql用户管理之二

mysql用户管理 一,创建和删除用户 mysql> select current_user();  查询当前的登录用户 +----------------+ | current_user() | +----------------+ | root@localhost | +----------------+  创建用户的时候没有分配任何权限,%表示的是任何机器,但是不包括localhost和127.0.0.1 mysql> create user 'chenzhongyang'@'%' id

03_dbcp数据源依赖jar包，DBCP中API介绍，不同过dbcp方式使用dbcp数据库连接池，通过配置文件使用dbcp数据库连接池

 DBCP数据源 使用DBCP数据源,需要导入两个jar包 Commons-dbcp.jar:连接池的实现 Common-pool.jar:连接池实现的依赖库.   导入mysql的jar包.   DBCP核心API BasciDataSource   它可以通过实例化对象的方式获得一个对象. 它里面有如下方法: setDriverClassName(String driverClassName) 设置驱动类的名称. setInitialSize(int initialSize) 设置初始化