通用的数据库数据操作类

package com.lyang.dao;

import java.lang.reflect.Field;
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 com.lyang.util.PageInfo;
import com.lyang.util.JdbcUtil;

/**
 * 通用的数据库数据操作类
 */
public class BaseDao {

    /**
     * 通用查询数据列表
     * @param <T>   具体的类
     * @param sql   sql指令
     * @param cls   反射类
     * @param param 参数
     * @return
     */
    public <T> List<T> selectList(String sql, Class<T> cls, Object... param) {
        Connection conn = JdbcUtil.getConn();
        PreparedStatement prep = null;
        ResultSet rs = null;
        List<T> data = new ArrayList<T>();
        try {
            prep = conn.prepareStatement(sql);
            //循环设置参数
            for (int i = 0; i < param.length; i++) {
                prep.setObject(i + 1, param[i]);
            }
            //查询结果
            rs = prep.executeQuery();
            while (rs.next()) {
                T bean = rsToBean(rs, cls);
                data.add(bean);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.close(conn, prep, rs);
        }
        return data;
    }

    /**
     * 查询一条数据
     * @param <T>   具体的类
     * @param sql   sql指令
     * @param cls   反射类
     * @param param 参数
     * @return
     */
    public <T> T selectOne(String sql, Class<T> cls, Object... param) {
        List<T> list = this.selectList(sql, cls, param);
        if (!list.isEmpty() && list.size() == 1) {
            return list.get(0);
        }
        return null;
    }

    /**
     * 将ResultSet 转化为任意对应的JavaBean
     * @param <T> 具体的类
     * @param rs  结果集
     * @param cls 反射类
     * @return
     */
    public <T> T rsToBean(ResultSet rs, Class<T> cls) {
        T t = null;
        try {
            t = cls.newInstance();
            // 获取查询结果的元数据
            ResultSetMetaData metaData = rs.getMetaData();
            // 获取列的个数 查询结果的列的个数
            int columnCount = metaData.getColumnCount();
            for (int i = 0; i < columnCount; i++) {
                // 获取列名称
                String columnLabel = metaData.getColumnLabel(i + 1);
                // 获取该列对应的值
                Object value = rs.getObject(columnLabel);
                // 根据结果列名称 查找对应属性
                Field field = cls.getDeclaredField(columnLabel);
                // 设置权限，因为属性都为私有的，无法直接获取
                field.setAccessible(true);
                // 为属性设置值
                field.set(t, value);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return t;
    }

    /**
     * 通用删除
     * @param sql sql指令
     * @return
     */
    public boolean deleteById(String sql) {
        Connection conn = JdbcUtil.getConn();
        PreparedStatement prep = null;
        try {
            prep = conn.prepareStatement(sql);
            int m = prep.executeUpdate();
            return m == 1 ? true : false;
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.close(conn, prep);
        }
        return false;
    }

    /**
     * 向表插入数据 返回 自增涨主键值
     * @param sql   sql指令
     * @param param 参数
     * @return
     */
    public int insert(String sql, Object... param) {
        Connection conn = JdbcUtil.getConn();
        PreparedStatement prep = null;
        ResultSet rs = null;
        try {
            // PreparedStatement.RETURN_GENERATED_KEYS：返回生成的key
            prep = conn.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
            for (int i = 0; i < param.length; i++) {
                prep.setObject(i + 1, param[i]);
            }
            prep.executeUpdate();
            // 生成的主键
            rs = prep.getGeneratedKeys();
            if (rs != null) {
                rs.next();
                return rs.getInt(1);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.close(conn, prep);
        }
        return 0;
    }

    /**
     * 通用更新
     * @param sql   sql指令
     * @param param 参数
     * @return
     */
    public boolean update(String sql, Object... param) {
        Connection conn = JdbcUtil.getConn();
        PreparedStatement prep = null;
        try {
            prep = conn.prepareStatement(sql);
            for (int i = 0; i < param.length; i++) {
                prep.setObject(i + 1, param[i]);
            }
            int m = prep.executeUpdate();
            return m > 0 ? true : false;
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.close(conn, prep);
        }
        return false;
    }

    /**
     * 分页查询
     * @param <T>   具体的类
     * @param sql   sql指令
     * @param page  页码
     * @param limit 每页条数
     * @param cls   反射类
     * @return
     */
    public <T> PageInfo<T> selectPage(String sql, Integer page, Integer limit, Class<T> cls) {
        // 总行数
        int total = this.selectCount(sql);
        // 最大页码
        int maxPage = total % limit == 0 ? total / limit : total / limit + 1;

        // 如果page比最大页码大  则值为最大页码
        if (page > maxPage) {
            page = maxPage;
        }
        // 如果page值小于1  则为1
        if (page < 1) {
            page = 1;
        }
        int startIndex = (page - 1) * limit;
        sql = sql + "  limit " + startIndex + "," + limit;
        // 查询数据
        List<T> data = this.selectList(sql, cls);

        PageInfo<T> pageInfo = new PageInfo<T>(page, limit, total, maxPage, data);
        return pageInfo;
    }

    /**
     * 符合条件的总行数
     * @param sql sql指令
     * @return
     */
    private int selectCount(String sql) {
        sql = "select count(1) from (" + sql + ") as rs";
        Connection conn = JdbcUtil.getConn();
        PreparedStatement prep = null;
        ResultSet rs = null;
        try {
            prep = conn.prepareStatement(sql);
            rs = prep.executeQuery();
            rs.next();
            return rs.getInt(1);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.close(conn, prep, rs);
        }
        return 0;
    }

}