JDBC 连接池

最新推荐文章于 2023-06-11 20:35:15 发布
最新推荐文章于 2023-06-11 20:35:15 发布
阅读量261 收藏 1
点赞数
分类专栏： java 数据库 文章标签： 数据库 mysql jdbc 数据库连接池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csxiewoxiexie/article/details/54409206
版权

1.创建jdbc配置文件 ds.config.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/competition
username=root
password=123456
maxConnection=10
initialConnection=5

2.编写数据库连接池类

package com.Tool.sql;

import java.io.IOException;
import java.io.InputStream;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Properties;

public class ConnectionPool {
	
	private String dbDriver = "";           //数据库驱动
	private String dbUrl = "";              //数据URL
	private String dbUsername = "";         //数据库用户名
	private String dbPassword = "";         //数据库用户密码
	
	private String testTable = "";          //测试连接是否可用的测试表名，默认没有测试表
	
	private int initialConnection = 0;      //连接池的初始大小
//	private int incrementalConnection = 0;  //连接池自动增加的大小
	private int maxConnections = 0;         //连接池的最大的大小
	
	private int inUsedConnection = 0;       //已使用的连接数
	
	static private long m_lastClearClosedConnection = System.currentTimeMillis();
	private static long CHECK_CLOSED_CONNECTION_TIME = 3 * 60 * 60 * 1000/*250*/; //3 hours  
	
	
    //使用LinkedList集合来存放数据库链接，
	private static LinkedList<Connection> listConnections = new LinkedList<Connection>();       

	private static ConnectionPool connectionPool = new ConnectionPool();
	
	/**
	 * 构造函数
	 * 功能：获取数据库配置文件数据，
	 *       并创建初始数量大小的数据库连接放在连接池中
	 */
	private ConnectionPool() {
		
		InputStream in = JdbcConnectionPool.class.getClassLoader().getResourceAsStream("ds.config.properties");
		Properties prop = new Properties();
		try {
			prop.load(in);
		} catch (IOException e) {
			e.printStackTrace();
		}
		dbDriver = prop.getProperty("driver");
		dbUrl = prop.getProperty("url");
		dbUsername = prop.getProperty("username");
		dbPassword = prop.getProperty("password");
		initialConnection = Integer.parseInt(prop.getProperty("initialConnection"));
		maxConnections = Integer.parseInt(prop.getProperty("maxConnection"));
		
		initConnectionPool();
	}
	
	//单例
	public static ConnectionPool getIntense(){
		return connectionPool;
	}
	
