Java 数据库连接池使用

1，使用数据库连接池工具基础

在同一包下建立utils文件，文件中定义JDBC_druid_pool 类

package utils;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

public class JDBC_druid_pool {
    public static DataSource ds;
    static {
        Properties pro = new Properties();
        InputStream is = JDBC_druid_pool.class.getClassLoader().getResourceAsStream("druid.properties");
        try {
            pro.load(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //获取连接池的方法
    public static DataSource get_dataSource(){
        return ds;
    }

    public static Connection get_connection() throws Exception {
        return ds.getConnection();
    }

    //关闭连接池以及 Statement
    public static void close(Statement stmt, Connection conn){
        close(null,stmt,conn);  //简写，会掉用下面的close方法
    }
    //
    public static void close(ResultSet res,Statement stmt,Connection conn){
        if(res != null){
            try {
                res.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

　　

2，在主程序中使用连接池

package cn.itcast.jdbcDemo;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import utils.JDBC_druid_pool;

import javax.sql.DataSource;
import javax.swing.*;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * druid 连接池使用,这样也不太好，还是要使用工具类的方式来使用
 */
public class JDBC_pool {
    public static void main(String[] args) {
        //1,导入jar包
        //2,定义配置文件
        //3,加载配置文件
//        Properties pro = new Properties();
//        InputStream is = JDBC_pool.class.getClassLoader().getResourceAsStream("druid.properties");
//        pro.load(is);
//        DataSource ds = DruidDataSourceFactory.createDataSource(pro);
//
//        for (int i=0;i<11;i++){
//            Connection conn = ds.getConnection();
//            System.out.println(conn);
//            if (i==5){
//                conn.close();
//            }
//        }

        // 工具类数据库连接池使用
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet res = null;
        try {
            // 获取连接
            conn = JDBC_druid_pool.get_connection();
            // 定义sql
            String sql = "select * from student where sno < ?";
            pstmt = conn.prepareStatement(sql);
            // 给sql赋值, 有setString，setDouble等
            pstmt.setInt(1, 5);
            res = pstmt.executeQuery();     //执行查询
//            res = pstmt.executeUpdate(sql)  // 执行DML语句 (增，删，改)

            if (res.next()) {  //游标要到数据区
                System.out.println(res.getInt("sclass"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBC_druid_pool.close(res, pstmt, conn);
        }
    }
}

 

2，使用连接池返回封装自定义数据类型

　　

 

 

　　2.1  定义数据库对应类 ，一般就和表名称对应就可以，放在src同级下自己随便建的一个包中就可以

package cn.itcast.domain;

public class EmpObj {
    // 注意点，这里使用包装类，使用基本数据类型字段为空时会报错
    public Integer empid;
    public String name;
    public String deptno;
    public String duty;
    public Integer sal;

    public Integer getEmpid() {
        return empid;
    }

    public void setEmpid(Integer empid) {
        this.empid = empid;
    }

    public String getName() {
        return name;
    }

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

    public String getDeptno() {
        return deptno;
    }

    public void setDeptno(String deptno) {
        this.deptno = deptno;
    }

    public String getDuty() {
        return duty;
    }

    public void setDuty(String duty) {
        this.duty = duty;
    }

    public Integer getSal() {
        return sal;
    }

    public void setSal(Integer sal) {
        this.sal = sal;
    }

    @Override
    public String toString() {
        return "EmpObj{" +
                "empid=" + empid +
                ", name='" + name + '\'' +
                ", deptno='" + deptno + '\'' +
                ", duty='" + duty + '\'' +
                ", sal=" + sal +
                '}';
    }
}

　　2.2  也是要导入Spring Template 的jar包， 文件中定义JDBC_druid_pool 类

　　　具体代码在最上面

　　2.3 使用：

// 1,修改emp表id为1的sal为2200
// 1，添加一条记录
// 2，删除刚添加的记录
// 2,查询id为1的数据封装为Map
// 3,查询所有记录，封装为list
// 4,查询所有记录，封装为Emp对象的list集合
// 5，查询总的记录数

　　我是使用单元测试来做的，这样就不用一个个的写到主程序中， 重点看t5  t7, t8  经常要用。

package cn.itcast.jdbcDemo;

import cn.itcast.domain.EmpObj;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import utils.JDBC_druid_pool;

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

public class domain_jdbcDemo {
    private JdbcTemplate template = new JdbcTemplate(JDBC_druid_pool.get_dataSource());
    // Junit 单元测试  用单元测试就不用主方法就可以运行了
//    @Test
    public void test1(){
        System.out.println("测试执行");
        int a = 3/0;
    }
    @Test
    public void test2(){
        System.out.println("测试执行");
    }

    // 1,修改emp表id为1的sal为2200
    @Test
    public void t1(){
        String sql = "update emp set sal = ? where empid =1";
        int count = template.update(sql,2500);
        System.out.println(count);
    }

    // 1，添加一条记录
//    @Test
    public void t2(){
        String sql = "insert into emp(empid,name,deptno) values(11,'wangjun',01)";
        int count = template.update(sql);
        System.out.println(count);
    }
    // 2，删除刚添加的记录
    @Test
    public void t3(){
        String sql = "delete from emp where empid=?";
        int count = template.update(sql,9);
        System.out.println(count);
    }
    // 2,查询id为1的数据封装为Map
    @Test
    public void t4(){
        String sql = "select * from emp where empid=?";
        Map<String, Object> map = template.queryForMap(sql, 1);  // 结果只能是一条
        System.out.println(map);
        System.out.println(map.get("duty"));
        System.out.println(map.get("sal"));
    }
    // 3,查询所有记录，封装为list
    @Test
    public void t5(){
        String sql = "select * from emp";
        List<Map<String, Object>> maps = template.queryForList(sql);
        System.out.println(maps);
        for (Map i:maps){
            System.out.println(i);
            System.out.println(i.get("duty"));
        }
    }
    // 4,查询所有记录，封装为Emp对象的list集合
    // 这个方法是自己写最原始的方法
    @Test
    public void t6(){
        String sql = "select * from emp";
        List<EmpObj> lis = template.query(sql, new RowMapper<EmpObj>() {
            @Override
            public EmpObj mapRow(ResultSet res, int i) throws SQLException {
                EmpObj emp = new EmpObj();
                int empid = res.getInt("empid");
                String name = res.getString("name");
                String deptno = res.getString("deptno");
                String duty = res.getString("duty");
                int sal = res.getInt("sal");

                emp.setEmpid(empid);
                emp.setName(name);
                emp.setDeptno(deptno);
                emp.setDuty(duty);
                emp.setSal(sal);
                return emp;
            }
        });
        System.out.println(lis);
    }

    //4,查询所有记录，封装为Emp对象的list集合
    // 用Sprint JDBC Template 封装好的模板做, 简化代码BeanPropertyRowMapper
    @Test
    public void t7(){
        String sql = "select * from emp";
        List<EmpObj> lis = template.query(sql,new BeanPropertyRowMapper<>(EmpObj.class));
        for (EmpObj i:lis){
            System.out.println(i);
        }
    }

    // 5，查询总的记录数
    // queryForObject 一般是使用查询聚合函数的，
    // Long.class 返回的数据类型
    @Test
    public void t8(){
        String sql = "select count(empid) from emp";
        Long totle = template.queryForObject(sql, Long.class);
        System.out.println(totle);
    }
}