使用反射封装DBUtils类中的通用操作类

包括增删改查、统计数据。
使用到了Druid数据库连接池技术、ConverUtils工具类进行类型转换。
需要在pom.xml里导入依赖

1. MySQL驱动依赖

	<dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>

2. commons-beanutils依赖包

 <!-- commons-beanutils -->
    <dependency>
      <groupId>commons-beanutils</groupId>
      <artifactId>commons-beanutils</artifactId>
      <version>1.9.4</version>
    </dependency>

3. 阿里巴巴druid数据库连接池依赖包

 <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.23</version>
    </dependency>

代码：

package com.study.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.apache.commons.beanutils.ConvertUtils;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public abstract class DBUtils {
    protected Connection conn=null;
    protected PreparedStatement psmt=null;
    protected ResultSet rs=null;
    //创建DataSource数据源对象，基于Druid的数据源
    private static DataSource dataSource;

    /**
     * 静态代码块，当类被加载时就被执行，而且只执行一次
     */
    static {
        try {
            //读取do.properties文件的数据
            InputStream rs = DBUtils.class.getClassLoader().getResourceAsStream("db.properties");
            //创建Properties对象，对应一个Properties文件
            Properties properties=new Properties();
            //将输入流的数据放在Properties对象中
            properties.load(rs);
            //创建Druid的dataSource对象
            dataSource= DruidDataSourceFactory.createDataSource(properties);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 使用Druid数据库连接池技术连接数据库
     * @return
     * @throws SQLException
     */
    protected Connection getConn() throws SQLException {
        //从连接池中获取一个连接对象
        conn=dataSource.getConnection();
        return conn;
    }

    /**
     * 数据库释放资源的方法
     */
    protected void close(){
        try {
            if(rs!=null){
                rs.close();
            }
            if(psmt!=null){
                psmt.close();
            }
            if(conn!=null){
                conn.close();
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            conn=null;
            psmt=null;
            rs=null;
        }
    }

    /**
     * 通用增删改操作
     * @param sql 带有？占位符的语句
     * @param params SQL语句中占位符的值
     * @return int整型  SQL语句执行后的影响行数
     */
    protected int executeUpdate(String sql,Object... params){
        try {
            //获取连接
            this.getConn();
            //获得预处理对象
            psmt=conn.prepareStatement(sql);
            //判断sql语句中是否存在？占位符。如果存在进行赋值
            if(params!=null&&params.length!=0){
                for (int i = 0; i < params.length; i++) {
                    //通过psmt.setObject()方法为不同类型的？占位符赋值
                    psmt.setObject(i+1,params[i]);
                }
            }
            return psmt.executeUpdate();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            this.close();
        }
        return 0;
    }

    /**
     * 执行count函数的SQL语句
     * @param sql
     * @param params
     * @return
     */
    public int executeCount(String sql,Object... params)  {
        try {
            //1.连接数据库
            this.getConn();
            //2.创建预处理对象
            psmt = conn.prepareStatement(sql);
            //3.根据SQL语句中？号占位符设置占位符的值
            //判断SQL语句是否存在？号占位符(根据params参数判断)
            if(params!=null && params.length!=0){
                //设置？号占位符的值,使用循环设置
                for(int i=0;i<params.length;i++){
                    psmt.setObject(i+1,params[i]);
                }
            }
            rs = psmt.executeQuery();
            if(rs.next()){
                return rs.getInt(1);
            }
            return 0;
        } catch (Exception e) {
            e.printStackTrace();
            //throw new SysException("系统升级中，请稍后访问...");
        } finally {
            this.close();
        }
        return -1;
    }


    /**
     * 通用查询，查询全部
     * @param sql
     * @param cla SQL语句中查询的表锁对应的实体Bean的类的Class对象
     * @param params
     * @param <T>
     * @return list集合
     */
    protected <T> List executeQueryList(String sql, Class<T> cla, Object... params){
        try {
            //获取连接
            this.getConn();
            //获得预处理对象
            psmt=conn.prepareStatement(sql);
            //判断sql语句中是否存在？占位符。如果存在进行赋值
            if(params!=null&&params.length!=0){
                for (int i = 0; i < params.length; i++) {
                    //通过psmt.setObject()方法为不同类型的？占位符赋值
                    psmt.setObject(i+1,params[i]);
                }
            }
            //执行查询sql语句，返回结果集
            rs=psmt.executeQuery();
            //从结果集中获得结果集的元数据(表结构)
            ResultSetMetaData metaData = rs.getMetaData();
            //获得元数据中记录的总列数
            int columnName = metaData.getColumnCount();
            //创建存储结果的List集合
            List<T> list=new ArrayList<>();
            while (rs.next()){
                //创建对象
                T t = cla.newInstance();
                //循环列数
                for (int i = 0; i < columnName; i++) {
                    //构建与对象中属性相对应的set方法
                    //获得与set方法所对应的属性名，进一步获得set方法
                    String fieldName = metaData.getColumnName(i + 1);
                    //根据属性名拼接方法名
                    String methodName="set"+fieldName.substring(0,1).toUpperCase()+fieldName.substring(1);
                    //根据指定的属性名获得属性对象
                    Field field = cla.getDeclaredField(fieldName);
                    //根据方法名和参数列表(属性的类型)获得set方法对象
                    Method setMethod = cla.getDeclaredMethod(methodName, field.getType());
                    //根据列表号获得该列咱数据库中对应的数据
                    Object value = rs.getObject(i + 1);
                    //调用set方法为对象赋值,相当于user.setObject(1,rs.getObject())
                    //使用ConvertUtils对value数据进行类型转换，转换为java中属性所对应的类型
                    setMethod.invoke(t, ConvertUtils.convert(value,field.getType()));
                }
                //将对象t添加到list集合中
                list.add(t);

            }
            return list;
        } catch (Exception throwables) {
            throwables.printStackTrace();
        }finally {
            this.close();
        }
        return null;
        }


    /**
     * 查询一个
     * @param sql
     * @param cla
     * @param params
     * @param <T>
     * @return
     */
    protected <T> T executeQueryOne(String sql, Class<T> cla, Object... params){
            try {
                //获取连接
                this.getConn();
                //获得预处理对象
                psmt=conn.prepareStatement(sql);
                //判断sql语句中是否存在？占位符。如果存在进行赋值
                if(params!=null&&params.length!=0){
                    for (int i = 0; i < params.length; i++) {
                        //通过psmt.setObject()方法为不同类型的？占位符赋值
                        psmt.setObject(i+1,params[i]);
                    }
                }
                //执行查询sql语句，返回结果集
                rs=psmt.executeQuery();
                //从结果集中获得结果集的元数据(表结构)
                ResultSetMetaData metaData = rs.getMetaData();
                //获得元数据中记录的总列数
                int columnName = metaData.getColumnCount();
                //创建对象
                T t = cla.newInstance();
                if (rs.next()){

                    //循环列数
                    for (int i = 0; i < columnName; i++) {
                        //构建与对象中属性相对应的set方法
                        //获得与set方法所对应的属性名，进一步获得set方法
                        String fieldName = metaData.getColumnName(i + 1);
                        //根据属性名拼接方法名
                        String methodName="set"+fieldName.substring(0,1).toUpperCase()+fieldName.substring(1);
                        //根据指定的属性名获得属性对象
                        Field field = cla.getDeclaredField(fieldName);
                        //根据方法名和参数列表(属性的类型)获得set方法对象
                        Method setMethod = cla.getDeclaredMethod(methodName, field.getType());
                        //根据列表号获得该列咱数据库中对应的数据
                        Object value = rs.getObject(i + 1);
                        //调用set方法为对象赋值,相当于user.setObject(1,rs.getObject())
                        //使用ConvertUtils对value数据进行类型转换，转换为java中属性所对应的类型
                        setMethod.invoke(t, ConvertUtils.convert(value,field.getType()));
                    }
                }
                return t;
            } catch (Exception throwables) {
                throwables.printStackTrace();
            }finally {
                this.close();
            }
            return null;

        }

        protected Object executeQueryNumber(String sql,Object... params){
            try {
                //获取连接
                this.getConn();
                //获得预处理对象
                psmt=conn.prepareStatement(sql);
                //判断sql语句中是否存在？占位符。如果存在进行赋值
                if(params!=null&&params.length!=0){
                    for (int i = 0; i < params.length; i++) {
                        //通过psmt.setObject()方法为不同类型的？占位符赋值
                        psmt.setObject(i+1,params[i]);
                    }
                }
                //执行查询SQL语句，返回结果集
                rs=psmt.executeQuery();
                if(rs.next()){
                    return rs.getObject(1);
                }
        } catch (Exception throwables) {
                throwables.printStackTrace();
            }finally {
                this.close();
            }
            return 0;
            }

        }