React Query Database Plugin: Ein Leitfaden zum Arbeiten mit verteilten Systemen

React Query ist eine häufig verwendete Front-End-Datenverwaltungsbibliothek, die uns bei der Verwaltung von Anwendungsdaten helfen kann und leistungsstarke Datenabfrage-, Caching- und Aktualisierungsfunktionen bietet. Wenn unsere Anwendung jedoch mit einem verteilten Datenbanksystem im Backend zusammenarbeiten muss, benötigen wir möglicherweise ein Datenbank-Plugin zur Integration mit React Query. In diesem Artikel wird erläutert, wie Sie das React Query-Datenbank-Plugin für die Arbeit mit verteilten Systemen verwenden, und es werden detaillierte Codebeispiele bereitgestellt.

Das React Query-Datenbank-Plug-in ist eine mittlere Ebene, die für die Interaktion mit dem Back-End-Datenbanksystem erstellt wurde. Seine Hauptfunktion besteht darin, Datenabfrage- und Aktualisierungsanfragen abzufangen und an das Backend-Datenbanksystem weiterzuleiten. Bei der Datenabfrage ist das Datenbank-Plugin dafür verantwortlich, die Daten abzurufen und an React Query zurückzugeben. Im Hinblick auf Datenaktualisierungen ist das Datenbank-Plug-in dafür verantwortlich, Aktualisierungsanfragen an das Back-End-Datenbanksystem zu senden und die aktualisierten Daten an React Query zurückzugeben. Auf diese Weise können wir React Query in jedes verteilte Datenbanksystem integrieren, um Daten abzufragen, zwischenzuspeichern und zu aktualisieren.

Im Folgenden nehmen wir die Zusammenarbeit mit der Firebase-Datenbank als Beispiel, um die Verwendung des React Query-Datenbank-Plug-Ins im Detail vorzustellen.

Zuerst müssen wir die React Query- und Firebase-Plugins installieren und importieren. Geben Sie in der Befehlszeile die folgenden Befehle ein, um React Query und Firebase zu installieren:

npm install react-query firebase

Importieren Sie die React Query- und Firebase-Plug-Ins in die Eintragsdatei der Anwendung:

import { QueryClientProvider, QueryClient } from 'react-query';
import { ReactQueryFirebaseProvider } from 'react-query-firebase';

const firebaseConfig = {...}; // Firebase 配置
const queryClient = new QueryClient();

ReactDOM.render(
  <QueryClientProvider client={queryClient}>
    <ReactQueryFirebaseProvider firebaseConfig={firebaseConfig}>
      <App />
    </ReactQueryFirebaseProvider>
  </QueryClientProvider>,
  document.getElementById('root')
);

Im obigen Code erstellen wir eine QueryClient-Instanz und verpacken das Ganze Sache mit der QueryClientProvider-App. Anschließend verwenden wir ReactQueryFirebaseProvider, um die App-Komponente zu umschließen und Firebase-Konfigurationsinformationen zu übergeben.

Als nächstes müssen wir einen benutzerdefinierten React Query-Hook erstellen, um Daten aus der Firebase-Datenbank abzurufen.

import { useQuery } from 'react-query';
import { firestore } from 'firebase';

const useFirebaseQuery = (collectionPath) => {
  return useQuery(collectionPath, async () => {
    const querySnapshot = await firestore().collection(collectionPath).get();
    return querySnapshot.docs.map((doc) => doc.data());
  });
};

export default useFirebaseQuery;

Im obigen Code haben wir einen benutzerdefinierten Hook „useFirebaseQuery“ erstellt, der den Hook „useQuery“ verwendet, um Daten aus der Firebase-Datenbank abzurufen. Dieser Hook akzeptiert einen CollectionPath-Parameter, der den Pfad der abzufragenden Sammlung darstellt. Bei der Implementierung des Hooks verwenden wir die firestore()-Methode von Firebase, um den Abfrage-Snapshot der Sammlung abzurufen, konvertieren die Dokumentdaten im Snapshot in ein Array und geben sie zurück. Auf diese Weise können wir den useFirebaseQuery-Hook in der Komponente verwenden, um die Daten abzurufen:

import useFirebaseQuery from './hooks/useFirebaseQuery';

const App = () => {
  const { data, status } = useFirebaseQuery('users');

  if (status === 'loading') {
    return <div>Loading...</div>;
  }

  if (status === 'error') {
    return <div>Error fetching data</div>;
  }

  return (
    <ul>
      {data.map((user) => (
        <li key={user.id}>{user.name}</li>
      ))}
    </ul>
  );
};

