# DBUtils
**Repository Path**: changshaligongdaxue/DBUtils
## Basic Information
- **Project Name**: DBUtils
- **Description**: Apache DBUtils是个小巧的JDBC轻量级封装的工具包，其最核心的特性是结果集的封装，可以直接将查询出来的结果集封装成JavaBean，这就为我们做了最枯燥乏味、最容易出错的一大部分工作
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No
## Statistics
- **Stars**: 0
- **Forks**: 1
- **Created**: 2017-01-17
- **Last Updated**: 2023-12-23
## Categories & Tags
**Categories**: Uncategorized
**Tags**: None
## README
##Apache DBUtils封装使用
Apache DBUtils是个小巧的JDBC轻量级封装的工具包，其最核心的特性是结果集的封装，可以直接将查询出来的结果集封装成JavaBean，这就为我们做了最枯燥乏味、最容易出错的一大部分工作。
大部分开发人员在生成环境中更多的是依靠Hibernate、Ibatis、Spring JDBC、JPA等大厂提供的持久层技术解决方案，或者是企业内部自己研发的持久层技术。但无论如何，使用这些
技术的初衷和本质都是为了能够减少企业开发成本，提高生产效率，降低耦合。
放眼企业级项目，Hibernate等ORM产品是首选，而互联网领域，大部分开发人员往往并不会在生产环境中上这些ORM技术，原因很简单，要的就是效率，其次都不重要。对于刚接触SQL和JDBC的开发人员，最引以为傲的就是希望能够在日后编写复杂的SQL语句，以及会使用诸如Hibernate、Ibatis等第三方持久层技术，并且极力的撇清与传统JDBC技术的关系，但笔者不得不认为,这是一种普遍业界存在的“病态”！
如果是企业级的项目，尤其是跟金融相关的业务，SQL语句或许会非常复杂，并且关联着事物。但互联网项目却并非如此，在互联网项目中，看你牛不牛逼并不是取决于你能否写出一条复杂的SQL语句，而是看你能否将原本一条复杂的SQL语句拆散成单条SQL，一句一句的执行；并且脱离Hibernate等ORM产品后，能否使用传统的JDBC技术完成一条简单的CRUD操作，这才是牛逼！是的，你没有听错，互联网确确实实就是这么玩，还原最本质的东西，才是追求性能的不二选择
####在使用DBUtils之前首先需要获取Connection或者DataBase连接
package com.silence.utils;
import java.beans.PropertyVetoException;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class ConnectionFactory {
private static String driver;
private static String dburl;
private static String user;
private static String password;
public static ComboPooledDataSource dataSource;
private static final ConnectionFactory factory = new ConnectionFactory();
private Connection conn = null;
// 初始化数据库连接池
static {
Properties prop = new Properties();
try {
InputStream inputStream = ConnectionFactory.class.
getClassLoader().getResourceAsStream("db.properties");
prop.load(inputStream);
driver = prop.getProperty("driver");
dburl = prop.getProperty("dburl");
user = prop.getProperty("user");
password = prop.getProperty("password");
dataSource = new ComboPooledDataSource();
dataSource.setUser(user);
dataSource.setPassword(password);
dataSource.setJdbcUrl(dburl);
dataSource.setDriverClass(driver);
dataSource.setInitialPoolSize(10);
dataSource.setMinPoolSize(5);
dataSource.setMaxPoolSize(50);
dataSource.setMaxStatements(100);
dataSource.setMaxIdleTime(60);
} catch (IOException e) {
System.out.println("the file of datasouce configuration is not exist!");
e.printStackTrace();
} catch (PropertyVetoException e) {
System.out.println("datasouce config error!");
e.printStackTrace();
}
System.out.println("datasouce init finish........!");
}
private ConnectionFactory() {
}
public static ConnectionFactory getInstance() {
return factory;
}
public static ComboPooledDataSource getDataSouce(){
return dataSource;
}
//获取连接
public Connection getConnection() {
if (null != dataSource) {
try {
conn = dataSource.getConnection();
} catch (SQLException e) {
e.printStackTrace();
}
}
return conn;
}
}
该文件从db.properties中读取数据库的配置文件并使用C3P0创建数据库连接池，该配置文件如下：
driver=com.mysql.jdbc.Driver
dburl=jdbc:mysql://localhost:3306/jdbc
user=root
password=root
然后我们就可以使用DBUtils来操作数据库了，下面是使用DBUtils再次封装的工具代码，使用该代码可以使你更快的操纵数据库。
import java.sql.Connection;
import java.util.List;
import java.util.Map;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayHandler;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
public class DataBaseUtils {
public static QueryRunner getQueryRunner() {
return new QueryRunner(ConnectionFactory.getDataSouce());
}
/**
* 批量操作，包括批量保存、修改、删除
*
* @param sql
* @param params
* @return
*/
public static int[] batch(Connection connection, String sql, Object[][] params) {
try {
return new QueryRunner().batch(connection, sql, params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
/**
* 批量操作，包括批量保存、修改、删除
*
* @param sql
* @param params
* @return
*/
public static int[] batch(String sql, Object[][] params) {
try {
return getQueryRunner().batch(sql, params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
/**
* 删除操作
*
* @param sql
* @param params
* @return
*/
public static int delete(String sql, Object... params) {
try {
return getQueryRunner().update(sql, params);
} catch (Exception ex) {
ex.printStackTrace();
}
return 0;
}
/**
* 删除操作
*
* @param sql
* @param params
* @return
*/
public static int delete(Connection connection, String sql, Object... params) {
try {
return new QueryRunner().update(connection, sql, params);
} catch (Exception ex) {
ex.printStackTrace();
}
return 0;
}
/**
* 更新操作
*
* @param sql
* @param params
* @return
*/
public static int update(Connection connection, String sql, Object... params) {
try {
new QueryRunner().update(connection, sql, params);
} catch (Exception ex) {
ex.printStackTrace();
}
return 0;
}
/**
* 更新操作
*
* @param sql
* @param params
* @return
*/
public static int update(String sql, Object... params) {
try {
return getQueryRunner().update(sql, params);
} catch (Exception ex) {
ex.printStackTrace();
}
return 0;
}
/**
* 保存操作
*
* @param sql
* @param params
* @return
*/
public static int save(Connection connection, String sql, Object... params) {
try {
return new QueryRunner().update(connection, sql, params);
} catch (Exception ex) {
ex.printStackTrace();
}
return 0;
}
/**
* 保存操作
*
* @param sql
* @param params
* @return
*/
public static int save(String sql, Object... params) {
try {
return getQueryRunner().update(sql, params);
} catch (Exception ex) {
ex.printStackTrace();
}
return 0;
}
/**
* 根据sql查询list对象
*
* @param
*
* @param sql
* @param type
* @param params
* @return
*/
public static List getListBean(Connection connection, String sql, Class type, Object... params) {
try {
return new QueryRunner().query(connection, sql, new BeanListHandler(type), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
/**
* 根据sql查询list对象
*
* @param
*
* @param sql
* @param type
* @param params
* @return
*/
public static List getListBean(String sql, Class type, Object... params) {
try {
return getQueryRunner().query(sql, new BeanListHandler(type), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
/**
* 根据sql查询list对象
*
* @param
*
* @param sql
* @param type
* @return
*/
public static List getListBean(Connection connection, String sql, Class type) {
try {
return new QueryRunner().query(connection, sql, new BeanListHandler(type));
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
/**
* 根据sql查询list对象
*
* @param
*
* @param sql
* @param type
* @return
*/
public static List getListBean(String sql, Class type) {
try {
// BeanListHandler 将ResultSet转换为List的ResultSetHandler实现类
return getQueryRunner().query(sql, new BeanListHandler(type));
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
/**
* 根据sql和对象，查询结果并以对象形式返回
*
* @param
*
* @param sql
* @param type
* @param params
* @return
*/
public static T getBean(Connection connection, String sql, Class type, Object... params) {
try {
return new QueryRunner().query(connection, sql, new BeanHandler(type), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
/**
* 根据sql和对象，查询结果并以对象形式返回
*
* @param
*
* @param sql
* @param type
* @param params
* @return
*/
public static T getBean(String sql, Class type, Object... params) {
try {
return getQueryRunner().query(sql, new BeanHandler(type), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
/**
* 根据sql和对象，查询结果并以对象形式返回
*
* @param
*
* @param sql
* @param type
* @return
*/
public static T getBean(Connection connection, String sql, Class type) {
try {
return new QueryRunner().query(connection, sql, new BeanHandler(type));
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
/**
* 根据sql和对象，查询结果并以对象形式返回
*
* @param
*
* @param sql
* @param type
* @return
*/
public static T getBean(String sql, Class type) {
try {
// BeanHandler 将ResultSet行转换为一个JavaBean的ResultSetHandler实现类
return getQueryRunner().query(sql, new BeanHandler(type));
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
/**
* 根据传入的sql查询所有记录，以List Map形式返回
*
* @param sql
* @param params
* @return
*/
public static List> getListMap(Connection connection, String sql, Object... params) {
try {
return new QueryRunner().query(connection, sql, new MapListHandler(), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
/**
* 根据传入的sql查询所有记录，以List Map形式返回
*
* @param sql
* @param params
* @return
*/
public static List> getListMap(String sql, Object... params) {
try {
return getQueryRunner().query(sql, new MapListHandler(), params);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
/**
* 根据传入的sql查询所有记录，以List Map形式返回
*
* @param sql
* @return
*/
public static List> getListMap(Connection connection, String sql) {
try {
return new QueryRunner().query(connection, sql, new MapListHandler());
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
/**
* 根据传入的sql查询所有记录，以List Map形式返回
*
* @param sql
* @return
*/
public static List> getListMap(String sql) {
try {
// MapListHandler 将ResultSet转换为List