2020-04-25

JavaWeb--数据库连接池【进阶】

字数统计: 1.7k字 | 阅读时长: 7分

一、前言

JavaWeb–数据库连接池【入门】
本篇博客主要总结如何高效的使用数据库连接池来进行开发，且本文中的Demo使用的数据库连接池技术为Druid。

二、需求

在exam数据库中有一张如下结构，且名为account的表：

现有如下需求：
往这张表中插入一条记录：values（null, ‘张三’, 4000）

三、V1.0版

public class DruidDemo1 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement pstat = null;

        try {
            //加载配置文件
            Properties pro = new Properties();
            InputStream is = DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties");
            pro.load(is);
            //获取连接池对象
            DataSource pool = DruidDataSourceFactory.createDataSource(pro);
            //获取连接对象
            conn = pool.getConnection();
            //编写SQL
            String sql = "insert into account values(null, ?, ?)";
            //获取sql预编译对象
            pstat = conn.prepareStatement(sql);
            //给？赋值
            pstat.setString(1, "张三");
            pstat.setDouble(2, 4000);
            //执行
            int count = pstat.executeUpdate();
            //处理结果
            System.out.println(count);
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //释放资源
            if(conn != null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

仔细思考我们就会发现，DruidDemo1中的如下部分代码时可重用的：
1、加载配置文件
2、获取连接池对象
3、释放资源
所以我们可以对其进行简单封装，从而形成工具类。因此出现了2.0版本。

四、V2.0版

对DruidDemo1中的部分代码进行封装，得到JDBCUtils工具类：

public class JDBCUtils {
    private static DataSource pool = null;

    static{
        try {
            //加载配置文件
            Properties pro = new Properties();
            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            //获取连接池对象
            pool = DruidDataSourceFactory.createDataSource(pro);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 返回Connection对象
     * @return
     */
    public static Connection getConnection() throws SQLException {
        return pool.getConnection();
    }

    /**
     * 释放资源
     * @param stat
     * @param conn
     */
    public static void close(Statement stat, Connection conn){
        if(stat != null){
            try {
                stat.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 释放资源
     * @param rs
     * @param stat
     * @param conn
     */
    public static void close(ResultSet rs, Statement stat, Connection conn){
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        close(stat, conn);
    }

    /**
     * 返回数据库连接池对象
     * @return
     */
    public static DataSource getDataSource(){
        return pool;
    }
}

使用工具类实现需求：

public class DruidDemo2 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement pstat = null;

        try {
            //获取连接对象
            conn = JDBCUtils.getConnection();
            //编写SQL
            String sql = "insert into account values(null, ?, ?)";
            //获取预编译对象
            pstat = conn.prepareStatement(sql);
            //给？赋值
            pstat.setString(1, "张三");
            pstat.setDouble(2, 4000);
            //执行
            int count = pstat.executeUpdate();
            //处理结果
            System.out.println(count);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //释放资源
            JDBCUtils.close(pstat, conn);
        }
    }
}

通过使用工具类我们就会发现，代码数量有了减少，并且其可重用性有了很大的提升。
但是，追求完美的我们是不能这样的满足的，因为我们又发现另一个情况：
虽然对于一些数据库的添加，删除，修改操作，代码数量不是很多；可当我们执行查询操作时，代码量可还是有很多，尤其我们通常还需要将查询查询后的结果进行封装，这样的话，代码就更多了，那么有没有更好地办法来解决这个问题呢？？？
答案当然是肯定的。比如JdbcTemplate

五、JdbcTemplate

JdbcTemplate是Spring框架对JDBC的简单封装后，提供的一个简化JDBC的使用的工具。
1、导入jar包

commons-logging-1.2.jar
spring-beans-5.0.0.RELEASE.jar
spring-core-5.0.0.RELEASE.jar
spring-jdbc-5.0.0.RELEASE.jar
spring-tx-5.0.0.RELEASE.jar

2、创建JdbcTemplate对象

1 2	JdbcTemplate template = new JdbcTemplate(参数); 参数：需要传递使用的DataSource对象（连接池对象）

3、调用JdbcTemplate的方法来完成CRUD的操作

* update():执行DML语句。增、删、改语句
* queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
		* 注意：这个方法查询的结果集长度只能是1（也就是说只能封装一条记录）
* queryForList():查询结果将结果集封装为list集合
		* 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
* query():查询结果，将结果封装为JavaBean对象
		* query的参数：RowMapper接口实现类的对象
		* 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
		* new BeanPropertyRowMapper<类型>(类型.class)
* queryForObject：查询结果，将结果封装为对象
		* 一般用于聚合函数的查询

了解了JdbcTemplate之后，我们就可以使用它来优化代码了，因此有了3.0版本。

六、V3.0版

public class JTDemo {
     public static void main(String[] args) {
     	JdbcTemplate jt = new JdbcTemplate(JDBCUtils.getDataSource());
        String sql = "insert into account values(null, ?, ?)";
        int count = jt.update(sql, "张三", 4000);
        System.out.println(count);
    }
}

是的，没有看错，在使用了JDBCUtils工具类和JdbcTemplate这个工具之后，之前的代码就变得这么简单了。

七、JdbcTemplate案例补充

exam数据库中有一张名为emp，且结构如下的表

（一）插入、删除、修改操作

1、插入一条记录

public void test01(){
   	JdbcTemplate jt = new JdbcTemplate(JDBCUtils.getDataSource());
    String sql = "insert into emp values(?,?,null,null,null,null,null,?)";
    int count = jt.update(sql, 1016, "李四", 30);
    System.out.println(count);
}

2、删除一条记录

 public void test02(){
    JdbcTemplate jt = new JdbcTemplate(JDBCUtils.getDataSource());
    String sql = "delete from emp where empno=?";
    int count = jt.update(sql, 1016);
    System.out.println(count);
}

3、修改一条记录

public void test03(){
    JdbcTemplate jt = new JdbcTemplate(JDBCUtils.getDataSource());
    String sql = "update emp set sal=10000 where empno=?";
    int count = jt.update(sql, 1001);
    System.out.println(count);
}

（二）查询操作

1、查询empno为1001的记录，将其封装为Map集合

public void test01(){
    JdbcTemplate jt = new JdbcTemplate(JDBCUtils.getDataSource());
    String sql = "select * from emp where empno=?";
    Map<String, Object> objectMap = jt.queryForMap(sql, 1001);
    System.out.println(objectMap);
}

2、查询所有记录，将其封装为List

public void test02(){
    JdbcTemplate jt = new JdbcTemplate(JDBCUtils.getDataSource());
    String sql = "select * from emp";
    List<Map<String, Object>> maps = jt.queryForList(sql);
    for(Map<String, Object> map : maps){
        System.out.println(map);
    }
}

3、查询所有记录，将其封装为Emp对象的List集合

public void test03(){
    JdbcTemplate jt = new JdbcTemplate(JDBCUtils.getDataSource());
    String sql = "select * from emp";
    List<Emp> empList = jt.query(sql, new BeanPropertyRowMapper<>(Emp.class));
    System.out.println(empList);
    for(Emp emp : empList){
        System.out.println(emp);
    }
}

当然，这个操作的前提是要先创建Emp这个JavaBean
4、查询总记录数

public void test04(){
    JdbcTemplate jt = new JdbcTemplate(JDBCUtils.getDataSource());
    String sql = "select count(empno) from emp";
    Long total = jt.queryForObject(sql, Long.class);
    System.out.println(total);
}

八、总结

通常当需要进行数据库操作时，都会封装JDBCUtils工具类、使用数据库连接池，以及使用JDBC工具来进行开发。

Java新手，若有错误，欢迎指正！

| 阅读量次