基于DBUtils的jdbc（BaseDao）工具类的封装

​​​​

• 实现数据库连接池的连接,并提供了简单事务的封装处理（保障开启事务，提交或者回滚的事务是同一个对象）

public class DBUtils {
    private static DataSource dataSource;
    private static ThreadLocal<Connection> threadLocal=new ThreadLocal<>();
    //初始化druid数据库连接池
    static {
        //创建输入流
        InputStream stream = DBUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
        Properties properties = new Properties();
        //将配置文件中的信息加载到properties中
        try {
            properties.load(stream);
            //方式1：通过的druid工厂创建数据源
            //创建druid数据连接池，并完成数据池的初始化
            dataSource = DruidDataSourceFactory.createDataSource(properties);
            Connection connection = dataSource.getConnection();
            threadLocal.set(connection);
        } catch (Exception e) {
            e.printStackTrace();

        }
    }
    /**
     * 得到一个普通的连接
     * @return connection
     */
    public static Connection getConnection(){
        try {
            return dataSource.getConnection();
        } catch (SQLException e) {
            //如果连接失败，抛出一个运行时异常
            throw new RuntimeException("连接池获取连接失败！");
        }
    }
    /**
     * 得到一个开启事务的连接
     * @return connection
     */
    public static Connection openTransaction(){
        Connection connection=threadLocal.get();
        try {
            if(connection==null){
                connection = dataSource.getConnection();
                threadLocal.set(connection);
            }
            connection.setAutoCommit(false);
            System.out.println("开启事务："+connection);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return connection;
    }
    /**
     * 提交事务，并关闭连接
     */
    public static void commit(){
        Connection connection=threadLocal.get();
        System.out.println("提交事务："+connection);
        try {
            connection.commit();
        } catch (SQLException e) {
            throw new RuntimeException("事务提交失败！");
        } finally {
           if(connection!=null){
               try {
                   threadLocal.remove();
                   connection.close();
               } catch (SQLException e) {
                   e.printStackTrace();
               }
           }
        }
    }
    /**
     * 回滚事务，并关闭连接
     */
    public static void rollback() {
        Connection connection = threadLocal.get();
        System.out.println("回滚事务："+connection);
        try {
            connection.rollback();
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException("数据库回滚失败");
        } finally {
            if(connection!=null){
                try {
                    threadLocal.remove();
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
//关闭连接
    public static void close(Connection connection){
        if (connection!=null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

• 使用了DBUtils封装BaseDao

public abstract class BaseDao {
    QueryRunner queryRunner=new QueryRunner();
    /**
     * 负责执行delete/update/insert操作
     * @param sql
     * @param args
     * @return  返回-1代表执行失败，其他代操作成功影响的行数
     */
    public int update(String sql,Object...args){
        Connection connection = DBUtils.getConnection();
        try {
            return queryRunner.update(connection,sql,args);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBUtils.close(connection);
        }
        return -1;
    }

    /**
     * 执行查询语句，返回一个javabean对象
     * @param type
     * @param sql
     * @param args
     * @param <T> 泛型，代表具体的javabean对象
     * @return
     */
    public <T>T selectSingleObject(Class<T>type,String sql,Object...args){
        Connection connection = DBUtils.getConnection();

        try {
            return queryRunner.query(connection,sql,new BeanHandler<T>(type),args);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBUtils.close(connection);
        }
        return null;
    }

    /**
     * 执行查询语句，返回一个list集合
     * @param type
     * @param sql
     * @param args
     * @param <T>
     * @return
     */
    public <T> List<T> selectManyObject(Class<T>type, String sql, Object...args){
        Connection connection = DBUtils.getConnection();
        try {
            return queryRunner.query(connection,sql,new BeanListHandler<T>(type),args);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBUtils.close(connection);
        }
        return null;
    }

    /**
     * 返回一行或一列
     * @param sql
     * @param args
     * @return
     */
    public Object selectObject(String sql, Object...args){
        Connection connection = DBUtils.getConnection();
        try {
            return queryRunner.query(connection,sql,new ScalarHandler(),args);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBUtils.close(connection);
        }
        return null;
    }
}