Pool de conexiones en PHP

[juanpablomagno]

Hola a todos foristas...
Estoy implementando un sistema de registro de alumnos en PHP5 / Postgres con tres capas, no estoy utilizando ningun framework o uno de esos otros chiches (quisiera toparme con estos problemillas primero). Mi consulta radica en la forma en que hago mis conexiones de base datos, si bien es cierto hay q dejar todo el peso de las conexiones a la capa de persistencia de datos, esto hace q abra y cierre las conexiones a cada rato.
Por ejemplo en el caso de cargar un objeto alumno haria:

Código PHP:

  function buscarAlumno($codigo){
    $con = new Conexion();
    $con->conectarse();

    // hago mi consulta
    $con->query($sql)

    $alumno = new Alumno();    
    $alumno->colegio = Colegio::buscarColegio($data["cod_colegio"]);
    //este metodo internamente tambien abre y cierra una conexion;
    $alumno->ciudad = Colegio::buscarCiudad($data["cod_ciudad"]);
    //esta tambien
    //... y cuantas tuviera

    $con->cerrar_conexion();
    // cerramos la conexion de al inicio
    return $alumno;
} 
   

Esto abriria y cerraria muchas conexiones por lo q reventaria el limite de estas.
Otro caso es este:

Código PHP:

  function buscarAlumno($con,$codigo){
    $alumno = new Alumno();
    // hago mi consulta
    $con->query($sql)
    $alumno->colegio = Colegio::buscarColegio($con,$data["cod_colegio"]);
    //usa la conexion ya disponible;
    $alumno->ciudad = Colegio::buscarCiudad($con,$data["cod_ciudad"]);
    //este tambien
    //... y cuantas tuviera

    return $alumno;
} 
   

Aqui mando mi conexion abierta desde fuera, pero esto haria que el que abra mi conexion sea mi capa de logica de negocio, pero supuestamente esta no debería ser su funcion, ademas imaginemos q el metodo de la capa de logica sea un poco extensa, la conexion estaria abierta mucho tiempo, y eso tambien acarrearia problemas.
La pregunta del millon es esta...
¿Cual de las dos formas es la mas optima a utilizar?
¿Existe una tercera forma?
¿Que hay de los pool de conexiones.. me comentaban que evitaban estos problemas?
Esto ultimo no lo he investigado
Agredecere cualquier colaboracion.

[sism82]

te estas enfrentando a este problema por que no has separado bien las responsabilidades de cada clase. Crea tu propia clase para base de datos y utiliza un patrón de diseño conocido como "Singleton" para obtener solo 1 conexión por base de datos. A continuación te dejo los inicios de una nueva clase que he iniciado a utilizar para mis conexiones.

Código PHP:

  <?php
/**
 * @package DbUtils
 */

/**
 * this class is a small abstraction of the PDO (PHP Dataobjects) database model
 * it implements singleton pattern to ensure that just 1 instance is created for
 * each requested database (DSN)
 * @todo hum, i guess a lot. I have only implemented what i need for now
 * @final
 */
final class PdoDatabase
{
    /**
     * array object of intances of PdoDatabase objects.
     * Only one object for DSN is allowed. So we
     * have an array object
     * @see PdoDatabase::GetPdoDatabase
     * @var object PdoDatabase
     * @static
     * @access private
     */
    private static $databases = NULL;

    /**
     * @var object PDO
     * @access private
     */
    private $pdo_object = NULL;

    /**
     * whether or not show debug info to STDOUT
     * @var bool
     * @access private
     */
    private $debug_mode = FALSE;

    /**
     * PdoDatabase private constructor. Just to ensure that no fool can
     * instanciate this class we declare a dummy private constructor
     * @param void
     * @access public
     */
    private function __construct(){}

    /**
     * set the PDO object to use with this PdoDatabase
     * @return void
     * @param object PDO $PdoObject
     * @access private
     */
    private function SetPdoObject(PDO $PdoObject)
    {
        $this->pdo_object = $PdoObject;
    }

    /**
     * return the PDO object reference used by this PdoDatabase
     * @return object PDO
     * @param void
     * @access public
     */
    public function GetPdoReference()
    {
        return $this->pdo_object;
    }

    /**
     * Turn debug mode on. It will stay on during all the script execution
     * @return void
     * @param void
     * @access public
     */
    public function TurnOnDebugMode()
    {
        $this->debug_mode = TRUE;
        $this->pdo_object->setAttribute(PDO::ATTR_ERRMODE, PDO_ERRMODE_WARNING);
    }

