4.JDBC高级之JDBC框架

4.自定义JDBC框架

4.1 框架的背景

定义必要的信息、获取数据库连接、释放资源时重复的代码，而我们最终的核心功能仅仅只是执行一条sql语句，所以我们可以抽取一个JDBC模板类，来封装一些方法（update，query），专门帮我们执行增删改查的sql语句。将之前那些重复的操作，都抽取到模板类的方法里，就能大大简化我们的使用步骤。

4.2 源信息

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

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

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

4.3 框架的编写

4.3.1 用于执行增删改功能的update()方法

① 定义所需要成员变量（数据源、数据库连接、执行者、结果集）
② 定义有参构造，为数据源对象赋值
③ 定义update()方法，参数：sql语句、sql语句所需参数
④ 定义int类型变量，用于接受sql语句执行后影响的行数
⑤ 通过数据源获取一个数据库连接
⑥ 通过数据库连接对象获取执行者对象并对sql语句预编译
⑦ 通过执行者对象获取sql语句中参数的源信息对象
⑧ 通过数据源信息对象获取sql语句中参数的个数
⑨ 判断参数个数是否一致
⑩ 为sql语句中?占位符赋值
11 执行sql语句并接受结果
12 释放资源
13 返回结果

package jdbc04;

import druid.DataSourceUtils;

import javax.sql.DataSource;
import java.sql.*;

/*
* JDBC框架类
* */
public class JDBCTemplate {
    //1 定义所需要成员变量（数据源、数据库连接、执行者、结果集）
    private DataSource dataSource;
    private Connection con;
    private PreparedStatement pst;
    private ResultSet rs;

    //2 定义有参构造，为数据源对象赋值
    public JDBCTemplate(DataSource dataSource){
        this.dataSource = dataSource;
    }

    //3 定义update()方法，参数：sql语句、sql语句所需参数
    public int update(String sql,Object...objs){
        //4 定义int类型变量，用于接受sql语句执行后影响的行数
        int result = 0;

        try {
            //5 通过数据源获取一个数据库连接
            con = dataSource.getConnection();

            //6 通过数据库连接对象获取执行者对象并对sql语句预编译
            pst = con.prepareStatement(sql);

            //7 通过执行者对象获取sql语句中参数的源信息对象
            ParameterMetaData parameterMetaData = pst.getParameterMetaData();

            //8 通过数据源信息对象获取sql语句中参数的个数
            int count = parameterMetaData.getParameterCount();

            //9 判断参数个数是否一致
            if(count != objs.length){
                throw new RuntimeException("参数个数不匹配");
            }
            //10 为sql语句中?占位符赋值
            for (int i = 0;i < objs.length;i++) {
                pst.setObject(i+1,objs[i]);
            }

            //11 执行sql语句并接受结果
            result = pst.executeUpdate();

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //12 释放资源
            DataSourceUtils.close(con,pst);
        }

        //13 返回结果
        return result;
    }
}

测试：

package jdbc04;

import druid.DataSourceUtils;
import org.junit.Test;
/*
    模拟dao层
*/
public class JDBCTemplateTest1 {
    private JDBCTemplate template = new JDBCTemplate(DataSourceUtils.getDataSource());
    @Test
    public void insert(){
        //新增或数据测试
        String sql = "insert into student values(?,?,?,?)";
        Object[] params = {10,"周周",27,"1997-07-07"};

        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 = {37,"周周"};

        int result = template.update(sql,params);
        System.out.println(result);
    }

    @Test
    public void delete(){
        //删除数据的测试
        String sql="delete from student where name=?";
        int result = template.update(sql,"周周");
        System.out.println(result);
    }
}

4.3.2 用于查询的方法

用于执行查询功能的方法介绍

• 查询一条记录并封装对象的方法：queryForObject()
• 查询多条记录并封装集合的方法：queryForList()
• 查询聚合函数并返回单条数据的方法：queryForScalar()

1）实体类的编写
定义一个类，提供一些成员变量

注意：成员变量的数据类型和名称要和表中的列保持一致。

package jdbc04.domain;

import java.util.Date;

/*
* 学生的实体类
* */
public class Student {
    private Integer sid;
    private String name;
    private Integer age;
    private Date birthday;

    public Student(){}

    public Student(Integer sid, String name, Integer age, Date birthday) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public Integer getSid() {
        return sid;
    }

    public void setSid(Integer sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", birthday=" + birthday +
                '}';
    }
}

2）处理结果集的接口
① 定义泛型接口ResultSetHandler
② 定义用于处理结果集的泛型方法 T handler(ResultSet rs)

注意：此接口仅用于为不同处理结果集的方法提供规范，具体的实现类还需要自行编写

package jdbc04.handler;

import java.sql.ResultSet;

/*
* 用于处理结果集方式的接口
* */
public interface ResultSetHandler<T>{
    <T> T handler(ResultSet rs);
}

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

package jdbc04.handler;

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

