Verwalten des Auth-Status in React mithilfe der useContext-API

Dieses Code-Snippet ist alles, was Sie brauchen, um den Authentifizierungsstatus Ihrer React-Anwendung zu verwalten. Verwendet die Kontext-API, um den Benutzerstatus in der gesamten Anwendung zu verwalten.

Kein Geplapper mehr, lass uns einfach eintauchen.

Importe und Typdefinitionen

import { createContext, Dispatch, ReactNode, SetStateAction, useContext, useEffect } from "react";
import { useLocalStorage } from "../utils/useLocalStorage";

type SignInForm = { email: string; password: string; };
type User = { id: number; email: string; };
type AuthState = User & { exp: number };
type UserContextType = {
  user: User | null;
  setUser: Dispatch<setstateaction null>>;
  signOut: () => Promise<string undefined>;
  signIn: (signInForm: SignInForm) => Promise<string undefined>;
};
</string></string></setstateaction>

Wir beginnen mit dem Importieren der erforderlichen React-Hooks und eines benutzerdefinierten useLocalStorage-Hooks. Anschließend definieren wir TypeScript-Typen für unser Authentifizierungssystem, einschließlich SignInForm, User, AuthState und UserContextType.

Erstellen des Kontexts und des benutzerdefinierten Hooks

const AuthDataContext = createContext<usercontexttype undefined>(undefined);

export const useAuth = (): UserContextType => {
  const context = useContext(AuthDataContext);
  if (!context) {
    throw new Error("useAuth must be used within a UserDataProvider");
  }
  return context;
};
</usercontexttype>

Hier erstellen wir den AuthDataContext und einen benutzerdefinierten useAuth-Hook. Dieser Hook stellt sicher, dass wir den Kontext innerhalb eines Anbieters verwenden und bietet eine bequeme Möglichkeit, auf unseren Authentifizierungsstatus zuzugreifen.

AuthProvider-Komponente

export const AuthProvider = ({ children }: { children: ReactNode }) => {
  const [user, setUser] = useLocalStorage<authstate null>("user", null);

  // ... (other functions)

  return (
    <authdatacontext.provider value="{{" user setuser signin signout>
      {children}
    </authdatacontext.provider>
  );
};
</authstate>

Die AuthProvider-Komponente ist der Kern unseres Authentifizierungssystems. Es verwendet den useLocalStorage-Hook, um den Benutzerstatus beizubehalten und den Kontextwert für seine untergeordneten Elemente bereitzustellen.

JWT-Ablaufprüfung

const isJwtExpired = (unixTime: number) => {
  const currentTime = Math.floor(Date.now() / 1000);
  const timeRemaining = unixTime - currentTime;
  if (timeRemaining 



<p>Diese Funktion prüft, ob das JWT abgelaufen ist und protokolliert die verbleibende Zeit, wenn es noch gültig ist.</p>

<h2>
  
  
  Abmeldefunktion
</h2>



<pre class="brush:php;toolbar:false">const signOut = async () => {
  const res = await fetch("http://localhost:8080/auth/signout", { method: "POST" });
  setUser(null);
  if (!res.ok) {
    console.log("Error signing out");
    return (await res.text()) || "Something went wrong";
  }
};

Die SignOut-Funktion stellt eine POST-Anfrage an den Signout-Endpunkt und löscht den Benutzerstatus.

Anmeldefunktion

const signIn = async (signInForm: SignInForm) => {
  const res = await fetch("http://localhost:8080/auth/signin", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(signInForm),
  });
  if (!res.ok) {
    return (await res.text()) || "Something went wrong";
  }
  const data = (await res.json()) as { user: User; exp: number };
  if (data) {
    setUser({ ...data.user, exp: data.exp });
  }
};

Die SignIn-Funktion sendet die Anmeldeinformationen des Benutzers an den Anmeldeendpunkt und aktualisiert den Benutzerstatus mit den Antwortdaten.

useEffect für die JWT-Ablaufprüfung

useEffect(() => {
  if (!user) return;
  if (isJwtExpired(user.exp)) signOut();
}, [user]);

Dieser Effekt wird immer dann ausgeführt, wenn sich der Benutzerstatus ändert. Dabei wird überprüft, ob das JWT abgelaufen ist, und bei Bedarf abgemeldet.

Hier ist übrigens eine Beispielimplementierung des useLocalStorage-Hooks

import { useState, useEffect, Dispatch, SetStateAction } from "react";

export function useLocalStorage<t>(
  key: string,
  initialValue: T
): [T, Dispatch<setstateaction>>] {
  const [storedValue, setStoredValue] = useState<t>(() => {
    try {
      const item = localStorage.getItem(key);
      return item ? JSON.parse(item) : initialValue;
    } catch (error) {
      console.log(error);
      return initialValue;
    }
  });

  const setValue: Dispatch<setstateaction>> = (value) => {
    try {
      const valueToStore =
        value instanceof Function ? value(storedValue) : value;
      setStoredValue(valueToStore);
      localStorage.setItem(key, JSON.stringify(valueToStore));
    } catch (error) {
      console.log(error);
    }
  };

  useEffect(() => {
    const handleStorageChange = (event: StorageEvent) => {
      if (event.key === key) {
        setStoredValue(JSON.parse(event.newValue || "null"));
      }
    };

    window.addEventListener("storage", handleStorageChange);
    return () => window.removeEventListener("storage", handleStorageChange);
  }, [key]);

  return [storedValue, setValue];
}
</setstateaction></t></setstateaction></t>

und schon bist du fertig? easy peasy Lemon Squeezy. Stellen Sie sicher, dass Sie bei Bedarf die Abruflogik für Ihre eigene API-Struktur ändern.

Das obige ist der detaillierte Inhalt vonVerwalten des Auth-Status in React mithilfe der useContext-API. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!