JDBC的简单工具类

最新推荐文章于 2022-08-01 15:13:47 发布

LFuser.

最新推荐文章于 2022-08-01 15:13:47 发布

阅读量418

点赞数

分类专栏：数据库文章标签： JDBC 工具类

本文链接：https://blog.csdn.net/qq_41596568/article/details/90343239

版权

数据库专栏收录该内容

19 篇文章 1 订阅

订阅专栏

工具类简介

功能：
1.连接数据库
2.对数据库进行增删改操作
3.对数据库进行查询操作
4.开始，提交，回滚事务
5.关闭数据库连接
技术
1.dbcp连接池
2.DBUtil
jar包
mysql-connector-java-8.0.16.jar
commons-pool2-2.6.1.jar
commons-dbcp2-2.6.0.jar
commons-dbutils-1.7.jar

工具类的实现

1.DAO接口

package Tools;

import java.sql.Connection;
import java.util.List;

/**
 * @author LFuser
 * @create 2019-05-18-22:32
 * 访问数据的DAO接口
 * @param  T : DAO处理的实体的类型
 */
public interface DAO<T> {

    /**
     * INSERT , UPDATE , DELETE
     *
     * @param connection ：数据库连接
     * @param sql        ： SQL语句
     * @param args       ： 填充占位符的可变参数
     */
    void update(Connection connection, String sql, Object... args);

    /**
     * 返回一个T对象
     * @param connection ： 数据库连接
     * @param sql ： SQL语句
     * @param args :填充占位符的可变参数
     * @return 返回一个T对象
     */
    T get(Connection connection ,String sql ,Object...args);

    /**
     * 返回具体的一个值
     * @param connection ： 数据库连接
     * @param sql ：SQL语句
     * @param args ：填充占位符的可变参数
     * @return 返回具体的一个值
     */
    List<T> gets(Connection connection , String sql , Object...args);

    /**
     * 返回T的一个集合
     * @param connection
     * @param sql
     * @param args
     * @param <E>
     * @return 返回一个T的集合
     */
    <E> E getValues(Connection connection , String sql , Object...args);

    /**
     * 批量处理的方法
     * @param connection
     * @param sql
     * @param args ：填充占位符的Object[]类型的可变参数
     */
    void batch(Connection connection , String sql , Object[]...args);
}

2.DBUtils工具类

package Tools;

import org.apache.commons.dbcp2.BasicDataSourceFactory;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Properties;

/**
 * @author LFuser
 * @create 2019-05-18-21:36
 * 需要的jar包 ：
 * 1.mysql-connector-java-8.0.16.jar
 * 2.commons-pool2-2.6.1.jar
 * 3.commons-dbcp2-2.6.0.jar
 * 4.commons-dbutils-1.7.jar
 */
public class DBUtils<T> implements DAO<T> {

    private QueryRunner queryRunner = null;
    private Class<T> type;

    public DBUtils() {
        queryRunner = new QueryRunner();
        type = ReflectionUtils.getSuperGenericType(getClass());
    }

    //数据库连接池只初始化一次
    private static DataSource dataSource = null;

