¿Alguna sugerencia para mejorar mi clase de conexión PDO?

Question

Hola chicos, soy bastante nuevo para el pdo, así que básicamente armé una clase de conexión simple usando información del libro introductorio que estaba leyendo pero ¿esta conexión es eficiente? Si alguien tiene alguna sugerencia informativa, realmente lo agradecería.

class PDOConnectionFactory{ 

    public $con = null; 
    // swich database? 
    public $dbType = "mysql"; 

    // connection parameters 

    public $host = "localhost"; 
    public $user = "user"; 
    public $senha = "password"; 
    public $db = "database"; 


    public $persistent = false; 

    // new PDOConnectionFactory(true) <--- persistent connection 
    // new PDOConnectionFactory()  <--- no persistent connection 
    public function PDOConnectionFactory($persistent=false){ 
     // it verifies the persistence of the connection 
     if($persistent != false){ $this->persistent = true; } 
    } 

    public function getConnection(){ 
      try{ 
       $this->con = new PDO($this->dbType.":host=".$this->host.";dbname=".$this->db, $this->user, $this->senha, 
       array(PDO::ATTR_PERSISTENT => $this->persistent)); 
       // carried through successfully, it returns connected 
       return $this->con; 
      // in case that an error occurs, it returns the error; 
      }catch (PDOException $ex){ echo "We are currently experiencing technical difficulties. ".$ex->getMessage(); } 

    } 

    // close connection 
    public function Close(){ 
     if($this->con != null) 
      $this->con = null; 
    } 

}

Answer 1

Al implementar una "fábrica" ​​por lo general es para que otras clases, métodos, etc. usarlo no tiene que conocer o preocuparse por las conexiones, los nombres de usuario, contraseñas, etc.

lo haría algo más como:

static class PDOConnectionFactory { 
    // database 
    private $dbType = "mysql"; 

    // connection parameters 
    private $host = "localhost"; 
    private $user = "user"; 
    private $senha = "password"; 
    private $db = "database"; 

    // new CreateNewConnection(true) <--- persistent connection 
    // new CreateNewConnection()  <--- no persistent connection 
    public function CreateNewConnection($persistent = false) { 
     try { 
      $con = new PDO($dbType . ":host=" . $host . ";dbname=" . $db, $user, $senha, array(PDO::ATTR_PERSISTENT => $persistent)); 
      // carried through successfully, it returns connected 
      return $con; 
     } 
     catch (PDOException $ex) { 
      // in case that an error occurs, it returns the error; 
      echo "We are currently experiencing technical difficulties. We have a bunch of monkies working really hard to fix the problem. Check back soon: " . $ex->getMessage(); 
     } 
    } 
} 

Luego utiliza la conexión devuelta por CreateNewConnection() de la forma que necesite.

No revisé si el código anterior se compila, podría haber algunos errores tipográficos/problemas, pero se entiende. Ahora necesita dar un paso más e implementar algo así como el patrón de repositorio :)

Answer 2

Usted puede encontrar este artículo útil, es por Erik Wurzer y que fue publicada en Nettuts, que es uno de mis otros sitios web favoritos (además de esto).
Why you Should be using PHP’s PDO for Database Access

Espero que esto ayude.

Answer 3

Mi sugerencia es que implemente un singleton para restringir la instanciación de PDO a un solo objeto. Se podría tener este aspecto:

class Database { 

    protected static $_instance; 
    protected $_connection; 
    protected $_dns = 'mysql:host=localhost;dbname=mydbname'; 
    protected $_username = 'myusername'; 
    protected $_password = 'mypassword'; 

    /** 
    * Singleton pattern implementation makes "new" unavailable 
    */ 
    protected function __construct() 
    { 
     $this->_connection = 
      new PDO($this->_dns, $this->_username, $this->_password); 
    } 

    public function getConnection() 
    { 
     return $this->_connection; 
    } 

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

    /** 
    * Singleton pattern implementation makes "clone" unavailable 
    */ 
    protected function __clone() 
    {} 
} 


$dbc = Database::getInstance()->getConnection();