//    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 handler(ResultSet rs) {
//        5.声明自定义对象类型
        T bean = null;

        try {
//            6.创建传递参数的对象，为自定义对象赋值
            bean = 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.toLowerCase(), beanClass);
//                    获取set方法
                    Method writeMethod = pd.getWriteMethod();
//                    执行set方法，给成员变量赋值
                    writeMethod.invoke(bean,value);

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

4）用于查询一条记录并封装对象的方法queryForObject()
1.定义方法queryForObject()，参数：sql语句、处理结果集接口、sql语句中的参数
2.声明自定义对象
3.通过数据源获取数据库连对象
4.通过数据库对象获取执行者对象并对sql语句进行预编译
5.通过执行者对象获取参数源信息的对象
6.通过参数源信息对象获取参数的个数
7.判断参数量是否一致
8.为sql语句中?占位符赋值
9.执行sql语句并接受结果集
10.通过结果集接口对结果集进行处理
11.释放资源
12.返回结果

在JDBCTemplate中添加

    /*
    * 查询方法：用于将单条记录封装成自定义对象并返回
    * */
    public <T> T queryForObject(String sql, ResultSetHandler<T> rsh,Object...objs){
//        2.声明自定义对象
        T obj = null;

        try {
            //3 通过数据源获取一个数据库连接
            con = dataSource.getConnection();

            //4 通过数据库连接对象获取执行者对象并对sql语句预编译
            pst = con.prepareStatement(sql);

            //5 通过执行者对象获取sql语句中参数的源信息对象
            ParameterMetaData parameterMetaData = pst.getParameterMetaData();

            //6 通过数据源信息对象获取sql语句中参数的个数
            int count = parameterMetaData.getParameterCount();

            //7 判断参数个数是否一致
            if(count != objs.length){
                throw new RuntimeException("参数个数不匹配");
            }
            //8 为sql语句中?占位符赋值
            for (int i = 0;i < objs.length;i++) {
                pst.setObject(i+1,objs[i]);
            }

            //9 执行sql语句并接受结果
            rs = pst.executeQuery();

//            10 通过结果集接口对结果集进行处理
            obj = rsh.handler(rs);

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //11 释放资源
            DataSourceUtils.close(con,pst);
        }

        //12.返回结果
        return obj;
    }

测试(JDBCTemplateTest1中)

    @Test
    public void queryForObject(){
        String sql = "select * from student where sid=?";
        Student stu = template.queryForObject(sql, new BeanHandler<>(Student.class), 1);
        System.out.println(stu);
    }

5）处理结果集的接口实现类2
1.定义BeanListHandler类事项ResultSetHandler接口
2.定义Class对象类型变量
3.通过有参构造为变量赋值
4.重写handler方法。用于将多条记录封装到自定义对象中并添加到集合中返回
5.创建List集合对象
6.遍历结果集对象
7.创建传递参数的对象
8.通过结果集对象获取结果集源信息的对象
9.通过结果集源信息对象获取列数
10.通过循环遍历列数
11.通过结果集源信息对象获取列名
12.通过列名获取该列的数据
13.创建属性描述器对象，将获取到的值通过该对象的set方法进行赋值
14.返回封装好的对象到集合中
15.返回集合对象

package jdbc04.handler;

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;

//1.定义BeanListHandler<T>类事项ResultSetHandler<T>接口
public class BeanListHandler<T> implements ResultSetHandler<T>{
    //    2.定义Class对象类型变量
    private Class<T> beanClass;

    //    3.通过有参构造为变量赋值
    public BeanListHandler(Class<T> beanClass){
        this.beanClass = beanClass;
    }

    //    4.重写handler方法。用于将多条记录封装到自定义对象中并添加到集合中返回
    @Override
    public List<T> handler(ResultSet rs) {
//        5.创建List集合对象
        List<T> list = new ArrayList<>();

        try {
//            6 遍历结果集对象
            while(rs.next()){
//                7.创建传递参数的对象
                T bean = 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.toLowerCase(), beanClass);
//                   获取set方法
                    Method writeMethod = pd.getWriteMethod();
//                   执行set方法，给成员变量赋值
                    writeMethod.invoke(bean,value);

//                    14.返回封装好的对象到集合中
                }
                list.add(bean);
            }
        } catch ( Exception e) {
            e.printStackTrace();
        }
//        15.返回封装好的对象
        return list;
    }
}

6）用于查询多条记录并封装集合的方法queryForList()
1.定义方法queryForList()，参数：sql语句、处理结果集接口、sql语句中的参数
2.创建集合对象
3.通过数据源获取数据库连对象
4.通过数据库对象获取执行者对象并对sql语句进行预编译
5.通过执行者对象获取参数源信息的对象
6.通过参数源信息对象获取参数的个数
7.判断参数量是否一致
8.为sql语句中?占位符赋值
9.执行sql语句并接受结果集
10.通过结果集接口对结果集进行处理
11.释放资源
12.返回结果

