JDBC实现自定义连接池、C3P0连接池和DBCP连接池的简单使用

最新推荐文章于 2022-04-22 17:04:54 发布
最新推荐文章于 2022-04-22 17:04:54 发布
阅读量1.4k 收藏 3
点赞数 1
分类专栏： JavaWeb基础 文章标签： JDCB连接池 C3P0连接池 DBCP连接池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jsagacity/article/details/80083363
版权

一、自定义连接池

1、连接池概念

用池来管理 Connection，这样可以重复使用 Connection。有了池，所以我们就不用自己来创建 Connection，而是通过池来获取 Connection 对象。当使用完 Connection 后，调用 Connection 的 close() 方法也不会真的关闭 Connection，而是把 Connection “归还”给池。池就可以在利用这个 Connection 对象了。

这里写图片描述

2、编写自定义连接池的步骤

  1. 创建连接池实现（数据源），并实现接口 java.sql.DataSource。因为我们只使用该接口中 getConnection() 方法，简化本案例，我们将自己提供方法，而没有实现接口；
  2. 提供一个集合，用于存放连接，因为移除/添加操作过多，所以选择 LinkedList；
  3. 本案例在静态代码快中，为连接池初始化5个连接；
  4. 之后程序如果需要连接，调用实现类的 getConnection()，本方法将从连接池（容器 List）获得连接。为了保证当前连接只能提供给一个线程使用，所以我们需要将连接先从连接池中移除；
  5. 当用户使用完连接，释放资源时，不执行 close() 方法，而是将连接添加到连接池中。

首先创建一个数据源，并实现 DataSource 接口。要新建和覆盖的方法已经贴出来：

/**
 * Created by Layne_Yao on 2018-4-25 下午4:51:17.
 * CSDN:http://blog.csdn.net/Jsagacity
 */
public class MyDataSource implements DataSource{
    //1.创建1个容器用于存储Connection对象
    private static LinkedList<Connection> pool = new LinkedList<>();

    //2.创建5个连接放到容器中去
    static{
        for (int i = 0; i < 5; i++) {
            Connection conn = BaseConnection.getConnection();
            pool.add(conn);
        }
    }

    /**
     * 重写获取连接的方法
     */
    @Override
    public Connection getConnection() throws SQLException {
        Connection conn = null;
        //3.使用前先判断
        if(pool.size() == 0){
            //连接池为空，我们就创建一些连接，并添加进去
            for (int i = 0; i < 5; i++) {
                conn = BaseConnection.getConnection();
                pool.add(conn);
            }
        }
        //5.从池子里面获取一个连接对象Connection
        conn = pool.remove(0);
        return conn;
    }


    /**
     * 归还连接对象到连接池中去
     */
    public void backConnection(Connection conn){
        pool.add(conn);

    }
    //其他方法省略......
}

接着测试一下这个连接池的使用：

/**
     * 使用未改造过的connection
     */
    @Test
    public void testAddPerson() {
        Connection conn = null;
        PreparedStatement pstmt = null;
        // 1.创建自定义连接池
        MyDataSource dataSource = new MyDataSource();
        try {
            conn = dataSource.getConnection();
            String sql = "insert into person (name,age) values(?,?)";
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, "Layne");
            pstmt.setInt(2, 20);
            int count = pstmt.executeUpdate();
            if (count > 0) {
                System.out.println("添加成功");
            } else {
                System.out.println("添加失败");
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            dataSource.backConnection(conn);
        }
    }

经测试，成功使用的，没有问题。


3、增强连接池的方法

提需求：
在自定义连接池中存在严重问题，用户调用 getConnection() 获得连接后，必须使用 backConnection() 方法进行连接归还，如果用户调用 conn.close() 将连接真正的释放，那么连接池的存在意义就不大了。

此时我们希望，即使用户调用了 close() 方法，连接仍归还给连接池。close() 方法原有功能是释放资源。而我们期望的功能是：将当前连接归还连接池。所以我们将对 close() 方法进行增强。

增强方法的方案

装饰者设计模式：此设计模式专门用于增强方法。
使用前提：必须有接口
缺点：需要将接口的所有方法都实现

增强方法步骤

