数据库连接池介绍

最新推荐文章于 2023-03-19 18:50:06 发布
最新推荐文章于 2023-03-19 18:50:06 发布
阅读量346 收藏
点赞数
分类专栏： java基础 文章标签： 数据库 java mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiao_suan_cai/article/details/126443380
版权

数据库连接池介绍

数据库连接池

1. 概念：

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

2. 好处：

   1. 节约资源
   2. 用户访问高效
    申请获取连接时，是调用底层的一项操作，对资源和时间的耗费较长，用户体验感较差，如果使用线程池，直接从线程池中申请对象，会减少响应时间，其次就是执行jdbc后，连接对象归还到容器，能实现连接对象的复用。

3. 实现：

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

4. C3P0:数据库连接池技术

  * 步骤：
  1. 导入jar包 （两个） c3p0-0.9.5.2.jar和mchange-commons-java-0.2.12.jar
    *不要忘记导入数据库驱动jar包
在这里插入图片描述

  2. 定义配置文件：

<c3p0-config>
  <!-- 使用默认的配置读取连接池对象 -->
  <default-config>
  	<!--  连接参数 -->
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/db1</property>
    <property name="user">root</property>
    <property name="password">root</property>
    
    <!-- 连接池参数 -->
    <!--    初始化申请的连接数量：初始化5个   -->
    <property name="initialPoolSize">5</property>
    <!--    最大的连接数量：10个   -->
    <property name="maxPoolSize">10</property>
    <!--    超时时间：3秒   -->
    <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/db1</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目录下即可c3p0.properties or c3p0-config.xml
在这里插入图片描述

  3. 创建核心对象 数据库连接池对象 comboPooledDataSource

DataSource ds = new ComboPooledDataSource();

  4. 获取连接： getConnection

// 2、获取连接对象
        Connection conn = ds.getConnection();
  • 测试数据库线程池中对象，通过打印线程池中对象的哈希值，来证明线程池中的对象是否存在。
package cn.itcast.SpringJDBC.C3P0;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * C3P0的演示
 */
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);
    }
}

测试代码如下显示：在这里插入图片描述

  • 通过检验可得，在创建线程池后，确实有相应的连接对象存在。
  • 此时我们通过循环，来检测数据库线程池中的最大连接数，代码如下：
public static void main(String[] args) throws SQLException {
        // 1、获取DataSource，使用默认配置
        DataSource ds = new ComboPooledDataSource();
        // 2.获取连接
        for(int i = 1;i<=11;i++){
            Connection conn = ds.getConnection();
            System.out.println(conn);
        }
  • 运行结果如下：在这里插入图片描述
  • 通过比较可得出，线程池中确实存在配置文件中的最大连接数的哈希值，但还存在一个问题，如果此时有访问数据库的用户需要申请的连接对象超过了线程池中的连接对象，那该如何处理呢？
        1、要合理控制数据库线程池中的连接对象个数，其中要考虑到服务器或者本机的最大访问量和自身的资源问题。
        2、用户在申请连接对象时，并不是同时申请，是存在一定的时间差，所以我们可以通过及时归还连接对象，也可以达到超过连接对象的最大数量的连接请求。
        代码示例如下：
public static void main(String[] args) throws SQLException {
        // 1、获取DataSource，使用默认配置
        DataSource ds = new ComboPooledDataSource();
        // 2.获取连接
        for(int i = 1;i<=11;i++){
            Connection conn = ds.getConnection();
            System.out.println(conn);
            if (i==5){
                conn.close();  // 归还连接到连接池中
            }
        }
  • 通过在循环申请线程池的连接对象过程中，我们及时归还了第五个申请的连接对象，那么在超过最大连接数的申请中，执行代码可以进行验证此种方法是否可行。
    在这里插入图片描述
  • 那么此时我们可以看到，因为在第五次申请连接对象时，及时将连接对象归还到线程池中，第六次申请连接对象的哈希码与第五次的哈希码完全一致。因此刚才提出的方法是能够解决部分超过最大连接量的线程池连接对象申请。
 - C3P0为用户提供了一个灵活的访问数据库的方式，就是可以采用多个自定义的数据库连接池配置

<named-config name="otherc3p0"> 
    <!--  连接参数 -->
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/db1</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>
  • 我们可以定义多个连接池，操作多个数据库中表来进行数据的访问。
  • 操作方法如下： 在这里插入图片描述

5. Druid：

数据库连接池实现技术，由阿里巴巴提供
 1. 步骤：
    1. 导入jar包 druid-1.0.9.jar
在这里插入图片描述
  2. 定义配置文件：
    * 是properties形式的

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///db1
username=root
password=root
# 初始化连接数量为5个
initialSize=5
# 最大连接数为10个
maxActive=10
# 最大等待时间为3秒（3000毫秒）
maxWait=3000

    * 可以叫任意名称，可以放在任意目录下面

  3. 获取数据库连接池对象：通过工厂类来获取，DruidDataSourceFactory
代码如下：

 // 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();
        }

  4. 获取连接getConnection

Connection connection = ds.getConnection;

 2. 定义工具类
    1. 定义一个类 JDBCUtils

public class JdbcUtils {}

  2. 提供静态代码块来加载配置文件，初始化连接池对象

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();
        }

 3. 提供方法
    1. 获取连接方法：通过数据库连接池来获取连接

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

    2. 释放资源

