（六）JDBC学习笔记——自定义JDBC框架

最新推荐文章于 2021-06-01 17:33:53 发布
最新推荐文章于 2021-06-01 17:33:53 发布
阅读量417 收藏 3
点赞数 1
分类专栏： # JDBC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mbytes/article/details/115017156
版权

文章目录


现在学习的是如何在上一章的工具类基础上再次将相同的功能抽象出来。例如，每次执行SQL语句时都需要预编译SQL语句、获得返回集等等，能否将这些功能封装到一起，将不同的SQL语句（增删改）都封装到一起，传入的参数数目不同也可以调用同一个方法进行UPDATE操作；或者是将查询的SELECT语句封装到一个方法中，不管传入需要查询的参数有多少，都可以调用同一个方法。

一、数据库源信息介绍

1.数据库的源信息：DataBaseMetaData

  • java.sql.DataBaseMetaData：封装了整个数据库的综合信息
  • 例如：
    • String getDatabaseProductName()：获取数据库产品的名称
    • int getDatabaseProductVersion()：获取数据库产品的版本号

2.参数的源信息：ParameterMetaData

  • java.sql.ParameterMetaData：封装的是预编译执行者对象中每个参数的类型和属性
  • 这个对象可以通过预编译执行者对象中的getParameterMetaData()方法来获取
  • 核心功能：int getParameterCount()：获取sql语句中参数的个数

3.结果集的源信息：ResultSetMetaData

  • java.sql.ResultSetMetaData：封装的是结果集对象中列的类型和属性
  • 这个对象可以通过结果集对象中的getMetaData()方法来获取
  • 核心功能：
    • int getColumnCount()：获取列的总数
    • String getColumnName(int i)：获取列名

二、自定义JDBC框架

1.将增删改功能抽象为模板

主要分为以下步骤：

  1. 定义所需的成员变量，如数据源、数据库连接、执行者、结果集等；
  2. 定义有参构造函数，为数据源对象赋值；
  3. 定义update()方法，封装增删改功能，形参为SQL语句和语句中占位参数；
  4. 定义int变量，接收SQL语句执行后影响的行数；
  5. 通过数据源获取到一个数据库连接；
  6. 通过数据库连接对象获取执行者对象并对SQL语句预编译。
  7. 通过执行者对象获取参数源信息对象
  8. 拿到参数源信息，获得sql语句中参数的个数
  9. 判断参数数量是否一致
  10. 给？占位符赋值
  11. 执行SQL语句进行增删改
  12. 返回影响行数

代码如下：

package org.example5;
import javax.sql.DataSource;
import java.sql.*;

public class JDBCTemplate {
    //1.定义所需的成员变量，如数据源、数据库连接、执行者、结果集等；
    private DataSource dataSource;
    private Connection connection;
    private PreparedStatement pst;
    private ResultSet resultSet;
    //2. 定义有参构造函数，为数据源对象赋值；
    public JDBCTemplate(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    //4. 定义int变量，接收SQL语句执行后影响的行数；
    int res = 0;
    //3. 定义update()方法，封装 增删改 功能，形参为SQL语句和语句中占位参数；
    public int update(String sql,Object...objs){
        try {
            //5. 通过数据库连接池对象，获取到一个数据库连接对象；
            connection = dataSource.getConnection();
            //6. 通过数据库连接对象,获取执行者对象,并对SQL语句预编译。
            pst = connection.prepareStatement(sql);
            //7.通过执行者对象获取参数源信息对象
            ParameterMetaData parameterMetaData = pst.getParameterMetaData();
            //8.拿到参数源信息，获得sql语句中参数的个数
            int count = parameterMetaData.getParameterCount();
            //9.判断参数数量是否一致
            if (count != objs.length) throw new RuntimeException("参数个数不匹配!");
            //10.给？占位符赋值
            for (int i = 0; i < objs.length; i++) {
                pst.setObject(i+1, objs[i]);//给任意类型字段赋值
            }
            //11.执行SQL语句进行增删改
            res = pst.executeUpdate();
        } catch (Exception throwables) {
            throwables.printStackTrace();
        }finally {
            DataSourceUtils.close(connection, pst);
        }
        //12.返回影响行数
        return res;
    }
}

进行增删改的测试类：JDBCTemplateTest

package org.example5;
import org.junit.Test;

public class JDBCTemplateTest {
    private JDBCTemplate template = new JDBCTemplate(DataSourceUtils.getDataSource());
    @Test
    public void insert(){
        //新增数据
        String sql = "INSERT INTO student VALUES (?,?,?,?)";
        Object[] params = {5, "小黄", 12, "1995-02-02"};
        int result = template.update(sql, params);

        if(result != 0) System.out.println("添加成功！");
        else System.out.println("添加失败");
    }
    @Test
    public void update(){
        String sql = "UPDATE student SET age=? WHERE name=?";
        Object[] params = {22, "小黄"};
        if(template.update(sql, params) != 0) System.out.println("修改成功！");
        else System.out.println("修改失败！");
    }
    @Test
    public void delete(){
        String sql = "DELETE FROM student WHERE name=?";
        if(template.update(sql, "小黄") != 0) System.out.println("删除成功！");
        else System.out.println("删除失败！");
    }
}

2.将查询功能抽象为模板

因为查询功能过于复杂，所以单独将查询抽象为模板框架。
用于执行查询功能的方法有：

