JDBC07-----代码重构之封装DBCUtils工具类

一. 代码重构原则

之前的DAO操作，除了sql语句和set值不一样，其它都一样，有太多的重复代码。因此需要重构。

重构代码原则：

二. 抽取DML方法

1. 具体抽取成executeUpdate方法在每一个dao实现中

/**
     * 重构DML操作
     */
    public int executeUpdate(String sql,Object...params) {
        Connection connection=null;
        PreparedStatement pStatement=null;
        
        try {
            //1.加载驱动
            //2.连接数据库
            connection=JDBCUtil.getConnection();
            //3.创建语句
            pStatement=connection.prepareStatement(sql);
            //4.遍历参数
            for(int i=0;i<params.length;i++) {
                pStatement.setObject(i+1, params[i]);
            }
            //4.执行语句
            return pStatement.executeUpdate();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            JDBCUtil.close(connection, pStatement, null);
        }
        return 0;
    }

    public void save(Stu stu) {
        String sql="insert into stu(name,age) values(?,?)";
        this.executeUpdate(sql,stu.getName(),stu.getAge());
    }

测试：

@Test
    public void testSave() {
        IStuDao dao=new StuDaoImpl();
        Stu stu=new Stu();
        stu.setName("hehe");
        stu.setAge(23);
        dao.save(stu);
    }

这样可以成功，但是倘若每个dao的实现类里面都写这个executeUpdate方法，还是有写多余，因此可以抽取到一个类中。如果放在JDBCUtil类中，也不好，因为JDBCUtil是直接和数据交互的，因此可以新建立一个类CRUDTemplate。

2. 抽取到CRUDTemplate中----最终抽取地方

public class CRUDTemplate {
    /**
     * 重构DML操作
     */
    public static int executeUpdate(String sql,Object...params) {
        Connection connection=null;
        PreparedStatement pStatement=null;
        
        try {
            //1.加载驱动
            //2.连接数据库
            connection=JDBCUtil.getConnection();
            //3.创建语句
            pStatement=connection.prepareStatement(sql);
            //4.遍历参数
            for(int i=0;i<params.length;i++) {
                pStatement.setObject(i+1, params[i]);
            }
            //4.执行语句
            return pStatement.executeUpdate();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            JDBCUtil.close(connection, pStatement, null);
        }
        return 0;
    }

}

public void save(Stu stu) {
        String sql="insert into stu(name,age) values(?,?)";
        CRUDTemplate.executeUpdate(sql,stu.getName(),stu.getAge());
    }

三. DQL抽取

1. DQL抽取

/**
     * DQL抽取
     */
    public static List<Stu> executeQuery(String sql,Object...params){
        Connection connection=null;
        PreparedStatement pStatement=null;
        ResultSet resultSet=null;
        //创建一个集合
        List<Stu> list=new ArrayList<Stu>();
        try {
            //1.加载驱动
            //2.连接数据库
            connection=JDBCUtil.getConnection();
            //3.创建语句
            pStatement=connection.prepareStatement(sql);
            //遍历参数
            for(int i=0;i<params.length;i++) {
                pStatement.setObject(i+1, params[i]);
            }
            //4.执行语句
            resultSet=pStatement.executeQuery();
            while(resultSet.next()) {
                Stu stu=new Stu();
                stu.setName(resultSet.getString("name"));
                stu.setAge(resultSet.getInt("age"));
                stu.setId(resultSet.getInt("id"));
                list.add(stu);
            }
            return list;
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            //5.释放资源
            JDBCUtil.close(connection, pStatement, resultSet);
        }
        return null;
    }

public Stu get(int id) {
        String sql="select *from stu where id=?";
        List<Stu> list=CRUDTemplate.executeQuery(sql, id);
        return list.size()==1?list.get(0):null;
    }
    

    public List<Stu> getAll() {
        String sql="select *from stu";
        return CRUDTemplate.executeQuery(sql);
    }

@Test
    public void testGet() {
        IStuDao dao=new StuDaoImpl();
        Stu student=dao.get(2);
        System.out.println(student);
        System.out.println(student.getName());
    }

    @Test
    public void testGetAll() {
        IStuDao dao=new StuDaoImpl();
        List<Stu> list=dao.getAll();
        System.out.println(list.toArray());
    }

2. 存在问题

上面的DQL抽取虽然简单了，但是还存在一个问题，那就是在while循环中，只操作了Stu这个表格，写死了，但是，当表格很多，不仅仅想让它适用于Stu表，还想使用更多的表，就需要额外处理。因此，表的类型处理应该放在executeQuery方法之外来执行。

四. 结果集处理代码实现

1. 定义一个结果集处理接口

package com.test.jdbctest.handler;

import java.sql.ResultSet;
import java.util.List;

public interface IResultSetHandler {
    List handle(ResultSet rs);

}

2. 在dao实现类中添加新的结果处理接口实现类

class StuResultSetHandImp implements IResultSetHandler{