	/**
	 * 函数名：initConnectionPool
	 * 功能：初始化数据库连接池listConnections
	 * 参数：
	 * 返回值：void
	 */
	private void initConnectionPool(){
		
		try {
			//加载数据库驱动
			Class.forName(dbDriver);

			for(int i=0; i<initialConnection; i++){
				Connection conn = newConnection();
//				System.out.println("获取到了连接---" + conn);
				//将获取到的数据库连接加入到listConnections集合中，
				//listConnections集合此时就是一个存放了数据库连接的连接池
				listConnections.add(conn);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 时间：2016-3-31 下午07:26:08
	 * 函数名：getConnection
	 * 功能：得到连接
	 * 参数：@return
	 * 返回值：Connection
	 * @throws SQLException 
	 */
	public synchronized Connection getConnection() throws SQLException{
		
		clearClosedConnection();  
		
		if(listConnections == null){
			System.out.println("连接池没创建");
			throw new SQLException("连接池没创建");
		}
		Connection conn = null;
		
		// 1.获得一个可用的数据库连接
		conn = getFreeConnection();
		
		// 2.如果连接为空，等待一会，重新再试
		if(conn == null){
			wait(5000);       //等待5秒
			conn = getFreeConnection();      // 重新再试
			if(conn == null){
				throw new SQLException("连接超时，没有可用连接");
			}
		}
		
//		while(conn == null){
//			wait(250);       //等待250毫秒
//			conn = getFreeConnection();      // 重新再试
//		}
		
		//3.如果获得可用连接，使用连接数量变量加1
		if(conn != null){
			inUsedConnection++;
			System.out.println("现有" +inUsedConnection+ "个连接在使用");
			System.out.println("数据库连接池大小是---" + listConnections.size());
		}
		
		return conn;
		
	}
	
	
	/**
	 * 时间：2016-4-1 下午06:00:38
	 * 函数名：getFreeConnection
	 * 功能：得到可用的连接
	 * 参数：@return
	 * 返回值：Connection
	 */
	private Connection getFreeConnection(){
		
		Connection conn = null;
		
		//如果数据库连接池中有连接对象，取出连接返回
		if(listConnections.size() > 0){
			
			//从connections集合中获取一个数据库连接，并删除数据库中的这个连接
			conn = listConnections.removeFirst(); 
			
		}else{
			
			//1.如果已创建连接数已达到数据库最大连接数
			if(inUsedConnection>=maxConnections){
				conn = null;
			}else{
				//2.否则，新建连接
			    conn = newConnection();  
			}
			
		}
		
		return conn;
	}
	
	
	/**
	 * 时间：2016-4-2 下午06:41:09
	 * 函数名：returnConnection
	 * 功能：用完，返回连接，放回到连接池中
	 * 参数：@param conn
	 * 参数：@param st
	 * 参数：@param rs
	 * 返回值：void
	 */
	public synchronized void returnConnection(Connection con,PreparedStatement ps,ResultSet res){
		
		//1.确保连接池存在，如果连接池不存在，则关闭相关连接，然后直接返回
		if(listConnections == null){
			System.out.println("连接池不存在，无法返回到此连接池中！");
//			throw new MyException("连接池不存在，无法返回到此连接池中！");
			if(con != null){
				closeConnection(con);
			}
			
			try {
				if(ps != null){
					ps.close();
				}
				if(res != null){
					res.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			return;
		}
		
		//2.将连接返回到连接池中并关闭相关连接
		listConnections.add(con);
		
		try {
			if(ps != null){
				ps.close();
			}
			if(res != null){
				res.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		
		inUsedConnection--;
		
		System.out.println("返回连接");
	}
	
	/**
	 * 时间：2016-4-4 下午06:00:20
	 * 函数名：returnConnection
	 * 功能：用完，返回连接，放回到连接池中
	 * 参数：@param con
	 * 参数：@param cs
	 * 参数：@param res
	 * 返回值：void
	 */
	public synchronized void returnConnection(Connection con,CallableStatement cs,ResultSet res){
		
		//1.确保连接池存在，如果连接池不存在，则关闭相关连接，然后直接返回
		if(listConnections == null){
			System.out.println("连接池不存在，无法返回到此连接池中！");
//			throw new MyException("连接池不存在，无法返回到此连接池中！");
			if(con != null){
				closeConnection(con);
			}
			
			try {
				if(cs != null){
					cs.close();
				}
				if(res != null){
					res.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			return;
		}
		
		//2.将连接返回到连接池中并关闭相关连接
		listConnections.add(con);
		
		try {
			if(cs != null){
				cs.close();
			}
			if(res != null){
				res.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		
		inUsedConnection--;
		
		System.out.println("返回连接");
	}

	
	/**
	 * 时间：2016-4-4 下午05:52:35
	 * 函数名：用完，返回连接，放回到连接池中
	 * 功能：TODO
	 * 参数：@param conn
	 * 参数：@param st
	 * 返回值：void
	 */
	public synchronized void returnConnection(Connection conn,PreparedStatement st){
		
		//1.确保连接池存在，如果连接池不存在，则关闭相关连接，然后直接返回
		if(listConnections == null){
			System.out.println("连接池不存在，无法返回到此连接池中！");
//			throw new MyException("连接池不存在，无法返回到此连接池中！");
			if(conn != null){
				closeConnection(conn);
			}
			
			try {
				if(st != null){
					st.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			return;
		}
		
		//2.将连接返回到连接池中并关闭相关连接
		listConnections.add(conn);
		
		try {
			if(st != null){
				st.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		
		inUsedConnection--;
		
		System.out.println("返回连接");
	}
	
	/**
	 * 时间：2016-3-31 下午08:51:57
	 * 函数名：returnConnection
	 * 功能：用完，返回连接，放回到连接池中
	 * 参数：@param conn
	 * 返回值：void
	 */
	public synchronized void returnConnection(Connection conn){
		
		//1.确保连接池存在，如果连接池不存在，则关闭相关连接，然后直接返回
		if(listConnections == null){
			System.out.println("连接池不存在，无法返回到此连接池中！");
//			throw new MyException("连接池不存在，无法返回到此连接池中！");
			if(conn != null){
				closeConnection(conn);
			}
			return;
		}
		
		//2.将连接返回到连接池中并关闭相关连接
		listConnections.add(conn);
		inUsedConnection--;
		
		System.out.println("返回连接");
	}
	
	/**
	 * 时间：2016-3-31 下午03:06:10
	 * 函数名：newConnection
	 * 功能：创建一个新的数据库连接并返回
	 * 参数：@return
	 * 参数：@throws SQLException
	 * 返回值：Connection
	 */
	private Connection newConnection(){
		
		//创建一个数据库连接
		Connection conn = null;
		try {
			conn = DriverManager.getConnection(dbUrl, dbUsername, dbPassword);
			
//			System.out.println("创建连接");
			//如果是第一次创建连接，检查数据库，获得此数据库允许支持的最大客户连接数目
			//connections.size()==0&&inUsedConnection==0表示目前没有连接已被创建
			if(listConnections.size()==0 && inUsedConnection==0){
				
				DatabaseMetaData metaData = conn.getMetaData();
				int driverMaxConnections = metaData.getMaxConnections();
				//数据库返回的driverMaxConnection若为0，表示此数据库没有最大连接限制
				//或数据库的最大连接限制不知道
				//driverMaxConnection为返回的一个整数，表示此数据库允许客户连接的数目
				//如果连接池中设置的最大连接数量大于数据库允许的连接数目，则连接池的最大
				//连接数目为数据库允许的最大数目
				
				if(driverMaxConnections>0 && this.maxConnections>driverMaxConnections){
					this.maxConnections = driverMaxConnections;
				}
			}
		} catch (SQLException e) {
			
			e.printStackTrace();
		}
		return conn;
	}
	
	/**
	 * 时间：2016-3-31 下午10:20:00
	 * 函数名：releaseConnection
	 * 功能：释放所有连接
	 * 参数：
	 * 返回值：void
	 */
	public synchronized void releaseConnection(){
		
		Iterator allConns = listConnections.iterator();
		
		while(allConns.hasNext()){
			Connection conn = (Connection) allConns.next();
			
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
		listConnections.clear();
	}
	
	/**
	 * 时间：2016-4-1 下午04:26:12
	 * 函数名：closeConnection
	 * 功能：关闭一个数据库连接
	 * 参数：@param conn
	 * 返回值：void
	 */
	private void closeConnection(Connection conn){
		try {
			conn.close();
		} catch (SQLException e) {
			System.out.println("关闭数据库连接出错" + e.getMessage());
		}
	}

	/**
	 * 时间：2016-4-1 下午04:30:15
	 * 函数名：testConnection
	 * 功能：测试连接是否可用
	 * 参数：@param conn
	 * 参数：@return
	 * 返回值：boolean
	 */
	private boolean testConnection(Connection conn){
		
		try {
			//判断测试表是否存在
			if(testTable.equals("")){
				conn.setAutoCommit(true);
			}else{
				Statement stmt = conn.createStatement();
				stmt.execute("select count(*) from " + testTable);
			}
			
		} catch (SQLException e) {
			closeConnection(conn);
			return false;
		}
		return true;
	}
	
	/**
	 * 时间：2016-4-1 下午04:31:15
	 * 函数名：wait
	 * 功能：使程序等待给定的毫秒数
	 * 参数：@param mSeconds
	 * 返回值：void
	 */
	private void wait(int mSeconds){
		
		try {
			Thread.sleep(mSeconds);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	
	/**
	 * 时间：2016-4-2 下午03:18:18
	 * 函数名：clearClosedConnection
	 * 功能：关闭多余的连接
	 * 参数：
	 * 返回值：void
	 */
	private void clearClosedConnection(){
		
		long time = System.currentTimeMillis();  
		
		//1.时间不合理，没有必要检查
		if(time < m_lastClearClosedConnection){
			time = m_lastClearClosedConnection;
			return;
		}
		
		//2.时间太短，没有必要检查
		if(time - m_lastClearClosedConnection < CHECK_CLOSED_CONNECTION_TIME){
			return;
		}
		
		m_lastClearClosedConnection = time;
		
		//3.开始检测连接池中是否有已关闭的连接
		Iterator iterator = listConnections.iterator();
		while(iterator.hasNext()){
			Connection conn = (Connection) iterator.next();
			
			try {
				if(conn.isClosed()){
					iterator.remove();  
				}
			} catch (SQLException e) {
				iterator.remove();  
				e.printStackTrace();
			}
		}
		
		//4.清除多余的Connection
		int decrease = getDecreasingConnectionCount();
		
		while (decrease > 0 && listConnections.size() > 0) {
		
			Connection conn = listConnections.removeFirst();
			closeConnection(conn);
			
			decrease--;
		}
	}
	
	
	/**
	 * 时间：2016-4-2 下午03:16:00
	 * 函数名：getDecreasingConnectionCount
	 * 功能：得到需要减少的连接数
	 * 参数：@return
	 * 返回值：int
	 */
	private int getDecreasingConnectionCount(){
		int count = 0;
		int current = listConnections.size() + inUsedConnection;
		
		if(current > initialConnection){
			count = current-initialConnection;
		}
		
		return count;
	}
	
	
}

3.用法

package com.Tool.sql;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class test implements Runnable{

	ConnectionPool pool = ConnectionPool.getIntense();
	
	public static void main(String[] args) {
		test test1 = new test();
		for(int i=0; i<100; i++){
			Thread a = new Thread(test1, "线程"+i);
			a.start();
		}

	}

	@Override
	public void run() {
		String sql = "select * from user where UserId = 62";
		ResultSet rs = null;
		PreparedStatement statement = null;
		Connection conn = null;
			
		try {
			conn = pool.getConnection();
			statement = conn.prepareStatement(sql);
			rs = statement.executeQuery(sql);
			
			while(rs.next()){
				System.out.println(Thread.currentThread().getName() + 
						"--->" + "id:" + rs.getInt("UserId")+ "用户名" + rs.getString("UserName"));
			}
		}catch (SQLException e) {
			e.printStackTrace();
		}finally{
			pool.returnConnection(conn,statement,rs);
		}
	}


}
则简单
关注
专栏目录
jdbc数据库连接池连接
kikock的博客
06-07 736
c3p0-config.xml 配置文件 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;c3p0-config&gt; &lt;named-config name="mysql"&gt; &lt;!-- 配置数据库用户名 --&gt; &lt;property name="
JDBC连接池
m0_46568163的博客
07-03 1579
连接池是创建和管理一个连接的缓冲池的技术，这些连接准备好被任何需要它们的 线程 使用。
记录：Sharding-Jdbc 配置max.connections.size.per.query造成的死锁问题
qq_37402304的博客
01-30 2444
Sharding-Jdbc 配置max.connections.size.per.query造成的死锁问题 项目场景： 版本：jdk11，sharding-jdbc4.1.1，mysql8.0 分表：table表根据 主键id 水平分表，分为10张表，即table_$->{0…9} 精简后的场景代码： @Transactional(rollbackFor = Exception.class) public void update(List<Long> ids) {
sharding-jdbc中的max.connections.size.per.query
firstendhappy的博客
09-12 3115
分表项目启动慢的问题，sharding-jdbc中的max.connections.size.per.query
JDBC Connection Configuration & JDBC Request 详解
小白裸奔
10-23 1万+
JDBC Connection Configuration & JDBC Request Jmeter同样可以测试数据库的性能，通过执行增删改查的语句，以下举的是oracle的例子 Step 1: 下载ojdbc14.jar包放到Jmeter lib包中 或 在test plan中配置（二者均可），并且重启Jmeter Step 2：配置JDBC Connection Configu
JDBC 连接池 详解（通俗易懂）
Cyan_RA9的博客
06-11 7236
JDBC 第五节 详解连接池 通俗易懂！
JDBC连接池详解
Dmeo_meng的博客
03-29 4550
文章目录一、JDBC数据库连接池的必要性二、数据库连接池技术1、数据库连接池的基本思想：2、数据库连接池的工作原理：3、数据库连接池技术的优点：三、多种开源的数据库连接池 一、JDBC数据库连接池的必要性 1、在使用开发基于数据库的web程序时，传统的模式基本是按以下步骤： （1）在主程序（如servlet、beans）中建立数据库连接 （2）进行sql操作 （3）断开数据库连接 2、这种模式开发，存在的问题: （1）普通的JDBC数据库连接使用 DriverManager 来获取，每次向数据库建立
自定义一个简单的JDBC连接池实现方法
08-28
自定义一个简单的JDBC连接池实现方法 知识点一：什么是JDBC连接池？ JDBC连接池是一种优化数据库连接的方法，在传统的JDBC连接中，每次获得一个Connection连接都需要加载通过一些繁杂的代码去获取，这样繁杂的...
java实现jdbc连接池+相关jar包
03-02
本文将详细介绍如何使用Java实现JDBC连接池，以及涉及到的相关库和jar包。 首先，Java JDBC（Java Database Connectivity）是Java平台中用于与各种数据库进行交互的一组标准API。要实现JDBC连接池，我们需要引入几...
JDBC连接池使用工具 C3P0 连接池 and druid-1.0.9
04-11
C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。C3P0的主要特点包括： 1. **连接测试**：C3P0提供了多种测试策略，确保获取到的连接是可用的。 2. **连接池初始化和最大...
HikariCP JDBC连接池 v3.4.5.zip
最新发布
03-21
HikariCP是一款高效、高性能的Java JDBC连接池，它被设计为替代传统连接池如C3P0和DBCP，以提供更快、更稳定的数据访问性能。在HikariCP v3.4.5这个版本中，我们可以深入探讨其在数据库连接管理、性能优化以及配置...
JDBC连接池驱动.zip
02-25
JDBC（Java Database Connectivity）是Java平台中用于与数据库交互的一组接口和类，而JDBC连接池就是在这个基础上实现的一种优化策略。本文将详细介绍JDBC连接池驱动的相关知识，主要涉及`mysql-connector-java-...
jdbc源码详解（二）：获取connection
木东居士
06-30 3454
0x00 前言上一节分析了jdbc的Driver注册过程，这一节分析一下jdbc是如何获取connection的。0x01 connection的建立过程DriverManager.getConnection 做了什么conn = DriverManager.getConnection("jdbc:mysql://192.168.108.145/test", "root", "root");可以看出
java---获取当前系统时间--纳秒
热门推荐
csxiewoxiexie的专栏
04-22 1万+
long startTime = System.nanoTime(); //开始時間 //这里写操作 //消耗時間 long consumingTime = System.nanoTime() - startTime; System.out.println("操作消耗时间--" + consumingTime + "纳秒");然后运行就可以了
Spring mvc 接受页面数据 和 返回页面数据 方法 总结
csxiewoxiexie的专栏
10-10 2371
1. 接受页面数据1、HttpServletRequest@RequestMapping(value="/addUser1.do") public String addUser1(HttpServletRequest request){ String userNum = request.getParameter("userNum"); String passWo
java 缓存--查成绩
csxiewoxiexie的专栏
04-19 891
现在正要写一个java缓存，查了很多资料，因为正在学习阶段，被要求不能用HashMap等，所以自己写了一个查成绩缓存。 先封装成绩缓存，单独写一个类，这样业务逻辑层能直接调用它，后期也比较容易维护。类里面是用Vector做容器的，存放成绩的实体类，然后再用一个比赛名称做变量名，用来当查成绩的时候，先对比是不是当前缓存内的比赛，不是就直接从数据库查询。 写完查成绩、导入成绩缓存、清除成绩缓存的函数。要
spingmvc 文件上传
csxiewoxiexie的专栏
10-24 341
一、单文件上传1.jar包2.springmvc-servlet.xml配置添加以下代码<!-- 文件上传设置 --> <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"> <property name="defaultE
spingmvc + mybatis jar包
csxiewoxiexie的专栏
10-23 295
一、spingmvc二、mybatis
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值