JDBC工具类DBUtils封装jar包
通过对JDBC操作数据库的学习，我们会发现，由于JDBC操作数据库的步骤基本没有大的变化，针对所有的数据访问操作，都会存在大量重复代码，因此，对操作数据库的步骤封装就显得十分有必要了，如下：
JDBC操作数据库时，每执行一次操作都要重新执行JDBC的获取连接对象、获取处理命令的对象、执行sql操作、处理结果、关闭资源的几个步骤的话，大大加重的程序员的代码压力，由于这些步骤基本没有太大变化，那么就可以对获取连接、关闭资源、通用增删改操作、通用查询操作、通用的查询集合操作、通用查询对象操作进行封装，将这些封装为DBUtils工具类，可极大简化数据库操作
相关依赖jar包
mysql-conntor-java-5.1.46.jar：JDBC java连接mysql工具包
druid-1.1.9.jar：Druid连接池jar包
准备属性文件
为了不用修改java源代码，可以将连接数据库的常见字符串直接配置到properties文件中：
jdbc.properties
#mysql connectin config
driverClass=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/mydb
user=root
password=000000
###Connection Pool Config
maxActive=10
minIdle=1
maxWait=10000
#mssqlserver connection config
#driver=com.miscrosoft.jdbc.sqlserver.SQLServerDriver
#url=jdbc:sqlserver://127.0.0.1:1433;databaseName=test
#user=sa
#password=123456
#oracle connection config
#driverClass=oracle.jdbc.OracleDriver
#url=jdbc:oracle:thin:@127.0.0.1:1521:orcl
#user=scott
#password=tigerDBUtils封装
package com.softeem.jdbc.utils;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Properties;
import java.util.Set;
import com.alibaba.druid.pool.DruidDataSource;
/**
* 封装的数据库工具类，包含一些操作数据库的简便方法
* 1.获取连接
* 2.关闭资源
* 3.通用增删改操作
* 4.封装通用查询操作
* 5.封装通用的查询集合操作，对于任何形式的查询，都能返回一个对象集合
* 6.封装通用查询对象操作，对于任何形式的查询，都能返回一个确定的对象
* @author max
*
*/
public class DBUtils {
private static String driverClass;
private static String url;
private static String user;
private static String password;
/** 最大活动连接数 */
private static int maxActive;
/** 最小闲置连接 */
private static int minIdle;
/** 等待连接的最长时间 */
private static long maxWait;
/** druid数据源对象 */
private static DruidDataSource dataSource;
static {
init();
}
public static void init() {
try {
Properties prop = new Properties();
// 加载属性文件
prop.load(new FileInputStream("src/jdbc.properties"));
// 获取属性信息（连接数据库的相关字符串）
driverClass = prop.getProperty("driverClass");
url = prop.getProperty("url");
user = prop.getProperty("user");
password = prop.getProperty("password");
maxActive = Integer.parseInt(prop.getProperty("maxActive"));
minIdle = Integer.parseInt(prop.getProperty("minIdle"));
maxWait = Long.parseLong(prop.getProperty("maxWait"));
// 创建数据源并配置
dataSource = new DruidDataSource();
dataSource.setDriverClassName(driverClass);
dataSource.setUrl(url);
dataSource.setUsername(user);
dataSource.setPassword(password);
dataSource.setMaxActive(maxActive);
dataSource.setMinIdle(minIdle);
dataSource.setMaxWait(maxWait);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 1.获取连接
*
* @return
*/
public static synchronized Connection getConn() {
if (dataSource == null || dataSource.isClosed()) {
init();
}
try {
return dataSource.getConnection();
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
/**
* 关闭连接池
*/
public static void closePool() {
if (dataSource != null) {
dataSource.close();
}
}
/**
* 2.关闭资源
*
* @param rs
* @param stat
* @param conn
*/
public static void close(ResultSet rs, Statement stat, Connection conn) {
try {
if (rs != null) {
rs.close();
}
if (stat != null) {
stat.close();
}
if (conn != null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 3.封装通用的增、删、改操作（针对任何数据库表的更新操作（DML语句）都能通过该方法实现）
*
* @param sql
* @return
*/
public static int exeUpdate( Connection conn,String sql,Object... params) {
PreparedStatement ps = null;
try {
// 编译sql语句获取预处理对象
ps = conn.prepareStatement(sql);
if (Objects.nonNull(params)) {
for (int i = 0; i < params.length; i++) {
ps.setObject(i + 1, params[i]);
}
}
// 执行更新
int i = ps.executeUpdate();
return i;
} catch (SQLException e) {
e.printStackTrace();
} finally {
close(null, ps, null);
}
return 0;
}
/**
* 4.封装通用查询操作
*
* @param sql
* @param params
*/
public static <T> List<T> query(String sql, CallBack callback, Object... params) {
List list = null;
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
conn = getConn();
ps = conn.prepareStatement(sql);
if (Objects.nonNull(params)) {
for (int i = 0; i < params.length; i++) {
ps.setObject(i + 1, params[i]);
}
}
// 执行查询操作
rs = ps.executeQuery();
list = callback.call(rs);
} catch (SQLException e) {
e.printStackTrace();
} finally {
close(rs, ps, conn);
}
return list;
}
/**
* 内部接口，里面包含一个函数（回调函数）
* @author max
*/
@FunctionalInterface
public interface CallBack {
List call(ResultSet rs) throws SQLException;
}
/**
* 5.封装通用的查询集合操作，对于任何形式的查询，都能返回一个对象集合
* @param t 需要返回的数据类型（泛型）
* @param sql 目标查询语句
* @param params 执行查询所需的参数
* @return 返回包含指定对象的集合
*/
public static <T> List<T> queryList(Class<T> t,String sql,Object... params){
//声明空集合
List<T> data = new ArrayList<>();
//获取查询结果信息
List<Map<String,Object>> list = getDataPair(sql,params);
if(list.isEmpty()) {
return data;
}
//遍历集合
for(Map<String,Object> map : list) {
T obj = parseMapToBean(map,t);
data.add(obj);
}
return data;
}
/**
* 6.封装通用查询对象操作，对于任何形式的查询，都能返回一个确定的对象
* @param t 需要返回的数据类型
* @param sql 目标查询语句
* @param params 执行查询所需的参数
* @return 返回指定对象
*/
public static <T> T queryOne(Class<T> t,String sql,Object... params){
List<Map<String,Object>> list = getDataPair(sql,params);
if(!list.isEmpty()) {
Map<String,Object> map = list.get(0);
T obj = parseMapToBean(map,t);
return obj;
}
return null;
}
/**
* 将一个Map集合对象转换为一个JavaBean并返回
* @param map
* @param t
* @return
*/
private static <T>T parseMapToBean(Map<String, Object> map, Class<T> t) {
T obj = null;
try {
//创建一个空实例
obj = t.newInstance();
//获取map集合的键集（所有列名称，即要返回对象的属性名）
Set<String> keys = map.keySet();
for(String cname : keys) {
//获取属性对象
Field f = t.getDeclaredField(cname);
//获取set方法的名称
String setMethodName = "set"+cname.substring(0,1).toUpperCase()+cname.substring(1);
//获取set方法对象
Method method = t.getMethod(setMethodName, f.getType());
//执行方法
method.invoke(obj, map.get(cname));
}
} catch (InstantiationException | IllegalAccessException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return obj;
}
/**
* 解析指定查询语句，并将获取的数据（列名，列值以集合的形式返回）
* @param sql
* @param params
* @return
*/
private static List<Map<String,Object>> getDataPair(String sql,Object... params){
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
//声明集合存储获取的表数据（列名，列值）
List<Map<String,Object>> list = new ArrayList<>();
try {
conn = getConn();
ps =conn.prepareStatement(sql);
if(Objects.nonNull(params)) {
for(int i = 0;i < params.length;i++) {
ps.setObject(i + 1, params[i]);
}
}
rs = ps.executeQuery();
//获取结果集元数据
ResultSetMetaData rsmd = rs.getMetaData();
//获取列总数，获取列名称，获取标签名，获取列值，将相关数据存储到map集合
//获取查询的总列数
int count = rsmd.getColumnCount();
while(rs.next()) {
//对结果集每遍历一次，获取一条数据（即一个map对象）
Map<String,Object> map = new HashMap<>();
//遍历每一列
for(int i =1;i <= count;i++) {
//获取列名称
String columnName = rsmd.getColumnName(i);
//获取标签名（列别名）
// String columnLabel = rsmd.getColumnLabel(i);
//获取列值
Object value = rs.getObject(i);
//当列值不为null时才将数据存入map集合
if(Objects.nonNull(value)) {
//将数据存入map
map.put(columnName, value);
}
}
//将map集合存入List
list.add(map);
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
DBUtils.close(rs, ps, conn);
}
return list;
}
}
以上就是此工具类的所有代码
资源已上传，需要的同学们可以自行下载
扫一扫
629
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
