03_07_JavaWeb||day06_JDBC连接池&JDBCTemplate||day06_JDBC连接池&JdbcTemplate（Spring JDBC提供的一个对象）

今日内容

数据库连接池【重要】
Spring JDBC : JDBC Template【简化JDBC】

1. 数据库连接池（容器）

获取连接（Connection）的操作，是向底层申请资源，过程非常浪费时间

概念：其实就是一个容器（集合），存放数据库连接的容器。

当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。

数据库连接池的好处：

节省时间
连接利用率更高，节约资源

实现：

标准接口：DataSource javax.sql包下的

方法：

获取连接：getConnection();
归还连接：Connection.close()

如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则不会在关闭连接了，而是归还连接

一般我们不去实现它，由数据库厂商来实现

由于实现难度不大，所以是开源的（这里讲两种：连接池技术实现）

C3P0：数据库连接池实现技术

比较老

Druid：数据库连接池实现技术

由阿里巴巴提供的
全球最好的连接池实现技术之一

2. C3P0：数据库连接池实现技术

步骤：

导入jar包(两个)

c3p0-0.9.5.2.jar
machange-commons-java-0.2.12.jar(被依赖的jar包)
注：还要导入数据库驱动jar包（mysql-connector-java-5.1.37-bin.jar）

定义配置文件：

名称：c3p0.properties 或者 c3p0-config.xml

c3p0-config.xml演示

<c3p0-config>
      <!-- 使用默认的配置读取连接池对象 -->
      <default-config>
        <!--  连接参数 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/db4</property>
        <property name="user">root</property>
        <property name="password">root</property>

        <!-- 连接池参数 -->
        <property name="initialPoolSize">5</property>
        <property name="maxPoolSize">10</property>
        <property name="checkoutTimeout">3000</property>
      </default-config>

      <named-config name="otherc3p0"> 
        <!--  连接参数 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/db3</property>
        <property name="user">root</property>
        <property name="password">root</property>

        <!-- 连接池参数 -->
        <property name="initialPoolSize">5</property>
        <property name="maxPoolSize">8</property>
        <property name="checkoutTimeout">1000</property>
      </named-config>
    </c3p0-config>

路径：类路径下面（编码的src下面）

创建核心对象

数据库连接池对象ComboPooledDataSource
获取连接池，使用默认配置【主要使用默认方法】

DataSource ds = new ComboPooledDataSource();

获取连接池，使用指定名称配置（配置文件c3p0-config.xml中连接的name）–>只是演示一下

DataSource ds = new ComboPooledDataSource("otherc3p0");

获取连接：getConnection

演示：

public static void main(String[] args) throws SQLException {
        //1.创建数据库连接池对象
        DataSource ds = new ComboPooledDataSource();
        //2. 获取连接对象
        Connection conn = ds.getConnection();
    }

3. Druid：数据库连接池实现技术

步骤：

导入jar包

druid-1.0.9.jar
注：还要导入数据库驱动jar包（mysql-connector-java-5.1.37-bin.jar）

定义配置文件(需要手动去加载)

是properties形式的
可以叫任意名称，可以放在任意目录下

druid.properties演示：

properties文件中#表示注释

driverClassName=com.mysql.jdbc.Driver
    url=jdbc:mysql://127.0.0.1:3306/db3
    username=root
    password=root
    # 初始化连接数量
    initialSize=5
    # 最大连接数
    maxActive=10
    # 最大等待时间
    maxWait=3000

加载配置文件：

ClassLoader对象中有个方法：getResourceAsStream（）

直接将资源的字节输入流返回==【简化操作】==

//1.加载配置文件
    Properties pro = new Properties();
    InputStream rs = DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties");
    pro.load(rs);

注：方法链式调用：调用的规则是：前一个方法返回的是原对象或者对象引用，最后一个不要求返回原对象或者对象引用。

原来的

//1. 创建Properties集合类。
    Properties pro = new Properties();

    //获取src路径下的文件的方式--->ClassLoader 类加载器
    ClassLoader classLoader = JDBCUtils.class.getClassLoader();
    URL res  = classLoader.getResource("jdbc.properties");
    String path = res.getPath(); //System.out.println(path);///D:/IdeaProjects/itcast/out/production/day04_jdbc/jdbc.properties


    //2. 加载文件
    pro.load(new FileReader(path));//读取字符文件

获取数据库连接池对象

通过工厂类来获取：DruidDataSourceFactory

里面的方法：createDataSource()

//2.获取连接池对象
    DataSource dataSource = DruidDataSourceFactory.createDataSource(pro);

获取连接：getConnection

演示：

