Besoin de code pour créer un pool de connexions en java

Besoin de code pour créer le pool de connexions en java?

Vous ne savez pas quelle est la question mais ne créez pas encore un autre pool de connexions, utilisez une solution existante comme C3P0, , Proxool ou BoneCP (un nouveau joueur dans ce domaine). Je voudrais utiliser C3P0.

Comment s'assurer que le pool de connexions ne renvoie pas le même objet qui est déjà utilisé?

Parce que si une connexion a été empruntée du pool et pas encore renvoyé, il n'est tout simplement pas dans le pool et ne peut pas être affecté à un autre client du pool (les ressources sont supprimées du pool jusqu'à ce qu'elles soient renvoyées).

Comment se passe - t-il si le client a fermé la connexion après l'avoir retirée du pool de connexions?

La connexion, le client obtient à partir d'un pool n'est pas vraiment un java.sql.Connection, c'est un wrapper (un proxy) pour un java.sql.Connection qui permettent de personnaliser le comportement de certaines méthodes. La méthode close() est l'une des eux et nepas ferme l'instance Connection mais la renvoie au pool.

N'écrivez pas le vôtre. Il y a beaucoup de librarires là-bas qui le feront pour vous qui sont open source et facile à utiliser et auront résolu tous les problèmes que vous rencontrerez en essayant de le faire vous-même.

Voici un exemple simple qui utilise le pool Commons DBCP et Commons d'Apache:

Configurez d'abord une source de données.

javax.sql.DataSource source = new org.apache.commons.dbcp.BasicDataSource();
source.setDriverClassName("com.mysql.jdbc.Driver");
source.setUsername("username");
source.setPassword("password");
source.setUrl("jdbc:mysql://localhost:3306/myDatabase");

Une fois que vous avez une source de données, il est facile d'obtenir une connexion à partir du pool.

java.sql.Connection connection = source.getConnection();

La fermeture de la connexion la renverra au piscine pour vous.

connection.close();

J'espère que ce code source aide http://jagadeeshmanne.blogspot.in/2014/03/connection-pool-in-java-jdbc.html

La Configuration.java

package com.jmanne.utils;

public class Configuration {

 public String DB_USER_NAME ;

 public String DB_PASSWORD ;

 public String DB_URL;

 public String DB_DRIVER;

 public Integer DB_MAX_CONNECTIONS;

 public Configuration(){
  init();
 }

 private static Configuration configuration = new Configuration();

 public static Configuration getInstance(){ 
  return configuration;
 }

 private void init(){
  DB_USER_NAME = "root"
  DB_PASSWORD = "root"
  DB_URL = "jdbc:mysql://localhost:3306/jmanne"
  DB_DRIVER = "com.mysql.jdbc.Driver"
  DB_MAX_CONNECTIONS = 5
 }     
}

JdbcConnectionPool.java

package com.jmanne.db;

import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.jmanne.utils.Configuration;
import com.mysql.jdbc.Connection;

public class JdbcConnectionPool {

 List<connection> availableConnections = new ArrayList<connection>();

 public JdbcConnectionPool()
 {
  initializeConnectionPool();
 }

 private void initializeConnectionPool()
 {
  while(!checkIfConnectionPoolIsFull())
  {
   availableConnections.add(createNewConnectionForPool());
  }
 }

 private synchronized boolean checkIfConnectionPoolIsFull()
 {
  final int MAX_POOL_SIZE = Configuration.getInstance().DB_MAX_CONNECTIONS;

  if(availableConnections.size() < MAX_POOL_SIZE)
  {
   return false;
  }

  return true;
 }

 //Creating a connection
 private Connection createNewConnectionForPool()
 {
  Configuration config = Configuration.getInstance();
  try {
   Class.forName(config.DB_DRIVER);
   Connection connection = (Connection) DriverManager.getConnection(
     config.DB_URL, config.DB_USER_NAME, config.DB_PASSWORD);
   return connection;
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  } catch (SQLException e) {
   e.printStackTrace();
  }
  return null;

 }

 public synchronized Connection getConnectionFromPool()
 {
  Connection connection = null;
  if(availableConnections.size() > 0)
  {
   connection = (Connection) availableConnections.get(0);
   availableConnections.remove(0);
  }
  return connection;
 }

 public synchronized void returnConnectionToPool(Connection connection)
 {
  availableConnections.add(connection);
 }
}

Source de données.java

package com.jmanne.db;

import java.sql.SQLException;

import com.mysql.jdbc.Connection;

public class DataSource {

 static JdbcConnectionPool pool = new JdbcConnectionPool();

 public static Connection getConnection() throws ClassNotFoundException, SQLException{
  Connection connection = pool.getConnectionFromPool();
  return connection;
 }

 public static void returnConnection(Connection connection) {
  pool.returnConnectionToPool(connection);
 }
}

Utilisez simplement des Sémaphores. Idéalement, vous devez utiliser CP3O ou DBCP comme pool de connexions. Maintenant, vous pouvez étrangler votre connexion basée sur le sémaphore.

Chaque fois que vous faites Get, vous acquérez et sur chaque Release vous le libérez du Sémaphore. Plus sur les sémaphores sont thread safe.

Utilisez l'un des éléments existants, par exemple Apache DBCP

Les connexions renvoyées par le pool sont souvent des proxys qui "ignorent" l'appel à close() depuis l'application. Lorsque les connexions sont renvoyées au pool, elles peuvent être réutilisées. Les piscines ferment également et rouvrent automatiquement si nécessaire.

Si votre application s'exécute sur un serveur, configurez-la en tant que source de données, où le serveur s'occupera du Pooling ou bien si un simple client Java utilise Apache DBCP (si pour la base de données) ou bien utilisez Apache Commons Pooling API Voir ici: Apache Commons

Un argument pour lancer votre propre connpool est la configuration et les jars supplémentaires qui sont évités. Je suis d'accord que vous devez activer les interfaces tierces afin que vous puissiez échanger dans un connpool mature, mais avoir votre propre solution minuscule peut avoir sa place. Vecteur autonettoyant avec bloc synchronisé et un wrapper conn avec close() marquant le conn comme disponible fonctionne très bien pour les applications de servlet.