自己封装的数据源(支持多种数据库访问,内部实现线程池 基于bonecp)

一个简简单的数据访问封装,有错误的地方希望大家给我留言共同提高,源码下载链接(jar 包)

http://download.csdn.net/detail/u011658193/8675403

[java]  view plain copy
  1. package com.xiaojia.database.dao;  
  2.   
  3. import com.xiaojia.database.Connection;  
  4.   
  5.   
  6. public class BaseDao  extends Connection {  
  7.   
  8.     /** 
  9.      * 此类描述 继承Connection 实现数据源 
  10.      */  
  11.       
  12.     static{  
  13.         /** 
  14.          * 第一个参数,路径 
  15.          * 第二个参数,用户名 
  16.          * 第三个参数,密码(没有写空) 
  17.          * 第四个参数,驱动(支持多数据库) 
  18.          */  
  19.         init("jdbc:mysql://127.0.0.1:3306/test""root""","com.mysql.jdbc.Driver");  
  20.         //setDriverClass("com.mysql.jdbc.Driver");  
  21.     }  
  22. }  

[java]  view plain copy
  1. package com.xiaojia.database.dao;  
  2.   
  3. import java.sql.ResultSet;  
  4. import java.sql.SQLException;  
  5. import java.util.ArrayList;  
  6. import java.util.List;  
  7.   
  8. import com.xiaojia.database.ResultSetHandler;  
  9. import com.xiaojia.database.model.User;  
  10.   
  11.   
  12. public class UserDao extends BaseDao {  
  13.   
  14.     // 单例  
  15.     private static UserDao instance = new UserDao();  
  16.       
  17.     public static UserDao getInstance() {  
  18.         return instance;  
  19.     }  
  20.       
  21.     private UserDao(){};  
  22.       
  23.     // 添加  
  24.     private String addUser_sql = "insert into t_user(phonenum,password) values(?,?)";  
  25.       
  26.     public boolean addUser(User user) throws SQLException {  
  27.         boolean result = super.addObject(addUser_sql, new Object[]{user.getPhonenum(),user.getPassword()});  
  28.         return result;  
  29.     }  
  30.       
  31.     // 修改  
  32.     private String updUser_sql = "update t_user set phonenum=? where id=?";  
  33.       
  34.     public boolean updateUser(User user) throws SQLException {  
  35.         boolean result = super.updateObject(updUser_sql, new Object[]{user.getPhonenum(),user.getUid()});  
  36.         return result;  
  37.     }  
  38.       
  39.     // 删除  
  40.     private String delUser_sql = "delete from t_user where id=?";  
  41.       
  42.     public boolean delUser(int uid) throws SQLException {  
  43.         return super.deleteObject(delUser_sql,new Object[]{uid});  
  44.     }  
  45.       
  46.     private String listUser_sql = "select * from t_user";  
  47.       
  48.     // 列表  
  49.     public List<User> listUser() throws SQLException {  
  50.         return super.get(listUser_sql, new ResultSetHandler<List<User>>() {  
  51.               
  52.             List<User> userArray = new ArrayList<User>();  
  53.               
  54.             @Override  
  55.             public List<User> handle(ResultSet rs) throws SQLException {  
  56.                 while(rs.next()) {  
  57.                     User user = new User();  
  58.                     user.setCreatetime(rs.getString("createtime"));  
  59.                     user.setPassword(rs.getString("password"));  
  60.                     user.setPhonenum(rs.getString("phonenum"));  
  61.                     userArray.add(user);  
  62.                 }  
  63.                 return userArray;  
  64.             }  
  65.         });  
  66.     }  
  67. }  

[java]  view plain copy
  1. package com.xiaojia.database.model;  
  2.   
  3.   
  4. import java.io.Serializable;  
  5.   
  6. public class User implements Serializable {  
  7.   
  8.     private static final long serialVersionUID = 2942802677651309244L;  
  9.   
  10.     private String uid;  
  11.     private String phonenum;  
  12.     private String password;  
  13.     private String createtime;  
  14.     private String status;  
  15.       
  16.       
  17.     public String getUid() {  
  18.         return uid;  
  19.     }  
  20.     public void setUid(String uid) {  
  21.         this.uid = uid;  
  22.     }  
  23.     public String getPhonenum() {  
  24.         return phonenum;  
  25.     }  
  26.     public void setPhonenum(String phonenum) {  
  27.         this.phonenum = phonenum;  
  28.     }  
  29.     public String getPassword() {  
  30.         return password;  
  31.     }  
  32.     public void setPassword(String password) {  
  33.         this.password = password;  
  34.     }  
  35.     public String getCreatetime() {  
  36.         return createtime;  
  37.     }  
  38.     public void setCreatetime(String createtime) {  
  39.         this.createtime = createtime;  
  40.     }  
  41.     public String getStatus() {  
  42.         return status;  
  43.     }  
  44.     public void setStatus(String status) {  
  45.         this.status = status;  
  46.     }  
  47.     @Override  
  48.     public String toString() {  
  49.         return "User [uid=" + uid + ", phonenum=" + phonenum + ", password="  
  50.                 + password + ", createtime=" + createtime + ", status="  
  51.                 + status + "]";  
  52.     }  
  53.       
  54.       
  55.       
  56. }  