Im obigen Code verwenden wir den useFirebaseQuery-Hook, um die Daten in der Sammlung mit dem Namen „users“ abzurufen. Je nach Zustand der Daten rendern wir unterschiedliche Komponenten.

Abschließend müssen wir beim Aktualisieren der Daten die Datenaktualisierungsanforderung an das Backend-Datenbanksystem senden. In der Komponente verwenden wir den Hook „useMutation“, um die Daten zu aktualisieren, und senden dann die Aktualisierungsanforderung in der Mutationsfunktion.

import { useMutation, useQueryClient } from 'react-query';
import { firestore } from 'firebase';

const useFirebaseMutation = (collectionPath) => {
  const queryClient = useQueryClient();

  return useMutation(
    async (data) => {
      await firestore().collection(collectionPath).add(data);
    },
    {
      onSuccess: () => {
        queryClient.invalidateQueries(collectionPath);
      },
    }
  );
};

export default useFirebaseMutation;

Im obigen Code verwenden wir den useMutation-Hook, um einen benutzerdefinierten Hook useFirebaseMutation zum Senden von Aktualisierungsanfragen für Daten zu erstellen. Dieser Hook akzeptiert einen CollectionPath-Parameter, der den Pfad der zu aktualisierenden Sammlung darstellt. In der Mutationsfunktion verwenden wir die firestore()-Methode von Firebase, um neue Dokumentdaten zur Sammlung hinzuzufügen. Nachdem die Daten erfolgreich aktualisiert wurden, verwenden wir die Methode queryClient.invalidateQueries, um alle Abfragen ungültig zu machen, die mit dem Sammlungspfad übereinstimmen.

Das Folgende ist ein Beispielcode für die Verwendung des useFirebaseMutation-Hooks zum Aktualisieren von Daten in einer Komponente:

import useFirebaseMutation from './hooks/useFirebaseMutation';

const AddUserForm = () => {
  const { mutate } = useFirebaseMutation('users');

  const handleSubmit = (event) => {
    event.preventDefault();

    const name = event.target.elements.name.value;
    const email = event.target.elements.email.value;

    mutate({ name, email });

    event.target.reset();
  };

  return (
    <form onSubmit={handleSubmit}>
      <input type="text" name="name" placeholder="Name" required />
      <input type="email" name="email" placeholder="Email" required />
      <button type="submit">Add User</button>
    </form>
  );
};

Im obigen Code verwenden wir den useFirebaseMutation-Hook, um eine Mutate-Funktion zum Senden einer Aktualisierungsanforderung für Daten zu erstellen. Wenn das Formular gesendet wird, rufen wir den Namen und die E-Mail-Adresse des hinzuzufügenden Benutzers aus dem Formularelement ab und rufen die Mutate-Funktion auf, um die Daten zu aktualisieren.

Durch die oben genannten Schritte haben wir erfolgreich mit verteilten Datenbanksystemen (wie Firebase) zusammengearbeitet, basierend auf der Verwendung des React Query-Datenbank-Plug-Ins. Wir können den Hook „useFirebaseQuery“ verwenden, um Daten abzurufen, und den Hook „useFirebaseMutation“, um die Daten zu aktualisieren. Auf diese Weise können wir die Daten der Anwendung bequemer verwalten und effizienter mit dem Backend-Datenbanksystem zusammenarbeiten.

Dieser Artikel enthält ein Integrationsbeispiel mit dem Firebase-Datenbanksystem, Sie können das React Query-Datenbank-Plugin jedoch auch mit anderen verteilten Datenbanksystemen integrieren. Implementieren Sie einfach die entsprechende Hook-Funktion gemäß der API-Dokumentation der Backend-Datenbank, um mit der Datenbank zusammenzuarbeiten.

Kurz gesagt, das React Query-Datenbank-Plugin ist ein leistungsstarkes Tool, das uns dabei helfen kann, die Daten der Anwendung einfach zu verwalten und mit dem verteilten Datenbanksystem im Backend zusammenzuarbeiten. Durch die Integration mit React Query können wir unsere Anwendungen effizienter entwickeln und warten und ein besseres Benutzererlebnis bieten.

Ich hoffe, dieser Artikel hilft Ihnen zu verstehen, wie Sie das React Query-Datenbank-Plugin für die Zusammenarbeit mit verteilten Systemen verwenden. Viel Glück bei der Verwendung von React Query und Datenbank-Plugins!

Das obige ist der detaillierte Inhalt vonReact Query Database Plugin: Ein Leitfaden zum Arbeiten mit verteilten Systemen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!