So verwenden Sie Node-Scaffolding zum Erstellen eines Servers zur Implementierung der Token-Verifizierung

Inhalt

Verwenden Sie Scaffolding, um schnell ein Knotenprojekt zu erstellen
Verwenden Sie den MySQL-Verbindungspool, um mit der Datenbank zu interagieren
Implementierung der Token-Authentifizierung mit jsonwebtoken
Umfassendes Beispiel: Umsetzung des oben Gesagten mit einer einführenden Anmeldeseite

1. Erstellen Sie schnell ein Knotenprojekt

Wir alle wissen, dass das Express-Framework Knotenserver effizient entwickeln kann, aber die zugrunde liegende Konstruktion hängt immer noch von der Handschrift ab. Das Aufkommen des Express-Generators löst dieses Problem jedoch sehr gut. Er kann mit einem Klick das Grundgerüst des Projekts für uns generieren, das als Knotengerüst bezeichnet werden kann.

1.1 Projekt generieren

①: Installieren Sie Express zuerst global: npm install express -g
②: Installieren Sie dann den Express-Generator global: npm install express-generator -g
③: Verwenden Sie dann den Befehl, um ein Projekt zu erstellen: express token_learn (Projektname)

1.2 Ändern der Eintragsdatei

Für viele Leute, die es gewohnt sind, Server manuell zu betreiben, bleibt app.js unvergessen, aber die Einstiegsdatei in diesem Skelett ist www.js. An diesem Punkt können wir den app.js-Code manuell ändern, um ihn zu unserer Einstiegsdatei zu machen

Beispiel:

var express = erforderlich('express');
var Pfad = erforderlich('Pfad');
var cookieParser = erforderlich('cookie-parser');

const index = erfordern('./routes/index');
const Benutzer = erfordern('./routes/users');

const app = express();

app.use(express.json());
app.use(express.urlencoded({ erweitert: false }));
app.use(cookieParser());
app.use(express.static(Pfad.join(__dirname, 'public')));

app.use('/', index);
app.use('/Benutzer', Benutzer);

app.listen(3000, () => console.log('Server läuft 3000'))

2. Verbindung zur MySQL-Datenbank herstellen

Der Verbindungspool wird hier zur Verbindung verwendet (effizient und sicher)

2.1 Verbindung herstellen

①: MySQL-Modul installieren: npm i mysql
②: Konfigurieren Sie den Verbindungspool im Stammverzeichnis des Projekts

Erstellen Sie zunächst einen util-Ordner im Stammverzeichnis des Projekts und erstellen Sie eine bdconfig.js-Datei im Ordner

bdconfig.js

const mysql = erfordern('mysql');

