JDBC连接池&&JdbcTemplate

数据库连接池

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

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

好处:
  1. 节约资源
  2. 用户访问高效
实现:
  1. 标准接口:DataSource javax.sql包下的
  • 方法:
    • 获取连接:getConnection()
    • 归还连接:Connection.close()。如果连接对象Connection是从连接池中获取的,那么调用Connection.close()方法,则不会再关闭连接了。而是归还连接
  1. 一般我们不去实现它,有数据库厂商来实现
  • C3P0:数据库连接池技术
  • Druid:数据库连接池实现技术,由阿里巴巴提供的
C3P0:数据库连接池技术
  • 步骤:
  • 导入jar包 (两个) c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar , 不要忘记导入数据库驱动jar包

  • 定义配置文件:

    • 名称: c3p0.properties 或者 c3p0-config.xml
    • 路径:直接将文件放在src目录下即可。
  • 创建核心对象 数据库连接池对象 ComboPooledDataSource ,可以指定连接一个数据库

    • DataSource ds = new ComboPooledDataSource(“otherc3p0”);
  • 获取连接: getConnection

  • 代码:

c3p0-config.xml

<c3p0-config>
  
  <default-config>
  	
    <property name="driverClass">com.mysql.jdbc.Driverproperty>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/day03property>
    <property name="user">rootproperty>
    <property name="password">123456property>
    
    
    
    <property name="initialPoolSize">5property>
    
    <property name="maxPoolSize">10property>
    
    <property name="checkoutTimeout">3000property>
  default-config>

  <named-config name="otherc3p0"> 
    
    <property name="driverClass">com.mysql.jdbc.Driverproperty>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/db3property>
    <property name="user">rootproperty>
    <property name="password">rootproperty>
    
    
    <property name="initialPoolSize">5property>
    <property name="maxPoolSize">8property>
    <property name="checkoutTimeout">1000property>
  named-config>
c3p0-config>

连接池的使用

//1.创建数据库连接池对象
DataSource ds  = new ComboPooledDataSource();
//DataSource ds = new ComboPooledDataSource("otherc3p0");
//2. 获取连接对象
Connection conn = ds.getConnection();

