JDBC连接池技术-C3P0/Druid

最新推荐文章于 2023-01-05 16:01:41 发布
最新推荐文章于 2023-01-05 16:01:41 发布
阅读量185 收藏
点赞数
分类专栏： 学习经验 文章标签： java 数据库 mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WDNMDnm/article/details/122511520
版权

数据库连接池

在这里插入图片描述

概念：

其实就是一个容器（集合），存放数据库连接的容器。
当系统初始化好后，容器被创建，容器中国会申请一些连接对象，
当用户来访问数据库时，从容器中获取连接对象，
用户访问完毕，将连接对象归还给容器。
优点：
节约资源
用户访问高效率

实现方式：

  1. 标准接口 DataSource javax.sql包下
    方法：
    获取连接：getConnnection()
    归还连接：如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，就不会再关闭连接，而是归还连接。
  2. 交给数据库厂商实现
    1.c3p0：数据库连接池实现技术
    2.druid：数据库连接池实现技术，由阿里巴巴提供，性能高效，号称全世界最好的数据库连接池技术之一。
c3p0的步骤：
1.导入jar包（两个）
- c3p0-0.9.5.2.jar  mchange-commons-java-0.2.12.jar
数据库驱动的jqr包也要导入  mysql-connector-java-8.0.12.jar

2.定义配置文件
- 配置文件名称为 c3p0.properties 或者 c3p0-config.xml
直接将文件放在src目录下即可

3.创建核心对象 
- 数据库连接池对象 ComboPooledDataSource("可以指定配置也可以不指定")
可以指定一个自定义的配置去读取连接池对象，也可以不给值，使用默认的配置

4.获取连接：通过数据库连接池对象获取连接 getConnection()
  • 代码演示
public class C3P0Demo1 {
    public static void main(String[] args) throws SQLException {
        //1.创建数据库连接池对象 父类引用指向子类对象
        DataSource ds  = new ComboPooledDataSource();
        //2. 获取连接对象
        Connection conn = ds.getConnection();
        //3. 打印
        System.out.println(conn);
    }
}

Druid数据库连接池技术

  步骤：
       1.导入jar包
           druid-1.0.9.jar
       2.定义配置文件
           通常叫druid.properties
           名称可以自定义，也可以放在任意目录下
       3.加载配置文件druid.properties
           使用Properties pro = new Properties();    pro.load()方法，传入一个字节输入流
       4.获取数据库连接池对象：
           通过工厂来获取 DruidDataSourceFactory
       5. 获取连接：getConnection


public class DruidDemo {
    public static void main(String[] args) throws Exception {
        //1.导入jar包
        //2.定义配置文件
        //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();
        System.out.println(conn);

    }
}

定义工具类 JDBCUtils减少重复代码

  1. 定义一个类 JDBCUtils
  2. 提供静态代码块加载配置文件，初始化连接池对象
  3. 提供方法
    1. 获取连接方法：通过数据库连接池获取连接
      1. 释放资源
        1. 获取连接池的方法
public class JDBCUtils {

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

    static{
        try {
            //1.加载配置文件
            Properties pro = new Properties();
            pro.load(JDBCUtils.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方法来减少重复代码
       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;
    }

}

C3P0Demo1简化

public class C3P0Demo2 {

    public static void main(String[] args) throws Exception {
       /* //1. 获取DataSource，使用默认配置
        DataSource ds  = new ComboPooledDataSource();

        //2.获取连接

        for (int i = 1; i <= 11 ; i++) {
            Connection conn = ds.getConnection();
            System.out.println(i+":"+conn);

            if(i == 5){
                conn.close();//归还连接到连接池中
            }
        }*/

        //testNamedConfig();

    }

    public static void testNamedConfig() throws Exception {
        // 1.1 获取DataSource，使用指定名称配置
        DataSource ds  = new ComboPooledDataSource("otherc3p0");
        //2.获取连接
        for (int i = 1; i <= 10 ; i++) {
            Connection conn = ds.getConnection();
            System.out.println(i+":"+conn);
        }
    }

}

DruidDemo1简化

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,?,?)";
            //3.获取pstmt对象
            pstmt = conn.prepareStatement(sql);
            //4.给？赋值
            pstmt.setString(1,"王五");
            pstmt.setDouble(2,3000);
            //5.执行sql
            int count = pstmt.executeUpdate();
            System.out.println(count);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            //6. 释放资源
            JDBCUtils.close(pstmt,conn);
        }
    }

}

JDBCTemplate对象简化JDBC的开发


  JdbcTemplate入门
  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：查询结果，将结果封装为对象
  			 一般用于聚合函数的查询，比如count()


//代码实现
public class JdbcTemplateDemo1 {

    public static void main(String[] args) {
        //1.导入jar包
        //2.创建JDBCTemplate对象，参数为数据源
        /** 不使用JBDCUtils工具类要写很多重复代码
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///db3? serverTimezone=GMT&useSSL=false&characterEncoding=utf8");
        dataSource.setUsername("root"); dataSource.setPassword("123456");
        * */
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        //3.调用方法
        String sql = "update account set balance = 5000 where id = ?";
        int count = template.update(sql, 3);
        System.out.println(count);
    }
}

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