modul.exporte = {
  mysqlParams: {
    Host: 'localhost', //Domänenname Port: '3306', //Port Benutzer: 'root', //Benutzername Passwort: 'myroot', //Passwort Datenbank: 'nodeapi' //Datenbank},
  sySqlConnect(sql, sqlArr) {
    return new Promise((resolve, reject) => { //Transformiere es mit einem Promise-Objekt, um den Datenempfang zu erleichtern const pool = mysql.createPool(this.mysqlParams);
      pool.getConnection((err, conn) => {
        wenn (Fehler) {
          ablehnen (Fehler)
        } anders {
          conn.query(sql, sqlArr, (err, data) => { //Datenbank ausführenwenn (err) {
              ablehnen (Fehler)
            } anders {
              auflösen (Daten)
            }
          })
          conn.release() //Verbindung lösen}
      })
    })
  }
}

2.2 Verbindungen verwenden

Bei der Verwendung müssen Sie nur SQL (SQL-Anweisung) und SQLArr (Parameter) übergeben. Nach der Promise-Transformation können Sie den Rückgabewert direkt verwenden, um das Ergebnis abzurufen

3. Token-Authentifizierung

Mit der Entwicklung des Webs wurden die Mängel der Sitzungs- und Cookie-Authentifizierungsmethoden immer deutlicher. Zu dieser Zeit wurden Token geboren. Die Leistungsfähigkeit von Token beschränkt sich nicht nur auf ihre Statuslosigkeit, sondern auch darauf, dass sie domänenübergreifend verwendet werden können.

3.1 Schritte zur Umsetzung

①: Installieren Sie zuerst das Modul jsonwebtoken: npm i jsonwebtoken
②: Dann verwenden Sie das Modul im Projekt

const dbConfig = erfordern('../util/dbconfig');
const jwt = erfordern('jsonwebtoken');
const secret = 'login-rule'; //Geheime Schlüsselregel (benutzerdefiniert)

token = async(req, res, next) => { //Middleware-Funktion zur Token-Verifizierung definieren (wird auf alle Anfragen außer der Anmeldung angewendet)
  wenn (erf.headers.authorization) {
    const token = erforderlich.header.authorization;
    const { id, username } = jwt.verify(token, secret); // Entschlüsseln und Token finden let sql = 'select * from test where id=?';
    sei sqlArr = [id];
    let result = warte auf dbConfig.sySqlConnect(sql, sqlArr);
    wenn (Ergebnis.Länge === 0) {
      res.status(200).send({ msg: 'Benutzerfehler' })
      zurückkehren
    }
    if (Benutzername !== Ergebnis[0].Benutzername) {
      res.status(200).send({ msg: 'Benutzerfehler' })
    } anders {
      nächste()
    }
  } anders {
    res.status(200).send({ msg: 'Ungültiger Anforderungsheader' })
  }
}

login = async(req, res) => { //Definiere die Anmeldeschnittstelle (da dieser Anforderungsheader kein Token enthält, wird er vor der Token-Verifizierungs-Middleware referenziert)
  let { Benutzername, Passwort } = req.body;
  let sql = 'Wählen Sie * aus Test aus, wobei Benutzername=?';
  let sqlArr = [Benutzername];
  let result = warte auf dbConfig.sySqlConnect(sql, sqlArr);
  if (Ergebnis.Länge) {
    if (Passwort === Ergebnis[0].Passwort) {
      const { id, Benutzername } = Ergebnis[0];
      //Token verschlüsseln und dem Client antworten (Parameter 1: Regel zur Wertübertragung; Parameter 2: Verschlüsselungsregel; Parameter 3: Definitionszeit)
      const token = jwt.sign({ id, benutzername }, secret, { expiresIn: 60 * 60 });
      res.status(200).send({ msg: 'Anmeldung erfolgreich', token: token, status: 200 });
    } anders {
      res.status(200).send({ msg: 'Anmeldung fehlgeschlagen', status: 422 });
    }
  } anders {
    res.status(200).send({ msg: 'Benutzername existiert nicht', status: 401 })
  }
}

// Identitäts-Middleware überprüfen module.exports = {
  Zeichen,
  Login
}

③: In app.js konfigurieren

//Schreiben Sie nach app.use() und vor dem Routing app.use('/users/loginjwt', token.login); //Anmeldeschnittstelle (Token muss nicht überprüft werden, schreiben Sie also vor der Token-Middleware)
app.verwenden(token.token);

4. Fallimplementierungstoken

4.1 Grundsatz

Um sicherzustellen, dass die Identität eindeutig und gültig ist: Jedes Mal, wenn ein Benutzer eine Anmeldeanforderung sendet und sich erfolgreich anmeldet, antwortet der Server dem Benutzer mit einem verschlüsselten Token (Zeichenfolge), das Benutzerinformationen (eindeutig) enthält. Zu diesem Zeitpunkt erhält der Benutzer das Token und speichert es in sessionStorage oder localStorage (hier). Gleichzeitig wird jedes Mal, wenn der Benutzer eine weitere Anfrage sendet, das lokale Token im Anfrageheader mitgeführt. Die serverseitige Token-Verifizierungs-Middleware fängt die Anfrage ab, entschlüsselt das Token, erhält die Benutzerinformationen und vergleicht sie mit der Datenbank. Wenn die Informationen vorhanden sind, werden sie freigegeben (Authentifizierung erfolgreich).