/**
     * 释放资源
*/
    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();
            }
        }

    }
    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();
            }
        }
    }

    3. 获取连接池的方法

/**
     * 获取连接池方法
     */
    public static DataSource getDataSource(){
        return ds;  // 无论为不为空都进行返回
    }

完整代码如下：

package 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 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(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;  // 无论为不为空都进行返回
    }
}

那么我们就完成了一个简单的druid的工具类封装。

检验练习

练习1

现在通过简单的使用工具类来实现Druid的使用：

import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;
/**
 *  Druid演示
 */
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);

    }
}

运行结果入戏下：在这里插入图片描述
那么说明我们写的这段代码能够有效的执行数据库线程池的连接对象的申请。

练习2

通过以上操作我们可以进行一个简单的小demo：完成一个添加的操作，给account表添加一条记录

public class DruidDemo2 {
    public static void main(String[] args) {
        /**
         * 完成一个添加的操作，给account表添加一条记录
         */
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            // 1、获取连接
            conn = JdbcUtils.getConnection();
            // 2、定义sqle
            String sql = "insert into account values(null,?,?)";
            // 3、获取pstmt对象
            pstmt = conn.prepareStatement(sql);
            // 4、给？赋值
            pstmt.setString(1,"wangwu");
            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);
        }
    }
}

通过代码运行与数据库查询我们发现能够执行对数据库中表的添加数据的操作：
在这里插入图片描述
我们使用sql语句进一步验证：
在这里插入图片描述

练习3

那么我们通过Druid进行对数据的增删改查操作。

package cn.itcast.SpringJDBC.Druid;

import Utils.JdbcUtils;
import cn.itcast.domain.Emp;

import java.sql.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;