public class JdbcTemplateDemo2 {

    //Junit单元测试，可以让方法独立执行
    //1. 获取JDBCTemplate对象
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
    /**
     * 1. 修改1号数据的 salary 为 10000
     */
    @Test
    public void test1(){

        //2. 定义sql
        String sql = "update emp set salary = 10000 where id = 1001";
        //3. 执行sql
        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, 1015, "郭靖", 10);
        System.out.println(count);

    }

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

    /**
     * 4.查询id为1001的记录，将其封装为Map集合
     * 注意：这个方法查询的结果集长度只能是1
     */
    @Test
    public void test4(){
        String sql = "select * from emp where id = ? or id = ?";
        Map<String, Object> map = template.queryForMap(sql, 1001,1002);
        System.out.println(map);
        //{id=1001, ename=孙悟空, job_id=4, mgr=1004, joindate=2000-12-17, salary=10000.00, bonus=null, dept_id=20}

    }

    /**
     * 5. 查询所有记录，将其封装为List
     */
    @Test
    public void test5(){
        String sql = "select * from emp";

        List<Map<String, Object>> list = template.queryForList(sql);
        //快捷输入list.iter
        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 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;
            }
        });
        //快捷输入list.iter
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }

    /**
     * 6.2 查询所有记录，将其封装为Emp对象的List集合
     * 通过RowMpper的实现类简化封装的代码
     */

    @Test
    public void test6_2(){
        String sql = "select * from emp";
        List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(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);
    }

}

实体类Emp

public class Emp {
    private Integer id;
    private String ename;
    private Integer job_id;
    private Integer mgr;
    private Date joindate;
    private Double salary;
    private Double bonus;
    private Integer dept_id;


    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public Integer getJob_id() {
        return job_id;
    }

    public void setJob_id(Integer job_id) {
        this.job_id = job_id;
    }

    public Integer getMgr() {
        return mgr;
    }

    public void setMgr(Integer mgr) {
        this.mgr = mgr;
    }

    public Date getJoindate() {
        return joindate;
    }

    public void setJoindate(Date joindate) {
        this.joindate = joindate;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    public Double getBonus() {
        return bonus;
    }

    public void setBonus(Double bonus) {
        this.bonus = bonus;
    }

    public Integer getDept_id() {
        return dept_id;
    }

    public void setDept_id(Integer dept_id) {
        this.dept_id = dept_id;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "id=" + id +
                ", ename='" + ename + '\'' +
                ", job_id=" + job_id +
                ", mgr=" + mgr +
                ", joindate=" + joindate +
                ", salary=" + salary +
                ", bonus=" + bonus +
                ", dept_id=" + dept_id +
                '}';
    }
}

C3P0数据库连接池配置文件c3p0-config.xml

<c3p0-config>
  <!-- 使用默认的配置读取连接池对象 -->
  <default-config>
  	<!--  连接参数 -->
    <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/db3?serverTimezone=GMT%2B8&amp;useSSL=false&amp;characterEncoding=utf-8</property>
    <property name="user">root</property>
    <property name="password">123456</property>
    
    <!-- 连接池参数 -->
    <!--初始化申请的连接数量-->
    <property name="initialPoolSize">5</property>
    <!--最大的连接数量-->
    <property name="maxPoolSize">10</property>
    <!--超时时间-->
    <property name="checkoutTimeout">3000</property>
  </default-config>

  <!--  可以配置多个config，可以用同一个文件去操作不同的数据库 -->
  <named-config name="otherc3p0"> 
    <!--  连接参数 -->
    <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/db3?serverTimezone=GMT%2B8&amp;useSSL=false&amp;characterEncoding=utf-8</property>
    <property name="user">root</property>
    <property name="password">123456</property>
    
