vue + springboot realisiert die Login-Funktion

vue + springboot realisiert die Login-Funktion

In diesem Artikelbeispiel wird der spezifische Code von vue + springboot zur Realisierung der Anmeldefunktion zu Ihrer Information geteilt. Der spezifische Inhalt ist wie folgt

1. Implementierung der Login-Funktion

Der Code zum Absenden des Formulars lautet wie folgt:

async submitForm(Benutzer) {
        dies.$refs[Benutzer].validate((gültig) => {
               wenn(gültig){
                        Alarm("Benutzer");
                        dies.$axios.post("http:localhost:8087/user/login?code="+this.code,user).then(res => {
                            Alarm("Erfolg")
                             wenn(res.data.state){
                                 alert(res.data.msg+"Anmeldung erfolgreich, werde gleich zur Startseite springen...");
                             }
                             anders{
                                 Alarm (res.data.msg);
                             }
                        });
                    }
                    anders{
                        gibt false zurück;
           }
   });
},

Es war ein Schlag auf den Kopf und mir dröhnte der Kopf.

Dieses Ding hat mehrere Tage lang gebrummt und wurde schließlich von mir mit einem relativ dummen Code implementiert. Die konkrete Idee ist wie folgt:

Zuerst hole ich mir im Hintergrund den echten Verifizierungscode des aktuellen Verifizierungscodebildes und übergebe ihn an das Frontend:

if (gültig) {
        Konsole.log(dieser.Benutzer);
         dies.$axios.get("http://localhost:8087/user/getCode").dann(res => {
                  Lassen Sie tcode = res.data.toLowerCase();
                  wenn (tcode == dieser.code) {
                                überprüfen(diesen.Benutzer);
                            } anders {
                                alert('Fehler beim Bestätigungscode!');
                            }
                        });
                    }

Bei der Überprüfung in der Mitte überprüfe ich den Benutzernamen und das Kennwort des sich anmeldenden Benutzers. Der Überprüfungscode generiert zuerst einen vierstelligen Überprüfungscode, konvertiert ihn dann in eine Zeichenfolge im Base64-Format und übergibt ihn schließlich an das Front-End. Das Back-End gibt den Zeichenfolgencode zurück.

@GetMapping("/getCode")
    @ApiOperation(value="Bestätigungscode abrufen", notes="Bestätigungscode vom Backend abrufen und an das Frontend senden")
    öffentliche Zeichenfolge getCode (HttpServletRequest-Anforderung) {
        Zeichenfolgenschlüssel = (Zeichenfolge)request.getServletContext().getAttribute("Code");
        log.info("Schlüssel:[{}]",Schlüssel);
        Eingabetaste;
    }

Ich habe analysiert, dass der Grund, warum das Frontend des Anmeldemoduls keine Werte an das Backend übergeben konnte, darin lag, dass das Frontend nur einen Benutzernamen und ein Passwort hatte. Dann dachte ich fälschlicherweise, dass ein Formular mit nur einem Benutzernamen und einem Passwort ein Objekt bilden könnte, was dazu führte, dass das Formular zwangsweise in ein Objekt umgewandelt und an das Backend übergeben werden musste. Dies führte zu einer Endlosschleife und ich steckte lange Zeit bei diesem Problem fest. Bisher wurden Benutzername, Passwort und Bestätigungscode an das Backend weitergegeben und blieben dort hängen. Ich hole mir zuerst den Bestätigungscode vom Backend und vergleiche ihn mit dem Frontend, um zu sehen, ob er korrekt ist. Dann übergebe ich den vom Benutzer eingegebenen Benutzernamen und das Passwort an das Backend, um die Datenbank nach dem Benutzer mit dem entsprechenden Benutzernamen zu durchsuchen. Wenn der Benutzer gefunden werden kann, bedeutet dies, dass der Benutzer existiert, andernfalls existiert der Benutzer. Als nächstes wird verglichen, ob das vom Benutzer eingegebene Passwort mit dem in der Datenbank gespeicherten Passwort übereinstimmt. Wenn sie übereinstimmen, wird „true“ zurückgegeben und die Anmeldung ist erfolgreich. Andernfalls schlägt sie fehl. Der spezifische Implementierungscode lautet wie folgt:

//BenutzerController
 @PostMapping("/Anmelden")
    @ApiOperation(value = "Anmeldung am System", notes = "Anmeldung am Mitarbeiterverwaltungssystem")
    öffentliche Map<String,Objekt> login(@RequestParam String Name,@RequestParam String Pwd){
        System.out.println(Name+" "+Pwd);
        Map<String,Objekt> map = neue HashMap<>();
        versuchen{
            Benutzer userdb = userService.login(Name,Pwd);
            map.put("Zustand",true);
            map.put("msg","Anmeldung erfolgreich");
            map.put("Benutzer",Benutzerdb);
        }fang(Ausnahme e){
            e.printStackTrace();
            map.put("Zustand",falsch);
            map.put("msg",e.getMessage());
        }
        log.info("[{}]",map.toString());
        Rückfahrkarte;
    }
