Java的BoneCP数据库连接池

最新推荐文章于 2024-03-09 15:25:12 发布
最新推荐文章于 2024-03-09 15:25:12 发布
阅读量858 收藏
点赞数
分类专栏： J2SE 文章标签： 数据库连接池 java sql string 数据库 null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangtang_newton/article/details/7668548
版权

 

  • 在JDBC中使用BoneCP

在JDBC中使用BoneCP相当简单，设置一些关于数据库连接池的参数信息，比如连接池的最大、最小连接数等。下面是一个简单的例子：
 

  1. package com.netskycn;  
  2. import java.sql.Connection;  
  3. import java.sql.ResultSet;  
  4. import java.sql.SQLException;  
  5. import java.sql.Statement;  
  6.  
  7. import com.jolbox.bonecp.BoneCP;  
  8. import com.jolbox.bonecp.BoneCPConfig;  
  9.    
  10. /** 测试bonecp数据库连接池的工具  
  11.  * @author zhoufoxcn 周公  
  12.  * @version 0.1  
  13.  * 说明：这是一个在JDBC中使用BoneCP的例子  
  14.  * 2010-11-23  
  15.  */ 
  16. public class MainClass {  
  17.     public static void main(String[] args) {  
  18.         BoneCP connectionPool = null;  
  19.         Connection connection = null;  
  20.    
  21.         try {  
  22.             //加载JDBC驱动  
  23.             Class.forName("com.mysql.jdbc.Driver");  
  24.         } catch (Exception e) {  
  25.             e.printStackTrace();  
  26.             return;  
  27.         }  
  28.           
  29.         try {  
  30.             //设置连接池配置信息  
  31.             BoneCPConfig config = new BoneCPConfig();  
  32.             //数据库的JDBC URL  
  33.             config.setJdbcUrl("jdbc:mysql:///jobeet");   
  34.             //数据库用户名  
  35.             config.setUsername("root");   
  36.             //数据库用户密码  
  37.             config.setPassword("jeri");  
  38.             //数据库连接池的最小连接数  
  39.             config.setMinConnectionsPerPartition(5);  
  40.             //数据库连接池的最大连接数  
  41.             config.setMaxConnectionsPerPartition(10);  
  42.             //  
  43.             config.setPartitionCount(1);  
  44.             //设置数据库连接池  
  45.             connectionPool = new BoneCP(config);  
  46.             //从数据库连接池获取一个数据库连接  
  47.             connection = connectionPool.getConnection(); // fetch a connection  
  48.               
  49.             if (connection != null){  
  50.                 System.out.println("Connection successful!");  
  51.                 Statement stmt = connection.createStatement();  
  52.                 ResultSet rs = stmt.executeQuery("SELECT * FROM customer");   
  53.                 while(rs.next()){  
  54.                     System.out.println(rs.getInt(1)+":"+rs.getString("firstname")+","+rs.getString("lastname"));   
  55.                 }  
  56.             }  
  57.             //关闭数据库连接池  
  58.             connectionPool.shutdown();   
  59.         } catch (SQLException e) {  
  60.             e.printStackTrace();  
  61.         } finally {  
  62.             if (connection != null) {  
  63.                 try {  
  64.                     connection.close();  
  65.                 } catch (SQLException e) {  
  66.                     e.printStackTrace();  
  67.                 }  
  68.             }  
  69.         }  
  70.     }  
  71. } 

====================一个池的例子========DatabaseConnectionPool.java=========================

package org.dave.common.database;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.ResourceBundle;

//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;

import com.jolbox.bonecp.BoneCP;
import com.jolbox.bonecp.BoneCPConfig;

/**
 * 数据库连接池
 * @author David Day
 */
public final class DatabaseConnectionPool {
 
 public static void main(String[] args) {
//  test for "conf/sysconfig.ini"
//  startup();
//  
  Connection conn = DatabaseConnectionPool.getConnection();
  if(null != conn){
   System.err.println("conn is not null");
   try {
    conn.close();
   } catch (Exception e) {
    // TODO: handle exception
   }
  }else{
   System.err.println("conn is null=====");
  }
 }
 
