jdbc 使用数据源连接池技术升级 BaseDao

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql:///fruitdb
jdbc.user=root
jdbc.pwd=123456
jdbc.init_size=5
jdbc.max_active=20
jdbc.max_wait=3000

package com.csdn.mymvc.dao;
import com.alibaba.druid.pool.DruidDataSource;
import com.csdn.mymvc.util.ClassUtil;
import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
public abstract class BaseDao {

    private String entityClassName;

    public BaseDao() {
        // this 是谁？ this代表的是 FruitDaoImpl 的实例对象，因为 BaseDao是抽象类，不能直接创建对象，所以 new 的是它的子类对象 FruitDaoImpl
        // this.getClass() 获取的是 FruitDaoImpl 的Class对象
        // getGenericSuperclass() 获取到的是：BaseDao
        // Type 是顶层接口，表示所有的类型。它有一个子接口：ParameterizedType
        ParameterizedType genericSuperclass = (ParameterizedType) this.getClass().getGenericSuperclass();
        // Actual:实际的
        // getActualTypeArguments() 获取实际的类型参数
        Type[] actualTypeArguments = genericSuperclass.getActualTypeArguments();
        Type actualTypeArgument = actualTypeArguments[0];

        // System.out.println(actualTypeArgument.getTypeName());//com.csdn.fruit.pojo.Fruit

        entityClassName = actualTypeArgument.getTypeName();

        initDataSource();
    }

    private DataSource dataSource;