//BenutzerServiceImpl
 @Überschreiben
    öffentliche Benutzeranmeldung(String Name,String Pwd) {
        Benutzer userDB = userMapper.selectByName(Name);
        if(!ObjectUtils.isEmpty(userDB)){
            wenn (userDB.getPwd().equals(Pwd)) {
                Benutzer-DB zurückgeben;
            }
            anders{
                throw new RuntimeException("Falsches Passwort");
            }
        }
        anders{
            throw new RuntimeException("Benutzer existiert nicht");
        }
    }
//UserMapper.java
Benutzer selectByName(Stringname);
<!--UserMapper.xml-->
 <select id="selectByName" parameterType="String" resultType="com.sunset.system.entity.User">
        Wählen Sie ID, Name, Alter, Geschlecht, Passwort, Abteilung, Gehalt
        vom Benutzer, wobei Name = #{name}
</Auswählen>

Während des Codierungsprozesses ist mir ein kleiner Vorfall begegnet, bei dem Name = "#{name}" einen Fehler bei der Datenbanksuche verursacht hat. Ich hoffe, dass die Leute, die diesen Artikel lesen, diese Falle vermeiden können.
Auf diese Weise wird die Backend-Logik implementiert. Folgendes ist die Frontend-Logik:

asynchrone Funktion überprüfen (Benutzerinfo) {
      const {data: res} = warte auf „VerifyUser(Benutzerinfo);“
      konsole.log(res);
          wenn (res.state == true) {
               _diese.$nachricht({
                 Titel: „Verifizierung erfolgreich“,
                 Nachricht: „Willkommen im Mitarbeiterverwaltungssystem“,
                  Typ: „Erfolg“
            });
      window.location.href = "http://www.baidu.com";
      //warte _darauf.$router.push("http://www.baidu.com");
       } anders {
           _diese.$nachricht({
            Titel: „Verifizierung fehlgeschlagen“,
         Nachricht: res.msg,
          Typ: „Fehler“
       })
       gibt false zurück;
     }
}

Hier verwenden wir die Axios-Post-Anfrage, der spezifische Pfad ist projectName.src.api, um eine neue user.js-Datei zu erstellen

export const verifyUser = (Benutzer) => {
    Rückgabeanforderung({
        URL: "/Benutzer/Login",
        Methode: 'post',
        Parameter: {
            Name: Benutzer.Name,
            Kennwort: Benutzer.Kennwort
        }
    })
}

Darüber hinaus müssen Sie request.js konfigurieren, der Dateipfad lautet projectName.src.utils

Axios von „Axios“ importieren

const Instanz = axios.create({
  baseURL: 'http://localhost:8080', //Port des Backend-Projekts Timeout: 10000,
  Kopfzeilen: {'X-Custom-Header': 'foobar'}
});

Standardinstanz exportieren;

Wenn Sie weitere logische Fragen haben, können Sie diese gerne diskutieren.

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, er wird für jedermanns Studium hilfreich sein. Ich hoffe auch, dass jeder 123WORDPRESS.COM unterstützen wird.

Das könnte Sie auch interessieren:
  • Trennung von Springboot + VUE-Frontend und Backend zur Realisierung der Epidemiepräventionsplattform JAVA
  • Springboot + Vue realisiert die Bestätigungscodefunktion
  • Domänenübergreifende Probleme bei der Trennung von Front-End und Back-End von Vue+SpringBoot
  • SpringBoot + VUE implementiert die Datentabellenpraxis
  • Realisierung eines Garbage-Klassifizierungsmanagementsystems basierend auf Springboot+Vue
  • SpringBoot+MyBatisPlus+Vue - Schneller Konstruktionsprozess für Front-End- und Back-End-Trennungsprojekte (Front-End-Kapitel)
  • SpringBoot+MyBatisPlus+Vue - Schneller Konstruktionsprozess für Front-End- und Back-End-Trennprojekte (Back-End)
  • Springboot+Vue-Produktionshintergrundverwaltungssystemprojekt

<<:  Beispiel für eine einfache Operation einer MySQL-Abfrageanweisung

>>:  Beispiel für die Ausführung eines MySQL-Befehlszeilenskripts

Artikel empfehlen

XHTML verwendet einige veraltete Elemente in HTML nicht mehr

Wenn wir CSS-Webseitenlayouts erstellen, wissen wi...

js zur Realisierung der Web-Message-Board-Funktion

In diesem Artikelbeispiel wird der spezifische JS...

So stellen Sie Daten mit Binlog in MySQL 5.7 wieder her

Schritt 1: Stellen Sie sicher, dass MySQL Binlog ...

CSS zum Erzielen des Effekts einer rotierenden Flip-Card-Animation

Die CSS-Animation des rotierenden Flip-Effekts, d...

Erläuterung der objektorientierten Klassenvererbung in JavaScript

1. Objektorientierte Klassenvererbung In den obig...

Tiefgreifendes Verständnis der verschiedenen Sperren von MySQL

Inhaltsverzeichnis Schlossübersicht Sperrklassifi...

js, um einen gleitenden Karusselleffekt zu erzielen

In diesem Artikel wird der spezifische Code von j...

Ausführliches Tutorial zur Installation von Deepin in VMware15 (Bild und Text)

Vorwort Die Benutzeroberfläche von Deepin sieht w...

Zusammenfassung gängiger Fehler beim Entwurf von MySQL-Tabellen

Inhaltsverzeichnis Fehler 1: Zu viele Datenspalte...