 static{
  startup();
 }
 
  
 private static ResourceBundle BUNDLE = ResourceBundle.getBundle("conf/sysconfig");//从sysconfig.ini中获取
 private static final String DRIVER = "driver";
 private static final String URL = "default.url";
 private static final String USERNAME = "default.user";
 private static final String PASSWORD = "default.password";
 private static final String MAX_CONNECTION = "db.maxConn";
 private static BoneCP pool;
 
 /**
  * 开启连接池
  */
 public static void startup() {
  System.err.println("begin to startup...");
  try {
   // for test
//   System.err.println("DRIVER " + BUNDLE.getString(DRIVER));
//   System.err.println("URL " + BUNDLE.getString(URL));
//   System.err.println("USERNAME " + BUNDLE.getString(USERNAME));
//   System.err.println("PASSWORD " + BUNDLE.getString(PASSWORD));
//   System.err.println("MAX_CONNECTION " + BUNDLE.getString(MAX_CONNECTION));
   BUNDLE = ResourceBundle.getBundle("conf/sysconfig");
   
   Class.forName(BUNDLE.getString(DRIVER));
   BoneCPConfig config = new BoneCPConfig();
   config.setJdbcUrl(BUNDLE.getString(URL));
   config.setUsername(BUNDLE.getString(USERNAME));
   config.setPassword(BUNDLE.getString(PASSWORD));
   config.setMaxConnectionsPerPartition(Integer.parseInt(BUNDLE.getString(MAX_CONNECTION)));
    config.setPartitionCount(3);
   pool = new BoneCP(config);
   
   System.out.println("已经创建的数据库连接(startup)"+pool.getTotalCreatedConnections());
      System.out.println("已创建未使用(startup)"+pool.getTotalFree());
      System.out.println("正在使用(startup)"+pool.getTotalLeased());
  } catch (Exception e) {
   e.printStackTrace();
   }
 }
 
 /**
  * 关闭连接池
  */
 public static void shutdown() {
  pool.shutdown();
 }
 
 /**
  * @return 数据库连接
  */
 public static Connection getConnection() {
  try {
   return pool.getConnection();
  } catch (SQLException e) {
   e.printStackTrace();
//   LOG.error(e.getMessage(), e);
//   throw new DatabaseException(e);
   return null;
  }
 }
 public static void closeConnection(Connection conn) {
  if(null != conn){
   try {
    conn.close();
   } catch (SQLException e) {
    e.printStackTrace();
   }
  }
  if(null != pool){
   System.out.println("已创建["+pool.getTotalCreatedConnections()+"]未使用["+pool.getTotalFree()+"]在使用["+pool.getTotalLeased()+"]");
  }
 }
}

========================对应的数据库存储类===========================================

 

package org.dave.common.database.access;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

import org.dave.common.database.convert.ResultConverter;

/**
 * 数据存取类
 * @author David Day
 */
public abstract class DataAccess {
 
 /**
  * 日志工具
  */
// private static final Logger LOG = LoggerFactory.getLogger(DataAccess.class);
 /**
  * 数据库连接
  */
 private Connection conn;
 /**
  * @param conn 数据库连接
  */
 protected DataAccess(Connection conn) {
  this.conn = conn;
 }
 
 /**
  * 插入数据
  * @param sql
  * @param generatedKeysConverter 主键映射
  * @param params
  * @return 主键
  * @throws DataAccessException
  */
 protected <T> T insert(String sql, ResultConverter<T> generatedKeysConverter, Object... params) throws DataAccessException {
  try {
   PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
   setParameters(pstmt, params);
   executeUpdate(pstmt);
   ResultSet rs = pstmt.getGeneratedKeys();
   nextResult(rs);
   return convertResult(rs, generatedKeysConverter);
  } catch (SQLException e) {
   e.printStackTrace();
//   LOG.error(e.getMessage(), e);
   throw new DataAccessException(e);
  }
 }
 
