Refactor de la conexión con clases

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

Cursos Empresas Blog Live Conf Eventos Precios

0:0016:50

Refactor de la conexión con clases

Curso de PHP: Bases de Datos

Clase 9 de 26

Clase 9 / 26

Comentarios (13)13 comentarios

Daniel G. Parrilla

Hace 4 años

Marvin Esteban Menchú Socop

Hace 4 años

Juan Pablo Campuzano Monsalve

Hace 2 años

Natalia Gutierrez

Hace 4 años

oscar enrique ordoñez izquierdo

Hace 2 años

Diego Sigcho Alvarado

Hace 3 años

jose alejandro zapata

Hace 3 años

Jose Antonio Viveros Andrade

Hace 3 años

eamedranoc1

Hace 2 años

Juan Pablo Campuzano Monsalve

Hace 2 años

Byron Marroquin

Hace 3 años

Augusto Rivero

Hace 3 años

Rodrigo Angel Zucchini

Hace 4 años

Hallking Quesada Medina

Hace 3 años

Alejandro Ivan Mendieta

Hace 4 años

Alejandro Ivan Mendieta

Hace 4 años

Reto 2 PDO:

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;
  }
}

Implementaste a mi parecer correctamente la lógica.

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();
        }
    }
}

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

mis apuntes de la clase:

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 “\”

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

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

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

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

<?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);

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

tendre que repasar POO, me pierdo cuando habla el profesor

<?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());
        }

    }

}

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);
    }

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;
    }
}

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

Refactor de la conexión con clases

Inserción de datos con MySQLi

Creación de controladores para la aplicación

Creación de ENUMS para la aplicación

Consultas con MySQLi

Evitando SQL Injection con bindParam

Inserción de datos con PDO

Consultas con PDO

Evitando SQL Injection con consultas preparadas en PDO

Ligando parámetros con bindParams

Ligando parámetros con bindValue

Selección de datos

Consultando datos con FetchAll

Consultando datos con Fetch

Vinculando columnas con bindColumn

Completando nuestros controladores

Transacciones: cómo revertir una consulta SQL con PHP

Reto: CRUD con PHP y SQL

Conexión a formularios en HTML

Creación de nuestro router

Programando los métodos del router

Mostrando nuestros datos en HTML

Próximos pasos

¿Quieres un Curso Profesional de PHP?

Refactor de la conexión con clases