当前位置 : 首页 » 文章分类 :  开发  »  c3p0

c3p0

[TOC]


概述

C3P0是一个开源的JDBC连接池,它实现了数据源和JNDI绑定,支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate,Spring等。

为什么要使用数据库连接池

一般我们在项目中操作数据库时,都是每次需要操作数据库就建立一个连接,操作完成后释放连接。因为jdbc没有保持连接的能力,一旦超过一定时间没有使用(大约几百毫秒),连接就会被自动释放掉。而每次新建连接都需要140毫秒左右的时间,所以耗费时间比较多。若使用C3P0连接池来池化连接,随时取用,则平均每次取用只需要10-20毫秒。这在高并发随机访问数据库的时候对效率的提升有很大帮助。

C3P0连接池会根据你的配置来初始化N个数据库连接,空闲T时间后连接过期又会自动新建K个连接使得连接池总有空闲的数据库连接等待被取用。我们只需通过dataSourse.getConnection()即可从线程池中取用一个已经连接好的空闲连接,执行数据库操作。然后“断开”(放回)这个连接,把这个连接的使用权放回连接池。真正的数据库连接的创建与释放是由C3P0在后台自动完成的,我们花的只是取用与释放占用权的时间。全程耗时10+毫秒,比原来提高了几十倍。

c3p0下载安装

https://sourceforge.net/projects/c3p0/ 下载c3p0-0.9.5.2.bin.zip,解压后将其中的lib/c3p0-0.9.5.2.jar 和 lib/mchange-commons-java-0.2.11.jar 拷贝到项目的CLASSPATH中即安装完毕。


c3p0配置参数

必需的数据库连接参数

driverClass

指定连接数据库的JDBC驱动,默认值:null

jdbcUrl

连接数据库所用的URL,默认值:null

user

连接数据库的用户名,默认值:null

password

连接数据库的密码,默认值:null

连接池管理

initialPoolSize

初始化时创建的连接数,应在minPoolSize与maxPoolSize之间取值。默认为3;

minPoolSize

连接池中保留的最小连接数,默认为3

maxPoolSize

连接池中保留的最大连接数,如果获得新连接时会使连接总数超过这个值则不会再获取新连接,而是等待其他连接释放,默认为15;

acquireIncrement

当连接池中的连接用完时,C3P0一次性创建新连接的数目; 默认为3;

maxIdleTime

最大空闲时间,超过空闲时间的连接将被丢弃。为0或负数则永不丢弃。默认为0;

maxConnectionAge

配置连接的生存时间,超过这个时间的连接将由连接池自动断开丢弃掉。当然正在使用的连接不会马上断开,而是等待它close再断开。配置为0的时候则不会对连接的生存时间进行限制。default : 0 单位 s(不建议使用)

maxIdleTimeExcessConnections

这个配置主要是为了快速减轻连接池的负载,比如连接池中连接数因为某次数据访问高峰导致创建了很多数据连接,但是后面的时间段需要的数据库连接数很少,需要快速释放,必须小于maxIdleTime。其实这个没必要配置,maxIdleTime已经配置了。default : 0 单位 s(不建议使用)

connectionCustomizerClassName

用来定制Connection的管理,比如在Connection acquire 的时候设定Connection的隔离级别,或者在Connection丢弃的时候进行资源关闭,就可以通过继承一个AbstractConnectionCustomizer来实现相关方法,配置的时候使用全类名。有点类似监听器的作用。default : null(不建议使用)

重连参数

acquireRetryAttempts

连接池在获得新连接失败时重试的次数,如果小于等于0则无限重试直至连接获得成功。default : 30(建议使用)

acquireRetryDelay

连接池在获得新连接时的间隔时间。default : 1000 单位ms(建议使用)

breakAfterAcquireFailure

获取连接失败将会引起所有等待获取连接的线程抛出异常。但是数据源仍有效保留,并在下次调用getConnection()的时候继续尝试获取连接。如果为true,则当连接获取失败时自动关闭数据源,除非重新启动应用程序。所以一般不用。default : false(不建议使用)

checkoutTimeout

配置当连接池所有连接用完时应用程序getConnection的等待时间。为0则无限等待直至有其他连接释放或者创建新的连接,不为0则当时间到的时候如果仍没有获得连接,则会抛出SQLException。其实就是acquireRetryAttempts*acquireRetryDelay。default : 0(与上面两个,有重复,选择其中两个都行)

连接测试

automaticTestTable

