Refactor de la conexión con clases

Clase 9 de 26 • Curso de PHP: Bases de Datos

Contenido del curso

Introducción

Creando nuestra base de datos

Conexión con una base de datos

Inserción de datos con MySQLi

Inserción de datos con PDO

Selección de datos

Completando nuestros controladores

Conexión a formularios en HTML

Próximos pasos

26
¿Quieres un Curso Profesional de PHP?
04:49 min

Tomar examen

Comentarios

Daniel G. Parrilla

student•

Reto 2 PDO:

Marvin Esteban Menchú Socop

student•

Yo lo resolví creando un archivo de configuración Config.php para que herede a la clase Conexion.php para el ejercicio en pdo y mysqli, y refactorice el código separando en pequeñas funciones.

Config.php

<?php
namespace App\Database\Config;
class Config 
{  
  protected $server = "localhost";
  protected $db     = "estudiantes"; 
  protected $user   = "root"; 
  protected $pass   = "root"; 
  protected $port   = 33061;
}

MySQLi Conexion.php

<?php

namespace App\Database\MySQLi;

use App\Database\Config\Config;

class Conexion extends Config
{
  private static $instancia;
  private $conexion;

  private function __construct()
  {
    $this->crear_conexion();
  }

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

  private function crear_conexion()
  {
    $mysqli = new \mysqli($this->server, $this->user, $this->pass, $this->db, $this->port);
    $this->validar_conexion($mysqli);
    $this->set_names($mysqli);
    $this->conexion = $mysqli;
  }
  
  private function set_names($mysqli)
  {
    $setnames = $mysqli->prepare("SET NAMES 'utf8'");
    $setnames->execute();
  }

  private function validar_conexion(&$mysqli)
  {
    if ($mysqli->connect_errno)
      die("Falló la conexión: {$mysqli->connect_error}");
  }

  public function get_database_conexion()
  {
    return $this->conexion;
  }
}

PDO Conexion.php

<?php

namespace App\Database\PDO;

use App\Database\Config\Config;

class Conexion extends Config
{
  private static $instancia;
  private $conexion;

  private function __construct()
  {
    $this->crear_conexion();
  }
  public static function getInstancia()
  {
    if (!self::$instancia instanceof self)
      self::$instancia = new self();
    return self::$instancia;
  }
  private function crear_conexion()
  {
    try {
      $con = new \PDO("mysql:host={$this->server};dbname=$this->db;port={$this->port}", $this->user, $this->pass);
      $this->set_names($con);
    } catch (\PDOException $e) {
      echo "Falló la conexión: " . $e->getMessage();
    }
  }

  private function set_names($con)
  {
    $setnames = $con->prepare("SET NAMES 'utf8'");
    $setnames->execute();
  }

  public function get_database_conexion()
  {
     return $this->conexion;
  }
}

Juan Pablo Campuzano Monsalve

student•

Implementaste a mi parecer correctamente la lógica.

Natalia Gutierrez

student•

El reto fue bastante exigente:

Tiene algunas modificaciones, ocup'e PDO, los datos para la conexion vienen desde un arreglo que cargo a partir de un archivo de configuracion.

Esta parte no estoy segura si es lo correcto, pas'e el arreglo desde getInstance, luego al constructor, hasta que finalmente llega al metodo que hace la conexion.

namespace App\Core\Database;

class Connection
{
    // Clase 9 : Refactor de la conexión con clases
    private static $instance;
    private $connection;

    private function __construct($config)
    {
        // El constructor previene que esta clase se pueda instanciar por fuera de la clase, la unica manera es con getInstance()

        $this->makeConection($config);
    }


    public static function getInstance($config)
    {
        // Usamos el patron singleton, para asegurarnos que solo exista una instancia de la conexion
        // self se refiere en todo momento a la misma clase Connection

        if (!self::$instance instanceof self)
            self::$instance = new self($config);

        return self::$instance;
    }


    public function get_database_instance()
    {
        return $this->connection;
    }


