c3p0参数的说明以及整合spring使用

最新推荐文章于 2024-07-18 10:17:25 发布

迪迪调调

最新推荐文章于 2024-07-18 10:17:25 发布

阅读量1k

点赞数

分类专栏：工作文章标签： c3p0 c3p0参数配置 c3p0Spring

本文链接：https://blog.csdn.net/u010248330/article/details/73089642

版权

工作专栏收录该内容

19 篇文章 0 订阅

订阅专栏

准备需要的jar包，如下：

这里写图片描述

这些jar包，我已经放到后面贴的源码里了，可自行下载。

列出常用的c3p0参数的配置的含义：

<!-- c3p0连接池配置 -->
     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
          <!--数据库连接相关的配置 --> 
          <property name="driverClass" value="${jdbc.driverClassName}"></property>
          <property name="jdbcUrl" value="${jdbc.url}"></property>
          <property name="user" value="${jdbc.username}"></property>
          <property name="password" value="${jdbc.password}"></property>

          <!--连接池中保留的最大连接数。默认值: 15 --> 
          <property name="maxPoolSize" value="30"/>
          <!-- 连接池中保留的最小连接数，默认为：3-->
          <property name="minPoolSize" value="2"/>
          <!-- 初始化连接池中的连接数，取值应在minPoolSize与maxPoolSize之间，默认为3-->
          <property name="initialPoolSize" value="2"/>

          <!--最大空闲时间，60秒内未使用则连接被丢弃。若为0则永不丢弃。默认值: 0 --> 
          <property name="maxIdleTime">60</property>

          <!-- 当连接池连接耗尽时，客户端调用getConnection()后等待获取新连接的时间，超时后将抛出SQLException，如设为0则无限期等待。单位毫秒。默认: 0 --> 
          <property name="checkoutTimeout" value="3000"/>

          <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。默认值: 3 --> 
          <property name="acquireIncrement" value="2"/>

         <!--定义在从数据库获取新连接失败后重复尝试的次数。默认值: 30 ；小于等于0表示无限次--> 
          <property name="acquireRetryAttempts" value="0"/>

          <!--重新尝试的时间间隔，默认为：1000毫秒--> 
          <property name="acquireRetryDelay" value="1000" />

          <!--关闭连接时，是否提交未提交的事务，默认为false，即关闭连接，回滚未提交的事务 --> 
          <property name="autoCommitOnClose">false</property>

          <!--每60秒检查所有连接池中的空闲连接。默认值: 0，不检查 --> 
          <property name="idleConnectionTestPeriod">60</property>
          <!--c3p0全局的PreparedStatements缓存的大小。如果maxStatements与maxStatementsPerConnection均为0，则缓存不生效，只要有一个不为0，则语句的缓存就能生效。如果默认值: 0--> 
          <property name="maxStatements">100</property>
          <!--maxStatementsPerConnection定义了连接池内单个连接所拥有的最大缓存statements数。默认值: 0 --> 
          <property name="maxStatementsPerConnection"></property>
     </bean>

下面就简单使用一下：

新建一个student的model:

public class Student {

    private int id;
    private String username;
    private String age;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }


}

并创建student表：

create table student (id int(10) not null auto_increment,username varchar(20),age varchar(3),primary key(id));

spring bean.xml配置文件:

<?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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context.xsd">       
  <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <value>classpath:jdbc.properties</value>
        </property>
   </bean>

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClassName}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>

        <property name="minPoolSize"><value>1</value></property>
        <property name="maxPoolSize"><value>3</value></property>
        <property name="maxIdleTime"><value>300</value></property>
        <property name="checkoutTimeout" value="3000"/>  

    </bean>
    <bean id="jdbctemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>

mysql数据库配置jdbc.properties:


jdbc.username=root
jdbc.password=root
jdbc.url=jdbc:mysql://localhost:3306/spring
jdbc.driverClassName=com.mysql.jdbc.Driver

测试代码：

import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;


public class Test {
     public static void main(String[] args) {
            ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
            JdbcTemplate jdbcTemplate = (JdbcTemplate) ctx.getBean("jdbctemplate");
            System.out.println(jdbcTemplate);
            jdbcTemplate.update("insert into student(id,username,age)values(null,?,?)", "xiaoming","20");
    }
}

可以在mysql客户端查看代码插入的一条记录。

我的主要目的是想测试一下参数maxPoolSize的具体含义，因为在工作中遇到了连接池的连接数满了导致的报错。，当使用的连接数已经达到最大的连接数时，再申请连接会发生什么情况？

import java.sql.Connection;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.mchange.v2.c3p0.ComboPooledDataSource;