/**
     * Druid演示
     */
    public class DruidDemo1 {
        public static void main(String[] args) throws Exception {
            //1.加载配置文件
            Properties pro = new Properties();
            InputStream rs = DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties");
            pro.load(rs);

            //2.获取连接池对象
            DataSource ds = DruidDataSourceFactory.createDataSource(pro);

            //3.获取连接
            Connection conn = ds.getConnection();

            //4.打印
            System.out.println(conn);
        }
    }

定义工具类【学会使用】

定义一个类：JDBCUtils
提供静态代码块加载配置文件，初始化连接池对象
提供方法

获取连接方法：通过数据库连接池获取连接
释放资源
获取连接池的方法

/*
    Druid连接池的工具类
     */
    public class JDBCUtils {

        //1.定义成员变量
        private static DataSource ds;

        static {
            try {
                //1. 加载配置文件
                Properties pro = new Properties();
                InputStream rs = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
                pro.load(rs);
                //2. 获取DataSource
                ds = DruidDataSourceFactory.createDataSource(pro);


            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        /*
        获取连接的方法
         */
        public static Connection getConnection() throws SQLException {
            return ds.getConnection();
        }

        /*
        释放资源的方法重载（DQL使用）
         */
        public static void close(ResultSet rs, Statement stmt, Connection conn){
            if(rs != null){
                try {
                    rs.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();
                }
            }
        }

        /*
        释放资源的方法（DML使用）
         */
        public static void close(Statement stmt, Connection conn){
            if(stmt != null){
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(conn != null){
                try {
                    conn.close();   //这里不是释放，而是归还连接
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            //也可以写成close(null, stmt, conn); 了解一下
        }

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

druid工具类的测试【基本用法（重点）】

添加一组信息到account表中

/**
     * 使用新的工具类
     */
    public class DruidDemo2 {
        public static void main(String[] args) {
            /**
             * 完成一个添加的操作：给account添加一条记录
             */
            Connection conn = null;
            PreparedStatement pstmt = null;
            try {
                //1. 获取连接：
                conn = JDBCUtils.getConnection();
                //2. 编写sql
                String sql = "INSERT INTO account VALUES (null, ?, ?)"; //预编译sql
                //3. 获取执行sql对象
                pstmt = conn.prepareStatement(sql);
                //4. 给？赋值
                pstmt.setString(1, "王五");
                pstmt.setInt(2, 3000);
                //5.执行sql
                int count = pstmt.executeUpdate();
                //6. 打印一下
                System.out.println(count);
            } catch (SQLException e) {
                e.printStackTrace();
            }finally {
                //7. 释放资源
                JDBCUtils.close(pstmt, conn);
            }
        }
    }

4. Spring JDBC

++技术由来++：比如java中的查询，需要先获取到信息，然后Emp实体类赋值，最后添加到集合中，此过程很繁琐！！
Spring框架对JDBC的简单封装，提供了一个JdbcTemplate对象简化JDBC的开发（内部做了封装）

不需要申请链接
也不需要释放资源了

步骤：

导入jar包

03_07_JavaWeb||day06_JDBC连接池&JDBCTemplate||day06_JDBC连接池&JdbcTemplate（Spring JDBC提供的一个对象）

创建JdbcTemplate对象。依赖于数据源DataSource

JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());

ds就可以用druid工具类获取

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

update【重点掌握】()：执行DML语句。–>增删改语句
queryForMap()：查询结果，将结果集封装为map集合，将列名作为key，将值作为value，将一条记录封装为一个map集合

注：这个方法查询的结果集长度只能是1（一次只能查询一条记录）

queryFroList【一般用下面的】()：查询结果，将结果集封装为list集合

注：将每一条记录封装为一个Map集合，再将Map集合装载都List集合中

query【重点掌握】()：查询结果，将结果集封装为JavaBean对象

query的参数：RowMapper

自己来实现
query的参数：BeanPropertyRowMappe【掌握】r
提供好的实现类：BeanPropertyRowMapper，可以完成数据到JavaBean的自动封装

new BeanPropertyRowMapper<类型>(类型.class);

queryForObject()：查询结果，将结果封装为对象（一般是基本数据类型）

第二个参数：封装的是返回值结果类型（long）
一般执行的是一些聚合函数

实例：将account表中id=3的钱改为5000

/**
     * JdbcTemplate入门
     */
    public class JdbcTemplateDemo1 {
        public static void main(String[] args) {
            //1. 创建JdbcTemplate对象
            JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
            //2. 调用方法
            String sql = "UPDATE account SET balance = 5000 WHERE id = ?";
            int count = template.update(sql, 3);   //第二个参数就是？的值
            System.out.println(count);
        }
    }

练习：

步骤：

首先要操作Emp表，就先创建一个Emp对象

注：创建成引用类型，不然基本数据类型不能接收null【注意】

注：由于每次都要先获取JdbcTemplate对象，所以将它直接写到成员变量的位置

//由于每次都要先获取JdbcTemplate对象，所以将它直接写到成员变量的位置
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());

实现：

执行DML语句

修改1号数据的salary为10000

//1. 修改1号数据的salary为10000
    @Test
    public void test1(){
        //1.获取Jdbctemplate对象的操作放到了外面
        //2. 定义sql
        String sql = "UPDATE emp SET salary=10000 WHERE id=1001";
        //3. 执行sql
        int count = template.update(sql);
        //4. 打印
        System.out.println(count);

    }

添加一条记录

//2. 添加一条记录
    @Test
    public void test2(){
        //1.获取Jdbctemplate对象的操作放到了外面
        //2.定义sql,这里可能会出现sql注入问题
        String sql = "SELECT INTO emp(id, ename, dept_id) VLAUES(?, ?, ?)";
        int count = template.update(sql, 1015, "郭靖", 10);
        //3.打印
        System.out.println(count);
    }

这里的update就相当于PreparedStatement–>防止sql注入问题（使用？预编译sql）

删除刚才添加的记录

//3. 删除刚才添加的记录
    @Test
    public void test3(){
        //1.获取Jdbctemplate对象的操作放到了外面
        //2. 定义sql
        String sql = "DELECT FROM emp WHERE id=?";
        int count = template.update(sql, 1015);
        //3. 打印
        System.out.println(count);
    }

执行DQL语句

查询id为1001的记录，将其封装为Map集合

//4. 查询id为1001的记录，将其封装为Map集合
    ///注：这个方法查询的结果集长度只能是1（==一次只能查询一条记录==）
    @Test
    public void test4(){
        //1.获取Jdbctemplate对象的操作放到了外面
        //2. 定义sql
        String sql = "SELECT * FROM emp WHERE id = ?";
        //3. 执行sql
        Map<String, Object> map = template.queryForMap(sql, 1001);
        //4.打印
        System.out.println(map);

    }

查询所有记录，将其封装为list

//5. 查询所有记录，将其封装为list
    @Test
    public void test5() {
        //1.获取Jdbctemplate对象的操作放到了外面
        //2. 定义sql
        String sql = "SELECT * FROM emp";
        //3. 执行sql
        List<Map<String, Object>> list = template.queryForList(sql);
        //4. 遍历打印
        for (Map<String, Object> stringObjectMap : list) {
            System.out.println(stringObjectMap);
        }
    }

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

自己来实现接口：RowMapper

//6. 查询结果，将结果集封装为JavaBean对象
    @Test
    public void test6() {
        //1.获取Jdbctemplate对象的操作放到了外面
        //2. 定义sql
        String sql = "SELECT * FROM emp";
        //3. 执行sql（自己来实现：RowMapper）
        List<Emp> list = template.query(sql, new RowMapper<Emp>() {  //匿名内部类
            @Override
            public Emp mapRow(ResultSet rs, int i) throws SQLException {
                Emp emp = new Emp();
                int id = rs.getInt("id");
                String ename = rs.getString("ename");
                int job_id = rs.getInt("job_id");
                int mgr = rs.getInt("mgr");
                Date joindate = rs.getDate("joindate");
                double salary = rs.getDouble("salary");
                double bonus = rs.getDouble("bonus");
                int dept_id = rs.getInt("dept_id");

                emp.setId(id);
                emp.setEname(ename);
                emp.setJob_id(job_id);
                emp.setMgr(mgr);
                emp.setJoindate(joindate);
                emp.setSalary(salary);
                emp.setBonus(bonus);
                emp.setDept_id(dept_id);
                return emp;
            }
        });
        //4. 遍历打印
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }

提供好的实现类：BeanPropertyRowMapper

//6_2. 查询结果，将结果集封装为JavaBean对象
    @Test
    public void test6_2() {
        //1.获取Jdbctemplate对象的操作放到了外面
        //2. 定义sql
        String sql = "SELECT * FROM emp";
        //3. 执行sql（提供好的实现类：BeanPropertyRowMapper）
        List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));    //括号里获取到Emp的class对象
        //4. 遍历打印
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }

查询总记录数(count)

//7. 查询总记录数(count)
    @Test
    public void test7() {
        //1.获取Jdbctemplate对象的操作放到了外面
        //2. 定义sql
        String sql = "SELECT COUNT(id) FORM emp";
        //3. 执行sql
        ///封装的是返回值结果类型（long）
        Long total = template.queryForObject(sql, long.class);
        //4. 打印
        System.out.println(total);

    }

实现代码汇总

public class JdbcTemplateDemo2 {
        //为了让7个需求在一个类中，所以我们写一个JUnit单元测试，可以让方法独立执行

        //由于每次都要先获取JdbcTemplate对象，所以将它直接写到成员变量的位置
        private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());

        //1. 修改1号数据的salary为10000
        @Test
        public void test1(){
            //1.获取Jdbctemplate对象的操作放到了外面
            //2. 定义sql
            String sql = "UPDATE emp SET salary=10000 WHERE id=1001";
            //3. 执行sql
            int count = template.update(sql);
            //4. 打印
            System.out.println(count);

        }

        //2. 添加一条记录
        @Test
        public void test2(){
            //1.获取Jdbctemplate对象的操作放到了外面
            //2.定义sql,这里可能会出现sql注入问题
            String sql = "SELECT INTO emp(id, ename, dept_id) VLAUES(?, ?, ?)";
            //3. 执行sql
            int count = template.update(sql, 1015, "郭靖", 10);
            //4.打印
            System.out.println(count);
        }

        //3. 删除刚才添加的记录
        @Test
        public void test3(){
            //1.获取Jdbctemplate对象的操作放到了外面
            //2. 定义sql
            String sql = "DELECT FROM emp WHERE id=?";
            //3. 执行sql
            int count = template.update(sql, 1015);
            //4. 打印
            System.out.println(count);
        }

        //4. 查询id为1001的记录，将其封装为Map集合
        ///注：这个方法查询的结果集长度只能是1（==一次只能查询一条记录==）
        @Test
        public void test4(){
            //1.获取Jdbctemplate对象的操作放到了外面
            //2. 定义sql
            String sql = "SELECT * FROM emp WHERE id = ?";
            //3. 执行sql
            Map<String, Object> map = template.queryForMap(sql, 1001);
            //4.打印
            System.out.println(map);

        }

        //5. 查询所有记录，将其封装为list
        @Test
        public void test5() {
            //1.获取Jdbctemplate对象的操作放到了外面
            //2. 定义sql
            String sql = "SELECT * FROM emp";
            //3. 执行sql
            List<Map<String, Object>> list = template.queryForList(sql);
            //4. 遍历打印
            for (Map<String, Object> stringObjectMap : list) {
                System.out.println(stringObjectMap);
            }
        }

        //6. 查询结果，将结果集封装为JavaBean对象
        @Test
        public void test6() {
            //1.获取Jdbctemplate对象的操作放到了外面
            //2. 定义sql
            String sql = "SELECT * FROM emp";
            //3. 执行sql（自己来实现：RowMapper）
            List<Emp> list = template.query(sql, new RowMapper<Emp>() {  //匿名内部类
                @Override
                public Emp mapRow(ResultSet rs, int i) throws SQLException {
                    Emp emp = new Emp();
                    int id = rs.getInt("id");
                    String ename = rs.getString("ename");
                    int job_id = rs.getInt("job_id");
                    int mgr = rs.getInt("mgr");
                    Date joindate = rs.getDate("joindate");
                    double salary = rs.getDouble("salary");
                    double bonus = rs.getDouble("bonus");
                    int dept_id = rs.getInt("dept_id");

                    emp.setId(id);
                    emp.setEname(ename);
                    emp.setJob_id(job_id);
                    emp.setMgr(mgr);
                    emp.setJoindate(joindate);
                    emp.setSalary(salary);
                    emp.setBonus(bonus);
                    emp.setDept_id(dept_id);
                    return emp;
                }
            });
            //4. 遍历打印
            for (Emp emp : list) {
                System.out.println(emp);
            }
        }

        //6_2. 查询结果，将结果集封装为JavaBean对象
        @Test
        public void test6_2() {
            //1.获取Jdbctemplate对象的操作放到了外面
            //2. 定义sql
            String sql = "SELECT * FROM emp";
            //3. 执行sql（提供好的实现类：BeanPropertyRowMapper）
            List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));    //括号里获取到Emp的class对象
            //4. 遍历打印
            for (Emp emp : list) {
                System.out.println(emp);
            }
        }

        //7. 查询总记录数(count)
        @Test
        public void test7() {
            //1.获取Jdbctemplate对象的操作放到了外面
            //2. 定义sql
            String sql = "SELECT COUNT(id) FORM emp";
            //3. 执行sql
            ///封装的是返回值结果类型（long）
            Long total = template.queryForObject(sql, long.class);
            //4. 打印
            System.out.println(total);

        }
    }

秒客网

03_07_JavaWeb||day06_JDBC连接池&JDBCTemplate||day06_JDBC连接池&JdbcTemplate（Spring JDBC提供的一个对象）

今日内容

1. 数据库连接池（容器）

2. C3P0：数据库连接池实现技术

3. Druid：数据库连接池实现技术

4. Spring JDBC

相关文章