PDO in static class

Overzicht Reageren

Sponsored by: Vacatures door Monsterboard

Nicoow Unknown

Nicoow Unknown

17/11/2009 21:47:00
Quote Anchor link
Hallo,

Ik zit even met een klein probleempje, en google helpt mij niet echt.
Ik heb een class met alleen maar static functies.
Maar hoe kan k nou een PDO connectie tot stand brengen, en die gewoon blijven gebruiken, in iedere functie.

dus ik wil dit:
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
class PdoWithStatic
{
      private $dbh;
      
     //Dit moet dus ergens
     $dbh = Config::PDO();
     //Cofig::PDO levert een nieuwe PDO instance op
    
    public static function getById($id)
    {

        $dbh->query("SELECT * FROM niks);
    }
}

?>

Ik hoop dat het zo duidelijk is.
Gewijzigd op 01/01/1970 01:00:00 door Nicoow Unknown
 
PHP hulp

PHP hulp

21/06/2021 15:09:43
 
Jelmer -

Jelmer -

18/11/2009 19:37:00
Quote Anchor link
Kan niet. Statische classes worden niet geïnitialiseerd, dus er is geen __construct-achtige die je kan aanroepen om de class klaar te maken. Althans, niet vanuit PHP zelf.

(Denk er maar eens over na. Wanneer zou een statische class geïnitialiseerd moeten worden?)

Je kan natuurlijk wel zelf een public static initialize() method toevoegen, en die aanroepen direct na je class definitie, maar je hebt in theorie geen 100% zekerheid dat __initialize maar 1 keer wordt aangeroepen (in praktijk eigenlijk altijd wel)
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?php
class PdoWithStatic {
   static private $dbh;

   static public __initialize()
   {

      self::$dbh = Config::PDO();
   }


   static public function getById($id)
   {

      self::$dbh->query("SELECT * FROM niks");
   }
}


PdoWithStatic::__initialize();
?>


Deze problemen heb je niet (en de zekerheid wel) wanneer je geen static classes gebruikt.

*disclaimer: ik heb het niet zo op static en singleton.
 
Nicoow Unknown

Nicoow Unknown

18/11/2009 21:34:00
Quote Anchor link
@Jelmer,
Ik heb het opzich ook niet zo op static, vind het toch wel beetje zweverig,,
Ik gebruik het eigenlijk alleen voor dingen als MathHelper class o.i.d.
Ik was het eigenlijk een beetje zat om constant in iedere controller opnieuw de database connectie te moeten maken.
Maar heb dat nu opgelost door een algemene controller class, die een (jawel) static functie aanroept die een PDO instance terug geeft.

Dus ik heb eigenlijk nu dit:
//Config.php
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
class Config
{
    private static $db_host = "localhost";
    private static $db_database = "videos";
    private static $db_username = "root";
    private static $db_password = "";
    
    public static function PDO()
    {

        $pdo = new PDO('mysql:host=' . self::$db_host . ';
                                dbname='
. self::$db_database,
                                self::$db_username,
                                self::$db_password,
                                array(PDO::ATTR_PERSISTENT => true));
        $pdo->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
        
        return $pdo;
    }
}

?>


Mijn Controller Class
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
<?php
class Controller
{    
    protected function getPDOInstance()
    {

        return Config::PDO();
    }
}

?>


En dan een echt controller class
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?php
class Video extends Controller
{
    public $_id;
    private $_title;
    private $_image;
    private $_min;
    private $_sec;
    private $_tags = array();
    
    protected $sql;
    private $tagController;
    
    public function Video($id = null, $name = null, $image = null, $min = 0, $sec = 0)
    {

        $this->_id = $id;
        $this->_title = $name;
        $this->_image = $image;
        $this->_min = $min;
        $this->_sec = $sec;
        
        $this->sql = parent::getPDOInstance();        
    }
}

?>


Is dit een goede / acceptabele oplossing,
Of krijg ik nu een tik op mijn vingers?
Gewijzigd op 01/01/1970 01:00:00 door Nicoow Unknown
 
Boris Mattijssen

Boris Mattijssen

18/11/2009 21:42:00
Quote Anchor link
Mag ik misschien vragen wat static precies doet?
Ik heb het ooit eens gehoord, maar snapte het niet echt..
 
Nicoow Unknown

Nicoow Unknown

18/11/2009 21:54:00
Quote Anchor link
een static functie of variable is een fuctie of variable, in een klasse, die niet vooraf ge-instantieerd hoeft te zijn.
Dit kan dus bijvoorbeeld heel handig zijn als je een class aanmaakt die wiskundige vraag stukken oplost.
Even een klein voorbeeld
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<?php
class wisNormal
{
    public function telOp($a, $b)
    {

        return $a + $b;
    }