装饰者固定结构：接口 A，已知实现类 C，需要装饰者创建代理类 B

  1. 创建类 B，并实现接口 A；
  2. 提供类 B 的构造方法，参数类型为 A，用语言接收 A 接口的其他实现类（C）；
  3. 给类 B 添加类型为 A 成员变量，用于存放 A 接口的其他实现类；
  4. 增强需要的方法；
  5. 实现不需要增强的方法，方法体重调用成员变量存放的其他实现类对应的方法。

创建代理类，并按照步骤实现功能：

//1.实现同一个接口Connection
public class MyConnection implements Connection{
    //3.定义一个变量
    private Connection conn;
    private LinkedList<Connection> pool;

    //2.编写一个构造方法（参数使用了面向对象的多态性）
    public MyConnection(Connection conn,LinkedList<Connection> pool){
        this.conn = conn;
        this.pool = pool;
    }

    //4.书写需要增强的方法
    @Override
    public void close() throws SQLException {
        pool.add(conn);

    }

    //此方法也覆盖一下
    @Override
    public PreparedStatement prepareStatement(String sql) throws SQLException {
        // TODO Auto-generated method stub
        return conn.prepareStatement(sql);
    }
    //其他方法省略......
}

实现完之后，改造一下数据源，也就是连接池：

/**
 * Created by Layne_Yao on 2018-4-25 下午4:51:17.
 * CSDN:http://blog.csdn.net/Jsagacity
 */
public class UpdateMyDataSource implements DataSource{
    //1.创建1个容器用于存储Connection对象
    private static LinkedList<Connection> pool = new LinkedList<>();

    //2.创建5个连接放到容器中去
    static{
        for (int i = 0; i < 5; i++) {
            Connection conn = BaseConnection.getConnection();
            //放入池子中connection对象已经经过改造了
            MyConnection myconn = new MyConnection(conn,pool);
            pool.add(myconn);
        }
    }

    /**
     * 重写获取连接的方法
     */
    @Override
    public Connection getConnection() throws SQLException {
        Connection conn = null;
        //3.使用前先判断
        if(pool.size() == 0){
            //连接池为空，我们就创建一些连接，并添加进去
            for (int i = 0; i < 5; i++) {
                conn = BaseConnection.getConnection();
                //放入池子中connection对象已经经过改造了
                MyConnection myconn = new MyConnection(conn,pool);
                pool.add(myconn);
            }
        }
        //5.从池子里面获取一个连接对象Connection
        conn = pool.remove(0);
        return conn;
    }


    /**
     * 归还连接对象到连接池中去
     */
    public void backConnection(Connection conn){
        pool.add(conn);

    }
    //其他方法省略......
}

增强完成，最后测试使用一下：

/**
     * 使用改造过的connection
     */
     @Test
    public void testAddPerson1() {
        Connection conn = null;
        PreparedStatement pstmt = null;
        // 1.创建自定义连接池
        DataSource dataSource = new UpdateMyDataSource();
        try {
            conn = dataSource.getConnection();
            String sql = "insert into person (name,age) values(?,?)";
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, "Layne1");
            pstmt.setInt(2, 18);
            int count = pstmt.executeUpdate();
            if (count > 0) {
                System.out.println("添加成功");
            } else {
                System.out.println("添加失败");
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            BaseConnection.closeResource(null, pstmt, conn);
        }
    }

经测试，也是添加成功的。以上就是简单的自定义连接池，并增强方法的实现。其主要代码都已经贴出来了，就没必要上传源码了。

二、C3P0连接池

C3P0开源免费的连接池！目前使用它的开源项目有：Spring、Hibernate等。使用第三方工具需要导入jar包，c3p0使用时还需要添加配置文件c3p0-config.xml

将文件c3p0-config.xml放在src的目录下：

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>

    <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql:///test</property>
        <property name="user">root</property>
        <property name="password">ssy_root</property>
        <property name="initialPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </default-config>

    <named-config name="mysql">
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql:///test</property>
        <property name="user">root</property>
        <property name="password">ssy_root</property>
    </named-config>


</c3p0-config>

然后导入c3p0的jar包：
这里写图片描述

导入完成之后，其实就可以直接使用的：

