Java 学习使用常见的开源连接池

连接池介绍

　　在说连接池之前，我们先想一个问题：程序要进行数据库操作，与数据库建立的是什么连接？开销怎么样？数据库是否可以同时支持上百万个连接？

　　首先第一个问题：程序与数据库建立的是socket连接，走的是传输层，使用TCP。

　　第二个问题：总开销约等于程序运行耗时 + 网络io + 数据库运行耗时。

　　第三个问题：应该是不能同时支持上百万个连接，几千个应该就是上限了。

　　看了上面三个问题，再提出一个问题：上面的问题中，我们可以优化哪一个环节？

　　运维可以优化网络传输的问题；DBA可以优化数据库的运行性能。

　　对于开发人员来说，我们可以优化第一个问题；首先，创建socket连接真的很耗时，主要的原因是因为建立TCP连接时有个3次握手，建立连接之后传输数据开销其实并不大。所以我们可以在这个角度上进行优化：尽量让程序与数据库建立几个连接，不要让程序频繁与数据库建立连接。

　　为了业务的正常执行，线程需要与数据库进行交互，只建立几个数据库连接，好像不现实。

　　我们可以换个方式来优化：创建固定数量的数据库的连接，这些数据库连接在Java中就是一个个对象而已，我们可以将这些对象存到容器中（比如List中），这个容器就叫做连接池。

　　当有一个线程需要与数据库交互的时候，如果容器中还有数据库连接对象，那就从容器中取出一个连接对象，使用完之后，并不关闭数据库连接，而是将数据库连接对象放回容器，方便其他线程使用；如果线程需要与数据库交互时，容器中没有数据库连接对象了，那么这个线程他就阻塞一下，等待别的线程使用完连接之后归还，然后再使用别的线程归还的数据库连接。

自定义连接池

　　自定义连接池的有个规范，需要实现DataSource接口，并且重写多个方法，但是主要重写一个无参的getConnection方法：

package cn.ganlixin.utils;
 
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;
import java.util.logging.Logger;
 
import javax.sql.DataSource;
 
/**
 * 自定义的超简单的连接池，主要重写了DataSource接口中的getConnection方法，然后创建了归还连接的方法
 */
public class MyConnectionPool implements DataSource {
 
	// 创建一个同步的容器来保存数据库连接
	private static List<Connection> connectionList =
			Collections.synchronizedList(new LinkedList<Connection>());
 
	// 设置建立数据库连接的最大数
	private static final int MAX_CONNECTIONS = 50;
 
