Transkripte
1. Einführung in den Kurs: Sind Sie ein Flutter-Entwickler ,
der Ihre
Fähigkeiten auf die nächste Stufe heben möchte kein
GAS-Backend für Flatter-Anfänger
einführen Der ultimative Leitfaden
Debt führt Sie in die Welt der
Erstellung benutzerdefinierter Backends In diesem Kurs
lernen Sie, wie Sie
mithilfe der neuen GS- und Mongo-DBs
leistungsstarke Backend-Systeme aufbauen , sich von
den Beschränkungen der
Firebase
befreien und
teure Herstellerbindungen vermeiden. Vom Schreiben von Servercode über die
Beherrschung der Cred-Operationen bis hin zur Bereitstellung
mit der Railway-App werden
Sie praktische
Erfahrung in der Erstellung einer benutzerdefinierten
Backend-Architektur sammeln ,
indem Sie am Ende des Kurses
eine grundlegende Anwendung
entwickeln des Kurses
eine grundlegende Anwendung Um ein reibungsloses
State-Management zu gewährleisten, werden
wir außerdem das beliebte
Provider-Paket verwenden Dieser Kurs wird Ihnen
auf jeden Fall helfen, den meisten
Entwicklern einen Schritt voraus zu den meisten
Entwicklern einen Schritt voraus , die nicht wissen, wie man ein
eigenes Backend erstellt und nur auf Fireways angewiesen sind Also ohne noch mehr
Zeit zu verschwenden. Lass uns anfangen
2. Ein Node-js-Projekt einrichten: Hallo. Willkommen zum
allerersten Video des Kurses, in dem wir lernen, wie man mit
No JS und Mongo DV ein benutzerdefiniertes Back-In für
unsere flachere Anwendung
erstellt No JS und Mongo DV ein benutzerdefiniertes Back-In für
unsere flachere Als Erstes müssen
wir also kein GS in Ihrem System
installieren Gehen Sie also zu Ihrem Browser
und geben Sie nos.org ein. Und von hier aus können Sie es einfach
herunterladen und installieren. Ich verwende ein Max-System, aber wenn Sie in Windows sind, können
Sie
es einfach über Downloads und
Windows Installer ändern . Wie Sie sehen können, werde
ich einfach V schreiben und ich habe die Version. Wenn Sie also nach der Installation diese Version in
Ihrer Befehlszeile
sehen können , bedeutet
das, dass Sie sie
erfolgreich installiert haben. Und NPM wird automatisch ohne Jaz
installiert, sodass wir uns darüber keine
Gedanken machen müssen Wenn ich die NPM-Version schreibe. Also habe ich auch NPM. Nach der Installation von Node JS müssen
wir
ein Node-JS-Projekt erstellen Gehen Sie also in Ihr gewünschtes Verzeichnis
und erstellen Sie einen neuen Ordner. Ich werde es Nodes App nennen. Erstellen Sie in der Nodes-App einen weiteren Ordner und nennen Sie ihn Backend. In diesem Ordner wird der gesamte
serverseitige Code vorhanden sein. Und später werden wir einen weiteren Ordner
namens Frontend
erstellen, der aus
dem
gesamten Flatter-Code bestehen wird Jetzt brauchen wir also einen
Einstiegspunkt für unseren Server. Genau wie in Flutter ist
es die Hauptpunktdatei also im Backend-Ordner Erstellen Sie also im Backend-Ordner eine neue JS-Datei, und es wird eine Datei sein die ich einfach im VS-Code
öffnen werde Ordner öffnen. Hier öffne ich dieses Backend und hier werde ich
einen neuen Dateiserver erstellen. So wie das. Wenn du willst, kannst
du es auch Index
Do Chase nennen, aber ich nenne
es nur Server Do Chase. Öffnen Sie nun ein neues Terminal in
diesem Backend-Ordner und initialisieren Sie NPM, indem Sie NPM in Y
eingeben. So initialisieren Sie hier
ein Sie können sehen, dass die Haupteintragsdatei Server Dot S
ist. Aber wenn Sie die
Server-Punkt-JS-Datei nicht erstellt hätten, hätte sie das S als Hauptdatei
verwendet Und alle Pakete oder externen Abhängigkeiten
werden in dieser Datei angezeigt. Wenn wir nun
über Pakete sprechen, ist
das erste Paket, das wir benötigen, das Express-Paket. Express JS ist ein Framework
, das zusätzlich zur
Net
JS-Webserver-Funktionalität arbeitet , um
die APIs zu vereinfachen und
hilfreiche neue Funktionen hinzuzufügen. Es macht es einfacher, die Funktionalität
unserer Anwendungen
mit Middleware und Routing zu organisieren Funktionalität
unserer Anwendungen . Also hier im
Back-End-Pool im Terminal simp NPM Sie können auch auf npmjsen.com gehen
und dort
auch nach
dem Express-Paket suchen, und dort
auch nach
dem Express-Paket suchen wenn Sie mehr darüber erfahren möchten Wie Sie
in den Abhängigkeiten sehen können,
habe ich das habe ich Lassen Sie uns jetzt
einen Express-Server erstellen. Zunächst müssen wir
unserem Projekt mitteilen , dass wir Express verwenden
werden. Lassen Sie uns importieren oder Sie können sagen, dass das
Express-Paket oben
benötigen. Schreiben Sie einfach const Express is to re express, und dann
müssen wir eine Instanz oder ein
Objekt des Express erstellen Ich gebe den Namen App. Dies ist ein Standardprozess, und dann werde ich den
Code zum Starten des Servers schreiben. Das heißt, ich höre
es mir im dritten Pot und
wenn es erfolgreich ist, werde
ich es in der Konsole protokollieren. Das Konsolenprotokoll finden Sie hier. Ich werde einfach einen Server schreiben, der auf Port 3.000
läuft. Okay, speichern Sie es. Und dann versuche den Server
laufen zu lassen,
indem du den Terminalknoten
und den finalen
Nameserver eingibst und ihn dir präsentiert. Sehen Sie, dass der Server
dort läuft, dass unser Server läuft. Wenn Sie zu Ihrem Browser gehen
und Local Host 3.000 eingeben. Hier können Sie also sehen, dass kein Schrägstrich abgerufen werden
kann. Das ist die Heimatroute. Aber zumindest wird kein anderer Fehler
angezeigt,
das heißt, dass die Seite keine Antwort ist oder der Server so
nicht verfügbar ist. Dies bedeutet, dass
der Server erfolgreich läuft. Im nächsten Video werden
wir einige
Routen für unseren Server erstellen. Danke.
3. Routen erstellen: Hallo. Willkommen zurück. Lassen Sie uns nun einige Daten
in der 3.000-Route des lokalen Hosts ausgeben . Dafür müssen wir GT-Anfrage
für die Slash-Route
konfigurieren Gehen wir zu unserem Code
hier oben App Listen. Ich werde App GT schreiben. Und dann welche Route wir wollen. Wir wollen die Slash-Route. Und wann immer die
Slash-Route aufgerufen wird, wollen
wir, dass diese Funktion ausgeführt
wird Antwort anfordern. Es gibt uns Anfrage
und Antwort. Das sind also die Grundlagen
von Express Framework. Also musst du es wissen. Oder Sie können einfach die Anwendung erstellen
und irgendwann verstehen Sie die
Konzepte. Also hier kannst du
es einfach verstehen. Die Anfrage ist das, was wir vom
Frontend an den Server gesendet haben. Nehmen wir also an, eine Person sendet
einige E-Mail-Passwortdaten. Also werden wir
diese Informationen
über diese Anforderungsvariable abrufen über diese Anforderungsvariable Was auch immer
wir vom Frontend senden, wir können die Anfrage
aufnehmen Und in ähnlicher Weise senden
wir die Antwort vom Server
an das Frontend. Das ist natürlich der Fall, wenn das Fronten
nach irgendwelchen Daten fragt Wir werden es mit
dieser Antwortvariablen senden. Also hier schreiben wir
Antwort Punkt Senden. Und das ist die Homepage. Das sind vorerst nur
Dummy-Daten. Offensichtlich werden wir
Daten nicht direkt im
Zeichenkettenformat senden Daten nicht direkt im
Zeichenkettenformat Nur damit du es verstehst. Jetzt müssen wir den Server stoppen, also einfach C kontrollieren und ihn dann wieder starten
, damit der Code aktualisiert wird. Wenn ich jetzt C aktualisiere, ist
das die Startseite. Das heißt unser Schrägstrich. Immer wenn wir zu unserem
lokalen Hos Fit Hus Slash gehen, erhalten
wir diese Antwort Aber wenn wir zu einem
anderen ähnlichen Knoten gehen, wir natürlich keine Knoten bekommen Lassen Sie uns nun
die Route für Notizen erstellen. Da es
sich bei unserer Anwendung um eine Knotenanwendung handeln wird, müssen
wir eine
Route für die Knoten erstellen. Blow d ist die Heimatroute, dann
hol dir hier Schrägstrichnotizen Dann wiederum
wird eine Funktion als
Anfrage Antwort
Anfrage Antwort aufgerufen Anfrage Antwort
Anfrage Antwort und ich werde Antwort
senden Dies ist die Seite mit den Notizen. Speichern Sie es. Gehen Sie erneut und stoppen Sie den Server. Ich habe es gespeichert und
starte es erneut. Wenn ich jetzt zur
Slash-Notizen-Route gehe, siehst du, das ist die Notizen-Seite Und wenn ich einfach zu Slash gehe, dann ist das die Startseite So
erstellt man also Routen. Und vergewissere dich, dass ich verstehe
, dass das für die GT-Strecken ist. Es gibt eine andere
Art von Anfragen
, nämlich G-Posts wie diesen, du wirst es verstehen, aber das ist die grundlegende, das ist die GT-Anfrage. Im nächsten Video werden
wir an der Einrichtung der
Mongo DB-Datenbank arbeiten.
4. MongoDB-Atlas einrichten: Hallo, willkommen zurück. Lassen Sie uns nun unsere
Mongo-DB-Datenbank einrichten. Dafür werden wir den Atlas
Cloud-Dienst verwenden. Öffnen Sie einfach Ihren Browser
und gehen Sie zu Mongo DB Atlas. Hier klicken Sie dann
auf den ersten Link. Dann melde dich an oder registriere dich
mit deinem Google-Konto. Ich habe bereits ein Konto, also melde ich mich einfach an. Wenn Sie ein neuer Benutzer sind, können
Sie
Ihrer Organisation einen beliebigen Namen geben und die Mongo DB Atlas-Optionen auswählen Da ich mich gerade
anmelde, werde ich diese Dinge nicht sehen, aber in Ihrem Fall wird nur der
Name Ihrer Organisation angegeben Und dann wählen Sie die Option
Mongo Atlas. Jetzt, nachdem ich mich angemeldet habe
, habe ich diese Organisation
mit dem Namen Rahul Agrawal Und wenn Sie auf dieser Seite sind, müssen
Sie als Erstes ein neues Projekt
erstellen Also, ich habe dieses Projekt bereits, aber in Ihrem Dashboard werden
Sie diesen
Projektnamen offensichtlich nicht sehen. Klicken Sie also einfach auf Neues Projekt
erstellen. Und hier, gib ihm
einen Projektnamen. Ich werde eine Notizen-App schreiben. Dann klicken Sie auf Weiter. Hier
erstellt der Projekteigentümer ein Projekt. Und nachdem das
Projekt erstellt wurde, müssen
wir eine Datenbank erstellen.
Klicken Sie einfach darauf. Wählen Sie dann den freien
Reifen aus, der Null ist. Natürlich können Sie
sich später für
Server und
solche Dinge entscheiden . Dann ist der Anbieter AWS und
die Region liegt in Ihrer Nähe. Also wähle einfach,
wo auch immer du wohnst. Und Sie können
Ihren Clusternamen angeben. Ich werde es einfach als Standard belassen. Es ist Cluster Null. Und klicken Sie auf Erstellen. Die It's Caps und so. Motorrad. Danach
geben wir den letzten Schliff. Danach müssen Sie einen Benutzernamen und ein Passwort
erstellen. Merken Sie sich einfach diese Details. Ich werde vorerst ein sehr
einfaches Passwort verwenden. Ich werde es mir merken.
Klicken Sie auf Create er. Sie dann, wo Sie von der
Cloud-Umgebung aus
eine Verbindung herstellen möchten Wählen Sie dann, wo Sie von der
Cloud-Umgebung aus
eine Verbindung herstellen möchten, dies aus. Und dann habe ich schon
meine IP-Adresse. Ich füge einfach meine
aktuelle IP-Adresse hinzu. Also habe ich meine IP hier. Und dann einfach fertig stellen und
schließen und zu Tababase gehen. M. Okay. Der nächste Schritt besteht nun darin, den Zugriff von überall aus zu
ermöglichen. Wie Sie sehen,
geben wir unsere IP-Adresse an, was bedeutet, dass nur dieses
System für diesen Server
zugänglich ist. Wir möchten jedoch, dass andere
unsere Anwendung auch im wirklichen Leben verwenden. Gehen Sie hier zum Netzwerkzugriff, klicken Sie auf IP-Adresse hinzufügen und dann auf
Zugriff überall zulassen. S und dann bestätigen. Es befindet sich in einem abhängigen Status. Es dauert einige Zeit. Wir stellen Ihre Änderungen aktuellen Aktion
zur Konfiguration von Mongo Wie Sie sagen können, dauert
es einige Zeit. Es ist in Ordnung. Lass uns das nach
ein paar Minuten sagen , bevor wir einen VS-Code öffnen. Und natürlich müssen wir diesen Knoten mit Mongo dV
verbinden. Dafür werden wir
ein anderes Paket verwenden, das als Mo bekannt ist. In diesem Terminal werde ich es
einfach beenden und
NPM install Mo schreiben und die Eingabetaste drücken In dem Serve-Paket
, das Jason eingereicht hat, können
Sie sehen, dass Mongos da ist Und ich glaube, unsere Datenbank
ist auch konfiguriert. Im nächsten Video werden
wir also die
Verbindung zwischen
der NA und dieser
Datenbank herstellen. Danke.
5. Die Node-App mit MongoDB verbinden: I. Im nächsten Schritt benötigen
wir eine
Verbindungszeichenfolge, um unsere App mit der
Mongo DV-Datenbank zu
verbinden Gehen Sie dazu zum
letzten Dashboard und klicken Sie hier auf die
Schaltfläche Mit dem Cluster verbinden Also hier, klicken Sie einfach auf Verbinden. Dann gibt es viele Möglichkeiten. Ich werde Mongo
DB für VS-Code wählen. Und dann kopiere einfach
diese Verbindungszeichenfolge. Wir werden das Passwort
durch unser eigenes Passwort ersetzen. Öffnen Sie den VS-Code und stellen
wir auf dem Server eine Verbindung her. Sie einfach zunächst das
Mongoose-Paket Mongoose, Importieren Sie einfach zunächst das
Mongoose-Paket Mongoose, das Mongoose benötigt . Dann schreibe mongoose connect. Hier müssen wir die Zeichenfolge angeben. Das ist die Verbindungszeichenfolge. Und einfach das
Passwort ersetzen und auch
dieses entfernen als weniger, als einfach das Passwort zu
schreiben. Ich habe es 12345 gegeben. Und am Ende werde
ich auch den
Datenbanknamen schreiben Das ist Nodes DV. Das war nur ein Cluster, und das ist der Datenbankname Knoten DV. Und wenn die
Verbindung erfolgreich ist,
werde
ich diese Funktion auslösen. werde
ich diese Funktion auslösen Welches wird alle Routen haben. Das heißt, ich werde
sicherstellen, dass Routen nur zugänglich
sind, wenn die
Verbindung erfolgreich ist. Ich schneide einfach
alle Routen innerhalb
der Mongoose-Verbindung aus und füge alle Routen innerhalb
der Mongoose-Verbindung Und dieser Appleion
wird draußen sein. Dann brauchen wir ein Tool,
um die APIs zu testen. Um Crud-Operationen
auf einem Server oder einer Datenbank durchzuführen, benötigen
wir einen Client oder ein Frontend Im Moment haben wir
die Flatter-Anwendung nicht. Um also gefälschte Anfragen zu simulieren oder zu
senden, werden
wir Postman verwenden, um die
API zu testen Gehen Sie also einfach in einen
Browser und schreiben Sie einfach Postman und dann hier, ich habe dieses Setup bereits,
aber stellen Sie sicher, dass Sie
ein Konto erstellen und die Software
herunterladen Ich habe diesen Postboten
hier schon installiert. Viele frühere Routen. hier
zunächst Ihren Server erneut. Der Server läuft. Das heißt, ich schätze, es gibt
keinen Fehler mit dem Mongo. Lass uns eine G-Anfrage senden. Dies ist die Get-Anfrage, und ich schreibe HTTP dann
3.000 Schrägstriche für den lokalen Host. Und wenn ich hier eine GT-Anfrage sende, sehen Sie, das ist die Notizen-Seite. Das bedeutet, dass unsere Antwort
da ist und der Server
einwandfrei funktioniert. Und dieser Postbote
ist sehr notwendig. Ich hoffe du hast es auch
installiert. Bevor wir etwas
anderes tun, müssen wir bis jetzt, wann immer wir
Änderungen am Code vornehmen, den
Server stoppen und erneut starten. Das ist keine gute
Entwicklungserfahrung. Um dieses Problem zu lösen, werden wir
ein Paket namens Nudmon verwenden. Es ermöglicht eine
Live-Aktualisierung des Servers. diesem Fall nehmen wir
Änderungen vor und speichern sie Der Server
selbst wird neu gestartet und die Änderungen werden übernommen. Stoppen Sie erneut den
Server und schreiben Sie NPM install global node
M. Binden Sie also diesen Code Wir werden dieses
Paket global
im System installieren , sodass
Sie
es
in zukünftigen Projekten nicht immer wieder neu installieren müssen Drücken Sie also einfach die Eingabetaste. Ich habe Node Ml bereits global
installiert. Das wird
es also in Ihrem System installieren. Und danach
erstellen Sie in
der Paket-JS-Datei ein neues Skript. Sie unten einfach D
und schreiben Sie das Skript
nodemon server do chase Dies ist nur in
der Entwicklungsphase der Fall. Auf dem Live-Server wird der
Node-Server
automatisch auf die Jagd genommen. Speichern Sie es. Von nun an werden
wir NPM run Dv schreiben
und sehen, wie der Nod
Mon-Server gestartet ist Das bedeutet also, dass die
Entwicklungserfahrung von nun an ein bisschen besser sein
wird Das war's für dieses Video. Im nächsten Video
werden wir anfangen, Modelle für
uns zu
erstellen. Danke.
6. Notenmodell erstellen: Hallo. Willkommen zurück. Bevor ich weitermache, möchte
ich
unser Projekt auf organisierte Weise in Dateien und
Ordnern strukturieren . Zuallererst werde
ich den Server stoppen. Dann werde
ich im Backend-Ordner einen neuen
Ordner namens SRC erstellen Und verschiebe die
Server-Punkt-JS-Datei in den Ordner *** Jetzt muss ich auch
in der
SN-Datei einige Änderungen im Paket vornehmen. Hier. Wenn ich
das Startskript mache, schreibe
ich den
Quell-SLA-Server für JS und
auch in den Nodemon Das ist
auch D-Skript , weil sich die Datei
nicht im Stammverzeichnis befindet Das ist es also. Lassen Sie uns nun einige Modelle
erstellen. Für unsere Knotendaten. Modelle sind die Struktur
aller Daten in unserer Anwendung. Wir werden diese Datenstruktur
in unserer Mongo DB-Datenbank speichern in unserer Mongo DB-Datenbank Mongoose hilft beim Speichern
der Daten und beim Erstellen von Modellen Außerdem können wir dieses Modell verwenden, um Crowd-Operationen
in der Datenbank
durchzuführen Diese sind also alle mit
dem Mongoose-Paket verbunden. Also musst du
die Grundlagen kennen. Erstellen Sie in einem Ordner einen neuen
Ordner und nennen Sie ihn Models. Erstellen Sie im Modell
eine neue JS-Datei. Beachten Sie Js wie folgt. Okay. Nun gibt es einige Schritte zum Erstellen
eines Modells. Der erste Schritt besteht darin,
das Mongoose-Paket zu benötigen. Als allererstes benötigen wir das
Mongoose-Paket. Dann müssen wir das Schema definieren. Das sind Details der Daten. In unseren Knotendaten wird
es einen
ID-Titelinhalt wie diesen haben. Welche Füllungen sind in diesen Daten
gespeichert? Lassen Sie uns ein const-Schema erstellen das dem Mongo-Schema entspricht Hier haben wir die Klammer. Die erste Füllung wird ID sein, und jetzt geht Typ, wird Zeichenfolge sein, unique ist wahr, das heißt alles, die ID sollte eindeutig und erforderlich
sein. Das heißt, dieses Feld ist erforderlich und darf
in der Datenbank nicht leer gelassen werden. Dann ist das nächste die Benutzer-ID, Typ ist st und re ist wahr. Weil der Benutzer natürlich mehrere Knoten haben
kann, sodass die Benutzer-ID nicht eindeutig sein kann. Dann Titel,
der Titel des Knotentyps Zeichenfolge
re ist , dann
hat er den
Inhaltstyp Zeichenfolge. Das heißt, es ist nicht erforderlich. Schließlich haben wir hinzugefügt. Sein Typ wird sein. So und standardmäßig
wird das jetzt gelehrt. Wenn keine Daten angegeben werden,
ist die Standardeinstellung vorhanden. Also haben wir die Mongos importiert. Wir haben ein Schema definiert. Jetzt müssen wir ein Modell erstellen. Dafür müssen wir
einen Modellnamen und ein Schema angeben. Schreiben Sie also einfach
Mongos Punktmodell. Der Modellname wird Node sein und das Schema ist Note Schema Der letzte Schritt besteht darin, das Modell zu
exportieren. Einfach zu Beginn dieses
Modells entsprechen die Exporte von
Schreibmodulen dem Mongoose-Modell Wie Sie sehen können, ist dies das
Code-Vier-Stunden-Node-Modell. Ich hoffe, Sie haben die Konzepte so gut verstanden,
wie Sie sie kennen. Denn dies ist offensichtlich das Konzept von Mongos
Paket und auch von Mongo DB Das ist es also. In den
kommenden Videos werden
wir auch einige
neue Routen erstellen. Danke.
7. Route zum Hinzufügen von Notizen: Hallo, verwenden wir das
Notizmodell, um
alle Notizen in der Datenbank abzurufen alle Notizen in der Datenbank und als JCN-Antwort zu senden Also werde
ich in der Server-JS-Datei diese
Schrägstrichnotizen in eine SNS-Do-Liste ändern Und hier werde ich R
schreiben. Ganz am
Anfang, ganz oben, muss
ich das Modell benötigen Schreibt einfach, dass der Knoten
dem Knoten des Re-Modells entspricht . Dann werde ich hier schreiben,
dass Knoten einem Knoten in Ordnung entsprechen. Das heißt, alle
Knoten aus der Datenbank holen, und es ist eine
synchrone Funktion, also müssen wir sie synchronisieren Und dann werde
ich in der Antwort nur Res JS
und Notizen schicken Ich setze diese Notizen nicht
in Klammern, da diese Notizen automatisch im
JCN-Format vorliegen Ich werde es speichern und auf dem Server laufen lassen. Und wenn ich zu diesem Endpunkt gehe, ist
das die Notizliste. Dann sehe ich, dass ich
ein leeres Array bekomme. Das bedeutet, dass
natürlich
keine Notizen eingefügt wurden, aber
es liegt kein Fehler vor. Lassen Sie uns nun eine Route
zum Hinzufügen einer Notiz erstellen. Sie unter dieser Listenroute Erstellen Sie unter dieser Listenroute eine GT-Route für die Anzeige now app.gs notes Es wird eine Synchronisierungsfunktion sein. Antwort anfordern. Jetzt müssen wir eine
Instanz des Knotenmodells erstellen. Für diesen neuen Knoten entspricht das also einer neuen Knoteninstanz. Da Sie wissen, welche Daten getestet werden, wird eine ID benötigt. Ich werde die Daten vorerst codieren. Später werden wir
diese Route so ändern, dass sie sowohl vom Benutzer veröffentlicht
als auch vom Benutzer gelesen wird. Ich schreibe einfach 0001, dann wird die Benutzer-ID
rahle atmail.com sein, dann ist der Titel zuerst
die persönliche Notiz und der Inhalt ist, das ist Wenn wir diese
Knoteninstanz mit den Daten haben, müssen
wir die
Modelldaten in der Datenbank speichern Und das ist sehr einfach. Verwenden Sie einfach diese neue
Notizvariable und geben Sie Speichern ein. Das ist es. Dieser Code speichert
diese Daten in der Datenbank. Wie Sie sehen können,
macht es Mongo sehr einfach. Erstellen Sie dann eine
Antwortvariable im CN-Format, und ich sende eine Nachricht, dass ein
neuer Knoten erstellt wurde Am Ende werde ich einfach
Response No Jason schreiben und diese
Antwortvariable so senden. Das ist es. Speichern Sie es. Lassen Sie uns nun diese API testen. Der APA-Endpunkt
besteht aus Knoten und Knoten. Flash und C-Nachricht, eine neue Notiz wird erstellt, und ich werde, wenn ich jetzt die
Liste L schreibe , schauen wir mal ich denke, weil ich weiß,
was der Fehler ist. Ja. Ich muss diese Dinge
ändern. Wenn ich jetzt auflisten gehe, dann sehe
ich, ich habe diese, in die ich die ID
eingefügt habe, den Titel der Benutzer-ID. Weil es nicht eindeutig war, gab
es einen Fehler. Wie dem auch sei, wir werden solche Werte nicht fest
codieren. Aber wie Sie sehen können, werden
Daten eingefügt. Wenn ich auch das hinzufüge
und dann mit der dritten ID eine andere
Benutzer-ID verwende, John, und das wird meine
erste Dummy-Notiz wie diese sein, und wenn er auch Hinzufügen schreibt,
in diesem Fall,
wenn ich Liste schreibe,
dann sind alle drei
Notizen da in diesem Fall, wenn ich Liste schreibe, dann sind alle drei
Notizen Das ist Johns und ich
habe Johns drei, vier K. Offensichtlich wurde auch der
letzte eingefügt. Wie gesagt, dieser Schrägstrich
enthält etwas, das ich
vielleicht zweimal eingegeben hätte, als wir Das ist die Sache.
Aber es ist in Ordnung. Die API funktioniert perfekt. Im nächsten Video werden
wir also an der Route arbeiten, um Notizen nur anhand der Benutzer-ID Natürlich
möchten wir nicht, dass
in dieser Liste alle Notizen aller
Benutzer abgerufen werden Ich möchte nicht, dass andere Benutzer
den Beitrag des anderen sehen. Ich kann auch sehen, dass ich diese
Art von Milbe habe, es ist in Ordnung. Speichere es einfach. Und das war's für dieses
Video. Danke.
8. Notizen nach Benutzer-ID erhalten: Hallo. Willkommen zurück. Wie Sie sehen können, können
wir alle Notizen in der Liste
der Schrägstrichknoten abrufen Aber natürlich möchten wir, dass
nur der Benutzer seine eigenen
Daten in der Anwendung sehen
kann Dafür
übergeben wir beim
Aufrufen der Route die Benutzer-ID
als Parameter. Lassen Sie uns also diese Route ändern
, die hinter dieser Liste steht Ich akzeptiere eine
Benutzer-ID-Variable. Das heißt,
wenn diese Route aufgerufen
wird, muss die Person diese Daten
senden. Und dann werde ich diese
Daten verwenden, um den Fund zu filtern. Das ist hier, ich
werde einfach filtern, wo Benutzer-ID der
Anfrage von PMs nach Benutzer-ID entspricht Das heißt, das ist ein
Parameter, das ist PMs. Auf diese Weise werden also nur die Knoten dieses
bestimmten Benutzers angezeigt Also lass es uns testen. Ja, ich werde dafür einfach
Postman benutzen. Jetzt schreibe ich einfach
rah auf Gmail.com. Das ist eine Benutzer-ID. Ich
habe diese GAT-Anfrage. Wenn ich es sende, dann sehe ich
nur die beiden Daten, die mir gehören, jetzt angezeigt werden. Das bedeutet also, dass das perfekt
funktioniert. Als Nächstes müssen
wir
ein Paket installieren, denn wenn wir Daten per Post-Anfrage
senden, kann
unser Node-Server
sie standardmäßig nicht verstehen. Nehmen wir an, dass wir hier ,
wenn wir die
Post-Anfragen und im Hauptteil ausführen, die
Knotendaten senden, weil wir
hier natürlich nur die Knotendaten fest
codieren, aber später werden wir diese Informationen
vom Benutzer
abfragen. Und in diesem Fall müssen
wir
sicherstellen, dass unser Server diese Daten verstehen
kann. Dafür werden wir das
Body-Passer-Paket verwenden. Also werde ich einfach Control
C benutzen, um meinen Server zu stoppen und NPM install body
passer so zu
schreiben Es konvertiert die JC-Daten, die wir
vom Frontend senden und macht sie für unseren Server
lesbar Das ist es. Und damit es funktioniert. Wir müssen es
als Middleware verwenden. Hier oben. Zuallererst
importiere ich es, dass Body-Parser gleich Require ist, und dann
den Body-Parser Danach muss ich
App E Body Parcel URL codiert schreiben ,
erweitert ist gleich false, erweitert ist gleich false, und dann muss ich App
Dot Use Body Parser, Jason, verwenden Hier ist extended falsch. Da wir keine
verschachtelten Daten im Körper senden werden. Der Schlüssel wird keine
JCN-Daten als Werte enthalten. Das heißt, wie Sie hier sehen können, sind
alle Daten und alle Werte nur einfache Zeichenketten Aber nehmen wir an, wir haben
irgendeine Art von Tags, und es wird eine
Reihe von Zeichenketten sein. In diesem Fall müssen Sie es wahr und erweitert
machen. Also, wie Sie sehen können, und dann wird
diese Zeile
einfach die
JN-Daten so konvertieren, dass sie lesbar sind. Das ist jetzt, lass uns an unserer Route zum
Hinzufügen von Notizen arbeiten. Zuvor haben wir eine Route
zum Hinzufügen einer Notiz erstellt, aber es wurden nur solche
Dummy-Daten gespeichert Lassen Sie uns nun daran arbeiten,
sodass wir Daten aus dem Hauptteil
der Anfrage, also
diesem, abrufen und in der Datenbank
speichern Zuallererst
müssen wir es zu einer
Post-Anfrage machen , statt und denken Sie daran, dass diese Post-Anfragen nicht im Browser getestet werden können. Also werden wir ab jetzt Postman verwenden bis wir ein Frontend bauen Anstatt
fest zu codieren, werde
ich hier die Punkt-Body-Dot-ID anfordern Das heißt, die Daten
werden im JCN-Format vorliegen und die ID wird der Schlüssel sein Ich werde das verwenden, um einfach den Wert
auszudrucken. In ähnlicher Weise wird die Benutzer-ID
als Hauptteil der Anfrage verwendet. Mach es groß. Benutzer-ID anfordern. Ich werde den Titel Dot
Body Dot anfordern. Und der Inhalt wird als Inhalt mit Punktkörper
angefordert. Okay. Davon abgesehen glaube
ich nicht. Das ist das s. Und ich werde hier einfach die Nachricht mit
der String-Interpolation schreiben Neuer Knoten mit ID erstellt, und dann schreibe ich einfach die dritte Punkt-ID der
Anfrage Genau das ist die Antwort. Ich will Sy. Dann lass uns
unseren Server wieder starten. Und jetzt teste es. Hier wird zunächst
die Route hinzugefügt. Denken Sie daran, dass dies eine Postroute
sein wird. Um nun Körperdaten zu senden, klicken Sie
zuerst auf
diesen Body und dann E Raw und stellen Sie
sicher, dass es sich um Text handelt.
Sie schreiben JS, weil
wir Jsta senden werden Lassen Sie uns hier schreiben, dass die
ID 005 sein wird. Weil es momentan vier
Notizen gibt. Ich weiß es. Benutzer-ID lautet
Mail-Titel Mail-Titel wird
Hard sein , die M-Notiz Und der Inhalt wird sein Das ist der Inhalt.
Versuchen wir es jetzt. Wir werden es einfach posten und sehen, wie
ein neuer Knoten mit der ID 005 erstellt wurde. Und das ist 005, ich habe es vergessen. Es soll bei Null sein, aber es ist okay. Wenn ich eine Liste schreibe
und dann Le auf Gmail.com schreibe,
bekommen wir eine bekommen wir Dann kannst du dir die
neueste Version hier ansehen. Und wenn ich auch in die Datenbank
gehe und
sie aktualisiere , kannst du sehen. 001-00-2003, alle
Daten sind da. Mal sehen, ob ich
diese 210 einfach noch ändern und aktualisieren kann. Das ist es 005. Und wenn ich
es einfach nochmal schaffe, sieh mal. Ich kann nur die
Noten von R auflisten, das gibt eine Idee. Das ist es also. Für dieses Video sehen wir uns im nächsten
Video. Danke.
9. Route zum Aktualisieren und Löschen: Hallo, willkommen zurück. Jetzt ist es an der Zeit, auch eine
Route für die Aktualisierung
einer Notiz zu erstellen . Also unten ist Route hinzufügen. Schreiben Sie App Tot. Und da es um
Updates geht, werden
wir put verwenden Dies ist eine
STP-Anfrage zur Aktualisierung, und ich werde den Namen der
Route in Notes geben Es wird eine Synchronisierungsfunktion sein, die eine
Antwort auf die Anfrage gibt. Okay. So wie wir das
machen, schreiben wir R Update Note ist gleich einer Gewichtung als
unser Note-Modell Punkt. Dieses Mal
schreiben wir Not Find, wir schreiben Fine
One und dann sehen
wir, wir haben ersetzt, entfernen und löschen, und wir werden
Update so verwenden. Und jetzt hier: Zuerst
schreiben
wir die Bedingung in diese Klammern oder
geschweiften Klammern Die Bedingung lautet, dass die
ID der Punkt-ID des
Anforderungspunkts entsprechen sollte Anforderungspunkts Also werden wir die
ID über den Körper senden. Was wollen wir dann aktualisieren? Wir möchten
das Titelfeld auf den
Punkt-B-Punkt-Titel
der Werteanforderung und
das Inhaltsfeld auf den Punkt-Inhalt
des
Werteanforderungspunkts aktualisieren Punkt-B-Punkt-Titel
der Werteanforderung und das Inhaltsfeld auf den . Das ist also die Bedingung Das ist, welche Felder
wir aktualisieren wollen und für welche Daten
und das letzte, wir werden schreiben, dass neu gleich wahr
ist. Das bedeutet, dass diese Abfrage die Daten
zurückgibt. Wenn wir nicht schreiben, dass neu gleich wahr
ist, werden die
vorherigen Daten zurückgegeben, nicht die aktualisierten Daten. Aus diesem Grund werden einfach die aktualisierten Daten
zurückgegeben, die in
dieser Aktualisierungsvariablen gespeichert werden. Denken Sie also daran,
finden Sie eine und aktualisieren Sie sie. So geht das,
und es werden die aktualisierten Daten zurückgegeben. Danach
erstellen wir eine Antwortvariable. Hier schreiben wir eine Nachricht, ob
die Notiz mit der ID aktualisiert
wurde. Und die ID wird als
Request Dot Body ID verwendet. Und dann senden wir auch
die
aktualisierten Notizdaten und aktualisieren die Notiz wie diese. Das heißt, wir
geben die Daten auch zurück. Um es in der
Konsole zu sehen. Das ist es. Sonst nichts. Ruhen Sie Json aus, das ist Antwortpunkt Jason
und wir werden
die
Antwortvariable wie folgt senden . Lass es uns testen, wie
du hier sehen kannst. In der ID fünf. Ich werde die Daten aktualisieren. Hier. Es wird sein. Der
Name der Route lautet Datum der Listennotizen. Es sollte gesetzt werden. Denk dran. ID ist 005-Titel. Das ist mein Inhalt wie dieser. Ich möchte nichts
anderes ändern. Ich werde einfach mal sehen, was passiert ist. , es gab einen Fehler Ich glaube, es gab einen Fehler, aber warum? Nein. Ich habe mich nicht verändert. Ich habe es noch einmal überprüfen lassen. Hinweise, Update. Dann habe ich eine gefunden und die ID
aktualisiert und die
Körper-ID angefordert. Und ID hier. Okay, die ID war offensichtlich
falsch. Ich ändere es.
Wenn ich jetzt C schreibe, ist
das mein aktualisierter Inhalt. Und wenn ich zur Datenbank gehe
und sie aktualisiere, können
Sie sagen, dass dies
mein aktualisierter Inhalt ist. Andere Details
bleiben unverändert. Okay. Die Update-Route funktioniert
also auch. Jetzt ist die nächste Route, die wir
wollen, die tägliche Route. Zum Aktualisieren verwenden wir die
Put-Route-Put-Anfrage. Hier werden wir das Löschen verwenden. Das ist eine Punktlöschung. Hier seht ihr, wir haben Abdo Post Put und Delete
bekommen. Die Route wird aus Notizen,
Löschen und dann aus einem Sync-Punch bestehen Antwort anfordern. Die Anfrage lautet „Löschen“. Die
Notiz entspricht einer Gewichtung. Beachten Sie, dass Sie einen löschen. Also hier verwende ich delete one, weil
ich offensichtlich nur eine lösche
und
die Bedingung lautet ID, die Anfrage Punkt für ID
entspricht. Dann werde ich eine Antwort erstellen Ich werde eine Nachricht schreiben, die der Nummer „Notiz
wurde gelöscht“ mit der ID entspricht Notiz . Dann forderst du die Body-Punkt-ID an. Und denken Sie daran, dass es die Daten
nicht herausgibt. Es wird einfach geschrieben,
gelöscht ist fertig, so
etwas in der Art. Sie werden es in der Antwort sehen, aber das gibt die
gelöschten Daten nicht so zurück. Dann schreibe ich einfach die
Antwort, die Punkt C hat. Ich werde hier Pons schreiben. Speichern. Lassen Sie uns jetzt auch
diese Route testen. Und jetzt werde ich die
aktualisierte Route löschen. Dieser. Ich werde hier
zuerst Löschen verwenden und
dann den
Routennamen in Löschen ändern. Und hier muss ich all diese Dinge nicht
schicken. Nur wenn ich nur einen Ausweis schicke,
dann ist es auch in Ordnung. Wenn ich all diese Daten sende,
ist es auch in Ordnung. Also schreibe ich einfach das N und
sehe, dass die Notiz gelöscht wurde,
bestätigt, dass T
gelöscht wurde. Zähle eins. Das war also die Antwort
vom Server. Und wenn ich dorthin gehe und wieder da
bin, dann ist das da. Das sollte nicht
in der Datenbank sein. Lass es uns aktualisieren. Mal
sehen, ob 005 da ist oder nicht. S. Der letzte ist 00004. Das ist der letzte. Also
wurden alle unsere Routen geschrieben und
funktionieren perfekt. Im nächsten Video werden
wir
unsere Routen einfach auf eine bestimmte
Weise organisieren . Danke.
10. Unsere Routen organisieren: Hallo. Wir haben alle unsere
Routen in eine Server-JS-Datei geschrieben. Wenn du willst, kannst du das tun, aber ich mag es,
es besser zu organisieren. Denn bei größeren Anwendungen müssen
Sie viel
mehr Routen bearbeiten. Wie Sie sehen können, haben wir vier
Routen für die Verwaltung von Knoten. Das sind diese vier. Lassen Sie uns sie also
in einer anderen Datei trennen. Ich spreche nicht
über diese Route. Ich spreche von
diesen vier Routen. Lassen Sie uns also zuerst den Server topen. Erstellen Sie im Ordner Asserts einen neuen Ordner Routes
und
erstellen Sie darin eine neue Datei Knoten bis. Das heißt, dies
wird der Routenknoten sein. Hier ist zunächst inp
express gleichbedeutend mit
require Express , dann verwenden
wir hier einen Router aus
der Express-Bibliothek,
ist ein Express-Router wie dieser und stellen sicher, dass Sie
diesen Router exportieren , damit wir ihn später in die
Server-JS-Datei importieren
können Danach gehen Sie zu Servers
Here, Server-JS-Datei. Und schneide alle vier Routen
außer der Heimatroute ab. Hier aus der App Punkt, diesen Gat Post platzieren und löschen, ausschneiden, zu diesen
Routen hier gehen und ihn
einfach so einfügen. Statt dieser app.gg werden
wir jetzt Router verwenden Und denken Sie auch daran, das
Knotenmodell zu importieren. Also dieser rechte konstante
Knoten entspricht require Das wird außerhalb des Modells notieren, und hier schreiben Sie einfach Router Hier auch. Da kann man sagen, dass dies unsere
eigene Router-Datei ist. Das heißt, wir verwenden diesen
Router-Express-Router. Und Sie können die Schrägstriche aus
dem Router-Namen entfernen. Weil dies
in allen vier Routen üblich ist. Wir werden diese JS-Datei auf dem
Server verwenden, um sie mit
unseren eigenen Routen zu verbinden. Zuallererst werden Sie verstehen,
dass entfernen auch hier die Routen und
die Schrägstriche Und auch hier, speichere es. Teilen Sie dem Server nun endlich
die JS-Datei mit, die Routen zu verwenden , die in der separaten Datei
geschrieben sind. Hier zunächst die
MP-Routendatei. Hier werden wir es hier importieren. Der C Note-Router muss la benötigen, tut mir leid, das sollte
Routes Slash Note sein Und dann werde ich
es einfach als Middleware-App verwenden, Punkt e. Eine Anfrage, die Schrägstriche
enthält,
also den Node-Router Also wenn du das verstehst, Routen automatisch angehängt. Das ist Slash Notes Slash Ad oder
Slash Notes Slash Update Also alle Anfragen, die dazu kommen, das
heißt, es hat die Schrägstriche Es wird es erkennen, dann schauen
wir einfach nach, fügen einen Anruf hinzu, aktualisieren diesen Anruf oder
löschen diesen Anruf auf diese Weise. Das ist ein saubererer Weg. Ebenfalls. Es ist nicht wichtig, aber da alle Daten
in JCN kommen, werde
ich auch die Antwort von Sen
an JCN hören , ich werde einfach API schreiben Die API funktioniert so. Und natürlich verwende ich diese Kommentare jetzt
nicht mehr. Ich weiß, was Anfragen sind. Ich weiß, was Antwort ist. Wenn ich es also nur testen muss, schreibe
ich einfach
terminal und P. listet s mail.com Es wird Get Request sein.
Lass uns sehen und sehen. Die Routen
funktionieren jetzt auch. Ich habe hier zwei Routen. Ich habe zwei Notizen. S.
Und wenn ich John schreibe , habe ich alle Notizen von John, also drei und vier. Unser Server ist also fertig. Im nächsten Video werden
wir diesen Server für die
Eisenbahn-App bereitstellen , damit er live
ist. Danke.
11. Push-Code zu Github: Hallo. Unser Backend ist fertig. Jetzt ist es an der Zeit, dass wir es von einem
lokalen Haus aus auf einen Remote-Server verteilen lokalen Haus aus auf einen Remote-Server ,
sodass jeder darauf zugreifen kann. Wir werden für
den Einsatz Railway Platform anstelle von Heroku verwenden, da für den Start keine
Kreditkarte erforderlich Lassen Sie uns vorher eine
kleine Änderung an unserem Code vornehmen. Wir müssen den Topf wechseln. Da wir den Pot
angegeben haben, müssen wir
den Pot, den Railway in
der Umgebungsvariablen angegeben hat,
anstelle eines statischen Pots verwenden den Pot, den Railway in
der Umgebungsvariablen angegeben . Schreiben Sie hier einfach Constant Put Two Process Env Pot und
wenn er nicht da ist, dann benutzen Sie einfach 3.000 Und hier so. Das ist also der einzige Code, der
benötigt wird, und hier kann ich ihn einfach so
verwenden. Okay, die Konfiguration ist abgeschlossen, ich kann den
Server vorerst einfach anhalten. Ich schätze, um Code bereitzustellen, verwenden wir Railway oder
Render oder eine andere Plattform. Wir müssen zuerst
unseren Code auf Github pushen. Gehen Sie also zu Ihrem Github-Konto ,
er melden sich bei Ihrem Getab-Konto und Sie müssen
ein neues Repository erstellen Schreiben Sie einfach neu, dann
nenne ich es Notes App API und mache es
dann öffentlich Sie können die Readme-Datei entfernen und einfach auf
Create reposite three klicken Und danach müssen wir Git in unserem
Projekt initialisieren. Schreiben Sie hier einfach Git hinein, dann schreiben Sie Git add dot schreiben Sie
dann get commit com Ich schreibe gerade First
Commit Presenter Dann hol dir Branch Main. Ich hoffe du kennst G-Code. Das heißt, das sind
nur Get-Zeilen, und Sie können all diese
Zeilen auch hier sehen. Danach
kopieren sie es einfach und fügen
es ein und bekommen endlich Origin Main. So wie das. S. Lass uns nachsehen ob unser Code
weitergegeben wird oder nicht. Ich werde ihn einfach aktualisieren. Und sieh mal. Wir haben den
Backend-Code hier, also Modelle, ja. Alles ist da. Und ich habe auch
diese Node-Module gepusht, aber es ist nicht notwendig,
dass Sie
diese Node-Module
genauso ignorieren können wie jede Dot-NV-Datei. Das war's also für den ersten
Schritt im nächsten Video Wir melden uns bei Railway an und stellen
dort unseren Server bereit. Danke.
12. Dein Repository bereitstellen: Hallo. Gehen wir jetzt
zur Railway Dot App. Es ist richtig, Bahn-App
wie diese, Moderator. Das können Sie sehen, bringen Sie Ihren Code mit. Wir kümmern uns um den
Rest, all diese Dinge. Das ist also der Bahnsteig. Das gefällt mir ziemlich gut. Sie können auch eine Datenbank erstellen. Laden Sie auch
einen beliebigen Serviit-Code hoch. Klicken Sie einfach auf Einloggen. Loggen Sie sich mit Github ein. Und sieh mal. Und weil ich mich schon früher mit
meinem Guitub-Konto angemeldet Ich denke, das ist der Grund, warum es direkt hierher gesendet wurde, ohne
nach einer Authentifizierung zu fragen Aber auf jeden Fall müssen
Sie sich über
Ihr Guitab-Konto
authentifizieren Nachdem Sie sich hier angemeldet haben, erstellen Sie
einfach ein neues Projekt Dann können Sie sehen, dass es viele
Optionen
gibt, die von Gitab aus bereitgestellt werden. Stellen Sie eine statische Vorlage Sie können hier
auch eine Datenbank erstellen , da Sie hier Mongo DB verwenden
können Dann können Sie diesen Link auf
Ihrem Server verwenden , wenn Sie Atlas
nicht verwenden.
Es liegt also an dir. Ich werde es einfach
von Github po aus bereitstellen. Dann habe ich mich schon bei meinem Github
authentifiziert. Aber vielleicht siehst du
all diese Dinge nicht. Du musst die
Github-App konfigurieren und so. Sie können also einfach darauf klicken
und einfach ein Passwort eingeben. Dann werde ich hier diese Notizen-API
verwenden. Und ich erinnere mich auch, dass
Sie dort die Möglichkeit haben, Zugriff auf alle oder bestimmte
Repositorien zu
autorisieren Also habe ich alle Repositorien angegeben
, weil es an dir liegt. Klicken Sie auf Notizen, API. Wenn Sie dann
Umgebungsvariablen haben, können
Sie diese auch hier
oder später hinzufügen. Aber ich werde jetzt einfach auf Deploy
klicken. Es wird also
innerhalb weniger Sekunden erledigt sein. Aber wie Sie sehen können, ist
es so einfach, unseren Server
bereitzustellen. Sie müssen nicht so viel Konfiguration vornehmen
und jetzt können Sie sehen,
dass dies ein Erfolg ist. Das Letzte, was wir
tun müssen, ist eine Domain zu erstellen. Das ist der Endpunkt unserer API, die vom
Client aus für den Zugriff auf diesen Server verwendet werden kann. Offensichtlich benötigen wir eine
Art URL. Gehe hier zu den Einstellungen. Klicken Sie einfach auf Domain generieren. Es generiert unsere
Server-API-URL und C. Wir können unsere API sehen. Und wenn
ich einfach draufklicke,
dann zeigt unsere Heimatroute
jetzt das Ergebnis an. Es ist die API, die funktioniert. Wie Sie sich erinnern, war
dies der Heimweg. Lassen Sie uns diese
APA nun auch in Postman testen. Ich werde es einfach kopieren.
Holt den Postboten raus Hier. Anstelle
dieses lokalen Hosts verwende
ich den Ich werde Notes verwenden. Am Anfang muss ich HTTPS und dann Column
schreiben. Jetzt hol einfach
alles für Ravel, sende und schau, wir haben
die Routen hier. Wenn ich jetzt versuche, eine
Route hinzuzufügen und ihr einen Beitrag zu geben, denke ich, dass diese gelöscht wurde
und das ist der Inhalt Ich denke, 005 ist nicht da. Lass es uns posten. S,
neuer Knoten erstellt. Und jetzt ilist@gmail.com und hol es dir, gib es eine Anfrage abrufen. Dann kann ich hier meine
neuesten Knotendaten sehen. Das bedeutet, dass unsere API
erfolgreich eingesetzt
wurde und einwandfrei funktioniert. Der gesamte
serverseitige Code ist also fertig. Im nächsten Video werden wir Arbeit an unserer
Flatter-Anwendung
beginnen Danke.
13. Ein Flatter-Projekt erstellen: Hallo, willkommen zurück zu einem neuen Video. Jetzt ist es an der Zeit, dass wir
an unserem Frontend arbeiten. Als erstes müssen Sie ein neues Flatter-Projekt
erstellen. Ich gehe davon aus, dass Sie das
Flutter S DCNO-System
bereits installiert haben Flutter S DCNO-System
bereits installiert Wie Sie sehen können, haben
wir dieses Backend bereits Jetzt hier, das ist in der
Notes-App, ein Terminal öffnen. Öffne ein Terminal. Und stellen Sie sicher, dass Sie
Flutter installiert haben. S. Wenn ich die Flutter-Version schreibe, sehe
ich die Version
Flutter Jetzt habe ich hier das Terminal
geöffnet, weil wir die Backend-Entwicklung bereits in diesem Ordner
erstellt Hier werde ich einfach einen Brief schreiben, ein Frontend wie dieses erstellen. Lass es uns erstellen. Sie können einen beliebigen Projektnamen
oder einen beliebigen Ort
verwenden. Ich bevorzuge es einfach so. Und danach können Sie das Frontend hier
sehen Ich lösche den
Windows-Ordner, dann das Web, dann Linux, dann macOS und dann den Test. Da ich nicht
für diese Plattformen bauen werde. Öffnen Sie jetzt dieses Projekt im Code. Wie dieses Frontend. Starte die App jetzt nicht. Ich werde einfach Namen der App in dieser
Haupt-Android-Manifestdatei
ändern. Ich hoffe du weißt das hier, ich werde einfach eine Notizen-App schreiben. Wann immer Sie
diese App auf Ihrem Handy erstellen, der App-Name
Notes-App statt Frontend. Und Sie können es auch zu
Kapital machen, Sie können
auch Platz geben. Es liegt an dir. Es war nur der Name. Jetzt. Lassen Sie uns eine
Homepage erstellen, weil
ich natürlich weiß, dass ich diesen Dummy-Code nicht
verwenden werde Erstellen Sie in ib einen
Ordner, der als Seiten bekannt ist, und erstellen Sie darin einen Punkt für die
Startseite Jetzt erstellen wir vorerst ein
Gesamtbudget für Startbildschirm mit einer App-Leiste und einer schwebenden
Aktionsschaltfläche. Importieren Sie zunächst das
Materialpaket, erstellen Sie
dann ein State-Full-Widget und nennen Sie es Startseite. Dann werde ich hier
ein Gerüst zurückgeben und dann die App. Das sind alles
Widgets von Flutter. Ich gehe davon aus, dass Sie
Grundkenntnisse in Flattern haben. Die Textnotizen-App Dann ist der zentrierte
Titel gleich wahr. nach der A-Leiste Schreiben Sie nach der A-Leiste
einfach die schwebende
Aktionstaste, dann die schwebende
Aktionstaste hier auf Drücken, lassen Sie sie
vorerst leer und fügen Sie im untergeordneten Const-Icon Icons hinzu So, speichere es. Sie dann in der Haupt-D-Datei Entfernen Sie dann in der Haupt-D-Datei diese Dummy-Homepage Das ist die Standardeinstellung. Dann werde ich auch diese
Kommentare entfernen. Ich schreibe
ihm nur Flatternotizen. Und hier zu Hause. Ich werde die Homepage schreiben. Okay, speichern Sie es. Jetzt starte ich den
Pixel Five-Emulator. Sie können den Emulator verwenden
oder auch
Ihr eigenes echtes Gerät anschließen, oder auch
Ihr eigenes echtes Gerät anschließen da ich weiß, dass dieses Android Studio
eine große Software ist und Ihr System auch
verzögern kann Danach starten Sie einfach beim
Ausführen das Debuggen. Es wird einige Zeit dauern, warte darauf. Aber wir wissen bereits
, dass unser Server, also das
Backend, einwandfrei funktioniert. Es ist relativ einfach, es
einfach mit dem
Frontend zu verbinden , da der größte Teil der Hauptlogik
auf der Serverseite lag. Es wird da sein. Wenn ich dann diese Eisenbahn-App sehe, stellen Sie sicher, dass Sie mehr über
diesen Bahnsteig erfahren , denn er ist
auf jeden Fall sehr nützlich. Es gibt so viele Dinge
, die Produktion und Entwicklung sind, man kann ihnen auch
Umgebungen geben. Denn mit etwas Übung werden
Sie verstehen und
sicherstellen, dass dieser
Startplan ein Limit hat. Aber wenn
Sie ein Anfänger sind, werden
Sie dieses Limit natürlich nicht
ausschöpfen können, da
dies nur zu nicht
ausschöpfen können, da Testzwecken dient. Sie können es einsetzen und Ihre Projekte den Arbeitgebern vorstellen.
Es liegt an dir. Okay. Also hier glaube ich, dass der
Server funktioniert und ich sehe, wir haben die Notes-App. Ich werde einfach
dieses Debug-Banner entfernen. Die
Debug-Banner anzeigen fallen. Okay. Das war's also für dieses Video. S in den kommenden
Videos. Danke.
14. Note-Modell erstellen: In unserer App werden wir uns mit Knotendaten
befassen. Es ist sehr wichtig, dafür ein Modell zu
haben. Wir verwenden Modelle, um unseren Daten eine
vordefinierte Struktur zu geben anstatt sie einfach
überall als
Stationsschlüsselwertpaare zu verwenden . Erstellen Sie also in Lib
einen Ordner mit dem Namen models und erstellen Sie darin eine neue
Punktdatei Note Dot Dart Jetzt werden wir eine
Modellklasse für den Knoten erstellen. Und das wird
alle Eigenschaften haben, die wir bereits im
Mongo DV Node-Schema definiert haben , also dieser JS-Datei Fangen Sie hier einfach mit der String-ID an. Zeichenfolge Benutzer-ID Zeichenfolge Titel
tut mir leid, ich Zeichenkettentitel. Zeichenketteninhalt Datet hat hinzugefügt. Erstellen Sie einen Konstruktor Hinweis: Das ist richtig. Diese Punkt-ID, diese Benutzer-ID, dieser Titel, dieser Inhalt
und dieser Punkt wurde hinzugefügt. Sie können zum
Knotenschema gehen und einfach sehen, dass wir diese
Eigenschaften auch dort haben. Lassen Sie uns nun an der
JCN-Serialisierung arbeiten. Lassen Sie uns Punchon erstellen, um JCN-Daten aus der
Datenbank in dieses Node-Objekt sowie von diesem
Objekt in das JS-Format zu konvertieren,
das vom Server verstanden
wird Also hier einfach richtig. Fabrik. Beachten Sie, dass wir
von einer Karte wie dieser eine Kartendatei senden, sich um eine dynamische Zeichenkette handelt dann ein Notizobjekt zurückgeben. Hier müssen wir die
Werte ID Map ID übergeben. Stellen Sie also sicher, dass diese Schlüssel mit denen in DV identisch
sind. Das heißt, falls Sie wissen
wollen, dass ich hier
über diese Schlüssel spreche hier
über diese Schlüssel Die Benutzer-ID gibt diesen Schlüsseln einen Titel. Dies wird auch in
unserem Schema erwähnt. Ich möchte nur nicht, dass du hier einen dummen Fehler
machst. Benutzer-ID Ordnen Sie die Benutzer-ID zu. Title Map, das wird der Titel sein. Inhaltsübersicht. Inhalt. Datum hinzugefügt. Denken Sie daran Wenn wir das
hinzugefügte Datum auf diese Weise schreiben, funktioniert das nicht,
weil
es als Zeichenfolge oder Sequenz
angrenzt,
aber wir wollen ein Datums- und Uhrzeitformat Wir werden es aufschreiben. Das
heißt, wir werden es pausieren. Wir werden dieses Datum
im Datetime-Format parsen
und versuchen Pase, sodass es im
Ausnahmefall
Null statt eines Fehlers zurückgibt im
Ausnahmefall
Null statt eines Fehlers zurückgibt Das heißt, wenn
das Datum versehentlich nicht da ist, wird einfach Es wird keine Ausnahme ausgelöst oder Sie können sagen, beenden Sie
unsere Anwendung. Und wie Sie sagen können, ist
dies ein Nulllabel. Zumindest werden wir auf diese Weise
sicher sein. Zumindest stürzt die App nicht ab. Auf diese Weise werden Daten
von JCN in dieses Objekt konvertiert,
und jetzt wird eine weitere Funktion erstellt Dass dies eine Zeichenketten-Map,
eine
dynamische Two-Map, zurückgibt , und dass
dies eine Map zurückgibt Es wird die ID als ID, die Benutzer-ID als Benutzer-ID-Titel als
Titel und dann das Datum haben, das hinzugefügt wird. Jetzt wird das hinzugefügte Datum, das wir senden werden,
im Datums- und Uhrzeitformat sein, aber jetzt müssen wir es
erneut in das Zeichenkettenformat konvertieren, das
von der Datenbank verstanden wird. Schreiben Sie einfach hinzugefügt und
konvertieren Sie es in die Zeichenfolge 2i86 01. Denken Sie also daran, wir konvertieren
wieder in eine
Zeichenfolge aus Datum Das ist ein einfaches Konzept. Das sind also unsere
Notizdaten. Speichere einfach alles. Und bevor
ich weitermache, möchte ich
zuerst die Anwendung beenden. Und ich werde
einige Abhängigkeiten installieren. Wir werden
den Anbieter als Statusverwaltung
in unserer Anwendung verwenden . Das andere Paket wird UUID sein , um eindeutige
IDs für unseren Benutzer zu erstellen Dann benötigen wir das
SDTP-Paket, um die API aufzurufen. Sie können also entweder zur
Pub Dot-Site gehen und
sie durchsuchen und sie in den Abschnitt mit den
Abhängigkeiten in der
DOML-Datei von PUPS einfügen , oder Sie können in den Befehl
einfach Pub add UUI Sie können
einfach mit
Provider-UUID und HTTP und Presenter beginnen Provider-UUID Das wird also alles installieren. Mal sehen, ob ein
Fehler vorliegt oder nicht. In der Pups Dot Yamal-Datei können
Sie sehen, dass wir die
Provider-UUID und HTTP installiert haben war's also für dieses Video.
Danke.
15. Benutzeroberfläche der Startseite: Hallo. Lassen Sie uns unsere
Anwendung erneut ausführen. In diesem Video werden wir an der Benutzeroberfläche der Startseite
arbeiten. Auf dieser Seite werden wir
alle Notizen dieses Benutzers anzeigen. Lassen Sie uns zunächst eine grundlegende Benutzeroberfläche erstellen. Hier haben wir die A-Leiste, wir haben die schwebende
Aktionstaste. Fangen wir im Körper
mit einem sicheren Bereich an. Wenn es also eine Kerbe
oder etwas gibt , das
mit dem Gerät zusammenhängt, es sich in der sicheren Zone Dann werden wir den Grid
View Dot Builder verwenden. Wenn Sie möchten,
können Sie also die Listenansicht verwenden. Aber hier, wie es sich gehört, wird
die Rasteransicht besser aussehen. Hier im Grid-Delegaten müssen
Sie also einen
Const-Sliver-Grid-Delegaten mit einer festen Achsenanzahl wie
folgt schreiben Const-Sliver-Grid-Delegaten mit einer Achsenanzahl wie
folgt Ich weiß, es ist sehr verwirrend, aber hier Und dieser Code
bedeutet das einfach auf dem Bildschirm. Wir werden nur zwei
Elemente in der Horizontalen haben. Sie werden also sehen, wann
wir diese UR fertig haben. Wie Sie wissen,
haben wir dann in der Liste auch die Anzahl der Artikel. Im Moment
verwende ich einfach eine Dummy-Zählung. Es gibt fünf, dann
im Item Builder. Schreiben Sie Kontext und Index. Hier gebe ich die Farbe des
Containers zurück,
vorerst werden die
Farben punktblau
sein und der Rand wird in allen fünf Sätzen als Rand angezeigt. Und Semikolon hier. Starten Sie neu oder Sie können es speichern
. Und sieh mal. Dies ist die Rasteransicht, und es gibt nur
zwei Elemente in der Horizontalen oder in einer Reihe. Wenn Sie also drei angeben, wird das angezeigt, aber es wird offensichtlich nicht gut aussehen da es sich um ein mobiles Gerät handelt. Es hat ein kleines Dann ist
das nur die Benutzeroberfläche. Jetzt benötigen wir natürlich eine Seite, auf der der Benutzer Notizen hinzufügen kann. Erstellen Sie innerhalb der Seiten eine neue Datei und fügen Sie dem Pfeil eine neue Notiz hinzu. Mappen Sie das Material, erstellen Sie dann ein
Status-Widget und fügen Sie eine neue Notiz hinzu. Okay. Hier einfach richtig,
gib ein Gerüst. Lass es vorerst. im Körper für einen sicheren Bereich und innerhalb des sicheren
Bereichs für eine Säule. Und Kinder lassen
es vorerst einfach leer. Okay. Navigiere von der Startseite zu dieser Seite „Neue Notizen
hinzufügen“. Wir haben diese schwebende
Aktionsschaltfläche auf der Homepage hier. Schreiben Sie einfach die
Navigation des Kontextes und klicken Sie auf die Route der Materialseite. Sie dann im Builder hier
Kontext ein
und fügen Sie eine neue Notiz hinzu. Okay. Und ich gebe
ihm einfach eine neue Immobilie. Zu zweit gibt es einen
Vollbild-Dialog. Das ist also einfach eine Eigenschaft
der Route auf der Materialseite. Wenn Sie nicht möchten, können
Sie dies auch entfernen. Also, wenn ich auf Plus klicke, dann hat es dieses Kreuz
statt eines Zurückpfeils. Es ist also wie ein
Vollbild-Dialogfeld statt einer Seite. Das ist das einzige, was
dieser Code tut. Wir haben auch den Bildschirm „Neue
Notiz hinzufügen“. Wir werden im nächsten Video an
der Benutzeroberfläche arbeiten. Danke.
16. Eine Notiz-Benutzeroberfläche hinzufügen: Lassen Sie uns an der Seite „Neue Notiz
hinzufügen“ arbeiten. Hier benötigen wir also
Textfelder, in die der Benutzer den Titel und den Inhalt
der Notiz eingeben kann, sowie
eine Schaltfläche zum Speichern. Zuallererst werde ich mit dem
Textbearbeitungs-Controller
beginnen. Ich weiß, dass es einen
Titelcontroller geben wird. Controller entspricht
Tex-Thing-Controller. Ein anderer wird ein Node-Controller sein. Das heißt, das
wird der eigentliche Knoten sein. Ich habe die Controller
dann im Körper. Lass uns ein Textfeld haben. In der Spalte
wird
der Controller der Titel-Controller sein. Dekoration handelt es sich um
eine konstante Eingabedekoration im Text als Titelrand während bei der Eingabe kein Rand vorhanden ist. Dann nach der Eingabedekoration. Lass uns etwas Stil haben. Der Stil wird ein konstantes
Textiltextil sein. Nehmen wir die Schriftgröße als. Wird nicht als Schriftpool verwendet. Okay. Und dann will ich Autofokus. Autofokus auf Rot. Lass es uns speichern. Wenn ich gehe und auf die Anzeige
klicke, sehe
ich, dass der Autofokus
da ist und das
Titelfeld da ist Ich werde der Spalte auch etwas
Auffüllung geben. Wickeln Sie es mit Polsterung ein
und hier wird es
symmetrisch sein , horizontal,
20 Ich werde es einfach speichern und sehen. Es sieht anständig aus. Dies ist ein Titel, das
nächste Eingabefeld , das das nächste
Textfeld ist, wird hier mit
Text gefüllt. Der Controller wird
ein Notencontroller sein. Max. Anzahl Zeilen. Ich gebe Null, damit der
Benutzer die Eingabetaste drücken und
nach unten gehen kann , das heißt, er kann
mehrere Zeilen haben und dann ist das
Styling konstant Textil bei Größe 20, dann Dekoration mit
Eingabedekoration im Textnotenrahmen. Speichere es. Wenn ich jetzt darauf klicke, haben
wir den Titel,
wir haben die Notiz. Aber wenn ich hier auf die Notiz klicke, dann ist nur sie fokussiert. Wenn ich irgendwo in
diesem verbleibenden Bereich klicke, ist er nicht scharf. Um es so zu machen, können
wir einfach die zweite
Notiz mit erweitert machen. So erweitert. Und
jetzt, was passiert ist, wenn ich zurückgehe und zum
Bildschirm komme wieder zum
Bildschirm komme und
irgendwo auf den Bildschirm klicke, haben wir
jetzt die
Notiz hier, weil sie den
ganzen Platz einnimmt. Weil
ich natürlich möchte, dass der Titel deutlich kleiner ist
als die Notiz selbst Und wenn ich auf Enter
klicke, haben wir mehrere Zeilen Das
Einzige, was noch übrig ist, ist ein sicherer Button
, den ich
in der App-Leiste angeben werde. Hier habe ich Aktionen, dann ist ein Icon-Button
beim Drücken erstmal leer. Und dann wird das Symbol ein konstantes Symbol
sein. Icons, Hinweis, Farbe,
Farbe, Punkt, Grün, Größe 30. Speichern Sie es. Dieses Symbol wird also im oberen C angezeigt. Wir haben
das Speichersymbol. Entweder kann er es einfach
speichern oder zurückgehen. Und stellen Sie sicher, dass Sie auch diese
Bearbeitungscontroller
entsorgen Der Textbearbeitungscontroller kann nicht
entsorgt werden. Beachten Sie, dass der
Controller-Punkt so angeordnet ist. Wenn wir zurückgehen und wieder auf die Seite
kommen, wird
es eine neue Instanz
der Controller Das war's also für diese Benutzeroberfläche. Im nächsten Video werden
wir daran arbeiten, einen Anbieter
zu erstellen. Danke.
17. Notiz-Anbieter erstellen: Hallo, willkommen zurück. Jetzt ist es an der Zeit, mit Daten umzugehen. Dafür müssen wir einen
Anbieter für die neuen Daten erstellen. also im Ordner Lip Erstellen Sie also im Ordner Lip einen neuen Ordner
providers und
erstellen Sie darin eine neue Datei. Notizenanbieter Punkt
Punkt. Also lass es uns tun. Importieren Sie zunächst
Material, damit wir diesen Change
Notifier-Anbieter verwenden
können, und importieren Sie dann Modelle
und dann nicht Torte Okay. Okay. Lassen Sie uns nun einen Class Note
Provider Extends Change
Notify Provider erstellen . Dann haben wir eine Variable, die aus einer Liste
aller Knoten besteht . Knoten
entsprechen vorerst einer leeren Liste. In diesem Jahr werden wir später
Notizen von APA abrufen. Im Moment werden wir es
einfach lokal machen. Erstellen Sie dann eine Funktion
zum Hinzufügen einer Notiz. Es akzeptiert eine Notiz und wir fügen
diese Notiz einfach zur Variablen hinzu. Und dann rufen Sie Notify
Listeners auf diese Weise an. Es ist ein sehr einfacher Anbieter. Dann hoffe ich, dass Sie wissen, dass wir unseren
Anbieter in der Hauptdatei registrieren müssen. Wickeln Sie hier die Material-App mit igd ein und schreiben Sie Provider Dann müssen wir Anbieter
erwähnen. Ich habe mehrere Anbieter verwendet
, weil ich davon ausgehe, dass Sie in Zukunft weitere Anbieter hinzufügen
möchten , dann können Sie das tun. Wir werden Change Notifier
Provider und dann Kontakte verwenden, und unser Providername ist Notes Anbieter wie dieser. Dann speichere es einfach. Und wir fangen an. Dann lassen Sie uns
eine Funktion im Inneren erstellen, neue Notiz
hinzufügen, in der wir ein Notizmodell
erstellen und
an die Provider-Funktion senden. Hier schreiben Sie
einfach eine neue Notiz hinzufügen. Jetzt werden
wir zunächst überprüfen, ob der
Titel da ist. Im Titel-Controller ist der
Text Tm leer, dann zeigen wir einen Snack P,
vorsichtig mit dem Kontext, der das Snag P, Snag Pow Widget im Inhalt anzeigt,
der Titel
darf einfach nicht leer sein Machen Sie es auf diese Weise konstant
und kehren Sie von hier aus einfach zurück. Ich möchte nicht, dass der
Billow-Code ausgeführt wird. Wenn der Titel leer ist. Wenn er dann nicht leer ist, dann erstelle ich
eine Notizinstanz, bei der es sich um eine neue Notiz handelt,
die zu notieren ist. Und hier werde ich die Daten-ID
weitergeben. Ich werde das UUID-Paket verwenden, um eindeutige IDs
zu erstellen, um die UU-ID
einfach konstant zu halten,
wie Es wird also
eindeutige IDs wie diese erstellen. Dann gebe
ich vorerst einige statische Daten an. Nehmen wir also an, dass vorerst ein Jo-Lag Val ist. Das ist nur ein Dummy. werden
wir gemeinsame Einstellungen verwenden Aber jetzt teste es einfach. Titel wird
Titel-Controller-Punkttext sein, und Inhalt wird
Notiz-Controller-Text sein
. Hinzugefügte Punkte werden wie folgt hinzugefügt. Das ist unser Knotenmodell. Danach verwenden wir
einfach den Anbieter, der außerhalb des Kontextes bereitgestellt
wird. Hier welchen Anbieter wir brauchen. Wir brauchen Nodes Node Provider. Und da das
außerhalb der Funktion Bill liegt, schreiben
wir „Listen,
is the Falls“, weil ich nicht möchte, dass es sich irgendwelche Änderungen
anhört. Denn wenn es
im Gebäude wäre, kann
es sich selbst rebellieren. Aber das
ist offensichtlich in einer Funktion enthalten, und ich werde die Hinzufügen-Notiz aufrufen und den neuen
Notizwert so senden. Dann
zeige ich wieder Messenger of Context Show Snag Bar Snack Bar Und der Inhalt wird erfolgreich
hinzugefügt. Und dann lasse ich den
Navigator so auftauchen. Und dann rufe diese Funktion
in der Icon-Schaltfläche hier auf. Dieser. Rufen Sie einfach eine neue Notiz an. Das war's also für dieses Video. Im nächsten Video werden wir arbeiten. Wir werden an dieser
Homepage auf TY arbeiten. Danke.
18. Notizen auf der Startseite anzeigen: Hallo. Jetzt können wir also neue Daten
hinzufügen. Lassen Sie uns also an der Notiz-Benutzeroberfläche arbeiten, die sich auf der Startseite
befindet, auf der wir
alle Notizen anzeigen werden. Vorher werde ich, nur weil der Dateiname Notes Provider
ist, Notes
Provider und nicht Note machen. Und dann hier werden es Notizen sein, und hier werden es Notizen
sein. Das ist es. Das ist nicht
sehr wichtig,
aber es ist so, als ob der
Dateiname in Notes angegeben wurde. Gehen wir hier zur Startseite. Dann werde
ich zuerst meinem Anbieter schreiben. Hier stellt der Anbieter
fest, dass der Anbieter dem Anbieter des Kontextes
entspricht, und es ist der Notes-Anbieter. Und ich muss es
in die Rechnung schreiben. So wie das hier. Dann werde
ich hier im untergeordneten
Bereich zunächst
bedingt
einen Text ausgeben , falls
keine Notiz verfügbar ist Hier werde ich nur Notizen schreiben.
Der Punkt ist leer. Dann zeige Const Center an. Zentriertes Kind. Und in den Text werde
ich noch keine Notizen schreiben. So, das ist es. der Benutzer feststellt, dass keine Notizen verfügbar sind,
und er diese hinzufügen kann. Dann in der
Rasteransicht Dot Builder. Die Anzahl der Artikel wird dann im Artikelgenerator in Notizen des Anbieters angegeben. Zuerst werde ich das Notizmodell
haben,
dann die aktuelle
Notiz schreiben entspricht den Notizen des Anbieters
und dem Index. also offensichtlich, dass es sich um eine Rasteransicht handelt, einzelne Knoten angezeigt werden. Das ist offensichtlich von
Null über Index bis Null, eins, zwei so. Dann
entferne im Behälter die Farbe Blau hier, weil das nur ein Dummy war Dann ergeben der Rand und der untere Rand rechts
einige Polsterungsnachteile alle zehn, dann Dekobox
, der Rand der Dekoration Rand Dann ist die Farbe des
Randes die Farben Grau,
W zwei, dann die Innenfarbe des Kastens, die
Dekoration, der Randradius, der
Radius
des Randes , der Kreis, der Kreis, dann zehn Okay. Dann das Kind
des Containers. Wir müssen über die Dekoration des
Grenzkastens hinausgehen, und dann
wird das Kind hier eine Säule sein. Die Achsenausrichtung wird Anfang an
kreuzachsenförmig sein. wir
bei den Kindern Zeigen wir
bei den Kindern ganz oben den
Titel des Knotens an. Aktueller Notiztitel,
und er ist nicht Null. Stilkonstantes Textil. Schriftstärke Schriftstärke
Punkt fett Schriftgröße 20. Dann gibt Max Lines einen Wert, das ist die Eigenschaft
dieses Textes,
und dann sollte
der Textüberlauf, also
der Überlauf, zu Overflow Dot Eclipse werden Das heißt einfach
Gewicht, das werde ich zeigen Zuerst sehen Sie sich den
gesamten Code hier an Also max. Zeile eins, das heißt, ich möchte nur, dass der Titel
in einer Zeile steht. Nehmen wir an, der Titel ist sehr umfangreich, also möchte ich nicht, dass er aus
zwei oder drei Zeilen besteht. Machen Sie es zu einer Zeile und der verbleibende Text wird
Sonnenfinsternis-Ellipsen sein, tut mir leid Das heißt Punkt Punkt
Punkt wie dieser. Das wird also nicht sehr schlecht aussehen. Sie dann nach diesem Text Geben Sie dann nach diesem Text einige Größenangaben
und die Höhe sieben an. Dann muss ich
die Beschreibung schreiben. Die Beschreibung ist wieder ein
Textraster mit dem aktuellen Inhalt der Notiz. Es ist nicht Null, dann wieder Textil, Größe, gib 18, Farbfarben machen
Grau, mach 700 daraus Das sind nur Stylings. Natürlich können Sie
Ihre eigenen Stile angeben ,
damit es gut aussieht Dann
schreiben Sie nach dem Stil
innerhalb des Textes auch dieses Mal die maximale Anzahl der Zeilen 24
hier,
und dann überlaufen Sie, um EPS
zu überlaufen Jetzt lass es uns testen H Ich habe
gerade alles gespeichert. Und jetzt sieh mal, hier
sind noch keine Notizen. Und ich schreibe eine neue Notiz, meine erste Notiz und schreibe. Das ist ein Scheininhalt. Machen wir es groß, damit der Textüberlauf funktioniert,
und machen wir es zu Ellipsen Ich hoffe das funktioniert. Und wenn ich auf Speichern drücke, dann sehe ich den Knoten erfolgreich, dann ist das ein Dummy-Inhalt
und da ist die Ellipse Und wenn ich es schaffe, ist Max auf fünf. Mal sehen, was passiert? Okay. Da ist der
Überlauf. Um vier Uhr Okay. Also das sieht gut aus. Wir haben den Titel hier
fett gedruckt, wir haben den Text. Und denken Sie daran, dass
dies im Moment nicht
in der Datenbank gespeichert wird. Es ist nur lokal. Wenn ich es also aktualisiere
, sind diese Daten weg. Und im Moment konzentriere ich mich
nur darauf, am Anbieter zu arbeiten. Später werden wir
den API-Dienst
mit diesem Anbieter verbinden . Jetzt können wir natürlich Daten hinzufügen. Wir müssen aber auch eine
Funktion zum Aktualisieren und
Löschen von Notizen erstellen . Gehen Sie zu den
hier bereitgestellten Notizen und fügen Sie unten eine Notiz hinzu Ich werde eine ungültige Notiz schreiben. Dadurch werden Sie
nach den Knotendaten gefragt. Das ist der Knoten, der aktualisiert werden
soll. Und jetzt muss ich diesen Wert
aktualisieren. Zuallererst in dieser Notizliste, weil diese
dem Benutzer angezeigt wird. Ich muss den Index
dieser Notiz hier in dieser Liste kennen. Ich werde schreiben, dass der Index der Notiz dem Index der
Notizen
entspricht Wo immer Sie die Element-ID finden, die dem Knoten
entspricht, der gesendet wird, dann holen Sie sich den Index. Was ich damit meine, ist, dass
es
diese Notiz in einer Schleife durchläuft und alle
Notizen-IDs zu dieser ID
überprüft. Und wenn es sie bekommt, dann bekommen wir hier den Index , der sich
an Position zwei befinden soll. Dann
schreibe ich einfach Notizen,
das ist der Index der Bemerkung und ändere sie zu
unserer neuen aktualisierten Notiz und schreibe dann Notify Listeners Das ist nur eine grundlegende Logik. Wir werden dann den Index abrufen und diesen Indexwert in
diesem Array in diese
neue Knotenvariable
ändern . In ähnlicher Weise werden wir etwas für
die verzögerte Knotenfunktion
tun . Ich werde den Index
dieser Notiz abrufen und dann
einfach die
Notizliste oder A schreiben und
dann die Anzeige entfernen, und ich werde diesen Index entfernen und dann die Listess benachrichtigen Das wird also die Benutzeroberfläche aktualisieren. Und ich hoffe, Sie haben verstanden
, dass dieses Update und Löschen vorübergehend
ist, da wir es nur auf App-Ebene
tun. Das ist es also.
Im kommenden Video werden
wir daran arbeiten, auch
einen Bildschirm für die Bearbeitung von A
Note zu erstellen . Danke.
19. An der Seite „Notiz bearbeiten“ arbeiten: Hallo. Willkommen zurück. In diesem Video werden
wir an der Bearbeitung einer Notiz arbeiten. Ich möchte also, dass der
Benutzer, wenn
er auf eine Notiz tippt, auf die
Bearbeitungsseite weitergeleitet wird, auf der er Todesnotiz aktualisieren und
löschen
kann Um das auf den Innenseiten zu tun, erstellen Sie eine neue Datei, um eine Notiz zu
bearbeiten Kopieren Sie den gesamten
Code aus einer neuen Notiz und fügen Sie ihn ein. Und danach werden
wir einige Änderungen vornehmen. Kopieren Sie es und fügen Sie es hier ein, ändern Sie den Namen des
Widgets, das so geschrieben ist Da dadurch eine Notiz bearbeitet
wird, müssen
wir
Notizdaten im Konstruktor akzeptieren Hier werde ich eine letzte Notiz schreiben. Hinweis und das wird
ein erforderlicher Parameter sein. Also diese Notiz. Und dann werde ich diesem
Textbearbeitungscontroller die Notizwerte zuweisen . Hier in seinem Zustand werde
ich schreiben, dass der Text des Titel-Controllers dem
Widget-Titel entspricht , und ich weiß, dass dies
nicht Null ist und ähnlich ist, dass T Widget-Notiz und nicht dem Inhalt
entspricht. Also ich hoffe du hast das verstanden. Angenommen, es gibt diesen Titel, meinen ersten Knoten, meine erste Notiz. Wenn wir dann
zur Bearbeitungsseite gehen, wird
sie bereits
in das Textfeld gefüllt. Und danach können wir es bearbeiten. Jetzt brauchen wir diese Funktion zum
Hinzufügen neuer Notizen nicht mehr. Lassen Sie uns hier eine
Funktion zum Aktualisieren einer Notiz erstellen. Video:
Wenn der Titel-Controller-Text Zuschneiden leer ist, ist er
ähnlich wie zuvor leer. Wir werden es nicht zulassen, also werden wir einen
Textnachrichtendienst verwenden
, der einen Haken hat. Und der Text wird sein, der Titel
darf nicht leer sein, und wir werden von hier zurückkehren Dies wird konstant sein,
wenn alles in Ordnung ist.
Was wir tun werden, ist der
aktualisierte Text, den wir haben. Wir werden es dem Knoten zuweisen, wir im
Konstruktorkonstruktor haben ,
damit wir
die anderen Füllungen nicht aktualisieren Andere Füllungen bedeuten
ID, Benutzer-ID-Datum. Diese Dinge sind bereits
in dieser Variablen enthalten, richtig. Auf diese Weise
müssen wir das nicht aktualisieren. Versuche jetzt einfach zu
verstehen, was ich tun werde, ist Widget-Punkt-Titel. Ich werde es in
Titel-Controller-Punkttext ändern, und ich brauche das nicht,
dann ist der Inhalt der Perücke mit dem Punkttext des
Notiz-Controllers identisch. Dann rufe ich den
Context-Provider auf, dann wird
der Notes-Provider
listen den Wert false haben, und ich rufe die
Aktualisierungsfunktion auf und sende die Notiz, die sich
im Konstruktor befindet, aber wir haben sie bereits aktualisiert Und nehmen wir an, der Benutzer
ändert den Inhalt nicht. Dann
müssen wir uns auch keine Sorgen machen. Da
wir im Konstruktor bereits
den Text eingefügt haben, wir im Konstruktor bereits
den Text eingefügt haben der
sich bereits in dieser Variablen befand Dasselbe wird
erneut aktualisiert. Das ist es. Dann werde ich
diese Nachrichten verwenden und einfach den Titel schreiben, der erfolgreich
aktualisiert wurde. Und dann
schreibe ich einfach Navigator Dot POP dadurch wird auch
eine neue Schaltfläche in der
App-Leiste erstellt , um sie zu löschen. Zuallererst diese Notizen
und wir können es machen. Ich werde das Symbol ändern,
sie kreuzen einfach den
Kreis an und weisen
ihm die
Notiz zum Funktionsupdate wie folgt zu, okay? Über diesem Button. Ich werde eine weitere
Schaltfläche erstellen, die eine Symbolschaltfläche ist. Das Symbol wird Icon-Symbolen bestehen, die Verzögerungsfarbe wird rot sein. Beim Drücken möchte ich einfach die
Provider-Funktion der
Kontextnotizen aufrufen,
sofern die Verzögerungsnotiz vorhanden ist einfach die
Provider-Funktion der
Kontextnotizen aufrufen,
sofern die ,
und ich schicke
dem Widget eine
Punktnotiz wie folgt. Außerdem möchte ich mir die Änderungen nicht anhören, weil ich
diese Funktion einfach aufrufen möchte. Dann brauche ich diesen Caful
und den Navigator Dot Pop. Dann schreibe ich einfach. Und sollte kein Titel sein. Sie sollten notiert werden und Notiz
sollte
erfolgreich gelöscht werden. Das ist es. Das ist die ganze
Sache. Jetzt müssen wir vom Startbildschirm
aus zu dieser Seite navigieren. Gehen Sie also zum Startbildschirm. Im Item Builder. Wickeln Sie diesen Behälter
mit einem Tintenbehälter ein und schreiben Sie auf den
Navigator des
Kontextes, den pH-Wert und dann die Route der Materialseite. Ich schicke die Seite
mit dem Notizwert an die
Bearbeitungsnotiz mit dem Notizwert an die
Bearbeitungsnotiz und der Notizwert ist hier
die aktuelle Notiz. Wie zuvor werde ich einen
Vollbild-Dialog schreiben. Das ist es. Also speichere alles. Warum das in diesem Korn ist. Wir wollen die UUID nicht. Lass es uns testen. Ich hätte gerne meine erste Notiz. Ich werde schreiben,
dass dies mein alter Inhalt ist. Speichere es, wenn ich darauf klicke,
schau , und das war die
Snackbar vor der Snackbar. Wenn ich darauf klicke, haben wir
einen Löschvorgang und das Update. Also werde ich es einfach aktualisieren auf. Das ist mein neuer Inhalt, drücke auf Speichern und sag, das ist mein neuer Inhalt. Wenn ich erneut darauf klicke
und ihn dann lösche, lösche ihn erfolgreich, und jetzt ist es Swing no notes. Das bedeutet, dass alle
Funktionen mit dem
Anbieter auf App-Ebene ordnungsgemäß funktionieren. Im nächsten Video werden
wir
Mongo Db endlich integrieren, sodass alle Daten,
die in die Anwendung kommen , aus
einer echten Datenbank stammen .
20. Funktion zum Hinzufügen von Notizen: Hallo. Willkommen zurück. Bisher
funktionierten alle Funktionen also
alle Funktionen nur auf App-Ebene. Wir haben
keine Daten in Mongo DV gespeichert. Jetzt ist es an der Zeit, dass wir auch die
Mongo DB-API integrieren. hier im Lift-Ordner Erstellen Sie hier im Lift-Ordner einen neuen Ordner
services und
erstellen Sie darin einen
Datei-API-Dienstpunkt wie diesen Zuallererst benötige ich
das HTTP-Paket. Ich gebe es als HTTP an, dann brauche ich Models Note Model. Erstellen Sie jetzt einen Klassen-API-Dienst. Hier
wollen wir als Erstes eine statische Variable. Es ist eine statische konstante String-Basis-URL. Was ist diese Basis-URL? Das ist die Domain
von Railway App. Gehen wir und hier
in der Eisenbahn-App haben
wir die Domain, haben
wir die Domain, diese Kopie und fügen Sie sie hier ein. Aber stellen Sie sicher, dass Sie hier die
HTTPS-Spalte hinzufügen und dann die Datenbank, tut mir leid, die Datenbank, die Route. Das ist die Route des Knotens. Da wir nur diese Route haben
, wurde
sie in der BaserL erwähnt Aber wenn Sie mehrere Routen
haben, werden
Sie das natürlich nicht tun.
Erstellen Sie jetzt eine Funktion
zum Hinzufügen eines Also mache ich es statisch ,
damit wir diese Funktion
aufrufen können ohne ein Objekt zu erstellen. Es wird also in Zukunft überall sein. Nennen Sie es Notiz hinzufügen. Es wird eine Sing-Funktion sein, und wir werden das
Notenmodell hier weitergeben. Jetzt brauchen
wir als Erstes die URI,
wir schreiben die Anfrage-URI
zu URI. Ich hoffe, Sie wissen, wie
man das STP-Paket benutzt URI wird die Basis-URL sein. Verwenden Sie die Basis-URL und fügen Sie hinzu. Das war unsere Route. Wenn Sie sich
serverseitig daran erinnern, werde ich schreiben, dass
R als Antwort darauf
wartet , dass HTTP hinzugefügt Wir müssen die Post-Anfrage verwenden. Dann müssen wir die
URL senden, das ist die URI. Und jetzt werden wir
den Körper in der Map senden und wir werden nur die Funktion mit den beiden Maps
notieren. Wenn Sie sich in der Notiz daran erinnern, haben
wir diese beiden Karten, die
sie
automatisch in eine Karte umwandeln. So werden diese
Dinge gehandhabt. Ich hoffe, du verstehst
diese Konvertierung von Objekt zu Map. Dann haben wir
den Antworttext, wir werden den Code schreiben, der dem JC-Code
entspricht,
und dann den Hauptteil erneut verwenden Roter Körper. Ich werde einfach den
Körper ausdrucken, den er für Debo sagt, sonst müssen wir das nicht in der Produktion
machen Rufen wir nun diese Funktion
im Notiz-Provider auf. Sie danach die Listener auf und rufen Sie den Mongo D V
, also den API-Dienst,
den Hinweis hinzufügen auf Das ist es. Jetzt denkst du vielleicht, warum ich
diese Zeile am Ende geschrieben habe. Weil dadurch
die Benutzeroberfläche innerhalb von Sekunden
oder sofort aktualisiert wird . Und im Hintergrund werden
dieselben Daten an die Datenbank
gesendet. Natürlich wird es auch für
den Benutzer
eine gute Erfahrung sein , da er nicht warten
muss, da er diese Notiz
sofort auf der Startseite sehen kann. Und wenn er später,
also später, zurückkommt , dauert das
natürlich
nur 5 Sekunden,
aber nehmen wir an,
er öffnet nach 10 Minuten erneut die App, dann werden
die Notizen auf der Startseite aus der Datenbank
abgerufen und alle Notizen werden identisch sein Denken Sie daran, dass Sie das natürlich auch oben machen
können, aber das macht keinen Sinn Lass es uns jetzt machen. Lassen Sie uns versuchen, eine Notiz hinzuzufügen. Ich schreibe und lerne „Kein Stuhl“. Senf. Ich glaube, es war etwas Luft
für die Tastatur. Mal sehen, was passiert. Deshalb bevorzuge ich meistens physische Geräte. Knoten wählen. Wir können den neuen Knoten speichern und
im Terminal sehen , der mit der ID this
erstellt wurde. Das kommt also
vom Server. Ich hoffe, Sie erinnern sich, dass
dies unsere Antwort war. Das heißt, das
ist in der Datenbank gespeichert. Das war's also für dieses Video. S im nächsten
Kapitel. Danke.
21. Funktionalität zum Aktualisieren und Löschen: Hallo. Willkommen zurück. Ähnlich wie das Hinzufügen einer Notiz. Lassen Sie uns auch eine API-Funktionalität erstellen
, um die Notiz zu aktualisieren. Gehen Sie zum API-Service
und fügen Sie unten eine Notiz hinzu. Schreiben Sie einfach Taktik. Zukunft. Dies wird auch vermeiden. Datumsnotiz, Synchronisieren Sie es. Damit wird eine Notiz akzeptiert. Und jetzt erstellen Sie erneut die
URI-Anforderung. Die URI entspricht URI Punkt P, der
Basis-URI und dann dem Update. Dann besteht die R-Antwort darin, auf TTP zu warten. Dieses Mal müssen wir den Put B
auf dem Server verwenden , auch wir
haben den Put angegeben Genau hier
müssen wir URI und
Body durch die Notiz in der Map ersetzen . Lassen Sie dann auf ähnliche Weise
das dekodierte Senden an den Hauptteil
durchführen und eine Zeichenfolge senden Zum Löschen
kopiere ich einfach diese Funktion und füge sie ein. Dies wird der Löschknoten sein. Sind genau hier. Es
wird gelöscht. Ihre TP-Anfrage wird sich verzögern. Und das ist alles. Und denken Sie daran, wenn
Sie möchten, können Sie ein Notizobjekt wie
dieses oder auch nur die ID senden . Es liegt an Ihnen, denn
aus dieser Map extrahiert
der Server
die ID selbst, oder wenn Sie nur die ID senden, dann ist das auch in Ordnung.
Es liegt an dir. Rufen wir diese Funktion auf, gehen wir zum Notizenanbieter und
schreiben am Ende auf ähnliche Weise eine Notiz zum API-Servicedatum und eine
solche Notiz zum API-Service und nicht zur
Verzögerung und speichern sie. Das
passiert, wenn ich hierher gehe und Dummy updated schreibe
und darauf klicke Siehst du. Note wurde
mit ID und Dummyd aktualisiert Das heißt, es wurde auf dem
Server aktualisiert. Denken Sie daran, dass diese Daten
entfernt werden,
wenn Sie es aktualisieren diese Daten
entfernt werden , da wir derzeit keine Notizen
abrufen Das ist nur auf App-Ebene. Aber zumindest kannst du
sehen, dass es funktioniert. Unser Aktualisieren und Löschen von
APA funktioniert also auch. Im nächsten Video werden wir die Funktionalität zum
Abrufen aller Notizen
schreiben und
eine Funktion erstellen , die
alles hier anzeigt.
22. Funktion zum Abrufen von Notizen: Hallo. Willkommen zurück. Es ist an der Zeit, dass wir
alle Knoten auf
dem Startbildschirm abrufen , damit,
wenn wir die App neu
starten, auch die Daten sichtbar sind Erstellen Sie hier eine neue Funktion in der DO-Datei des
APS-Dienstes. Schreiben wir Static Future. Und das wird nicht nichtig zurückkehren. Dies wird eine Liste der Knoten zurückgeben. Wir rufen Knoten ab. Und wir werden
die Benutzer-ID hierher schicken. Dann wollen wir den URI, also ist es die
E2IP-Basisliste der Anfrage-URI E2IP-Basisliste der Anfrage-URI Denken Sie daran, das ist die Benutzer-ID. Wir müssen
es nur in der URL senden , da
es sich um eine GT-Anfrage handelt. R-Antwort entspricht einer TPG- und dann einer
Anforderungs-URI, wie hier Wir müssen nichts anderes
schicken. Dann heißt Write List
decodiert , um Json die
Antwort auf diesen Body zu dekodieren Wir wissen, dass es eine Liste sein wird. Und dann gib einfach die
dekodierte Punktkarte zurück. Ich werde alle
Knoten in das Knotenobjekt konvertieren. Notiz von der Karte, wir müssen die Notiz schicken
und das ist falsch. Sie müssen die
JC-Serialisierung für diese Dinge kennen. Ich hoffe also, das sind die
Konzepte von Flattern. Aber verstehe einfach
, dass wir
die Map in ein Notizobjekt konvertieren und es zurückgeben Dann müssen wir auch in
der Provider-Klasse
eine neue Funktion erstellen ,
um diese Fetch Notes aufzurufen Gehe hier zum Notes-Anbieter. Und lassen Sie uns zunächst eine boolesche Variable haben, damit auf dem Startbildschirm eine Ladeanzeige
angezeigt wird damit auf dem Startbildschirm eine Ladeanzeige
angezeigt Wenn es wechselt,
werde ich verhindern, dass Patchknoten synchronisiert werden. Es wird eine Liste von Notizen sein ,
in denen der
Awart-API-Service Notizen abruft. Im Moment werde ich die Benutzer-ID verwenden. Dann werden diese Daten in
aufsteigender Reihenfolge angezeigt, da ich auf der Serverseite
nichts
erwähnt habe der Serverseite
nichts
erwähnt Also werde ich einfach so schreiben,
dass Knoten gleich der
Punkt-Zwei-Liste von Abrufen von
Knoten sind Also habe ich einfach alles
darin umgedreht und dann wieder in
eine Liste umgewandelt und das dann unseren existierenden
Knoten zugewiesen Damit es
bis zum Frontend gesehen werden kann. Denken Sie daran, wenn Sie diese Zeile nicht
schreiben, wird sie auch funktionieren, aber sie wird in aufsteigender Reihenfolge sein Die neuesten Notizen werden also
nicht ganz oben stehen. Du kannst es versuchen. Dann
werde ich hinzufügen, dass Ease Loading Wert False entspricht, und die Zuhörer
benachrichtigen Und ich werde
diesen Patch
im Konstruktor dieses Nodes-Anbieters Fun-Nodes
nennen diesen Patch
im Konstruktor dieses Nodes-Anbieters Fun-Nodes im Konstruktor dieses Nodes-Anbieters Fun-Nodes Wenn also seine Instanz aufgerufen wird, ruft
sie diese
Knotenfunktion und unser Startbildschirm
wird mit den
neuesten Knotendaten gefüllt Gehen Sie jetzt endlich zum Homescreen, hier im Körper Ich werde einfach Notizen schreiben,
vorausgesetzt, dass es geladen wird,
dann ist die Fortschrittsanzeige in der Mitte des untergeordneten Ordners zu sehen
. Das ist es. Lass uns jetzt sehen. Der zirkuläre
Fortschrittsindikator ist da. Ja. Ja, wir haben diese Notiz, die
aus der Datenbank stammt. Also wenn ich es nochmal aktualisiere, dann ist auch diese Notiz da. Das bedeutet also, dass unsere API
auch perfekt funktioniert. Unser Frontend und
Backend sind jetzt miteinander verbunden. Das Letzte, was wir
tun werden, ist,
im nächsten Video gemeinsame Einstellungen
zu verwenden, um die Benutzer-ID zu speichern. Also hier jetzt in
der In the API-Umfrage. Entschuldigung, im Notes-Anbieter. Ich kodiere die Benutzer-ID fest, was nicht gut ist,
weil offensichtlich verschiedene Personen
unterschiedliche Benutzer-IDs haben. Im nächsten Video werden
wir also eine eindeutige
Benutzer-ID erstellen und sie auf
dem Gerät des Benutzers speichern und für die
CRD-Operationen verwenden .
23. Funktion zum Speichern von USERID: Hallo. Willkommen zurück. Also haben wir bis jetzt Dummy-Benutzer-IDs
verwendet. Lassen Sie uns einen
Offline-Datenspeicher wie
gemeinsame Einstellungen verwenden , um
die
von UUID erstellte Benutzer-ID lokal zu speichern die
von UUID erstellte Benutzer-ID Und denken Sie daran, dass wir Werte vom Typ int, string,
double und boolean
nur
in Form von Schlüsselwerten speichern können double und boolean
nur
in Form von Schlüsselwerten Innerhalb gemeinsamer Einstellungen. Ich glaube, Sie können
komplexe Datenmodelle nicht speichern. P, du musst benutzen. Hi, kann es speichern, ich weiß, aber gemeinsame Einstellungen,
ich bin mir nicht sicher. Beenden Sie jetzt Ihre Briefbewerbung
und schreiben Sie im Terminal einfach den Buchstaben P shared pre per. Es wird installiert. Also, wenn ich hier in
den Pub Sec-Dot gehe, kann
ich die gemeinsamen
Einstellungen sehen, okay? Lassen Sie uns nun
eine neue Funktion erstellen, die eine eindeutige
ID für die Benutzer-ID zurückgibt. Lassen Sie uns also in den
bereitgestellten Hinweisen eine neue Funktion
erstellen, eine neue Funktion
erstellen, die eine
Zeichenfolge zurückgibt und die Benutzer-ID abruft. Eine Synchronisation. Okay. Zuallererst werden
wir eine Instanz erstellen, die
auf Flaps verweist, eine gemeinsame Voreinstellung
erhält eine Instanz wie diese Dann werde ich
in einer Ebene eine Zeichenfolge erstellen, die Benutzer-ID geschrieben wird, die vielleicht der Zeichenfolge „get“
entspricht Also werde
ich zunächst versuchen,
die Benutzer-ID vom Gerät zu bekommen . heißt, wenn der
Benutzer kein neuer Benutzer ist,
das heißt, er
verwendet möglicherweise eine Anwendung, sodass die Benutzer-ID gespeichert wird. Jetzt werde ich überprüfen, ob die
Benutzer-ID gleich Null ist, das heißt, es ist ein neuer Benutzer, dann erstelle ich den
Schlüssel, der eine festgelegte Zeichenfolge ist, schreibe
dann die Schlüsselbenutzer-ID, und der Wert hier ist die UUID V vier Es wird eine
eindeutige ID für uns erstellt, und ich werde
diese ID dem Schlüssel zuweisen Entschuldigung, warte. Ich werde es dir erklären. Ich weiß, dass du vielleicht
ein bisschen verwirrt bist. Und zum Schluss werde ich die Benutzer-ID
zurückgeben. Und was nicht Null ist, weiß
ich, weil wir hier
speichern, ob es Null ist, und wenn es nicht Null ist, dann geben wir einfach
die Benutzer-ID direkt zurück. Ich erkläre noch einmal, dass
wir zunächst eine Instanz
von Shared Preference erstellen werden. Dann werden wir prüfen,
ob bereits
ein Benutzer-ID-Schlüssel vorhanden ist. Ist dies nicht der Fall, wenn es Null ist, erstellen wir in der
gemeinsamen Einstellung einen Schlüssel für diese Benutzer-ID und speichern darin eine neue
eindeutige ID. Und dann werde ich
diesen Wert dieser Variablen zuweisen und ihn am Ende zurückgeben. Das bedeutet, dass
diese Funktion trotzdem eine Benutzer-ID zurückgibt. Dann rufe ich
diese Funktion
hier drinnen auf, das ist eine Zeichenfolge, Benutzer-ID ist gleich await
get user ID wie folgt, und ich werde diese
Benutzer-ID an diese Funktion senden Okay. Alles andere ist gut. Dann müssen wir jetzt
die Benutzer-ID in
den gemeinsamen Einstellungen speichern . Jetzt haben wir die Benutzer-ID in
den gemeinsamen Einstellungen gespeichert. Wir müssen
sicherstellen, dass wir
diese Benutzer-ID senden und gleichzeitig
eine neue Notiz hinzufügen. Gehe hier zu dieser Seite. Wir senden eine HD. Ich werde einfach noch einmal schreiben, dass
final s
einer Gewichtung gemeinsamer Referenzen entspricht , die Instanz erhalten. Und da wir ein Gewicht verwenden, müssen
wir es synchronisieren. Dann schreibe ich einfach eine Zeichenketten-Benutzer-ID um vielleicht eine Zeichenfolge zu erhalten, und der ST-Name ist die Benutzer-ID. Der Schlüsselname ist Benutzer-ID. Hier bekommen wir die Benutzer-ID, und ich werde sie hierher schicken. A. Das ist es. Das ist die einzige Änderung, die erforderlich ist. Offensichtlich verwenden
wir hier also keinerlei
Authentifizierung. Ich werde ein paar
andere Kerne darauf machen. Im Moment
ist dieser Kurs ausschließlich der Bedienung von
Rohmaterial und der
Bedienung ohne GS für
Anfänger gewidmet Rohmaterial und der
Bedienung ohne GS für
Anfänger Es gibt eine Menge Dinge, die
du machen kannst, wo du
zumindest jetzt mit den Grundlagen
vertraut bist Ich hoffe, es hat dir gefallen. Im nächsten Video werde
ich die
komplette Anwendung testen, werde
ich die
komplette Anwendung testen da alles andere erledigt
ist. Danke.
24. Die vollständige Anwendung testen: Hallo. Willkommen zum letzten
Video dieses Kurses. In diesem Kurs werden wir einfach die vollständige Funktionsweise
der Anwendung
testen. Bevor wir also weitermachen, löschen
wir alle
vorherigen Datensätze aus der Datenbank, da
diese Dummy-Benutzer-IDs hatten Also werde ich einfach
all diese Dinge löschen. Okay. Also ich glaube, ich habe alles
gelöscht. Lassen Sie uns unsere Anwendung ausführen. Okay. Offensichtlich haben wir im Moment
keine Notizen. Also werde ich kreieren. Und hier werde ich Plattformentwicklung
lernen und sie speichern. Siehe Notiz erfolgreich hinzugefügt. Ich werde eine weitere Notiz hinzufügen. Kein Backend, ich werde einfach
Master Red Operation
mit Mongo schreiben Master Red Operation mit Mongo Ich habe noch zwei, und zum Schluss werde
ich die Übung Daily
Eight schreiben, werde
ich die Übung Daily
Eight schreiben trainieren und programmieren Okay. Ich habe drei Notizen. Und wenn ich anfangen würde, also jetzt, also
habe ich drei Knoten. Und wenn ich dann versuche
, diesen zu aktualisieren. Und lerne nur Nod JS. Mit Mongo DB und Flutter. Wenn ich es einfach aktualisiere, dann schau. Wir haben die Learning-Nicken
und hier haben wir Flatter. Und wenn ich es
nochmal neu starte, dann schauen wir mal. Wir haben dieselben
Daten. Deshalb nenne ich diese Datenbankfunktion am Ende nach Notify
Listeners, weil
die Benutzererfahrung hier offensichtlich sehr gut
ist Der Benutzer muss nicht auf das Speichern der Daten
warten. Er kann es einfach in seiner Benutzeroberfläche sehen. Und wenn ich jetzt auch
diesen lösche, dann siehe Nein, lösche
ihn erfolgreich. Wir haben jetzt nur zwei Notizen, und wenn ich neu gestartet habe
, werden nur zwei Notizen
abgerufen Ich freue mich also, dass die App ohne
Pflug funktioniert. Und wir haben in diesem Kurs
viel gelernt. Offensichtlich war alles
für Anfänger gedacht. Aber wenn Sie die Grundlagen kennen, in Zukunft natürlich können
Sie in Zukunft natürlich auch an komplexen
Projekten arbeiten. Ich hoffe, es hat Ihnen gefallen. Schauen Sie sich auch meine anderen
Kurse an. Danke. Hab einen schönen
Tag und übe weiter.