Grails MVC-Tutorial

Grails ist eine MVC-Plattform, die zur Entwicklung von MVC-Anwendungen verwendet wird. Grails hat die MVC-Architektur von Natur aus unterstützt. Dieses Tutorial führt Sie durch das einfache Beispiel zum Schreiben der Grails-Anwendung mithilfe ihres MVC-Entwurfsmusters. Es dient dazu, Ihnen detaillierte Schritte zum Erstellen einer MVC-Anwendung mit Grails und seiner GGTS-Suite bereitzustellen, die bereits in unserem vorherigen Tutorial installiert und konfiguriert wurde.

Wir gehen davon aus, dass Sie das Setup der Grails-Plattform und der GGTS-Suite ordnungsgemäß in Ihrer Umgebung installiert und konfiguriert haben, um das Grails-MVC-Beispiel zu schreiben, wie in diesem Tutorial erläutert.

lesen Sie auch:

  • Einführung in Grails
  • Einführung in die Groovey / Grails Suite
  • Was ist GVM?
  • Einführung in die Groovy-Sprache

1. Grails MVC

In diesem Abschnitt werden die Architektur und die verschiedenen Komponenten erläutert, die in der Grails MVC-Anwendung verwendet werden. Das folgende Bild zeigt den Anforderungsablauf in einer Grails MVC-Anwendung.

Grails MVC-Architektur

  • Modell: Modell ist ein Java-Objekt, das die Daten speichert, die von den Controllern und Ansichten verwendet werden können. Technisch gesehen können Controller ein Modell erstellen oder es einfach in normalen Vorgängen verarbeiten. Grails bietet Ihnen eine gebunden Mechanismus, der Ihnen hilft, Ihr Modell aus den Grails-UI-Komponenten wie g:each zu referenzieren.
  • Regler: Es handelt sich um ein Servlet, das alle Anfragen vom Frontend verarbeitet. Im Allgemeinen erweitert das Grails-Servlet das DispatcherServlet von Spring, um die Grails-Umgebung zu booten (SimpleGrailsController) für die Bearbeitung der Anfragen. SimpleGrailsController Delegierte an eine Klasse namens SimpleGrailsControllerHelper das tatsächlich die Anfrage bearbeitet.
  • Sicht: Für die Darstellung der Modelle ist groovy Server Pages zuständig. Grails verwendet GroovyPagesTemplateEngine zum Rendern von GSP-Ansichten, da diese Ansichten das Konzept benutzerdefinierter Tag-Bibliotheken unterstützen. Sie können darauf zugreifen G Tags direkt in Ihrem GSP, ohne dass ein Import erforderlich ist. Es stehen Ihnen zahlreiche vorgefertigte Tags zur Verfügung. Gral G Die Bibliothek bietet Ihnen die Möglichkeit, auf datengebundene und Domänenklassenzuordnungen zuzugreifen.

