mostrar - pool de conexiones java netbeans

Necesita código para crear grupo de conexiones en java

Question

¿Necesita código para crear el grupo de conexiones en java? ¿Cómo nos aseguramos de que la agrupación de conexiones no devuelva el mismo objeto que ya está en uso? ¿Qué sucede si el cliente cerró la conexión después de sacarla del grupo de conexiones?

Actualización 1:

Quiero crear esto en términos simples de Java y quiero ver cómo funciona en Multithreading Env. Me refiero a qué métodos se sincronizarían y cuáles no. ¿También esta clase sería una clase pública? Si es así, ¿alguien puede acceder a esta clase y reinicializar el grupo de conexiones?

Actualización 2:

Tengo un código como el siguiente. Pero no sé cómo "Cerrar una conexión proveniente de un grupo lo devuelve al grupo, no cierra físicamente la conexión". Además, no entendí esto "Porque si una conexión se tomó prestada del grupo y aún no se ha devuelto, no está" disponible "y no se puede redistribuir a otro cliente del grupo".

import java.util.*;
import java.sql.*;
class ConnectionPoolManager
{
String databaseUrl = "jdbc:mysql://localhost:3306/myDatabase";
String userName = "userName";
String password = "userPass";
Vector connectionPool = new Vector();
public ConnectionPoolManager()
{
initialize();
}
public ConnectionPoolManager(
//String databaseName,
String databaseUrl,
String userName,
String password
)
{
this.databaseUrl = databaseUrl;
this.userName = userName;
this.password = password;
initialize();
}
private void initialize()
{
//Here we can initialize all the information that we need
initializeConnectionPool();
}
private void initializeConnectionPool()
{
while(!checkIfConnectionPoolIsFull())
{
System.out.println("Connection Pool is NOT full. Proceeding with adding new connections");
//Adding new connection instance until the pool is full
connectionPool.addElement(createNewConnectionForPool());
}
System.out.println("Connection Pool is full.");
}
private synchronized boolean checkIfConnectionPoolIsFull()
{
final int MAX_POOL_SIZE = 5;
//Check if the pool size
if(connectionPool.size() < 5)
{
return false;
}
return true;
}
//Creating a connection
private Connection createNewConnectionForPool()
{
Connection connection = null;
try
{
Class.forName("com.mysql.jdbc.Driver");
connection = DriverManager.getConnection(databaseUrl, userName, password);
System.out.println("Connection: "+connection);
}
catch(SQLException sqle)
{
System.err.println("SQLException: "+sqle);
return null;
}
catch(ClassNotFoundException cnfe)
{
System.err.println("ClassNotFoundException: "+cnfe);
return null;
}
return connection;
}
public synchronized Connection getConnectionFromPool()
{
Connection connection = null;
//Check if there is a connection available. There are times when all the connections in the pool may be used up
if(connectionPool.size() > 0)
{
connection = (Connection) connectionPool.firstElement();
connectionPool.removeElementAt(0);
}
//Giving away the connection from the connection pool
return connection;
}
public synchronized void returnConnectionToPool(Connection connection)
{
//Adding the connection from the client back to the connection pool
connectionPool.addElement(connection);
}
public static void main(String args[])
{
ConnectionPoolManager ConnectionPoolManager = new ConnectionPoolManager();
}
}

Answer 1

¿Necesita código para crear el grupo de conexiones en java?

No está seguro de cuál es la pregunta, pero no cree otra agrupación de conexiones, use una solución existente como C3P0 , Apache DBCP , Proxool o BoneCP (un nuevo jugador en ese campo). Yo usaría C3P0.

¿Cómo nos aseguramos de que la agrupación de conexiones no devuelva el mismo objeto que ya está en uso?

Porque si una conexión se tomó prestada del grupo y aún no se devolvió, simplemente no está en el grupo y no se puede asignar a otro cliente del grupo (los recursos se eliminan del grupo hasta que se devuelven).

¿Qué sucede si el cliente cerró la conexión después de sacarla del grupo de conexiones?

La conexión que un cliente obtiene de un grupo no es realmente una java.sql.Connection , es una envoltura (un proxy) para una java.sql.Connection que personaliza el comportamiento de algunos métodos. El método close() es uno de ellos y no cierra la instancia de Connection , sino que la devuelve al grupo.

Answer 2

Espero que este código fuente ayude a http://jagadeeshmanne.blogspot.in/2014/03/connection-pool-in-java-jdbc.html

Configuración.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);
}
}

DataSource.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);
}
}

Answer 3

No escribas el tuyo. Hay un montón de bibliotecas por ahí que harán esto por ti que son de código abierto y fáciles de usar y habrán resuelto todos los problemas que encontrarás al tratar de crearlo tú mismo.

Aquí hay un ejemplo simple que usa DBCP de Commons de Apache y el Pool de Commons:

Primero configurar una fuente de datos.

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");

Una vez que tenga un DataSource, es fácil obtener una conexión del grupo.

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

Cerrar la conexión lo devolverá a la piscina para usted.

connection.close();

Answer 4

Sólo usa semáforos. Idealmente, lo que debería hacer es usar CP3O o DBCP como su grupo de conexión. Ahora puedes estrangular tu conexión basada en el Semáforo.

Cada vez que haces Get , adquieres y en cada Release lo liberas de Semaphore. Más sobre los semáforos son hilos seguros.

Answer 5

Si su aplicación se ejecuta en un servidor, configúrela como Fuente de datos, donde el servidor se encargará de la agrupación o si un simple Java Client entonces usa Apache DBCP (si está en la base de datos) o si no usa la API de Apache Commons. Vea aquí: Apache Commons

Answer 6

Un argumento para hacer rodar su propio connpool es la configuración y los archivos jar adicionales que se evitan. Estoy de acuerdo en que necesita habilitar las interfaces de terceros para poder intercambiar una conexión madura, pero tener su propia solución pequeña puede tener su lugar. Vector autolimpiante con bloque sincronizado y una envoltura conn con cierre () que marca la conexión como disponible funciona muy bien para aplicaciones servlet.

Answer 7

Utilice uno de los existentes, por ejemplo, Apache DBCP

Las conexiones devueltas por el grupo a menudo son proxies que "ignoran" la llamada a close() desde la aplicación. Cuando las conexiones se devuelven a la agrupación, se pueden reutilizar. Las piscinas también se cierran y vuelven a abrir automáticamente si es necesario.