配置一个表名,连接池根据这个表名用自己的测试sql语句在这个空表上测试数据库连接,这个表只能由c3p0来使用,用户不能操作。default : null(不建议使用)

preferredTestQuery

定义所有连接测试都执行的测试语句。在使用连接测试的情况下这个参数能显著提高测试速度。测试的表必须在初始数据源的时候就存在。默认为null;与automaticTestTable二者只能选一。

idleConnectionTestPeriod

用来配置测试空闲连接的间隔时间。测试方式还是上面的两种之一,可以用来解决MySQL8小时断开连接的问题。因为它保证连接池会每隔一定时间对空闲连接进行一次测试,从而保证有效的空闲连接能每隔一定时间访问一次数据库,将于MySQL8小时无会话的状态打破。为0则不测试。default : 0(建议使用)

testConnectionOnCheckin

如果设为true那么在取得连接的同时将校验连接的有效性。默认为false。

testConnectionOnCheckout

因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable等方法来提升连接测试的性能。默认为false;

connectionTesterClassName

通过实现ConnectionTester或QueryConnectionTester的类来测试连接,类名需设置为全限定名。默认为 com.mchange.v2.C3P0.impl.DefaultConnectionTester;

PreparedStatement缓存

maxStatements

连接池为数据源缓存的PreparedStatement的总数。由于PreparedStatement属于单个Connection,所以这个数量应该根据应用中平均连接数乘以每个连接的平均PreparedStatement来计算。同时maxStatementsPerConnection的配置无效。default : 0(不建议使用)

maxStatementsPerConnection

连接池为数据源单个Connection缓存的PreparedStatement数,这个配置比maxStatements更有意义,因为它缓存的服务对象是单个数据连接,如果设置的好,肯定是可以提高性能的。为0的时候不缓存。default : 0(看情况而论)

事务配置

autoCommitOnClose

连接池在回收数据库连接时是否自动提交事务。如果为false,则会回滚未提交的事务,如果为true,则会自动提交事务。default : false(不建议使用)

forceIgnoreUnresolvedTransactions

这个配置强烈不建议为true。default : false(不建议使用)一般来说事务当然由自己关闭了,为什么要让连接池来处理这种不细心问题呢?

其他配置

numHelperThreads

C3P0是异步操作的,缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能,通过多线程实现多个操作同时被执行。默认为3;

propertyCycle

用户修改系统配置参数执行前最多等待的秒数。默认为300;

unreturnedConnectionTimeout

为0的时候要求所有的Connection在应用程序中必须关闭。如果不为0,则强制在设定的时间到达后回收Connection,所以必须小心设置,保证在回收之前所有数据库操作都能够完成。这种限制减少Connection未关闭情况的不是很适用。建议手动关闭。default : 0 单位 s(不建议使用)

debugUnreturnedConnectionStackTraces

如果为true并且unreturnedConnectionTimeout设为大于0的值,当所有被getConnection出去的连接unreturnedConnectionTimeout时间到的时候,就会打印出堆栈信息。只能在debug模式下适用,因为打印堆栈信息会减慢getConnection的速度default : false(不建议使用)


参考


Spring中使用c3p0连接池

数据库properties配置文件

一般把数据库链接的配置信息放到properties文件里,便于统一管理。
例如property-database.properties内容如下:

ras.database.url=jdbc:postgresql://localhost:5443/mydb
ras.database.driver=org.postgresql.Driver
ras.database.user=admin
ras.database.password=admin
ras.database.minPoolSize=3
ras.database.maxPoolSize=100
ras.database.initialPoolSize=15
ras.database.maxIdleTime=60
ras.database.acquireIncrement=10
ras.database.maxStatements=0
ras.database.idleConnectionTestPeriod=60
ras.database.acquireRetryAttempts=10
ras.database.breakAfterAcquireFailure=false
ras.database.testConnectionOnCheckout=false
ras.database.checkoutTimeout=3000
ras.database.automaticTestTable=C3P0_Test
ras.database.dataSourceName=my-dataSource

Spring配置文件

使用spring提供的org.springframework.beans.factory.config.PropertyPlaceholderConfigurer类读取数据库配置文件。
配置一个c3p0连接池com.mchange.v2.c3p0.ComboPooledDataSource数据源

