pool de conexiones

[magam]

Buenas, mi duda del dia de hoy es la siguiente:
me gustaria saber mas sobre pool de conexiones, en este momento me encuentro programando las clases necesarias para despues mas adelante usar web.
En las clases por ejemplo insertPersona(); lo que hago dentro de este metodo es llamar a una clase conexion que use el jdbc, ahora mi duda es, con el pool de conexiones esto que hago en cada metodo desaparece?
como es el correcto uso del pool ? me podrian por favor mostrar un ejemplo simple? y en donde utilizarlo?'
muchas gracias.

[chuidiang]

Hola:

Con un pool de conexiones lo que haces es en vez de crear tú mismo la Connection a base de datos, se la pidesl al Pool. Para usarlo correctamente, debes cerrar la Connection después de haber hecho la transacción

Código:

Connection con = pool.getConnection();
// Aquí haces el select, insert, update....
con.close();

Casi te diría que conviene usar un Pool siempre. En principio debe usarse siempre que haya varios hilos que quieran acceder a base de datos y que haya que abrir y cerrar conexiones con cierta frecuencia.

Se bueno.

[GreenEyed]

Exactamente. Hay que tener en cuenta ademas que en este caso, hacer un close() de la conexion no es cerrar la conexion, si no devolverla al pool*. Lo importante del pool es que mantiene abiertas las conexiones por que lo que nos ahorramos el tiempo de conexion a la BDD, usualmente 1~2 segundos minimo, y que por otro lado, al limitar las conexiones que se crean simultaneamente, estamos protegiendo la BDD frente a picos de carga.

Si abrimos demasiadas conexiones a la vez contra la BDD o las cerramos/abrimos con demasiada frecuencia, la BDD "sufre" y el rendimiento global cae.

Por eso es tan importante usar un pool de conexiones en aplicaciones web, donde la concurrencia es la norma y los picos de carga pueden ocurrir en cualquier momento. Las aplicaciones de escritorio que se conectan directamente a una BDD no tienen ese problema, aunque si tienen que hacer varias tareas a la vez, tambien pueden beneficiarse de los pool.

S!

*: No es así en todos los pools pero si es muy habitual y es así en la especificacion del java.sql.DataSource que se usa en servidores de aplicaciones Java. Personalmente no me gusta que usen el mismo nombre y aislen totalmente la conexion, el pool que tengo hecho yo no funciona así, pero es como esta hecho DataSource.

[Lino-kun]

Hola.

Esta clase se hace la peticion al pool que ya esta configurado en el servidor.

Código PHP:

  import java.sql.*; 
import javax.naming.InitialContext; 
import javax.sql.DataSource; 
 
public class ConnectionFactory { 
  private static String jndi="java:comp/env/jdbc/ConEnvDS"; 
  public static Connection getConnection() throws SQLException{ 
   Connection conn=null; 
   try{ 
     InitialContext ini = new InitialContext();                                                                              
     DataSource ds = (DataSource) ini.lookup(jndi);                          
     conn = ds.getConnection();                                              
    }catch(Exception e){ 
      e.printStackTrace(); 
      throw new SQLException(e.getMessage());                                   
    } 
    return conn; 
  } 
   
  public static void closeConnection(Connection conn) throws SQLException{ 
    try{ 
     if(conn!=null && !conn.isClosed()){ 
       conn.close(); 
     } 
    }catch(SQLException e){ 
      e.printStackTrace(); 
    } 
  } 
}  
   

esta clase realiza operaciones en la base de datos.

Código PHP:

  import java.sql.Connection; 
import java.sql.PreparedStatement; 
import java.sql.ResultSet; 
import java.sql.SQLException; 
 
public class ConsultasDAO { 
  public ConsultaaDAO(){} 
 
  public String getConsulta(String parametro) throws Exception{ 
      String parametro2=null; 
        Connection conn = null;         
    PreparedStatement ps = null; 
    ResultSet rs = null; 
    String sql = "select * from TABLA where PARAMETRO=? "; 
     
    try{ 
        conn = ConnectionFactory.getConnection(); 
        ps = conn.prepareStatement(sql); 
        ps.setString(1,parametro); 
        rs = ps.executeQuery(); 
         
        if(rs.next()){ 
            parametro2=rs.getString("PARAMETRO"); 
        } 
    }catch(Exception e){ 
        throw new SQLException(e.getMessage()); 
    }finally{ 
        if(rs != null) 
            rs.close(); 
        if(ps != null) 
            ps.close(); 
    } 
    ConnectionFactory.closeConnection(conn); 
    return parametro2;   
  } 
}  
   

si quieres pasate por la seccion de FAQs ahi puse un ejemplo de configurar y usar un pool de conexiones.

saludos.

[magam]

gracias por la ayuda, por ah ies tonto lo que voy a preguntar, pero igual..
si tengo varios modulos en donde se insertan,modifican etc.. datos hay que usar este codigo?

Connection con = pool.getConnection();
// Aquí haces el select, insert, update....
con.close();

es decir en lugar de hacer el getconection comun solo se reemplaza por el pool?
muchas gracias

[GreenEyed]

Iniciado por Lino-kun

Hola.

Esta clase se hace la peticion al pool que ya esta configurado en el servidor.
...

No te lo tomes a mal pero el código que has puesto no es eficiente ni seguro. No es eficiente por que estas haciendo un "JNDI lookup" cada vez que pides una conexion, lo cual no es eficiente si siempre vas a usar el mismo DataSource, y ademas estas repitiendo mucho código en el metodo comun que total vas a hacer algo parecido en cada metodo. Y no es seguro por que asi como lo usas no garantizas que las conexiones siempre se devuelvan al pool.

Aparte de que estas perdiendo mucha informacion de las excepciones al encapsularlas solo copiando el getMessage, y enmascarando el origen por otro que quiza no es (convirtiendo un NameNotFound en una SQLException, por ejemplo)

Lo digo solo como critica constructiva por que no sería muy recomendable usar ese codigo en produccion, IMHO.

S!

[Lino-kun]

hola no te lo tomo a mal alcontrario gracias por que asi crecemos todos.

pero te explico.

yo tengo aprox 10 DataSources y bueno la clase ConnectionFactory me ahorra muchas tareas, por eso la pongo.


saludos

[GreenEyed]

Ya, pero aunque tengas 10, si no le pasas el nombre del DataSource en cada llamada, entonces es que en realidad no necesitas hacer el lookup cada vez. Y un JNDI lookup es una operacion costosa en tiempo que conviene evitar.

De todas formas, la parte mas preocupante es no asegurar que las conexiones se devuelvan al pool, dado que no estas devolviendo la conexion dentro de un finally "protegido" anti-excepciones.

S!

[Lino-kun]

Hola.

Lo de los costos en tiempo lo desconocia voy a averiguar un poco mas sobre esto, y lo del finally no lo uso para devolver la conexion sino para cerrar el PreparedStatement y el ResultSet creo que no has visto bien jeje.

Si te fijas bien en caso de que la conexion no se logre se genera una excepcion. puse dos clases completamente distintas y creo que estas mezclando tus observaciones, por que despues de cerrar el PreparedStatement y el ResultSet, cierro la conexion con el pool.

[GreenEyed]

Si ocurre una excepcion ejecutando el codigo o cerrando el resultset o el prepared statement, la conexion nunca se cierra/devuelve al data source.

Aunque lo hagas "despues" el codigo no tiene que para por ConnectionFactory.closeConnection(conn); puesto que esta instruccion esta fuera del finally. Asi que cualquier excepcion se la salta.

Así que creo que veo perfectamente .

S!