JDBC封装工具于详解

最新推荐文章于 2024-07-25 16:06:56 发布
最新推荐文章于 2024-07-25 16:06:56 发布
阅读量159 收藏
点赞数 1
文章标签： jdbc mysql java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq1131610682/article/details/107865985
版权

JDBC封装工具

  相信大家在使用jdbc的时候，如果按部就班，就总是会写老旧的六步式，以下是jdbc标准六步式的使用方式：

//1.加载数据库驱动(注册驱动)  JDBC4之后无需编写
Class.forName("com.mysql.jdbc.Driver"); 
//2.获取连接
Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mydb2", "root", "123456");
//3.获取执行sql语句命令的对象
Statement stat = conn.createStatement();
//4.执行sql
boolean f = stat.execute("insert into tbuser(username,password) values('java-jdbc','112233')");
//5.处理结果
System.out.println("执行结果:"+f);
//6.关闭资源
stat.close();
conn.close();

  如果每次使用jdbc都是使用这些步骤，未免繁琐空乏，杂多的 方法使人感觉到恶心，看不下去。何不创建一个jdbc的工具类，将六步式封装起来，像如下的语句，一部就能完成jdbc操作呢？

//根据id删除  直接返回删除是否成功
 public boolean delect(int id) {
        String sql ="delete  from goods where id=?";
        return DBUtils.exeUpdate(sql,id);
    } 
  //传入一个实体类，更新数据库中的数据
      public boolean update(Goods goods) {
        String sql="update goods set id=? gname=? price=? num=? unit=? outNum=? time=? state=?cid=?";
        return DBUtils.exeUpdate(sql,goods.getId(),goods.getGname(),goods.getPrice(),goods.getNum(),goods.getUnit(),goods.getTime(),goods.getState(),goods.getCid());
    }

  废话说的有点多，那现在让我开始吧！！！
  由于不同用户，需要操作的数据库不同，所以我们需要创建一个配置文件，让用户来配置参数。而且考虑到工具类的使用，会使用到多个连接Connection，我们创建一个连接池，当用户使用了连接池，自动归还连接，加快工具类的使用速率。Druid（德鲁伊）是阿里巴巴开发的号称为监控而生的数据库连接池，Druid是目前最好的数据库连接池。在功能、性能、扩展性方面，都超过其他数据库连接池，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况。Druid地址:添加链接描述DRUID连接池使用的jar包：druid-1.0.9.jar
配置文件信息：在这里插入图片描述

配置文件代码：

# jdbc connection
dirver=com.mysql.jdbc.Driver
# 写入自己想连接的数据库
url=jdbc:mysql://127.0.0.1:3306/mydb2
user=root
password=123456
#connection pool settings
pool.maxActive=10
pool.initSize=5
pool.maxWait=30000

jdbc驱动文件下载地址：添加链接描述

  另外，在处理jdbc事务时，为了保证事务的四大特性，我们只需要一个连接，用于提交和回滚。这个时候我们需要将下面代码中的exeUpdate(String sql, Object… params)方法重写为exeUpdate(Connection conn, String sql, Object… params)，用于添加同一个连接。

import java.io.IOException;
import java.io.InputStream;
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.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import com.alibaba.druid.pool.DruidDataSource;

