广告

扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >Java中JDBC连接池的基本原理及实现方式
  • 396

0
分享到

Java中JDBC连接池的基本原理及实现方式

2024-04-02 19:04:59 396人浏览 泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

目录一、 应用程序直接建立数据库连接模型二、使用数据库连接池优化模型1、关于连接池中的连接数量的一些规定：2、编写数据库连接池创建数据库连接池：进一步封装一些相关数据库的类的方法三、

一、 应用程序直接建立数据库连接模型

应用程序直接每次访问数据库时，都建立创建一个数据库的链接，这样每次建立这样的连接都需要耗费的资源，当同时有很多用户在使用应用程序时，可能会导致应用程序崩溃。

图为应用程序直接建立数据库连接模型

二、使用数据库连接池优化模型

数据库连接池的基本思路是，平时建立适量的数据库的连接，放在一个集合中，当有用户需要建立数据库连接的时候，直接到集合中取出一个数据库连接对象（Connection），这样不用再需要重新创建，这样会节省大量的资源，当用户不需要在对数据库进行访问了，那么就将数据库连接对象（Connection）重新放回到集合中，以便方便下次使用。

数据库连接池优化模型图

1、关于连接池中的连接数量的一些规定：

  • （1）最小连接数:是连接池一直保持的数据库连接,所以如果应用程序对数据库连接的使用量不大,将会有大量的数据库连接资源被浪费（适量）.
  • （2）最大连接数:是连接池能申请的最大连接数,如果数据库连接请求超过次数,后面的数据库连接请求将被加入到等待队列中,这会影响以后的数据库操作。通常在使用完起始集合中的连接后，会再重新创建一些数据库连接对象，用来满足用户需求，但是这种新建并不是无限制的。
  • （3）当使用完的连接对象需要重新放回到集合中以备使用，但是超过最小连接数的连接在使用完不会马上被释放,他将被放到连接池中等待重复使用或是超时后最终被释放。

2、编写数据库连接池

简单思路为：创建一个类继承DataSource接口，在类中实现静态的加载出配置文档db.properties文档，并创建最小连接量的数据库连接对象(Connection)，添加到Linkedlist（选择Linkedlist集合原因是便于增删）集合中。重写getConnection()函数，在getConnection()函数中实现数据库连接对象的获取。

db.properties文档


driver=com.Mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/imooc?useUnicode=true&characterEncoding=utf-8
username=root
passWord=tiger

jdbcConnectionInitSize=10

创建数据库连接池：


package JDBC;

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.LinkedList;
import java.util.Properties;
import java.util.logging.Logger;

import javax.sql.DataSource;