添加在JDBCTemplate中

    /*
     * 查询方法：用于将多条记录封装成自定义对象并返回
     * */
    public <T> List<T> queryForList(String sql, ResultSetHandler<T> rsh, Object...objs){
//        2.创建集合对象
        List<T> list = new ArrayList<>();

        try {
            //3 通过数据源获取一个数据库连接
            con = dataSource.getConnection();

            //4 通过数据库连接对象获取执行者对象并对sql语句预编译
            pst = con.prepareStatement(sql);

            //5 通过执行者对象获取sql语句中参数的源信息对象
            ParameterMetaData parameterMetaData = pst.getParameterMetaData();

            //6 通过数据源信息对象获取sql语句中参数的个数
            int count = parameterMetaData.getParameterCount();

            //7 判断参数个数是否一致
            if(count != objs.length){
                throw new RuntimeException("参数个数不匹配");
            }
            //8 为sql语句中?占位符赋值
            for (int i = 0;i < objs.length;i++) {
                pst.setObject(i+1,objs[i]);
            }

            //9 执行sql语句并接受结果
            rs = pst.executeQuery();

//            10 通过结果集接口对结果集进行处理
            list = rsh.handler(rs);

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //11 释放资源
            DataSourceUtils.close(con,pst);
        }

        //12.返回结果
        return list;
    }

测试（JDBCTemplateTest1中）

     @Test
    public void queryForList(){
        //查询所有学生信息的测试
        String sql = "select * from student";
        List<Student> list = template.queryForList(sql, new BeanListHandler<>(Student.class));
        for (Student stu : list) {
            System.out.println(stu);
        }
    }

7）处理结果集的接口实现类3
1.定义ScalarHandler类实现ResultSetHandler接口
2.重写handler()方法，用于返回一个聚合函数的查询结果
3.定义Long类型变量
4.判断结果集对象是否有数据
5.通过结果集对象获取结果集源信息的对象
6.通过结果集源信息对象获取第一列的列名
7.通过列名获取该列的数据
8.将结果返回

package jdbc04.handler;

import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;

//1.定义ScalarHandler<T>类实现ResultSetHandler<T>接口
public class ScalarHandler<T> implements ResultSetHandler<T>{

//    2.重写handler()方法，用于返回一个聚合函数的查询结果
    @Override
    public Long handler(ResultSet rs) {
//        3.定义Long类型变量
        Long value = null;

        try {
//            4.判断结果集对象是否有数据
            if(rs.next()){
//                5.通过结果集对象获取结果集源信息的对象
                ResultSetMetaData metaData = rs.getMetaData();

//                6.通过结果集源信息对象获取第一列的列名
                String columnName = metaData.getColumnName(1);

//                7.通过列名获取该列的数据
                value = rs.getLong(columnName);

            }
        } catch (Exception e) {
            e.printStackTrace();
        }

//        8.将结果返回
        return value;
    }
}

8）用于执行聚合函数sql语句的方法queryForScalar()
1.定义方法queryForScalar()，参数：sql语句、处理结果集接口、sql语句中的参数
2.创建Long类型变量
3.通过数据源获取数据库连对象
4.通过数据库对象获取执行者对象并对sql语句进行预编译
5.通过执行者对象获取参数源信息的对象
6.通过参数源信息对象获取参数的个数
7.判断参数量是否一致
8.为sql语句中?占位符赋值
9.执行sql语句并接受结果集
10.通过ScalarHandler对结果集进行处理
11.释放资源
12.返回结果

在JDBCTemplate中添加

/*
     * 查询方法：用于将聚合函数的查询结果进行返回
     * */
    public Long queryForScalar(String sql, ResultSetHandler<Long> rsh, Object...objs){
//        2.创建集合对象
        Long value = null;

        try {
            //3 通过数据源获取一个数据库连接
            con = dataSource.getConnection();

            //4 通过数据库连接对象获取执行者对象并对sql语句预编译
            pst = con.prepareStatement(sql);

            //5 通过执行者对象获取sql语句中参数的源信息对象
            ParameterMetaData parameterMetaData = pst.getParameterMetaData();

            //6 通过数据源信息对象获取sql语句中参数的个数
            int count = parameterMetaData.getParameterCount();

            //7 判断参数个数是否一致
            if(count != objs.length){
                throw new RuntimeException("参数个数不匹配");
            }
            //8 为sql语句中?占位符赋值
            for (int i = 0;i < objs.length;i++) {
                pst.setObject(i+1,objs[i]);
            }

            //9 执行sql语句并接受结果
            rs = pst.executeQuery();

//            10 通过ScalarHandler对结果集进行处理
            value = rsh.handler(rs);

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //11 释放资源
            DataSourceUtils.close(con,pst);
        }

        //12.返回结果
        return value;
    }

测试(JDBCTemplateTest1中)

    @Test
    public void queryForScalar(){
        //查询聚合函数的测试
        String sql = "select count(*) from student";
        Long value = template.queryForScalar(sql, new ScalarHandler<Long>());
        System.out.println(value);
    }