JDBC工具包封装

最新推荐文章于 2024-04-12 15:36:39 发布
最新推荐文章于 2024-04-12 15:36:39 发布
阅读量191 收藏
点赞数
分类专栏： java基础 文章标签： java jdbc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16116881/article/details/117711776
版权

前言

​ 工作中，需要使用java访问数据库，操作一些数据；使用orm框架就显得笨重。所以，对jdbc的基本使用方法进行封装，直接复制代码就可以使用，代码中使用mysql数据和dbcp连接池，默认连接数为8。

使用说明

1.使用maven，引入jar
    <!-- dbcp连接池 -->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-dbcp2</artifactId>
      <version>2.8.0</version>
    </dependency>
    
	<!-- mysql驱动 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.49</version>
    </dependency>
2.配置并创建数据源
jdbcConfig.properties文件（放在根目录）
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/jiangz?useUnicode=true&characterEncoding=UTF-8
username=root
password=root
JdbcConfig.java代码
/**
 * jdbc工具类
 *
 * @author yangfan
 *
 */
public final class JdbcConfig {

    private static Logger log = LoggerFactory.getLogger(JdbcConfig.class);

    private static DataSource dataSource;
    /**
     * 数据源创建成功
     */
    static {

        try {
            InputStream in = JdbcConfig.class.getResourceAsStream("/jdbcConfig.properties");
            Properties p = new Properties();
            p.load(in);
            dataSource = BasicDataSourceFactory.createDataSource(p);
            log.info("dataSource 创建成功！");
        } catch (Exception e) {
            log.error("dataSource 创建失败！");
            e.printStackTrace();
        }
    }

