Crear una clase para conectar a base de datos con PHP (II)

En un post anterior vimos como crear una clase muy sencilla la cual podía ser instanciada varias veces (patrón de diseño Singleton) sin que nos produjese la creación de varios objectos ni la creación de más conexiones concurrentes.

En en esta segunda parte vamos a ver cómo crear una clase, siguiendo también el patrón Singleton, que sea capaz de leer un fichero de configuración. En este fichero de configuración aparecerán los parámetros de conexión a nuestra base de datos, además de otros valores que puedan ser interesantes para nuestra aplicación. Con ello, haremos que nuestras clases sean reutilizables sin la necesidad de editarlas para adaptarlas al proyecto de turno.

Lo primero de todo veamos la estructura del fichero de configuración:

config.php

Código :

//Datos de configuración de la conexión a la base de datos

//Servidor
$host='localhost';

//Usuario
$user='user';

//Password
$password='test';

//Base de datos a utilizar
$db='testDB';

La estructura de este fichero es muy sencilla y se limita a un conjunto de variables que contiene la información necesaria para conectarse a la base de datos.

Ahora veamos la estructura de la clase Conf

Conf.class.php

Código :

Class Conf{
   private $_domain;
   private $_userdb;
   private $_passdb;
   private $_hostdb;
   private $_db;

   static $_instance;

   private function __construct(){
      require 'config.php';
      $this->_domain=$domain;
      $this->_userdb=$user;
      $this->_passdb=$password;
      $this->_hostdb=$host;
      $this->_db=$db;
   }

   private function __clone(){ }

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

   public function getUserDB(){
      $var=$this->_userdb;
      return $var;
   }

   public function getHostDB(){
      $var=$this->_hostdb;
      return $var;
   }

   public function getPassDB(){
      $var=$this->_passdb;
      return $var;
   }

   public function getDB(){
      $var=$this->_db;
      return $var;
   }

}

Como podemos observar en el código, lo único que hace esta clase es la inclusión del fichero de configuración y la importación de los valores de las variables a variables privadas de la clase. Mediante métodos podremos obtener los valores que necesitemos de la configuración sin peligro de sobreescribir ninguno de los valores, algo que si requiriésemos el fichero config.php en cualquier lugar, sería muy probable que nos pasase. Ahora debemos realizar algunas modificaciones sencillas dentro del fichero de nuestra clase de base de datos, Db.class.php:

Código :

/* Clase encargada de gestionar las conexiones a la base de datos */
Class Db{

   private $servidor;
   private $usuario;
   private $password;
   private $base_datos;
   private $link;
   private $stmt;
   private $array;

   static $_instance;

   /*La función construct es privada para evitar que el objeto pueda ser creado mediante new*/
   private function __construct(){
      $this->setConexion();
      $this->conectar();
   }

   /*Método para establecer los parámetros de la conexión*/
   private function setConexion(){
      $conf = Conf::getInstance();
      $this->servidor=$conf->getHostDB();
      $this->base_datos=$conf->getDB();
      $this->usuario=$conf->getUserDB();
      $this->password=$conf->getPassDB();
   }

   /*Evitamos el clonaje del objeto. Patrón Singleton*/
   private function __clone(){ }

   /*Función encargada de crear, si es necesario, el objeto. Esta es la función que debemos llamar desde fuera de la clase para instanciar el objeto, y así, poder utilizar sus métodos*/
   public static function getInstance(){
      if (!(self::$_instance instanceof self)){
         self::$_instance=new self();
      }
         return self::$_instance;
   }

   /*Realiza la conexión a la base de datos.*/
   private function conectar(){
      $this->link=mysql_connect($this->servidor, $this->usuario, $this->password);
      mysql_select_db($this->base_datos,$this->link);
      @mysql_query("SET NAMES 'utf8'");
   }

   /*Método para ejecutar una sentencia sql*/
   public function ejecutar($sql){
      $this->stmt=mysql_query($sql,$this->link);
      return $this->stmt;
   }

   /*Método para obtener una fila de resultados de la sentencia sql*/
   public function obtener_fila($stmt,$fila){
      if ($fila==0){
         $this->array=mysql_fetch_array($stmt);
      }else{
         mysql_data_seek($stmt,$fila);
         $this->array=mysql_fetch_array($stmt);
      }
      return $this->array;
   }

   //Devuelve el último id del insert introducido
   public function lastID(){
      return mysql_insert_id($this->link);
   }

}

Podemos ver que en la clase hay un nuevo método privado llamado setConexion() el cual se encarga de instanciar el objeto de la clase Conf y establecer el valor de las variables privadas que tenemos en la clase Db. Luego el proceso es el mismo que en la primera parte del tutorial.

Veamos cómo debería quedar el código de ejemplo para que nos funcione con la nueva clase:

Código :

/*Incluimos el fichero de la clase Db*/
require 'Db.class.php';
/*Incluimos el fichero de la clase Conf*/
require 'Conf.class.php';

/*Creamos la instancia del objeto. Ya estamos conectados*/
$bd=Db::getInstance();

/*Creamos una query sencilla*/
$sql='SELECT NOMBRE FROM CLIENTES';

/*Ejecutamos la query*/
$stmt=$bd->ejecutar($sql);

/*Realizamos un bucle para ir obteniendo los resultados*/
while ($x=$bd->obtener_fila($stmt,0)){
   echo $x['NOMBRE'].'<br />';
}

Como podemos observar, únicamente hemos añadido un require para la nueva clase creada. Nada más. En la siguiente parte del tutorial veremos cómo podemos hacer que esta clase se conecte a diferentes tipos de base de datos.

Un saludo

Temas relacionados:
Crear una clase para conectar a la base de datos

 

Tweet