Comment mettre en place un pool de connexions JDBC?

Si vous avez besoin d'un autonome pool de connexion, ma préférence va à C3P0 sur DBCP (que j'ai mentionné dans ce réponse précédente), j'ai juste eu trop de problèmes avec DBCP sous une lourde charge. À l'aide de C3P0 est mort simple. À partir de la la documentation:

ComboPooledDataSource cpds = new ComboPooledDataSource();
cpds.setDriverClass( "org.postgresql.Driver" ); //loads the jdbc driver
cpds.setJdbcUrl( "jdbc:postgresql://localhost/testdb" );
cpds.setUser("swaldman");
cpds.setPassword("test-password");

//the settings below are optional -- c3p0 can work with defaults
cpds.setMinPoolSize(5);
cpds.setAcquireIncrement(5);
cpds.setMaxPoolSize(20);

//The DataSource cpds is now a fully configured and usable pooled DataSource 

Mais si vous êtes en cours d'exécution à l'intérieur d'un serveur d'application, je vous recommande d'utiliser l'intégré dans le pool de connexion qu'il fournit. Dans ce cas, vous devez le configurer (reportez-vous à la documentation de votre serveur d'application) et de récupérer une source de données via JNDI:

DataSource ds = (DataSource) new InitialContext().lookup("jdbc/myDS");

Je vous conseille d'utiliser le communes-dbcp de la bibliothèque. Il existe de nombreux exemples répertoriés sur la façon de l'utiliser, voici le lien pour le déplacer simple. L'utilisation est très simple:

 BasicDataSource ds = new BasicDataSource();
 ds.setDriverClassName("oracle.jdbc.driver.OracleDriver")
 ds.setUsername("scott");
 ds.setPassword("tiger");
 ds.setUrl(connectURI);
 ...
 Connection conn = ds.getConnection();

Vous avez seulement besoin de créer la source de données une fois, alors assurez-vous de lire la documentation si vous ne savez pas comment le faire. Si vous n'êtes pas conscients de la façon d'écrire correctement JDBC états de sorte que vous n'avez pas de fuite de ressources, vous pouvez aussi envie de lire ce Wikipédia page.

Ne pas réinventer la roue.

Essayez l'une des facilement disponibles 3ème partie composants:

• Apache DBCP - Ce qu'on est
  utilisé en interne par Tomcat, et par
  sincèrement vôtre.
• c3p0

Apache DBCP est livré avec différents exemple de configuration d'un groupement de javax.sql.Source de données. Voici un exemple qui peuvent vous aider à obtenir commencé.

Piscine

• Mécanisme de mise en commun est le moyen de créer les Objets à l'avance. Quand une classe est chargée.
• Il améliore l'application performance [re en utilisant le même objet est de réaliser une action sur l'Objet-Données] & memory [affectation et de réaffectation des de nombreux objets crée une mémoire importante des frais de gestion].
• Objet le nettoyage n'est pas nécessaire comme nous utilisons le même Objet, la réduction de la collecte des Déchets de la charge.

« La mutualisation [ Objet piscine, String Constante de la Piscine, Thread Piscine, pool de Connexion]

Constante de chaîne piscine

• Littéral de chaîne de la piscine ne conserve qu'une seule copie de chaque chaîne de valeur. qui doivent être immuables.
• Lorsque le stagiaire méthode est invoquée, elle vérifier objet de la disponibilité avec le même contenu dans la piscine à l'aide de méthode equals.
  « Si la Chaîne de copie est disponible dans la Piscine puis retourne la référence.
  « Dans le cas contraire, la Chaîne de l'objet est ajouté à la piscine et retourne la référence.

Exemple: Chaîne de vérifier Objet Unique de la piscine.