    public List handle(ResultSet rs) {
        List<Stu> list=new ArrayList<Stu>();
        try {
            while(rs.next()) {
                Stu stu=new Stu();
                stu.setName(rs.getString("name"));
                stu.setAge(rs.getInt("age"));
                stu.setId(rs.getInt("id"));
                list.add(stu);
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return list;
    }



放在daoimpl类里面的末尾处

3. 修改template

/**
     * DQL抽取
     */
    public static List<Stu> executeQuery(String sql,IResultSetHandler handler,Object...params){
        Connection connection=null;
        PreparedStatement pStatement=null;
        ResultSet resultSet=null;
        //创建一个集合
        List list=new ArrayList();
        try {
            //1.加载驱动
            //2.连接数据库
            connection=JDBCUtil.getConnection();
            //3.创建语句
            pStatement=connection.prepareStatement(sql);
            //4.执行语句
            resultSet=pStatement.executeQuery();
            return handler.handle(resultSet);
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            //5.释放资源
            JDBCUtil.close(connection, pStatement, resultSet);
        }
        return null;
    }

4. 使用泛型

上面的结果集都是返回的list，但是有时候我们可能不仅仅是返回对象，有可能返回的是int的数量，比如查询共有多少行。因此，需要把返回类型改写成泛型，到时候调用的时候再决定返回什么类型。

（1）修改结果处理集接口

public interface IResultSetHandler<T> {
    T handle(ResultSet rs);

}

（2）修改实现

class StuResultSetHandImp implements IResultSetHandler<List<Stu>>{

    public List<Stu> handle(ResultSet rs) {
        List<Stu> list=new ArrayList<Stu>();
        try {
            while(rs.next()) {
                Stu stu=new Stu();
                stu.setName(rs.getString("name"));
                stu.setAge(rs.getInt("age"));
                stu.setId(rs.getInt("id"));
                list.add(stu);
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return list;
    }
    

（3）修改template

public static <T>T executeQuery(String sql,IResultSetHandler<T> handler,Object...params){
        Connection connection=null;
        PreparedStatement pStatement=null;
        ResultSet resultSet=null;
        try {
            //1.加载驱动
            //2.连接数据库
            connection=JDBCUtil.getConnection();
            //3.创建语句
            pStatement=connection.prepareStatement(sql);
            for(int i=0;i<params.length;i++) {
                pStatement.setObject(i+1, params[i]);
            }
            //4.执行语句
            resultSet=pStatement.executeQuery();
            return handler.handle(resultSet);
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            //5.释放资源
            JDBCUtil.close(connection, pStatement, resultSet);
        }
        return null;
    }

5. 存在问题

发现其实每个表格查询做的事情差不多，如果每一个表都建立一个handler，是不好的。因此，可以统一处理：

使用内省可以解决上面的问题。

五. 内省

 1. 内省的简单使用

假设有表stu，有id,name,age三个属性，且有对应的domain类

现在做如下操作：

class ClassTest{
    public Class class1;
    public ClassTest(Class class1) {
        this.class1=class1;
    }
}
public class Test {
    public static void main(String args[]) throws Exception {
        Stu stu=Stu.class.newInstance();
        //获取指定字节码的属性信息
        BeanInfo beanInfo=Introspector.getBeanInfo(Stu.class,Object.class);
        //获取所有的属性描述器
        PropertyDescriptor pds[]=beanInfo.getPropertyDescriptors();
        for(PropertyDescriptor pd:pds) {
            System.out.println(pd.getName());
            System.out.println(pd.getReadMethod());
            System.out.println(pd.getWriteMethod());
        }
        PropertyDescriptor propertyDescriptor=new PropertyDescriptor("name", Stu.class);
        System.out.println(propertyDescriptor.getName());
        propertyDescriptor.getWriteMethod().invoke(stu, "zhangsan");
        System.out.println(stu.getName());
    }

}

age
public java.lang.Integer com.test.jdbctest.domain.Stu.getAge()
public void com.test.jdbctest.domain.Stu.setAge(java.lang.Integer)
id
public java.lang.Integer com.test.jdbctest.domain.Stu.getId()
public void com.test.jdbctest.domain.Stu.setId(java.lang.Integer)
name
public java.lang.String com.test.jdbctest.domain.Stu.getName()
public void com.test.jdbctest.domain.Stu.setName(java.lang.String)
name
zhangsan

2. 内省应用于结果处理集

（1）创建一个BeanHandler

修改dao实现

（2）新建立BeanListHandler

因此，上面每个类一个handerl就改成了BeanHanler和BeanListHandler了

六. DBUtils

之前几个章节都是介绍的如何一步步实现我们自己的JDBC重构，且可以把我们自己写的转换成jar包，以便自己项目中使用。实际上，有很多第三方很好用的JDBC工具，DBUtils就是其中的一款，它为我们提供了调用接口，我们直接使用就好。但是，底层的原理其实和我们之前学习的重构思想也有相似之处。可以接下来研究下。

参考文献

https://ke.qq.com/course/339214