收藏    

目录
连接池介绍

自定义连接池

JDBC Tomcat Pool

DBCP（DataBase Connection Pool）

使用配置文件来设置DBCP

C3P0

Druid













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

　　首先第一个问题：程序与数据库建立的是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/DruidDataSourceE9858DE7BDAE

　　在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();
}
}