JDBC的简单工具类

小灰灰 2022-01-30 12:11 267阅读 0赞

## ***工具类简介*** ##

1.  **功能**：  
    1.连接数据库  
    2.对数据库进行增删改操作  
    3.对数据库进行查询操作  
    4.开始，提交，回滚事务  
    5.关闭数据库连接
2.  **技术**  
    1.dbcp连接池  
    2.DBUtil
3.  **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;
    	}
    }