<?xml version="1.0" encoding="UTF-8"?>    
<beans xmlns="http://www.springframework.org/schema/beans"    
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    
    xmlns:jee="http://www.springframework.org/schema/jee"    
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-2.0.xsd    
            http://www.springframework.org/schema/jee 
        http://www.springframework.org/schema/jee/spring-jee-2.0.xsd">    

    <!-- 读取数据库配置文件 -->
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:config/property/property-database.properties</value>
            </list>
        </property>
    </bean>        

    <!-- 配置一个c3p0数据源 -->
    <bean id="ras-dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${ras.database.driver}" />
        <property name="jdbcUrl" value="${ras.database.url}"/>        
        <property name="user" value="${ras.database.user}"/>
        <property name="password" value="${ras.database.password}"/>
        <property name="minPoolSize" value="${ras.database.minPoolSize}" />
        <property name="maxPoolSize" value="${ras.database.maxPoolSize}" />
        <property name="initialPoolSize" value="${ras.database.initialPoolSize}" />
        <property name="maxIdleTime" value="${ras.database.maxIdleTime}" />
        <property name="acquireIncrement" value="${ras.database.acquireIncrement}" />
        <property name="maxStatements" value="${ras.database.maxStatements}" />
        <property name="idleConnectionTestPeriod" value="${ras.database.idleConnectionTestPeriod}" />
        <property name="acquireRetryAttempts" value="${ras.database.acquireRetryAttempts}" />
        <property name="breakAfterAcquireFailure" value="${ras.database.breakAfterAcquireFailure}" />
        <property name="testConnectionOnCheckout" value="${ras.database.testConnectionOnCheckout}" />
        <property name="checkoutTimeout" value="${ras.database.checkoutTimeout}"/>
        <property name="automaticTestTable" value="${ras.database.automaticTestTable}"/>
        <property name="dataSourceName" value="${ras.database.dataSourceName}"></property>    
    </bean>            

</beans>

参考


原生Java中配置c3p0的4种方式

直接在Java代码中设置c3p0参数

直接在Java代码中new一个com.mchange.v2.c3p0.ComboPooledDataSource类的实例,在ComboPooledDataSource类实例上直接set各种c3p0参数。

封装类C3P0Inner.java