Dieses Tutorial bietet Ihnen ein einfaches Beispiel dafür, wie wir eine einfache Grails MVC-Anwendung erstellen können.

  • Erstellen Sie eine Domänenklasse.
  • Erstellen Sie einen Grails-Controller.
  • Ansichten erstellen.
  • Binden Sie Ihre Modelle zur Verwendung aus Ihren Ansichten.
  • Umgang mit verschiedenen Navigationsarten, einschließlich der Verwendung von Standardaktionen und g:link Etikett.
  • Die Projektstruktur für dieses Tutorial würde wie folgt aussehen:

    Gails – MVC – Projektverzeichnis

    2. Erstellen Sie ein Grails-Modell

    Dieser Abschnitt des Tutorials hilft Ihnen beim Erstellen eines Automodells. Beginnen wir mit den dafür erforderlichen Schritten.

    • Öffnen Sie Ihr GGTS (Grails Suite) und öffnen Sie Ihr erstelltes Grails-Projekt.
    • Klicken Sie mit der rechten Maustaste auf Domain Kategorie auswählen und auswählen neu->Domänenklasse.
    • Geben Sie im Grails-Befehlsassistenten den Namen der Domänenklasse ein, die Sie erstellen möchten. Für unser Beispiel haben wir „Auto“ eingegeben und auf „Fertig stellen“ geklickt.
    • Sie würden ein Codefragment wie sehen statische Einschränkungen = {} was durch die hinzugefügt wurde Gral in Ihrem Modell.
    • Grails bietet eine Inline-Validierung im Modell. Die Grails-Domänenklasse kann Domäneneinschränkungen einfach durch die Definition einer öffentlichen statischen Eigenschaft ausdrücken Einschränkungen das hat einen Abschluss als Wert. Dieses Level ist genau das, was Sie brauchen. Weiteres wird in den nächsten Tutorials besprochen.
    • Definieren Sie Ihre Car-Klasse wie jedes normale Plain Old Groovy Object (POGO) und folgen Sie dabei den unten aufgeführten Car POGOs, die der Groovy Beans-Konvention entsprechen.
    • Groovy unterstützt auch den Aufbau von Beziehungen zwischen verschiedenen Klassen innerhalb Ihrer Domain. Beziehungen wie Vererbung, Assoziationen oder Aggregationen werden ebenfalls vom Groovy unterstützt.

    Auto.groovig

    package grails.mvc.example
    
    class Car {
    String carName
    String carBrand
    String productionCountry
    String productionYear
    }
    

    3. Erstellen Sie einen Grails-Controller

    In diesem Abschnitt erfahren Sie, welche Schritte zum Erstellen einer Controller-Komponente erforderlich sind. Die Hauptaufgabe des Controllers besteht darin, die vom Client empfangenen Daten zu bearbeiten und zu entscheiden, ob die Anfrage an einen anderen Controller delegiert, direkt in den Browser ausgegeben oder die Anfrage in eine andere Ansicht delegiert werden soll, die mit den erforderlichen Modellen gefüllt ist.

    Führen Sie die folgenden Schritte aus, um einen neuen Controller zu erstellen:

    • Stellen Sie in Ihrem Grails-Projekt sicher, dass Sie zunächst die Controller-Kategorie auswählen.
    • Klicken Sie dort mit der rechten Maustaste und wählen Sie Neu -> Regler.
    • Geben Sie im Grails-Befehlsassistenten den Namen des Controllers ein, den Sie erstellen möchten.
    • Für unser Beispiel haben wir getippt RegisterCarController. Ein richtiger Name für Ihren Controller muss mit enden Regler Satz, der Grails helfen würde, die Controller konventionell zu entdecken.
    • Wenn Sie auf „Fertig stellen“ klicken, werden zwei Dateien erstellt: Ihr Controller und sein Komponententest.
    • Standardmäßig ist ein Index Dort wird die Aktion definiert.
    • Um eine Aktion zu definieren, müssen Sie verwenden def <>{} bauen.
    • Das Definieren von Controller-Eigenschaften unterscheidet sich nicht von denen, die normalerweise in Groovy-Beans definiert werden.

    Der unten definierte Controller enthält benutzerdefinierte definierte Eigenschaften sowie die erforderlichen Aktionen:

    RegisterCarController.groovy

    package grails.mvc.example
    
    class RegisterCarController {
    ArrayList&lt;Car&gt; carList = new ArrayList&lt;Car&gt;();
    // Scope static variable used for specifying the scope of the controller
    static scope ="session"
    // Specify the default action of the RegisterCarController
    static defaultAction = "initialize"
    
    def initialize (){
    // Default action will lead us into register view
    render view:"/registerCar/register";
    }
    
    def registerAgain(){
    // register again action will lead us into register view
    render view:"/registerCar/register";
    }
    
    def register() {
    // Create new instance of car
    Car car = new Car()
    // Populate the car instance with those corresponding matched request parameters
    car.properties = params
    try {
    // Add car into list of cars
    carList.add(car)
    }
    catch(Exception e){
    // Debug the exception thrown
    log.debug("Exception Occured ::", e)
    }
    // Render the next view
    render view:"/viewCars/list",model:[cars:carList]
    }
    }
    

    Einige wichtige Punkte sollten jetzt beachtet werden:

    • RegisterCarController hat eine Liste von Autoobjekten definiert.
    • Grails MVC definiert Bereiche für die Controller. Bereiche sind Hash-ähnliche Objekte, die zum Speichern von Variablen verwendet werden. Sitzung, Anfrage, Parameter, Flash und ServletContext sind alles Bereiche, die Sie für Ihre Controller verwenden können.
    • Statische Variable Umfang ist die Variable, die zur Bestimmung des Bereichs verwendet wird, den Sie für Ihren Controller verwendet haben, wie Sie im RegisterCarController gesehen haben, Sitzung wurde als Zielfernrohr verwendet.
    • Standardaktion kann wie folgt definiert werden: Verwenden der statischen defaultAction-Variable Definieren Sie, wie wir es im RegisterCarController getan haben, eine Index Aktion und bietet keine zusätzlichen Aktionen gleichzeitig oder indem es die einzige Aktion in Ihrem Controller bereitstellt.
    • Die Standardaktion wurde von der Grails-Plattform aufgerufen, wenn im angeforderten URI keine Aktion angegeben ist, da dies auf der Hauptseite der Fall war RegisterCarController unter verfügbaren Controller Abschnitt.
    • Initialisieren Die Aktion bietet keinerlei Datenmanipulation, sondern delegiert die Kontrolle an registrieren Sicht.
    • RegistrierenAndere Die Aktion bietet keinerlei Datenmanipulation, sondern delegiert die Kontrolle an registrieren Sicht.
    • Registrieren Wenn die Aktion die von uns gewünschte gezielte Datenmanipulation durchführt, wird sie verwendet implizites Objekt Parameter zum Sammeln der Anfrageparameter aus dem übermittelten Formular. Eine implizite Konvertierung wurde von Grails selbst bei der Zuweisung durchgeführt Parameter hinein car.properties, Jede einzelne Eigenschaft im Auto erhält ihren Wert vom identischen Parameter. Name der Immobilie, die für die erforderliche Identifizierung verwendet wird.
    • Aktionsverwendungen registrieren machen Phrase zum Bestimmen der nächsten Ansicht und optionales Einbinden der Liste der Autos Autos zur späteren Verwendung in der nächsten Ansicht.
    • Grails bieten Ihnen die Möglichkeit, das implizite Protokollobjekt zum Protokollieren Ihrer Nachrichten zu verwenden. Es ist also nicht erforderlich, das zu verwendende Protokollobjekt zu definieren. Mehr zum Thema Logging in Zukunft.

    4. Erstellen Sie Grails-Ansichten

    Grails betrachtet die Groovy-Serverseiten (APS) als Ansichtstechnologie; GSP basiert auf HTML und verfügt über eine spezielle Tag-Bibliothekstechnologie. Es ist genau wie JavaServer Pages (JSP) mit dem großen Vorteil, dass es sich um einen Entwicklungsprozess für Grails-Tags handelt.

    Die Grails-Suite bietet Ihnen die Möglichkeit, Ansichten zu erstellen. In unserem Beispiel erstellen Sie zwei Ansichten: Die Register- und die Listenansicht dienen zur Registrierung neuer Autos und die letztere zum Anzeigen dieser.

    Erstellen wir zunächst die Registrierungsansicht, indem wir die folgenden Schritte ausführen:

    • Stellen Sie sicher, dass Sie in Ihrem Grails-Projekt die Kategorie „Ansichten“ auswählen.
    • Klicken Sie mit der rechten Maustaste und erstellen Sie einen Ordner mit dem Namen registerCar. (Das wird uns helfen, die Entschlossenheit des Controllers auf herkömmliche Weise zu nutzen, wie Grails es versprochen hatte.)
    • Erstellen Sie im Ordner „registerCar“ eine neue Groovy-Serverseite mit dem Namen register.gsp.

    Nachfolgend die Form der Ansicht, die uns bei der Registrierung eines neuen Autos helfen würde:

    register.gsp

    &lt;%@ page contentType="text/html;charset=UTF-8" %&gt;
    &lt;html&gt;
    &lt;head&gt;
    &lt;meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/&gt;
    &lt;meta name="layout" content="main"/&gt;
    &lt;title&gt;Car Registration&lt;/title&gt;
    &lt;/head&gt;
    &lt;body&gt;
    &lt;div  &gt;
    &lt;g:form action="register"&gt;
    &lt;table&gt;
    &lt;tr&gt;&lt;td&gt;Car Name:&lt;/td&gt;&lt;td&gt;&lt;input id="carName" name="carName" type="text"/&gt;&lt;/td&gt;&lt;/tr&gt;
    &lt;tr&gt;&lt;td&gt;Car Brand:&lt;/td&gt;&lt;td&gt;&lt;input id="carBrand" name="carBrand" type="text"/&gt;&lt;/td&gt;&lt;/tr&gt;
    &lt;tr&gt;&lt;td&gt;Car Production Country:&lt;/td&gt;&lt;td&gt;&lt;input id="productionCountry" name="productionCountry" type="text"/&gt;&lt;/td&gt;&lt;/tr&gt;
    &lt;tr&gt;&lt;td&gt;Car Production Year:&lt;/td&gt;&lt;td&gt;&lt;input id="productionYear" name="productionYear" type="text"/&gt;&lt;/td&gt;&lt;/tr&gt;
    &lt;tr&gt;&lt;td colspan="2"&gt;&lt;input value="Register" type="submit"/&gt;&lt;/td&gt;&lt;/tr&gt;
    &lt;/table&gt;
    
    &lt;/g:form&gt;
    &lt;/div&gt;
    &lt;/body&gt;
    &lt;/html&gt;
    

    Einige wichtige Tipps seien hier erwähnt:

    • Grails bietet Ihnen das G Tag-Bibliothek zur Verwendung in Ihrem Groovy-Serverseiten-GSP. Es ist so integriert in die groovigen Serverseiten und auch so anpassbar.
    • Wir haben mithilfe von ein Einreichungsformular erstellt g:form das wird einem Controller unterworfen. Gral bilden Die Komponente bietet Ihnen neben allen HTML-Attributen zusätzliche Attribute wie Aktion, Controller, Parameter, Zuordnung und andere.
    • Falls Sie das Controller-Attribut aus dem Formular-Tag entfernt haben, berücksichtigen die Grails Ihre GSP-Verzeichnisstruktur, um den Controller zu berücksichtigen, der für die Verarbeitung der Formularübermittlung verantwortlich ist. Ihr GSP befindet sich im RegisterCar-Verzeichnis, wie es in der Verzeichnisstruktur oben angezeigt wird, sodass es Ihren Controller-Namen konstruiert, indem es die Controller-Phrase als Suffix in Ihre Verzeichnisstruktur einfügt, zu der wir gelangen registerCarController.
    • Wir haben eine Liste mit Eingaben zum Sammeln aller erforderlichen Daten bereitgestellt, die zum Erstellen eines Autoobjekts erforderlich sind. Diese Formulareigenschaften haben denselben Namen wie die in der Fahrzeugklasse definierten Eigenschaften. So würde uns die Benennung helfen, das zu nutzen Parameter implizites Objekt.
    • Eingabe des Typs einreichen hilft uns beim Absenden des Formulars.

    Mit den gleichen Schritten wie oben können Sie die Ansicht der Listenautos erstellen. Folgen Sie dem untenstehenden Formular:

    list.gsp

    &lt;%@ page contentType="text/html;charset=UTF-8"%&gt;
    &lt;html&gt;
    &lt;head&gt;
    &lt;meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" /&gt;
    &lt;meta name="layout" content="main" /&gt;
    &lt;title&gt;List Cars&lt;/title&gt;
    &lt;/head&gt;
    &lt;body&gt;
    &lt;div  &gt;
    &lt;table&gt;
    &lt;tr&gt;
    &lt;th&gt;Car Name&lt;/th&gt;
    &lt;th&gt;Car Brand&lt;/th&gt;
    &lt;th&gt;Car Production Country&lt;/th&gt;
    &lt;th&gt;Car Production Year&lt;/th&gt;
    &lt;/tr&gt;
    &lt;g:each var="car" in="${cars}"&gt;
    &lt;tr&gt;
    &lt;td&gt;
    ${car.carName}
    &lt;/td&gt;
    &lt;td&gt;
    ${car.carBrand}
    &lt;/td&gt;
    &lt;td&gt;
    ${car.productionCountry}
    &lt;/td&gt;
    &lt;td&gt;
    ${car.productionYear}
    &lt;/td&gt;
    &lt;/tr&gt;
    &lt;/g:each&gt;
    &lt;/table&gt;
    &lt;/div&gt;
    &lt;g:link controller="registerCar" action="registerAgain"&gt;Register Again&lt;/g:link&gt;
    &lt;/body&gt;
    &lt;/html&gt;
    

    Hier ist die detaillierte Erklärung für den obigen Code:

    • Wir haben verwendet g:jeder Tag für die Iteration über ${Autos} gebundene Variable, die bereits von der Registeraktion zurückgegeben wurde.
    • Wir haben das verwendet g:link Um erneut zur Registrierungsansicht zu navigieren, bietet Ihnen g:link die Möglichkeit, zu definieren, welcher Controller Sie aufrufen möchten und welche Aktion Sie ausführen möchten. Durch Klicken auf die Registrieren Sie sich erneut Link, Registeransicht wird angezeigt.

    5. Grails MVC-Demo

    Führen Sie zum Ausführen der Anwendung die folgenden Schritte aus:

    • Klicken Sie mit der rechten Maustaste auf Ihr Projekt.
    • Wählen Rennen wie.
    • Wählen Grails-Befehl (run-app).
    • Warten Sie eine Weile, bis Ihr Projekt gestartet ist.
    • Der Link wird in der Konsole aufgeführt. Klicken Sie einfach auf.

    Grails – MVC – Hauptseite

    • Klicken Sie auf Ihren oben aufgeführten Controller. Der Controller hat die Standardaktion bereitgestellt initialisieren das auf der Hauptseite verwendet wird.
    • Die Initialisierungsaktion wurde ausgeführt und delegiert die Steuerung der Anwendung an die Registeransicht.

    Grails – MVC – Registeransicht

    • Eine für Sie bereitgestellte Aktion: „Register“ ruft die Aktion „RegisterCarController“ auf – basierend auf dem Prinzip „Konvention über Konfiguration“.
    • Durch die Registrierungsaktion wurde ein neues Auto erstellt und zur Fahrzeugliste hinzugefügt.
    • Abschließend wird die Ansicht mit ausgewählt reservierte Renderphrase Damit füllen Sie auch das benötigte Modell aus, das für die nächste Ansicht verwendet wird.

    Grails – MVC – Listenansicht

    • Sie haben die Möglichkeit, weitere Autos zu registrieren, indem Sie auf „Erneut registrieren“ klicken.
    • Die Aktion „Erneut registrieren“ wurde unter Verwendung der entwickelt g:link Grails-Komponenten-Tag. Es wird die Aktion „registerAgain“ ausgeführt, die uns wieder in die Registeransicht führt.

    6. Zusammenfassung

    Die MVC-Architektur ist heutzutage die am häufigsten für die Entwicklung von Webanwendungen verwendete Architektur. In diesem Tutorial erfahren Sie ausführlich, wie mit der Grails-Plattform ein MVC-Beispiel erstellt werden kann. Sie können uns unterstützen, indem Sie unten Ihre Kommentare, Fragen oder Vorschläge hinterlassen.

    Kommentar verfassen

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

    Nach oben scrollen