数据库连接池

最新推荐文章于 2022-01-13 16:57:48 发布

扮猪吃老虎2号

最新推荐文章于 2022-01-13 16:57:48 发布

阅读量161

点赞数

分类专栏：数据库

本文链接：https://blog.csdn.net/qq_38635681/article/details/86560224

版权

数据库专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、应用程序直接获取数据库连接的缺点

　　用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。假设网站一天10万访问量，数据库服务器就需要创建10万次连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出、拓机

二、使用数据库连接池优化程序性能

2.1、数据库连接池的基本概念

　　数据库连接是一种关键的有限的昂贵的资源,这一点在多用户的网页应用程序中体现的尤为突出.对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性,影响到程序的性能指标.数据库连接池正式针对这个问题提出来的.数据库连接池负责分配,管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是重新建立一个。如下图所示

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

数据库连接池的最小连接数和最大连接数的设置要考虑到以下几个因素:

最小连接数:是连接池一直保持的数据库连接,所以如果应用程序对数据库连接的使用量不大,将会有大量的数据库连接资源被浪费.
最大连接数:是连接池能申请的最大连接数,如果数据库连接请求超过次数,后面的数据库连接请求将被加入到等待队列中,这会影响以后的数据库操作
如果最小连接数与最大连接数相差很大:那么最先连接请求将会获利,之后超过最小连接数量的连接请求等价于建立一个新的数据库连接.不过,这些大于最小连接数的数据库连接在使用完不会马上被释放,他将被放到连接池中等待重复使用或是空间超时后被释放.

2.2、编写数据库连接池

　　编写连接池需实现java.sql.DataSource接口。DataSource接口中定义了两个重载的getConnection方法：

Connection getConnection()
Connection getConnection(String username, String password)

　　实现DataSource接口，并实现连接池功能的步骤：

在DataSource构造函数中批量创建与数据库的连接，并把创建的连接加入LinkedList对象中。
实现getConnection方法，让getConnection方法每次调用时，从LinkedList中取一个Connection返回给用户。
当用户使用完Connection，调用Connection.close()方法时，Collection对象应保证将自己返回到LinkedList中,而不要把conn还给数据库。Collection保证将自己返回到LinkedList中是此处编程的难点。

MyDataSource代码：

//开始创建10个连接，来的程序通过getConnection获取连接，用完之后使用addBack归还连接。

public class MyDataSource implements DataSource{
	
	List<Connection> list = new ArrayList<Connection>();
	
	public MyDataSource() {
		for(int i = 0; i<10;i++) {
			Connection conn = JDBCUtil.getCon();
			list.add(conn);
		}	
	}	
	//该连接池对外公布的获取连接的方法
	@Override
	public Connection getConnection() throws SQLException {
		//来的时候先看看池子里面是否还有连接
		if(list.size() == 0) {
			for(int i = 0; i<5;i++) {
				Connection conn = JDBCUtil.getCon();
				list.add(conn);
			}
		}		
		Connection conn = list.remove(0);//移除第一个,后面的前移
		return conn;
	}
	//用完之后归还
	public void addBack(Connection conn) {
		list.add(conn);
	}
	