  1. 查询一条记录并封装为对象的方法：queryForObject()
  2. 查询多条记录并封装为集合的方法：queryForList()
  3. 查询聚合函数并返回单条数据的方法：queryForScalar()
  • 首先，根据表中的列信息，编写实体类，提供成员变量，且成员变量的数据类型须与表中的列的数据类型保持一致。
  • 编写用于处理结果集的接口，此接口仅用于为处理不同结果集的方式提供规范，具体实现类再自行实现。
    • 定义泛型接口ResultSetHandler；
    • 定义用于处理结果集的泛型方法 T handler(ResultSet rs)。

准备

首先定义Student类，包含表中的所有字段信息，创建set和get方法，重写toString()方法，便于打印查看。

2.1 查询表中的一条记录并封装为对象的方法

  • 实现类1：查询一条记录，封装为Student对象返回——BeanHandler
    1. 定义一个类，实现ResultSetHandler接口
    2. 定义Class对象类型变量
    3. 通过有参构造飞变量赋值
    4. 重写handler方法，用于将一条记录封装到自定义对象中
    5. 声明自定义对象类型
    6. 创建传递参数的对象，为自定义对象赋值
    7. 判断结果集中是否有数据
    8. 通过结果集对象获取结果集源信息的对象
    9. 通过结果集源信息对象获取列数
    10. 通过循环遍历列数
    11. 通过结果集源信息对象获取列名
    12. 通过列名获取该列数数
    13. 创建属性描述其对象，将获取到的值通过该对象的set方法进行赋值
    14. 返回封装好的对象

代码如下：

package org.example5.handler;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
//-------实现类1：查询一条记录，封装为Student对象返回
//1.定义一个类，实现ResultSetHandler接口
public class BeanHandler<T> implements ResultSetHandler<T>{
    //2.定义Class对象类型变量
    private Class<T> beanClass;
    //3.通过有参构造为变量赋值
    public BeanHandler(Class<T> beanClass) {
        this.beanClass = beanClass;
    }