public class JdbcConnectionsPool implements DataSource {

    
    //创建linkedlist集合
    private static LinkedList<Connection> linkedlist1=new LinkedList<Connection>();
    private static String driver;//
    private static String url;//
    private static String username;//数据库登陆名
    private static String password;//数据库的登陆密码
    private static int jdbcConnectionInitSize;//最小连接数量
    private static int max=1; //当前最大连接数量=max*jdbcConnectionInitSize
    static{
        //通过反射机制获取访问db.properties文件
        InputStream is=JdbcConnectionsPool.class.getResourceAsStream("/db.properties");
        Properties prop=new Properties();
        try {
            //加载db.properties文件
            prop.load(is);
            //获取db.properties文件中的数据库连接信息
            driver=prop.getProperty("driver");
            url=prop.getProperty("url");
            username=prop.getProperty("username");
            password=prop.getProperty("password");
            jdbcConnectionInitSize=Integer.parseInt(prop.getProperty("jdbcConnectionInitSize"));

            Class.forName("com.mysql.jdbc.Driver");

            //创建最小连接数个数据库连接对象以备使用
            for(int i=0;i<jdbcConnectionInitSize;i++){
                Connection conn=DriverManager.getConnection(url, username, password);
                 System.out.println("获取到了链接" + conn);
                //将创建好的数据库连接对象添加到Linkedlist集合中
                linkedlist1.add(conn);
            }


        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }


    @Override
    public PrintWriter getLogWriter() throws SQLException {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {
        // TODO Auto-generated method stub

    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException {
        // TODO Auto-generated method stub

    }

    @Override
    public int getLoginTimeout() throws SQLException {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        // TODO Auto-generated method stub
        return false;
    }

    
    @Override
    public Connection getConnection() throws SQLException {
         //如果集合中没有数据库连接对象了，且创建的数据库连接对象没有达到最大连接数量，可以再创建一组数据库连接对象以备使用
         if(linkedlist1.size()==0&&max<=5){
             try {
                Class.forName("com.mysql.jdbc.Driver");
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
             for(int i=0;i<jdbcConnectionInitSize;i++){
               Connection conn=DriverManager.getConnection(url, username, password);
               System.out.println("获取到了链接" + conn);
               //将创建好的数据库连接对象添加到Linkedlist集合中
               linkedlist1.add(conn);
                }
             max++;
            }
        if(linkedlist1.size()>0){
            //从linkedlist集合中取出一个数据库链接对象Connection使用
            Connection conn1=linkedlist1.removeFirst();
            System.out.println("linkedlist1数据库连接池大小是" + linkedlist1.size());
            
            return (Connection) Proxy.newProxyInstance(conn1.getClass().getClassLoader(),//这里换成JdbcConnectionsPool.class.getClassLoader();也行
                 conn1.getClass().getInterfaces(), new InvocationHandler() {

                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        if(!method.getName().equalsIgnoreCase("close")){
                            return method.invoke(conn1, args);
                        }else{
                            linkedlist1.add(conn1);
                            System.out.println(conn1+"对象被释放，重新放回linkedlist集合中！");
                            System.out.println("此时Linkedlist集合中有"+linkedlist1.size()+"个数据库连接对象！");
                            return null;
                            }
                        }
                   });
        }else{
            System.out.println("连接数据库失败！");
        }
        return null;
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {

        return null;
    }

}

进一步封装一些相关数据库的类的方法


package JDBC;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JdbcConnectionPoolTest {

        
        private static JdbcConnectionsPool pool = new JdbcConnectionsPool();

        
        public static Connection getConnection() throws SQLException{
            return pool.getConnection();
        }

        
        public static void release(Connection conn,Statement st,ResultSet rs){
            if(rs!=null){
                try{
                    //关闭存储查询结果的ResultSet对象
                    rs.close();
                }catch (Exception e) {
                    e.printStackTrace();
                }
                rs = null;
            }
            if(st!=null){
                try{
                    //关闭负责执行SQL命令的Statement对象
                    st.close();
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }

            if(conn!=null){
                try{
                    //关闭Connection数据库连接对象
                    conn.close();
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

}

调试代码：


package JDBC;

import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;

public class TestJdbcPool {

    public static void main(String[] args) throws SQLException {
        //实例化封装了有关数据库类方法类的对象
        JdbcConnectionPoolTest jcpt=new JdbcConnectionPoolTest();
        //获得数据库连接对象
        Connection conn=jcpt.getConnection();
        //下面代码是存储过程的调用
        String s="call SP_select_nofilter6(?,?,?) ";
        CallableStatement cst=conn.prepareCall(s);
        cst.setInt(2, 2);
        cst.reGISterOutParameter(1, Types.VARCHAR);
        cst.registerOutParameter(3, Types.BLOB);
        ResultSet rs=cst.executeQuery();
        String name=cst.getString(1);
        Blob b=cst.getBlob(3);

        System.out.println("name:"+name+" Blob:"+b);
        //关闭所有的数据库资源
        jcpt.release(conn, cst, rs);
    }
}

运行结果：


获取到了链接com.mysql.jdbc.Connection@5f184fc6
获取到了链接com.mysql.jdbc.Connection@723279cf
获取到了链接com.mysql.jdbc.Connection@4e50df2e
获取到了链接com.mysql.jdbc.Connection@7cc355be
获取到了链接com.mysql.jdbc.Connection@52cc8049
获取到了链接com.mysql.jdbc.Connection@7530d0a
获取到了链接com.mysql.jdbc.Connection@4fca772d
获取到了链接com.mysql.jdbc.Connection@7cd84586
获取到了链接com.mysql.jdbc.Connection@70177ecd
获取到了链接com.mysql.jdbc.Connection@cc34f4d
linkedlist1数据库连接池大小是9
name:xiao Blob:com.mysql.jdbc.Blob@5197848c
com.mysql.jdbc.Connection@5f184fc6对象被释放，重新放回linkedlist集合中！
此时Linkedlist集合中有10个数据库连接对象！

标红的代码是比较重要的代码段~，其中Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)，返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序，loader参数定义代理类的类加载器，interfaces - 代理类要实现的接口列表，h - 指派方法调用的调用处理程序 。

三、两个开源的数据库连接池

在使用了数据库连接池之后，在项目的实际开发中就不需要编写连接数据库的代码了，直接从数据源获得数据库的连接。

1、dbcp连接

（1）导入相关jar包

commons-dbcp2-2.1.1.jar

commons-pool2-2.4.2.jar

commoms-logging-1.2.jar

（2）在项目根目录增加配置文件dbcp.properties


#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy
username=root
password=XDP

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

#最大连接数量
maxActive=50

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

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

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


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

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

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

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

（3）程序实现dbcp连接

代码演示：

数据库对象的代理类（封装Connection类的一些方法）


package DBCP;

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;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSourceFactory;

public class DBCPUtil {
    private static DataSource ds;
    private static final String configFile="/dbcp.properties";

    public DBCPUtil(){
        //实例化properties对象用于加载配置文件
        Properties prop=new Properties();
        InputStream is=DBCPUtil.class.getResourceAsStream(configFile);
        try {
            prop.load(is);
            ds=BasicDataSourceFactory.createDataSource(prop);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    public Connection getConn(){
        Connection conn=null;
        if(ds!=null){
            try {
                conn=ds.getConnection();
                conn.setAutoCommit(false);//设置禁止操作自动提交的情况
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return conn;
        }
        return conn;
    }
    
    public void close(ResultSet rs,Statement st,Connection conn) throws SQLException{
        if(rs!=null){
                rs.close();
        }
        if(st!=null){
                st.close();
        }
        if(conn!=null){
            conn.close();
        }
    }
}

代码调用：


package DBCP;

import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;

public class DbcpTest {

    public static void main(String[] args) throws SQLException {
                //实例化数据库连接的代理类
                DBCPUtil dbcpUtil=new DBCPUtil();
                //获得数据库连接对象
                Connection conn=dbcpUtil.getConn();
                //下面代码是存储过程的调用
                String s="call SP_select_nofilter6(?,?,?) ";
                CallableStatement cst=conn.prepareCall(s);
                cst.setInt(2, 2);
                cst.registerOutParameter(1, Types.VARCHAR);
                cst.registerOutParameter(3, Types.BLOB);
                ResultSet rs=cst.executeQuery();
                String name=cst.getString(1);
                Blob b=cst.getBlob(3);

                System.out.println("name:"+name+" Blob:"+b);
                //关闭资源
                dbcpUtil.close(rs, cst, conn);
    }

}

运行结果：


name:xiao Blob:com.mysql.jdbc.Blob@30946e09

2、c3p0连接池

c3p0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定支持JDBC3和JDBC2的标准扩展

（1）导入相关的jar包

cc3p0-0.9.2-pre4.jar

mchange-commons-java-0.2.2.jar

如果是oracle数据库还需要添加c3p0-oracle-thin-extras-0.9.2-pre1.jar

（2）在项目根目录下增加配置文件

1）c3p0.properties


##配置除user,password,minpoolsize,maxpoolsize的参数
##[注意] 整数值不能有空格
#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/imooc?useUnicode=true&characterEncoding=utf-8
username=root
password=tiger

#初始化时获取三个连接，取值应在minPoolSize与maxPoolSize之间。Default: 3
c3p0.initialPoolSize=10

#当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3
c3p0.acquireIncrement=3

#最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0
#maxIdleTime应该小于MySQL的wait_timeout的值
c3p0.maxIdleTime=600

#定义在从数据库获取新连接失败后重复尝试的次数。Default: 30
c3p0.acquireRetryAttempts=5

#两次连接中间隔时间，单位毫秒。Default: 1000
c3p0.acquireRetryDelay=1000

#连接关闭时默认将所有未提交的操作回滚。Default: false
c3p0.autoCommitOnClose=false

#c3p0将建一张名为Test的空表，并使用其自带的查询语句进行测试。如果定义了这个参数那么
#属性preferredTestQuery将被忽略。你不能在这张Test表上进行任何操作，它将只供c3p0测试
#使用。Default: null
#c3p0.automaticTestTable=

#获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效
#保留，并在下次调用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试
#获取连接失败后该数据源将申明已断开并永久关闭。Default: false
#c3p0.breakAfterAcquireFailure=false

#当连接池用完时客户端调用getConnection()后等待获取新连接的时间，超时后将抛出
#SQLException,如设为0则无限期等待。单位毫秒。Default: 0
c3p0.checkoutTimeout=10000

#每60秒检查所有连接池中的空闲连接。Default: 0
c3p0.idleConnectionTestPeriod=600

#JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements
#属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。
#如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 0
c3p0.maxStatements=100

#maxStatementsPerConnection定义了连接池内单个连接所拥有的最大缓存statements数。Default: 0
c3p0.maxStatementsPerConnection=0

#c3p0是异步操作的，缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能
#通过多线程实现多个操作同时被执行。Default: 3
c3p0.numHelperThreads=3

2）c3p0-config.xml文档


<?xml version="1.0" encoding="UTF-8"?>
<!--
c3p0-config.xml必须位于类路径下面
private static ComboPooledDataSource ds;
static{
    try {
        ds = new ComboPooledDataSource("MySQL");
    } catch (Exception e) {
        throw new ExceptionInInitializerError(e);
    }
}
-->

<c3p0-config>
    <!--
    C3P0的缺省(默认)配置，
    如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource();”这样写就表示使用的是C3P0的缺省(默认)配置信息来创建数据源
    -->
    <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://127.0.0.1:3306/imooc?useUnicode=true&characterEncoding=utf-8</property>
        <property name="user">root</property>
        <property name="password">tiger</property>

        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </default-config>

    <!--
    C3P0的命名配置，
    如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource("MySQL");”这样写就表示使用的是name是MySQL的配置信息来创建数据源
    -->
    <named-config name="MySQL">
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://127.0.0.1:3306/imooc?useUnicode=true&characterEncoding=utf-8</property>
        <property name="user">root</property>
        <property name="password">tiger</property>

        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </named-config>

</c3p0-config>

（3）编写类文件，创建连接池

1）c3p0.properties配置文件情况下

数据库对象的代理类（封装Connection类的一些方法）


package C3P0;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0Util {

    private static ComboPooledDataSource ds=new ComboPooledDataSource();

    
    public static Connection getConnection() throws SQLException{
        return ds.getConnection();
    }

    
    public void close(ResultSet rs,Statement st,Connection conn) throws SQLException{
        if(rs!=null){
                rs.close();
        }
        if(st!=null){
                st.close();
        }
        if(conn!=null){
            conn.close();
        }
    }
}

代码调用：


package C3P0;

import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;

public class C3P0Test {

    public static void main(String[] args) throws SQLException {
        C3P0Util c3p0Util=new C3P0Util();
        Connection conn=c3p0Util.getConnection();
        //下面代码是存储过程的调用
                String s="call SP_select_nofilter6(?,?,?) ";
                CallableStatement cst=conn.prepareCall(s);
                cst.setInt(2, 2);
                cst.registerOutParameter(1, Types.VARCHAR);
                cst.registerOutParameter(3, Types.BLOB);
                ResultSet rs=cst.executeQuery();
                String name=cst.getString(1);
                Blob b=cst.getBlob(3);

                System.out.println("name:"+name+" Blob:"+b);
                //关闭资源
                c3p0Util.close(rs, cst, conn);
    }
}

运行结果：


二月 14, 2017 7:36:12 下午 com.mchange.v2.log.MLog
信息: MLog clients using java 1.4+ standard logging.
二月 14, 2017 7:36:13 下午 com.mchange.v2.c3p0.C3P0Registry
信息: Initializing c3p0-0.9.5.2 [built 08-December-2015 22:06:04 -0800; debug? true; trace: 10]
二月 14, 2017 7:36:13 下午 com.mchange.v2.c3p0.impl.AbstractPoolBackedDataSource
信息: Initializing c3p0 pool... com.mchange.v2.c3p0.ComboPooledDataSource [ acquireIncrement -> 3, acquireRetryAttempts -> 5, acquireRetryDelay -> 1000, autoCommitOnClose -> false, automaticTestTable -> null, breakAfterAcquireFailure -> false, checkoutTimeout -> 10000, connectionCustomizerClassName -> null, connectionTesterClassName -> com.mchange.v2.c3p0.impl.DefaultConnectionTester, contextClassLoaderSource -> caller, dataSourceName -> 2y4pm69mgrekqw18rvmvn|7aec35a, debugUnreturnedConnectionStackTraces -> false, description -> null, driverClass -> com.mysql.jdbc.Driver, extensions -> {}, factoryClassLocation -> null, forceIgnoreUnresolvedTransactions -> false, forceSynchronousCheckins -> false, forceUseNamedDriverClass -> false, identityToken -> 2y4pm69mgrekqw18rvmvn|7aec35a, idleConnectionTestPeriod -> 600, initialPoolSize -> 10, jdbcUrl -> jdbc:mysql://127.0.0.1:3306/imooc?useUnicode=true&characterEncoding=utf-8, maxAdministrativeTaskTime -> 0, maxConnectionAge -> 0, maxIdleTime -> 600, maxIdleTimeExcessConnections -> 0, maxPoolSize -> 15, maxStatements -> 100, maxStatementsPerConnection -> 0, minPoolSize -> 3, numHelperThreads -> 3, preferredTestQuery -> null, privilegeSpawnedThreads -> false, properties -> {user=******, password=******}, propertyCycle -> 0, statementCacheNumDeferredCloseThreads -> 0, testConnectionOnCheckin -> false, testConnectionOnCheckout -> false, unreturnedConnectionTimeout -> 0, userOverrides -> {}, usesTraditionalReflectiveProxies -> false ]
name:xiao Blob:com.mysql.jdbc.Blob@31b7dea0

2）c3p0-config.xml配置文档情况下

数据库对象的代理类（封装Connection类的一些方法）


package C3P0;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0Util1 {

    private static ComboPooledDataSource ds;

    
    public static Connection getConnection() throws SQLException{
        //通过代码创建C3P0数据库连接池
        

        //通过读取C3P0的xml配置文件创建数据源，C3P0的xml配置文件c3p0-config.xml必须放在src目录下
        //ds = new ComboPooledDataSource();//使用C3P0的默认配置来创建数据源
        ds = new ComboPooledDataSource("MySQL");//使用C3P0的命名配置来创建数据源
        return ds.getConnection();
    }

    
    public void close(ResultSet rs,Statement st,Connection conn) throws SQLException{
        if(rs!=null){
                rs.close();
        }
        if(st!=null){
                st.close();
        }
        if(conn!=null){
            conn.close();
        }
    }
}

代码调用：


package C3P0;

import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;

public class C3P0Test1 {

    public static void main(String[] args) throws SQLException {
        C3P0Util1 c3p0Util1=new C3P0Util1();
        Connection conn=c3p0Util1.getConnection();
        //下面代码是存储过程的调用
                String s="call SP_select_nofilter6(?,?,?) ";
                CallableStatement cst=conn.prepareCall(s);
                cst.setInt(2, 2);
                cst.registerOutParameter(1, Types.VARCHAR);
                cst.registerOutParameter(3, Types.BLOB);
                ResultSet rs=cst.executeQuery();
                String name=cst.getString(1);
                Blob b=cst.getBlob(3);

                System.out.println("name:"+name+" Blob:"+b);
                //关闭资源
                c3p0Util1.close(rs, cst, conn);
    }
}

运行结果：


二月 14, 2017 8:06:03 下午 com.mchange.v2.log.MLog
信息: MLog clients using java 1.4+ standard logging.
二月 14, 2017 8:06:03 下午 com.mchange.v2.c3p0.C3P0Registry
信息: Initializing c3p0-0.9.5.2 [built 08-December-2015 22:06:04 -0800; debug? true; trace: 10]
二月 14, 2017 8:06:03 下午 com.mchange.v2.c3p0.impl.AbstractPoolBackedDataSource
信息: Initializing c3p0 pool... com.mchange.v2.c3p0.ComboPooledDataSource [ acquireIncrement -> 5, acquireRetryAttempts -> 5, acquireRetryDelay -> 1000, autoCommitOnClose -> false, automaticTestTable -> null, breakAfterAcquireFailure -> false, checkoutTimeout -> 10000, connectionCustomizerClassName -> null, connectionTesterClassName -> com.mchange.v2.c3p0.impl.DefaultConnectionTester, contextClassLoaderSource -> caller, dataSourceName -> MySQL, debugUnreturnedConnectionStackTraces -> false, description -> null, driverClass -> com.mysql.jdbc.Driver, extensions -> {}, factoryClassLocation -> null, forceIgnoreUnresolvedTransactions -> false, forceSynchronousCheckins -> false, forceUseNamedDriverClass -> false, identityToken -> 2y4pm69mgsgybs1qf3g8s|6e5e91e4, idleConnectionTestPeriod -> 600, initialPoolSize -> 10, jdbcUrl -> jdbc:mysql://127.0.0.1:3306/imooc?useUnicode=true&characterEncoding=utf-8, maxAdministrativeTaskTime -> 0, maxConnectionAge -> 0, maxIdleTime -> 600, maxIdleTimeExcessConnections -> 0, maxPoolSize -> 20, maxStatements -> 100, maxStatementsPerConnection -> 0, minPoolSize -> 5, numHelperThreads -> 3, preferredTestQuery -> null, privilegeSpawnedThreads -> false, properties -> {user=******, password=******}, propertyCycle -> 0, statementCacheNumDeferredCloseThreads -> 0, testConnectionOnCheckin -> false, testConnectionOnCheckout -> false, unreturnedConnectionTimeout -> 0, userOverrides -> {}, usesTraditionalReflectiveProxies -> false ]
name:xiao Blob:com.mysql.jdbc.Blob@c39f790

总结：其实不管配置文件是c3p0.properties还是c3p0-config.xml，其代码实现部分没有多大区别，唯一区别可能就是c3p0-config.xml情况下可以调用含参的ComboPooledDataSource(String s)构造函数，两个都可以调用其默认的无参构造函数。

3、dbcp和c3p0不同之处

dbcp c3p0
spring组织推荐使用 Hibernate组织推荐使用
强制关闭连接或者数据库重启后无法自动重连 强制关闭连接或者数据库重启可以自动连接
没有自动的去回收空闲连接的功能 自动回收空闲的功能
DBCP提供最大连接数

c3p0提供最大空闲时间
dbcp并没用相应功能 c3p0可以控制数据源加载的prepareedstatement数量，并且可以设置帮助线程的数量来提升JDBC操作速度

以上所述是小编给大家介绍的Java中JDBC连接池的基本原理及实现方式，希望对大家有所帮助。在此也非常感谢大家对编程网网站的支持！

您可能感兴趣的文档:
点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Java中JDBC连接池的基本原理及实现方式

本文链接: https://www.lsjlt.com/news/160318.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档
去做题
猜你喜欢
  • Java中JDBC连接池的基本原理及实现方式
    目录一、 应用程序直接建立数据库连接模型二、使用数据库连接池优化模型1、关于连接池中的连接数量的一些规定：2、编写数据库连接池创建数据库连接池：进一步封装一些相关数据库的类的方法三、...
    99+
    2022-11-12
  • 详解Oracle 11g DRCP连接方式的基本原理
    学习Oracle是一个复杂、繁琐的过程。在浩如烟海的Oracle官方资料、新特性、MOS资料和各种Internal知识面前，我们总是觉得力不从心、不知所措。但是，这往往也就是我们不断坚持、积累和追寻的乐趣。...
    99+
    2022-10-18
  • CSS中Hack的基本原理和实现方式
    本篇内容主要讲解“CSS中Hack的基本原理和实现方式”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“CSS中Hack的基本原理和实现方式”吧!CSS Hack的...
    99+
    2022-10-19
  • Java对象池技术的原理及其实现方法
    这篇文章主要讲解了“Java对象池技术的原理及其实现方法”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Java对象池技术的原理及其实现方法”吧！摘 要 ：本文在分析对象池技术基本原理的基础上...
    99+
    2023-06-03
  • C++中内存池的原理及实现方法是什么
    这篇文章主要讲解了“C++中内存池的原理及实现方法是什么”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“C++中内存池的原理及实现方法是什么”吧！为什么要用内存池C++程序默认的内存管理（ne...
    99+
    2023-07-05
  • Java线程池实现原理及其在美团业务中的实践
    　随着计算机行业的飞速发展，摩尔定律逐渐失效，多核CPU成为主流。使用多线程并行计算逐渐成为开发人员提升服务器性能的基本武器。J.U.C提供的线程池ThreadPoolExecutor类，帮助开发人员管理线...
    99+
    2022-10-18
  • SPA中前端路由基本原理与实现方式的示例分析
    这篇文章给大家分享的是有关SPA中前端路由基本原理与实现方式的示例分析的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。后端路由： 浏览器在地址栏中切换不同的url时，每次都向后台服...
    99+
    2022-10-19
  • Java数据结构之基于比较的排序算法基本原理及具体实现
    目录1. 七大基于比较的排序-总览1.1常见基于比较的排序分类1.2时间复杂度，空间复杂度以及稳定性。2.直接插入排序2.1 直接插入排序的基本思想2.2 直接插入排序动画演示2.3...
    99+
    2022-11-12
  • Java中​HashMap的工作原理及实现方法是什么
    今天小编给大家分享一下Java中HashMap的工作原理及实现方法是什么的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我们一起来了解一下吧。Has...
    99+
    2023-06-03
  • 夯实Java基础系列4：一文了解final关键字的特性、使用方法，以及实现原理
    本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看https://github.com/h3pl/Java-Tutorial喜欢的话麻烦点下Star哈文章首发于我的个人博客：www.how2pla...
    99+
    2023-06-02
  • Java中实现线程的三种方式及对比_动力节点Java学院整理
    Java中创建线程主要有三种方式：一、继承Thread类创建线程类（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。（2）创建Thread子类的实例，即创建...
    99+
    2023-05-31
    java 线程 实现方式
  • 分布式系统中的自然语言处理接口开发详解：Java实现方案
    自然语言处理（NLP）是人工智能领域中的一个重要分支，它涵盖了语音识别、文本分类、情感分析等多个领域。在分布式系统中，NLP接口的开发显得尤为重要，因为它能够帮助不同的系统之间更好地交流和协同工作。本文将介绍如何使用Java实现NLP接口...
    99+
    2023-10-25
    分布式 自然语言处理 接口
软考高级职称资格查询
软考职称历年真题下载
软考职称资料下载
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作