    /**
     * @return PdoDatabase Object. It ensure the existance of
     * only 1 object for each DSN
     * @param string $PdoDsn
     * @static
     * @access public
     * @throw PDOException
     */
    public static function GetPdoDatabase($PdoDsn)
    {
        /* if is the first database connection to open, init the arrayobject of databases */
        if ( self::$databases === NULL )
        {
            self::$databases = new ArrayObject();    
        }
        try
        {
            /* if a connection to the provided PdoDsn already exists, return it */
            if ( self::$databases->offsetExists($PdoDsn) )
            {
                return $databases->offsetGet($PdoDsn);
            }
            else
            {
                /* otherwise open the new connection, add it to databases and return it */
                $new_pdo = new PDO($PdoDsn);
                $new_db  = new PdoDatabase();
                $new_db->SetPdoObject($new_pdo);
                $new_db->SetAttribute(PDO::ATTR_ERRMODE, PDO_ERRMODE_EXCEPTION);
                self::$databases->offsetSet($PdoDsn, $new_db);
                return $new_db;
            }
        }
        catch ( PDOException $PdoException )
        {
            /* oops, something has gone wrong, just re-throw the PDOException */
            throw $PdoException;
        }            
    }

    /**
     * prepares and executes the provided statement $Statement
     * with the given statement values $StatementValues
     * @return void
     * @param string $Statement
     * @param array $StatementValues
     * @access public
     * @throw PDOException
     */
    public function ExecuteStatement($Statement, array $StatementValues)
    {
        /* check debug mode, if so, dump the arguments */
        if ( $this->debug_mode )
        {
            echo 'Executing statement ' . $Statement . "\n";
            var_dump($StatementValues);
        }
        /* if we have a previous statement, clear possible buffer data */
        if ( $this->pdo_statement instanceof PDOStatement )
        {
            $this->pdo_statement->closeCursor();
        }
        /* execute the query and save the result in internal statement */            
        $this->pdo_statement = $this->pdo_object->prepare($Statement);
        $this->pdo_statement->execute($StatementValues);
    }

    /**
     * executes again the last executed statement with the given 
     * statement values $StatementValues
     * @return void
     * @param array $StatementValues
     * @access public
     */
    public function ExecuteLastStatement(array $StatementValues)
    {
        /* if we dont have a previous valid statement, throw exception */
        if ( !($this->pdo_statement instanceof PDOStatement) )
        {
            throw BadFunctionCallException('You must execute a statement before calling ' . __METHOD__);
        }
        $this->pdo_statement->execute($StatementValues);
    }

    /**
     * return a row data from the last statement executed
     * @return void
     * @param enum $FetchMode
     * @access public
     */
    public function FetchStatementData($FetchMode = PDO::FETCH_LAZY)
    {
        if ( !$this->pdo_statement->setFetchMode($FetchMode) )
        {
            throw new InvalidArgumentException("it seems that  '{$FetchMode}' is not a valid FetchMode");
        }
        if ( $this->pdo_statement instanceof PDOStatement )
        {
            if ( ( $db_row = $this->pdo_statement->fetch() ) !== FALSE )
            {
                return $db_row;
            }
        }
        else
        {
            throw new BadFunctionCallException('a valid statement must exists to call ' . __METHOD__);
        }
        return NULL;
    }

}
?>   

[Casuis]

Bueno antes de implementar un sistema de 3 capas estaría bien que te informaras un poco antes de empezar picando codigo. Lo bueno de un sistema de 3 capas es la facilidad de modelage que tiene en la fase de diseño (gracias a los objetos). Bien referente a tu problema tienes dos opciones: 1ª facilona: conectar a la base de datos con persistencia (esto depende de tu SGBD). 2ª implementar un patrón Singleton te dejo una referencia en PHP5 (no funciona en PHP4) con ADODB:

Código PHP:

  
require_once(ADODB."/adodb-exceptions.inc.php");
require_once(ADODB."/adodb.inc.php");

class DataManager{
    
    static $db;
    
    static public function getInstance(){
        global $dsn;
        if(!isset(self::$db)){
            try {
                self::$db = new NewADOConnection($dsn);
            } catch (exception $e) {
                var_dump($e);
                adodb_backtrace($e->gettrace());
            }
        }
        return self::$db;
    }
}//final de la classe dataManager 
   

[HerSAn]

En la siguiente liga se trata el tema del singleton, trae un ejemplo sencillo de implementacion en php y otro mas complejo.
http://www.phppatterns.com/docs/desi...gleton_pattern