/**
 * 数据库工具类V2.0 ORM框架 将访问数据库的公共代码抽取 1.加载驱动 2.获取连接 6关闭资源
 *
 * @author Keerloo
 *
 */
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;

    /**
     *获取由Alibaba提供的Druid 连接池元数据
     */
    private static DruidDataSource ds ;

    /**
     * 初始化块，用于获取配置文件中的信息
     */

    static {

        try {
            //获取jdbc文件驱动
            InputStream is = DBUtils.class.getResourceAsStream("/jdbc.properties");
            //创建属性对象
            Properties p = new Properties();
            p.load(is);
            DRIVER_CLASS = p.getProperty("drver");
            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);
    }

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

    /**
     * 关闭资源的操作
     *
     * @param rs
     * @param stat
     */
    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 throwables) {
            throwables.printStackTrace();
        }

    }

    /**
     * 封装通用的更新操作:insert update delete
     *
     * @param sql
     * @param params
     * @return
     */
    public static boolean exeUpdate(String sql, Object... params) {
        //获取连接
        Connection 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 throwables) {
            throwables.printStackTrace();
        } finally {
            close(null, ps, conn);
        }
        return false;
    }
    /**
     * 封装通用的更新操作:insert update delete，是对上面方法的重写
     *
     * @param sql
     * @param params
     * @return
     */
    public static boolean exeUpdate(Connection conn, String sql, Object... params) {
        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 throwables) {
            throwables.printStackTrace();
        } finally {
            close(null, ps, null);
        }
        return false;
    }

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

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

    /**
     * 将map集合转换为一个确定的类型
     *
     * @param t
     * @param <T>
     * @return
     */
    public static <T> T mapToBean(Map<String, Object> map, Class<T> t) {
        T obj = null;
        try {
            //根据提供的Class对象创建对应的类型的Object
            obj = t.newInstance();
            //获取Class中的所有field
            Field[] fields = t.getDeclaredFields();
            //遍历每一个属性对象
            for (Field field : fields) {
                //获取属性名
                String fname = field.getName();
                //获取属性值
                Object value = map.get(fname);
                if (value != null) {
                    //设置属性对象的可访问性
                    field.setAccessible(true);
                    //将从map中获取的值设置个属性 obj.name=xx
                    field.set(obj, value);
                }
            }


        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return obj;

    }

    /**
     * 执行相关查询并将结果返回为List<Map<String,Object>> 集合
     *
     * @param sql
     * @param params
     * @return
     */

    public static List<Map<String, Object>> queryToMaps(String sql, Object... params) {
        //声明动态数组用于存储每一个查询到的map对象
        List<Map<String, Object>> list = new ArrayList<>();

        //获取连接
        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>();
                    map.clear();
                    //遍历获取每一列的信息
                    for (int i = 1; i <= columnCount; i++) {
                        //获取类名称
                        String key = rsmd.getColumnName(i);
                        //获取列标签
                        String label = rsmd.getColumnLabel(i);
                        //获取列值
                        Object value = rs.getObject(label);
                        //将取到的每一列的列名月列值存储到map
                        map.put(key, value);
                    }
                    //将map集合装入到List
                    list.add(map);

                }

            }
        } catch (SQLException throwables) {
            throwables.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 throwables) {
            throwables.printStackTrace();
        } finally {
            close(rs, ps, conn);
        }

        return 0;
    }



}
``
keerloo
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring JDBC的使用方法详解
08-25
为什么使用Spring提供的JDBC封装？ Spring提供了完整的模板类以及基类，可以简化开发，我们只需写少量的代码即可。使用Spring提供的JDBC封装可以简化数据库访问，提高开发效率。 实例讲解 第一步：导入依赖 在...
Jdbc工具类的封装
m0_70503831的博客
05-22 239
自己封装Jdbc工具类
利用Java针对MySql封装的jdbc框架类 JdbcUtils 完整实现(包含增删改查、JavaBean反射原理，附源码)
热门推荐
yanzi1225627的专栏
05-25 6万+
最近看老罗的视频，跟着完成了利用Java操作MySql数据库的一个框架类JdbcUtils.java,完成对数据库的增删改查。其中查询这块，包括普通的查询和利用反射完成的查询，主要包括以下几个函数接口:1、public Connection getConnection()   获得数据库的连接2、public boolean updateByPreparedStatement(String sql
jdbc工具类的封装
Arya_boy的博客
08-28 211
今天做了一个jdbc工具类的分装：比如findall那个文件就写的不是很好，没有做到通用性。 package com.zzu; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.net.URL; import java.sql.Con...
jdbc的封装
东方
03-05 5021
把驱动注册和释放连接资源封装了一个工具类 package com.yidongxueyuan.dao; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; /...
Jdbc封装与使用
小白学编程
06-09 1791
封装就是将一些常用的比较固定的一些写法封装起来。 第一步：首先建立资源文件（封装） 1、选择File类型文件 2、弹出窗口后，命名为xx.properties（这里主要说明一下后缀为properties，xx自己进行选择取名。） 3、完成上述步骤后，即会出现以下窗口，建议使用Properties窗口中的Add添加name与value，不建议使用Source。因为格式是与正常编写出来...
简易JDBC框架实现过程详解
08-24
JdbcNewUtils类是指封装update和query方法的工具类，该类提供了getConnection、update和query方法。getConnection方法用于获取数据库连接，update方法用于执行CUD操作，query方法用于执行R操作。 十、使用...
JDBC工具类.txt
12-28
### JDBC工具类知识点详解 #### 一、JDBC概述与工具类的作用 JDBC（Java Database Connectivity）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。...
jdbc工具类
10-27
**JDBC工具类详解** Java Database Connectivity（JDBC）是Java编程语言中用来规范客户端程序如何访问数据库的应用程序接口（API），提供了诸如查询和更新数据库中数据的能力。JDBC工具类是为了简化数据库操作，...
jdbc封装包
08-27
综上，JDBC封装包是一个实用的工具，它简化了数据库操作流程，提高了开发效率，并且通过良好的封装，降低了出错的可能性。使用时，只需根据自己的数据库配置进行适当的参数修改，即可快速地进行数据库操作。
高并发下单例的jdbc连接池工具类
ZksLoveLy的博客
12-21 1453
package com.mlt.util;import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.ArrayList; import java.util.LinkedList;
解析 JDBC封装过程 & 掌握封装思维
WzXxZw_Bolgs
12-23 159
教你如何封装Connection、update、query、了解Result结果集方法，封装不单是封装，更是理解JDBC增删查改的方法。
JDBC(规范和封装jdbc代码)
Akagiii的博客
04-17 908
主程序package zucc.edu.cn.jdbc; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class Base { public static void main(String[] arg...
JDBC封装
weixin_44589334的博客
05-15 3098
在学jdbc之前先要了解一下什么是jdbc? 它有什么用？具体的功能是什么？JDBC全称：Java DataBase Connectivity；是java数据库连接，是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，例如：MySQL、Oracle、SQLServer等数据库；它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口...
MYSQL
maoqiwei的博客
07-23 278
1.修改student 表中年龄(sage)字段属性，数据类型由int 改变为smallint 2.为Course表中Cno 课程号字段设置索引,并查看索引 3.为SC表建立按学号(sno)和课程号(cno)组合的升序的主键索引，索引名为SC_INDEX4.创建一视图 stu info,查询全体学生的姓名，性别，课程名，成绩5.删除所有索引
《MySQL DBA 修炼之道》第四章 开发进阶
最新发布
Trishia的博客
07-25 577
博主学习《MySQL DBA 修炼之道》结合自身理解的总结。主要讲解了范式、反范式、慢SQL查询、事务和锁等。
MySQL字段设置的varchar长度小于数据长度自动截取丢弃超出的长度而不是报错？
weixin_43831997的博客
07-23 382
当MySQL数据库设置为==严格模式（STRICT_TRANS_TABLES 或 STRICT_ALL_TABLES）==时，如果尝试插入或更新超过设定长度的数据，将会导致错误，并阻止该事务进行。在默认情况下，或者在非严格模式（NO_STRICT）下，当插入长度超出 VARCHAR 字段定义的字符串时，MySQL会自动截断超出的部分，并发出一个警告，而不是错误。
MySql 主从同步会不会影响到SQL执行速度？
weixin_44892327的博客
07-24 800
作用：负责将主库的二进制日志（binary log）数据传输到从库。工作方式：当从库连接到主库时，主库会为每个连接的从库开启一个 Binlog Dump 线程。这个线程从主库的二进制日志中读取日志记录，并将其发送给从库。Binlog Dump 线程：将二进制日志传输给从库。Binlog Dump GTID 线程（在启用 GTID 模式时）：处理 GTID 相关的复制任务。
MySQL中的CREATE EVENT 语句详解
u011565038的博客
07-24 559
CREATE EVENT语句在 MySQL 中用于创建一个事件调度器（Event Scheduler）的事件。事件调度器允许你安排数据库任务（如查询、数据更新等）在将来的某个时间点自动执行，或者根据特定的时间间隔重复执行。这对于需要定期执行的任务特别有用，比如数据清理、报表生成等。
Spring JDBC封装详解：数据源与持久层操作
"Spring的持久层封装主要涉及如何在Spring框架中管理和使用数据源，以及与各种持久层技术如Hibernate、iBatis等集成。本文档将详细介绍Spring在持久层的配置和使用，包括数据源的注入和选择合适的持久层解决方案。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值