    /**
     * 1.加载 dbcp 的 properties 配置文件
     * 2.调用 BasicDataSourceFactory 的 createDataSource 方法 创建 DataSource实例
     */
    static {
        Properties properties = new Properties();
        InputStream inputStream =
                DBUtils.class.getClassLoader().getResourceAsStream("dbcp.properties");
        try {
            properties.load(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            dataSource = BasicDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 从 DataSource实例中获取数据库连接
     *
     * @return 返回一个数据库连接
     */
    public static Connection getConnection() {
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return connection;

    }

    /**
     * 关闭数据库资源
     *
     * @param connection
     * @param preparedStatement
     * @param resultSet
     */
    public static void releaseDB(Connection connection, PreparedStatement preparedStatement, ResultSet resultSet) {
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (preparedStatement != null) {
            try {
                preparedStatement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * INSERT , UPDATE , DELETE
     * @param connection ：数据库连接
     * @param sql        ： SQL语句
     * @param args       ： 填充占位符的可变参数
     */
    @Override
    public void update(Connection connection, String sql, Object... args) {

        try {
            queryRunner.update(connection, sql, args);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            releaseDB(connection,null,null);
        }
    }

    /**
     *
     * @param connection ： 数据库连接
     * @param sql ： SQL语句
     * @param args :填充占位符的可变参数
     * @return 返回具体的一个值
     * BeanHandler ： 把结果集的第一条记录转化为创建BeanHandler对象时传入的Class参数对应的对象
     */
    @Override
    public T get(Connection connection, String sql, Object... args) {
        T t = null;
        try {
            t = queryRunner.query(connection,sql,new BeanHandler<>(type),args);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            releaseDB(connection,null,null);
        }
        return t;
    }

    /**
     *
     * @param connection ： 数据库连接
     * @param sql ：SQL语句
     * @param args ：填充占位符的可变参数
     * @return 返回一个T的集合
     * BeanListHandler ： 把结果集转化为一个List，该List不为null;但可能为空集合（sise（）方法返回0）
     */
    @Override
    public List<T> gets(Connection connection, String sql, Object... args) {
        List<T> t = null;

        try {
            t = queryRunner.query(connection,sql,new BeanListHandler<>(type),args);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            releaseDB(connection,null,null);
        }
        return t;

    }

    /**
     *
     * @param connection
     * @param sql
     * @param args
     * @param <E>
     * @return
     * ScalarHandler ： 把结果集转化为一个数值返回
     */
    @Override
    public <E> E getValues(Connection connection, String sql, Object... args) {
        Object e = null;
        try {
            e = queryRunner.query(connection,sql,new ScalarHandler<>(),args);
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        return (E)e;
    }

    @Override
    public void batch(Connection connection, String sql, Object[]... args) {

    }

    /**
     * 提交事务
     * @param connection
     */
    public static void commit(Connection connection){
        if(connection != null){
            try {
                connection.commit();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 回滚事务
     * @param connection
     */
    public static void rollback(Connection connection){
        if(connection != null){
            try {
                connection.rollback();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 开始事务
     * @param connection
     */
    public static  void beginTx(Connection connection){
        if(connection != null){
            try {
                connection.setAutoCommit(false);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

3.dbcp数据库配置文件：dbcp.properties

//基本的驱动加载
driverClassName=com.mysql.cj.jdbc.Driver

//驱动注册
url=jdbc:mysql://localhost:3306/数据库名?characterEncoding=UTF8&serverTimezone=UTC

//用户名
username=root

//密码
password=123456

//设置是否自动提交,默认为true
defaultAutoCommit=true

//设置数据库的事务隔离级别默认为1，READ_UNCOMMITTED，推荐设置为3
defaultTransactionIsolation=1

//初始化数据池拥有的连接数量
initialSize=10

//池中最多可容纳的活着的连接数量，当达到这个数量不在创建连接
maxActive=20

//最大空闲等待，也就是连接等待队列超过这个值会自动回收未使用的连接，直到达到20
maxIdle=15

//最小空闲等待,数据池中最少保持的连接
minIdle=5

//最大等待时间，超过这个时间等待队列中的连接就会失效
maxWait=10000

4.ReflectionUtils :查询时用到的反射工具类

package Tools;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 * 反射的 Utils 函数集合
 * 提供访问私有变量, 获取泛型类型 Class, 提取集合中元素属性等 Utils 函数
 * @author Administrator
 *
 */
public class ReflectionUtils {


	/**
	 * 将反射时的 "检查异常" 转换为 "运行时异常"
	 * @return
	 */
	public static IllegalArgumentException convertToUncheckedException(Exception ex){
		if(ex instanceof IllegalAccessException || ex instanceof IllegalArgumentException
				|| ex instanceof NoSuchMethodException){
			throw new IllegalArgumentException("反射异常", ex);
		}else{
			throw new IllegalArgumentException(ex);
		}
	}


	/**
	 * 通过反射, 获得定义 Class 时声明的父类的泛型参数的类型
	 * 如: public EmployeeDao extends BaseDao<Employee, String>
	 * @param clazz
	 * @param index
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static Class getSuperClassGenricType(Class clazz, int index){
		Type genType = clazz.getGenericSuperclass();

		if(!(genType instanceof ParameterizedType)){
			return Object.class;
		}

		Type [] params = ((ParameterizedType)genType).getActualTypeArguments();

		if(index >= params.length || index < 0){
			return Object.class;
		}

		if(!(params[index] instanceof Class)){
			return Object.class;
		}

		return (Class) params[index];
	}

	/**
	 * 通过反射, 获得 Class 定义中声明的父类的泛型参数类型
	 * 如: public EmployeeDao extends BaseDao<Employee, String>
	 * @param <T>
	 * @param clazz
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static<T> Class<T> getSuperGenericType(Class clazz){
		return getSuperClassGenricType(clazz, 0);
	}

	/**
	 * 循环向上转型, 获取对象的 DeclaredMethod
	 * @param object
	 * @param methodName
	 * @param parameterTypes
	 * @return
	 */
	public static Method getDeclaredMethod(Object object, String methodName, Class<?>[] parameterTypes){

		for(Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){
			try {
				//superClass.getMethod(methodName, parameterTypes);
				return superClass.getDeclaredMethod(methodName, parameterTypes);
			} catch (NoSuchMethodException e) {
				//Method 不在当前类定义, 继续向上转型
			}
			//..
		}

		return null;
	}

	/**
	 * 使 filed 变为可访问
	 * @param field
	 */
	public static void makeAccessible(Field field){
		if(!Modifier.isPublic(field.getModifiers())){
			field.setAccessible(true);
		}
	}

	/**
	 * 循环向上转型, 获取对象的 DeclaredField
	 * @param object
	 * @param filedName
	 * @return
	 */
	public static Field getDeclaredField(Object object, String filedName){

		for(Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){
			try {
				return superClass.getDeclaredField(filedName);
			} catch (NoSuchFieldException e) {
				//Field 不在当前类定义, 继续向上转型
			}
		}
		return null;
	}

	/**
	 * 直接调用对象方法, 而忽略修饰符(private, protected)
	 * @param object
	 * @param methodName
	 * @param parameterTypes
	 * @param parameters
	 * @return
	 * @throws InvocationTargetException
	 * @throws IllegalArgumentException
	 */
	public static Object invokeMethod(Object object, String methodName, Class<?> [] parameterTypes,
									  Object [] parameters) throws InvocationTargetException{

		Method method = getDeclaredMethod(object, methodName, parameterTypes);

		if(method == null){
			throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + object + "]");
		}

		method.setAccessible(true);

		try {
			return method.invoke(object, parameters);
		} catch(IllegalAccessException e) {}

		return null;
	}

	/**
	 * 直接设置对象属性值, 忽略 private/protected 修饰符, 也不经过 setter
	 * @param object
	 * @param fieldName
	 * @param value
	 */
	public static void setFieldValue(Object object, String fieldName, Object value){
		Field field = getDeclaredField(object, fieldName);

		if (field == null)
			throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");

		makeAccessible(field);

		try {
			field.set(object, value);
		} catch (IllegalAccessException e) {}
	}

	/**
	 * 直接读取对象的属性值, 忽略 private/protected 修饰符, 也不经过 getter
	 * @param object
	 * @param fieldName
	 * @return
	 */
	public static Object getFieldValue(Object object, String fieldName){
		Field field = getDeclaredField(object, fieldName);

		if (field == null)
			throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");

		makeAccessible(field);

		Object result = null;

		try {
			result = field.get(object);
		} catch (IllegalAccessException e) {}

		return result;
	}
}