 /**
  * 更新数据
  * @param sql
  * @param params
  * @return 影响行数
  * @throws DataAccessException
  */
 protected int update(String sql, Object... params) throws DataAccessException {
  return executeUpdate(getPreparedStatement(sql, params));
 }
 
 /**
  * 查询单个结果
  * @param <T>
  * @param sql
  * @param converter
  * @param params
  * @return
  */
 protected <T> T queryForObject(String sql, ResultConverter<T> converter, Object... params) {
  ResultSet rs = executeQuery(sql, params);
  if (nextResult(rs)) {
   return convertResult(rs, converter);
  } else {
   return null;
  }
 }
 
 /**
  * 查询结果列表
  * @param <T>
  * @param sql
  * @param converter
  * @param params
  * @return
  */
 protected <T> List<T> queryForList(String sql, ResultConverter<T> converter, Object... params) {
  ResultSet rs = executeQuery(sql, params);
  List<T> list = new ArrayList<T>();
  while (nextResult(rs)) {
   list.add(convertResult(rs, converter));
  }
  return list;
 }
 
 /**
  * @param sql SQL语句
  * @return 预编译声明
  */
 private PreparedStatement getPreparedStatement(String sql, Object... params) throws DataAccessException {
  PreparedStatement pstmt = getPreparedStatement(sql);
  setParameters(pstmt, params);
  return pstmt;
 }
 
 /**
  * @param sql SQL语句
  * @return 预编译声明
  */
 private PreparedStatement getPreparedStatement(String sql) throws DataAccessException {
  try {
   return conn.prepareStatement(sql);
  } catch (SQLException e) {
   e.printStackTrace();
//   LOG.error(e.getMessage(), e);
   throw new DataAccessException(e);
  }
 }
 
 /**
  * 为预编译声明传入参数
  * @param pstmt 预编译声明
  * @param params 参数
  * @throws DataAccessException
  */
 private void setParameters(PreparedStatement pstmt, Object... params) throws DataAccessException {
  try {
   for (int i = 0; i < params.length; i++) {
    pstmt.setObject(i + 1, params[i]);
   }
  } catch (SQLException e) {
   e.printStackTrace();
//   LOG.error(e.getMessage(), e);
   throw new DataAccessException(e);
  }
 }
 
 /**
  * 执行更新操作
  * @param pstmt
  * @return 影响行数
  * @throws DataAccessException
  */
 private int executeUpdate(PreparedStatement pstmt) throws DataAccessException {
  try {
   return pstmt.executeUpdate();
  } catch (SQLException e) {
   e.printStackTrace();
//   LOG.error(e.getMessage(), e);
   throw new DataAccessException(e);
  }
 }
 
 /**
  * 执行查询操作
  * @param pstmt 预编译声明
  * @return 结果集
  * @throws DataAccessException
  */
 private ResultSet executeQuery(PreparedStatement pstmt) throws DataAccessException {
  try {
   return pstmt.executeQuery();
  } catch (SQLException e) {
   e.printStackTrace();
//   LOG.error(e.getMessage(), e);
   throw new DataAccessException(e);
  }
 }
 
 /**
  * 执行查询操作
  * @param sql SQL语句
  * @param params 参数
  * @return 结果集
  * @throws DataAccessException
  */
 private ResultSet executeQuery(String sql, Object... params) throws DataAccessException {
  return executeQuery(getPreparedStatement(sql, params));
 }
 
 /**
  * 移动到下一行记录
  * @param rs 结果集
  * @return 是否有下一行记录
  * @throws DataAccessException
  */
 private boolean nextResult(ResultSet rs) throws DataAccessException {
  try {
   return rs.next();
  } catch (SQLException e) {
   e.printStackTrace();
//   LOG.error(e.getMessage(), e);
   throw new DataAccessException(e);
  }
 }
 
 /**
  * 映射
  * @param rs 结果集
  * @return 映射结果
  * @throws DataAccessException
  */
 private <T> T convertResult(ResultSet rs, ResultConverter<T> converter) throws DataAccessException {
  try {
   return converter.convert(rs);
  } catch (SQLException e) {
   e.printStackTrace();
//   LOG.error(e.getMessage(), e);
   throw new DataAccessException(e);
  }
 }

}

 

