Cómo evitar la apertura de conexiones múltiples a la base de datos con OOP PHP

Question

He sido programador de procedimientos por más de 4 años y es hora de comenzar a buscar OOP. Dicho esto, supongamos que necesito llamar a dos métodos en mi clase. Cada método requiere una conexión con el DB, por lo que son dos viajes al DB, que también abre conexiones múltiples. ¿Se puede evitar esto teniendo algún tipo de código en la capa de la aplicación (constructor?) O ¿se debe configurar un grupo de conexiones en el lado de la base de datos? Y solo por diversión, no estoy usando mysql; Estoy usando mongodb con codeigniter.

Esto es lo que tengo hasta ahora, ¿no estoy seguro si es ideal para usar?

Aquí es donde puedo configurar mi información DB:

database_conn.php archivo de modelo

class Database_Conn extends Model { 

    function _connect() { 
     $m = new Mongo("localhost:27017", array("persist"=>"x")); 
     $db = $m->selectDB("foo"); 
     return $db; 
    }  
}  

muestra

class Home_model extends Model { 

    public function __construct() { 
     // Establish connection to "profiles" table 
     $this->db_conn = Database_Conn::_connect()->selectCollection("profiles"); 
    } 

    function getMyProfile($username) { 
     $data = $this->db_conn->findOne(array("username" => $username)); 
     return $data; 
    } 

    function getAll() { 
     $data = $this->db_conn->find(); 
     return $data; 
    } 
} 

Answer 1

se debe utilizar singleton pattern

EDITAR: De la manera en que lo hizo, es posible llamar a _connect varias veces, lo que significa reconectar.

la implementación singleton generalmente significa que debe crear el constructor privado/protegido y definir un método getInstance que cree la conexión en la primera llamada y devuelva la conexión creada en llamadas posteriores.

esto es lo que haría:

class Database_Conn extends Model { 

    static protected $_instance; 

    protected $db = null; 

    final protected function __construct() { 
     $m = new Mongo("localhost:27017", array("persist"=>"x")); 
     $this->db = $m->selectDB("foo"); 
    } 

    static public function getInstance() { 
     if (!(self::$_instance instanceof self)) { 
      self::$_instance = new self(); 
     } 
     return self::$_instance; 
    } 

    public function getConnection() { 
     return $this->db; 
    } 

    final protected function __clone() { } 
} 

y luego usar Database_Conn::getInstance()->getConnection() para obtener el objeto de conexión.

Answer 2

Debe buscar en una clase de administrador para sus conexiones db. Entonces puede tener un lugar central desde donde solicitar conexiones. Si ya hay una conexión abierta, el administrador puede devolverla en lugar de devolver una nueva conexión.

Este sería un enfoque. Hay muchos ejemplos de cómo implementar algo como esto. Ya hay algunos para mysql y mssql. Pero seguramente podrías extender tu db.

Answer 3

Utilice una capa de base de datos. Dibi es una gran biblioteca en este caso. http://dibiphp.com