    private function makeConection($config)
    {
        try {
            $this->connection = new \PDO(
                $config['connection'] . ';dbname=' . $config['name'],
                $config['username'],
                $config['password'],
                $config['options']
            );
        } catch (\PDOException $e) {
            // echo 'No pude conectar:<br>'.$e;
            echo $e->getMessage();
        }
    }
}

oscar enrique ordoñez izquierdo

student•

El profesor menciona que la funcion make_connection no deberia hacer todo lo que esta escrito, y como seria lo ideal y correcto?

Diego Sigcho Alvarado

student•

mis apuntes de la clase:

Refactor de la conexión con clases

Para poder utilizar la conexión de la base mediante la autocarga de composer debemos crear una clase que contenga la conexión siguiendo la convención de psr-4 que nos dice que el nombre del archivo debe ser igual que el de la clase.

Para crear la clase de la conexión usamos el patrón de diseño Singleton, el cual como ya hemos visto en clases anteriores, garantiza que tan solo exista un objeto de su tipo (la conexión en este caso solo se puede instanciar 1 vez) y proporciona un único punto de acceso a él para cualquier otro código.

En resumen, usamos ese patrón debido a que queremos y necesitamos que la conexión con la base se haga 1 sola vez y no se esten generando multiples conexiones.

namespace Database\MySQLi;

class Connection {

    private static $instance;
    private $connection;

    private function __construct() {
        $this->make_connection();
    }

    public static function getInstance() {

        if(!self::$instance instanceof self)
            self::$instance = new self();

        return self::$instance;

    }

    public function get_database_instance() {
        return $this->connection;
    }

    private function make_connection() {

        $server = "localhost";
        $database = "finanzas_personales";
        $username = "retaxmaster";
        $password = "123";
        
        // Esta es al forma orientada a objetos
        $mysqli = new \mysqli($server, $username, $password, $database);
        
        // Comprobar conexión de manera orientada a objetos
        if ($mysqli->connect_errno)
            die("Falló la conexión: {$mysqli->connect_error}");
        
        // Esto nos ayuda a poder usar cualquier caracter en nuestras consultas
        $setnames = $mysqli->prepare("SET NAMES 'utf8'");
        $setnames->execute();

        $this->connection = $mysqli;
        
    }
    
}

Dentro de esta clase:

Creamos un método static get_instance() para obtener una instancia de la clase dentro de si misma. Preguntamos si la variable $instance no contiene una instancia de la misma clase entonces se la asignamos. Esta función estática es invocada directamente y al ejecutarse llama al método constructor en el momento que se crea la instancia.
El método constructor se define como private para asegurarnos de que no se pueda crear una instancia de la clase desde cualquier otra parte del código y dentro de este ejecutamos el método make_connection().
Dentro del método make_connection() se escribe el código para crear la conexión con la base de datos, y al finalizar en lugar de retornar la variable que almacena nuestra conexión se la asignamos a otra variable definida al inicio de la clase
Finalmente se crea un getter para obtener la variable resultante de todo el proceso antes mencionado que contiene la conexión con la BD