	@Override
	public PrintWriter getLogWriter() throws SQLException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public int getLoginTimeout() throws SQLException {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public Logger getParentLogger() throws SQLFeatureNotSupportedException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void setLogWriter(PrintWriter arg0) throws SQLException {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void setLoginTimeout(int arg0) throws SQLException {
		// TODO Auto-generated method stub
		
	}

	@Override
	public boolean isWrapperFor(Class<?> arg0) throws SQLException {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public <T> T unwrap(Class<T> arg0) throws SQLException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Connection getConnection(String arg0, String arg1) throws SQLException {
		// TODO Auto-generated method stub
		return null;
	}

}

JDBCUtil代码：

public class JDBCUtil {	
	static String driverClass = null;
	static String url = null;
	static String username = null;
	static String password = null;	
	static {
		try {
			//1.创建一个属性配置对象
			Properties properties = new Properties();
			//InputStream is = new FileInputStream("jdbc.properties");
			InputStream is = JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");			
			//导入输入流
			properties.load(is);
			//读取属性			
			driverClass = properties.getProperty("driverClass");
			url = properties.getProperty("url");
			username = properties.getProperty("username");
			password = properties.getProperty("password");
		} catch (IOException e) {
			e.printStackTrace();
		}	
	}
	
	public static Connection getCon() {
		Connection con = null;
		try {
			Class.forName(driverClass);
			con = DriverManager.getConnection(url,username, password);
		}catch(Exception e){
			e.printStackTrace();
		}
		return con;
	}
	
	public static void release(Connection con,Statement st, ResultSet rs) {
		closeRs(rs);
		closeSt(st);
		closeCon(con);
	}
	
	private static void closeRs(ResultSet rs) {
		try {
			if(rs!=null) {
				rs.close();
			}
		}catch(SQLException e) {
			e.printStackTrace();
		}finally {
			rs = null;
		}
	}
	
	private static void closeSt(Statement St) {
		try {
			if(St!=null) {
				St.close();
			}
		}catch(SQLException e) {
			e.printStackTrace();
		}finally {
			St = null;
		}
	}
	
	private static void closeCon(Connection Con) {
		try {
			if(Con!=null) {
				Con.close();
			}
		}catch(SQLException e) {
			e.printStackTrace();
		}finally {
			Con = null;
		}
	}
}

jdbc.properties代码：

driverClass = com.mysql.cj.jdbc.Driver
url = jdbc:mysql://localhost:3306/bank?useSSL=false&serverTimezone=UTC
username = root
password = 123456

TestPool代码：

public class TestPool {
	@Test
	public void testPool(){
		Connection conn = null;
		PreparedStatement ps = null;
		MyDataSource dataSource = new MyDataSource();	
		try {
			conn = dataSource.getConnection();
			String sql = "insert into account values (null,'dod',10)";
			ps = conn.prepareStatement(sql);
			ps.executeUpdate();
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			try {
				ps.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			dataSource.addBack(conn);
		}
	} 
}

三、开源数据库连接池

　　现在很多WEB服务器(Weblogic, WebSphere, Tomcat)都提供了DataSoruce的实现，即连接池的实现。通常我们把DataSource的实现，按其英文含义称之为数据源，数据源中都包含了数据库连接池的实现。
　　也有一些开源组织提供了数据源的独立实现：

DBCP 数据库连接池
C3P0 数据库连接池

　　在使用了数据库连接池之后，在项目的实际开发中就不需要编写连接数据库的代码了，直接从数据源获得数据库的连接。

3.1、DBCP数据源

　　DBCP 是 Apache 软件基金组织下的开源连接池实现，要使用DBCP数据源，需要应用程序应在系统中增加如下两个 jar 文件：

Commons-dbcp.jar：连接池的实现
Commons-pool.jar：连接池实现的依赖库

　　Tomcat 的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使用，也可由应用程序独立使用。

3.2、在应用程序中加入dbcp连接池

　　1.导入相关jar包
　　 commons-dbcp-1.2.2.jar、commons-pool.jar
　　2、在类目录下加入dbcp的配置文件：dbcpconfig.properties

　　　　dbcpconfig.properties的配置信息如下：

#连接设置
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/bank?useSSL=false&serverTimezone=UTC
username=root
password=123456

#<!-- 初始化连接 -->
initialSize=10

#最大连接数量
maxActive=50

#<!-- 最大空闲连接 -->
maxIdle=20

#<!-- 最小空闲连接 -->
minIdle=5

#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWait=60000


#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;] 
#注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=gbk

#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true

#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED

测试代码：

try {
			
	BasicDataSourceFactory factory = new BasicDataSourceFactory();
	Properties properties = new Properties();
	InputStream is = new FileInputStream("src//dbcpconfig.properties");
	properties.load(is);
	DataSource dataSource = factory.createDataSource(properties);
	conn = dataSource.getConnection();
	String sql = "insert into account values (null,?,?)";
	ps = conn.prepareStatement(sql);		
        ps. setString(1, "eoe");
        ps.setInt(2, 1100);	
	ps.executeUpdate();
} catch (Exception e) {
	e.printStackTrace();
}finally{
	JDBCUtil.release(conn, ps);
}

3.3、C3P0数据源

　　C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。C3P0数据源在项目开发中使用得比较多。

　　c3p0与dbcp区别

dbcp没有自动回收空闲连接的功能
c3p0有自动回收空闲连接功能

3.4、在应用程序中加入C3P0连接池

　　1.导入相关jar包
　　　c3p0-0.9.2-pre1.jar、mchange-commons-0.2.jar（两个版本要匹配），如果操作的是Oracle数据库，那么还需要导入c3p0-oracle-thin-extras-0.9.2-pre1.jar
　　2、在类目录下加入C3P0的配置文件：c3p0-config.xml（名称不可错）

　　　　c3p0-config.xml的配置信息如下：

<?xml version="1.0" encoding="UTF-8"?>
<!--
c3p0-config.xml必须位于类路径下面
private static ComboPooledDataSource ds;
static{
    try {
        ds = new ComboPooledDataSource("MySQL");
    } catch (Exception e) {
        throw new ExceptionInInitializerError(e);
    }
}
-->

<c3p0-config>
    <!--
    C3P0的缺省(默认)配置，
    如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource();”这样写就表示使用的是C3P0的缺省(默认)配置信息来创建数据源
    -->
    <default-config>
        <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/bank?useSSL=false&amp;serverTimezone=UTC</property>
        <property name="user">root</property>
        <property name="password">123456</property>
        
        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </default-config>

    <!--
    C3P0的命名配置，
    如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource("MySQL");”这样写就表示使用的是name是MySQL的配置信息来创建数据源
    -->
    <named-config name="MySQL">
        <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/bank?useSSL=false&amp;serverTimezone=UTC</property>
        <property name="user">root</property>
        <property name="password">123456</property>
        
        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </named-config>

</c3p0-config>

测试代码：

//默认会找 xml 中的 default-config 分支。 
ComboPooledDataSource dataSource = new ComboPooledDataSource();
//2. 得到连接对象
conn = dataSource.getConnection();
String sql = "insert into account values(null , ? , ?)";
ps = conn.prepareStatement(sql);
ps.setString(1, "admi234n");
ps.setInt(2, 103200);
ps.executeUpdate();

四、DBUtils

commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。因此dbutils成为很多不喜欢hibernate的公司的首选。

　　commons-dbutilsAPI介绍：

org.apache.commons.dbutils.QueryRunner
org.apache.commons.dbutils.ResultSetHandler

　　工具类

org.apache.commons.dbutils.DbUtils

QueryRunner是DBUtils的核心，该类简单化了SQL查询，它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作（CRUD），能够大大减少编码量。

qr.query（）方法有多个重载，第一个参数是sql语句没差，但第二个表示用什么来接受返回值

ArrayHandler：把结果集中的第一行数据转成对象数组。
ArrayListHandler：把结果集中的每一行数据都转成一个数组，再存放到List中。
BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
ColumnListHandler：将结果集中某一列的数据存放到List中。
KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map里，再把这些map再存到一个map里，其key为指定的key。
MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List

五、DBUtils和C3P0的结合使用——账户登录案例

1.数据库准备

2.页面准备（login.jsp）

3.导包

4..编写bean

package com.bob.domain;

public class UserBean {
	
	private int id;
	private String username;
	private String password;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}

}

5.编写JDBC和DAO

JDBCUtil02（C3P0）可以一次编写，多处使用。

package com.bob.util;

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


import javax.sql.DataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class JDBCUtil02 {
	
	static ComboPooledDataSource dataSource = null;
	static{
		dataSource = new ComboPooledDataSource();
	}
	
	public static DataSource getDataSource(){
		return dataSource;
	}
	
	/**
	 * 获取连接对象
	 * @return
	 * @throws SQLException 
	 */
	public static Connection getConn() throws SQLException{
		return dataSource.getConnection();
	}
	
	/**
	 * 释放资源
	 * @param conn
	 * @param st
	 * @param rs
	 */
	public static void release(Connection conn , Statement st , ResultSet rs){
		closeRs(rs);
		closeSt(st);
		closeConn(conn);
	}
	public static void release(Connection conn , Statement st){
		closeSt(st);
		closeConn(conn);
	}

	
	private static void closeRs(ResultSet rs){
		try {
			if(rs != null){
				rs.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			rs = null;
		}
	}
	
	private static void closeSt(Statement st){
		try {
			if(st != null){
				st.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			st = null;
		}
	}
	
	private static void closeConn(Connection conn){
		try {
			if(conn != null){
				conn.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			conn = null;
		}
	}
}

DAO：先写dao接口，在写实现代码，在实现代码中使用QueryRunner（DBUtils）

package com.bob.dao;

import java.sql.SQLException;

import com.bob.domain.UserBean;

public interface UserDao{
	/*
	 * 执行登录，并返回用户的所有信息
	 */
	UserBean login(UserBean user) throws SQLException;
}

package com.bob.dao;

import java.sql.SQLException;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;

import com.bob.domain.UserBean;
import com.bob.util.JDBCUtil02;

public class UserDaoImpl implements UserDao{

	@Override
	public UserBean login(UserBean user) throws SQLException {
			QueryRunner runner = new QueryRunner(JDBCUtil02.getDataSource());
			String sql = "select * from user where username=? and password=?";
			return runner.query(sql, new BeanHandler<UserBean>(UserBean.class),user.getUsername(),user.getPassword());
	}
	
}

6.编写servlet

package com.bob.servlet;

import java.io.IOException;
import java.sql.SQLException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.bob.dao.UserDao;
import com.bob.dao.UserDaoImpl;
import com.bob.domain.UserBean;
import com.mysql.cj.Session;

/**
 * Servlet implementation class LoginSevlet
 */
public class LoginSevlet extends HttpServlet {
	
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		try {
			String username = request.getParameter("username");
			String password = request.getParameter("password");
			String autoLogin = request.getParameter("auto_login");
			System.out.println(username+"="+password+"="+autoLogin);
			
			UserBean user = new UserBean();
			user.setUsername(username);
			user.setPassword(password);
			UserDao dao = new UserDaoImpl();
			UserBean userBean = dao.login(user);
			if(userBean != null) {
				request.getSession().setAttribute("userBean", userBean); 
				
				response.sendRedirect("index.jsp");
			}else {
				request.getRequestDispatcher("login.jsp").forward(request, response);
			}
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

7.编写index.jsp页面

<body>
	欢迎您，${userBean.username}
</body>

8.效果演示

扮猪吃老虎2号

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
数据库连接池

一、应用程序直接获取数据库连接的缺点　　用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。假设网站一天10万访问量，数据库服务器就需要创建10万次连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出、拓机二、使用数据库连接池优化程序性能2.1、数据库连接池的基本概念　　数据库连接是一种关键的有限的昂贵的资源,这一点在多用户...
复制链接

扫一扫