public class StringPoolTest {
    public static void main(String[] args) { //Integer.valueOf(), String.equals()
        String eol = System.getProperty("line.separator"); //java7 System.lineSeparator();

        String s1 = "Yash".intern();
        System.out.format("Val:%s Hash:%s SYS:%s "+eol, s1, s1.hashCode(), System.identityHashCode(s1));
        String s2 = "Yas"+"h".intern();
        System.out.format("Val:%s Hash:%s SYS:%s "+eol, s2, s2.hashCode(), System.identityHashCode(s2));
        String s3 = "Yas".intern()+"h".intern();
        System.out.format("Val:%s Hash:%s SYS:%s "+eol, s3, s3.hashCode(), System.identityHashCode(s3));
        String s4 = "Yas"+"h";
        System.out.format("Val:%s Hash:%s SYS:%s "+eol, s4, s4.hashCode(), System.identityHashCode(s4));
    }
}

Pool de connexion à l'aide de Type 4 Pilote à l'aide de la 3e partie des bibliothèques[ DBCP2, c3p0, Tomcat JDBC]

Type 4 - The Thin driver converts JDBC calls directly into the vendor-specific database protocol Ex[Oracle - Thick, MySQL - Quora]. wiki

Dans le mécanisme de pool de connexions, lorsque la classe est chargée, elle est la physique connexion JDBC objets et fournit un enveloppé de connexion physique de l'objet à l'utilisateur. PoolableConnection est un wrapper autour de la connexion réelle.

• getConnection() de choisir l'une des gratuit enveloppé-forme de connexion la connexion objectpool et le renvoie.
• close() au lieu de le fermer renvoie la enveloppé de connexion de retour de la piscine.

Exemple: à l'Aide de ~ DBCP2 Pool de Connexion avec Java 7[try-with-resources]

public class ConnectionPool {
static final BasicDataSource ds_dbcp2 = new BasicDataSource();
static final ComboPooledDataSource ds_c3p0 = new ComboPooledDataSource();
static final DataSource ds_JDBC = new DataSource();
static Properties prop = new Properties();
static {
try {
prop.load(ConnectionPool.class.getClassLoader().getResourceAsStream("connectionpool.properties"));
ds_dbcp2.setDriverClassName( prop.getProperty("DriverClass") );
ds_dbcp2.setUrl( prop.getProperty("URL") );
ds_dbcp2.setUsername( prop.getProperty("UserName") );
ds_dbcp2.setPassword( prop.getProperty("Password") );
ds_dbcp2.setInitialSize( 5 );
ds_c3p0.setDriverClass( prop.getProperty("DriverClass") );
ds_c3p0.setJdbcUrl( prop.getProperty("URL") );
ds_c3p0.setUser( prop.getProperty("UserName") );
ds_c3p0.setPassword( prop.getProperty("Password") );
ds_c3p0.setMinPoolSize(5);
ds_c3p0.setAcquireIncrement(5);
ds_c3p0.setMaxPoolSize(20);
PoolProperties pool = new PoolProperties();
pool.setUrl( prop.getProperty("URL") );
pool.setDriverClassName( prop.getProperty("DriverClass") );
pool.setUsername( prop.getProperty("UserName") );
pool.setPassword( prop.getProperty("Password") );
pool.setValidationQuery("SELECT 1");//SELECT 1(mysql) select 1 from dual(oracle)
pool.setInitialSize(5);
pool.setMaxActive(3);
ds_JDBC.setPoolProperties( pool );
} catch (IOException e) {   e.printStackTrace();
} catch (PropertyVetoException e) { e.printStackTrace(); }
}
public static Connection getDBCP2Connection() throws SQLException {
return ds_dbcp2.getConnection();
}
public static Connection getc3p0Connection() throws SQLException {
return ds_c3p0.getConnection();
}
public static Connection getJDBCConnection() throws SQLException {
return ds_JDBC.getConnection();
}
}
public static boolean exists(String UserName, String Password ) throws SQLException {
boolean exist = false;
String SQL_EXIST = "SELECT * FROM users WHERE username=? AND password=?";
try ( Connection connection = ConnectionPool.getDBCP2Connection();
PreparedStatement pstmt = connection.prepareStatement(SQL_EXIST); ) {
pstmt.setString(1, UserName );
pstmt.setString(2, Password );
try (ResultSet resultSet = pstmt.executeQuery()) {
exist = resultSet.next(); //Note that you should not return a ResultSet here.
}
}
System.out.println("User : "+exist);
return exist;
}

