OOP Laie Brauche mal ein Anstoss

Also vorab muß ich sagen, ich habe von OOP sogut wie keine Ahnung ich kann Funktionen erstellen und unstrukturierten Code massig erzeugen. Bekomme SQL Verbindungen hin und beschäftige mich unregelmäßig seit 4-5 Jahren mit PHP. Es kann auch sein das die Frage jetzt eher in ein anderes Forum passt.

Also ich habe für mich mal ein kleinen Shop gebastelt gehabt. Jetzt stellt sich mir die Frage wie könnte ich die Produktauflistung in OOP umsetzen.

Jetzt ist es so, es gibt eine Datei mit einer Funktion wo die DB ausgelesen wird die Daten in einer Schleife durchgegangen und in ein Array gespeichert wird und am Ende werden diese ausgegeben. Dazu habe ich dann noch eine Datei mit ähnlicher Funktion für die Suche, für die Auflistung nach Hersteller und fürs Archiv. Das macht zusammen 4 Funktionen in vier Dateien. Und bevor ich es noch vergesse, es gibt noch eine fünfte für die Detailanzeige, ist jetzt aber nicht wichtig.

Nun sind die Bedingungen für alle vier Funktionen unterschiedlich. Dennoch ist der Output bei allen fast ähnlich. Bei dreien gibt es eine dazu noch eine Blätterfunktion.

Hier mal ein Versuch von mir:

PHP-Code:

<?php
 class products {
     
     private function hersteller(){
         $sql_teil = 'FROM...WHERE';
         return sql_query('SELECT...');
     }
     
     private function normal_listing(){
         $sql_teil = 'FROM...WHERE';
         return sql_query();
     }
     
     private function suche(){
         $sql_teil = 'FROM...WHERE';
         return sql_query();
     }
     
     private function archiv(){
         $sql_teil = 'FROM...WHERE';
         return sql_query();
     }
     
     private function blaettern(){
         
         return sql_query('SELECT COUNT...');
     }
     
     public function get_blaettern($was, $blaettern, $suche){
         $this->blaettern();
         return array('vor', 'zurueck', 'nummern etc');
     }
     public function get_output($was, $blaettern, $suche){
         
         switch($was){
             case 'hersteller':
                 $data = $this->hersteller($blaettern);            
                 break;
             case 'normal':
                 $data =    $this->normal_listing($blaettern);    
                 break;
             case 'suche':
                 $data =    $this->suche($suche, $blaettern);
                 break;
             case 'archiv':
                 $data =    $this->archiv($blaettern);
                 break;
         }
         
         while($r = sql_result($data)){
             $output[] = array('blabla');
         }
         return $output;
     }
     
 }
 
 $items = new products();
 
$ausgabe = $items->get_output($was,$blaettern, $suche);
$blaetter_data = $items->get_blaettern($was,$blaettern,$suche);
?>

Ist das noch OOP oder ist es schon zu viel Codemischung? Dann das soweit von der Struktur noch OK ist, hätte ich gerne noch ein Tipp wie ich in der Blätter Funktion an den jeweils passenden SQL Code aus den anderen Funktionen komme. Möchte wenn, diesen ja nicht nochmal in der Blätter Funktion schreiben. Vielleicht sollte man die Blätterfunktion von der product Klasse ableiten, Art Mutter - Kind.

Das sieht wirklich nicht sehr OOPlig aus...
Mehr wie, in eine Klasse, gestopfter Prozeduraler Code.


Das Switch-Case ist da nicht schön anzusehen. Meist ist es Aufgabe des Controllers, zu wissen, wie welche Daten vom Modell zu bekommen sind.

mhh dachte mir sowas schon, denke offensichtlich noch zu sehr in meinen alten Mustern.

Neuer Versuch:

PHP-Code:

<?php
class products_data {

    public static function listing($sql){
        $sql = sql_query($sql);
        while($r = sql_fetch($sql)){
            $arr[] = array('id'=>$r['id'],
                            'name'=>$r['name'],
                            'img'=>$this->picture($r['picture']),
                            'etc'=>etc);
        }
        return $arr;
    }

    public static function detail($sql){
        $sql = sql_query($sql);
        return $sql_fetch($sql);
    }