	// 编写静态初始化块，读取数据库配置文件，建立数据库连接，放入容器
	static {
		InputStream _is = MyConnectionPool.class.getClassLoader().getResourceAsStream("database.properties");
		try {
			Properties props = new Properties();
			props.load(_is);
			String driver = props.getProperty("jdbc.driver");
			String url = props.getProperty("jdbc.url");
			String username = props.getProperty("jdbc.username");
			String password = props.getProperty("jdbc.password");
 
			Class.forName(driver);
 
			// 创建多个连接，放入容器中
			for (int i = 0; i < MAX_CONNECTIONS; i++) {
				Connection conn = DriverManager.getConnection(url, username, password);
				connectionList.add(conn);
				System.out.println("创建第 " + (i+1) + " 个连接");
			}
 
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
 
	// 从容器中取出一个数据库连接对象
	@Override
	public Connection getConnection() throws SQLException {
 
		if (connectionList.size() > 0) {
			// 如果容器中还有数据库连接对象，就将取出第一个对象，并将该对象从容器中删除
			Connection conn = connectionList.remove(0);
			System.out.println("使用了一个数据库连接， 容器中还剩下 " + connectionList.size() + " 个数据库连接");
			return conn;
		}
 
		return null;
	}
 
	/**
	 * 归还数据库连接给容器，便于其他线程使用
	 * @param conn 要归还的数据库连接对象
	 */
	public void releaseConnection(Connection conn) {
		connectionList.add(conn);
	}
 
	@Override
	public PrintWriter getLogWriter() throws SQLException { return null; }
 
	@Override
	public void setLogWriter(PrintWriter out) throws SQLException {	}
 
	@Override
	public void setLoginTimeout(int seconds) throws SQLException {	}
 
	@Override
	public int getLoginTimeout() throws SQLException { return 0; }
 
	@Override
	public Logger getParentLogger() throws SQLFeatureNotSupportedException { return null; }
 
	@Override
	public <T> T unwrap(Class<T> iface) throws SQLException { return null; }
 
	@Override
	public boolean isWrapperFor(Class<?> iface) throws SQLException { return false; }
 
	@Override
	public Connection getConnection(String username, String password) throws SQLException { return null; }
 
}

　　测试

package cn.ganlixin.test;
 
import java.sql.Connection;
import java.sql.SQLException;
 
public class TestPool {
	public static void main(String[] args) throws SQLException {
		MyConnectionPool connectionPool = new MyConnectionPool(); // 获取连接池
 
		for (int i = 0; i < 20; i++) {
			// 获取连接
			Connection connection = connectionPool.getConnection();
 
			if (i % 3 == 0) { // 归还连接
				connectionPool.releaseConnection(connection);
			}
 
			System.out.println(connection);
		}
	}
}

JDBC Tomcat Pool

　　tomcat服务器可以提供数据库连接池。我们可以将数据库连接池的配置保存在一个文件名为context.xml的文件中。

　　context.xml可以放在项目下的webRoot/META-INF目录下，只对于本项目有效。

　　context.xml可以放在tomcat服务器安装路径的conf目录下，针对所有项目都有效。

<?xml version="1.0" encoding="UTF-8"?>
<Context>
    <WatchedResource>WEB-INF/web.xml</WatchedResource>
    <Resource
    	driverClassName="com.mysql.jdbc.Driver"
    	url="jdbc:mysql://localhost:3306/test"
    	user="root"
    	password="123456"
    	name="tomcat_supported_pool"
    	auth="Container"
    	maxActive="50"
    	maxIdle="20"
    	maxWait="10000"
    	type="javax.sql.DataSource"
    ></Resource>
</Context>

　　测试：

package lixin.gan.test;
 
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
 
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.sql.DataSource;
 
/**
 * Servlet implementation class TestPool
 */
@WebServlet("/TestPool")
public class TestPool extends HttpServlet {
	@Override
	public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
		request.setCharacterEncoding("utf-8");
		response.setContentType("text/html; charset=utf-8");
 
		try {
			Context ctx = new InitialContext();
			DataSource ds = (DataSource) ctx.lookup("java:comp/env/tomcat_supported_pool");
 
			Connection conn = ds.getConnection();
 
			/*
 
			 进行数据库操作即可
 
			 */
 
		} catch (NamingException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
 
	}
}

DBCP（DataBase Connection Pool）

　　需要下载commons-dbcp.jar、commons-pool.jar、commons-logging.jar。另外仍旧需要导入mysql的驱动包。

　　下载网址（下载xxx-bin.zip即可）：

　　　　http://commons.apache.org/proper/commons-dbcp/download_dbcp.cgi

　　　　http://commons.apache.org/proper/commons-pool/download_pool.cgi

　　　　http://commons.apache.org/proper/commons-logging/download_logging.cgi

　　　　下载之后解压，将jar包添加到build path中。

　　使用DBCP的示例：

package cn.ganlixin.test;
 
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
 
import org.apache.commons.dbcp2.BasicDataSource;
 
public class TestDBCP {
	public static void main(String[] args) throws SQLException {
 
		// 获取连接池
        BasicDataSource dataSource = new BasicDataSource();
 
        // 设置连接池相关信息
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        dataSource.setInitialSize(5);
        dataSource.setMinIdle(2);
 
        // 获取数据库连接
        Connection conn = dataSource.getConnection();
 
        // 执行数据库操作
        Statement stmt  = conn.createStatement();
        stmt.executeUpdate("update stu set age = 30 where id < 4");
 
        // 这个close()方法被重写了，并不是关闭数据库连接，而是将连接归还连接池
        conn.close();
 
	}
}

使用配置文件来设置DBCP

　　前面使用DBCP时，是在程序中手动指定连接信息，同样的，我们可以使用配置文件保存DBCP的连接信息。

　　操作：在src下创建一个dbcp.properties文件，内容如下：

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test
username=root
password=root
 
initialSize=20
maxIdle=10
minIdle=5
maxWait=10000

　　使用DBCP

package cn.ganlixin.test;
 
import java.io.InputStream;
import java.sql.Connection;
import java.sql.Statement;
import java.util.Properties;
 
import org.apache.commons.dbcp2.BasicDataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;
 
public class TestPool {
	public static void main(String[] args) throws Exception {
 
		BasicDataSourceFactory dataSourceFacoty = new BasicDataSourceFactory();
 
		InputStream _is = TestPool.class.getClassLoader().getResourceAsStream("dbcp.properties");
		Properties props = new Properties();
		props.load(_is);
 
		// 获取连接池
		BasicDataSource dataSource = dataSourceFacoty.createDataSource(props);
		Connection conn = dataSource.getConnection();
		Statement stmt = conn.createStatement();
		stmt.executeUpdate("update stu set age = 30 where id < 4");
 
		conn.close();
 
	}
}

DBCP返回的数据库连接是包装类对象

　　当我们从DBCP连接池获取的连接其实是一个经过包装之后的数据库连接对象，而不是原生的jdbc数据库连接对象：

package cn.ganlixin.test;
 
import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;
 
import org.apache.commons.dbcp2.BasicDataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;
import org.apache.commons.dbcp2.DelegatingConnection;
 
public class TestDBCP1 {
	public static void main(String[] args) throws Exception {
 
		BasicDataSourceFactory dataSourceFacoty = new BasicDataSourceFactory();
 
		InputStream _is = TestPool.class.getClassLoader().getResourceAsStream("dbcp.properties");
 
		Properties props = new Properties();
		props.load(_is);
 
		BasicDataSource dataSource = dataSourceFacoty.createDataSource(props);
 
		// 获取数据库连接
		Connection conn = dataSource.getConnection();
 
		System.out.println(conn.getClass().getName());
		// org.apache.commons.dbcp2.PoolingDataSource$PoolGuardConnectionWrapper
		// 通过DBCP连接池获得的是一个包装过后的连接池对象
 
		// 可以通过下面的步骤获取原生的Connection对象
		DelegatingConnection dc = (DelegatingConnection) conn;
		Connection connection = dc.getInnermostDelegateInternal();
		System.out.println(connection.getClass().getName());
		// com.mysql.jdbc.JDBC4Connection
 
	}
}

C3P0

　　C3P0也是一个数据库连接池的开源项目，他和DBCP功能类似，但是有一些区别：

　　1、DBCP不会自动回收空闲连接的功能，而C3P0有这个功能。

　　2、DBCP需要手动指定配置文件的路径以及文件明，而C3P0不需要（C3P0的配置文件指定路径和名称）。

　　需要下载c3p0.jar，mchange-commons-java.jar，以及mysql的驱动包。

　　http://central.maven.org/maven2/com/mchange/c3p0/0.9.5.4/c3p0-0.9.5.4.jar

　　http://central.maven.org/maven2/com/mchange/mchange-commons-java/0.2.15/mchange-commons-java-0.2.15.jar

创建C3P0的配置文件

　　C3P0的配置文件名为c3p0-config.xml，放在src目录下即可，配置文件的内容如下：

<?xml version="1.0" encoding="utf-8"?>
<c3p0-config>
	<default-config>
		<property name="driverClass">com.mysql.jdbc.Driver</property>
		<property name="jdbcUrl">jdbc:mysql://localhost:3306/test</property>
		<property name="user">root</property>
		<property name="password">root</property>
		<property name="initialPoolSize">30</property>
		<property name="maxIdleTime">60</property>
		<property name="maxPoolSize">60</property>
		<property name="minPoolSize">15</property>
	</default-config>
 
	<!-- 可以指定两个数据库配置，一个线上环境，一个开发环境 -->
	<named-config name="dev">
		<property name=""></property>
		<property name=""></property>
		<property name=""></property>
		<property name=""></property>
		<property name=""></property>
		<property name=""></property>
		<property name=""></property>
		<property name=""></property>
		<property name=""></property>
	</named-config>
</c3p0-config>

测试C3P0

package cn.ganlixin.test;
 
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
 
import com.mchange.v2.c3p0.ComboPooledDataSource;
 
public class TestC3P0 {
	public static void main(String[] args) throws SQLException {
 
		// 获取连接池
		// 加载默认的数据库连接配置
		// ComboPooledDataSource dataSource = new ComboPooledDataSource();
		// 使用c3p0配置文件中named-config里面name为dev的数据库配置
		ComboPooledDataSource dataSource = new ComboPooledDataSource("dev");
 
		// 获取数据库连接
		Connection connection = dataSource.getConnection();
 
		// 获取到数据库连接之后就可以进行各种操作了
		// code
 
		// c3p0返回的数据库连接同样是包装类
		System.out.println(connection);
		// com.mchange.v2.c3p0.impl.NewProxyConnection@769c9116
		// [wrapping: com.mysql.jdbc.JDBC4Connection@6aceb1a5]
 
		// 将数据库连接归还连接池
		connection.close();
	}
}

Druid

　　Druid是alibaba开源的一个连接池项目；

　　使用Druid，需要下载druid.jar以及mysql的驱动包；

　　druid.jar的下载地址：http://central.maven.org/maven2/com/alibaba/druid/1.1.15/druid-1.1.15.jar

　　github地址：https://github.com/alibaba/druid

　使用方法设置连接池信息

package cn.ganlixin.test;
 
import java.sql.SQLException;
 
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidPooledConnection;
 
public class TestDruid {
	public static void main(String[] args) throws SQLException {
		// 获取连接池对象
		DruidDataSource dataSource = new DruidDataSource();
 
		// 设置连接信息
		dataSource.setDriverClassName("com.mysql.jdbc.Driver");
		dataSource.setUrl("jdbc:mysql://localhost:3306/test");
		dataSource.setUsername("root");
		dataSource.setPassword("root");
 
		// 设置连接池的配置
		dataSource.setInitialSize(20);
		dataSource.setMaxActive(30);
		dataSource.setMaxWait(1000);
		dataSource.setMinIdle(10);
 
		// 获取连接（得到的不是原生的jdbc for mysql的连接对象）
		DruidPooledConnection connection = dataSource.getConnection();
 
		// 释放连接到连接池中
		connection.close();
	}
}

　　使用properties配置文件的方式配置Druid

　　配置Druid可以参考官方的示例：https://github.com/alibaba/druid/wiki/DruidDataSource%E9%85%8D%E7%BD%AE

　　在src下创建druid-config.properties（文件名随意），内容如下：

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test
username=root
password=root
 
maxActive=10
initialSize=5
maxWait=10000
minIdle=5

　　配置项和DBCP几乎一样。

　　进行测试：

package cn.ganlixin.test;
 
import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;
 
import javax.sql.DataSource;
 
import com.alibaba.druid.pool.DruidDataSourceFactory;
 
public class TestDruid2 {
	public static void main(String[] args) throws Exception {
 
		InputStream _is = TestDruid2.class.getClassLoader().getResourceAsStream("druid-config.properties");
 
		Properties props = new Properties();
		props.load(_is);
 
		/**
		读取配置文件，手动调用setter进行设置连接池
		DruidDataSource dataSource = new DruidDataSource();
		dataSource.setDriverClassName(props.getProperty("driverClassName"));
		.........
		*/
 
		// 利用工厂加载配置文件来配置连接池
		DruidDataSourceFactory factory = new DruidDataSourceFactory();
		DataSource dataSource = factory.createDataSource(props);
 
		// 获取数据库连接
		Connection connection = dataSource.getConnection();
		System.out.println(connection.getClass().getName());
 
		connection.close();
	}
}