/////////jdbc连接操作
private static String url;
/**
* 用户名
*/
private static String userName;
/**
* 密码
*/
private static String password;
private static String driver;
// 连接池
private static int max = 20;
private static int min = 2;
private static int count = 0;
private static List<Connection> freeConn = new ArrayList<Connection>();
// private static List<Connection> useConn = new ArrayList<Connection>();
/**
* 装载驱动
*/
static {
DbConfig config = new DbConfig();
url = config.getUrl();
userName = config.getUserName();
password = config.getPassword();
driver = config.getDriver();
try {
Class.forName(driver);
} catch (ClassNotFoundException e) {
throw new ExceptionInInitializerError(e);
}
initCon();
}
public static void initCon() {
try {
// 初始化
Connection conn;
if (count > max) {// 如果大于 最大,就只new一个;
conn = DriverManager.getConnection(url, userName, password);
freeConn.add(conn);
} else {
for (int i = 0; i < min; i++) {
conn = DriverManager.getConnection(url, userName, password);
freeConn.add(conn);
count++;
}
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 建立数据库连接
*
* @return
* @throws SQLException
*/
public static synchronized Connection getConnection() throws SQLException {
if (null == freeConn || freeConn.size() == 0) {
initCon();
}
Connection conn = freeConn.get(0);
freeConn.remove(0);
if (conn.isClosed()) {// 已关闭,去找未关闭的连接
while (true) {
conn = freeConn.get(0);
if (!conn.isClosed()) {// 未关闭
freeConn.remove(0);//如果移除完了,就重新init连接
break;
}
freeConn.remove(0);//如果移除完了,就重新init连接
if (null == freeConn || 0 == freeConn.size()) {
initCon();
}
}
}
return conn;
// conn = DriverManager.getConnection(url, userName, password);
// return conn;
}
/**
* 释放连接
*
* @param conn
*/
private static void freeConnection(Connection conn) {
freeConn.add(conn);
// try {
// conn.close();
// } catch (SQLException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
}
/**
* 释放statement
*
* @param statement
*/
private static void freeStatement(Statement statement) {
try {
statement.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 释放resultset
*
* @param rs
*/
private static void freeResultSet(ResultSet rs) {
try {
rs.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 释放资源
*
* @param conn
* @param statement
* @param rs
*/
public static void free(Connection conn, Statement statement, ResultSet rs) {
if (rs != null) {
freeResultSet(rs);
}
if (statement != null) {
freeStatement(statement);
}
if (conn != null) {
freeConnection(conn);
}
}
////////////////////////////////查询操作
/**
* 根据sql获得 obj对象集合的数据
* @param sql
* @param cla
* @param paramters
* @return
* @throws Exception
*/
@SuppressWarnings("rawtypes")
public static List<Object> queryObjs(String sql,Class cla, Object... paramters)
throws Exception {
ResultSet rs = null;
try {
getPreparedStatement(sql);
for (int i = 0; i < paramters.length; i++) {
preparedStatement.setObject(i + 1, paramters[i]);
}
rs = preparedStatement.executeQuery();
// ResultToListObj(ResultSet rs,Class cla)
return ResultToListObj(rs,cla);
} catch (SQLException e) {
throw new SQLException(e);
} finally {
free(rs);
}
}
/**
* 获取PreparedStatement
*
* @param sql
* @throws SQLException
*/
private static void getPreparedStatement(String sql) throws SQLException {
conn = JdbcUnits.getConnection();
preparedStatement = conn.prepareStatement(sql);
}
/**
* 用于增删改
*
* @param sql
* sql语句
* @return 影响行数
* @throws SQLException
*/
public static int update(String sql) throws SQLException {
try {
getPreparedStatement(sql);
return preparedStatement.executeUpdate();
} catch (SQLException e) {
throw new SQLException(e);
} finally {
free();
}
}
/**
* 用于增删改(带参数)
*
* @param sql
* sql语句
* @param paramters
* sql语句
* @return 影响行数
* @throws SQLException
*/
public static int update(String sql, Object... paramters)
throws SQLException {
try {
getPreparedStatement(sql);
for (int i = 0; i < paramters.length; i++) {
preparedStatement.setObject(i + 1, paramters[i]);
}
return preparedStatement.executeUpdate();
} catch (SQLException e) {
throw new SQLException(e);
} finally {
free();
}
}
/**
* 返回obj对象的数据
* @param rs
* @param cla
* @return
* @throws Exception
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
private static List<Object> ResultToListObj(ResultSet rs,Class cla) throws Exception {
List list = new ArrayList();
// Class cla = Mystudy.class;
//获取全部公共域的方法
Field[] field=cla.getDeclaredFields();//获得定义的属性
// for(Field f:field){
// System.out.println("获取全部公共域的方法:"+f.toString());
// }
while (rs.next()) {
ResultSetMetaData md = rs.getMetaData();
// Map<String,String> map = new HashMap<String,String>();
Object obj = cla.newInstance();//获得类实例
for (int i = 1; i <= md.getColumnCount(); i++) {
// System.out.println(md.getColumnType(i)+":"+md.getColumnLabel(i)+">>>>>"+rs.getObject(i));
// int tmp = md.getColumnType(i);
for(Field f:field){
// System.out.println(f.getName()+">>"+f.getType()); );
if(f.getName().equalsIgnoreCase(md.getColumnLabel(i))){//属性与表列名相同
if("int".equalsIgnoreCase(f.getType()+"")){
PropertyDescriptor pd = new PropertyDescriptor(f.getName(), cla);
Method wM = pd.getWriteMethod();//获得写方法
wM.invoke(obj, stringToInt(rs.getObject(i)+""));
}else if("long".equalsIgnoreCase(f.getType()+"")){
PropertyDescriptor pd = new PropertyDescriptor(f.getName(), cla);
Method wM = pd.getWriteMethod();//获得写方法
wM.invoke(obj, stringToLong(rs.getObject(i)+""));
}else{
PropertyDescriptor pd = new PropertyDescriptor(f.getName(), cla);
Method wM = pd.getWriteMethod();//获得写方法
wM.invoke(obj,rs.getObject(i)+"");
}
break;
}
}
// map.put(md.getColumnLabel(i), rs.getObject(i)+"");
}
list.add(obj);
}
return list;
}
/////////////////////////////////用户查询示例
public Video getVideoObjByid(int video_id) {
StringBuffer sql = new StringBuffer();
sql.append(" select * from video ");
sql.append(" where id = ? ");
sql.append(" limit 1 ");
try {
List<Object> objList = JdbcHelper.queryObjs(sql.toString(), Video.class, video_id);
Video o = null;
if (null != objList && objList.size() > 0) {
o = (Video) objList.get(0);
}
return o;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
相关推荐
Java JDBC连接池是一种高效管理数据库连接的技术,它允许应用程序重复使用已经建立的数据库连接,而不是每次需要时都创建新的连接。这显著提高了性能并减少了系统资源的消耗,尤其是在高并发的环境中。本类库提供了...
它基于Jakarta POI项目中的池化代码,并提供了对JDBC连接的池化管理。DBCP可以有效地减少创建和销毁数据库连接的开销,尤其是在高并发的应用场景下。这个库通常会依赖`commons-pool.jar`来处理对象的池化操作,而`...
`JdbcTemplate`通过封装常见的JDBC操作,如执行SQL查询、更新、调用存储过程等,避免了手动管理连接、结果集解析等繁琐工作,提高了代码的可读性和可维护性。开发者只需提供SQL语句和参数,`JdbcTemplate`会自动处理...
JDBC提供了一种标准的API,使得Java开发者能够连接到不同的数据库系统,执行SQL语句,处理结果集,并对数据库进行增删改查操作。本学习手册将深入探讨JDBC的核心概念、使用方法以及最佳实践。 一、JDBC基础 1. ...
- 数据源(DataSource):在Java应用中,推荐使用DataSource对象来获取数据库连接,它提供了一种池化连接的机制,能有效管理和重用数据库连接,提高系统性能。 - 获取连接:通过DataSource的getConnection()方法...
1. PooledConnection:C3P0的核心是PooledConnection对象,它是对数据库连接的封装,实现了java.sql.Connection接口。 2. ConnectionPoolDataSource:这是C3P0的数据源,负责提供PooledConnection实例。 3. ...
Java中的数据库连接是应用程序与数据库交互的基础,而`DBUtil`类是一个常见的工具类,用于封装数据库连接的创建、管理以及执行SQL语句的过程。在Java中,我们通常使用JDBC(Java Database Connectivity)API来实现...
6. **JDBC (Java Database Connectivity)**:JDBC是Java语言连接数据库的标准API。Spring JDBC模块提供了一种高级的抽象层,可以更方便地执行SQL语句,管理连接,处理异常,从而减少代码的重复性。 7. **MyBatis**...
- PooledConnection:连接池中的连接对象,封装了实际的数据库连接。 2. **C3P0主要组件** - `com.mchange.v2.c3p0.ComboPooledDataSource`:C3P0的核心数据源类,负责管理和维护数据库连接。 - Connection ...
Java的JDBC(Java Database Connectivity)API提供了与各种数据库的连接接口。通过DataSource,可以实现数据库连接的池化,提高性能和资源利用率。 6. **权限控制**:在办公自动化系统中,权限控制至关重要,确保...
这个库包括了对JDBC API的封装,以及连接池的管理逻辑,使得多个并发的数据库操作可以共享有限的数据库连接资源,从而降低系统资源消耗,提升系统性能。 而`commons-pool`是Apache Commons的另一个项目,它的主要...
"连接池(内含dbcp c3p0)jar包" 提供了两个著名的Java数据库连接池实现:Apache DBCP(Database Connection Pool)和C3P0,这两个库的jar文件被封装在一起,便于开发者快速引入到他们的项目中。 **Apache DBCP** ...
- **PoolableConnection**:封装了JDBC的Connection,添加了池化的特性。 5. **配置参数** - **maxActive**:最大活动连接数,超过这个数会阻塞等待。 - **maxIdle**:最大空闲连接数,超过这个数会销毁连接。 ...
2. **Java数据库连接池实现**:在Java中,有多种开源的数据库连接池实现,如Apache的DBCP、C3P0、HikariCP和Tomcat JDBC Connection Pool等。这些库提供了一套接口和配置选项,使得开发者可以轻松集成到自己的应用中...
Spring整合JDBC主要涉及到Spring框架中的JdbcTemplate模块,这是一个用于简化数据库访问的API,它将JDBC相关的繁琐工作进行了封装,比如管理数据库连接、处理事务、执行SQL语句等,从而使得开发人员能够更加专注于...
总的来说,Java的ActiveRecord框架结合了数据库连接池和JDBC驱动,为Java开发者提供了一种面向对象的数据库操作方式,简化了数据库交互,提高了开发效率。在实际项目中,结合这些库的使用,可以构建出高效且易于维护...
`PoolableConnection`则负责具体的连接池化逻辑,它将数据库连接封装成池化的对象,使得连接可以被多次复用。 在使用DBCP时,你需要配置以下几个关键参数: 1. `driverClassName`: 指定数据库驱动类名,如`...
DBCP是基于Jakarta-pool对象池实现的数据库连接池组件,它在JDBC API之上提供了一层封装,使得开发者能够更方便地管理和复用数据库连接。DBCP 1.4是该组件的一个稳定版本,它包含了对多种数据库的兼容性支持,如...
- **池化对象(PoolableConnection, PooledConnection)**:C3P0通过池化数据库连接,减少了每次请求新连接时的开销,提高了性能。 在实际应用中,C3P0可以与各种Java持久层框架如Hibernate、Spring JDBC等结合使用...
例如,JDBC驱动程序(Java Database Connectivity)用于Java应用程序,而Python中的pymysql或mysql-connector-python库则用于Python应用。 2. 连接管理:管理数据库连接的类或模块,包括创建、关闭以及池化连接。...