web-dev-qa-db-de.com

Verwendung von PDO in Klassen

Ich habe einige Klassen, die einige MySQL-Abfragen und vorbereitete Anweisungen ausführen. Ich verliere jedoch nicht, wie ich mein PDO-Objekt in diese Klassen einbinden kann. Zum Beispiel möchte ich so etwas machen:

<?php

$dbh = new PDO(...);

class Foo extends PDO {
    public $dbh;

    public function bar() {
        $this->dbh->prepare('SELECT * FROM table');
        $this->dbh->execute();

    }
}


?>

Leider funktioniert es nicht. Kann jemand einen eleganten Weg vorschlagen, dies zu tun? Vielen Dank für Ihre Zeit. Es tut mir leid, ich bin neu in diesem Bereich. Bitte hinterlassen Sie Kommentare, wenn Sie sich nicht klar sind und ich werde mein Bestes geben, um zu antworten!

26
axsuul

Sie können Ihre Verbindung zur Datenbank in einer Klasse instanziieren, die das Singleton-Muster implementiert. Die Verbindung wird einmal hergestellt und diese Klasse ist für alle Ihre anderen Objekte/Skripts leicht zugänglich.

ich benutze eine Klasse namens "Core" im folgenden Beispiel.

class Core
{
    public $dbh; // handle of the db connexion
    private static $instance;

    private function __construct()
    {
        // building data source name from config
        $dsn = 'pgsql:Host=' . Config::read('db.Host') .
               ';dbname='    . Config::read('db.basename') .
               ';port='      . Config::read('db.port') .
               ';connect_timeout=15';
        // getting DB user from config                
        $user = Config::read('db.user');
        // getting DB password from config                
        $password = Config::read('db.password');

        $this->dbh = new PDO($dsn, $user, $password);
    }

    public static function getInstance()
    {
        if (!isset(self::$instance))
        {
            $object = __CLASS__;
            self::$instance = new $object;
        }
        return self::$instance;
    }

    // others global functions
}

diese Klasse übernimmt Parameter von einer statischen Klasse namens "Config", in der Sie Ihre Konfiguration speichern können:

<?php
class Config
{
    static $confArray;

    public static function read($name)
    {
        return self::$confArray[$name];
    }

    public static function write($name, $value)
    {
        self::$confArray[$name] = $value;
    }

}

// db
Config::write('db.Host', '127.0.0.1');
Config::write('db.port', '5432');
Config::write('db.basename', 'mydb');
Config::write('db.user', 'myuser');
Config::write('db.password', 'mypassword');

in all Ihren Skripten/Objekten müssen Sie nur die Instanz von Core abrufen und dann die Datenbank abfragen

$sql = "select login, email from users where id = :id";