//3.归还连接给连接池
conn.close();
Druid:数据库连接池实现技术,由阿里巴巴提供的
  1. 步骤:
  1. 导入jar包 druid-1.0.9.jar
  2. 定义配置文件:
    是properties形式的
    可以叫任意名称,可以放在任意目录下
  3. 加载配置文件。Properties
  4. 获取数据库连接池对象:通过工厂来来获取 DruidDataSourceFactory
  5. 获取连接:getConnection
  • 代码

    配置文件 druid.properties

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

    连接示例

    public class DruidDemo {
        public static void main(String[] args) throws Exception {
            // 1. 导入jar包
            // 2. 定义配置文件
            // 3. 加载配置文件
            Properties prop = new Properties();
            InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
            prop.load(is);
            // 4. 获取数据库连接池对象
            DataSource ds = DruidDataSourceFactory.createDataSource(prop);
            // 5. 获取连接
            Connection conn = ds.getConnection();
            System.out.println(conn);
        }
    }
    
  1. 定义工具类
  1. 定义一个类 JDBCUtils
  2. 提供静态代码块加载配置文件,初始化连接池对象
  3. 提供方法
        获取连接方法:通过数据库连接池获取连接
        释放资源
        获取连接池的方法
  • 代码:

    package util;
    
    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 JDBCUtils {
    
        static DataSource ds = null;
        static {
    
            try {
                // 1.获取配置文件
                Properties prop = new Properties();
                InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
                prop.load(is);
                // 2.获取连接池对象
                ds = DruidDataSourceFactory.createDataSource(prop);
            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 获取连接
         * @return 连接对象
         * @throws SQLException
         */
        public static Connection getConnection() throws SQLException {
            return ds.getConnection();
        }
    
        /**
         * 关闭资源
         * @param res
         * @param state
         * @param conn
         */
        public static void close(ResultSet res, Statement state,Connection conn){
            if (res!=null){
                try {
                    res.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
    
            if (state != null){
                try {
                    state.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
    
            if (conn != null){
                try {
                    conn.close();  // 归还连接
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 获取连接池
         * @return 返回连接池对象
         */
        public static DataSource getDataSource(){
            return ds;
        }
    }
    

    测试代码:

    import util.JDBCUtils;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.SQLException;
    
    /*
    * 给account 添加一个值
    * */
    public class DruidDemo2 {
        public static void main(String[] args) {
    
            Connection conn = null;
            PreparedStatement pstate = null;
    
            try {
                // 1. 获取连接
                conn = JDBCUtils.getConnection();
    
                // 2. 编写sql 语句
                String sql = "insert into account values(null,?,?)";
                // 3. 获取执行sql语句的对象
                pstate = conn.prepareStatement(sql);
                // 4. 给? 赋值
                pstate.setString(1,"zhangfei");
                pstate.setDouble(2,2000);
                // 5. 执行sql语句
                int res = pstate.executeUpdate();
                // 6. 处理结果
                if (res > 0){
                    System.out.println("插入成功!");
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }finally {
                // 7. 关闭资源
                JDBCUtils.close(null,pstate,conn);
            }
        }
    }
    

Spring JDBC

  • Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发

步骤:

  1. 导入jar包

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

    • JdbcTemplate template = new JdbcTemplate(ds);
  3. 调用JdbcTemplate的方法来完成CRUD的操作
    JDBC连接池&&JdbcTemplate_第1张图片

练习:

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

import c3p0.Emp;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import util.JDBCUtils;

import java.util.List;
import java.util.Map;

public class JdbcTemplateDemo2 {

    //1. 获取JdbcTemplate对象
    static JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());


    /**
     * 修改1号数据的 salary 为 10000
     */
    @Test
    public void test1(){

        // 2. 编写sql 语句
        String sql = "update emp set salary=? where id = ?";

        // 3.调用方法
        int res = template.update(sql, 10000, 1);
        System.out.println(res);
    }

    /**
     * 添加一条记录
     */

    @Test
    public void test2(){
        String sql = "insert into emp values(null,?,?,?)";
        int res = template.update(sql, "wangwu", "2019-01-01", 6000);
        System.out.println(res);
    }

    /*删除添加的记录*/
    @Test
    public void test3(){
        String sql = "delete from emp where ename = ?";
        int res = template.update(sql, "wangwu");
        System.out.println(res);
    }

    /*
    * 查询id为1的记录,将其封装为Map集合
    *
    * 结果将会 将列名作为key,将值作为value,将这条记录封装为一个map集合
    * 这个方法查询的结果集长度只能是1个
    * */
    @Test
    public void test4(){
        String sql = "select * from emp where id = ?";
        Map<String, Object> empMap = template.queryForMap(sql, 1);
        System.out.println(empMap);

        // {id=1, ename=long, join_date=2019-09-17, salary=10000.00}
    }

    /**
     * 查询所有记录,将其封装为List
     * * 注意:将每一条记录封装为一个Map集合,再将Map集合装载到List集合中
     */
    @Test
    public void test5(){
        String sql = "select * from emp";
        List<Map<String, Object>> maps = template.queryForList(sql);
        for(Map<String,Object> map:maps){
            System.out.println(map);
        }

        //{id=1, ename=long, join_date=2019-09-17, salary=10000.00}
        //{id=2, ename=lisi, join_date=2019-09-04, salary=99999.90}
        //{id=3, ename=zahngsan, join_date=2019-09-21, salary=11111.22}
    }

    /**
     * 查询所有记录,将其封装为Emp对象的List集合
     */
    @Test
    public void test6(){
        String sql = "select * from emp";
        List<Emp> query = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
        System.out.println(query);

        // [Emp{id=1, ename='long', join_date=2019-09-17 00:00:00.0, salary=10000.0}, Emp{id=2, ename='lisi', join_date=2019-09-04 00:00:00.0, salary=99999.9}, Emp{id=3, ename='zahngsan', join_date=2019-09-21 00:00:00.0, salary=11111.22}]
    }

    /**
     * 查询总记录数
     */
    @Test
    public void test7(){
        String sql = "select count(id) from emp";

        // 第二个参数是返回的类型
        Integer res = template.queryForObject(sql, Integer.class);
        System.out.println(res);  // 3
    }
}

你可能感兴趣的:(#,JDBC)