Cet article présente principalement en détail les informations pertinentes sur la configuration du pool de connexions à la base de données c3p0, qui a une certaine valeur de référence. Les amis intéressés peuvent s'y référer
Il existe trois méthodes de configuration de c3p0, respectivement
<.>
2. Fournissez un fichier c3p0.properties sous le chemin de classe
3. Fournissez un c3p0-config sous le chemin de classe
Cette méthode est la plus lourde, et la forme est généralement la suivante :
Properties props = new Properties();
InputStream in = ConnectionManager.class.getResourceAsStream("/c3p0.properties");
props.load(in);
in.close();
ComboPooledDataSource cpds = new ComboPooledDataSource();
cpds.setDriverClass(props.getProperty("driverClass"));
cpds.setJdbcUrl(props.getProperty("jdbcUrl"));
cpds.setUser(props.getProperty("user"));
cpds.setPassword(props.getProperty("password"));
Le nom du fichier doit être c3p0.properties et le format des éléments de configuration est :
c3p0.driverClass=com.mysql.jdbc.Driver c3p0.jdbcUrl=jdbc:mysql://localhost:3306/jdbc c3p0.user=root c3p0.password=java
private static ComboPooledDataSource ds = new ComboPooledDataSource();
public static Connection getConnection() {
try {
return ds.getConnection();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
Cette méthode est similaire à la seconde, mais présente plus d'avantages
(2). Il peut être utilisé pour plusieurs données. Le service source fournit deux méthodes de configuration : default-config et approved-config
Ce qui suit est un modèle de configuration :
<c3p0-config> <default-config> <property name="user">root</property> <property name="password">java</property> <property name="driverClass">com.mysql.jdbc.Driver</property> <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbc</property> <property name="initialPoolSize">10</property> <property name="maxIdleTime">30</property> <property name="maxPoolSize">100</property> <property name="minPoolSize">10</property> </default-config> <named-config name="myApp"> <property name="user">root</property> <property name="password">java</property> <property name="driverClass">com.mysql.jdbc.Driver</property> <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbc</property> <property name="initialPoolSize">10</property> <property name="maxIdleTime">30</property> <property name="maxPoolSize">100</property> <property name="minPoolSize">10</property> </named-config> </c3p0-config>
private static ComboPooledDataSource ds = new ComboPooledDataSource(" myApp");
Ce qui suit est un résumé de la compréhension de la configuration c3p0 apprise à partir de documents et en ligne (utilisateur, mot de passe, driverClass, jdbcUrl n'est pas nécessaire)acquireIncrement
par défaut : 3
Le nombre de nouvelles connexions à la base de données créées en même temps par le pool de connexions lorsqu'aucune connexion inactive n'est disponible
initialPoolSize
par défaut : 3
Le nombre de connexions créées lorsque le pool de connexions est initialisé
maxPoolSize
par défaut : 15
Le nombre maximum de connexions dans le pool de connexions Le nombre de connexions Si le nombre total de connexions dépasse cette valeur lors de l'obtention d'un. nouvelle connexion, de nouvelles connexions ne seront pas obtenues, mais attendront que
d'autres connexions soient libérées, donc cette valeur peut être conçue pour être très grande
maxIdleTime
par défaut : 0 unité s
Le temps d'inactivité maximum de la connexion Si ce temps est dépassé et qu'une connexion à la base de données n'a pas été utilisée, la connexion sera déconnectéeS'il est 0 , la connexion ne sera jamais déconnectée
minPoolSize
Le nombre minimum de connexions maintenues par le pool de connexions et les maxIdleTimeExcessConnections suivantes sont utilisées en conjonction avec cela pour réduire la charge sur le pool de connexions
maxConnectionAge
par défaut : 0 unité s
configuration La durée de vie de la connexion. Les connexions qui dépassent cette durée seront automatiquement déconnectées et rejetées par le pool de connexions. Bien entendu, la connexion utilisée ne sera pas déconnectée immédiatement, mais attendra la fermeture de
avant de se déconnecter. Lorsqu'il est configuré sur 0, il n'y aura aucune limite sur la durée de vie de la connexion.
maxIdleTimeExcessConnections
par défaut : 0 unité s
Cette configuration vise principalement à réduire la charge du pool de connexions. Par exemple, le nombre de connexions dans le pool de connexions est créé. en raison d'un certain pic d'accès aux données. Il existe de nombreuses connexions de données
mais le nombre de connexions à la base de données requises dans la période ultérieure est très faible. À l'heure actuelle, le pool de connexions n'a pas besoin d'en maintenir autant. connexions, il est donc nécessaire de déconnecter et de jeter
Certaines connexions pour réduire la charge, doivent être inférieures à maxIdleTime. Si la configuration n'est pas 0, le nombre de connexions dans le pool de connexions sera maintenu à minPoolSize. Si
vaut 0, il ne sera pas traité.
maxIdleTime peut également entrer dans cette catégorie, qui a déjà été écrite.
3. Configurer le test de connexion : étant donné que la connexion à la base de données dans le pool de connexions est susceptible de maintenir une connexion pendant plusieurs heures, il est très probable que la connexion réelle soit devenue invalide en raison de problèmes de serveur de base de données, de problèmes de réseau, etc., mais le pool de connexions La connexion à l'intérieur est toujours valide. Si la connexion est obtenue à ce moment, une exception se produira certainement, il est donc nécessaire de confirmer la validité de la connexion en testant la connexion.
Les trois premiers éléments ci-dessous sont utilisés pour configurer la manière de tester la connexion, et les trois derniers éléments sont utilisés pour configurer le moment du test de la connexion.par défaut : null
Un moyen de configurer une connexion de test. Configurez un nom de table, le pool de connexions crée une table vide basée sur ce nom de table,
et utilisez votre propre instruction test sql pour tester la connexion à la base de données sur cette table vide
Cette table ne peut que être accessible par c3p0 S'il est utilisé, l'utilisateur ne peut pas fonctionner et le PreferredTestQuery configuré par l'utilisateur sera ignoré.
preferredTestQuerypar défaut : null
Une autre façon de configurer une connexion de test. Vous ne pouvez en choisir qu’un seul dans le tableau de test automatique ci-dessus.
Si vous souhaitez l'utiliser pour tester la connexion, ne la définissez pas sur null, sinon le processus de test prendra beaucoup de temps. En même temps, vous devez vous assurer que la table dans l'instruction SQL. doit exister dans la base de données.
connectionTesterClassName
default : com.mchange.v2.c3p0.impl.DefaultConnectionTester
连接池用来支持automaticTestTable和preferredTestQuery测试的类，必须是全类名，就像默认的那样，
可以通过实现UnifiedConnectionTester接口或者继承AbstractConnectionTester来定制自己的测试方法
idleConnectionTestPeriod
default : 0
用来配置测试空闲连接的间隔时间。测试方式还是上面的两种之一，可以用来解决MySQL8小时断开连接的问题。因为它
保证连接池会每隔一定时间对空闲连接进行一次测试，从而保证有效的空闲连接能每隔一定时间访问一次数据库，将于MySQL
8小时无会话的状态打破。为0则不测试。
testConnectionOnCheckin
default : false
如果为true，则在close的时候测试连接的有效性。为了提高测试性能，可以与idleConnectionTestPeriod搭配使用，
配置preferredTestQuery或automaticTestTable也可以加快测试速度。
testConnectionOnCheckout
default : false
性能消耗大。如果为true，在每次getConnection的时候都会测试，为了提高性能，
可以与idleConnectionTestPeriod搭配使用，
配置preferredTestQuery或automaticTestTable也可以加快测试速度。
4.配置PreparedStatement缓存
maxStatements
default : 0
连接池为数据源缓存的PreparedStatement的总数。由于PreparedStatement属于单个Connection,所以
这个数量应该根据应用中平均连接数乘以每个连接的平均PreparedStatement来计算。为0的时候不缓存，
同时maxStatementsPerConnection的配置无效。
maxStatementsPerConnection
default : 0
连接池为数据源单个Connection缓存的PreparedStatement数，这个配置比maxStatements更有意义，因为
它缓存的服务对象是单个数据连接，如果设置的好，肯定是可以提高性能的。为0的时候不缓存。
5.重连相关配置
acquireRetryAttempts
default : 30
连接池在获得新连接失败时重试的次数，如果小于等于0则无限重试直至连接获得成功
acquireRetryDelay
default : 1000 单位ms
连接池在获得新连接时的间隔时间
breakAfterAcquireFailure
default : false
如果为true，则当连接获取失败时自动关闭数据源，除非重新启动应用程序。所以一般不用。
个人觉得上述三个没有更改的必要，但可以将acquireRetryDelay配置地更短一些
6.定制管理Connection的生命周期
connectionCustomizerClassName
default : null
用来定制Connection的管理，比如在Connection acquire 的时候设定Connection的隔离级别，或者在
Connection丢弃的时候进行资源关闭，就可以通过继承一个AbstractConnectionCustomizer来实现相关
方法，配置的时候使用全类名。有点类似监听器的作用。
例如：
import java.sql.Connection;
import com.mchange.v2.c3p0.AbstractConnectionCustomizer;
public class ConnectionCustomizer extends AbstractConnectionCustomizer{
@Override
public void onAcquire(Connection c, String parentDataSourceIdentityToken)
throws Exception {
System.out.println("acquire : " + c);
}
@Override
public void onCheckIn(Connection c, String parentDataSourceIdentityToken)
throws Exception {
System.out.println("checkin : " + c);
}
@Override
public void onCheckOut(Connection c, String parentDataSourceIdentityToken)
throws Exception {
System.out.println("checkout : " + c);
}
@Override
public void onDestroy(Connection c, String parentDataSourceIdentityToken)
throws Exception {
System.out.println("destroy : " + c);
}
}<property name="connectionCustomizerClassName">liuyun.zhuge.db.ConnectionCustomizer</property>
7.配置未提交的事务处理
autoCommitOnClose
default : false
连接池在回收数据库连接时是否自动提交事务
如果为false，则会回滚未提交的事务
如果为true，则会自动提交事务
forceIgnoreUnresolvedTransactions
default : false
这个配置强烈不建议为true。
一般来说事务当然由自己关闭了，为什么要让连接池来处理这种不细心问题呢？
8.配置debug和回收Connection 一般来说事务当然由自己关闭了，为什么要让连接池来处理这种不细心问题呢？
unreturnedConnectionTimeout
default : 0 单位 s
为0的时候要求所有的Connection在应用程序中必须关闭。如果不为0，则强制在设定的时间到达后回收
Connection，所以必须小心设置，保证在回收之前所有数据库操作都能够完成。这种限制减少Connection未关闭
情况的不是很适用。为0不对connection进行回收，即使它并没有关闭。
debugUnreturnedConnectionStackTraces
default : false
如果为true并且unreturnedConnectionTimeout设为大于0的值，当所有被getConnection出去的连接
unreturnedConnectionTimeout时间到的时候，就会打印出堆栈信息。只能在debug模式下适用，因为
打印堆栈信息会减慢getConnection的速度
同第七项一样的，连接用完当然得close了，不要通过unreturnedConnectionTimeout让连接池来回收未关闭的连接。
9.其他配置项：因为有些配置项几乎没有自己配置的必要，使用默认值就好，所以没有再写出来
checkoutTimeout
default : 0
配置当连接池所有连接用完时应用程序getConnection的等待时间。为0则无限等待直至有其他连接释放
或者创建新的连接，不为0则当时间到的时候如果仍没有获得连接，则会抛出SQLException
三、示例：
示例采用第二种方式：
1.c3p0.properties:
#驱动 c3p0.driverClass=com.mysql.jdbc.Driver #地址 c3p0.jdbcUrl=jdbc:mysql://localhost:3306/jdbc #用户名 c3p0.user=root #密码 c3p0.password=lovejava #------------------------------- #连接池初始化时创建的连接数 c3p0.initialPoolSize=3 #连接池保持的最小连接数 c3p0.minPoolSize=3 #连接池在无空闲连接可用时一次性创建的新数据库连接数,default:3 c3p0.acquireIncrement=3 #连接池中拥有的最大连接数，如果获得新连接时会使连接总数超过这个值则不会再获取新连接，而是等待其他连接释放，所以这个值有可能会设计地很大,default : 15 c3p0.maxPoolSize=15 #连接的最大空闲时间，如果超过这个时间，某个数据库连接还没有被使用，则会断开掉这个连接,单位秒 c3p0.maxIdleTime=100 #连接池在获得新连接失败时重试的次数，如果小于等于0则无限重试直至连接获得成功 c3p0.acquireRetryAttempts=30 #连接池在获得新连接时的间隔时间 c3p0.acquireRetryDelay=1000
2.ConnectionPool
package com.study.pool;
import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class ConnectionPool {
private DataSource ds;
private static ConnectionPool pool;
private ConnectionPool(){
ds = new ComboPooledDataSource();
}
public static final ConnectionPool getInstance(){
if(pool==null){
try{
pool = new ConnectionPool();
}catch (Exception e) {
e.printStackTrace();
}
}
return pool;
}
public synchronized final Connection getConnection() {
try {
return ds.getConnection();
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
} 3.PoolThread
package com.study.pool;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class PoolThread extends Thread {
@Override
public void run(){
ConnectionPool pool = ConnectionPool.getInstance();
Connection con = null;
PreparedStatement stmt= null;
ResultSet rs = null;
try{
con = pool.getConnection();
stmt = con.prepareStatement("select sysdate as nowtime from dual");
rs = stmt.executeQuery();
while(rs.next()){
System.out.println(Thread.currentThread().getId()+"---------------开始"+rs.getString("nowtime"));
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
rs.close();
stmt.close();
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getId()+"--------结束");
}
} 4.PoolMain
package com.study.pool;
public class PoolMain {
/**
* 数据源缓冲池 实例练习
*/
public static void main(String[] args) {
System.out.println("缓冲池模拟开始");
PoolThread[] threads = new PoolThread[50];
for(int i=0;i<threads.length;i++){
threads[i] = new PoolThread();
}
for(int i=0;i<threads.length;i++){
threads[i].start();
}
}
}Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
