二、数据库连接池

本章内容

  1. 数据库连接池
  2. Spring JDBC : JDBC Template

一、数据库连接池

  1. 概念:其实就是一个容器(集合),存放数据库连接的容器。当系统初始化好后,容器被创建,容器中会申请一些连接对象,当用户来访问数据库时,从容器中获取连接对象,用户访问完之后,会将连接对象归还给容器。
  2. 好处:
    ①节约资源
    ③用户访问高效
  3. 实现:
    ①标准接口:DataSource javax.sql包下的
    //获取连接:
    getConnection()
    //归还连接,如果连接对象Connection是从连接池中获取的,那么调用        Connection.close()方法,则不会再关闭连接了,而是归还连接
    Connection.close()。
    
    ②一般我们不去实现它,有数据库厂商来实现
    (1)C3P0:数据库连接池技术
    (2)Druid:数据库连接池实现技术,由阿 里巴巴提供的
  4. C3P0:数据库连接池技术
    ①步骤:
    1. 导入jar包 (两个) c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar ,
    注意:不要忘记导入数据库驱动jar包
    2. 定义配置文件:
       名称: c3p0.properties 或者 c3p0-config.xml
       路径:直接将文件放在src目录下即可。
    3. 创建核心对象 - 数据库连接池对象 ComboPooledDataSource
    4. 获取连接: getConnection  
    
    ②代码:
    //1.创建数据库连接池对象
    DataSource ds  = new ComboPooledDataSource();
    //2. 获取连接对象
    Connection conn = ds.getConnection();
    
    ③注意:c3p0-config.xml中可以有多个配置,获取连接对象的时候可以指定名字
    //1.创建数据库连接池对象
    DataSource ds  = new ComboPooledDataSource();
    //2. 获取连接对象
    Connection conn = ds.getConnection("otherc3p0");
    
  5. Druid:数据库连接池实现技术,由阿里巴巴提供的
    ①步骤:
    1. 导入jar包 druid-1.0.9.jar
    2. 定义配置文件:
        是properties形式的
        可以叫任意名称,可以放在任意目录下
    3. 加载配置文件:Properties
    4. 获取数据库连接池对象:通过工厂来来获取  DruidDataSourceFactory
    5. 获取连接:getConnection
    
    ②代码:
    //1.导入jar包
    //2.定义配置文件druid.properties
    //3.加载配置文件
    Properties pro = new Properties();
    InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
    pro.load(is);
    //4.获取连接池对象
    DataSource ds = DruidDataSourceFactory.createDataSource(pro);
    //5.获取连接
    Connection conn = ds.getConnection();
    
  6. 定义工具类
    步骤:
    ①定义一个类 JDBCUtils
    ②提供静态代码块加载配置文件,初始化连接池对象
    ③提供方法
    (1)获取连接方法:通过数据库连接池获取连接
    (2)释放资源
    (3)获取连接池的方法
    代码:
    package cn.itcast.datasource.utils;
    import com.alibaba.druid.pool.DruidDataSourceFactory;
    import javax.sql.DataSource;
    import java.io.IOException;
    import java.sql.Connection;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    import java.util.Properties;
    
    /**
     * Druid工具类
     */
    public class JDBCUtil {
        //1.定义成员变量 DataSource
        private static DataSource ds;
    
        static {
            try {
                //1.加载配置文件
                Properties pro = new Properties();
                pro.load(JDBCUtil.class.getClassLoader().getResourceAsStream("druid.properties"));
                //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();
        }
    
        /**
         * 释放资源
         */
        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 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();
                }
            }
        }
    
        /**
         * 获取连接池方法
         */
        public static DataSource getDataSource() {
            return ds;
        }
    }
    

二、Spring JDBC

  1. 概念:Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发

  2. 步骤:
    ①导入jar包
    ②创建JdbcTemplate对象。依赖于数据源DataSource
    JdbcTemplate template = new JdbcTemplate(ds);
    ③调用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:查询结果,将结果封装为对象
        * 一般用于聚合函数的查询
    

    ④练习:


    employee.png

    需求:

    1. 修改1号数据的 salary 为 10000
    2. 添加一条记录
    3. 删除刚才添加的记录
    4. 查询id为1的记录,将其封装为Map集合
    5. 查询所有记录,将其封装为List
    6. 查询所有记录,将其封装为Emp对象的List集合
    7. 查询总记录数
    

    代码:

    package cn.itcast.jdbctemplate;
    
    import cn.itcast.datasource.utils.JDBCUtil;
    import cn.itcast.jdbctemplate.domain.Emp;
    import org.junit.Test;
    import org.springframework.jdbc.core.BeanPropertyRowMapper;
    import org.springframework.jdbc.core.JdbcTemplate;
    
    import java.util.List;
    import java.util.Map;
    
    public class JdbcTemplateDemo2 {
        private JdbcTemplate jt = new JdbcTemplate(JDBCUtil.getDataSource());
    
        //使用junit可以使方法单独执行
        //1. 修改1号数据的 salary 为 10000
        @Test
        public void test1() {
    
            String sql = "update employee set salary = 10000 where id = 1";
            int count = jt.update(sql);
            System.out.println(count);
        }
    
        //2. 添加一条记录
        @Test
        public void test2() {
            String sql = "insert into employee values(?,?,?,?,?)";
            int conut = jt.update(sql, 5, "anfly", "男", 20, 20000);
            System.out.println(conut);
        }
    
        //3. 删除刚才添加的记录
        @Test
        public void test3() {
            String sql = "delete from employee where id = 5";
            int conut = jt.update(sql);
            System.out.println(conut);
        }
    
        //4. 查询id为1的记录,将其封装为Map集合
        // 注意:这个方法的结果长度只能是1
        @Test
        public void test4(){
            String sql = "select * from employee where id = ?";
            Map map = jt.queryForMap(sql, 1);
            System.out.println(map);
        }
    
        //5. 查询所有记录,将其封装为List
        @Test
        public void test5(){
            String sql = "select * from employee";
            List> list = jt.queryForList(sql);
            System.out.println(list);
        }
    
        //6. 查询所有记录,将其封装为Emp对象的List集合
        @Test
        public void test6(){
            String sql = "select * from employee";
            List list = jt.query(sql, new BeanPropertyRowMapper(Emp.class));
            System.out.println(list);
        }
        //7. 查询总记录数
        @Test
        public void test7(){
            String sql = "select count(*) from employee";
            Long count = jt.queryForObject(sql, Long.class);
            System.out.println(count);
        }
    }
    

你可能感兴趣的:(二、数据库连接池)