Ankündigung

Einklappen
Keine Ankündigung bisher.

Schichtenmodell in modernen Webanwendungen

Einklappen

Neue Werbung 2019

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

  • Schichtenmodell in modernen Webanwendungen

    Hallo,
    ich habe die letzten Tage damit verbracht, mich mit Schichtenmodellen und Design Pattern auseinanderzusetzen. Doch da ich nach vielen Stunden immer noch nicht viel weiter mit meiner Planung der Architektur bin und mich irgendwie im Kreis drehe, würde ich mich gerne mal genauer informieren, wie bestehende moderne Webanwendungen aufgebaut sind.

    Mir ist klar, das heutige Objektorientierte Anwendungen aus mindestens drei Schichten bestehen: Der Ein- und Ausgabe, der Datenhaltung, sowie den eigentlichen Kern der Anwendung. Das wird wohl auch ziemlich dem MVC-Konzept entsprechen. Was mich daran stört ist, das man hier oft dazu neigt, alles was nicht Model oder View ist, in den Controller zu schmeißen, welcher dann extrem aufgebläht wird, erst recht bei größeren Projekten.

    Aus diesem Grund wollte ich euch einfach mal fragen, ob ihr gute Open Source Projekte kennt, in die man mal reinschnuppern und sich ein bisschen was abgucken kann.
    Vielleicht habt ihr auch ein Paar Tipps, was ich mir unbedingt ansehen sollte.

    Ich freue mich über jede Antwort.
    Gruß


  • #2
    MVC ist keine Architektur, es ist ein Pattern.

    es gibt zb die
    * Clean Code Architektur
    * Data Context Interaction
    * Onion Achitecture

    http://dkmulligan.files.wordpress.co...chitecture.jpg
    http://blog.8thlight.com/uncle-bob/2...hitecture.html
    im grunde sind die alle gleich.. als referenz Projekt kannste dir zb das hier ansehen:

    https://github.com/igorw/doucheswag

    und/oder die vorträge in meinem übungsprojekt

    https://github.com/Opentribes/Core

    bei konkreten Fragen können hier sicherlich einige eine antwort geben
    apt-get install npm -> npm install -g bower -> bower install <package> YOLO https://www.paypal.me/BlackScorp | Mein Youtube PHP Kanal: https://www.youtube.com/c/VitalijMik

    Kommentar


    • #3
      Hallöchen,

      mein Tipp: mach's dir nicht zu kompliziert

      Viele Grüße,
      lotti

      Kommentar


      • #4
        Am einfachsten wird es wohl sein, die großen Frameworks anzuschauen. Bei PHP sehe ich aktuell Symfony, Laravel und Flow vorne. Alle drei haben auch massig Dokumentation.

        Kommentar


        • #5
          Zitat von WilliTheSmith Beitrag anzeigen
          Was mich daran stört ist, das man hier oft dazu neigt, alles was nicht Model oder View ist, in den Controller zu schmeißen, welcher dann extrem aufgebläht wird, erst recht bei größeren Projekten.
          Dem musst du dich ja nicht anschließen.

          Vielleicht interessant:
          Skinny everything
          PHPMD
          "Mein Name ist Lohse, ich kaufe hier ein."

          Kommentar


          • #6
            Stimmt schon das ist ein Problem. Grad bei großen Projekten blähen sich die Controller schnell auf.

            - Eine action sollte nicht mehr als 30-60 codezeilen (jaja da sagt jeder was anderes) enthalten (ist glaub ich symfony cs)

            - ein controller nicht mehr als 30 action

            Werden die Actions zu lang -> Auslagern und/oder auf mehrere actions /module verteilen.

            Ich finde z.B. diese art der action definition nice: übersichtlich, schnell fassbar und einfach zu warten

            (schematisch)
            PHP-Code:
            public function baumApiActionBla($params)
            {
               
            $baum Wald::findBaum(...);

               
            // birth
               
            $form = new BaumSchuleForm($baum);
               if (
            $form->submit(....))
               {
                  
            $user->notice('Baum ist gewachsen');
                  
            $this->redirect(bäume);
               }

               
            // cut
               
            if (FÄLLE-BAUM)
               {
                  
            $baum->cut();
                  
            $user->notice('Baum ist Holz');
                  
            $this->redirect(bäume);
               }

               
            // water
               
            if (GIESSE-BAUME)
               {
                  
            $user->notice('Baum ist gewässert.');
                  
            $baum->water();
                  
            $this->redirect(bäume);
               }

            Wirds zu lang hast du zu viel versucht in der action zu machen

            my2cents

            Kommentar


            • #7
              Zitat von Spezl Beitrag anzeigen
              - ein controller nicht mehr als 30 action
              Irgendwie finde ich ist MVC da generell kaputt. Heißt es nicht eine Klasse sollte genau eine Aufgabe haben? Meiner Meinung nach sollte die Action eine eigene Klasse sein. Fände ich zumindest konsequenter. Mal sehen wann das C bei MVC mal von fähigen Leuten aufgeräumt wird zu etwas, das mehr Sinn macht. Aber das ist vielleicht eine ganz andere Diskussion.
              "Mein Name ist Lohse, ich kaufe hier ein."

              Kommentar


              • #8
                Meiner Meinung nach sollte die Action eine eigene Klasse sein.
                Halte ich in der Regel auch so. Zumindest bei „echten“ Actions, die mehr machen, als nur was ausm Model auslesen und die View bedienen. Führt natürlich zu Abhängigkeiten oder Konfigurationsaufwand.
                --

                „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
                Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


                --

                Kommentar


                • #9
                  Zitat von Chriz Beitrag anzeigen
                  Meiner Meinung nach sollte die Action eine eigene Klasse sein. Fände ich zumindest konsequenter
                  So ist es auch bei der Clean Code Achitecture, eine Interaction ist eine Klasse die ledeglich in einer Action aufgerufen wird(um DRY nicht zu verletzen, kombiniert man auch Interactions zu einem Context, was auch eine Eigene klasse ist die Interactionen anhand von Rollen sequenziell abarbeitet), auch das M fällt weg da man Entities hat die von einem Repository kommen und das V kann man eher als T(emplate) bezeichnen
                  apt-get install npm -> npm install -g bower -> bower install <package> YOLO https://www.paypal.me/BlackScorp | Mein Youtube PHP Kanal: https://www.youtube.com/c/VitalijMik

                  Kommentar


                  • #10
                    Zitat von BlackScorp Beitrag anzeigen
                    ... und das V kann man eher als T(emplate) bezeichnen
                    heheh das denk ich mir auch seit jahren *g*

                    Kommentar


                    • #11
                      Hallöchen,

                      Zitat von Spezl Beitrag anzeigen
                      heheh das denk ich mir auch seit jahren *g*
                      dieser Aspekt wird besonders deutlich wenn man sich mal das Konzept von AngularJS (JavaScript Framework) ansieht. Dort geht man sogar so weit, dass die Controller gar nichts von den Views (simple HTML-Templates) wissen dürfen. Das Template bestimmt quasi selbst, welcher Controller die Steuerung für selbiges übernimmt. Somit bleiben Controller absolut unabhängig und wiederverwendbar -- wenn man sich denn daran hält. Hier ein simples Beispiel:

                      template.html
                      HTML-Code:
                      <div data-ng-controller='ListCtrl'>
                          <ul>
                              <li data-ng-repeat='item in items'>Eintrag Nr. {{$index}}</li>
                          </ul>
                          <button data-ng-click='appendNewItem()'></button>
                      </div>
                      controller.js
                      Code:
                      ...
                      app.controller('ListCtrl', [
                          '$scope',
                          function($scope){
                              $scope.items = [0, 1, 2, 3, 4];
                              $scope.appendNewItem = function(){
                                  $scope.items.push($scope.items.length);
                              };
                          }
                      ]);
                      ...
                      Der Controller "ListCtrl" weiß zu keinem Zeitpunkt, dass es das Template "template.html" überhaupt gibt.

                      Viele Grüße,
                      lotti

                      Kommentar


                      • #12
                        Zitat von Spezl Beitrag anzeigen
                        heheh das denk ich mir auch seit jahren *g*
                        ich will aber nicht sagen dass es keine Views mehr gibt, die Views sind eher Simple Objekte die dann im Template gerendert werden(Views und Templates werden unterschieden). Ähnlich wie bei Angular.js kann man es in php mit Mustache PHP umsetzen
                        apt-get install npm -> npm install -g bower -> bower install <package> YOLO https://www.paypal.me/BlackScorp | Mein Youtube PHP Kanal: https://www.youtube.com/c/VitalijMik

                        Kommentar


                        • #13
                          Der Controller "ListCtrl" weiß zu keinem Zeitpunkt, dass es das Template "template.html" überhaupt gibt.
                          Und was soll daran jetzt schlauer sein, wenn die Konfiguration in der View steckt, statt in den Controller gefüttert? So lange ich im Controller die Actions verdrahte, habe ich ja letztlich allenfalls die Konfiguration auf verschiedene Bereiche verteilt.
                          --

                          „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
                          Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


                          --

                          Kommentar


                          • #14
                            Zitat von nikosch Beitrag anzeigen
                            Und was soll daran jetzt schlauer sein, wenn die Konfiguration in der View steckt, statt in den Controller gefüttert? So lange ich im Controller die Actions verdrahte, habe ich ja letztlich allenfalls die Konfiguration auf verschiedene Bereiche verteilt.
                            ich denke lottis antwort wahr eher an Templates vs Views bezogen und nicht aufs ACL
                            apt-get install npm -> npm install -g bower -> bower install <package> YOLO https://www.paypal.me/BlackScorp | Mein Youtube PHP Kanal: https://www.youtube.com/c/VitalijMik

                            Kommentar


                            • #15
                              Hallöchen,

                              Zitat von nikosch Beitrag anzeigen
                              Und was soll daran jetzt schlauer sein, wenn die Konfiguration in der View steckt, statt in den Controller gefüttert? So lange ich im Controller die Actions verdrahte, habe ich ja letztlich allenfalls die Konfiguration auf verschiedene Bereiche verteilt.
                              Die Architektur von AngularJS zielt im Speziellen darauf ab, Controller unabhängig von Templates zu entwickeln. Ein Controller darf zu keinem Zeitpunkt direkt mit einem Template kommunizieren - bspw. indem er Änderungen am DOM vornimmt. Stattdessen stellt ein Controller einen konkreten Funktionsumfang bereit, an welchem sich die Templates, je nach Bedarf, frei bedienen können. Hier nochmal ein kleines Beispiel:

                              UserController.js
                              Code:
                              app.controller('UserController', [
                              	'$scope',
                              	function($scope){
                              		/** Pseudo-Benutzer */
                              		$scope.users = [
                              			{username: 'foo', email: 'foo@bar.de'},
                              			{username: 'bar', email: 'bar@foo.de'}
                              		];
                              
                              		/** Methode zum Hinzufügen eines Nutzers */
                              		$scope.add = function(username, email){
                              			$scope.users.push({
                              				username: username,
                              				email: email
                              			});
                              		};
                              
                              		/** Methode zum Löschen eines Nutzers */
                              		$scope.remove = function(i){
                              			$scope.users.splice(i, 1);
                              		};
                              	}
                              ]);
                              UserList.html
                              HTML-Code:
                              <ul data-ng-controller='UserController'>
                                  <li data-ng-repeat='user in users'>{{user.username}} ({{user.email}})</li>
                              </ul>
                              AddUser.html
                              HTML-Code:
                              <form data-ng-controller='UserController' data-ng-submit='add(username, email)'>
                                  <input type='text' data-ng-model='username'>
                                  <input type='text' data-ng-model='email'>
                                  <button type='submit'>Hinzufügen</button>
                              </form>
                              RemoveUser.html
                              HTML-Code:
                              <ul data-ng-controller='UserController'>
                                  <li data-ng-repeat='user in users'>
                                      <a data-ng-click='remove($index)'>{{user.username}} löschen</a>
                                  </li>
                              </ul>
                              Dieses Beispiel demonstriert, wie man beliebige Templates um einen Controller herum aufbauen kann. Das funktioniert in dieser Form auch nur, weil der Controller keinerlei Abhängigkeit zu den Templates aufweist. Das macht den Controller extrem flexibel und jederzeit wiederverwendbar. Zudem erhöht das die Testbarkeit ungemein.

                              PS: Das bezog sich natürlich nicht auf die ACL-Problematik.

                              Viele Grüße,
                              lotti

                              Kommentar

                              Lädt...
                              X