@Test
    public void testAddPerson() {
        Connection conn = null;
        PreparedStatement pstmt = null;
        // 1.创建自定义连接池
        ComboPooledDataSource dataSource = new ComboPooledDataSource();//加载默认的配置
//      ComboPooledDataSource dataSource = new ComboPooledDataSource("mysql");//加载对应名称的配置
        try {
            conn = dataSource.getConnection();
            String sql = "insert into person (name,age) values(?,?)";
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, "LayneYao");
            pstmt.setInt(2, 18);
            int count = pstmt.executeUpdate();
            if (count > 0) {
                System.out.println("添加成功");
            } else {
                System.out.println("添加失败");
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }  finally {
            C3P0Utils.close(conn, pstmt, null);
        }
    }

1、编写C3P0的工具类

编写C3P0的工具类，让代码更加的简洁一些添加一个工具类：

public class C3P0Utils {
    private static ComboPooledDataSource dataSource = new ComboPooledDataSource();

    public static DataSource getDataSource() {
        return dataSource;
    }

    public static Connection getConnection() {
        try {
            return dataSource.getConnection();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

      /** 
     * 关闭数据库连接 
     * @param conn 
     */  
    public static void closeConn(Connection conn){
        try {  
            if(conn!=null && conn.isClosed()){  
                conn.close();  
            }  
        } catch (SQLException e) {  
            e.printStackTrace();  
        }  
    }

    //释放连接回连接池
    public static void close(Connection conn,PreparedStatement ps,ResultSet rs){  
           if(rs!=null){  
               try {  
                   rs.close();  
               } catch (SQLException e) {  
                   e.printStackTrace();  
               }  
           }  
           if(ps!=null){  
               try {  
                   ps.close();  
               } catch (SQLException e) {  
                   e.printStackTrace();  
               }  
           }  

           if(conn!=null){  
               try {  
                   conn.close();  
               } catch (SQLException e) {  
                   e.printStackTrace();  
               }  
           }  
       }  
}

然后测试使用一下：

    @Test
    public void testAddPerson1() {
        Connection conn = null;
        PreparedStatement pstmt = null;

        try {
            conn = C3P0Utils.getConnection();
            String sql = "insert into person (name,age) values(?,?)";
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, "Layne1");
            pstmt.setInt(2, 18);
            int count = pstmt.executeUpdate();
            if (count > 0) {
                System.out.println("添加成功");
            } else {
                System.out.println("添加失败");
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            C3P0Utils.close(conn, pstmt, null);
        }
    }

代码就是变得如此简洁。

三、DBCP连接池

DBCP也是一个开源的连接池，是Apache Common成员之一，在企业开发中也比较常见，tomcat内置的连接池。
首先导包：
这里写图片描述

配置文件：

  • 配置文件名称：*.properties
  • 配置文件的位置：任意，建议src（classpath/类路径）
  • 配置文件内容：properties不能编写中文，不支持在STS中修改，必须使用记事本修改内容，否则中文注释就乱码了
#连接设置
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
username=root
password=ssy_root

#<!-- 初始化连接 -->
initialSize = 10

#最大连接数量
maxActive = 50

#<!-- 最大空闲连接 -->
maxIdle = 20

#<!-- 最小空闲连接 -->
minIdle = 5

#<!-- 超时等待时间以毫秒为单位 60000毫秒/1000等于60秒 -->
maxWait = 60000

#JDBC驱动建立连接是附带的连接属性的格式必须为这样：[属性名=property;]
#注意：“user”与“password”两个属性会被明确地传递，因为这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=gbk

#指定由连接池所创建的连接的自动提交（auto-commit）状态
defaultAutoCommit = true

#driver default指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=

#driver default指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE，READ_UNCOMMITTED，READ_COMMITTED，REPEATBLE_READ，SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED

1、编写DBCP的工具类

public class DBCPUtils {
    private static DataSource dataSource;
    static{
        try {
            //1.加载找properties文件输入流
            InputStream is = DBCPUtils.class.getClassLoader().getResourceAsStream("db.properties");
            //2.加载输入流
            Properties props = new Properties();
            props.load(is);
            //3.创建数据源
            dataSource = BasicDataSourceFactory.createDataSource(props);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public static DataSource getDataSource(){
        return dataSource;
    }

    public static Connection getConnection(){
        try {
            return dataSource.getConnection();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

测试使用一下：

@Test
    public void testUpdatePersonById() {
        Connection conn = null;
        PreparedStatement pstmt = null;

        try {
            conn = DBCPUtils.getConnection();
            String sql = "update person set name=? where _id = ?";
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, "Yorkie");
            pstmt.setInt(2, 23);
            int count = pstmt.executeUpdate();
            if (count > 0) {
                System.out.println("更新成功");
            } else {
                System.out.println("更新失败");
            }
        } catch (Exception e) {

            e.printStackTrace();
        }
    }

四、使用DBUtils增删改查的操作

如果只使用JDBC进行开发，我们会发现冗余代码过多，为了简化JDBC开发，本案例我们将采用Apache Commons组建一个成员DBUtils。

DBUtils就是JDBC的简化开发工具包。需要使用技术：连接池（获得连接），SQL语句都没有少。
下面直接展示源码，代码都有注释：

/**
 * 测试DBUtils工具类的增删改操作
 * @author Administrator
 *
 */
public class TestDBUtils1 {

    /**
     * 添加所有用户方法
     */
    @Test
    public void testAddUser() {
        try {
            // 1.创建核心类QueryRunner
            QueryRunner qr = new QueryRunner(C3P0Utils.getDataSource());
            // 2.编写SQL语句
            String sql = "insert into person (name,age) values(?,?)";
            // 3.为站位符设置值
            Object[] params = { "Layne", 18 };
            // 4.执行添加操作
            int rows = qr.update(sql, params);
            if (rows > 0) {
                System.out.println("添加成功!");
            } else {
                System.out.println("添加失败!");
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 根据id修改用户方法
     * 
     */
    @Test
    public void testUpdateUserById() {
        try {
            // 1.创建核心类QueryRunner
            QueryRunner qr = new QueryRunner(C3P0Utils.getDataSource());
            // 2.编写SQL语句
            String sql = "update person set name=? where _id=?";
            // 3.为站位符设置值
            Object[] params = { "Yorkie", 28 };
            // 4.执行添加操作
            int rows = qr.update(sql, params);
            if (rows > 0) {
                System.out.println("修改成功!");
            } else {
                System.out.println("修改失败!");
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 根据id删除用户方法
     */
    @Test
    public void testDeleteUserById() {
        try {
            // 1.创建核心类QueryRunner
            QueryRunner qr = new QueryRunner(C3P0Utils.getDataSource());
            // 2.编写SQL语句
            String sql = "delete from person where _id=?";
            // 3.为站位符设置值
            Object[] params = {28};
            // 4.执行添加操作
            int rows = qr.update(sql, params);
            if (rows > 0) {
                System.out.println("删除成功!");
            } else {
                System.out.println("删除失败!");
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

再有一个类：

/**
 *  测试DBUtils查询操作
 * @author Administrator
 *
 */
public class TestDBUtils2 {

    /*
     * 查询所有用户方法
     */
    @Test
    public void testQueryAll() {
        try {
            // 1.获取核心类queryRunner
            QueryRunner qr = new QueryRunner(C3P0Utils.getDataSource());
            // 2.编写sql语句
            String sql = "select * from person";
            // 3.执行查询操作
            List<Person> persons = qr.query(sql, new BeanListHandler<Person>(Person.class));
            // 4.对结果集集合进行遍历
            for (Person person : persons) {
                System.out.println(person.toString());
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    /*
     * 根据id查询用户方法
     */
    @Test
    public void testQueryUserById() {
        try {
            // 1.获取核心类queryRunner
            QueryRunner qr = new QueryRunner(C3P0Utils.getDataSource());
            // 2.编写sql语句
            String sql = "select * from person where _id=?";
            //3.为占位符设置值
            Object[] params = {21};
            // 4.执行查询操作
            Person person = qr.query(sql, new BeanHandler<Person>(Person.class), params);
            System.out.println(person.toString());
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    /*
     * 根据所有用户的总个数
     */
    @Test
    public void testQueryCount() {
        try {
            // 1.获取核心类queryRunner
            QueryRunner qr = new QueryRunner(C3P0Utils.getDataSource());
            // 2.编写sql语句
            String sql = "select count(*) from person";
            // 4.执行查询操作
            Long count = (Long) qr.query(sql, new ScalarHandler());
            System.out.println(count);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    /*
     * 查询所有用户方法
     */
    @Test
    public void testQueryAll1() {
        try {
            // 1.获取核心类queryRunner
            QueryRunner qr = new QueryRunner(C3P0Utils.getDataSource());
            // 2.编写sql语句
            String sql = "select * from person";
            // 3.执行查询操作
            List<Map<String, Object>> list = qr.query(sql, new MapListHandler());
            // 4.对结果集集合进行遍历
            for (Map<String, Object> map : list) {
                System.out.println(map);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    /*
     * 查询所有用户方法
     */
    @Test
    public void testQueryAll2() {
        try {
            // 1.获取核心类queryRunner
            QueryRunner qr = new QueryRunner(C3P0Utils.getDataSource());
            // 2.编写sql语句
            String sql = "select * from person";
            // 3.执行查询操作
            List<Object> list = qr.query(sql, new ColumnListHandler("name"));
            // 4.对结果集集合进行遍历
            for (Object object : list) {
                System.out.println(object);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

源码下载

LayneYao
关注
专栏目录
JDBC-自定义连接池
Lxjyh99的博客
08-29 396
【连接池的原理】 在javax.sql.DataSource接口–连接池的接口 功能：初始化多个连接.把多个连接放入到内存中 归还：将连接对象放回到内存中 【自定义连接池】 step1.创建类MyDataSource实现DataSource接口 step2.在JDBCUtils类中创建连接池，获取数据库...
JDBC：C3P0连接池
health的博客
04-16 364
C3P0连接池的使用 eclipse+mysql80 一、下载工具包 C3P0工具包：https://sourceforge.net/projects/c3p0/files/latest/download?source=files mysql驱动包：https://dev.mysql.com/downloads/connector/j 二、导入驱动包 在根目录新建libs文件夹...
读取配置文件建立一个标准连接池
weixin_34396103的博客
03-09 113
2019独角兽企业重金招聘Python工程师标准>>> ...
JDBC连接池
dingliuji5223的博客
07-24 123
JDBC连接池 概念：其实就是一个容器(集合)，存放数据库连接的容器。   当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。 好处： 节约资源 用户访问高效 实现： 标准接口：DataSource javax.sql包下的 方法： 获取连接：getConnection() 归还连接：...
自定义的数据库连接池（C3P0）JAVA版
风景旧曾谙
12-19 1023
之前有写java通过c3p0连接池与数据库进行连接。但是之前写的和普通的连接没啥子区别的样子，完全没有起到池的作用。我们知道，池应该可以理解为一种对数据库的一种直接映射，但是又有不同。池的作用，其实就是一些小的数据库的集群。我们所要的，都在这个池子里。从而避免了对数据库的直接操作，也就是这个池就是我们的数据库。 因为原来写的没有起到池的作用，只起到了一个中间者的作用，所以这次再来一次好了。自定义...
自定义一个简单的JDBC连接池实现方法
08-28
常用的连接池有DBCP、C3P0，现在最主流是好像是阿里的Druid连接池，还有tomcat的自带的JNDI连接池。 知识点三：自定义一个简单的连接池 自定义连接池需要实现DataSource接口，并实现其中的方法，基于我们的情况，...
数据库连接池资源包（c3p0 , dbcp,druid连接池）
12-04
本资源包包含三个主流的数据库连接池实现：c3p0、dbcp和Druid。它们各有特点，适应不同的应用场景。 1. **c3p0**：全称为Com形3P0，是由Miquel Arquero开发的一个开源的JDBC连接池。c3p0提供了完善的连接池管理和...
DBCP,c3p0连接池所需要的包
07-01
DBCP（Jakarta DBCP）和c3p0是两种常用的开源数据库连接池实现。 DBCP，全称Jakarta Commons DBCP，是Apache软件基金会下的一个项目，它基于Apache的Jakarta POI项目中的DBUtils模块发展而来。DBCP提供了一个可配置...
数据库连接池C3P0.zip
05-21
C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。在本压缩包“数据库连接池C3P0.zip”中，包含了C3P0数据库连接池的相关jar包以及配置文件，用于帮助开发者集成到他们的...
三大连接池常用jar（c3p0,dbcp,druid）
08-15
本文将详细介绍三大常用的数据库连接池——C3P0、DBCP和Druid，以及它们的主要特点和使用方法。 1. C3P0 C3P0是一个开源的JDBC连接池，由Miquel Catalan开发。它提供了全面的JDBC API支持，包括JDBC3规范和JDBC2的...
JDBC + MySQL使用c3p0连接池
04-11
NULL 博文链接：https://263644449.iteye.com/blog/1682739
Jdbc - C3P0数据库连接池
QWQAWAA的博客
11-10 202
参考链接 1.一般c3p0-config.xml模板 <?xml version="1.0" encoding="UTF-8"?> <c3p0-config> <default-config> <!--mysql数据库连接的各项参数--> <property name="driverClass">com.mysql.jdbc.Driver</property> <property name="jdbcU
JDBC应用—C3P0连接池
zhang150114的博客
04-25 243
工程目录 一、准备工作 1、相关jar包： mysql驱动包：mysql-connector-java-5.1.37-bin.jar c3p0依赖包：c3p0-0.9.5.2.jar ，mchange-commons-java-0.2.12.jar 2、c3p0配置文件：c3p0-config.xml 二、代码编写 1、导jar包 2、c3p0-config.xml配置文件 <c3p0-...
JDBC连接池-c3p0
WARGON的博客
07-17 492
    一个数据库连接对象对应着一个物理数据库连接，使用完后关闭连接。频繁的打开关闭连接会造成系统的性能低下，且可能造成数据库的缓存溢出，通常开发中使用连接池（严格来说叫做数据源：DataSource）来进行处理。 连接池的解决方案是：当应用程序启动时，系统主动建立足够的数据库连接，并将它们组成连接池，每次应用请求数据库连接时，无需创建连接，而是从连接池中取出一个已有的连接，使用完后，也不用关闭...
JDBC连接------C3P0连接池
heronsbill_peng
06-13 580
JDBC连接------C3P0连接池 目录 1、为什么要用到连接池 2、连接池原理 3、C3P0连接池 总结 1、为什么要用到连接池 当一个用户要访问某个网站时，就需要频繁的使用数据库进行增删改查，每次增删改查操作都需要获取连接，如果说一个用户的频繁获取连接系统尚能接受，那么成千上万的用户浏览这个网站进行增删改查来获取连接 对系统来说将是一个巨大的负荷！为了解决这一问题，我们可...
JDBC——c3p0连接池的使用
Shixuefeng2410的博客
04-22 1231
本文主要讲解jdbc连接mySQL。 一、在idea上新建maven工程 二、添加依赖包 <!-- 连接mysql工具包--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.38</version> </dependency> <
【JDBC】C3P0连接池的使用
ElegantHedgehog的博客
12-17 92
C3P0连接池的c3p0-config.xml配置文件 <?xml version="1.0" encoding="UTF-8"?> <c3p0-config> <default-config> <property name="driverClass">com.mysql.cj.jdbc.Driver</property> <property name="jdbcUrl">jdbc:mysql:///jdbctest...
JDBC+c3p0连接池的使用
qq_35182361的博客
04-01 476
package com.hd.xy.jdbc; import com.mchange.v2.c3p0.ComboPooledDataSource; import java.io.InputStream; import java.sql.Connection; import java.sql.SQLException; import java.util.Properties; import co...
Java之JDBC中数据库C3P0连接池的使用
hestyle的博客
10-05 876
C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。 C3P0连接池的使用演示 建库、建表sql脚本 #创建数据库 CREATE DATABASE IF NOT EXISTS jdbc_test; #选中刚刚创建的数据库 use jdbc_test; #创建users表 CREATE ...
数据库连接池配置详解：c3p0, JDBC, JNDI, BoneCP
Java中，可以利用容器类（如Vector、Stack）或特定的连接池实现（如c3p0、DBCP、HikariCP等）来实现这一过程。 1.2 连接池的治理 治理策略是连接池的核心部分，它包括连接的分配和释放。常见的策略有： - **引用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值