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

Schritt-für-Schritt-Anleitung zum Erstellen einer Kalenderkomponente mit React

Inhaltsverzeichnis Betriebswirtschaftlicher Hinte...

Der beste Weg, ein JAR-Paketprojekt unter einem Centos7-Server zu starten

Vorwort Jeder weiß, wie man ein JAR-Paket unter L...

Detaillierte Erklärung des CSS3-Rotationswürfelproblems

3D-Koordinatenkonzept Wenn sich ein Element dreht...

Beispielcode einer in Vue3 gekapselten Lupenkomponente

Inhaltsverzeichnis Komponenteninfrastruktur Zweck...

Vue implementiert Video-Upload-Funktion

In diesem Artikelbeispiel wird der spezifische Co...

Zusammenfassung der Binlog-Nutzung der MySQL-Datenbank (unbedingt lesen)

Ich werde nicht näher darauf eingehen, wie wichti...

Detaillierter Prozess der Installation von nginx1.9.1 auf centos8

1.17.9 Wirklich leckerer Nginx-Download-Adresse: ...

Node.js gibt je nach Anforderungspfad unterschiedliche Daten zurück.

Inhaltsverzeichnis 1. Lernen Sie, je nach Anforde...

Spezifische Verwendung von MySQL-Fensterfunktionen

Inhaltsverzeichnis 1. Was ist eine Fensterfunktio...

Lösungen für ungültige Nullsegmentbeurteilungen und IFNULL()-Fehler in MySql

MySql Nullfeldbeurteilung und IFNULL-Fehlerverarb...