Refactor de la conexión con clases

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

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

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

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

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