    /**
     * 建立数据库连接
     *
     * @return
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException {
        Connection conn = null;
        conn = dataSource.getConnection();
        return conn;
    }

    /**
     * 释放连接
     * @param conn
     */
    private static void freeConnection(Connection conn) {
        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 释放statement
     * @param statement
     */
    private static void freeStatement(Statement statement) {
        try {
            statement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 释放resultset
     * @param rs
     */
    private static void freeResultSet(ResultSet rs) {
        try {
            rs.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 释放资源
     *
     * @param conn
     * @param statement
     * @param rs
     */
    public static void free(Connection conn, Statement statement, ResultSet rs) {
        if (rs != null) {
            freeResultSet(rs);
        }
        if (statement != null) {
            freeStatement(statement);
        }
        if (conn != null) {
            freeConnection(conn);
        }
    }

}
3.CURD方法封装
JdbcHelper.java
/**
 * 数据库访问帮助类
 *
 * @author yangfan
 *
 */
public class JdbcHelper {

    private static Connection conn = null;
    private static PreparedStatement preparedStatement = null;
    private static CallableStatement callableStatement = null;

    /**
     * 单个对象查询
     * @param sql
     * @return
     * @throws SQLException
     */
    public static Map<String,Object> getOne(String sql) throws SQLException {

        ResultSet rs = null;
        try {
            getPreparedStatement(sql);
            rs = preparedStatement.executeQuery();

            return getResultMap(rs);
        } catch (SQLException e) {
            throw new SQLException(e);
        } finally {
            free(rs);
        }

    }

    /**
     * 获取集合数据（多个对象）
     * @param sql
     * @return
     * @throws SQLException
     */
    public static List<Map<String,Object>> getList(String sql) throws SQLException {

        ResultSet rs = null;
        try {
            getPreparedStatement(sql);
            rs = preparedStatement.executeQuery();

            return convertList(rs);
        } catch (SQLException e) {
            throw new SQLException(e);
        } finally {
            free(rs);
        }

    }

    /**
     * 获取集合数据（多个对象）
     * @param sql
     * @return
     * @throws SQLException
     */
    public static List<Map<String,Object>> getList(String sql, Object... paramters)
            throws SQLException {

        ResultSet rs = null;
        try {
            getPreparedStatement(sql);

            for (int i = 0; i < paramters.length; i++) {
                preparedStatement.setObject(i + 1, paramters[i]);
            }
            rs = preparedStatement.executeQuery();
            return ResultToListMap(rs);
        } catch (SQLException e) {
            throw new SQLException(e);
        } finally {
            free(rs);
        }
    }

    /**
     * 单个值获取
     * 如 select id from test where id =1
     * @param sql
     * @return
     * @throws SQLException
     */
    public static Object getSingle(String sql) throws SQLException {
        Object result = null;
        ResultSet rs = null;
        try {
            getPreparedStatement(sql);
            rs = preparedStatement.executeQuery();
            if (rs.next()) {
                result = rs.getObject(1);
            }
            return result;
        } catch (SQLException e) {
            throw new SQLException(e);
        } finally {
            free(rs);
        }

    }

    /**
     * 单个值获取
     * 如 select id from test where id =1
     * @param sql
     * @return
     * @throws SQLException
     */
    public static Object getSingle(String sql, Object... paramters)
            throws SQLException {
        Object result = null;
        ResultSet rs = null;
        try {
            getPreparedStatement(sql);

            for (int i = 0; i < paramters.length; i++) {
                preparedStatement.setObject(i + 1, paramters[i]);
            }
            rs = preparedStatement.executeQuery();
            if (rs.next()) {
                result = rs.getObject(1);
            }
            return result;
        } catch (SQLException e) {
            throw new SQLException(e);
        } finally {
            free(rs);
        }
    }

    /**
     * 用于增删改
     *
     * @param sql
     *            sql语句
     * @return 影响行数
     * @throws SQLException
     */
    public static int update(String sql) throws SQLException {

        try {
            getPreparedStatement(sql);

            return preparedStatement.executeUpdate();
        } catch (SQLException e) {
            throw new SQLException(e);
        } finally {
            free();
        }
    }

    /**
     * 用于增删改（带参数）
     *
     * @param sql
     *            sql语句
     * @param paramters
     *            sql语句
     * @return 影响行数
     * @throws SQLException
     */
    public static int update(String sql, Object... paramters)
            throws SQLException {
        try {
            getPreparedStatement(sql);

            for (int i = 0; i < paramters.length; i++) {
                preparedStatement.setObject(i + 1, paramters[i]);
            }
            return preparedStatement.executeUpdate();
        } catch (SQLException e) {
            throw new SQLException(e);
        } finally {
            free();
        }
    }

    /**
     * 插入值后返回主键值
     *
     * @param sql
     *            插入sql语句
     * @return 返回结果
     * @throws Exception
     */
    public static Object insertWithReturnPrimeKey(String sql)
            throws SQLException {
        ResultSet rs = null;
        Object result = null;
        try {
            conn = JdbcConfig.getConnection();
            preparedStatement = conn.prepareStatement(sql,
                    PreparedStatement.RETURN_GENERATED_KEYS);
            preparedStatement.execute();
            rs = preparedStatement.getGeneratedKeys();
            if (rs.next()) {
                result = rs.getObject(1);
            }
            return result;
        } catch (SQLException e) {
            throw new SQLException(e);
        }finally {
            free(rs);
        }
    }

    /**
     * 插入值后返回主键值
     *
     * @param sql
     *            插入sql语句
     * @param paramters
     *            参数列表
     * @return 返回结果
     * @throws SQLException
     */
    public static Object insertWithReturnPrimeKey(String sql,
                                                  Object... paramters) throws SQLException {
        ResultSet rs = null;
        Object result = null;
        try {
            conn = JdbcConfig.getConnection();
            preparedStatement = conn.prepareStatement(sql,
                    PreparedStatement.RETURN_GENERATED_KEYS);
            for (int i = 0; i < paramters.length; i++) {
                preparedStatement.setObject(i + 1, paramters[i]);
            }
            preparedStatement.execute();
            rs = preparedStatement.getGeneratedKeys();
            if (rs.next()) {
                result = rs.getObject(1);
            }
            return result;
        } catch (SQLException e) {
            throw new SQLException(e);
        }

    }

    /**
     * 调用存储过程执行查询
     *
     * @param procedureSql
     *            存储过程
     * @return
     * @throws SQLException
     */
    public static List callableQuery(String procedureSql) throws SQLException {
        ResultSet rs = null;
        try {
            getCallableStatement(procedureSql);
            rs = callableStatement.executeQuery();
            return ResultToListMap(rs);
        } catch (SQLException e) {
            throw new SQLException(e);
        } finally {
            free(rs);
        }
    }

    /**
     * 调用存储过程（带参数）,执行查询
     *
     * @param procedureSql
     *            存储过程
     * @param paramters
     *            参数表
     * @return
     * @throws SQLException
     */
    public static List callableQuery(String procedureSql, Object... paramters)
            throws SQLException {
        ResultSet rs = null;
        try {
            getCallableStatement(procedureSql);

            for (int i = 0; i < paramters.length; i++) {
                callableStatement.setObject(i + 1, paramters[i]);
            }
            rs = callableStatement.executeQuery();
            return ResultToListMap(rs);
        } catch (SQLException e) {
            throw new SQLException(e);
        } finally {
            free(rs);
        }
    }

    /**
     * 调用存储过程，查询单个值
     *
     * @param procedureSql
     * @return
     * @throws SQLException
     */
    public static Object callableGetSingle(String procedureSql)
            throws SQLException {
        Object result = null;
        ResultSet rs = null;
        try {
            getCallableStatement(procedureSql);
            rs = callableStatement.executeQuery();
            while (rs.next()) {
                result = rs.getObject(1);
            }
            return result;
        } catch (SQLException e) {
            throw new SQLException(e);
        } finally {
            free(rs);
        }
    }

    /**
     * 调用存储过程(带参数)，查询单个值
     *
     * @param procedureSql
     * @return
     * @throws SQLException
     */
    public static Object callableGetSingle(String procedureSql,
                                           Object... paramters) throws SQLException {
        Object result = null;
        ResultSet rs = null;
        try {
            getCallableStatement(procedureSql);

            for (int i = 0; i < paramters.length; i++) {
                callableStatement.setObject(i + 1, paramters[i]);
            }
            rs = callableStatement.executeQuery();
            while (rs.next()) {
                result = rs.getObject(1);
            }
            return result;
        } catch (SQLException e) {
            throw new SQLException(e);
        } finally {
            free(rs);
        }
    }

    public static Object callableWithParamters(String procedureSql)
            throws SQLException {
        try {
            getCallableStatement(procedureSql);
            callableStatement.registerOutParameter(0, Types.OTHER);
            callableStatement.execute();
            return callableStatement.getObject(0);

        } catch (SQLException e) {
            throw new SQLException(e);
        } finally {
            free();
        }

    }

    /**
     * 调用存储过程，执行增删改
     *
     * @param procedureSql
     *            存储过程
     * @return 影响行数
     * @throws SQLException
     */
    public static int callableUpdate(String procedureSql) throws SQLException {
        try {
            getCallableStatement(procedureSql);
            return callableStatement.executeUpdate();
        } catch (SQLException e) {
            throw new SQLException(e);
        } finally {
            free();
        }
    }

    /**
     * 调用存储过程（带参数），执行增删改
     *
     * @param procedureSql
     *            存储过程
     * @param parameters
     * @return 影响行数
     * @throws SQLException
     */
    public static int callableUpdate(String procedureSql, Object... parameters)
            throws SQLException {
        try {
            getCallableStatement(procedureSql);
            for (int i = 0; i < parameters.length; i++) {
                callableStatement.setObject(i + 1, parameters[i]);
            }
            return callableStatement.executeUpdate();
        } catch (SQLException e) {
            throw new SQLException(e);
        } finally {
            free();
        }
    }

    /**
     * 批量更新数据
     *
     * @param sqlList
     *            一组sql
     * @return
     */
    public static int[] batchUpdate(List<String> sqlList) {

        int[] result = new int[] {};
        Statement statenent = null;
        try {
            conn = JdbcConfig.getConnection();
            conn.setAutoCommit(false);
            statenent = conn.createStatement();
            int  len = sqlList.size();
            for (int i = 0; i < len; i++) {

                statenent.addBatch(sqlList.get(i));

                if((i != 0 && i % 500 == 0) || i == len-1){//可以设置不同的大小；如50，100，200，500，1000等等
                    statenent.executeBatch();
                    //优化插入第三步       提交，批量插入数据库中。
                    conn.commit();
                    statenent.clearBatch();        //提交后，Batch清空。
                }
            }
        } catch (SQLException e) {
            try {
                conn.rollback();
            } catch (SQLException e1) {
                throw new ExceptionInInitializerError(e1);
            }
            throw new ExceptionInInitializerError(e);
        } finally {
            free(statenent, null);
        }
        return result;
    }

    private static List ResultToListMap(ResultSet rs) throws SQLException {
        List list = new ArrayList();
        while (rs.next()) {
            ResultSetMetaData md = rs.getMetaData();
            Map map = new HashMap();
            for (int i = 1; i < md.getColumnCount(); i++) {
                map.put(md.getColumnLabel(i), rs.getObject(i));
            }
            list.add(map);
        }
        return list;
    }

    /**
     * 查询结果转Map
     * @param rs
     * @return
     * @throws SQLException
     */
    private static Map<String, Object> getResultMap(ResultSet rs)
            throws SQLException {
        Map<String, Object> hm = new HashMap<String, Object>();
        ResultSetMetaData rsmd = rs.getMetaData();
        int count = rsmd.getColumnCount();// 获取列的数量
        for (int i = 1; i <= count; i++) {
            String key = rsmd.getColumnLabel(i);
            String value = rs.getString(i);
            hm.put(key, value);
        }
        return hm;
    }


    /**
     * 将查询结果resultset转换为List<Map>
     * @param rs
     * @return
     * @throws SQLException
     */
    private static List<Map<String,Object>> convertList(ResultSet rs) throws SQLException{
        List<Map<String,Object>> list = new ArrayList<>();
        ResultSetMetaData md = rs.getMetaData();//获取键名
        int columnCount = md.getColumnCount();//获取列的数量
        while (rs.next()) {
            Map<String,Object> rowData = new HashMap<>();//声明Map
            for (int i = 1; i <= columnCount; i++) {
                rowData.put(md.getColumnName(i), rs.getObject(i));//获取键名及值
            }
            list.add(rowData);
        }
        return list;
    }

    /**
     * 获取PreparedStatement
     *
     * @param sql
     * @throws SQLException
     */
    private static void getPreparedStatement(String sql) throws SQLException {
        conn = JdbcConfig.getConnection();
        preparedStatement = conn.prepareStatement(sql);
    }

    /**
     * 获取CallableStatement
     *
     * @param procedureSql
     * @throws SQLException
     */
    private static void getCallableStatement(String procedureSql)
            throws SQLException {
        conn = JdbcConfig.getConnection();
        callableStatement = conn.prepareCall(procedureSql);
    }

    /**
     * 释放资源
     *
     * @param rs
     *            结果集
     */
    public static void free(ResultSet rs) {

        JdbcConfig.free(conn, preparedStatement, rs);
    }

    /**
     * 释放资源
     *
     * @param statement
     * @param rs
     */
    public static void free(Statement statement, ResultSet rs) {
        JdbcConfig.free(conn, statement, rs);
    }

    /**
     * 释放资源
     */
    public static void free() {

        free(null);
    }

}
fanger8848
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDBC工具类的封装
m0_48895748的博客
09-12 1437
JDBC工具类的封装，封装获取数据库连接方法，获取preparedStatement对象的方法，解析ResultSet集合，关闭资源等方法
JDBC封装工具类
kaijiayongshi001的博客
10-26 420
第一节:工具类封装 公共属性抽取 public static final String DRIVER = "com.mysql.jdbc.Driver"; public static final String URL = "jdbc:mysql://localhost:3306/ceshi?useUnicode=true&characterEncoding=utf8&useSSL=false"; public static final String ROOT = "ro...
JDBC工具包MidaoJDBC.zip
07-16
Midao JDBC 简化了 JDBC 的开发，特点是灵活、可定制、简单直观，提供大量的功能，包括事务处理、元数据操作、类型处理、检视、输入输出处理和转化，带连接池的数据源支持；缓存和懒查询执行；命名参数；多供应商支持；自定义异常处理和重载等等。只需要一个简单的 jar 包就可以支持 JDBC 3.0 (Java 5) 和 JDBC 4.0 (Java 6). 示例代码： QueryRunnerService runner = MidaoFactory.getQueryRunner(this.dataSource); Map<String, Object> queryParameters = new HashMap<String, Object>(); queryParameters.put("id", 1); MapInputHandler input = new MapInputHandler("SELECT name FROM students WHERE id = :id", queryParameters); Map<String, Object> result = runner.query(input, new MapOutputHandler()); 标签：Midao
java框架学习——spring IOC示例纯注解实现单表操作
weixin_37719485的博客
07-28 144
示例来源本博客中上一个xml方式实现的单表操作基础上修改为注解开发 新建一个maven工程命名为：studentAnnoationIoc 将xml方式创建的代码尽数拷贝过来，做一定调整并新建替代的类，项目环境搭建完成后的结构如下： 需要修改的代码类如下： 1.StudentDaoImpl.java中添加红色框中的并删除相应set方法 2.StudentServiceImpl.java中的代码修改添加红色框中的并删除相应set方法 3.在resources中新建jdbcConfig.properties
JDBC高级篇-JDBC工具类、DAO封装和BaseDAO工具类
最新发布
weixin_44201223的博客
04-12 604
JDBC优化及工具类封装、ThreadLocal、DAO封装及BaseDAO工具类
JDBC超详细封装教程
weixin_48991399的博客
03-18 1711
​ JDBC（Java Database Connectivity）是什么？它是一种规范，SUN公司要求数据库公司必须按照JDBC规范实现对应数据库Java代码，提供数据库的相关资源给java程序。在JDBC出来之前，各种数据库提供给java程序数据的方法各式各样，可以说，JDBC极大地方便了我们java开发程序员，目前和java配合最好的数据库是Oracle和MySQL数据库。
JDBC的封装
qi341500的博客
09-12 4236
JDBC封装的步骤： 1、在src里面创建一个文件，命名为：database.properties 2、定义实体类：实体类的表名与数据库的表名一致，表中大每一列为实体类的属性 3、将用户对象的所有操作抽取成接口 4、由不同数据库的实现类分别实现接口；实现类实现接口并继承数据库工具类 5、将通用的操作（如打开、关闭连接等）封装到工具类数据库工具类 6、在测试类进行测试 7、单例模式
SpringBoot中封装jdbc工具类
04-08
现在的数据层的开发，大多会使用如MyBatis或...由于部分场景下MyBatis或JPA之类无法满足我的需求，所以我打算自己封装一套查数据库的工具类。 文章地址： https://blog.csdn.net/lxyoucan/article/details/124042295
javaweb jdbc工具类.zip
05-20
本压缩包"javaweb-jdbc工具类.zip"提供了一个实用的工具包，旨在简化数据库操作，使持久层 Dao 包的编写更加简便，提高开发效率。下面我们将详细探讨JDBC工具类的关键知识点。 1. **数据库连接管理**：在Java Web...
jdbc封装包
08-27
综上，JDBC封装包是一个实用的工具，它简化了数据库操作流程，提高了开发效率，并且通过良好的封装，降低了出错的可能性。使用时，只需根据自己的数据库配置进行适当的参数修改，即可快速地进行数据库操作。
泛型封装JDBC
01-11
将泛型应用于JDBC封装，能够使代码更加灵活、高效且易于维护。下面我们将深入探讨如何利用泛型来封装JDBC，以及其在Oracle数据库操作中的应用。 1. **泛型的理解**： 泛型的主要作用是为容器类（如List、Map等）...
jdbc-utils.rar_Utils_jdbc_jdbc封装
09-23
"jdbc-utils.rar_Utils_jdbc_jdbc封装"这个压缩包提供了一些工具类，用于简化JDBC操作，提高代码的可读性和可维护性。下面我们将详细探讨JDBC封装处理类的原理和实现。 1. **JDBC基础** - JDBC API包括一组Java...
对JDBC进行封装，封装成工具类，封装成几行简单的代码就可以从数据库中获取指定的数据~
hariya的博客
03-21 1095
我们将自己数据库对应的URL写到工具类中的static代码块中，但是在项目中我们写的工具类有好多，java文件也有好多。别人看或者在他电脑上想运行我们的项目的时候，需要修改他自身的用户名和密码 所以将这些写到static中也并不是非常合适的，这时候我们就需要想到我们可以将这些数据写到一个资源文件中，在static中通过读取资源文件中的数据来加载数据库。 在集合中，有一个键值对集合Properties，这个我们没怎么说当时，但是这个集合是map集合。我们可以写一个 properties文件专门存放我们
jdbc工具类封装
weixin_41796772的博客
03-15 163
JAVA连接JDBC,编写简单的学生管理系统1
jdbc工具包
暮辰的博客
05-10 411
JDBC连接数据库
JDBC工具类封装
qq_42732184的博客
04-18 1123
jdbc工具类的封装： package com.hyc.study02.utils; import java.io.InputStream; import java.sql.*; import java.util.Properties; public class JDBCUtils { private static String driver = null; private static String url = null; private static String userna
封装JDBC通用的工具类
wk3510的博客
08-26 344
使用jdbc的步骤：加载JDBC驱动程序 → 建立数据库连接Connection → 创建执行SQL的语句Statement → 处理执行结果ResultSet → 释放资源；
JDBC - （05）工具类封装
chenyouchang的博客
03-15 312
JDBC：Java Database Connectivity（Java连接数据库技术） 通俗点说：在Java代码中，使用JDBC提供的方法，可以发送字符串类型的`SQL语句`到`数据库管理软件`（MySQL、Oracle等），并且获取语句`执行结果`，进而实现数据库数据`CURD操作`的技术。
jdbc工具类最终版
07-28
引用\[1\]中提到了JDBC工具类的代码实现，其中使用了ResourceBundle进行资源的绑定，主要是绑定到jdbc.properties文件，方便读取相关配置信息。工具类的代码实现包括加载驱动、关闭资源、建立数据库连接、执行预编译...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值