`

JAVA JDBC连接池

 
阅读更多

1.为什么要使用连接池

(1)对于开发者而言,通过JDBC获取数据连接,然后执行SQL,是很简单的事情

(2)对于JDBC Driver而言:具体到每一个数据库厂商的驱动实现

  • 首先建立应用服务器到数据库服务器之间的连接也就是Socket Connection
  • 接下来应用服务器和数据库服务器之间还有很多次数据交换,比如用户密码校验、权限认证等
  • 最后数据库应用服务器要初始化连接会话句柄,记录联机日志,并为这一次连接分配进程和系统资源

也就是说:建立一次连接可能花费500毫秒,而你执行一个SQL,很可能只花费50毫秒!!!可以看出来,系统如此忙碌,如果开发者只是执行一个简单的SQL,然后就把此次连接抛弃关闭了,浪费了很多系统资源

 

2.连接池应该具备什么样的特性

(1)能满足分布式数据源,比如一个应用可能连接多个数据库,或者一个数据库不能的权限

(2)具备事务处理能力,每一个事务独占一个连接来实现,降低事务管理的复杂性

(3)连接池的分配与释放,提高连接的复用度,从而降低建立新连接的开销

(4)连接池的配置与维护,设置最小连接数(minConn)和最大连接数(maxConn)来控制连接池中的连接

 

3.最基本连接池实现

 

package com.yli.dal;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

/**
 * 最基本连接池实现,本例使用静态单例,不使用多数据源<br>
 * 要使用多数据源,将单例改成普通模式即可
 * @author yli
 *
 */
public class ConnectionPool {

	private static ConnectionPool pool = null;

	private String poolName;

	private String driver;

	private String url;

	private String user;

	private String password;
	
	private final static int defaultMin = 5;
	
	private final static int defaultMax = 10;

	private int minConn = defaultMin;

	private int maxConn = defaultMax;

	private List<Connection> usedConnections = new ArrayList<Connection>();

	private List<Connection> freeConnections = new ArrayList<Connection>();

	/**
	 * 私有构造方法,初始化最小连接数
	 * @param poolName
	 * @param driver
	 * @param url
	 * @param user
	 * @param password
	 * @param minConn
	 * @param maxConn
	 */
	private ConnectionPool(String poolName, String driver, String url,
			String user, String password, int minConn, int maxConn) {
		this.poolName = poolName;
		this.driver = driver;
		this.url = url;
		this.user = user;
		this.password = password;
		this.minConn = minConn;
		this.maxConn = maxConn;
		initDriver();
		initPool();
	}

	/**
	 * 单例模式,构造连接池,使用默认的最小最大连接数
	 * @param poolName
	 * @param driver
	 * @param url
	 * @param user
	 * @param password
	 * @return
	 */
	public static ConnectionPool newInstanceDefault(String poolName,
			String driver, String url, String user, String password) {
		return newInstanceFull(poolName, driver, url, user, password, defaultMin, defaultMax);
	}

	/**
	 * 单例模式,构造连接池,指定最小最大连接数
	 * @param poolName
	 * @param driver
	 * @param url
	 * @param user
	 * @param password
	 * @param minConn
	 * @param maxConn
	 * @return
	 */
	public static ConnectionPool newInstanceFull(String poolName,
			String driver, String url, String user, String password,
			int minConn, int maxConn) {
		if (null == pool) {
			pool = new ConnectionPool(poolName, driver, url, user, password, minConn, maxConn);
		}
		return pool;
	}

	/**
	 * 获取连接
	 * @return
	 */
	public synchronized Connection getConnection() {
		Connection conn = null;
		if (freeConnections.size() > 0) {
			System.out.println("======================>当前闲置连接数为:[" + freeConnections.size() + "]个");
			System.out.println("======================>从闲置连接中获取一个连接");
			conn = freeConnections.get(0);
			
			freeConnections.remove(0);
			System.out.println("======================>当前闲置连接减少一个,还剩余[" + freeConnections.size() + "]个");
			
			System.out.println("======================>将获取的闲置连接加入到使用中列表");
			usedConnections.add(conn);
			System.out.println("======================>当前使用中连接数为:[" + usedConnections.size() + "]个");
		} else {
			if (usedConnections.size() >= maxConn) {
				System.out.println("======================>警告:线程池连接数已经达到最大[" + maxConn + "]个!");
				System.out.println("======================>不允许再创建新连接");
			} else {
				System.out.println("======================>当前使用中连接数为:[" + usedConnections.size() + "]个");
				System.out.println("======================>已经没有闲置连接,重新创建一个连接");
				conn = newConnection();
				
				System.out.println("======================>将新创建的连接状态置为使用中");
				usedConnections.add(conn);
				System.out.println("======================>当前使用中连接数为:[" + freeConnections.size() + "]个");
			}
		}
		return conn;
	}

	/**
	 * 获取连接,指定超时时间
	 * @param time
	 * @return
	 */
	public synchronized Connection getConnection(long time) {
		Connection conn = null;
		if (freeConnections.size() > 0) {
			conn = freeConnections.get(0);
			freeConnections.remove(0);
			usedConnections.add(conn);
			this.notifyAll();
		} else {
			if (usedConnections.size() >= maxConn) {
				System.out.println("======================>警告:线程池连接数已经达到最大[" + maxConn + "]个!");
				System.out.println("======================>不允许再创建新连接");
				try {
					this.wait(time);
					conn = getConnection();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			} else {
				conn = newConnection();
				usedConnections.add(conn);
				this.notifyAll();
			}
		}
		return conn;
	}

	/**
	 * 释放连接
	 * 
	 * @param conn
	 */
	public synchronized void releaseConnection(Connection conn) {
		System.out.println("======================>释放当前连接");
		usedConnections.remove(conn);
		System.out.println("======================>使用中连接减少一个");

		freeConnections.add(conn);
		System.out.println("======================>闲置连接增加一个");
	}

	/**
	 * 关闭连接:一旦关闭,使用中的连接数应该减少一个
	 * 
	 * @param conn
	 */
	public synchronized void closeConnection(Connection conn) {
		try {
			if (usedConnections.size() > 0) {
				usedConnections.remove(conn);
			}
			if (null != conn) {
				conn.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 关闭连接池
	 */
	public synchronized void closePool() {
		System.out.println("======================>开始初关闭连接池");
		System.out.println("======================>当前使用中连接数总共有[" + usedConnections.size() + "]个");
		clearListConnection(usedConnections);
		
		System.out.println("======================>当前闲置连接数总共有[" + freeConnections.size() + "]个");
		clearListConnection(freeConnections);
		System.out.println("======================>关闭连接池成功");
	}

	private void clearListConnection(List<Connection> list) {
		Connection itemConn;
		try {
			for (int i = 0; i < list.size(); i++) {
				itemConn = list.get(i);
				list.remove(i);
				if (null != itemConn) {
					itemConn.close();
				}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	private void initDriver() {
		try {
			Class.forName(driver);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	private void initPool() {
		System.out.println("======================>开始初始化最少个数连接数");
		for (int i = 0; i < minConn; i++) {
			Connection conn = newConnection();
			freeConnections.add(conn);
		}
		System.out.println("======================>初始化成功,当前闲置连接数剩余[" + minConn + "]个");
	}

	private Connection newConnection() {
		Connection conn = null;
		try {
			conn = DriverManager.getConnection(url, user, password);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return conn;
	}

	public String getPoolName() {
		return poolName;
	}

	public String getDriver() {
		return driver;
	}

	public String getUrl() {
		return url;
	}

	public String getUser() {
		return user;
	}

	public String getPassword() {
		return password;
	}

	public int getMinConn() {
		return minConn;
	}

	public int getMaxConn() {
		return maxConn;
	}
}

 

4.连接池简单测试

package com.yli.dal;

import java.sql.Connection;

/**
 * 连接池简单测试
 * @author yli
 *
 */
public class PoolTest implements Runnable {

	private ConnectionPool pool;

	public PoolTest(ConnectionPool pool) {
		this.pool = pool;
	}

	@Override
	public void run() {
		Connection conn = pool.getConnection();
		// 超时机制获取
		// Connection conn = pool.getConnection(200);
		int threadName = Integer.valueOf(Thread.currentThread().getName());
		// 测试释放链接
		if (threadName >= 8) {
			pool.releaseConnection(conn);
		}
	}

	public static void main(String[] args) {
		String poolName = "MySQL-Connection-Pool";
		String driver = "com.mysql.jdbc.Driver";
		String url = "jdbc:mysql://localhost:3306/world";
		String user = "root";
		String password = "123456";
		ConnectionPool pool = ConnectionPool.newInstanceDefault(poolName,
				driver, url, user, password);
		System.out.println();

		for (int i = 0; i < 20; i++) {
			PoolTest poolTarget = new PoolTest(pool);
			new Thread(poolTarget, "" + i).start();
			System.out.println();
		}
		
		try {
			// 等待5秒再关闭连接池
			Thread.sleep(5*1000);
			pool.closePool();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

	}
}

 

分享到:
评论

相关推荐

    完美的java jdbc连接池实例

    本实例提供了完美的Java JDBC连接池配置,适用于Oracle、MySQL和SQL Server等主流数据库,允许开发者轻松地在不同数据库之间切换方言。 首先,让我们了解什么是JDBC连接池。JDBC(Java Database Connectivity)是...

    java JDBC连接池

    Java JDBC连接池是一种高效管理数据库连接的技术,它允许应用程序重复使用已经建立的数据库连接,从而减少频繁创建和关闭连接带来的开销。在大型系统中,尤其是高并发环境下,使用连接池能够显著提升性能并降低资源...

    java jdbc 连接池

    - HikariCP:目前被认为是最快的Java JDBC连接池,它设计的主要目标是速度、简单性和低资源占用。 - Druid:阿里巴巴开源的数据库连接池,具有监控、扩展性好的特点。 - Tomcat JDBC Connection Pool:Tomcat...

    完美的java jdbc连接池实例.zip

    标题"完美的java jdbc连接池实例.zip"暗示了这是一个关于如何高效利用JDBC连接池的实例教程。这个压缩包可能包含了一些示例代码、配置文件以及详细的使用说明,旨在帮助开发者理解并实践如何在Java项目中正确设置和...

    Java jdbc数据库连接池总结

    Java JDBC 数据库连接池总结 Java 语言中,JDBC(Java DataBase Connection)是应用程序与数据库沟通的桥梁。在 Web 应用开发的早期,主要使用的技术是 CGIASPPHP 等。之后,Sun 公司推出了基于 Java 语言的 ...

    java实现jdbc连接池+相关jar包

    本资源提供了实现Java JDBC连接池所需的相关jar包,包括: 1. cp30.jar:这是一个C3P0连接池的库文件,它是一个开源的JDBC连接池,除了提供基本的连接池功能外,还具有异常检测、自动关闭空闲连接、支持JNDI绑定等...

    Java对JDBC连接池的实现

    这是我写的一个对JDBC连接池的实现,高手见了可不要笑啊!!!! 程序是在linux下用Eclipse下编写的. 用Jude进行建模,数据库使用了mysql. 程序自带了MySql的Connection连接驱动类,你也可以使用别的驱动类和数据库, 在src/...

    jdbc 连接池

    C3P0是一个开源的JDBC连接池,它实现了数据源和JNDI绑定,支持JDBC3规范和JDBC2的标准扩展。C3P0的主要特点包括: 1. **自动管理数据库连接**:C3P0会自动创建、配置和管理数据库连接,避免了频繁创建和销毁连接...

    关于JDBC连接池的java类

    Java JDBC连接池是一种高效管理数据库连接的技术,它允许应用程序重复使用已经建立的数据库连接,而不是每次需要时都创建新的连接。这显著提高了性能并减少了系统资源的消耗,尤其是在高并发的环境中。本类库提供了...

    java_jdbc数据库连接池总结

    Java JDBC 数据库连接池总结 Java JDBC 数据库连接池是 Java 应用程序访问数据库的基本原理之一。Java 语言通过 JDBC 技术访问数据库,JDBC 是一种“开放”的方案,为数据库应用开发人员和数据库前台工具开发人员...

    HikariCP JDBC连接池 v3.4.5.zip

    HikariCP是一款高效、高性能的Java JDBC连接池,它被设计为替代传统连接池如C3P0和DBCP,以提供更快、更稳定的数据访问性能。在HikariCP v3.4.5这个版本中,我们可以深入探讨其在数据库连接管理、性能优化以及配置...

    Tongweb5中配置JDBC连接池

    Tongweb5是一款基于Java的Web应用服务器,它支持配置JDBC连接池来管理数据库连接。本文将详细介绍如何在Tongweb5中配置JDBC连接池,以及Web应用如何通过JNDI(Java Naming and Directory Interface)查找并使用这些...

    Java-jdbc数据库连接池总结.doc

    Java JDBC 数据库连接池技术是Java应用程序访问数据库的关键优化手段,尤其在Web应用程序中,它解决了传统JDBC连接方式存在的效率低下和资源浪费问题。Java JDBC(Java Database Connectivity)是Java语言与各种...

    jdbc连接池配置(优化连接速度)

    JDBC(Java Database Connectivity)是Java语言访问数据库的标准接口,而JDBC连接池则是一种对数据库连接进行管理和复用的技术。它预先创建并维护一定数量的数据库连接,当应用程序需要连接数据库时,可以从连接池中...

    Java-JDBC【源码】数据库连接池技术、常规操作与Durid对比、测试(20-200)不同连接数下,10万记录,1万并发

    Java-JDBC【源码】数据库连接池技术、常规操作与Durid对比、测试(20-200)不同连接数下,10万记录,1万并发,CPU磁盘占用情况 1.数据库连接池 2.Durid介绍(官方文档) 3.编码,问题,常规并发操作 3.1.JDBCUtil....

    JDBC连接池(通用basedao)可直接用的模板

    在Java开发中,数据库操作是不可或缺的一部分,而JDBC连接池是提高数据库访问效率、优化系统资源使用的重要技术。本文将深入探讨JDBC连接池的概念、工作原理,并以"通用basedao"模板为例,讲解如何在实际项目中应用...

    JDBC连接池驱动.zip

    JDBC(Java Database Connectivity)是Java平台中用于与数据库交互的一组接口和类,而JDBC连接池就是在这个基础上实现的一种优化策略。本文将详细介绍JDBC连接池驱动的相关知识,主要涉及`mysql-connector-java-...

    简单的jdbc连接池类

    本示例中的"简单的jdbc连接池类"实现了一个基本的数据库连接池功能,非常适合初学者理解和实践。 首先,我们来理解`jdbc`。JDBC(Java Database Connectivity)是Java语言用来与各种数据库进行交互的一种标准接口。...

    jdbc连接池dbcp工具包

    DBCP(Jakarta DBCP,又称为Apache Commons DBCP)是Apache软件基金会提供的一款开源的JDBC连接池实现,它为Java开发者提供了方便、高效的数据库连接管理功能。 DBCP工具包的出现,主要是为了解决频繁创建和销毁...

Global site tag (gtag.js) - Google Analytics