Der Autor wählte den Tech Education Fund, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.
AdonisJs ist ein in einfachem JavaScript geschriebenes Node.js Web-Framework, das auf allen gängigen Betriebssystemen läuft. Es verwendet das beliebte Designmuster MVC (Model - View - Controller) und bietet ein stabiles Ökosystem für das Schreiben serverseitiger Webanwendungen. Das Framework bietet nahtlose Authentifizierung, SQL ORM (objekt-relationales Mapping), Migrationen und Datenbank-Seeding. AdonisJs weist eine ähnliche Architektur wie das PHP Webanwendungs-Framework Laravel auf, einschließlich der gleichen Ordnerstruktur und mehrere gemeinsam genutzter Einrichtungskonzepte.
Standardmäßig verwendet AdonisJs die Edge Template Engine, die für eine intuitive Verwendung konzipiert ist. Genau wie Laravel wird AdonisJs mit einem ORM namens Lucid bereitgestellt, das als Schnittstelle für die Kommunikation zwischen den Modellen einer Anwendung und der Datenbank dient. Mit AdonisJs können Entwickler eine Full-Stack-Anwendung erstellen, bei der der Backend-Server für die Anwendung der Geschäftslogik, das Routing und das Rendering aller Seiten der Anwendung verantwortlich ist. Es ist auch möglich, eine Webdienst-API zu erstellen, um JSON-Antworten von einem Controller zurückzugeben; diese Webdienste können dann über Frontend-Frameworks wie Vue.js, React und Angular konsumiert werden.
In diesem Tutorial erstellen Sie eine Anwendung mit AdonisJs unter Verwendung seiner CLI. Sie erstellen Routen, Controller, Modelle und Ansichten innerhalb Ihrer Anwendung und führen Formularvalidierungen durch. Das Beispiel in diesem Tutorial wird eine Anwendung für ein inspirierendes Zitat sein, bei der sich ein Benutzer registrieren und anmelden kann, um ein inspirierendes Zitat zu erstellen. Diese Demo-Anwendung bietet Ihnen die Möglichkeit zur Ausführung von CRUD (Create, Read, Update und Delete)-Operationen.
Bevor Sie mit diesem Leitfaden beginnen, benötigen Sie Folgendes:
Anmerkung: Dieses Tutorial verwendet für die Entwicklung einen macOS-Rechner. Wenn Sie ein anderes Betriebssystem verwenden, müssen Sie in den ersten Schritten möglicherweise sudo
für npm
-Befehle verwenden.
In diesem Abschnitt werden Sie Adonis CLI und alle erforderlichen Pakete auf Ihrem lokalen Rechner installieren. Die CLI ermöglicht es Ihnen, ein neues AdonisJs-Projekt aufzubauen, sowie Boilerplates für Controller, Middlewares und Modelle in Ihrer Anwendung zu erstellen und zu generieren. Außerdem erstellen Sie Ihre Datenbank für das Projekt.
Führen Sie den folgenden Befehl aus, um die AdonisJs CLI global auf Ihrem Rechner über npm
zu installieren:
- npm i -g @adonisjs/cli
Geben Sie nach Abschluss der Installation den folgenden Befehl im Terminal ein, um die Installation von AdonisJs zu bestätigen und die aktuelle Version anzuzeigen:
- adonis --version
Sie sehen eine Ausgabe, die die aktuelle Version von AdonisJs zeigt:
Output4.1.0
Mit der erfolgreichen Installation der AdonisJs CLI haben Sie nun Zugriff auf den Befehl adonis
und können ihn zum Erstellen neuer Installationen eines AdonisJs-Projekts, zur Verwaltung Ihres Projekts und zum Erzeugen relevanter Dateien wie die Controller, Modelle usw. verwenden.
Nun können Sie mit der Erstellung eines neuen AdonisJs-Projekts fortfahren, indem Sie den Befehl adonis
wie hier gezeigt verwenden:
- adonis new adonis-quotes-app
Der vorhergehende Befehl erstellt eine Anwendung namens adonis-quotes-app
in einem neuen Verzeichnis mit demselben Namen in Ihrem lokalen Projektverzeichnis mit der entsprechenden AdonisJs MVC-Struktur.
Verschieben Sie sie in den neuen Anwendungsordner:
- cd adonis-quotes-app
Starten Sie dann Ihre Anwendung durch Ausführen von:
- adonis serve --dev
Dadurch wird der Entwicklungsserver auf dem Standardport 3333
gestartet, wie in der Root-Datei .env
für Ihre Anwendung angegeben. Navigieren Sie zu http://localhost:3333, um die Begrüßungsseite von AdonisJs anzuzeigen.
Jetzt schließen Sie die Einrichtung Ihrer Datenbank ab. Hier installieren Sie den Treiber mysql
, um sich über npm
von Ihrer Node.js-Anwendung mit Ihrem MySQL-Server zu verbinden. Gehen Sie zunächst wieder zu Ihrem Terminal zurück, auf dem die Anwendung derzeit läuft, beenden Sie den Prozess mit STRG+C
und führen Sie den folgenden Befehl aus:
- npm i mysql
Nachdem Sie nun den MySQL Node.js-Treiber für diese Anwendung erfolgreich installiert haben, müssen Sie die Anwendungsdatenbank erstellen und die entsprechende Verbindung zu ihr aufbauen.
Die neueste Version von MySQL, die Sie aus dem vorbereitendem Tutorial installiert haben, verwendet ein standardmäßiges Authentifizierungs-Plugin namens caching_ha2_password
. Dieses wird derzeit von den Node.js-Treibern für MySQL nicht unterstützt. Um Probleme mit der Datenbankverbindung in Ihrer Anwendung zu vermeiden, müssen Sie einen neuen MySQL-Benutzer anlegen und das derzeit unterstützte Authentifizierungs-Plugin mysql_native_password
verwenden.
Um zu beginnen, greifen Sie mit dem Account root auf den MySQL-Client zu:
- mysql -u root -p
Sie werden aufgefordert, das während der MySQL-Installation eingerichtete Passwort für den Account root einzugeben.
Erstellen Sie als Nächstes den Benutzer und das Passwort unter Verwendung des Plugins mysql_native_password
:
- CREATE USER 'sammy'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';
Sie sehen den folgenden Output:
OutputQuery OK, 0 rows affected (0.02 sec)
Erstellen Sie nachfolgend eine Datenbank für die Anwendung mit:
- CREATE DATABASE adonis;
Sie sehen den folgenden Output:
OutputQuery OK, 1 row affected (0.03 sec)
Damit haben Sie die Datenbank für diese Anwendung erfolgreich erstellt.
Aktivieren Sie jetzt den Zugriff auf die erstellte Datenbank für den neuen MySQL-Benutzer. Führen Sie den folgenden Befehl aus, um dem Benutzer alle Berechtigungen in der Datenbank zu erteilen:
- GRANT ALL PRIVILEGES ON adonis.* TO 'sammy'@'localhost';
Laden Sie die Berechtigungstabelle neu, indem Sie den folgenden Befehl ausführen, um die soeben vorgenommenen Änderungen zu übernehmen:
- FLUSH PRIVILEGES;
Sie sehen den folgenden Output:
OutputQuery OK, 0 rows affected (0.00 sec)
Beenden Sie den MySQL-Client mit:
- quit;
Sie haben die AdonisJs CLI erfolgreich installiert, ein neues AdonisJs-Projekt erstellt und mysql
über npm
installiert. Außerdem haben Sie die Datenbank für diese Anwendung erstellt und einen MySQL-Benutzer mit den entsprechenden Berechtigungen eingerichtet. Dies ist die Grundeinrichtung für Ihre Anwendung. Im nächsten Abschnitt beginnen Sie mit der Erstellung der erforderlichen Ansichten für Ihre Anwendung.
AdonisJs wird mit einer eigenen Template-Engine namens Edge bereitgestellt. Sie ermöglicht Ihnen die Erstellung einer wiederverwendbaren HTML-Vorlage und die Einführung von Front-End-Logik in Ihre Anwendung mit minimalem Code. Edge stellt JavaScript-Entwickler während der Entwicklung einer Anwendung die Werkzeuge zur Verfügung, um ein komponentenbasiertes Layout zu erstellen, Bedingungen zu schreiben, Iterationen zu verwenden und Anzeigeebenen zur Aufnahme der Logik zu erstellen. Alle Template-Dateien enden mit der Erweiterung .edge
und werden im Verzeichnis resources/views
gespeichert.
Nachfolgend sind die Ansichten aufgeführt, die Ihre Anwendung für die ordnungsgemäße Funktionsweise benötigt:
Verwenden Sie zunächst den Befehl adonis
, um die Seite Master Layout zu erstellen, indem Sie den folgenden Befehl ausführen:
- adonis make:view layouts/master
Sie werden eine Ausgabe ähnlich der folgenden sehen:
Output✔ create resources/views/layouts/master.edge
Dieser Befehl erstellt automatisch eine Datei master.edge
in Ihrem Ordner resources/views/layouts
. Öffnen Sie die neue Datei:
- nano resources/views/layouts/master.edge
Fügen Sie den folgenden Code hinzu:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>adonis-quotes-app</title>
{{ style('https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css') }}
{{ style('style') }}
{{ script('https://code.jquery.com/jquery-3.3.1.slim.min.js') }}
</head>
<body>
<div class="container-fliud">
@include('navbar')
@!section('content')
</div>
{{ script('https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js') }}
</body>
</html>
In dieser Datei schließen Sie die CDN-Dateien für Bootstrap CSS, Bootstrap JavaScript und jQuery ein. Sie fügen einen globalen CSS-Dateinamen style.css
hinzu und schließen innerhalb der div
eine Partiale-Datei namens navbar
ein. Um Fragmente des HTML-Codes, die Sie auf mehreren Seiten Ihrer Anwendung benötigen, wie nav
oder footer
, wiederzuverwenden, können Sie Partiale einfügen. Dabei handelt es sich um kleinere Dateien, die den sich wiederholenden Code enthalten, sodass der Code für diese Elemente schneller an einer Stelle und nicht bei jedem Auftreten aktualisiert werden kann. Die navbar
enthält Markierungen für die Schaltflächen Login und Register, ein Logo und einen Home-Link.
Auf diese Weise können alle nachfolgenden für diese Anwendung erstellten Seiten das Master-Layout erweitern und die navbar
rendern, ohne dass der Inhalt neu geschrieben werden muss. Sie erstellen diese Datei navbar
später im Tutorial.
Abschließend definieren Sie einen Abschnitt-Tag @! section()
, um Inhalte anderer Seiten einzuschließen und sie vom Master-Layout rendern zu lassen. Damit dies wie erwartet funktioniert, müssen alle neuen Seiten, die das Master-Layout erweitern, auch einen Abschnitt-Tag mit demselben Namen (d. h. @section('content')
) definieren.
Speichern und schließen Sie die Datei, sobald Sie mit der Bearbeitung fertig sind.
Als Nächstes verwenden Sie den Befehl adonis
, um die Navigationsleiste zu erstellen:
- adonis make:view navbar
Sie sehen einen Output, der so ähnlich wie der nachfolgende aussieht:
Output✔ create resources/views/navbar.edge
Öffnen Sie die neu erstellte Datei:
- nano resources/views/navbar.edge
Fügen Sie dann den folgenden Code hinzu:
<nav class="navbar navbar-expand-lg navbar-dark text-white">
<a class="navbar-brand" >LOGO</a>
<button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarNav" aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
<span class="navbar-toggler-icon"></span>
</button>
<div class="collapse navbar-collapse" id="navbarNav">
<ul class="navbar-nav">
<li class="nav-item active ">
<a class="btn text-white" href="/">Home</a>
</li>
</ul>
</div>
<div class="navbar-right" id="navbarNav">
@loggedIn
<ul class="navbar-nav">
<li>
<div class="text-right">
<a href="{{route('create.quote')}}" class="btn btn-outline-primary">Create Quote</a>
</div>
</li>
<li class="nav-item dropdown">
<a class="nav-link dropdown-toggle" href="#" id="navbarDropdownMenuLink" role="button" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
{{ auth.user.username}}
</a>
<div class="dropdown-menu" aria-labelledby="navbarDropdownMenuLink">
<form method="POST" action="{{route('logout')}}">
{{ csrfField() }}
<button type="submit" class="dropdown-item" href="">logout</button>
</form>
</div>
</li>
</ul>
@else
<ul class="navbar-nav">
<li class="nav-item active pr-2">
<a href="{{route('login.create')}}" class="btn btn-outline-danger">
login
</a>
</li>
<li class="nav-item active pr-2">
<a href="{{route('register.create')}}" class="btn btn-outline-primary">
Register
</a>
</li>
</ul>
@endloggedIn
</div>
</nav>
Zusätzlich zur Definition der Links zu der Homepage und einer Schaltfläche zum Registrieren und Anmelden fügen Sie ein Tag @loggedIn
hinzu. Damit können Sie eine bedingte Anweisung um den authentifizierten Benutzer herum schreiben und bei Bedarf entsprechende Inhalte anzeigen. Für einen authentifizierten Benutzer zeigt die Anwendung den Benutzernamen und eine Schaltfläche zum Erstellen eines neuen Zitats an. Wenn ein Benutzer nicht angemeldet ist, zeigt Ihre Anwendung eine Schaltfläche für die Anmeldung oder die Registrierung an. Diese Seite wird als Partiale auf jeder Seite eingefügt, so wie es zuvor im Master-Layout für diese Anwendung enthalten war.
Speichern und schließen Sie die Datei.
Nun erstellen Sie die Indexseite, die Sie für die Homepage der Anwendung verwenden. Sie wird die Liste aller inspirierenden Zitate, die die Benutzer schreiben, rendern und anzeigen:
- adonis make:view index
Sie werden eine Ausgabe sehen, die der folgenden ähnelt:
Output✔ create resources/views/index.edge
Die hier erstellte Datei wird sich in resources/views/index.edge
befinden. Öffnen Sie die Datei:
- nano resources/views/index.edge
Fügen Sie dann den folgenden Code hinzu:
@layout('layouts/master')
@section('content')
<div class="container">
<div class="text-center">
@if(flashMessage('successmessage'))
<span class="alert alert-success p-1">{{ flashMessage('successmessage') }}</span>
@endif
</div>
<div class="row">
@each(quote in quotes)
<div class="col-md-4 mb-4 quote-wrapper">
<a href="/view-quote/{{quote.id}}" class="w-100">
<div class="card shadow-lg bg-dark text-white">
<div class="card-body">
<blockquote class="blockquote mb-0">
<p>{{quote.body}}</p>
<footer class="blockquote-footer">
<cite title="Source Title"> {{quote.username}}</cite>
</footer>
</blockquote>
@if(auth.user.id == quote.user_id)
<div>
<a href="/edit-quote/{{quote.id}}" class="btn btn-primary">edit</a>
<a href="/delete-quote/{{quote.id}}" class="btn btn-danger">delete</a>
</div>
@endif
</div>
</div>
</a>
</div>
@else
<div class="col-md-12 empty-quote text-center">
<p>No inspirational quote has been created</p>
</div>
@endeach
</div>
</div>
@endsection
Hier geben Sie an, dass diese Ansicht das Layout master
durch Erweiterung verwenden wird. Diese Seite hat nun Zugriff auf alle Bibliotheken, Stylesheets und die navbar
, die im Layout master
enthalten sind. Als Nächstes iterieren Sie über ein Array von quotes
(Zitaten) unter Verwendung des integrierten Tags @each
. Das Array quotes
wird von dem QuoteController
, den Sie später in diesem Tutorial erstellen werden, an diese Ansicht übergeben. Wenn keine Zitate vorhanden sind, wird eine entsprechende Meldung angezeigt.
Speichern und schließen Sie diese Datei.
Um die Anmeldeseite zu erstellen, führen Sie nun den folgenden Befehl aus:
- adonis make:view auth/login
Sie werden eine Ausgabe sehen, die der folgenden ähnelt:
Output✔ create resources/views/auth/login.edge
Dadurch wird automatisch ein Ordner auth
innerhalb von resources/views
erstellt und darin ebenfalls eine Datei login.edge
angelegt. Öffnen Sie die Datei login.edge
:
- nano resources/views/auth/login.edge
Fügen Sie den folgenden Inhalt hinzu:
@layout('layouts/master')
@section('content')
<div class="container">
<div class="row">
<div class="col-md-4 shadow bg-white mt-5 rounded offset-md-4">
<form method="POST" action="{{route('login.store')}}">
{{ csrfField() }}
<div>
@if(flashMessage('successmessage'))
<span class="alert alert-success p-1">{{ flashMessage('successmessage') }}</span>
@endif
</div>
<div class="form-group">
<label for="email">Email address</label>
<input type="email" class="form-control" id="email" name="email" value="{{old('email','')}}" placeholder="Enter email">
{{ elIf('<span class=text-danger>$self</span>', getErrorFor('email'), hasErrorFor('email')) }}
</div>
<div class="form-group">
<label for="pasword">Password</label>
<input type="password" class="form-control" id="password" name="password" value="{{old('password','')}}" placeholder="Password">
{{ elIf('<span class=text-danger>$self</span>', getErrorFor('password'), hasErrorFor('password')) }}
</div>
<div class="text-center">
<button type="submit" class="btn btn-primary">Submit</button>
</div>
</form>
</div>
</div>
</div>
@endsection
Diese Datei enthält ein Formular, das Eingabeelemente enthält,mit denen Sie den Benutzernamen und das Passwort eines registrierten Benutzers erfassen, bevor dieser sich erfolgreich authentifizieren und mit der Erstellung von Zitaten beginnen kann. Ein weiteres wichtiges Element, das Sie auf dieser Seite beachten sollten, ist das {{ csrfField() }}
. Es handelt sich dabei um eine globale Variable, die AdonisJs verwendet, um das CSRF-Zugriffstoken zu übergeben, wenn eine POST
-, PUT
- und DELETE
-Anfrage aus Ihrer Anwendung gesendet wird.
Dies wurde eingerichtet, um Ihre Anwendung vor Cross-Site Request Forgery (CSRF)-Angriffen zu schützen. Es funktioniert, indem es für jeden Benutzer, der Ihre Website besucht, ein eindeutiges CSRF-Geheimnis erzeugt. Sobald Ihre Benutzer eine HTTP-Anfrage vom Frontend aus senden, wird ein entsprechendes Token für dieses Geheimnis generiert und mit der Anfrage weitergegeben. Auf diese Weise kann die für diese Anfrage innerhalb von AdonisJs erstellte Middleware überprüfen, ob sowohl das Token als auch das CSRF-Geheimnis gültig sind und dem aktuell authentifizierten Benutzer gehören.
Speichern und schließen Sie die Datei, sobald Sie fertig sind.
Als Nächstes erstellen Sie die Registrierungsseite mit diesem Befehl:
- adonis make:view auth/register
Sie werden eine ähnliche Ausgabe wie diese sehen:
Output✔ create resources/views/auth/register.edge
Suchen und öffnen Sie die neu erstellte Datei in resources/views/auth/register.edge
:
- nano resources/views/auth/register.edge
Fügen Sie folgenden Code hinzu:
@layout('layouts/master')
@section('content')
<div class="container ">
<div class="row">
<div class="col-md-4 bg-white p-3 mt-5 shadow no-border rounded offset-md-4">
<form method="POST" action="{{route('register.store')}}">
{{ csrfField() }}
<div class="form-group">
<label for="name">Fullname</label>
<input type="text" class="form-control" id="name" name="name" value="{{old('name','')}}" placeholder="Enter Fullname">
{{ elIf('<span class=text-danger>$self</span>', getErrorFor('name'), hasErrorFor('name')) }}
</div>
<div class="form-group">
<label for="email">Email address</label>
<input type="email" class="form-control" id="email" name="email" value="{{old('email','')}}" placeholder="Enter email">
{{ elIf('<span class=text-danger>$self</span>', getErrorFor('email'), hasErrorFor('email')) }}
</div>
<div class="form-group">
<label for="pasword">Password</label>
<input type="password" class="form-control" id="password" name="password" placeholder="Password">
{{ elIf('<span class=text-danger>$self</span>', getErrorFor('password'), hasErrorFor('password')) }}
</div>
<div class="text-center">
<button type="submit" class="btn btn-primary">Submit</button>
</div>
</form>
</div>
</div>
</div>
@endsection
Ähnlich wie die Anmeldeseite enthält diese Datei ein HTML-Formular mit Eingabefeldern zur Erfassung von Name
, E-Mail
und Passwort
eines Benutzers während des Registrierungsvorgangs. Ebenfalls enthalten ist das {{ csrfField() }}
, da es für jede Post-Anfrage für eine AdonisJs-Anwendung erforderlich ist.
Speichern und schließen Sie die Datei.
Nun erstellen Sie eine neue Datei, um ein inspirierendes Zitat zu erstellen, indem Sie den folgenden Befehl vom Terminal aus ausführen:
- adonis make:view quotes/create-quote
Sie sehen eine Ausgabe wie:
Output✔ create resources/views/quotes/create-quote.edge
Öffnen Sie resources/views/quotes/create-quote.edge
:
- nano resources/views/quotes/create-quote.edge
Und fügen Sie den folgenden Inhalt hinzu:
@layout('layouts/master')
@section('content')
<div class="container">
<div class="row">
<div class="col-md-3"></div>
<div class="col-md-6 shadow bg-white mt-5 rounded p-3">
<div class="float-right">
<a href="/" class="btn btn-outline-dark ">back</a>
</div>
<br>
<div class="clear-fix"></div>
<form method="POST" action="{{route('store.quote')}}">
{{ csrfField() }}
<div class="form-group">
<label for="quote">Create Quote</label>
<textarea type="text" rows="5" name='body' id="body" class="form-control" id="quote" placeholder="Write an inspirational quote"></textarea>
</div>
<div class="text-center">
<button type="submit" class="btn btn-primary">Submit</button>
</div>
</form>
</div>
</div>
<div class="col-md-3"></div>
</div>
</div>
@endsection
Diese Seite erweitert das Master-Layout und enthält ein HTML-Formular mit einem Textbereichselement, das es dem Benutzer ermöglicht, Text über mehrere Zeilen einzugeben, bevor er über die entsprechende Route veröffentlicht und gehandhabt wird.
Speichern und schließen Sie die Datei, sobald Sie fertig sind.
Erstellen Sie als Nächstes eine Seite zur Bearbeitung eines bestimmten Zitats. Führen Sie den folgenden Befehl vom Terminal aus:
- adonis make:view quotes/edit-quote
Sie sehen den folgenden Output:
Output✔ create resources/views/quotes/edit-quote.edge
Öffnen Sie die Datei mit:
- nano resources/views/quotes/edit-quote.edge
Fügen Sie den folgenden Inhalt zu resources/views/quotes/edit-quote
hinzu:
@layout('layouts/master')
@section('content')
<div class="container">
<div class="row">
<div class="col-md-6 shadow bg-white rounded p-3 offset-md-3">
<div class="float-right">
<a href="/" class="btn btn-outline-dark ">back</a>
</div>
<br>
<div class="clear-fix"></div>
<form method="POST" action="/update-quote/{{quote.id}}">
{{ csrfField() }}
<div class="form-group">
<label for="pasword">Edit Quote</label>
<textarea type="text" rows="5" name='body' id="body" class="form-control" id="quote" placeholder="write the inspirational quote">{{quote.body}}</textarea>
</div>
<div class="text-center">
<button type="submit" class="btn btn-primary">Update</button>
</div>
</form>
</div>
</div>
</div>
@endsection
Diese Seite enthält ähnliche Inhalte wie die Datei create-quote.edge
– der Unterschied besteht darin, dass sie die Details eines bestimmten Zitats enthält, die zu bearbeiten sind, <form method="POST" action="/update-quote/{{quote.id}}">
.
Speichern und schließen Sie die Datei.
Erstellen Sie abschließend eine Seite, um ein einzelnes inspirierendes Zitat anzuzeigen:
- adonis make:view quotes/quote
Sie sehen eine Ausgabe, die dieser ähnelt:
Output✔ create resources/views/quotes/quote.edge
Öffnen Sie die Datei mit:
- nano resources/views/quotes/quote.edge
Fügen Sie folgenden Code hinzu:
@layout('layouts/master')
@section('content')
<div class="container">
<div class="row">
<div class="col-md-6 offset-md-3">
<div class="card shadow-lg bg-dark text-white">
<div class="card-body">
<div class="float-right">
<a href="/" class="btn btn-outline-primary ">back</a>
</div>
<br>
<div class="clear-fix"></div>
<blockquote class="blockquote mb-0">
<p>{{quote.body}}</p>
<footer class="blockquote-footer">
<cite title="Source Title">{{quote.username}}</cite>
</footer>
</blockquote>
</div>
</div>
</div>
</div>
</div>
@endsection
Diese Seite gibt die Details eines bestimmten Zitats wieder, einschließlich des Zitatkörpers quote.body
, und des Autors, der es erstellt hat, quote.username
.
Wenn Sie mit der Datei fertig sind, speichern und schließen Sie sie.
Sie haben alle erforderlichen Seiten für Ihre Anwendung mit Hilfe der Edge Templating Engine erstellt. Als Nächstes konfigurieren und stellen Sie eine Verbindung mit der Datenbank Ihrer Anwendung her.
Wenn Sie Ihre Anwendung jetzt bereitstellen, wird ein Fehler ausgegeben, da Sie die Anwendung noch mit einer Datenbank verbinden müssen. In diesem Abschnitt richten Sie eine Verbindung mit der Datenbank ein und verwenden dann den Befehl adonis
zur Erzeugung einer Migrationsdatei, die zur Erstellung der Tabellen für die Datenbank verwendet wird.
AdonisJs enthält ein ORM namens Lucid ORM, das eine aktive Datensatz-Implementierung für die Arbeit mit Ihrer Datenbank bereitstellt. Damit entfällt das mühsame Schreiben von SQL-Abfragen, die Daten in Echtzeit aus der Datenbank abrufen. Dies ist besonders hilfreich bei der Arbeit an einer komplexen Anwendung, die viele Abfragen erfordert. So können Sie beispielsweise alle Zitate aus Ihrer Anwendung abrufen, indem Sie eingeben:
const quotes = await Quote.all()
Um mit der entsprechenden Konfiguration für Ihre Anwendungsdatenbank fortzufahren, stellen Sie sicher, dass Sie sich immer noch im Stammverzeichnis Ihrer Anwendung befinden und erstellen Sie eine .env
-Datei:
- nano .env
Öffnen Sie die neu erstellte Datei und fügen Sie den folgenden Inhalt hinzu:
HOST=127.0.0.1
PORT=3333
NODE_ENV=development
APP_URL=http://${HOST}:${PORT}
CACHE_VIEWS=false
APP_KEY=bTVOEgUvmTCfkvgrK8gEBC3Qxt1xSYr0
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_USER=sammy
DB_PASSWORD=password
DB_DATABASE=adonis
SESSION_DRIVER=cookie
HASH_DRIVER=bcrypt
Standardmäßig ist die Datenbankverbindung für eine AdonisJs-Anwendung SQLite, die Sie hier auf MySQL aktualisieren werden. Des Weiteren geben Sie den PORT
für die Anwendung, die Anwendungsumgebung und Berechtigungsnachweise für die Datenbank an. Stellen Sie sicher, dass Sie die Platzhalter DB_USER
, DB_PASSWORD
und DB_DATABASE
mit Ihren Berechtigungsnachweisen ersetzen.
Als Nächstes erstellen Sie das Modell und eine Migrationsdatei für Quote
unter Verwendung der Adonis CLI. Führen Sie dazu den folgenden Befehl aus:
- adonis make:model Quote --migration
Sie sehen eine Ausgabe, die der folgenden ähnelt:
Output✔ create app/Models/Quote.js
✔ create database/migrations/1568209992854_quote_schema.js
Dieser Befehl erstellt ein Modell für Quote
im Ordner app/Models
und eine Schemadatei in dem Ordner database/migrations
. Der neu erstellten Schemadatei wird der aktuelle Zeitstempel vorangestellt. Öffnen Sie die Schemadatei mit:
- nano database/migrations/1568209992854_quote_schema.js
Aktualisieren Sie den Inhalt mit dem folgenden Code:
'use strict'
/** @type {import('@adonisjs/lucid/src/Schema')} */
const Schema = use('Schema')
class QuoteSchema extends Schema {
up () {
this.create('quotes', (table) => {
table.increments()
table.integer('user_id').notNullable()
table.string('username', 80).notNullable()
table.string('body').notNullable()
table.timestamps()
})
}
down () {
this.drop('quotes')
}
}
module.exports = QuoteSchema
Eine Schemadatei in AdonisJs erfordert zwei verschiedene Methoden:
up
vorgenommene Änderung rückgängig zu machen.Zusätzlich zu den Feldern timestamps()
und increments()
aktualisieren Sie den Inhalt der Schemadatei mit den Feldattributen user_id
, username
und dem body
eines zu erstellenden Zitats. Die Felder user_id
und username
verweisen auf die Details des Benutzers, der ein bestimmtes Zitat erstellt. Dies definiert eine 1:n-Beziehung und bedeutet, dass ein Benutzer eine unendliche Anzahl von Zitaten besitzen kann, während ein einzelnes Zitat nur einem Benutzer gehören kann.
Speichern und schließen Sie die Datei.
AdonisJs wird standardmäßig mit Modell User
und der zugehörigen Migrationsdatei installiert. Dies erfordert nur eine kleine Änderung, um die Beziehung zwischen dem Modell User
und Quote
herzustellen.
Öffnen Sie das Modell User
in app/Models/User.js
:
- app/Models/User.js
Fügen Sie diese Methode unmittelbar nach der Methode tokens()
hinzu:
...
class User extends Model {
...
tokens () {
return this.hasMany('App/Models/Token')
}
quote () {
return this.hasMany('App/Models/Quote')
}
}
module.exports = User
Dadurch wird eine 1:n-Beziehung mit der Tabelle Quote
unter Verwendung von user_id
als Fremdschlüssel festgelegt.
Speichern und schließen Sie die Datei.
Um diesen Abschnitt abzuschließen, verwenden Sie den folgenden Befehl zur Ausführung von Migrationen, wodurch die Methode up()
aller Migrationsdateien ausgeführt wird:
- adonis migration:run
Sie werden eine Ausgabe sehen, die der folgenden ähnelt:
Outputmigrate: 1503248427885_user.js
migrate: 1503248427886_token.js
migrate: 1568209992854_quote_schema.js
Database migrated successfully in 3.42 s
Sie haben eine Verbindung mit Ihrer Datenbank konfiguriert und gesichert. Des Weiteren haben Sie ein Modell Quote
und die dazugehörige Schemadatei erstellt und eine 1:n-Beziehung zwischen User
und Quote
hergestellt. Als Nächstes generieren Sie die Routen und Controller zur Bearbeitung von HTTP-Anfragen und die Geschäftslogik zum Erstellen, Bearbeiten und Löschen eines inspirierenden Zitats.
In diesem Abschnitt beginnen Sie mit der Erstellung von Controllern, die die gesamte Logik für die Anwendung verarbeiten und diese später an eine bestimmte Route anhängen, damit die Benutzer über eine URL darauf zugreifen können.
Zu Beginn werden Sie mit der Adonis CLI einen neuen HTTP-Request-Controller erstellen, der alle Authentifizierungsprozesse für Ihre Anwendung verarbeiten kann, indem Sie den folgenden Befehl ausführen:
- adonis make:controller Auth --type http
Dieser Befehl erstellt eine Datei AuthController.js
und speichert sie innerhalb des Ordners app/Controllers/Http
. Sie verwenden das Flag --type
, um anzugeben, dass dieser Controller ein HTTP-Controller sein soll.
Sie werden eine Ausgabe sehen, die der folgenden ähnelt:
Output✔ create app/Controllers/Http/AuthController.js
Öffnen Sie als Nächstes die neu erstellte Controller-Datei:
- nano app/Controllers/Http/AuthController.js
Aktualisieren Sie sie mit dem folgenden Inhalt:
'use strict'
const User = use('App/Models/User')
class AuthController {
loginView({ view }) {
return view.render('auth.login')
}
registrationView({ view }) {
return view.render('auth.register')
}
async postLogin({ request, auth, response}) {
await auth.attempt(request.input('email'), request.input('password'))
return response.route('index')
}
async postRegister({ request, session, response }) {
const user = await User.create({
username: request.input('name'),
email: request.input('email'),
password: request.input('password')
})
session.flash({ successmessage: 'User have been created successfully'})
return response.route('login.create');
}
async logout ({ auth, response }) {
await auth.logout()
return response.route('/')
}
}
module.exports = AuthController
In dieser Datei importieren Sie das Modell User
und erstellen dann zwei Methoden namens loginView()
und registerView()
, um die Anmelde- bzw. Registrierungsseite zu rendern. Abschließend erstellen Sie die folgenden asynchronen Methoden:
postLogin()
: Mit dieser Methode erhalten Sie den Wert von email
und password
, die mit Hilfe der in AdonisJs eingebauten Methode request
gepostet wurden, und validieren dann diesen Benutzer anhand der Details in der Datenbank. Wenn ein solcher Benutzer in der Datenbank existiert und den korrekten Berechtigungsnachweis eingegeben hat, wird er zurück auf die Homepage umgeleitet und authentifiziert, bevor er ein neues Zitat erstellen kann. Andernfalls wird eine Meldung angezeigt, die auf den falschen Berechtigungsnachweis hinweist.postRegister()
: Dies erhält den Wert von username
, email
und password
für einen Benutzer, um ein Konto für diesen Benutzer in der Datenbank zu erstellen. Eine Nachricht mit der Angabe, dass dieser Benutzer erfolgreich erstellt wurde, wird an die Sitzung weitergeleitet, und der Benutzer wird auf die Anmeldeseite umgeleitet, um authentifiziert zu werden und mit der Erstellung eines Zitats zu beginnen.logout()
: Diese Methode verarbeitet die Logout-Funktionalität und leitet den Benutzer zurück auf die Homepage.Speichern und schließen Sie die Datei.
Nachdem Sie nun den Controller für die Registrierung und Authentifizierung von Benutzern eingerichtet haben, fahren Sie mit der Erstellung eines HTTP-Request-Controllers für die Verwaltung aller Operationen in Bezug auf Zitate fort.
Führen Sie, zurück im Terminal, den folgenden Befehl aus, um den QuoteController
zu erstellen:
- adonis make:controller Quote --type http --resource
Die Verwendung des Flags --resource
erstellt einen Controller mit vordefinierten kreativen Methoden zur Durchführung von CRUD (Create, Read, Update und Delete)-Operationen.
Sie sehen:
Output✔ create app/Controllers/Http/QuoteController.js
Finden Sie diese Datei innerhalb von app/Controllers/Http/QuoteControllers.js
:
- nano app/Controllers/Http/QuoteController.js
Aktualisieren Sie sie mit dem folgenden Inhalt:
'use strict'
const Quote = use('App/Models/Quote')
class QuoteController {
async index ({ view }) {
const quote = await Quote.all()
return view.render('index', {
quotes: quote.toJSON()
})
}
async create ({ view }) {
return view.render('quotes.create-quote')
}
async store ({ request,auth,session, response }) {
const quote = await Quote.create({
user_id: auth.user.id,
username: auth.user.username,
body: request.input('body')
})
session.flash({ 'successmessage': 'Quote has been created'})
return response.redirect('/')
}
async show ({ params, view }) {
const quote = await Quote.find(params.id)
return view.render('quotes.view-quote', {
quote: quote.toJSON()
})
}
async edit ({ params, view }) {
const quote = await Quote.find(params.id)
return view.render('quotes.edit-quote', {
quote: quote.toJSON()
})
}
async update ({ params, request, response, session }) {
const quote = await Quote.find(params.id)
quote.body = request.input('body')
await quote.save()
session.flash({'successmessage': 'Quote has been updated'})
return response.redirect('/')
}
async destroy ({ params, response, session }) {
const quote = await Quote.find(params.id)
await quote.delete()
session.flash({'successmessage': 'Quote has been deleted'})
return response.redirect('/')
}
}
module.exports = QuoteController
In diesem Controller haben Sie das Modell Quote
importiert und die folgenden Methoden aktualisiert, die automatisch mit AdonisJs CLI erstellt wurden:
index()
: Um alle Zitate aus der Datenbank zu holen und sie auf der Homepage der Anwendung darzustellen.create()
: Um eine Seite zum Erstellen von Zitaten darzustellen.store()
: Um ein neu erstelltes Zitat dauerhaft in der Datenbank zu speichern und eine entsprechende Antwort zurückzugeben.show()
: Um die id
eines bestimmten Zitats zu erhalten, es aus der Datenbank abzurufen und auf der Seite zur Bearbeitung von Zitaten anzuzeigen.edit()
: Um Details eines bestimmten Zitats aus der Datenbank abzurufen und zur Bearbeitung darzustellen.update()
: Um jede Aktualisierung eines Zitats zu verarbeiten und den Benutzer zurück auf die Homepage zu leiten.destroy()
: Um ein bestimmtes Zitat zu löschen und vollständig aus der Datenbank zu entfernen.Speichern und schließen Sie die Datei.
Nachdem Sie alle erforderlichen Controller für diese Anwendung erstellt haben, können Sie nun die Routen so einrichten, dass die Benutzer problemlos mit Ihrer Anwendung interagieren können. Navigieren Sie zu Beginn zu der Datei start/routes.js
:
- nano start/routes.js
Ersetzen Sie den Inhalt mit dem folgenden:
'use strict'
const Route = use('Route')
Route.get('/','QuoteController.index').as('index')
Route.get('/register','AuthController.registrationView').as('register.create')
Route.post('/register-store','AuthController.postRegister').as('register.store').validator('Register')
Route.get('/login','AuthController.loginView').as('login.create')
Route.post('/login-store','AuthController.postLogin').as('login.store')
Route.get('/view-quote/:id','QuoteController.show').as('view.quote')
Route.group(() => {
Route.get('/create-quote','QuoteController.create').as('create.quote')
Route.post('/store-quote','QuoteController.store').as('store.quote')
Route.get('/edit-quote/:id','QuoteController.edit').as('edit.quote')
Route.post('/update-quote/:id','QuoteController.update').as('update.quote')
Route.get('/delete-quote/:id','QuoteController.destroy').as('delete.quote')
Route.post('/logout','AuthController.logout').as('logout')
}).middleware(['auth'])
Hier definieren Sie den Pfad für jede Route in Ihrer Anwendung, geben die HTTP-Verben für jede Aktion an und binden die Route an eine bestimmte Methode in jedem Controller. Außerdem benennen Sie jede dieser Routen so, wie sie in den Controllern und Ansichten referenziert wurden.
Um sicherzustellen, dass nur authentifizierte Benutzer auf alle Zitatrouten zugreifen können, ordnen Sie eine Gruppe namens Middleware zu. Schließlich hängen Sie eine Validierer-Methode an die Route register.store
an, um die Benutzereingaben zu validieren.
Speichern und schließen Sie die Datei.
Sie haben Ihre Controller erstellt und die Routen für Ihre Anwendung eingerichtet. Als Nächstes erstellen Sie die in diesem Schritt definierte Validierer-Methode.
Standardmäßig verfügt AdonisJs nicht über integrierte Validierer. Daher müssen Sie den Validierer für Ihre Anwendung manuell installieren und registrieren.
Führen Sie den folgenden Befehl aus, um ihn zu installieren:
- adonis install @adonisjs/validator
Öffnen Sie die folgende Datei, um den Anbieter des Validieres (Validator Provider) zu registrieren:
- nano start/app.js
Registrieren Sie dann den Anbieter des Validieres, indem Sie ihn an die Liste der Anbieter anhängen, wie nachfolgend gezeigt:
...
const providers = [
...
'@adonisjs/cors/providers/CorsProvider',
'@adonisjs/shield/providers/ShieldProvider',
'@adonisjs/session/providers/SessionProvider',
'@adonisjs/auth/providers/AuthProvider',
'@adonisjs/validator/providers/ValidatorProvider'
]
Nachdem Sie den Anbieter des Validieres innerhalb Ihrer Anwendung installiert und registriert haben, erstellen Sie nun mit dem folgenden Befehl einen benutzerdefinierten Validierer, um die Eingabe des Benutzers während der Registrierung zu validieren:
- adonis make:validator Register
Dadurch wird eine Datei Register.js
im Verzeichnis App/Validators
erstellt. Öffnen Sie die Datei mit:
- nano app/Validators/Register.js
Fügen Sie den folgenden Code zur Datei hinzu:
'use strict'
class Register {
get rules () {
return {
name:'required',
email:'required|email|unique:users',
password:'required|min:8'
}
}
get messages(){
return{
'name.required':'Full name is required',
'email.required':'email is required',
'email.unique':'email already exists',
'password.required':'password is required',
'password.min':'password should be at least 8 characters'
}
}
}
module.exports = Register
In Ihrer Anwendung definieren Sie Regeln für bestimmte Felder. Wenn Validierungen zu einem beliebigen Zeitpunkt fehlschlagen, setzt der Validierer den Fehler automatisch als Flash-Meldung und der Benutzer wird zurück zum Formular geleitet.
Speichern und schließen Sie die Datei, sobald Sie die Bearbeitung abgeschlossen haben.
Um Ihrer Anwendung ein Design hinzuzufügen, öffnen Sie schließlich die folgende Datei:
- nano public/style.css
Ersetzen Sie die Inhalte mit dem folgenden:
@import url('https://fonts.googleapis.com/css?family=Montserrat:300');
html, body {
height: 100%;
width: 100%;
}
body {
font-family: 'Montserrat', sans-serif;
font-weight: 300;
background-image: url("/splash.png");
background-color: #220052;
}
* {
margin: 0;
padding: 0;
}
a {
color: inherit;
text-decoration: underline;
}
p {
margin: 0.83rem 0;
}
.quote-wrapper {
margin-top: 20px;
}
.quote-wrapper a {
text-decoration: none;
}
.quote-wrapper a:hover {
color: #ffffff;
}
.empty-quote {
color: #ffffff;
}
form {
padding: 20px;
}
In dieser Datei aktualisieren Sie das CSS-Design Ihrer Anwendung in der Datei style.css
.
Sie haben einen Anbieter eines Validieres installiert und registriert, um die Eingabe von Benutzern während des Registrierungsvorgangs zu überprüfen. Des Weiteren haben Sie den Inhalt Ihres Stylesheets aktualisiert, um der Anwendung mehr Design hinzuzufügen. Im letzten Schritt testen Sie Ihre Anwendung.
In diesem Schritt stellen Sie Ihre Anwendung bereit und erstellen einen Benutzer und ein Passwort zum Testen der Authentifizierung. Außerdem fügen Sie Ihrer Anwendung ein Zitate hinzu und zeigen es auf der Homepage an.
Um Ihre Anwendung zu testen, starten Sie den Entwicklungsserver mit dem folgenden Befehl aus dem Stammverzeichnis Ihrer Anwendung:
- adonis serve --dev
Dadurch wird die Anwendung auf dem innerhalb der Stammdatei .env
definierten Port, 3333
, gestartet. Navigieren Sie in Ihrem Browser zu http://localhost:3333.
Die Homepage ist zur Zeit leer, da Sie keine Zitate erstellt haben. Klicken Sie auf die Schaltfläche Register.
Geben Sie Ihre Informationen ein und klicken Sie auf die Schaltfläche Submit, um den Registrierungsvorgang abzuschließen. Sie werden auf die Anmeldeseite umgeleitet. Geben Sie Ihre E-Mail-Adresse und Ihr Passwort für die Authentifizierung ein.
Nachdem Sie authentifiziert sind, klicken Sie auf die Schaltfläche Create Quote.
Geben Sie ein Zitat ein und navigieren Sie zu der Seite View all, um Ihr Zitat anzuzeigen.
Sie haben Ihre Anwendung getestet, indem Sie einen Benutzer erstellt und authentifiziert und anschließend ein Zitat verfasst haben.
In diesem Tutorial haben Sie eine Webanwendung mit AdonisJs erstellt. Sie haben die Anwendung unter Verwendung der AdonisJs CLI eingerichtet und die CLI zum Erstellen anderer relevanter Dateien wie Controller, Modelle und Ansichten verwendet.
Sie können Webanwendungen mit diesem Framework unabhängig von Ihrer Größe und Komplexität erstellen. Sie können den Quellcode für dieses Projekt hier auf GitHub herunterladen. Um weitere Funktionen zu erkunden, können Sie auch die offizielle Dokumentation besuchen.
Wenn Sie einige unserer anderen JavaScript-Framework-Tutorials erkunden möchten, sehen Sie sich Folgendes an:
Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.
This textbox defaults to using Markdown to format your answer.
You can type !ref in this text area to quickly search our full set of tutorials, documentation & marketplace offerings and insert the link!
Sign up for Infrastructure as a Newsletter.
Working on improving health and education, reducing inequality, and spurring economic growth? We'd like to help.
Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.