    //4.重写handler方法，用于将一条记录封装到自定义对象中
    @Override
    public <T> T handler(ResultSet rs) {
        //5.声明自定义对象类型
        T bean = null;
        try {
            //6.创建传递参数的对象，为自定义对象赋值
            bean = (T) beanClass.newInstance();
            //7.判断结果集中是否有数据
            if (rs.next()){
                //8.通过结果集对象获取结果集源信息的对象
                ResultSetMetaData metaData = rs.getMetaData();
                //9.通过结果集源信息对象获取列数
                int count = metaData.getColumnCount();
                //10.通过循环遍历列数
                for (int i = 1; i <= count; i++) {
                    //11.通过结果集源信息对象获取列名
                    String columnName = metaData.getColumnName(i);
                    //12.通过列名获取该列数据
                    Object value = rs.getObject(columnName);
                    //13.创建"属性描述器对象"，将获取到的值通过该对象的set方法进行赋值
                    PropertyDescriptor pd = new PropertyDescriptor(columnName, beanClass);
                    //获取set方法
                    Method writeMethod = pd.getWriteMethod();
                    //执行set方法，给成员变量赋值
                    writeMethod.invoke(bean, value);
                }
                //14.返回封装好的对象
                return bean;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

在JDBCTemplate类中编写：查询一条记录并封装为对象的方法：

//查询1：将一条记录封装成自定义对象返回
    public <T> T queryForObject(String sql, ResultSetHandler<T> rsh, Object...objs){
        T obj = null;
        try {
            //通过数据库连接池对象，获取到一个数据库连接对象；
            connection = dataSource.getConnection();
            //通过数据库连接对象,获取执行者对象,并对SQL语句预编译。
            pst = connection.prepareStatement(sql);
            //通过执行者对象获取参数源信息对象
            ParameterMetaData parameterMetaData = pst.getParameterMetaData();
            //拿到参数源信息，获得sql语句中参数的个数
            int count = parameterMetaData.getParameterCount();
            //判断参数数量是否一致
            if (count != objs.length) throw new RuntimeException("参数个数不匹配!");
            //给？占位符赋值
            for (int i = 0; i < objs.length; i++) {
                pst.setObject(i+1, objs[i]);//给任意类型字段赋值
            }
            //执行SQL语句进行查询
            resultSet = pst.executeQuery();
            //通过beanHandler对结果进行处理
            obj = rsh.handler(resultSet);
        } catch (Exception throwables) {
            throwables.printStackTrace();
        }finally {
            DataSourceUtils.close(connection, pst);
        }
        //返回对象
        return obj;
    }

2.2 查询表中的多条记录并封装为对象，加入list的方法

BeanListHandler

package org.example5.handler;

import org.example5.domain.Student;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;

//-------实现类2：查询多条记录，封装为Student对象并添加到集合，返回list
//1.定义一个类，实现ResultSetHandler接口
public class BeanListHandler<T> implements ResultSetHandler<T>{
    //2.定义Class对象类型变量
    private Class<T> beanClass;
    //3.通过有参构造为变量赋值
    public BeanListHandler(Class<T> beanClass) {
        this.beanClass = beanClass;
    }

    //4.重写handler方法，用于将多条记录封装到自定义对象中并添加到list中返回
    @Override
    public List<T> handler(ResultSet rs) {
        //5.声明集合对象类型
        List<T> list = new ArrayList<>();
        try {
            //7.判断结果集中是否还有数据
            while (rs.next()){
                //6.创建传递参数的对象，为自定义对象赋值
                T bean = (T) beanClass.newInstance();
                //8.通过结果集对象获取结果集源信息的对象
                ResultSetMetaData metaData = rs.getMetaData();
                //9.通过结果集源信息对象获取列数
                int count = metaData.getColumnCount();
                //10.通过循环遍历列数
                for (int i = 1; i <= count; i++) {
                    //11.通过结果集源信息对象获取列名
                    String columnName = metaData.getColumnName(i);
                    //12.通过列名获取该列数据
                    Object value = rs.getObject(columnName);
                    //13.创建"属性描述器对象"，将获取到的值通过该对象的set方法进行赋值
                    PropertyDescriptor pd = new PropertyDescriptor(columnName, beanClass);
                    //获取set方法
                    Method writeMethod = pd.getWriteMethod();
                    //执行set方法，给成员变量赋值
                    writeMethod.invoke(bean, value);
                }
                //将对象添加到list
                list.add(bean);

            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        //14.返回封装好的对象
        return list;
    }
}

在JDBCTemplate类中编写：查询多条记录并封装为对象加入list的方法：

//查询2：将多条记录封装成自定义对象，添加到list再返回
    public <T> List<T> queryForList(String sql, ResultSetHandler<T> rsh, Object...objs){
        List<T> list = new ArrayList<>();
        try {
            //通过数据库连接池对象，获取到一个数据库连接对象；
            connection = dataSource.getConnection();
            //通过数据库连接对象,获取执行者对象,并对SQL语句预编译。
            pst = connection.prepareStatement(sql);
            //通过执行者对象获取参数源信息对象
            ParameterMetaData parameterMetaData = pst.getParameterMetaData();
            //拿到参数源信息，获得sql语句中参数的个数
            int count = parameterMetaData.getParameterCount();
            //判断参数数量是否一致
            if (count != objs.length) throw new RuntimeException("参数个数不匹配!");
            //给？占位符赋值
            for (int i = 0; i < objs.length; i++) {
                pst.setObject(i+1, objs[i]);//给任意类型字段赋值
            }
            //执行SQL语句进行查询
            resultSet = pst.executeQuery();
            //通过beanListHandler对结果进行处理
            list = rsh.handler(resultSet);
        } catch (Exception throwables) {
            throwables.printStackTrace();
        }finally {
            DataSourceUtils.close(connection, pst);
        }
        //返回list
        return list;
    }

2.3 将聚合函数的查询结果返回的方法

ScalarHandler

package org.example5.handler;

import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
//1.定义一个类，实现ResultSetHandler接口
//2.重写handler方法
//3.定义一个Long类型变量
//4.判断结果集对象中是否还有数据
//5.获取结果集源信息的对象
//6.获取第一列的列名
//7.根据列名获取该列的值
//8.返回结果

//1.定义一个类，实现ResultSetHandler接口
public class ScalarHandler<T> implements ResultSetHandler {
    //2.重写handler方法
    @Override
    public Long handler(ResultSet rs) {
        //3.定义一个Long类型变量
        Long value = null;
        //4.判断结果集对象中是否还有数据
        try {
            if (rs.next()){
                //5.获取结果集源信息的对象
                ResultSetMetaData metaData = rs.getMetaData();
                //6.获取第一列的列名
                String columnName = metaData.getColumnName(1);
                //7.根据列名获取该列的值
                value = rs.getLong(columnName);
            }
        } catch (Exception throwables) {
            throwables.printStackTrace();
        }
        //8.返回结果
        return value;
    }
}

在JDBCTemplate类中编写：将聚合函数的查询结果返回的方法：

//查询3：将聚合函数的查询结果返回
    public Long queryForScalar(String sql, ResultSetHandler<Long> rsh, Object...objs){
        Long value = null;
        try {
            //通过数据库连接池对象，获取到一个数据库连接对象；
            connection = dataSource.getConnection();
            //通过数据库连接对象,获取执行者对象,并对SQL语句预编译。
            pst = connection.prepareStatement(sql);
            //通过执行者对象获取参数源信息对象
            ParameterMetaData parameterMetaData = pst.getParameterMetaData();
            //拿到参数源信息，获得sql语句中参数的个数
            int count = parameterMetaData.getParameterCount();
            //判断参数数量是否一致
            if (count != objs.length) throw new RuntimeException("参数个数不匹配!");
            //给？占位符赋值
            for (int i = 0; i < objs.length; i++) {
                pst.setObject(i+1, objs[i]);//给任意类型字段赋值
            }
            //执行SQL语句进行查询
            resultSet = pst.executeQuery();
            //通过ScalarHandler对结果进行处理
            value = rsh.handler(resultSet);
        } catch (Exception throwables) {
            throwables.printStackTrace();
        }finally {
            DataSourceUtils.close(connection, pst);
        }
        //返回
        return value;
    }

最后，在进行增删改的测试类——JDBCTemplateTest中编写测试以上三种查询的语句：

	//下面是查询一条的函数
    @Test
    public void query(){
        String sql = "SELECT * FROM student WHERE sid=?";
        Student stu = template.queryForObject(sql, new BeanHandler<>(Student.class),1);
        System.out.println(stu);
    }

    //下面是查询所有的函数
    @Test
    public void queryList(){
        String sql = "SELECT * FROM student";
        List<Student> stuList = template.queryForList(sql, new BeanListHandler<>(Student.class));
        System.out.println(stuList.size());
        for(Student stu : stuList) System.out.println(stu);
    }

    //下面是查询聚合函数的函数
    @Test
    public void queryScalar(){
        String sql = "SELECT COUNT(*) FROM student";
        Long value = template.queryForScalar(sql, new ScalarHandler<Long>());
        System.out.println(value);
    }
MegaBytes
关注
专栏目录
Spring 坑路5 -> 封装自定义 JDBC 模版
simple的博客
06-01 857
在上一篇文章中提到了 JDBC 模版语法的基本使用，现在在数据库中多加一个表： 表结构为： 表数据为： pom.xml，springConfig.xml 与上文一样，文件结构如下： BookVO 的代码如下： package springjdbc.vo; public class BookVO { private Integer id; private St...
动力节点全新升级版MybatisPlus教程学习笔记——入门篇
ewertyucf的博客
04-12 1913
MyBatis-Plus（简称 MP）是一个 MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。愿景我们的愿景是成为 MyBatis 最好的搭档，就像魂斗罗中的 1P、2P，基友搭配，效率翻倍。
【总结】编写自己的JDBC框架
weixin_34018169的博客
07-18 160
一、数据库连接池：  　　在一般用JDBC 进行连接数据库进行CRUD操作时，每一次都会： 　　　　通过：java.sql.Connection conn = DriverManager.getConnection(url,user,password); 重新获取一个数据库的链接再进行操作，这样用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。 ...
JDBC自定义框架
QAQiiii的博客
08-11 1603
用到的连接池:druid-1.0.9.jar Druid是阿里巴巴开发的号称为监控而生的数据库连接池，Druid是目前最好的数据库连接池。在功能、性能、扩 展性方面，都超过其他数据库连接池，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况。 Druid下载地址:https://github.com/alibaba/druid 提前写好的JdbcUtils类 package com.e...
自定义JDBC框架
hongcaixia的博客
01-03 1342
自定义JDBC框架 连接数据库的工具类(数据源)： DBCPUtils: package com.heima.utils; import java.awt.image.DataBuffer; import java.io.IOException; import java.io.InputStream; import java.sql.Connection; import java.sql.
JDBC 学习笔记（四）—— 自定义JDBC框架+Apache—DBUtils框架+事务管理+操作多表...
Even2012的专栏
06-15 347
    本文查阅方法：    1、查阅目录 —— 查阅本文目录，确定想要查阅的目录标题    2、快捷“查找” —— 在当前浏览器页面，按键 “Ctrl+F” 按键组合，开启浏览器的查找功能，             在查找搜索框中 输入需要查阅的 目录标题，便可以直接到达 标题内容 的位置。    3、学习小结 —— 文中的学习小结内容，是笔者在学习之后总结出的，开发时可直接参考其进行应...
Java JDK 6学习笔记——ppt简体版
10-01
Java JDK 6学习笔记——PPT简体版是针对初学者和有经验的开发者们的一份宝贵资源，它深入浅出地介绍了Java编程语言的核心概念和技术。这份笔记以PPT的形式呈现，使得学习过程更加直观易懂，适合课堂教学或自我学习。...
JDK 6学习笔记——PPT简体版
05-26
**JDK 6学习笔记——PPT简体版** Java Development Kit（JDK）是Java编程语言的核心组件，它提供了开发和运行Java应用程序所需的工具和环境。JDK 6是Oracle公司发布的一个重要版本，为开发者带来了许多改进和新特性...
java框架学习笔记spring笔记
最新发布
12-19
5. **数据访问集成**：Spring 支持多种数据访问技术，如 JDBC、Hibernate、MyBatis 等 ORM（Object-Relational Mapping）框架，提供了事务管理、数据源配置等功能，简化了数据库操作。 6. **Spring Boot**：随着...
JDBC框架
。。。
04-20 2528
在实际的开发中，如果直接使用JDBC开发，是非常繁琐且麻烦的，所以现在的企业在开发web程序时，连接数据库一定会使用一些JDBC的框架。 在学习框架之前，得先掌握一些基础知识。 JDBC元数据(编写JDBC框架的基础) 首先就来学习一下JDBC元数据。 元数据就是数据库、表、列的定义信息。 元数据相关类(DataBaseMetaData)，可以通过Connetion接口中的getMetaDat...
JDBC数据库连接框架
05-10
在eclipse上用Java语言进行项目开发时用到的一个JDBC框架，用于连接数据库。可以解压之后找到里面的数据库驱动信息，把数据库名和密码换成自己的，就可以重新打包放进eclipse里面用。
自定义一个jdbc框架
weixin_34126215的博客
12-18 67
2019独角兽企业重金招聘Python工程师标准>>> ...
自定义jdbc框架
weixin_30438813的博客
09-15 73
获取元数据 元数据－ DataBaseMetaData 　　　　DatabaseMetaData meta = con.getMetaData(); getDatabaseProductName()、getDatabaseMajorVersion()、 getDatabaseProductVersion()、getDriverName(...
javaweb学习总结(四十)——编写自己的JDBC框架
weixin_34040079的博客
10-19 118
一、元数据介绍 　　元数据指的是"数据库"、"表"、"列"的定义信息。 1.1、DataBaseMetaData元数据 　　Connection.getDatabaseMetaData()获得代表DatabaseMetaData元数据的DatabaseMetaData对象。　　DataBaseMetaData对象的常用方法： getURL()：返回一个String类对象，代表数据库的U...
JDBC-06-笔记
qq_24410589的博客
06-01 332
JDBC框架（JDBCTemplate） 1. 分析前一天案例中的重复代码 2. 自定义JDBC框架 2.1 数据库的源信息 2.2 JDBCTemplate类增删改功能的编写 2.3 JDBCTemplate类查询功能的编写 2.4 测试自定义JDBC框架的使用 JDBC框架（JDBCTemplate） 1. 分析前一天案例中的重复代码 dao层的重复代码 定义必要的信息、获取数据库的连接、释放资源都是重复的代码！ 而我们最终的核心功能仅仅只是执行一条sql语句而已啊！ 所以我们可以抽取出一个JDBC模板
自定义JdbcTemplet,自定义JDBC框架,实现基本功能.包括连接池
佐月儿
11-04 255
本文运用到的技术和思想有:反射, 动态代理, 策略模式等 package com.zuoyueer.util; import java.io.InputStream; import java.sql.*; import java.util.List; import java.util.Properties; /** * @author Zuoyueer * Date: 2019/11/4...
java自定义jdbc,Java自定义jdbc连接池
weixin_29216957的博客
03-10 155
获取连接工具类：package com.itest;import java.sql.*;public class JdbcUtils {//获得连接public static Connection getConnection() throws Exception {Class.forName("com.mysql.jdbc.Driver");Connection con = DriverManag...
JDBC
Major_S的博客
11-05 277
JDBC
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值