public class JDBCDruidDemo {
        Connection conn = null;
        ResultSet rs = null;
        PreparedStatement pstmt = null;
        Statement stmt = null;
    List<Account> list = null;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请你输入要执行的操作：\n1.添加用户操作\t2、删除用户操作\n3、更改用户信息\t4、查询用户信息\n");
        int i = sc.nextInt();
        switch (i){
            case 1:
                System.out.println("请你输入想要添加的用户：");
                String name = sc.next();
                System.out.println("请你输入该用户的金额：");
                double balance = sc.nextDouble();
                new JDBCDruidDemo().Add(name,balance);
                break;
            case 2:
                System.out.println("请你输入想要删除的用户id：");
                int id = sc.nextInt();
                new JDBCDruidDemo().delete(id);
                break;
            case 3:
                System.out.println("请你输入想要更改的用户：");
                String oname = sc.next();
                System.out.println("请您输入更改后的用户名：");
                name = sc.next();
                System.out.println("请您输入更改后的金额：");
                balance = sc.nextDouble();
                new JDBCDruidDemo().update(oname,name,balance);
                break;
            case 4:
                List<Account> list = new JDBCDruidDemo().find();
                System.out.println(list);
                break;
            default:
                System.out.println("操作有误，请重新执行！");
                break;
        }
    }
    /**
     * jdbc添加数据练习
     */
    public void Add(String name,double balance){
        try {
            // 1、获取连接
            conn = JdbcUtils.getConnection();
            // 2、定义sql
            String sql = "insert into account values(null,?,?)";
            // 3、获取对象
            pstmt = conn.prepareStatement(sql);
            // 4、赋值？
            pstmt.setString(1,name);
            pstmt.setDouble(2,balance);
            // 5、执行sql
            int count = pstmt.executeUpdate();
            if (count==1){
                System.out.println("插入成功");
            }else{
                System.out.println("插入失败");
            }
            System.out.println(count);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 6、释放资源
            JdbcUtils.close(pstmt,conn);
        }
    }
    /**
     * jdbc删除数据练习
     */
    public void delete(int id){

        try {
            // 1、获取连接
            conn = JdbcUtils.getConnection();
            // 2、定义sql
            String  sql = "delete from account where id = ?";
            // 3.获取对象
            pstmt = conn.prepareStatement(sql);
            // 4.为？赋值
            pstmt.setInt(1,id);
            // 5、执行sql
            int count = pstmt.executeUpdate();
            if (count==1){
                System.out.println("删除成功");
            }else{
                System.out.println("删除失败");
            }
            System.out.println(count);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 6、释放、归还资源
            JdbcUtils.close(pstmt,conn);
        }
    }
    public void update(String oname,String name,double balance){
        try {
            // 1、创建连接
            conn = JdbcUtils.getConnection();
            // 2、定义sql语句
            String sql = "update  account set name =?,balance=? where name = ?";
            // 3、获取对象
            pstmt = conn.prepareStatement(sql);
            // 4.为？赋值
            pstmt.setString(1,name);
            pstmt.setDouble(2,balance);
            pstmt.setString(3,oname);
            // 5、执行sql
            int count = pstmt.executeUpdate();
            if (count==1){
                System.out.println("更改成功");
            }else{
                System.out.println("更改失败");
            }
            System.out.println(count);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 6、释放资源
        }
    }
    public List<Account> find(){
        try {
            // 1、获取连接
            conn = JdbcUtils.getConnection();
            // 2、定义sql
            String sql = "select * from account";
            // 3、获取对象
            pstmt = conn.prepareStatement(sql);
            // 4、执行sql
           rs = pstmt.executeQuery();
           Account account = null;
           list = new ArrayList<Account>();
           while(rs.next()){
               // 获取数据
               int id = rs.getInt("id");
               String name = rs.getString("name");
               double balance = rs.getDouble("balance");
              //  System.out.println(id+"-----------"+name+"----------"+balance);
               account = new Account();
               account.setId(id);
               account.setName(name);
               account.setBalance(balance);
               list.add(account);

           }
           // System.out.println(list);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 6、释放资源
            JdbcUtils.close(rs,stmt,conn);
        }
        return list;
    }
}

执行验证：
界面：
在这里插入图片描述
输入1进行添加用户数据：
在这里插入图片描述
输入2进行删除数据：因为之前做了一些，因此多了一条6的数据，现在进行删除，最后进行统一查询数据。
在这里插入图片描述
输入3进行数据的修改：
在这里插入图片描述
输入4进行所有操作的检查：
在这里插入图片描述
经过检验，比较粗糙的完成了我们的需求，进行了较为简单的增删改查的任务。