[java]  view plain copy
  1. package com.xiaojia.database.service;  
  2.   
  3. import java.sql.SQLException;  
  4. import java.util.List;  
  5.   
  6. import com.xiaojia.database.dao.UserDao;  
  7. import com.xiaojia.database.model.User;  
  8.   
  9. public class UserServiceImpl {  
  10.   
  11.     public boolean addUser(User user) {  
  12.         try {  
  13.             return UserDao.getInstance().addUser(user);  
  14.         } catch (SQLException e) {  
  15.             e.printStackTrace();  
  16.         }  
  17.         return false;  
  18.     }  
  19.   
  20.     public boolean updateUser(User user) {  
  21.         try {  
  22.             return UserDao.getInstance().updateUser(user);  
  23.         } catch (SQLException e) {  
  24.             e.printStackTrace();  
  25.         }  
  26.         return false;  
  27.     }  
  28.   
  29.     public boolean delUser(int uid) {  
  30.         try {  
  31.             return UserDao.getInstance().delUser(uid);  
  32.         } catch (SQLException e) {  
  33.             e.printStackTrace();  
  34.         }  
  35.         return false;  
  36.     }  
  37.       
  38.     public List<User> listUser() {  
  39.         try {  
  40.             return UserDao.getInstance().listUser();  
  41.         } catch (SQLException e) {  
  42.             e.printStackTrace();  
  43.         }  
  44.         return null;  
  45.     }  
  46.       
  47.     public static void main(String[] args) {  
  48.         User user = new User();  
  49.   
  50.         UserServiceImpl ser = new UserServiceImpl();  
  51.   
  52. //       user.setPhonenum("12121212");  
  53. //       user.setPassword("12121212");  
  54. //       ser.addUser(user);  
  55.   
  56. //      user.setPhonenum("2323232323");  
  57. //      user.setUid("46");  
  58. //      ser.updateUser(user);  
  59. //      ser.delUser(45);  
  60.         System.out.println(ser.listUser().toString());  
  61.     }  
  62. }  
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在用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>
在使用数据库连接池进行读写分离时,需要配置多个只读数据库连接和一个读写数据库连接,在应用程序中根据SQL语句类型自动选择读写数据库连接。以下是一个基本的实现方法: 1. 配置数据库连接池:使用第三方的连接池工具,如C3P0、DBCP和BoneCP等,配置多个只读数据库连接和一个读写数据库连接。例如,在C3P0连接池中,可以使用以下代码配置多个只读数据库连接和一个读写数据库连接: ``` ComboPooledDataSource dataSource = new ComboPooledDataSource(); dataSource.setDriverClass("oracle.jdbc.driver.OracleDriver"); dataSource.setJdbcUrl("jdbc:oracle:thin:@readonly1:1521:orcl"); dataSource.setUser("readonly_user"); dataSource.setPassword("readonly_password"); dataSource.setReadOnly(true); dataSource.setMaxPoolSize(10); ComboPooledDataSource dataSourceRW = new ComboPooledDataSource(); dataSourceRW.setDriverClass("oracle.jdbc.driver.OracleDriver"); dataSourceRW.setJdbcUrl("jdbc:oracle:thin:@readwrite:1521:orcl"); dataSourceRW.setUser("readwrite_user"); dataSourceRW.setPassword("readwrite_password"); dataSourceRW.setReadOnly(false); dataSourceRW.setMaxPoolSize(10); ``` 其中,`@readonly1` 是只读数据库连接字符串,`readwrite` 是读写数据库连接字符串,`readonly_user` 和 `readwrite_user` 分别是只读用户和读写用户的用户名,`readonly_password` 和 `readwrite_password` 分别是只读用户和读写用户的密码。 2. 在代码中使用连接池:在代码中使用连接池时,可以根据SQL语句类型自动选择读写数据库连接。例如: ``` Connection conn = null; if (isSelectQuery(sql)) { conn = dataSource.getConnection(); } else { conn = dataSourceRW.getConnection(); } PreparedStatement pstmt = conn.prepareStatement(sql); ResultSet rs = pstmt.executeQuery(); ``` 其中,`isSelectQuery()` 方法用于判断当前 SQL 语句是否是读操作,如果是则使用只读数据库连接,否则使用读写数据库连接。 需要注意的是,使用数据库连接池进行读写分离需要进行额外的开发和配置,但相对于使用Oracle Data Guard或Oracle RAC进行读写分离,更加灵活、可控,适用于一些小型应用场景。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值