    public static function listing_count($sql){
        $sql = sql_query($sql);
        return $sql_fetch($sql);
    }

    private function picture($pic){
        $picture = '';
        if(file_exists($pfad.etc.$pic)){
            //....weiter code
            $picture = 'blabla';
        }
        return $picture;
    }

}

class products_controller{

    public function get_output($was, $suche, $seiten_anzahl){
        $data_build = new products_build();
        switch($was){
            case 'hersteller':
                $sql  = 'SELECT...';
                $data1 = products_data::listing($sql);
                $data2 = '';//keine Blätterfunktion
                break;
            case 'archiv':
                $sql  = 'SELECT...';
                $sql1 = 'SELECT COUNT...';
                $data1 = products_data::listing($sql);
                $data2 = products_data::listing_count($sql1);
                break;
            case 'suche':
                $sql  = 'SELECT...';
                $sql1 = 'SELECT COUNT...';
                $data1 = products_data::listing($sql);
                $data2 = products_data::listing_count($sql1);
                break;
            case 'archiv':
                $sql  = 'SELECT...';
                $sql1 = 'SELECT COUNT...';
                $data1 = products_data::listing($sql);
                $data2 = products_data::listing_count($sql1);
                break;
            case 'detail':
                $sql  = 'SELECT...';
                $data1 = products_data::detail($sql);
                $data2 = '';//keine Blätterfunktion
                break;
            case 'normal':
            default:
                $sql  = 'SELECT...';
                $sql1 = 'SELECT COUNT...';
                $data1 = products_data::listing($sql);
                $data2 = products_data::listing_count($sql1);
        }
        return array($data1, $data2);
    }
}

$items = new products_controller();

$daten = $items->get_output($was, $suche, $seiten_anzahl);

?>

Oder läuft OOP generell auf ein MVC hinaus wie hier: MVC mit PHP - Das MVC-PAttern mit PHP implementieren und verwenden

Oder läuft OOP generell auf ein MVC hinaus

Nicht unbedingt, aber meist ja...

Übrigens, auf das static solltest du möglichst verzichten.
Auch das Switch-Case Konstrukt solltest du entsorgen. (aber das sagte ich ja schon mal)

Tipp:
Schau dir mal das Google: "Doctrine ORM" an. Das bietet eine sehr angenehme DB Schnittstelle.

Das ist nicht OOP. Du hast lediglich Funktionen in Klassen gebündelt und so eine Art Namespacing erzeugt. Wenn das dein Ziel ist, dann mach get_output() auch noch static und es ist perfekt.

Zitat von combie

Auch das Switch-Case Konstrukt solltest du entsorgen. (aber das sagte ich ja schon mal)

Mhh und wie zum Beispiel unterscheide ich am einfachsten welche Art (archiv, suche etc) gerade gefragt ist. Hatte mir ja über Google ein paar Beispiele angesehen gehabt und manche nutzen auch switch case Konstrukte in ihren sogenannten "controllern", daher hatte ich das zwar ausgelagert in eine eigene Klasse aber dennoch erstmal erhalten.

Oder soll ich das außerhalb der Klassen machen und dann die passende Klasse/Methode aufrufen?

So ala:

PHP-Code:

$data = new products();
$data->product_listing($sql_fuer_archiv); 


Das mit dem doctrine orm muß ich mir mal anschauen.

Das ist nicht OOP. Du hast lediglich Funktionen in Klassen gebündelt und so eine Art Namespacing erzeugt. Wenn das dein Ziel ist, dann mach get_output() auch noch static und es ist perfekt.

PHP-Code:

//sql_query() ist hier nur ein Platzhalter für PDO
class products_data {

    public function listing($sql){
        $sql = sql_query($sql);
        while($r = sql_fetch($sql)){
            $arr[] = $r;
        }
        return $arr;
    }

    public function detail($sql){
        $sql = sql_query($sql);
        return $sql_fetch($sql);
    }

} 


Inwieweit müsste ich denn die Klasse für die Datenholung abändern, das die dem OOP nahekommt.

Zitat von PuP

Inwieweit müsste ich denn die Klasse für die Datenholung abändern, das die dem OOP nahekommt.

Versuchs mal mit interface, abstract, extends, implements, __construct(), final, ...

final ist u.U. etwas übertrieben!
Aber die Richtung stimmt...