4.2 Effektvorschau

4.3 Beginnen Sie mit der Umsetzung

Schreiben Sie einfache statische Seiten und implementieren Sie Ajax-Anfragen

anmelden.html

<!DOCTYPE html>
<html lang="de">

<Kopf>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=Gerätebreite, Anfangsmaßstab=1.0">
  <script src="../javascripts/jquery.min.js"></script>
  <title>Dokument</title>
</Kopf>

<Text>
  <form id="loginform">
    <input type="text" name="Benutzername">
    <input type="Passwort" name="Passwort">
    <input type="submit" value="Anmelden">
  </form>
  <Skript>
    $(Funktion() {
      $('#loginform').on('senden', function() {
        const formdata = $(this).serialize()
        $.ajax({
          URL: '/Benutzer/loginjwt',
          Typ: "Beitrag",
          Daten: Formulardaten,
          Erfolg(res) {
            wenn (res.status === 200) {
              window.sessionStorage.setItem('token', res.token);
              location.href = "/Benutzer/index.html"
            }
          }
        })
        return false
      })
    })
  </Skript>
</body>
</html>

Hauptseite

<Skript>
  wenn (!sessionStorage.getItem('token')) {
    location.href = "/Benutzer/login.html"
  }
</Skript>
<!DOCTYPE html>
<html lang="de">

<Kopf>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=Gerätebreite, Anfangsmaßstab=1.0">
  <script src="../javascripts/jquery.min.js"></script>
  <title>Dokument</title>
</Kopf>

<Text>
  <h1>Willkommensindex</h1>
  <a href="javascript:;" rel="external nofollow" >Abmelden</a>
  <Skript>
    $(Funktion() {
      $.ajaxSetup({
        // Wird vor dem Senden der Anfrage ausgelöst beforeSend(xhr) {
          // Legen Sie hier einen benutzerdefinierten Anforderungsheader fest xhr.setRequestHeader('authorization', sessionStorage.getItem('token'))
        }
      })
      $.ajax({
        URL: „/Benutzer“,
        Erfolg(res) {
          konsole.log(res);
        }
      })
      $('a').on('click', function() {
        sessionStorage.clear();
        location.href = "/Benutzer/login.html"
      })
    })
  </Skript>
</body>
</html>

4.4 Hinweise

Es ist zu beachten, dass die Überprüfung des lokalen Tokens (ob es vorhanden ist) oben auf der Seite stehen muss (um zu verhindern, dass die Seite die Benutzerlistenanforderung erneut lädt und sendet).
Es ist wirklich mühsam, Ajax-Anforderungsheader einzeln hinzuzufügen. Hier wird die Methode $ajaxSetup verwendet, um die Standardkonfiguration von Ajax zu ändern. Nach der Konfiguration verfügen alle darunter geschriebenen Ajax-Anfragen über Anforderungsheader.

Dies ist das Ende dieses Artikels über die Verwendung von Node-Scaffolding zum Erstellen eines Servers und zur Implementierung der Token-Verifizierung. Weitere relevante Inhalte zur Node-Token-Verifizierung finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!

Das könnte Sie auch interessieren:

Beispiel für die Implementierung der Node-Anmeldeberechtigungsüberprüfungstokenüberprüfung
So stellen Sie Token mithilfe von JWT in Node aus und verifizieren sie
Node implementiert tokenbasierte Authentifizierung
Node.js+captchapng+jsonwebtoken zur Implementierung eines Beispiels zur Anmeldeüberprüfung

<<: So dekomprimieren Sie mehrere Dateien mit dem Befehl „unzip“ in Linux

>>: Tiefgreifendes Verständnis von UID und GID in Docker-Containern