try {
    $core = Core::getInstance();
    $stmt = $core->dbh->prepare($sql);
    $stmt->bindParam(':id', $this->id, PDO::PARAM_INT);

    if ($stmt->execute()) {
        $o = $stmt->fetch(PDO::FETCH_OBJ);
        // blablabla....

Weitere Informationen zu Singleton finden Sie unter PHP doc http://php.net/manual/de/language.oop5.patterns.php

61

Hier ist ein größtenteils funktionierendes Cut & Paste-Beispiel von Guillaume Boschini s Antwort oben.

Eine bestückte DB-Tabelle (MySQL):

CREATE TABLE `useraddress` (                                                                                                                                        
  `addressid` int(10) unsigned NOT NULL AUTO_INCREMENT,                                                                                                                             
  `userid` int(10) unsigned NOT NULL,                                                                                                                                               
  `addresstitle` char(100) NOT NULL,                                                                                                                        
  `streetaddressa` char(100) NOT NULL,
  `streetaddressb` char(100) DEFAULT NULL,
  `unit` char(50) DEFAULT NULL,
  `city` char(50) NOT NULL,
  `state` char(2) NOT NULL,
  `Zip` int(5) NOT NULL,
  `zipplusfour` int(4) DEFAULT NULL,
  PRIMARY KEY (`addressid`),
  KEY `userid` (`userid`),
  CONSTRAINT `useraddress_fk_1` FOREIGN KEY (`userid`) REFERENCES `user` (`userid`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

In /DBLibrary/pdocore.php:

<?php

    Config::write('db.Host', 'localhost');
    Config::write('db.port', '3306');
    Config::write('db.basename', 'DBName');
    Config::write('db.user', 'DBUser');
    Config::write('db.password', 'DBPassword');

    class Config {

        static $confArray;

        public static function read($name) {
            return self::$confArray[$name];
        }

        public static function write($name, $value) {
            self::$confArray[$name] = $value;
        }

    }

    class Core {
        public $dbh; // handle of the db connection
        private static $instance;

        private function __construct()  {

            // building data source name from config
            $dsn = 'mysql:Host=' . Config::read('db.Host') . ';dbname=' . Config::read('db.basename') . ';port=' . Config::read('db.port') .';connect_timeout=15';

            // getting DB user from config
            $user = Config::read('db.user');

            // getting DB password from config
            $password = Config::read('db.password');

            $this->dbh = new PDO($dsn, $user, $password);
            $this->dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

        }

        public static function getInstance() {
            if (!isset(self::$instance)) {
                $object = __CLASS__;
                self::$instance = new $object;
            }
            return self::$instance;
        }

        // others global functions
    }
?>

In /objectsLibrary/SYS_UserAddress.php:

<?php

    define('k_uaddress_addressid','addressid');
    define('k_uaddress_userid','userid');
    define('k_uaddress_addresstitle','addresstitle');
    define('k_uaddress_addressa','streetaddressa');
    define('k_uaddress_addressb','streetaddressb');
    define('k_uaddress_unit','unit');
    define('k_uaddress_city','city');
    define('k_uaddress_state','state');
    define('k_uaddress_Zip','Zip');
    define('k_uaddress_zipplusfour','zipplusfour');

    require_once '../DBLibrary/pdocore.php';

    class SYS_UserAddress {

        public $addressid;
        public $userid;
        public $addresstitle;
        public $addressa;
        public $addressb;
        public $unit;
        public $city;
        public $state;
        public $Zip;
        public $zipplusfour;

        public function SYS_UserAddressByAddressId($_addressid) {

            $returnValue=FALSE;

            $query='select * from useraddress where ' . k_uaddress_addressid . '=:addressid';

            try {
                $pdoCore = Core::getInstance();
                $pdoObject = $pdoCore->dbh->prepare($query);

                $queryArray = array(':addressid'=>$_addressid);

                if ($pdoObject->execute($queryArray)) {

                    $pdoObject->setFetchMode(PDO::FETCH_ASSOC);;

                    while ($addressrow = $pdoObject->fetch()) {

                        $this->addressid=$addressrow[k_uaddress_addressid];
                        $this->userid=$addressrow[k_uaddress_userid];
                        $this->addresstitle=$addressrow[k_uaddress_addresstitle];
                        $this->addressa=$addressrow[k_uaddress_addressa];
                        $this->addressb=$addressrow[k_uaddress_addressb];
                        $this->unit=$addressrow[k_uaddress_unit];
                        $this->city=$addressrow[k_uaddress_city];
                        $this->Zip=$addressrow[k_uaddress_Zip];
                        $this->zipplusfour=$addressrow[k_uaddress_zipplusfour];

                    }
                    $returnValue=TRUE;
                }
            }
            catch(PDOException $pe) {
                trigger_error('Could not connect to MySQL database. ' . $pe->getMessage() , E_USER_ERROR);
            }

            return $returnValue;

        }
    }

    $test=1;
    $testAddressId=2;

    if($test>0) {

        $testAddress = new SYS_UserAddress();

        $testAddress->SYS_UserAddressByAddressId($testAddressId);

        echo '<pre>';
        echo print_r($testAddress);
        echo '</pre>';

    }

?>

Der Beitrag oben hat mir wirklich geholfen. Dieser Beitrag, den ich jetzt mache, hätte mich dahin gebracht, wo ich schneller sein wollte. Das ist alles. Wenn etwas nicht stimmt, bin ich für Sie da.

6
BradChesney79

$dbh fällt nicht in den Geltungsbereich von Foo.

class Foo /*extends PDO*/
{
    public $dbh;

    public function __construct()
    {
        $dbh = new PDO(/*...*/);
    }

    public function bar()
    {
        $this->dbh->prepare('SELECT * FROM table');
        return $this->dbh->execute();
    }
}

Außerdem muss Foo nicht PDO erweitert werden.

3
Alix Axel

ich habe eine bessere Lösung gefunden: Wenn Sie eine PDO-Verbindung außerhalb Ihrer Klasse haben und diese Verbindung nicht innerhalb der Klasse verwenden können, senden Sie dieses PDO-Objekt als Parameter an den Konstruktor 

/// das ist meine PDO-Verbindung

$pdo_object = new PDO('mysql:Host=localhost;dbname=blabla','user','pw');

/// im die Instanz dieser Klasse als obj erstellt 

$dataObj=new class_name($pdo_obj);

///// innerhalb der Klasse ::: vereinfacht

class class_name{

private $handler;//// this is what i use for PDO connection inside the class

public function __construct($connection_name){

    if(!empty($connection_name)){
        $this->handler=$connection_name;
  ///its a great thing that holy php doesnt care much about variant types. any variant is able to carry any object (like PDO obj)
    }else{
        throw new Exception("cant connect bla bla...");
    }



}/////contruct fx

////how i use that pdo connection which is implamented to a local var called handler  with any sql query is : 

$dataSet= $this->handler->query("SELECT * FROM users WHERE ....");



}////endof class
0
ulas korpe