jdbc:<DB>:<drivertype>:<HOST>:<TCP/IP PORT>:<dataBaseName>
jdbc:oracle:thin:@localhost:1521:myDBName
jdbc:mysql://localhost:3306/myDBName

connectionpool.propriétés

URL         : jdbc:mysql://localhost:3306/myDBName
DriverClass : com.mysql.jdbc.Driver
UserName    : root
Password    :

Web Application: Pour éviter les problème de connexion lorsque toutes les connexions sont fermées[MySQL "wait_timeout" par défaut 8 heures] dans l'ordre de rouvrir la connexion sous-jacente DB.

Vous pouvez le faire Tester à Chaque Connexion en définissant testOnBorrow = true et validationQuery= "SELECT 1" et donot utiliser autoReconnect pour le serveur MySQL comme il est obsolète. question

===== ===== context.xml ===== =====
<?xml version="1.0" encoding="UTF-8"?>
<!-- The contents of this file will be loaded for a web application -->
<Context>
<Resource name="jdbc/MyAppDB" auth="Container" 
factory="org.apache.tomcat.jdbc.pool.DataSourceFactory" 
type="javax.sql.DataSource" 
initialSize="5" minIdle="5" maxActive="15" maxIdle="10"
testWhileIdle="true"
timeBetweenEvictionRunsMillis="30000"
testOnBorrow="true"
validationQuery="SELECT 1"
validationInterval="30000"
driverClassName="com.mysql.jdbc.Driver" 
url="jdbc:mysql://localhost:3306/myDBName" 
username="yash" password="777"
/>
</Context>
===== ===== web.xml ===== =====
<resource-ref>
<description>DB Connection</description>
<res-ref-name>jdbc/MyAppDB</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
===== ===== DBOperations ===== =====
servlet «   init() {}
Normal call used by sevlet  « static {}
static DataSource ds;
static {
try {
Context ctx=new InitialContext();
Context envContext = (Context)ctx.lookup("java:comp/env");
ds  =   (DataSource) envContext.lookup("jdbc/MyAppDB");
} catch (NamingException e) {   e.printStackTrace();    }
}

Voir également:

• suis-je-aide-jdbc-connexion de la mise en commun
• configuration-jdbc-piscine-haute concurrence

Comme répondu par d'autres, vous aurez probablement être heureux avec Apache Dbcp ou c3p0. Les deux sont populaires, et fonctionnent très bien.

Concernant votre doute

N'est pas javax.sql ou java.sql ont
connexion de pool implémentations? Pourquoi
ne serait-il pas préférable d'utiliser ces?

Ils ne fournissent pas mises en œuvre, plutôt interfaces et certaines classes de soutien, seules conditions pour les programmeurs qui mettent en œuvre des bibliothèques tierces (piscines ou des pilotes). Normalement, vous ne regardez même pas que. Votre code doit composer avec les connexions de votre piscine tout comme ils ont été "clair" des connexions, de manière transparente.

Apache Commons dispose d'une bibliothèque à cet effet: DBCP. Sauf si vous avez étrange exigences autour de vos piscines, je voudrais utiliser une bibliothèque comme il est lié à être plus difficile et plus subtile qu'on ne pourrait l'espérer.

MiniConnectionPoolManager est un java-fichier de mise en œuvre, si vous êtes à la recherche d'une solution intégrable et ne sont pas trop préoccupés par les performances (même si je ne l'ai pas testé sur ce sujet).

Il est multi-licence EPL, LGPL et MPL.

Sa documentation donne aussi des alternatives à la peine de vérifier (sur le haut de DBCP et C3P0):

• Proxool
• BoneCP
• Tomcat Pool de connexions JDBC