Irgendwelche Vorschläge, um meine PDO-Verbindungsklasse zu verbessern?

Question

Hey Leute, ich bin ziemlich neu bei PDO, also habe ich im Grunde nur einen einfachen Verbindungskurs zusammengestellt, der Informationen aus dem Einführungsbuch verwendet, das ich gelesen habe, aber ist diese Verbindung effizient? Wenn jemand irgendwelche informativen Vorschläge hat, würde ich es sehr schätzen.

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

Wenn eine „Fabrik“ zur Durchführung in der Regel ist es so, dass andere Klassen, Methoden, etc. es verwenden, haben nicht zu wissen oder über die Verbindungen, Benutzernamen, Passwörter Pflege usw.

ich es tun würde etwas mehr wie:

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

Dann nutzen Sie die Verbindung wieder von CreateNewConnection() in welcher Weise auch immer Sie brauchen.

Ich habe nicht überprüft, ob der obige Code kompiliert, es könnte ein paar Tippfehler/Probleme geben, aber Sie bekommen die Idee. Jetzt müssen Sie einen Schritt weiter gehen und etwas wie das Repository-Muster implementieren :)

Answer 2

Sie können diesen Artikel nützlich finden, es ist von Erik Wurzer und es wurde in Nettuts geschrieben, die eine meiner anderen Lieblings-Websites ist (außer dieser).
Why you Should be using PHP’s PDO for Database Access

Hoffe, das hilft.

Answer 3

Mein Vorschlag ist, dass Sie ein Singleton implementieren, um die Instanziierung von PDO auf ein einzelnes Objekt zu beschränken. Es könnte wie folgt aussehen:

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