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

Detaillierte Erläuterung der Verwaltung und Verwendung von Docker Secrets

1. Was ist Docker Secret 1. Szenariodarstellung W...

Installation von VMware Workstation unter Linux (Ubuntu)

Wenn Sie nicht wissen, wie das System auf dem Com...

Grundlegendes Handbuch für Webdesign 216 Websichere Farben

Die Farbdarstellung auf einer Webseite wird von ve...

So konfigurieren Sie Benutzerrollenberechtigungen in Jenkins

Die Jenkins-Konfiguration von Benutzerrollenberec...

Verwendung von Docker UI, einem Docker-Visualisierungsverwaltungstool

1. Einführung in DockerUI DockerUI basiert auf de...

Implementierungscodebeispiel für die lokale Verzeichniszuordnung von Nginx

Manchmal müssen Sie auf einige statische Ressourc...

Zusammenfassung zum Sharding von MySQL-Datenbanken und -Tabellen

Während der Projektentwicklung werden unsere Date...

Tutorial zu HTML-Formular-Tags (4):

Nehmen Sie nun an, dass Sie dem Formular ein Elem...

Ausführliche Erklärung der Closure in JavaScript

Einführung Closure ist eine sehr leistungsstarke ...

Beispielmethode zum Anzeigen der mit MySQL verbundenen IP-Adresse

Spezifische Methode: Öffnen Sie zuerst die Eingab...

Mobiles Internet-Zeitalter: Responsive Webdesign ist zum allgemeinen Trend geworden

Wir befinden uns in einer Ära der rasanten Entwick...