OOP Laie Brauche mal ein Anstoss

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • 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.

  • #2
    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.
    Zuletzt geändert von combie; 02.07.2009, 13:19.
    Wir werden alle sterben

    Kommentar


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

      Kommentar


      • #4
        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

        Kommentar


        • #5
          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.
          Wir werden alle sterben

          Kommentar


          • #6
            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.

            Kommentar


            • #7
              Zitat von combie Beitrag anzeigen
              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);
                  }


              [COLOR=#000000][COLOR=#006600][/COLOR][/COLOR]Inwieweit müsste ich denn die Klasse für die Datenholung abändern, das die dem OOP nahekommt.

              Kommentar


              • #8
                Zitat von PuP Beitrag anzeigen
                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, ...

                Kommentar


                • #9
                  final ist u.U. etwas übertrieben!
                  Aber die Richtung stimmt...
                  Wir werden alle sterben

                  Kommentar

                  Lädt...
                  X