Nota: En el código de conexión debemos colocar una barra invertida “new \mysqli(” debido a que al definir el namespace como Database\MySQLi php asume que existe una clase mysqli dentro de este namespace, sin embargo esta clase ya esta definida en el namespace global por lo tanto se debe escapar con “\”

jose alejandro zapata

student•

donde esta el curso de buenas practicas? necesito ver para entender mejor esto

Jose Antonio Viveros Andrade

student•

Aquí esta el link en donde se ve el tema de Singleton

https://platzi.com/clases/1630-mejor-codigo/22212-patrones-de-diseno-singleton/

eamedranoc1

student•

Creo que fue mucha informacion para solo conectarnos a una bd y me perdí en muchos conceptos.

Juan Pablo Campuzano Monsalve

student•

Reto 2 PDO:

<?php

namespace Database\PDO;


class Connection
{
    protected $server;
    protected $database;
    protected $username;
    protected $password;
    protected $sgbd;
    // $driver = "mysql:host=$server;dbname=$database";



    public function __construct($server, $database, $username, $sgbd, $password = "")
    {
        $this->server = $server;
        $this->database = $database;
        $this->username = $username;
        $this->password = $password;
        $this->sgbd = $sgbd;
    }

    public function makeDriver()
    {
        return "$this->sgbd:host=$this->server;dbname=$this->database";
    }


    public function getConexion()
    {
        $driver = self::makeDriver();
        $connection = new \PDO($driver, $this->username, $this->password);

        $setnames = $connection->prepare("SET NAMES 'utf8'");
        $setnames->execute();

        var_dump($setnames);
    }
}


$connection = new Connection(
    "localhost",
    "finanzas_personales",
    "root",
    "mysql"
);


var_dump($connection);

Byron Marroquin

student•

Augusto Rivero

student•

Conexión con MySQLi usando el patrón Singleton:

<?php

class ConexionMySQLi {

private static $instancia;

private $conn;

private function __construct() {

$servername = "nombre_del_servidor";

$username = "nombre_de_usuario";

$password = "contraseña";

$database = "nombre_de_la_base_de_datos";

// Crear una conexión

$this->conn = new mysqli($servername, $username, $password, $database);

// Verificar la conexión

if ($this->conn->connect_error) {

die("Conexión fallida: " . $this->conn->connect_error);

}

public static function obtenerInstancia() {

if (!self::$instancia) {

self::$instancia = new self();

}

return self::$instancia;

}

public function obtenerConexion() {

return $this->conn;

}

// Obtener la instancia única de la conexión

$conexion = ConexionMySQLi::obtenerInstancia();

// Obtener la conexión

$conn = $conexion->obtenerConexion();

// No es necesario cerrar la conexión explícitamente, ya que el objeto se destruirá cuando termine el script

Rodrigo Angel Zucchini

student•

tendre que repasar POO, me pierdo cuando habla el profesor

Hallking Quesada Medina

student•

<?php

namespace database\MySQLi;

class Conecction
{
    private static object $intance;
    private object $connection;

    private $server = "localhost";
    private $database = "proyectoplatzi";
    private $username = "root";
    private $password = "";
     
    private function __construct(){
        $this->makeConnecciont();
    }

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

    public function getDatabaseInstance() : object {
        return $this->connection;
    }

    public function makeConnecciont(){
        try {

            //Coneccion con MySQLi procedural
            $connection = new PDO("mysql:host=$this->server;dbname=$this->database", $this->username, $this->password);
    
            //Esto nos ayuda a poder usar cualquier caracter en nuestras consultas
            $setnames = $mysqli->prepare("SET NAMES 'utf8'");
            $setnames->execute(); 

            return $$this->connection = $mysqli;

        } catch (\Throwable $e) {
            die ("Error al intentar la conecciones". $e->getCode());
        }

    }

}

Alejandro Ivan Mendieta

student•

Reto 1 *Separando funciones

 private function check_connection(Object $connect_result){
    if($connect_result->connect_errno)
      die("Hubo un problema: {$connect_result->connect_error}");
    }

    private function character_set(Object $connect_result){
       //Para en una consulta poder usar cualquier tipo de caracter
       $setnames = $connect_result->prepare("SET NAME 'utf8'");
       $setnames->execute();
       $this->connection = $connect_result;
    }

    private function make_connection(){
      $server = "localhost";
      $database = "curso_php_mysql";
      $user = "ivi";
      $password = "1234";

      $mysqliPoo = new \mysqli($server,$user,$password,$database);

      return $mysqliPoo;
     
    }

*Usandolas en el constructor

 private function __construct(){
      $connect = $this->make_connection();
      $this->check_connection($connect);
      $this->character_set($connect);
    }

Alejandro Ivan Mendieta

student•

Reto 2

<?php

namespace Database\PDO;

class Connection{
    private static $instance;

    private function __construct(){
        $conn = $this->make_connection();
        $this->name_set($conn);
    }

    private function make_connection() : Object{
        $server = "localhost";
        $database = "curso_php_mysql";
        $user = "ivi";
        $password = "minino";
        $connection = new \PDO("mysql:host=$server;dbname=$database",$user,$password);
        return $connection;
    }

    private function name_set(Object $connection){
        $setnames = $connection->prepare("SET NAME 'utf8'");
        $setnames->execute();
    }

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

<?php
namespace App\Database\Config;
class Config 
{  
  protected $server = "localhost";
  protected $db     = "estudiantes"; 
  protected $user   = "root"; 
  protected $pass   = "root"; 
  protected $port   = 33061;
}

<?php

namespace App\Database\MySQLi;

use App\Database\Config\Config;

class Conexion extends Config
{
  private static $instancia;
  private $conexion;

  private function __construct()
  {
    $this->crear_conexion();
  }

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

  private function crear_conexion()
  {
    $mysqli = new \mysqli($this->server, $this->user, $this->pass, $this->db, $this->port);
    $this->validar_conexion($mysqli);
    $this->set_names($mysqli);
    $this->conexion = $mysqli;
  }
  
  private function set_names($mysqli)
  {
    $setnames = $mysqli->prepare("SET NAMES 'utf8'");
    $setnames->execute();
  }

  private function validar_conexion(&$mysqli)
  {
    if ($mysqli->connect_errno)
      die("Falló la conexión: {$mysqli->connect_error}");
  }

  public function get_database_conexion()
  {
    return $this->conexion;
  }
}

<?php

namespace App\Database\PDO;

use App\Database\Config\Config;

class Conexion extends Config
{
  private static $instancia;
  private $conexion;

  private function __construct()
  {
    $this->crear_conexion();
  }
  public static function getInstancia()
  {
    if (!self::$instancia instanceof self)
      self::$instancia = new self();
    return self::$instancia;
  }
  private function crear_conexion()
  {
    try {
      $con = new \PDO("mysql:host={$this->server};dbname=$this->db;port={$this->port}", $this->user, $this->pass);
      $this->set_names($con);
    } catch (\PDOException $e) {
      echo "Falló la conexión: " . $e->getMessage();
    }
  }

  private function set_names($con)
  {
    $setnames = $con->prepare("SET NAMES 'utf8'");
    $setnames->execute();
  }

  public function get_database_conexion()
  {
     return $this->conexion;
  }
}

namespace App\Core\Database;

class Connection
{
    // Clase 9 : Refactor de la conexión con clases
    private static $instance;
    private $connection;

    private function __construct($config)
    {
        // El constructor previene que esta clase se pueda instanciar por fuera de la clase, la unica manera es con getInstance()

        $this->makeConection($config);
    }


    public static function getInstance($config)
    {
        // Usamos el patron singleton, para asegurarnos que solo exista una instancia de la conexion
        // self se refiere en todo momento a la misma clase Connection

        if (!self::$instance instanceof self)
            self::$instance = new self($config);

        return self::$instance;
    }


    public function get_database_instance()
    {
        return $this->connection;
    }


    private function makeConection($config)
    {
        try {
            $this->connection = new \PDO(
                $config['connection'] . ';dbname=' . $config['name'],
                $config['username'],
                $config['password'],
                $config['options']
            );
        } catch (\PDOException $e) {
            // echo 'No pude conectar:<br>'.$e;
            echo $e->getMessage();
        }
    }
}

namespace Database\MySQLi;

class Connection {

    private static $instance;
    private $connection;

    private function __construct() {
        $this->make_connection();
    }

    public static function getInstance() {

        if(!self::$instance instanceof self)
            self::$instance = new self();

        return self::$instance;

    }

    public function get_database_instance() {
        return $this->connection;
    }

    private function make_connection() {

        $server = "localhost";
        $database = "finanzas_personales";
        $username = "retaxmaster";
        $password = "123";
        
        // Esta es al forma orientada a objetos
        $mysqli = new \mysqli($server, $username, $password, $database);
        
        // Comprobar conexión de manera orientada a objetos
        if ($mysqli->connect_errno)
            die("Falló la conexión: {$mysqli->connect_error}");
        
        // Esto nos ayuda a poder usar cualquier caracter en nuestras consultas
        $setnames = $mysqli->prepare("SET NAMES 'utf8'");
        $setnames->execute();

        $this->connection = $mysqli;
        
    }
    
}

<?php

namespace Database\PDO;


class Connection
{
    protected $server;
    protected $database;
    protected $username;
    protected $password;
    protected $sgbd;
    // $driver = "mysql:host=$server;dbname=$database";



    public function __construct($server, $database, $username, $sgbd, $password = "")
    {
        $this->server = $server;
        $this->database = $database;
        $this->username = $username;
        $this->password = $password;
        $this->sgbd = $sgbd;
    }

    public function makeDriver()
    {
        return "$this->sgbd:host=$this->server;dbname=$this->database";
    }


    public function getConexion()
    {
        $driver = self::makeDriver();
        $connection = new \PDO($driver, $this->username, $this->password);

        $setnames = $connection->prepare("SET NAMES 'utf8'");
        $setnames->execute();

        var_dump($setnames);
    }
}


$connection = new Connection(
    "localhost",
    "finanzas_personales",
    "root",
    "mysql"
);


var_dump($connection); 

<?php

namespace database\MySQLi;

class Conecction
{
    private static object $intance;
    private object $connection;

    private $server = "localhost";
    private $database = "proyectoplatzi";
    private $username = "root";
    private $password = "";
     
    private function __construct(){
        $this->makeConnecciont();
    }

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

    public function getDatabaseInstance() : object {
        return $this->connection;
    }

    public function makeConnecciont(){
        try {

            //Coneccion con MySQLi procedural
            $connection = new PDO("mysql:host=$this->server;dbname=$this->database", $this->username, $this->password);
    
            //Esto nos ayuda a poder usar cualquier caracter en nuestras consultas
            $setnames = $mysqli->prepare("SET NAMES 'utf8'");
            $setnames->execute(); 

            return $$this->connection = $mysqli;

        } catch (\Throwable $e) {
            die ("Error al intentar la conecciones". $e->getCode());
        }

    }

}

 private function check_connection(Object $connect_result){
    if($connect_result->connect_errno)
      die("Hubo un problema: {$connect_result->connect_error}");
    }

    private function character_set(Object $connect_result){
       //Para en una consulta poder usar cualquier tipo de caracter
       $setnames = $connect_result->prepare("SET NAME 'utf8'");
       $setnames->execute();
       $this->connection = $connect_result;
    }

    private function make_connection(){
      $server = "localhost";
      $database = "curso_php_mysql";
      $user = "ivi";
      $password = "1234";

      $mysqliPoo = new \mysqli($server,$user,$password,$database);

      return $mysqliPoo;
     
    }

<?php

namespace Database\PDO;

class Connection{
    private static $instance;

    private function __construct(){
        $conn = $this->make_connection();
        $this->name_set($conn);
    }

    private function make_connection() : Object{
        $server = "localhost";
        $database = "curso_php_mysql";
        $user = "ivi";
        $password = "minino";
        $connection = new \PDO("mysql:host=$server;dbname=$database",$user,$password);
        return $connection;
    }

    private function name_set(Object $connection){
        $setnames = $connection->prepare("SET NAME 'utf8'");
        $setnames->execute();
    }

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

Refactor de la conexión con clases

Introducción

¿Cómo conectarse a una base de datos con PHP?

Programa un sistema de control de gastos

Diagramando la base de datos

Creando nuestra base de datos

Instalación de phpMyAdmin

Creando tablas con phpMyAdmin

Conexión con una base de datos

Instalación de drivers para PDO en Linux

Conexión con MySQLi

Conexión con PDO