Jav数据库访问工具DBUtil和BasDao (泛型)

package com.bdqn.utils;
/**
 * 数据库工具类
 * @author JY
 *
 */

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Optional;
import java.util.Properties;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;


public class DBUtil {
    //定义静态变量
    private static Properties properties;
    
    //准备静态块，价值数据到配置对象中
    static {
        //使用消费型接口，接受配置文件的名称，消费型接口：有参数，无返回值
        Consumer<String> c=(fileName) ->{
            //使用供给型接口，加载文件到输入流中；供给型接口；无参数，有返回值
            Supplier<InputStream> s=() ->DBUtil.class.getClassLoader().getResourceAsStream(fileName);
            //得到properties配置对象
            properties = new Properties();
            try {
            //将输入流通过properties配置对象的load()方法
                properties.load(s.get());
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        };
        c.accept("db.properties");
    }
    /**
     * 得到数据库连接
     * @return
     */
    public static Connection getConnection() {
        Function<Properties, Connection> f = (properties) ->{
            String driverName=properties.getProperty("driverName");
            String url=properties.getProperty("url");
            String username=properties.getProperty("username");
            String password=properties.getProperty("password");
            
            try {
                Class.forName(driverName);
                return DriverManager.getConnection(url,username,password);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
            return null;
        };
        //返回函数类型接口中的返回值
        return f.apply(properties);
    }
    /**
     * 关闭资源
     * Optional:处理空指针异常
     * 当数据可能为空，但之后一定会使用该数据的方法或属性时
     * @param resultSet
     * @param preparedStatement
     * @param connection
     */
    public static void close(ResultSet resultSet,PreparedStatement preparedStatement,Connection connection) {
        Optional.ofNullable(resultSet).ifPresent((r)->{
            try {
                r.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        });
        Optional.ofNullable(preparedStatement).ifPresent((p)->{
            try {
                p.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        });
        Optional.ofNullable(connection).ifPresent((c)->{
            try {
                c.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        });
    }
    
}

BaseDao

package com.bdqn.dao;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;

import com.bdqn.utils.DBUtil;

/**
 * 数据库工具类
 * 
 * @author JY
 *
 */
public class BaseDao {
    /**
     * 更新操作
     * @param sql
     * @param params
     * @return
     */
    public static int executeUpdate(String sql,List<Object> params) {
        int row=0;
        //在括号里声明要关闭的资源；定义在try里面的变量会被final关键字修饰，不能重复赋值
        try(Connection connection=DBUtil.getConnection();
                PreparedStatement preparedStatement = getPreparedStatement(sql,params,connection);
                ){
            //执行更新，返回受影响行数
            row =preparedStatement.executeUpdate();
        }catch (Exception e) {
            e.printStackTrace();
        }
        
        return row;
    
    }
    /**
     * 查询某一个字段（常用查询总数count）
     * @param sql
     * @param params
     * @return
     */
    public static Object findSingleValue(String sql,List<Object> params) {
        Object object=null;
        try(Connection connection=DBUtil.getConnection();
                PreparedStatement preparedStatement = getPreparedStatement(sql,params,connection);
                ResultSet resultSet=preparedStatement.executeQuery();
                ){
            //执行更新，返回受影响行数
            if (resultSet.next()) {
                object=resultSet.getObject(1);
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
        return object;
    }
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static List queryRows(String sql,List<Object> params,Class cls) {
        List list=new ArrayList();
        Connection connection=null;
        PreparedStatement preparedStatement=null;
        ResultSet resultSet=null;
        try {
            connection =DBUtil.getConnection();
            preparedStatement = connection.prepareStatement(sql);
            if (params != null && params.size() >0) {
                for (int i = 0; i < params.size(); i++) {
                    preparedStatement.setObject(i+1, params.get(i));
                }
            }
            resultSet = preparedStatement.executeQuery();
            ResultSetMetaData metaData=resultSet.getMetaData();
            int fiedNum= metaData.getColumnCount();
            while (resultSet.next()) {
                Object object=cls.getDeclaredConstructor().newInstance();
                for (int i = 1; i <= fiedNum; i++) {
                    String columnName=metaData.getColumnLabel(i);
                    Field field=cls.getDeclaredField(columnName);
                    String methodName="set"+columnName.substring(0,1).toUpperCase()+columnName.substring(1);
                    Method method=cls.getDeclaredMethod(methodName, field.getType());
                    method.invoke(object, resultSet.getObject(columnName));
                }
                list.add(object);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            DBUtil.close(resultSet, preparedStatement, connection);
        }
        return list;
    }
    /**
     * 查询对象
     *     从集合中获取第一个对象即可
     * @param sql
     * @param params
     * @param cls
     * @return
     */
    @SuppressWarnings("rawtypes")
    public static Object queryRow(String sql,List<Object> params,Class cls) {
        Object object=null;
        List list =queryRows(sql, params, cls);
        if (list !=null && list.size()>0) {
            object = list.get(0);
        }
        return object;
     }
    
    
    /**
     * 完成预编译操作
     * @param sql
     * @param params
     * @param connection
     * @return
     * @throws SQLException
     */
    public static PreparedStatement getPreparedStatement(String sql,List<Object> params,Connection connection) throws SQLException {
        //预编译
        PreparedStatement preparedStatement=connection.prepareStatement(sql);
        if (params !=null && params.size() >0) {
            IntStream.range(0, params.size()).forEach((i) ->{
                try {
                    preparedStatement.setObject(i+1, params.get(i));
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            });
        }
        return preparedStatement;
    }
    
}

配置文件