    //加载jdbc.properties文件
    private void initDataSource() {
        try {
            InputStream inputStream = getClass().getClassLoader().getResourceAsStream("jdbc.properties");
            Properties properties = new Properties();
            properties.load(inputStream);

            String driver = properties.getProperty("jdbc.driver", "com.mysql.cj.jdbc.Driver");
            String url = properties.getProperty("jdbc.url", "jdbc:mysql:///fruitdb");
            String user = properties.getProperty("jdbc.user", "root");
            String pwd = properties.getProperty("jdbc.pwd", "123456");
            Integer initSize = Integer.parseInt(properties.getProperty("jdbc.init_size", "5"));
            Integer maxActive = Integer.parseInt(properties.getProperty("jdbc.max_active", "10"));
            Integer maxWait = Integer.parseInt(properties.getProperty("jdbc.max_wait", "5000"));

            DruidDataSource druidDataSource = new DruidDataSource();

            druidDataSource.setDriverClassName(driver);
            druidDataSource.setUrl(url);
            druidDataSource.setUsername(user);
            druidDataSource.setPassword(pwd);
            druidDataSource.setInitialSize(initSize);
            druidDataSource.setMaxActive(maxActive);
            druidDataSource.setMaxWait(maxWait);

            dataSource = druidDataSource;


        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }

    private Connection getConn() throws SQLException {
            return dataSource.getConnection();
    }

    private void close(Connection conn, PreparedStatement psmt, ResultSet rs) {
        try {
            if (rs != null) {
                rs.close();
            }
            if (psmt != null) {
                psmt.close();
            }
            if (conn != null && !conn.isClosed()) {
                conn.close();
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    //抽取执行更新方法
    //执行更新，返回影响行数
    //如果是执行 insert，那么可以尝试返回自增列的值
    protected int executeUpdate(String sql, Object... params) {

        boolean insertFlag = sql.trim().toUpperCase().startsWith("INSERT");

        Connection conn = null;
        PreparedStatement psmt = null;
        try {
            conn = getConn();
            psmt = insertFlag ? conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS) : conn.prepareStatement(sql);

            setParams(psmt, params);

            int count = psmt.executeUpdate();

            if (insertFlag) {
                ResultSet rs = psmt.getGeneratedKeys();
                if (rs.next()) {
                    Long id = rs.getLong(1);
                    count = id.intValue();
                }
            }

            return count;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            close(conn, psmt, null);
        }
    }

    //设置参数
    private void setParams(PreparedStatement psmt, Object... params) throws SQLException {
        if (params != null && params.length > 0) {
            for (int i = 0; i < params.length; i++) {
                psmt.setObject(i + 1, params[i]);
            }
        }
    }

    //执行查询，返回集合
    protected List executeQuery(String sql, Object... params) {
        List list = new ArrayList<>();
        Connection conn = null;
        PreparedStatement psmt = null;
        ResultSet rs = null;

        try {
            conn = getConn();
            psmt = conn.prepareStatement(sql);
            setParams(psmt, params);
            rs = psmt.executeQuery();
            ResultSetMetaData rsmd = rs.getMetaData();//元数据,结果集的结构数据
            while (rs.next()) {
                //T t = new T();  T仅仅是一个符号，所以不能 new
                T t = (T) ClassUtil.createInstance(entityClassName);
                int columnCount = rsmd.getColumnCount();//获取结果集的列的数据
                //jdbc中都是从 1 开始，所以要把 i 改成 从 1 开始
                for (int i = 1; i <= columnCount; i++) {
                    //假设循环 5 次，得到 5 个值，应该对应的是一个对象的 5 个属性的值
                    String columnName = rsmd.getColumnLabel(i);
                    Object columnValue = rs.getObject(i);
                    //给 t 这个对象的 columnName 属性赋 columnValue 值
                    ClassUtil.setProperty(t, columnName, columnValue);
                }
                list.add(t);
            }
            return list;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            close(conn, psmt, rs);
        }
    }

    protected T load(String sql, Object... params) {

        Connection conn = null;
        PreparedStatement psmt = null;
        ResultSet rs = null;

        try {
            conn = getConn();
            psmt = conn.prepareStatement(sql);
            setParams(psmt, params);
            rs = psmt.executeQuery();
            ResultSetMetaData rsmd = rs.getMetaData();//元数据,结果集的结构数据
            if (rs.next()) {
                //T t = new T();  T仅仅是一个符号，所以不能 new
                T t = (T) ClassUtil.createInstance(entityClassName);
                int columnCount = rsmd.getColumnCount();//获取结果集的列的数据
                //jdbc中都是从 1 开始，所以要把 i 改成 从 1 开始
                for (int i = 1; i <= columnCount; i++) {
                    //假设循环 5 次，得到 5 个值，应该对应的是一个对象的 5 个属性的值
                    String columnName = rsmd.getColumnLabel(i);
                    Object columnValue = rs.getObject(i);
                    //给 t 这个对象的 columnName 属性赋 columnValue 值
                    ClassUtil.setProperty(t, columnName, columnValue);
                }
                return t;
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            close(conn, psmt, rs);
        }
        return null;
    }

    //select max(age) as max_age ,  avg(age)  as avg_age from t_user
    // 28               24.5

    //select deptNo,avg(sal)  as avg_sal  from emp  group by deptNo

    /**
     * d001       3500
     * d002       3650
     * d003       2998
     */
    protected List executeComplexQuery(String sql, Object... params) {
        List list = new ArrayList<>();
        Connection conn = null;
        PreparedStatement psmt = null;
        ResultSet rs = null;

        try {
            conn = getConn();
            psmt = conn.prepareStatement(sql);
            setParams(psmt, params);
            rs = psmt.executeQuery();
            ResultSetMetaData rsmd = rs.getMetaData();//元数据,结果集的结构数据
            while (rs.next()) {
                int columnCount = rsmd.getColumnCount();//获取结果集的列的数据
                Object[] arr = new Object[columnCount];
                //jdbc中都是从 1 开始，所以要把 i 改成 从 1 开始
                for (int i = 1; i <= columnCount; i++) {
                    Object columnValue = rs.getObject(i);
                    //数组从 0 开始，所以要减 1
                    arr[i - 1] = columnValue;
                }
                list.add(arr);
            }
            return list;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            close(conn, psmt, rs);
        }
    }
}

• 只有增删改查方法才去处理异常，其他的辅助性的方法都直接往外抛 ，因为这些方法将来都会在增删改查方法里面去调用

 

•  一旦我们用数据源连接池对象技术，这里的 conn.close() 就不是真正的关闭，而是把这个对象重新归还给池子，我们把这个称为面向对象的多态现象，说明他仅仅是把他的一个标签从正在使用设置为空闲，但是这个对象没有关闭，这个close()相当于是一个多态。

•  真正的实现类是DruidPooledConnection，德鲁伊池子的连接，下面是close方法的源码

    public void close() throws SQLException {
        if (!this.disable) {
            DruidConnectionHolder holder = this.holder;
            if (holder == null) {
                if (this.dupCloseLogEnable) {
                    LOG.error("dup close");
                }

            } else {
                DruidAbstractDataSource dataSource = holder.getDataSource();
                boolean isSameThread = this.getOwnerThread() == Thread.currentThread();
                if (!isSameThread) {
                    dataSource.setAsyncCloseConnectionEnable(true);
                }

                if (dataSource.isAsyncCloseConnectionEnable()) {
                    this.syncClose();
                } else if (CLOSING_UPDATER.compareAndSet(this, 0, 1)) {
                    try {
                        Iterator var4 = holder.getConnectionEventListeners().iterator();

                        while(true) {
                            if (!var4.hasNext()) {
                                List filters = dataSource.getProxyFilters();
                                if (filters.size() > 0) {
                                    FilterChainImpl filterChain = new FilterChainImpl(dataSource);
                                    filterChain.dataSource_recycle(this);
                                } else {
                                    this.recycle();
                                }
                                break;
                            }

                            ConnectionEventListener listener = (ConnectionEventListener)var4.next();
                            listener.connectionClosed(new ConnectionEvent(this));
                        }
                    } finally {
                        CLOSING_UPDATER.set(this, 0);
                    }

                    this.disable = true;
                }
            }
        }
    }