    <!-- 连接池参数 -->
    <property name="initialPoolSize">5</property>
    <property name="maxPoolSize">8</property>
    <property name="checkoutTimeout">1000</property>
  </named-config>
</c3p0-config>

Druid连接池配置文件druid.properties

driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/db3?serverTimezone=GMT%2B8&useSSL=false&characterEncoding=utf-8
# 数据库登录用户名
username=root
#  数据库登录密码
password=123456
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大等待时间
maxWait=3000
我是咸鱼丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDBC连接池使用工具 C3P0 连接池 and druid-1.0.9
04-11
JDBC - Java 连接Mysql JDBC连接池使用工具 C3P0 连接池 and druid-1.0.9
JDBC常用连接池 c3p0 BDCP Druid
12-19
C3P0是一个开放源代码的JDBC连接池，它在lib目录中与Hibernate一起发布,包括了实现jdbc3和jdbc2扩展规范说明的Connection 和Statement 池的DataSources 对象 DBCP （Database Connection Pool）是一个依赖Jakarta ...
JDBC---数据库连接池之C3p0
大呱的博客
01-05 192
JDBC---数据库连接池之C3p0
JDBC --- 数据库连接池 & C3P0
qq_57151931的博客
01-05 1032
C3P0
JDBC数据库连接池（Druid技术）
keepstrivingchy的博客
07-25 922
day14 JDBC基础03 以及一些杂的补充知识点
jdbc之Druid数据库连接池
weixin_45439287的博客
01-03 213
jdbc之Druid数据库连接池
JDBC笔记5(基础—c3p0连接池)
wangshiqi666的博客
10-17 1451
使用ComboPooledDataSource连接池对象来对jdbc进行配置。
数据库连接池资源包（c3p0 , dbcp,druid连接池）
12-04
数据库连接池的资源包（c3p0 , dbcp,druid连接池）
C3P0连接池jar包,mysql-connector-java-5.1.37,druid连接池jar包，commons-dbu
07-26
jdbc学习时，需要的jre资源包
数据库连接池druid，c3p0，jdbctemplate，jar包.rar
08-13
数据库连接池jar包，包含c3p0、druidjar包和依赖jar包，c3p0通过配置文件xml或者properties读取连接对象 druid通过properties读取连接，使用springJDBC JdbcTempalte简化sql操作
Java Jdbc mysql数据库连接驱动和c3p0 jar包极其配置文件
02-26
适用于mysql8，数据库连接池c3p0，亲测适用。
jdbc使用c3p0连接池连接数据库的工具类
12-23
jdbc使用c3p0连接池连接数据库，支持配置多个数据源，有相关的查询测试。
c3p0数据库连接池的使用
梅子酒的博客
12-12 1394
c3p0连接数据库
关于.class.getClassLoader().getResourceAsStream
热门推荐
成神之路
03-29 1万+
从配置文件读取获得连接mysql数据库的代码中，有这么一段InputStream in=JDBCUtilsConfig.class.getClassLoader().getResourceAsStream("database.properties"); Properties pro = new Properties(); pro.load(in);其中 JDBCUtilsConfig.class是
关于InputStream in = JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties")的介绍
dragon901的博客
04-03 1万+
上述代码 pro创建一个静态的Properties对象JDBCUtil.class是创建一个JDBCUtil的Class对象可能有很多人不知道Class对象是什么这里简单介绍一下Class类：Java程序在运行时，Java运行时系统一直对所有的对象进行所谓的运行时类型标识，即所谓的RTTI。这项信息纪录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去执行，用来保存这些类型信息的类是C...
C3P0连接池、DRUID连接池和JdbcTemplate
yfy的博客
09-02 3284
  目录 一、C3P0连接池 1.C3P0连接池简介 2.常用的配置参数 3.C3P0连接池基本使用 （1）C3P0配置文件 （2）API介绍 4.使用步骤 二、DRUID连接池 1. DRUID简介 2.DRUID连接池基本使用 （1）API介绍 （2）使用步骤 （3）配置文件 （4）DataSourceUtils工具类 三、JdbcTemplate 1. Jd...
JDBC以及数据库连接池（C3P0和Druid）实现连接MySQL
weixin_42467369的博客
09-13 657
JDBC JDBC全称是Java Database Connectivity，意思是用Java语言管理关系数据库。 Java给JDBC定义了一套规则，去管理关系型数据库，而这些规则的实现需要相应关系型数据库的厂商去实现。 如果要使用JDBC管理关系型数据数据库，就需要导入相应数据库驱动的jar包 JDBC的作用是，连接数据库，然后执行SQL语句 JDBC与数据库的关系 使用JDBC连接MySQL 使用JDBC的时候，只需导入相应数据库的驱动jar包即可。例如，我是用的是MySQL，则需要MySQL的jar
JDBC——连接池Druid，C3P0的使用
weixin_46848251的博客
08-06 86
Druid阿里旗下开源连接池产品，使用非常简单，可以与Spring框架进行快速整合。 使用：①导入jar包，druid-1.1.2.jar；②DataSource datasource = DruidDataSourceFactory.createDataSource(prop); package Druid; import java.io.FileInputStream; import java.sql.Connection; import java.sql.PreparedStatement;
数据库连接池相关配置。 c3p0,tomcat jdbc,druid
laokaizzz的专栏
12-18 591
c3p0 destroy-method="close">  pom.xml dependency> groupId>c3p0groupId> artifactId>c3p0artifactId> version>0.9.1.2version> dependency> tomcat jdbc be
常用数据库连接池 (DBCP、c3p0、Druid) 配置说明
最新发布
06-01
常用的数据库连接池有 DBCP、c3p0 和 Druid。它们都是用来提高数据库连接的效率和性能的。 以下是它们的配置说明： 1. DBCP DBCP 是 Apache 开源组织提供的连接池，配置方式如下： ``` <!-- 引入 DBCP 依赖 --> ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值