======================对应转化后的数据库处理类==================================

package com.qh.server;

import java.sql.Connection;

import org.dave.common.database.access.DataAccess;
import org.dave.common.database.convert.IntegerConverter;
import org.dave.common.database.convert.LongConverter;
import org.dave.common.database.convert.StringConverter;

public class HandleDAO extends DataAccess{

 protected HandleDAO(Connection conn) {
  super(conn);
  // TODO Auto-generated constructor stub
 }

 /**
  * 个数查询
  * @param sql
  * @return
  */
 public int findIntV(String sql) {
  Integer i = super.queryForObject(sql,new IntegerConverter());
  return null == i ? 0 : i.intValue();
//  return super.queryForObject("SELECT id,name,pass,email FROM demo WHERE id=?",
//    new DemoConverter(), id);
 }
 
 /**
  * 字符串查询
  * @param sql
  * @return
  */
 public String findStringV(String sql) {
  String s = super.queryForObject(sql,new StringConverter());
  return null == s ? "" : s;
 }
 
 public Long findLongV(String sql) {
  Long s = super.queryForObject(sql,new LongConverter());
  return null == s ? Long.parseLong("0") : s;
 }
 
 /**
  * 更新
  * @param sql
  */
 public void update(String sql) {
  super.update(sql);
 }
}

 

======================调用例子代码===================

 conn = DatabaseConnectionPool.getConnection();
   dao = new HandleDAO(conn);
   int a = dao.findIntV(sql);

 

