数据库连接池的一种实现方案
数据库连接池有多个开源实现，像dbcp、druid等。这里我们再一次造轮子，思路很简单：当有SQL操作（增删查改）到来时，先到池子里看一眼，如果有可用的连接，拿来用，没有就新建一个连接。连接不在新建时入池，而是在被关闭时。本来应当被系统回收的连接被放入池中复用，当累计到最大连接数时，就不再入池，直接回收。
为何要在关闭时判断最大连接数、入池，而不是在请求到来时做呢？我们把关闭入池叫方案1，请求入池叫方案2。采用方案1有两个好处：一、方案2的问题是，当一开始就有超过最大连接数的SQL操作的情况出现时，超过部分的请求会被拒绝或者等待。方案1避免了这种情况，就算超过仍然可以先把连接创建出来，因为它在关闭时才会校验最大连接数。二、方案2在系统启动时新建连接把池子填满，或者在每次请求到来时建立新的连接并入池，最终都会让池子满。方案1则支持动态调整池子大小，请求来多少给多少个连接，如果请求数少于最大连接数，根本不会让池子满。比如最大连接数是10，每批次并发请求来5个，用完后这个5个入池，下次再并发来5个，那么还是这5个出池，用完后再入池。
方案1的优势是有前提的：一、当请求并发量很大时，池子就起不到保护缓冲的作用了，系统可能一开始就被请求洪峰冲毁了；反而方案2可以起到限流保护的作用。二、弹性的前提是请求连接数少于最大连接数，只要有一次池子满了，那以后也一直是满池运行，跟方案2没啥区别了。
1、配置文件，放在main/java/resources目录下的jdbc.properties：
db.driver=oracle.jdbc.driver.OracleDriver
db.url=jdbc:oracle:thin:@127.0.0.1:1521:orcl
db.username=wlf
db.passwd=wlf
db.max=10
2、3类合一
import javax.sql.DataSource; import java.io.IOException; import java.io.PrintWriter;import java.sql.Array; import java.sql.Blob; import java.sql.CallableStatement; import java.sql.Clob; import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.DriverManager; import java.sql.NClob; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLClientInfoException; import java.sql.SQLException; import java.sql.SQLFeatureNotSupportedException; import java.sql.SQLWarning; import java.sql.SQLXML; import java.sql.Savepoint; import java.sql.Statement; import java.sql.Struct; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Properties; import java.util.concurrent.CountDownLatch; import java.util.concurrent.Executor; import java.util.logging.Logger; /** * 数据库连接池 */ public class DataSourcePool { private DataSource dataSource; // 数据源 public DataSourcePool() { try { dataSource = new SimpleDataSource("/jdbc.properties"); } catch (IOException e) { e.printStackTrace(); } } /** * 增删改 * * @param sql * @param args * @return */ public int update(String sql, Object... args) { try (Connection conn = dataSource.getConnection(); PreparedStatement ps = conn.prepareStatement(sql)) { for (int i = 1; i <= args.length; i++) { ps.setObject(i, args[i - 1]); } return ps.executeUpdate(); } catch (Exception e) { e.printStackTrace(); } return 0; } /** * 查 * * @param sql * @return */ public List<String> query(String sql, int index) { List<String> queryResults = new ArrayList<>(); try (Connection conn = dataSource.getConnection(); PreparedStatement ps = conn.prepareStatement(sql)) { ps.setInt(1, index); ResultSet rs = ps.executeQuery(); while (rs.next()) { queryResults.add(rs.getString("TITLE")); } } catch (Exception e) { e.printStackTrace(); } return queryResults; } public static void main(String[] args) throws InterruptedException { int threadNum = 10; // 起多个线程执行 CountDownLatch countDownLatch = new CountDownLatch(threadNum); // 让插入先行，删除后行 String updateSql = "insert into t_wlf_component_template values (?,?)"; String deleteSql = "delete from t_wlf_component_template where id = ?"; String querySql = "select TITLE from t_wlf_component_template where id = ?"; DataSourcePool dataSourcePool = new DataSourcePool(); for (int i = 0; i < threadNum; i++) { final int j = i + 1; new Thread(new Runnable() { @Override public void run() { String currentThreadName = Thread.currentThread().getName(); long begin = System.currentTimeMillis(); System.out.println(currentThreadName + " 更新结果：" + dataSourcePool.update(updateSql, j, "heihei.")); System.out.println(currentThreadName + " 更新耗时: " + (System.currentTimeMillis() - begin) + " 微秒。"); begin = System.currentTimeMillis(); System.out.println(currentThreadName + " 查询结果：" + dataSourcePool.query(querySql, j)); System.out.println(currentThreadName + " 查询耗时: " + (System.currentTimeMillis() - begin) + " 微秒。"); countDownLatch.countDown(); // 每执行一次插入，减少一次 } }).start(); } countDownLatch.await(); // 主线程在此等待 for (int i = 0; i < threadNum; i++) { final int j = i + 1; new Thread(new Runnable() { @Override public void run() { String currentThreadName = Thread.currentThread().getName(); long begin = System.currentTimeMillis(); System.out.println(currentThreadName + " 删除结果：" + dataSourcePool.update(deleteSql, j)); System.out.println(currentThreadName + " 删除耗时: " + (System.currentTimeMillis() - begin) + " 微秒。"); } }).start(); } } /** * 数据源，从配置文件中加载驱动，获取连接 */ class SimpleDataSource implements DataSource { private List<Connection> conns; // 数据库连接列表 private String dbDriver; // 驱动 private String dbUrl; // 数据库连接url private String dbUserName; // 用户名 private String dbPasswd; // 密码 private int dbMax; // 最大连接数 public SimpleDataSource(String configFilePath) throws IOException { // 读取数据库配置文件 Properties properties = new Properties(); properties.load(DataSourcePool.class.getResourceAsStream(configFilePath)); dbDriver = properties.getProperty("db.driver"); dbUrl = properties.getProperty("db.url"); dbUserName = properties.getProperty("db.username"); dbPasswd = properties.getProperty("db.passwd"); dbMax = Integer.valueOf(properties.getProperty("db.max")); // 初始化数据连接池 conns = Collections.synchronizedList(new ArrayList<>(dbMax)); } @Override public Connection getConnection() throws SQLException { // 加载驱动 try { Class.forName(dbDriver); } catch (ClassNotFoundException e) { e.printStackTrace(); } // 每次返回一个新的数据库连接 return DriverManager.getConnection(dbUrl, dbUserName, dbPasswd); // 每次从数据库连接池中获取 // return getConnection(dbUserName, dbPasswd); } /** * 获取指定用户名连接 * * @param username * @param password * @return * @throws SQLException */ @Override public synchronized Connection getConnection(String username, String password) throws SQLException { // 数据库连接池为空，新创建一个连接，否则从池中捞取一个 if (conns.isEmpty()) { try { Class.forName(dbDriver); } catch (ClassNotFoundException e) { e.printStackTrace(); } Connection connection = new ConnectionWrapper(conns, DriverManager.getConnection(dbUrl, username, password), dbMax); return connection; } else { System.out.println("当前数据库连接池还剩 " + conns.size() + " 个连接。"); return conns.remove(conns.size() - 1); } } // 下面的方法都是在包装，不管它 @Override public <T> T unwrap(Class<T> iface) throws SQLException { return null; } @Override public boolean isWrapperFor(Class<?> iface) throws SQLException { return false; } @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; } } /** * 数据库连接包装器，在连接关闭时放入连接池 */ private class ConnectionWrapper implements Connection { private List<Connection> conns; // 连接池 private Connection connection; // 连接 private int max; // 最大连接数 public ConnectionWrapper(List<Connection> conns, Connection connection, int max) { this.conns = conns; this.connection = connection; this.max = max; } // 下面的方法都是在包装，除了close方法 @Override public Statement createStatement() throws SQLException { return connection.createStatement(); } @Override public PreparedStatement prepareStatement(String sql) throws SQLException { return connection.prepareStatement(sql); } @Override public CallableStatement prepareCall(String sql) throws SQLException { return connection.prepareCall(sql); } @Override public String nativeSQL(String sql) throws SQLException { return connection.nativeSQL(sql); } @Override public void setAutoCommit(boolean autoCommit) throws SQLException { connection.setAutoCommit(autoCommit); } @Override public boolean getAutoCommit() throws SQLException { return connection.getAutoCommit(); } @Override public void commit() throws SQLException { connection.commit(); } @Override public void rollback() throws SQLException { connection.rollback(); } /** * 关闭方法需自己实现 * @throws SQLException */ @Override public void synchronized close() throws SQLException { // 当数据库连接数等于最大值时，回收，否则仍回池里复用 if (conns.size() == max) { connection.close(); } else { conns.add(this); } } @Override public boolean isClosed() throws SQLException { return false; } @Override public DatabaseMetaData getMetaData() throws SQLException { return connection.getMetaData(); } @Override public void setReadOnly(boolean readOnly) throws SQLException { connection.setReadOnly(readOnly); } @Override public boolean isReadOnly() throws SQLException { return connection.isReadOnly(); } @Override public void setCatalog(String catalog) throws SQLException { connection.setCatalog(catalog); } @Override public String getCatalog() throws SQLException { return connection.getCatalog(); } @Override public void setTransactionIsolation(int level) throws SQLException { connection.setTransactionIsolation(level); } @Override public int getTransactionIsolation() throws SQLException { return connection.getTransactionIsolation(); } @Override public SQLWarning getWarnings() throws SQLException { return connection.getWarnings(); } @Override public void clearWarnings() throws SQLException { connection.clearWarnings(); } @Override public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException { return connection.createStatement(resultSetType, resultSetConcurrency); } @Override public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException { return connection.prepareStatement(sql, resultSetType, resultSetConcurrency); } @Override public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException { return connection.prepareCall(sql, resultSetType, resultSetConcurrency); } @Override public Map<String, Class<?>> getTypeMap() throws SQLException { return connection.getTypeMap(); } @Override public void setTypeMap(Map<String, Class<?>> map) throws SQLException { connection.setTypeMap(map); } @Override public void setHoldability(int holdability) throws SQLException { connection.setHoldability(holdability); } @Override public int getHoldability() throws SQLException { return connection.getHoldability(); } @Override public Savepoint setSavepoint() throws SQLException { return connection.setSavepoint(); } @Override public Savepoint setSavepoint(String name) throws SQLException { return connection.setSavepoint(name); } @Override public void rollback(Savepoint savepoint) throws SQLException { connection.rollback(savepoint); } @Override public void releaseSavepoint(Savepoint savepoint) throws SQLException { connection.releaseSavepoint(savepoint); } @Override public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException { return connection.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability); } @Override public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException { return connection.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability); } @Override public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException { return connection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability); } @Override public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException { return connection.prepareStatement(sql, autoGeneratedKeys); } @Override public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException { return connection.prepareStatement(sql, columnIndexes); } @Override public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException { return connection.prepareStatement(sql, columnNames); } @Override public Clob createClob() throws SQLException { return connection.createClob(); } @Override public Blob createBlob() throws SQLException { return connection.createBlob(); } @Override public NClob createNClob() throws SQLException { return connection.createNClob(); } @Override public SQLXML createSQLXML() throws SQLException { return connection.createSQLXML(); } @Override public boolean isValid(int timeout) throws SQLException { return connection.isValid(timeout); } @Override public void setClientInfo(String name, String value) throws SQLClientInfoException { connection.setClientInfo(name, value); } @Override public void setClientInfo(Properties properties) throws SQLClientInfoException { connection.setClientInfo(properties); } @Override public String getClientInfo(String name) throws SQLException { return connection.getClientInfo(name); } @Override public Properties getClientInfo() throws SQLException { return connection.getClientInfo(); } @Override public Array createArrayOf(String typeName, Object[] elements) throws SQLException { return connection.createArrayOf(typeName, elements); } @Override public Struct createStruct(String typeName, Object[] attributes) throws SQLException { return connection.createStruct(typeName, attributes); } @Override public void setSchema(String schema) throws SQLException { connection.setSchema(schema); } @Override public String getSchema() throws SQLException { return connection.getSchema(); } @Override public void abort(Executor executor) throws SQLException { connection.abort(executor); } @Override public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException { connection.setNetworkTimeout(executor, milliseconds); } @Override public int getNetworkTimeout() throws SQLException { return connection.getNetworkTimeout(); } @Override public <T> T unwrap(Class<T> iface) throws SQLException { return connection.unwrap(iface); } @Override public boolean isWrapperFor(Class<?> iface) throws SQLException { return connection.isWrapperFor(iface); } } }
运行结果：
Thread-5 更新结果：1 Thread-5 更新耗时: 609 微秒。 Thread-4 更新结果：1 Thread-4 更新耗时: 616 微秒。 Thread-1 更新结果：1 Thread-1 更新耗时: 625 微秒。 Thread-3 更新结果：1 Thread-3 更新耗时: 626 微秒。 Thread-8 更新结果：1 Thread-8 更新耗时: 587 微秒。 Thread-7 更新结果：1 Thread-7 更新耗时: 624 微秒。 Thread-2 更新结果：1 Thread-2 更新耗时: 641 微秒。 Thread-0 更新结果：1 Thread-0 更新耗时: 649 微秒。 Thread-6 更新结果：1 Thread-6 更新耗时: 646 微秒。 Thread-9 更新结果：1 Thread-9 更新耗时: 608 微秒。 Thread-5 查询结果：[heihei.] Thread-5 查询耗时: 88 微秒。 Thread-4 查询结果：[heihei.] Thread-4 查询耗时: 97 微秒。 Thread-1 查询结果：[heihei.] Thread-1 查询耗时: 115 微秒。 Thread-8 查询结果：[heihei.] Thread-8 查询耗时: 134 微秒。 Thread-3 查询结果：[heihei.] Thread-3 查询耗时: 152 微秒。 Thread-7 查询结果：[heihei.] Thread-7 查询耗时: 166 微秒。 Thread-2 查询结果：[heihei.] Thread-2 查询耗时: 186 微秒。 Thread-6 查询结果：[heihei.] Thread-6 查询耗时: 199 微秒。 Thread-9 查询结果：[heihei.] Thread-9 查询耗时: 219 微秒。 Thread-0 查询结果：[heihei.] Thread-0 查询耗时: 241 微秒。 Thread-10 删除结果：1 Thread-10 删除耗时: 32 微秒。 Thread-11 删除结果：1 Thread-11 删除耗时: 52 微秒。 Thread-13 删除结果：1 Thread-13 删除耗时: 77 微秒。 Thread-12 删除结果：1 Thread-12 删除耗时: 101 微秒。 Thread-15 删除结果：1 Thread-15 删除耗时: 122 微秒。 Thread-14 删除结果：1 Thread-14 删除耗时: 144 微秒。 Thread-16 删除结果：1 Thread-16 删除耗时: 165 微秒。 Thread-17 删除结果：1 Thread-17 删除耗时: 187 微秒。 Thread-19 删除结果：1 Thread-19 删除耗时: 209 微秒。 Thread-18 删除结果：1 Thread-18 删除耗时: 234 微秒。
我们把SimpleDataSource类的getConnection() 改写一下：
@Override public Connection getConnection() throws SQLException { // // 加载驱动 // try { // Class.forName(dbDriver); // } catch (ClassNotFoundException e) { // e.printStackTrace(); // } // // // 每次返回一个新的数据库连接 // return DriverManager.getConnection(dbUrl, dbUserName, dbPasswd); // 每次从数据库连接池中获取 return getConnection(dbUserName, dbPasswd); }
再跑一遍：
Thread-6 更新结果：1 Thread-6 更新耗时: 663 微秒。 Thread-5 更新结果：1 Thread-5 更新耗时: 665 微秒。 Thread-7 更新结果：1 Thread-7 更新耗时: 665 微秒。 Thread-9 更新结果：1 Thread-9 更新耗时: 665 微秒。 Thread-1 更新结果：1 Thread-1 更新耗时: 668 微秒。 Thread-8 更新结果：1 Thread-8 更新耗时: 665 微秒。 当前数据库连接池还剩 6 个连接。 当前数据库连接池还剩 5 个连接。 当前数据库连接池还剩 4 个连接。 当前数据库连接池还剩 3 个连接。 当前数据库连接池还剩 2 个连接。 Thread-4 更新结果：1 Thread-4 更新耗时: 682 微秒。 当前数据库连接池还剩 2 个连接。 当前数据库连接池还剩 1 个连接。 Thread-3 更新结果：1 Thread-3 更新耗时: 689 微秒。 Thread-2 更新结果：1 Thread-2 更新耗时: 691 微秒。 Thread-0 更新结果：1 Thread-0 更新耗时: 698 微秒。 Thread-1 查询结果：[heihei.] Thread-9 查询结果：[heihei.] Thread-7 查询结果：[heihei.] Thread-8 查询结果：[heihei.] Thread-7 查询耗时: 35 微秒。 Thread-9 查询耗时: 34 微秒。 Thread-1 查询耗时: 34 微秒。 Thread-8 查询耗时: 34 微秒。 当前数据库连接池还剩 7 个连接。 Thread-6 查询结果：[heihei.] Thread-6 查询耗时: 69 微秒。 当前数据库连接池还剩 7 个连接。 Thread-5 查询结果：[heihei.] Thread-5 查询耗时: 67 微秒。 当前数据库连接池还剩 7 个连接。 当前数据库连接池还剩 6 个连接。 Thread-0 查询结果：[heihei.] Thread-0 查询耗时: 36 微秒。 当前数据库连接池还剩 6 个连接。 Thread-2 查询结果：[heihei.] Thread-2 查询耗时: 42 微秒。 Thread-3 查询结果：[heihei.] Thread-3 查询耗时: 45 微秒。 Thread-4 查询结果：[heihei.] Thread-4 查询耗时: 51 微秒。 当前数据库连接池还剩 8 个连接。 当前数据库连接池还剩 7 个连接。 当前数据库连接池还剩 6 个连接。 当前数据库连接池还剩 5 个连接。 当前数据库连接池还剩 4 个连接。 当前数据库连接池还剩 3 个连接。 当前数据库连接池还剩 2 个连接。 Thread-12 删除结果：1 Thread-12 删除耗时: 2 微秒。 Thread-11 删除结果：1 Thread-11 删除耗时: 3 微秒。 Thread-10 删除结果：1 Thread-13 删除结果：1 Thread-13 删除耗时: 9 微秒。 Thread-10 删除耗时: 9 微秒。 Thread-14 删除结果：1 Thread-14 删除耗时: 9 微秒。 Thread-16 删除结果：1 Thread-16 删除耗时: 8 微秒。 Thread-15 删除结果：1 Thread-15 删除耗时: 9 微秒。 当前数据库连接池还剩 8 个连接。 当前数据库连接池还剩 7 个连接。 当前数据库连接池还剩 6 个连接。 Thread-19 删除结果：1 Thread-19 删除耗时: 2 微秒。 Thread-17 删除结果：1 Thread-18 删除结果：1 Thread-18 删除耗时: 2 微秒。 Thread-17 删除耗时: 11 微秒。