    //Yeej, Puberale humor
    public function trekAf($a, $b)
    {

        return $a - $b;
    }
}


class wisStatic
{
    public static function telOp($a, $b)
    {

        return $a + $b;
    }


    //Yeej, Puberale humor
    public static function trekAf($a, $b)
    {

        return $a - $b;
    }
}

?>


Dit lijkt opzich niet heel verschillend, maar de aanroep is wel heel verschillend.
Als je het "normaal" doet, dan is je script ongeveer zo:
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
<?php
$a
= 5;
$b = 3;
$calculator = new wisNormal();
$c = $calculator->telOp($a, $b);
$d = $calculator->trekAf($a, $b);
?>

Hier moet je dus eerst een instantie aanmaken van een class, en daarna kan je pas de functies aanroepen.
bij een static functie gaat het zo:
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
<?php
$a
= 5;
$b = 3;
$c = wisStatic::telOp($a, $b);
$d = wisStatic::trekAf($a, $b);
?>


Hier zie je dus dat je niet eerst een instantie hoeft aan te maken.
Dit heeft als grote nadeel, dat je niks in een klasse variable kan opslaan, omdat die namelijk daarna weer verdwijnt.

Dus statische functies zijn er eigenlijk alleen voor simpele functies, voor luie programmeurs (en dat zijn we toch allemaal??), en andere kleine dingen, die je snel wilt kunnen aanroepen, zonder dat er een groot geheim achter zit.

Ik hoop dat het een beetje duidelijk is zo.
 
Boris Mattijssen

Boris Mattijssen

18/11/2009 21:58:00
Quote Anchor link
Hey Nico,

Bedankt voor je uitleg. Helemaal duidelijk.
Eén ding begrijp ik niet.
Je kan toch ook gewoon wisNormal::telOp($a,$b) doen?
 
Nicoow Unknown

Nicoow Unknown

18/11/2009 22:06:00
Quote Anchor link
(helaas) Kan dit soort ongein in PHP, maar dit is niet de bedoeling!!
Als je in wat striktere talen gaat programmeren, dan zal dit je niet meer lukken.
 
Boris Mattijssen

Boris Mattijssen

18/11/2009 22:18:00
Quote Anchor link
Oke, duidelijk.
Dankjewel voor je uitleg (:

ps: ff mbt je script.
Ik zelf vind "sql" een beetje een vreemde naam in dit geval:
$this->sql = parent::getPDOInstance();
noem het dan pdo ofzo (:
Gewijzigd op 01/01/1970 01:00:00 door Boris Mattijssen
 
Stien ss

stien ss

18/11/2009 22:37:00
Quote Anchor link
@nico:

ik ben geen voorstander van hoe je dit aanpakt, gebruik dan depedency injection ofzo, maar als je het zo wil doen, zou ik er dit van maken:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?php
class Config
{
    private static $db_host = "localhost";
    private static $db_database = "videos";
    private static $db_username = "root";
    private static $db_password = "";
    protected static $_pdo = null;

    public static function PDO()
    {

        if ( self::$_pdo === null ) {
              $pdo = new PDO('mysql:host=' . self::$db_host . ';
                                        dbname='
. self::$db_database,
                                        self::$db_username,
                                        self::$db_password,
                                        array(PDO::ATTR_PERSISTENT => true));
               $pdo->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
        
              self::$_pdo = $pdo;
        }

        return self::$_pdo;
    }
}

?>
 
Nicoow Unknown

Nicoow Unknown

18/11/2009 22:53:00
Quote Anchor link
Ziet er interessant uit, dat DI
Dependency Injection
Alleen zie ik dan niet helemaal in waarom mijn Config anders moet,
Ik kan begrijpen dat jij het zo zou doen, maar dat maakt voor de rest niks uit,
Je krijgt dan gewoon zoiets.
$database = Config::PDO();
$video = new Video();
$video->setDatabase = $database;

Ik zie nu trouwens na een test dat hij hem maar 1 keer aanmaakt, bedankt voor jou methode, ik ga hem van je stelen en misbruiken =D
 



Overzicht Reageren

 
 

Om de gebruiksvriendelijkheid van onze website en diensten te optimaliseren maken wij gebruik van cookies. Deze cookies gebruiken wij voor functionaliteiten, analytische gegevens en marketing doeleinden. U vindt meer informatie in onze privacy statement.