package com.song.c3p0.db.inner;

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

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0Inner {

    private static ComboPooledDataSource ds;

    //静态初始化块进行初始化
    static{
        try {
            ds = new ComboPooledDataSource();//创建连接池实例
            ds.setDriverClass("com.mysql.jdbc.Driver");//设置连接池连接数据库所需的驱动
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/cloudhospital");//设置连接数据库的URL
            ds.setUser("root");//设置连接数据库的用户名
            ds.setPassword("admin");//设置连接数据库的密码
            ds.setMaxPoolSize(40);//设置连接池的最大连接数
            ds.setMinPoolSize(2);//设置连接池的最小连接数
            ds.setInitialPoolSize(10);//设置连接池的初始连接数
            ds.setMaxStatements(100);//设置连接池的缓存Statement的最大数            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //获取与指定数据库的连接
    public static ComboPooledDataSource getInstance(){
        return ds;
    } 

    //从连接池返回一个连接
    public static Connection getConnection(){
        Connection conn = null;
        try {
            conn = ds.getConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }

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

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

        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

调用类C3P0InnerMain.java

package com.song.c3p0.db.inner;

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

public class C3P0InnerMain {

    public PreparedStatement setStatement(Connection conn,String sql){
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return ps;
    }

    public PreparedStatement setParameter(PreparedStatement ps,Object...values){
        try {
            if(null != values){
                for(int i=1;i<=values.length;i++){
                    ps.setObject(i, values[i-1]);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ps;
    }

    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = C3P0Inner.getConnection();

            C3P0InnerMain c3P0InnerMain = new C3P0InnerMain();

            String sql = "SELECT * FROM tb_user WHERE ID < ? ";

            ps = c3P0InnerMain.setStatement(conn, sql);
            ps = c3P0InnerMain.setParameter(ps, new Object[]{20});

            rs = ps.executeQuery();

            while(rs.next()){
                Object ob = rs.getObject(1);
                Object name = rs.getObject(4);
                System.out.println("ID: " + ob + ",NAME:" + name);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            //释放资源
            C3P0Inner.realeaseResource(rs, ps, conn);
        }
    }
}

显式读取properties配置文件中的参数

此方法与第一种方法大体相同,只不过将c3p0配置放在.properties配置文件中,在Java代码中读取配置文件的各项参数,分别set给ComboPooledDataSource的实例。

配置文件config.properties

DriverClass = com.mysql.jdbc.Driver  
JdbcUrl = jdbc:mysql://localhost:3306/cloudhospital  
User = root  
Password = admin  
MaxPoolSize = 20  
MinPoolSize = 2  
InitialPoolSize = 5  
MaxStatements = 30  
MaxIdleTime = 100

封装类C3P0Properties.java

package com.song.c3p0.db.properties;

import java.sql.Connection;
import java.util.Properties;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0Properties {

    private ComboPooledDataSource cpds;

    private static C3P0Properties c3P0Properties;

    static{
        c3P0Properties = new C3P0Properties();
    }

    public C3P0Properties() {
        try {
            cpds = new ComboPooledDataSource();

            //加载配置文件
            Properties props = new Properties();
            props.load(C3P0Properties.class.getClassLoader().getResourceAsStream("config.properties"));

            cpds.setDriverClass(props.getProperty("DriverClass"));
            cpds.setJdbcUrl(props.getProperty("JdbcUrl"));
            cpds.setUser(props.getProperty("User"));
            cpds.setPassword(props.getProperty("Password"));

            cpds.setMaxPoolSize(Integer.parseInt(props.getProperty("MaxPoolSize")));
            cpds.setMinPoolSize(Integer.parseInt(props.getProperty("MinPoolSize")));
            cpds.setInitialPoolSize(Integer.parseInt(props.getProperty("InitialPoolSize")));
            cpds.setMaxStatements(Integer.parseInt(props.getProperty("MaxStatements")));
            cpds.setMaxIdleTime(Integer.parseInt(props.getProperty("MaxIdleTime")));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static C3P0Properties getInstance(){
        return c3P0Properties;
    }

    public Connection getConnection(){
        Connection conn = null;
        try {
            conn = cpds.getConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }
}

调用类C3POPropertiesMain.java

package com.song.c3p0.db.properties;

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

public class C3POPropertiesMain {

    public PreparedStatement getPrepareStatement(Connection conn,String sql){
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return ps;
    }

    public PreparedStatement setPrepareStatementParameter(PreparedStatement ps,Object... values){
        try {
            if (null != values) {
                for (int i = 1; i <= values.length; i++) {
                    ps.setObject(i, values[i - 1]);
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return ps;
    }

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

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

        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = C3P0Properties.getInstance().getConnection();

            String sql = "SELECT * FROM tb_user WHERE ID < ? ";

            C3POPropertiesMain c3p0Instance = new C3POPropertiesMain();

            ps = c3p0Instance.getPrepareStatement(conn, sql);
            c3p0Instance.setPrepareStatementParameter(ps, new Object[]{20});

            rs = ps.executeQuery();

            while(rs.next()){
                Object obj1 = rs.getObject(1);
                Object obj4 = rs.getObject(4);

                System.out.println("ID: " + obj1 + ",NAME: " + obj4);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            //释放资源
            C3POPropertiesMain.realeaseResource(rs, ps, conn);
        }
    }
}

使用默认c3p0.properties文件配置c3p0参数

使用ComboPooledDataSource cpds = new ComboPooledDataSource(); 默认构造方法时,会自动读取classpath下的名为c3p0.properties的配置文件。所以我们可以在classpath下创建一个名为c3p0.properties的配置文件,填入c3p0参数,然后new ComboPooledDataSource() 时便会自动加载解析此配置。

配置文件c3p0.properties

c3p0.driverClass = com.mysql.jdbc.Driver  
c3p0.jdbcUrl = jdbc:mysql://localhost:3306/cloudhospital  
c3p0.user = root  
c3p0.password = admin  
c3p0.maxPoolSize = 20  
c3p0.minPoolSize = 3  
c3p0.maxStatements = 30  
c3p0.maxIdleTime = 150

封装类C3P0PropertiesSimplify.java

package com.song.c3p0.db.properties;

import java.sql.Connection;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0PropertiesSimplify {

    private static C3P0PropertiesSimplify c3P0PropertiesSimplify;

    private ComboPooledDataSource cpds;

    static{
        c3P0PropertiesSimplify = new C3P0PropertiesSimplify();
    }

    public C3P0PropertiesSimplify() {
        cpds = new ComboPooledDataSource(); //自动读取并解析c3p0.properties配置文件
    }

    public static C3P0PropertiesSimplify getInstance(){
        return c3P0PropertiesSimplify;
    }

    public Connection getConnection(){
        Connection conn = null;
        try {
            conn = cpds.getConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }
}

调用类C3P0PropertiesSimplifyMain.java

package com.song.c3p0.db.properties;

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

public class C3P0PropertiesSimplifyMain {

    public PreparedStatement createStatement(Connection conn,String sql){
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return ps;
    }

    public PreparedStatement setParameters(PreparedStatement ps,Object...values){
        try {
            if(null != values){
                for(int i=1;i<=values.length;i++){
                    ps.setObject(i, values[i-1]);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ps;
    }

    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = C3P0PropertiesSimplify.getInstance().getConnection();

            C3P0PropertiesSimplifyMain c3p0Instance = new C3P0PropertiesSimplifyMain();
            String sql = "SELECT * FROM tb_user WHERE ID < ? ";
            ps = c3p0Instance.createStatement(conn, sql);
            ps = c3p0Instance.setParameters(ps, new Object[]{20});

            rs = ps.executeQuery();
            while(rs.next()){
                Object obj1 = rs.getObject(1);
                Object obj4 = rs.getObject(4);

                System.out.println("ID: " + obj1 + ",Name: " + obj4);
            }
        } catch (Exception e) {
        }finally{
            try {
                if(null != rs){
                    try {
                        rs.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }

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

                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
    }
}

使用默认c3p0-config.xml文件配置c3p0参数

c3p0默认会读取classpath下的名为c3p0-config.xml的配置文件,所以我们可以在classpath下创建一个名为c3p0-config.xml的配置文件,填入c3p0参数,然后new ComboPooledDataSource() 时便会自动加载解析此配置。

使用c3p0-config.xml配置文件的好处是,如果用new ComboPooledDataSource(String configName)方法创建实例,可以在参数中指定c3p0-config.xml配置文件中的不同<named-config>,实现一个配置文件中有多个配置实例。

配置文件c3p0-config.xml

<?xml version="1.0" encoding="UTF-8"?>  
<c3p0-config>  
    <named-config name="myc3p0xml">  
        <property name="driverClass">com.mysql.jdbc.Driver</property>  
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/cloudhospital</property>  
        <property name="user">root</property>  
        <property name="password">admin</property>  
        <property name="maxPoolSize">20</property>  
        <property name="minPoolSize">3</property>  
        <property name="maxStatements">30</property>  
        <property name="maxIdleTime">150</property>  
    </named-config>  

    <named-config name="myc3p0xmlconfig2">
    ...
    </named-config>    
</c3p0-config>

封装类C3P0XmlSimplify.java


package com.song.c3p0.db.xml;

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

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0XmlSimplify {

    private static C3P0XmlSimplify c3P0XmlSimplify;

    private ComboPooledDataSource cpds;

    static{
        c3P0XmlSimplify = new C3P0XmlSimplify();
    }

    public C3P0XmlSimplify() {
        //自动读取并解析c3p0-config.xml配置文件,选择其中的myc3p0xml配置实例
        cpds = new ComboPooledDataSource("myc3p0xml"); 
    }

    public static C3P0XmlSimplify getInstance(){
        return c3P0XmlSimplify;
    }

    public Connection getConnection(){
        Connection conn = null;
        try {
            conn = cpds.getConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }

    public static PreparedStatement setStatement(Connection conn, String sql){
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return ps;
    }


    public static PreparedStatement setSQLParameters(PreparedStatement ps,Object...values){
        try {
            if (null != values) {
                for (int i = 1; i <= values.length; i++) {
                    ps.setObject(i, values[i-1]);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ps;
    }

    public static void releaseSources(Connection conn, PreparedStatement ps, ResultSet rs){
        if(null != rs){
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        if(null != ps){
            try {
                ps.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

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

调用类C3P0XmlSimplifyMain.java

package com.song.c3p0.db.xml;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class C3P0XmlSimplifyMain {

    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;a
        try {
            conn = C3P0XmlSimplify.getInstance().getConnection();

            String sql = " SELECT * FROM tb_user WHERE ID < ? ";
            ps = C3P0XmlSimplify.setStatement(conn, sql);
            ps = C3P0XmlSimplify.setSQLParameters(ps, new Object[]{20});

            rs = ps.executeQuery();

            while(rs.next()){
                Object obj1 = rs.getObject(1);
                Object obj4 = rs.getObject(4);

                System.out.println("ID: " + obj1 + ",Name: " + obj4);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            C3P0XmlSimplify.releaseSources(conn, ps, rs);
        }
    }
}

参考


上一篇 Apache-Maven-POM

下一篇 Java-SPI

域名迁移公告
2017年12月20日起,本博客迁移到新域名madaimeng.com,旧域名masikkk.com不再更新内容,但将永久保持可访问!
阅读
4,559
阅读预计21分钟
创建日期 2017-05-05
修改日期 2017-08-01
类别
百度推荐