php - transacciones - ¿Mejores prácticas para una clase de PDO?

sqlite pdo php

Question

Quiero crear una clase PDO para manejar las conexiones de la base de datos.

Esto es lo que tengo:

require(''php/packages/store/store_db_settings.php'');

class store_pdo
{
    private $DBH; // Data Base Handler

    function __construct() 
    {
        $DBH = new PDO(DB_DSN,DB_USER,DB_PASSWORD);
    }

    public function getHandler()
    {
        return $DBH;
    }

}

Creo que esto parece estar bien, sin embargo, estoy acostumbrado a usar cosas como mysql_query y no estoy seguro de qué problemas podría enfrentar en el futuro. Así que pensé que la experiencia aquí podría ofrecer una guía.

Es lo que tengo suficiente? ¿Debo hacer mi clase Singleton o usar funciones estáticas? ¿Hay una mejor práctica?

No quiero ir con esto, luego tengo varias otras clases usándolo, descubro que debería haberlo escrito de manera diferente.

PD: Acabo de darme cuenta de que la etiqueta de best-practices ya no está permitida ... ¿significa eso que ahora también se desalientan preguntas como esta?

Answer 1

extender PDO para tener un mejor control sobre él.

class Database Extends PDO
{
    static $instance; //singleton
    static function Singleton($params = false)
    {
       if(!isset(self::$instance))
       {
           self::$instance = new self($params); //tomh
           self::$instance->init();
       }
       return self::$instance;
    }
    private function __construct(){}; //not allowed with singleton.

    public function init($params) //Override PDO::__construct()
    {
       parent::__construct($params);
    }

    public function query($query)
    {
        //Catch,Custom Query Object maybe. W.e
        return parent::query($modified_query);
    }
}

Uso:

$Database = Database::Singleton(array(''user'' => ''root'')); //....
$Database->query(''Helooooooo Sexy MySql, Send me my Shizzle'');

Answer 2

Singleton te morderá en el culo la primera vez que necesites conectarte a dos bases de datos diferentes, ya sea para la replicación o para dos bases de datos diferentes. Entonces tu código está tan desordenado.

En su lugar, utilice una única función estática para cargar fácilmente la última configuración utilizada:

class MyPDODB extends PDO
{
    // Prevent unconfigured PDO instances!
    private function __construct($config)
    {
        $dsn = sprintf(''mysql:dbname=%s;host=%s;port=%d;'', $config[''database''], $config[''hostname''], $config[''port'']);
        parent::__construct($dsn, $config[''username''], $config[''password'']);        
    }

    public static function loadDB($config_in = null)
    {
        static $last_config = null;

        if (!is_null($config_in))
        {
            self::validateConfig($config_in);
            $config = $config_in;
            if (!isset($config[''isTemp'']) || $config[''isTemp''] !== true)
            {
                $last_config = $config;
            }
        }
        else
        {
            if (!is_null($last_config)) { $config = $last_config; }
            else throw new MyDBException("No config provided'');
        }

        return new MyPDODB($config);
    }
}

En cualquier función, solo haces:

$db = MyPDODB::loadDB();
$db->prepare($sql);
$db->execute();

Fácil, ¿eh?

Answer 3

Un Singleton y una clase estática funcionarían bien. No puedo pensar en una situación en la que marcaría la diferencia.

Asegúrese de que si existe la posibilidad de utilizar conexiones múltiples, haga que su multiconexión de clase Singleton / Static sea capaz desde el inicio (utilizando una matriz de conexiones, o propiedades de objeto ...)

Se podría argumentar, sin embargo, que todos estos métodos crean un "Objeto de Dios" de algún tipo, no son más que un mundo glorificado, y van en contra de los principios de la POO real. Hice una pregunta sobre esto una vez que produjo muchos comentarios excelentes.