数据库工具类

将访问数据库的公共代码抽取出来

/**
 * 数据库工具类V1.5 将访问数据库的公共代码抽取: 1.加载驱动 2.获取连接 6.关闭资源
 *
 * @author Freedom
 *
 */
public class DBUtils {

    /** 驱动类路径 */
    private static String DRIVER_CLASS;
    /** url地址 */
    private static String URL;
    /** 数据库服务区登录用户名 */
    private static String USER;
    /** 数据库服务器登录密码 */
    private static String PASSWORD;

    /**最大活动连接数*/
    private static int MAX_ACTIVE;
    /**最长等待连接获取的时间*/
    private static long MAX_WAIT;
    /**初始连接数*/
    private static int INIT_SIZE;
    /**声明一个连接池引用*/
    private static DruidDataSource ds;

    /**
     * 静态初始块
     */
    static {
        try {
            // 读取属性文件获取连接数据库相关的字符串
            InputStream is = DBUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
            // 创建属性对象
            Properties p = new Properties();
            // 加载包含属性信息的输入流
            p.load(is);
            // 根据属性名获取属性值
            DRIVER_CLASS = p.getProperty("driver");
            URL = p.getProperty("url");
            USER = p.getProperty("user");
            PASSWORD = p.getProperty("password");
            //获取连接池相关配置
            MAX_ACTIVE = Integer.parseInt(p.getProperty("pool.maxActive"));
            INIT_SIZE = Integer.parseInt(p.getProperty("pool.initSize"));
            MAX_WAIT = Long.parseLong(p.getProperty("pool.maxWait"));
            //初始化连接池
            init();
        }catch(IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 初始化连接池
     */
    public static void init() {
        ds = new DruidDataSource();
        ds.setDriverClassName(DRIVER_CLASS);
        ds.setUrl(URL);
        ds.setUsername(USER);
        ds.setPassword(PASSWORD);
        ds.setMaxActive(MAX_ACTIVE);
        ds.setInitialSize(INIT_SIZE);
        ds.setMaxWait(MAX_WAIT);
    }

    /**
     * 2.获取数据库连接对象
     *
     * @return
     */
    public static synchronized Connection getConn() {
        try {
            //当连接池被关闭或者为null重新初始化
            if(ds==null||ds.isClosed()) {
                init();
            }
            //从连接池获取一个连接并返回
            return ds.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 6.关闭资源
     *
     * @param rs
     * @param stat
     * @param conn
     */
    public static void close(ResultSet rs, Statement stat, Connection conn) {
        try {
            if (rs != null){
                rs.close();
            }
            if (stat != null) {
                stat.close();
            }
            if (conn != null){
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 封装通用的更新操作:INSERT UPDATE DELETE
     *
     * @param sql
     * @param params
     * @return
     */
    public static boolean exeUpdate(Connection conn,String sql, Object... params) {
        // 获取连接
        conn = getConn();
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(sql);
            if (params != null) {
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i + 1, params[i]);
                }
            }
            return ps.executeUpdate() > 0;
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            close(null, ps, null);
        }
        return false;
    }

    /**
     * 封装通用查询单挑数据的方法
     *
     * @param <T>
     * @param t
     * @param sql
     * @param params
     * @return
     */
    public static <T> T queryOne(Class<T> t, String sql, Object... params) {
        // 获取查询到的数据集合
        List<Map<String, Object>> list = queryMaps(sql, params);
        if (list.size() > 0) {
            // 获取一个Map对象
            Map<String, Object> map = list.get(0);
            return mapToBean(map, t);
        }
        return null;
    }

    /**
     * 封装通用查询多条数据的方法
     *
     * @param <T>
     * @param t
     * @param sql
     * @param params
     * @return
     */
    public static <T> List<T> queryList(Class<T> t, String sql, Object... params) {
        List<T> list = new ArrayList<T>();
        // 获取所有查询的到的数据
        List<Map<String, Object>> maps = queryMaps(sql, params);
        maps.forEach(m -> {
            // 将map转换为Javabean
            T obj = mapToBean(m, t);
            // 将Javabean装入list
            list.add(obj);
        });
        return list;
    }

    /**
     * 将Map集合转换为一个确定的类型
     *
     * @param <T>
     * @param map
     * @param t
     * @return
     */
    private static <T> T mapToBean(Map<String, Object> map, Class<T> t) {
        try {
            T obj = t.newInstance();
            map.forEach((k, v) -> {
                try {
                    // 根据Field名称获取字段对象
                    Field field = t.getDeclaredField(k);
                    // 设置字段的可访问性
                    field.setAccessible(true);
                    // 为字段设置值
                    field.set(obj, v);
                } catch (NoSuchFieldException e) {
                    e.printStackTrace();
                } catch (SecurityException e) {
                    e.printStackTrace();
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            });
            return obj;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 执行相关查询并将结果返回为List<Map<String,Object>>集合
     *
     * @param sql
     * @param params
     * @return
     */
    public static List<Map<String, Object>> queryMaps(String sql, Object... params) {
        // 声明动态数组用于存储每一个查询的Map对象
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        // 获取连接
        Connection conn = getConn();
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            // 获取预处理sql命令的对象
            ps = conn.prepareStatement(sql);
            if (params != null) {
                for (int i = 0; i < params.length; i++) {
                    // 对指定位置的占位符填充值(预处理)
                    ps.setObject(i + 1, params[i]);
                }
            }
            // 执行查询获取结果集
            rs = ps.executeQuery();
            // 获取结果集的元数据对象ResultSetMetaData
            ResultSetMetaData rsmd = rs.getMetaData();
            // 获取总查询列数
            int columnCount = rsmd.getColumnCount();
            // 遍历结果集
            while (rs.next()) {
                // 声明map集合存储每一条数据(临时存储)
                Map<String, Object> map = new HashMap<String, Object>();
                // 遍历获取每一列的信息
                for (int i = 1; i <= columnCount; i++) {
                    // 获取列名称(作为map集合的键)
                    String key = rsmd.getColumnName(i);
                    // 获取列表标签
                    String label = rsmd.getColumnLabel(i);
                    // 获取列值(作为map集合的值)
                    Object value = rs.getObject(label);
                    if(Objects.nonNull(value)) {
                        // 将读取的每一列与列名存储到map
                        map.put(key, value);
                    }
                }
                // 将map集合装入list
                list.add(map);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            close(rs, ps, conn);
        }
        return list;
    }

    /**
     * 根据提供的查询语句以及查询参数,返回符合条件的数目
     *
     * @param sql
     * @param params
     * @return
     */
    public static int queryCount(String sql, Object... params) {
        Connection conn = getConn();
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(sql);
            if (params != null) {
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i + 1, params[i]);
                }
            }
            rs = ps.executeQuery();
            if (rs.next()) {
                return rs.getInt(1);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            close(rs, ps, conn);
        }
        return 0;
    }

}

使用数据库工具类时需要在创建一个jdbc.properties文件
文件里面存放访问数据库的数据

# jdbc connection settings
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/XXXX?character=utf8
user=XXXXXXX
password=XXXXXX

# connection pool settings
pool.maxActive=XX
pool.initSize=XX
pool.maxWait=XX

DAO层

/**
 * 商品类DAO实现
 * @author Freedom
 */
public class GoodsDAO {

    /**
     * 商品添加
     * @param g
     * @return
     */
    public boolean addGoods(Goods g){
        String sql = "insert into goods(gname,price,count,unit,sell,time,status,cid) values(?,?,?,?,?,current_timestamp(),?,?)";
        return DBUtils.exeUpdate(sql,g.getGname(),g.getPrice(),g.getCount(),g.getUnit(),g.getSell(),g.getStatus(),g.getCid());
    }

    /**
     * 查询指定分类的商品信息
     * @param cid
     * @return
     */
    public List<Goods> findByclass(int cid){
        String sql = "select * from goods where cid = ?";
        return DBUtils.queryList(Goods.class,sql,cid);

    }

    /**
     *  查询库存量低于5的商品信息
     * @return
     */
    public List<Goods> findBycount(){
        String sql = "select * from goods where count<5";
        return DBUtils.queryList(Goods.class,sql);
    }

    /**
     * 查询所有商品按照销量从高到低排序
     * @return
     */
    public  List<Goods> findBysell(){
        String sql = "select * from goods order by sell desc";
        return DBUtils.queryList(Goods.class,sql);
    }

    /**
     * 查询所有商品按照单价从高到低排序
     * @return
     */
    public List<Goods> findByprice(){
        String sql = "select * from goods order by price desc";
        return DBUtils.queryList(Goods.class,sql);
    }

    /**
     *  根据分类id查询有没有商品分类
     * @param cid
     * @return
     */
    public List<Goods> findBycid(int cid){
        String sql = "select id from goods where cid=?";
        return DBUtils.queryList(Goods.class,sql,cid);
    }

    /**
     *  分页查询所有商品，每页显示5条记录
     * @return
     */
    public List<Goods> pagelist(int pagenum){
        String sql = "{call sp_goods_paging(5,?)}";
        return DBUtils.pagelist(Goods.class,sql,pagenum);
    }

    /**
     * 通过商品名查找商品信息
     * @param name
     * @return
     */
    public Goods findByname(String name){
        String sql  = "select * from goods where gname=?";
        return DBUtils.queryOne(Goods.class,sql,name);
    }

    /**
     *  修改商品分类
     * @param id
     * @return
     */
    public boolean updategoodsclass(int cid,int id){
        String sql = "update goods set cid=? where id=?";
        return DBUtils.exeUpdate(sql,cid,id);
    }

    /**
     * 修改查询到的商品的分类
     * @return
     * @param g
     */
    public boolean updatecid(Goods g){
        String sql = "update goods set cid=null where id=?";
        return DBUtils.exeUpdate(sql,g.getId());
    }
}