TingFeng清风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据库连接池简单介绍
xylyaya的博客
01-01 119
• 传统连接方式 首先调用Class.forName() 方法加载数据库驱动，然后调用DriverManager.getConnection() 方法建立连接。 • 连接池技术 连接池解决方案是在应用程序启动时就预先建立多个数据库连接对象，然后将连接对象保存到连接池中。当客户请求到来时 从池中取出一个连接对象为客户服务。当请求完成时客户程序调用 close() 方法将连接对象放回池中 。...
数据库连接池简介
liitdar的博客
08-21 916
本文简要介绍数据库连接池（connection pool）的相关知识。
数据库连接池介绍及使用
weiyoo55的博客
09-01 256
数据库连接池 **1.概念：**其实就是一个容器（集合），存放数据库连接的容器 ​ 当系统初始化好之后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还容器。 2.好处： ​ （1）节约资源 ​ （2）用户访问高效 3.实现： (1):标准接口：DataSource javax.sql包下的 1）方法: 获取连接：getConnection(); 归还连接：如果连接对象Co
数据库连接池
a2398496515的博客
11-20 318
数据库连接池是个容器，负责分配、管理数据库连接（Connection），它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个，释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏
DBCP数据库连接池的连接有效检测配置
Kirito_j的博客
05-06 3636
基本配置initialSize ：连接池启动时创建的初始化连接数量（默认值为0）maxActive：连接池中可同时连接的最大的连接数（默认值为8，调整为20，高峰单机器在20并发左右，自己根据应用场景定）maxIdle：连接池中最大的空闲的连接数，超过的空闲连接将被释放，如果设置为负数表示不限制（默认为8个，maxIdle不能设置太小，因为假如在高负载的情况下，连接的打开时间比关闭的时间快，会引起...
c# mysql数据库连接池实现
最新发布
03-24
本文将深入探讨如何在C#中使用MySQL数据库连接池。 首先，我们需要了解什么是数据库连接池。数据库连接池是一种资源管理技术，它预先创建并维护一定数量的数据库连接，当应用需要时，可以从池中获取连接，使用完毕...
Druid数据库连接池介绍.pptx
09-18
Druid数据库连接池介绍.pptx
Java实现数据库连接池简易教程
09-02
本文将介绍一个简单的数据库连接池实现，包括设计思路和关键类的讲解。 首先，我们来看一下数据库连接池的核心类： 1. **ConnectionParam**：这是一个配置类，用于存储数据库连接的相关参数，如驱动名（driver）、...
03-数据库连接池驱动_数据库连接池；驱动_
10-01
数据库连接池是现代应用程序开发中的重要组成部分，尤其是在处理大量数据交互的应用中，它极大地提高了数据库操作的效率和系统的稳定性。本资源"03-数据库连接池驱动"包含了三种常用的数据库连接池驱动：C3P0、Druid...
Java实现数据库连接池的方法
09-03
Java数据库连接池是一种管理数据库连接的技术，通过复用已存在的数据库连接来提高应用程序的性能，减少新连接的创建和释放带来的开销。在Java中，实现数据库连接池主要有以下步骤： 1. **配置数据库连接参数**： `...
数据库连接池的测试
Faith的博客
11-08 1470
一、什么是数据库连接池？ 官方：数据库连接池（Connection pooling）是程序启动时建立足够的数据库连接，并将这些连接组成一个连接池，由程序动态地对池中的连接进行申请，使用，释放。 个人理解：创建数据库连接是一个很耗时的操作，也容易对数据库造成安全隐患。所以，在程序初始化的时候，集中创建多个数据库连接，并把他们集中管理，供程序使用，可以保证较快的数据库读写速度，还更加安全可靠。 二、...
数据库连接池之配置
绣花针
06-18 805
目录 一、基本配置 二、关键配置 三、性能配置 1.预缓存设置 2.连接有效性检测设置 3.超时连接关闭设置 4.重连设置 一、基本配置 基本配置是指连接池进行数据库连接的四个基本必需配置，传递给JDBC驱动的用于连接数据库的用户名、密码、URL以及驱动类名 注意：在Druid连接池的配置中，driverClassName可配可不配，如果不配置会根据url自动识别dbType...
JDBC与数据库连接池
slivelight的博客
09-03 1426
JDBC 简介 JDBC 是Java应用程序用来连接关系型数据库的标准API，为多种关系型数据库提供一个统一的访问接口。Sun公司一共定义4种 JDBC 驱动类型，一般使用第4种，该类型的Driver完全由Java代码实现，通过使用socket与数据库进行通信。 JDBC-ODBC Bridge driver (bridge driver)，JDBC-ODBC桥驱动程序； Native-API/partly Java driver (native driver)，JDBC本地API； All Ja
数据库连接池中连接有效性探测的几种方式
雨潇的专栏
03-19 3326
但凡涉及到数据库的应用，基本上都离不开数据库连接池工具的使用，但在使用时，对于应用而言，无需关注你获取到的连接是否可用，不像之前，有个著名的MySQL连接8小时问题，现在根本不用关心从连接池拿到的连接是否可用，你拿到了说明就是可用的，这一点是数据库连接池的框架保证的，常见的数据库连接池都有保证，今天主要探讨下SpringBoot默认的数据库连接池HikariCP和Durid连接池在连接的有效性探测的差异。
Spring Boot2.0配置Druid数据库连接池（单数据源、多数据源、数据监控）
热门推荐
你好，我们在哪里见过啊！
06-22 2万+
我这里使用的开发环境是：IDEA（2017），JDK(1.8)，Maven(3.3.9)，SpringBoot(使用的是2.0.3版本，详细创建过程可以参考：https://blog.csdn.net/qq_38455201/article/details/80742205)一：单数据源的配置以及数据监控第一步：导入maven依赖&lt;!--数据库连接驱动和连接池依赖--&gt; &lt;!--...
常用数据库连接池技术小结
哈
06-24 1352
数据库连接池技术有很多，常用的有c3p0、dbcp、proxool、bonecp、droid等： DBCP DBCP是一个依赖Jakarta commons-pool对象池机制的数据库连接池。 DBCP可以直接的在应用程序用使用，可以设置最大和最小连接，连接等待时间等，基本功能都有，此连接池的持续运行的稳定性还是可以，不过速度稍慢，在大并发量的压力下稳定性有所下降，此外不提供连接池监控 连接池参数说明如下： dataSource：要连接的 datasource defaultAutoCommit：对于事务
常用的数据库连接池技术
u012315155的专栏
04-18 1110
常用的数据库连接池技术有DBCP和C3P0  1、DBCP技术，这个连接池的技术的核心类是BasicDataSource，当需要使用这个连接池技术的时候就需要引入相应的jar包，Commons-dbcp.jar和Commons-pool.jar 可以使用硬编码的方式来实现连接池，也可以使用配置文件的方式来实现连接池技术，其中这里的配置文件就是一个Properties文件。示例代码如下： Ba
JDBC之多种开源数据库连接池介绍
Zxy_zzz的博客
05-19 1118
目录 一、多种开源的数据库连接池 二、C3P0数据库连接池 三、DBCP数据库连接池 四、 Druid（德鲁伊）数据库连接池 一、多种开源的数据库连接池 1、JDBC 的数据库连接池使用 javax.sql.DataSource 来表示，DataSource 只是一个接口，该接口通常由服务器(Weblogic, WebSphere, Tomcat)提供实现，也有一些开源组织提供实现： （1）DBCP 是Apache提供的数据库连接池。tomcat服务器自带dbcp数据库连接池。速度相对C3
数据库连接池原理与应用
本章主要介绍了数据库连接池的概念、原理和使用方法，包括DBCP和C3P0等常见连接池的配置。此外，还讨论了直接使用数据库连接的缺点，如事务冲突、连接创建耗时和维护成本高。数据库连接池通过预先建立一组连接，按需...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值