JDBC连接池和Spring JDBC

淡淡的烟草味﹌ 2023-10-03 12:05 13阅读 0赞

#### 文章目录 ####

*  JDBC连接池&Spring JDBC
 *   *  1.数据库连接池
     *   *  1.1概念
         *  1.2好处
         *  1.3实现
         *  1.4C3P0：数据库连接池技术
         *  1.5 Druid：数据库连接池实现技术，由阿里巴巴提供的
     *  2.Spring JDBC

## JDBC连接池&Spring JDBC ##

### 1.数据库连接池 ###

#### 1.1概念 ####

其实就是一个容器(集合)，存放数据库连接的容器。

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

#### 1.2好处 ####

1.  节约资源
2.  用户访问高效

#### 1.3实现 ####

1.  标准接口：`DateSource` `javax.sq`l包下的。
    
    方法：
    
     *  获取连接：`getConnection()`
     *  归还连接：`Connection.close()`。如果连接对象`Connection`是从连接池中获取的，那么调用`Connection.close()`方法，则不会再关闭连接了。而是归还连接。
2.  一般我们不去实现它，有数据库厂商来实现。
    
    1.  `C3P0`：数据库连接池技术。
    2.  `Druid`：数据库连接池实现技术，由阿里巴巴提供的。

#### 1.4C3P0：数据库连接池技术 ####

*  步骤：
    
    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();

#### 1.5 Druid：数据库连接池实现技术，由阿里巴巴提供的 ####

*  步骤：
    
    1.  导入`jar`包 `druid-1.0.9.jar`
    2.  定义配置文件：
        
         *  是`properties`形式的。
         *  可以叫任意名称，可以放在任意目录下。
    3.  加载配置文件。`Properties`
    4.  获取数据库连接池对象：通过工厂来来获取 `DruidDataSourceFactory`
    5.  获取连接：`getConnection`
    
    代码：
    
        public class DruidDemo {
              
            public static void main(String[] args) throws Exception {
              
                //1.加载配置文件
                Properties pro=new Properties();
                InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
                pro.load(is);
                //2.获取连接池对象
                DataSource ds= DruidDataSourceFactory.createDataSource(pro);
                //3.获取连接
                Connection conn = ds.getConnection();
            }
        }
 *  **定义工具类**
    
    1.  定义一个类 `JDBCUtils`
    2.  提供静态代码块加载配置文件，初始化连接池对象。
    3.  提供方法。  
        1. 获取连接方法：通过数据库连接池获取连接。  
        2. 释放资源。  
        3. 获取连接池的方法。
    
    代码：
    
        public class JDBCtils {
              
            //1.定义成员变量 DataSource
            private static DataSource ds;
            
            static {
              
           	    //1.加载配置文件
                Properties pro = new Properties();
                try {
              
                    pro.load(JDBCUtiles.class.getClassLoader().getResourceAsStream("druid.properties"));
                    try {
              
                        //2.获取DataSource
                        ds = DruidDataSourceFactory.createDataSource(pro);
                    } catch (Exception e) {
              
                        e.printStackTrace();
                    }
                } catch (IOException e) {
              
                    e.printStackTrace();
                }
            }
        	//获取连接
            public static Connection getConnection() throws SQLException {
              
                return ds.getConnection();
            }
        	//释放资源
            public static void close(Statement stmt, Connection conn) {
              
                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;
        	}
        }
    
    练习：
    
        public class DruidDemo1 {
              
            public static void main(String[] args) {
              
                Connection conn = null;
                PreparedStatement pstmt = null;
                try {
              
                    conn = JDBCtils.getConnection();
                    String sql = "insert into account values(null,?,?)";
        
                    pstmt = conn.prepareStatement(sql);
                    pstmt.setString(1, "小皮皮");
                    pstmt.setInt(2, 2323);
        
                    int count = pstmt.executeUpdate();
                    System.out.println(count);
        
                } catch (SQLException throwables) {
              
                    throwables.printStackTrace();
                } finally {
              
                    JDBCtils.close(pstmt, conn);
                }
            }
        }

### 2.Spring JDBC ###

*  **概述**：`Spring`框架对`JDBC`的简单封装。提供了一个`JDBCTemplate`对象简化`JDBC`的开发。
 *  **步骤**：
    
    1.  导入`jar`包
    2.  创建`JdbcTemplate`对象。依赖于数据源`DataSource`
        
            JdbcTemplate template = new JdbcTemplate(ds);
    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`:查询结果，将结果封装为对象。
            
             *  一般用于聚合函数的查询。
 *  **练习**
    
     *  需求：
        
        1.  修改1号数据的 salary 为 10000
        2.  添加一条记录
        3.  删除刚才添加的记录
        4.  查询id为1的记录，将其封装为Map集合
        5.  查询所有记录，将其封装为List
        6.  查询所有记录，将其封装为Emp对象的List集合
        7.  查询总记录数
     *  代码实现：
        
            public class JDBCTemplateDemo {
                    
                private JdbcTemplate template = new JdbcTemplate(JDBCtils.getDataSource());
            
                //Junit单元测试,可以让方法独立执行
                //1.修改1号数据的 salary 为 10000
                @Test
                public void test1() {
                    
                    String sql = "update emp set salary =10000 where id=1001";
                    int count = template.update(sql);
                    System.out.println(count);
                }
            
                //2.添加一条记录
                @Test
                public void test2() {
                    
                    String sql = "insert into emp(id,ename,dept_id) values(?,?,?)";
                    int count = template.update(sql, 15, "郭靖", 10);
                    System.out.println(count);
                }
            
                //3.删除刚才添加的记录
                @Test
                public void test3() {
                    
                    String sql = "delete from emp where id=?";
                    int count = template.update(sql, 15);
                    System.out.println(count);
                }
            
                /*4.查询id为1001的记录，将其封装为Map集合
                 * 注意：这个方法查询的结果集长度只能是
                 * */
                @Test
                public void test4() {
                    
                    String sql = "select * from emp where id=? ";
                    Map<String, Object> m = template.queryForMap(sql, 1001);
                    System.out.println(m);
                }
            
                //5.查询所有记录，将其封装为List
                @Test
                public void test5() {
                    
                    String sql = "select * from emp ";
                    List<Map<String, Object>> list = template.queryForList(sql);
                    for (Map<String, Object> stringObjectMap : list) {
                    
                        System.out.println(stringObjectMap);
                    }
                }
            
                //6.查询所有记录，将其封装为Emp对象的List集合
                @Test
                public void test6() {
                    
                    String sql = "select * from emp";
                    List<Emp> list = template.query(sql, new BeanPropertyRowMapper<>(Emp.class));
                    for (Emp emp : list) {
                    
                        System.out.println(emp);
                    }
                }
            
                //7.查询总记录数
                @Test
                public void test7() {
                    
                    String sql = "select count(id) from emp";
                    Long total = template.queryForObject(sql, long.class);
                    System.out.println(total);
                }
            }