yangtang_newton
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据连接池——BoneCP
progammer10086的博客
08-03 431
最后讲的是BoneCP，到目前为止老一代的四种连接池(c3p0,DBCP,proxool,BoneCP)就到这里了 把我这几篇博客都看了的小伙伴或许会发现，这四种连接池的配置极其的相似，套路完全一样，总的来说连接池的操作还是比较简单的，下面我把BoneCP说一下 BoneCP网上的资料真的是少之又少，毕竟这个很少使用 1.导入jar包，BoneCP要的jar包比较的多 bonecp-pro...
bonecp连接池
05-23
在用C3P0数据连接池的时候，一旦并发上来就坑不住了，因为C3P0存在BUG，c3p0在从连接池中获取和返回连接的时候，采用了异步的处理方式，使用一个线程池来异步的 把返回关闭了（没有真正关闭）的连接放入连接池中。这样就意味着，我们在调用了从c3p0获得的连接的close方法时，不是立即放回池中的，而是放入一 个事件队列中等待c3p0内部的线程池顺序的处理。这里给出bonecp连接池，用了就知道好了 #bonecp properties #分区数量 bonecp.partitionCount = 1 #每个分区含有的最小连接数 bonecp.minConnectionsPerPartition = 1 #每个分区含有的最大连接数 bonecp.maxConnectionsPerPartition = 2 #每次新增连接的数量 bonecp.acquireIncrement = 1 #连接池阀值，当 可用连接/最大连接 < 连接阀值 时，创建新的连接 bonecp.poolAvailabilityThreshold = 20 #连接超时时间阀值，获取连接时，超出阀值时间，则获取失败，毫秒为单位 bonecp.connectionTimeout = 10000 #连接池助手线程数量，可设置为0，该参数会降低运行速度，但程序有大量连接时，有助于提升高并发程序的性能 bonecp.releaseHelperThreads = 0 #语句助手线程数，可设置为0，该参数会降低运行速度，但程序有大量的查询语句时，有助于提升高并发程序的性能 bonecp.statementReleaseHelperThreads = 0 #测试连接有效性的间隔时间，单位分钟 bonecp.idleConnectionTestPeriod = 60 #连接的空闲存活时间，当连接空闲时间大于该阀值时，清除该连接 bonecp.idleMaxAge = 240 #语句缓存个数，默认是0 bonecp.statementsCacheSize = 5 在Hibernate中使用BoneCP除了需要上面提到的jar包之外，还需要下载一个名为bonecp-provider-0.7.0.jar的bonecp-provider的jar包，它的下载位置是：http://jolbox.com/bonecp/downloads/maven/com/jolbox/bonecp-provider/0.7.0/bonecp-provider-0.7.0.jar。 除此之外，还需要做如下配置： <!-- Hibernate SessionFactory --> <bean id="sessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean" autowire="autodetect"> <property name="hibernateProperties"> <props> <prop key="hibernate.connection.provider_class">com.jolbox.bonecp.provider.BoneCPConnectionProvider</prop> <prop key="hibernate.connection.driver_class">com.mysql.jdbc.Driver</prop> <prop key="hibernate.connection.url">jdbc:mysql://127.0.0.1/yourdb</prop> <prop key="hibernate.connection.username">root</prop> <prop key="hibernate.connection.password">abcdefgh</prop> <prop key="bonecp.idleMaxAge">240</prop> <prop key="bonecp.idleConnectionTestPeriod">60</prop> <prop key="bonecp.partitionCount">3</prop> <prop key="bonecp.acquireIncrement">10</prop> <prop key="bonecp.maxConnectionsPerPartition">60</prop> <prop key="bonecp.minConnectionsPerPartition">20</prop> <prop key="bonecp.statementsCacheSize">50</prop> <prop key="bonecp.releaseHelperThreads">3</prop> </props> </property> </bean>
BoneCP 学习笔记
Y.out
08-02 270
什么是BoneCP BoneCP 是一个快速、免费而且开源的java数据库连接池(JDBC Pool)管理工具库。如果你曾经使用过C3P0或者DBCP，那你肯定知道上面这句话的意思；如果你没用过这些，那简单的解释一下，它是一个能为你的应用管理数据库连接的工具。   官方网站：http://jolbox.com/   为什么要学习BoneCP ...
BoneCP 数据库连接池
zj380475045的博客
07-05 1800
BoneCP是一个开源的数据库连接池，听说比C3P0快好多倍（这个自己没有验证过） 官网： http://jolbox.com/index.html MAVEN dependency: <dependency> <groupId>com.jolbox</groupId> <artifactId>bonecp</artifactId>
Java数据库连接池比较（c3p0,dbcp,proxool和BoneCP）
grefr的技术博客，博客已迁移至 http://blog.yemou.net
05-23 153
详见：[url]http://blog.yemou.net/article/query/info/tytfjhfascvhzxcytp21[/url] Java框架数据库连接池比较（c3p0,dbcp和proxool，BoneC） 现在常用的开源数据连接池主要有c3p0,dbcp，proxool，BoneCP，其中： ¨ hibernate开发组推荐使用c3p0; ...
Java数据库连接池 BoneCP
06-02
BoneCP是一款轻量级、高性能的Java数据库连接池，设计目标是解决传统数据库连接池在高并发环境下的性能瓶颈问题。 BoneCP的核心原理是预先创建并维护一定数量的数据库连接，这些连接存储在一个池中，当应用程序需要...
bonecp数据库连接池使用Demo
10-18
采用bonecp数据库连接池封装了Jdbc，当时也是网上下载了一份代码，发现不能用，只好自己修改代码，现在这个代码是可以直接运行的，测试用的Sql Server 2008，表很简单，就四个字段
Java中的BoneCP数据库连接池用法.doc
05-04
Java 中的 BoneCP 数据库连接池用法 BoneCP 是一个开源的 Java 数据库连接池，它的官方网站网址是 http://jolbox.com/。据 BoneCP 官方网站报告称，BoneCP 比性能排名第二的 Java 数据库连接池性高高 25 倍以上，...
基于java的数据库连接池 BoneCP.zip
05-28
BoneCP是一款高效、轻量级的Java数据库连接池实现，它在设计上注重了性能和线程安全。 BoneCP的配置文件通常以`bonecp-default-config.xml`的形式存在，这是设置连接池参数的关键文件。在该文件中，开发者可以定制...
bonecp连接池demo
04-03
NULL 博文链接：https://aleywang.iteye.com/blog/1477371
BoneCP 连接池学习笔记
10-13
BoneCP 连接池学习笔记 例子 代码
基于Java的数据库连接池 BoneCP.zip
06-17
BoneCP是一个高效、轻量级的Java数据库连接池实现，设计目标是提供比其他连接池更高的并发性能。在这个"基于Java的数据库连接池 BoneCP.zip"压缩包中，我们可以找到与 BoneCP 相关的关键配置文件和组件。 首先，`...
BoneCP - 高性能的JDBC连接池
最新发布
gitblog_00007的博客
03-09 384
BoneCP - 高性能的JDBC连接池 BoneCP 是一个高性能、轻量级的 JDBC 连接池实现。它通过优化线程模型和提供精细的并发控制，实现了高并发环境下的高效数据库访问。 什么是 BoneCP？ BoneCP 是一个开源的 Java 框架，用于管理数据库连接。它可以自动创建、管理和回收数据库连接，从而减轻开发人员的工作负担，并提高应用程序的性能和稳定性。 BoneCP 能用来做什么？ 通过...
Java中的BoneCP数据库连接池用法
为梦想而飞
09-02 4507
在2006年8月的时候我在项目中使用过Proxool这个Java数据库连接池，在当时的使用过程中遇到了一些问题，为此曾写过一篇名为《关于Proxool使用的一点问题》的博客，网址是http://blog.csdn.net/zhoufoxcn/archive/2006/08/30/1142685.aspx，博文发布以后有很多朋友在博文下面留言，因为它们也遇到了类似的问题。我记得我在2006年使用Pr
JDBC连接池BoneCP
qq_1141193930的博客
11-02 181
public class ExampleDataSource { public static void main(String[] args) { Connection connection = null; try { Class.forName("com.mysql.jdbc.Driv...
BoneCp连接池总结
java的平凡之路
09-26 907
1、数据库连接池c3p0、dbcp、bonecp     hibernate推荐c3p0，spring推荐dbcp，但是公司项目用的bonecp，有点并发更好，不是用的synchronize关键字，而是使用了concurrent包，连接池响应更快。配置入下：      xml version="1.0" encoding="UTF-8"?> xmlns="http://w
数据库连接池 BoneCP、HikariCP 等
简简单单Onlinezuozuo
02-14 725
Tomcat 在 7.0 以前都是使用 common-dbcp 做为连接池组件，但是 dbcp 是单线程，为保证线程安全会锁整个连接池，性能较差，dbcp有超过60个类，也相对复杂。大型系统一般都有专门的监控类软件，如 skywalking、prometheus 等，因此连接池只需要做好的他的本职工作即可，应该更加关注连接池的性能。LRU 是思路是，最近使用过的缓存被认为是有用的，很久都没用过的数据应该是无用的，当内存空间不足时，应该优先淘汰很久没使用过的缓存。这样的场景，性能可能是一个数量级的提升。
在tomcat下配置BoneCP连接池
IOT之无线网络传输技术
04-16 2103
<br />公司的内部服务器,一直是采用的tomcat,连接池也是采用的tomcat自带的dbcp.最近发现好象连接池的数据库连接只会增加,不会自动释 放.后来网上一查,很多人说这是dbcp的老毛病了,虽然基本不影响使用,但毕竟占用了数据库资源,因此,想测试一下其它连接池.首先找到有人推荐的 proxool,这个网上有详细的配置方式,一配就通了.但又在网上看到一个快速的连接池BoneCP,决定也测试一下.结果在 http://jolbox.com/ 和网上都只看到在spring下的配置方式.于是自
数据库连接池配置详解：c3p0, JDBC, JNDI, BoneCP
本文将详细解析c3p0、jdbc、jndi和BoneCP等多种数据库连接池的配置。” 数据库连接池是现代应用程序中用于高效管理数据库连接的重要工具。其工作原理在于预先创建一定数量的数据库连接，存储在一个池中，应用程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值