public class TestPoolSize {
     public static void main(String[] args) throws Exception {

            ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

            ComboPooledDataSource cpds =(ComboPooledDataSource)ctx.getBean("dataSource");

            for (int i = 0; i <3; i++) {
                Connection con = cpds.getConnection();
                System.out.println("获取第" +i+ "个连接:" + con);

            }
            System.out.println("正在使用的连接数：" +cpds.getNumBusyConnections());
            Connection con = cpds.getConnection();
            System.out.println("再获取一个连接" + con);



    }

}

从配置文件中我们可以知道，配置的最大连接数是maxPoolSize=3，我们的测试代码的循环中取了三个连接，且没有释放，达到了我们设置的最大连接数3。此时再去连接池中拿连接，就会抛出异常。

这里写图片描述

注意，这是因为我们设置了参数checkoutTimeout,要是不设置这个参数，程序会一直等待连接，不会报错了。

如果我们将获取的连接用完就正确的释放，这个连接就会重新回到连接池中，就可以再次使用了。

import java.sql.Connection;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.mchange.v2.c3p0.ComboPooledDataSource;


public class TestPoolSize {
     public static void main(String[] args) throws Exception {

            ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

            ComboPooledDataSource cpds =(ComboPooledDataSource)ctx.getBean("dataSource");

            for (int i = 0; i <3; i++) {
                Connection con = cpds.getConnection();
                System.out.println("获取第" +(i+1)+ "个连接:" + con);
                System.out.println("使用完毕，释放连接....");
                con.close();//释放连接

            }
            System.out.println("正在使用的连接数：" +cpds.getNumBusyConnections());

            for (int i = 0; i <3; i++) {
                Connection con = cpds.getConnection();
                System.out.println("重新获取连接:" + con);

            }



    }

}

实验结果：

获取第1个连接:com.mchange.v2.c3p0.impl.NewProxyConnection@451c0d60
使用完毕，释放连接....
获取第2个连接:com.mchange.v2.c3p0.impl.NewProxyConnection@319c0bd6
使用完毕，释放连接....
获取第3个连接:com.mchange.v2.c3p0.impl.NewProxyConnection@6536d9d8
使用完毕，释放连接....
正在使用的连接数：1
重新获取连接:com.mchange.v2.c3p0.impl.NewProxyConnection@2bbe2893
重新获取连接:com.mchange.v2.c3p0.impl.NewProxyConnection@63d87b85
重新获取连接:com.mchange.v2.c3p0.impl.NewProxyConnection@2918958e

acquireRetryAttempts:连接池在获得新连接失败时重试的次数，如果小于等于0则无限重试直至连接获得成功

checkoutTimeout:配置当连接池所有连接用完时应用程序getConnection的等待时间。为0则无限等待直至有其他连接释放或者创建新的连接，不为0则当时间到的时候如果仍没有获得连接，则会抛出SQLException

所以当不设置checkoutTimeout，且设置acquireRetryAttempts时，当当前连接数达到最大的maxPoolSize时，再申请连接时，会一直等待有连接释放后拿到连接。

修改配置文件：

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClassName}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>

        <property name="minPoolSize"><value>1</value></property>
        <property name="maxPoolSize"><value>10</value></property>
        <property name="maxIdleTime"><value>300</value></property>
<!--        <property name="checkoutTimeout" value="3000"/>-->
        <property name="acquireRetryAttempts"><value>30</value></property>

    </bean>

import java.sql.Connection;
import java.sql.SQLException;
import java.util.*;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.mchange.v2.c3p0.ComboPooledDataSource;


public class TestPoolSize {
     public static void main(String[] args) throws Exception {

            ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

            final ComboPooledDataSource cpds =(ComboPooledDataSource)ctx.getBean("dataSource");
            final List<Connection>cons =new ArrayList<Connection>();
            for (int i = 0; i <10; i++) {
                Connection con = cpds.getConnection();
                cons.add(con);
                System.out.println("获取第" +(i+1)+ "个连接:" + con);
            }
            System.out.println("正在使用的连接数：" +cpds.getNumBusyConnections());


            new Thread(new Runnable() {

                @Override
                public void run() {
                     for (Connection connection : cons) {
                        try {
                                System.out.println("正在释放一个连接....");
                                Thread.sleep(2000);
                                connection.close();

                         } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
            //主线程申请的连接已经达到maxPoolSize，运行到下面的线程获取连接时，如果不设置checkoutTimeout，会一直等待，
            //且如果设置了acquireRetryAttempt就会一直尝试获取连接，如果上面有连接释放，就获取连接。

            new Thread( new Runnable() {
                public void run() {
                    for (int i = 0; i <10; i++) {
                        Connection con=null;
                        try {
                            con = cpds.getConnection();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        System.out.println("新获取第" +(i+1)+ "个连接:" + con);
                    }
                }
            }).start();





    }

}