In diesem Artikel erfahren Sie, wie Sie effizient eine Map basierend auf einem bestimmten Satz von UUID-Listen in einer Spring Data JPA-Anwendung generieren, wobei der boolesche Wert angibt, ob die UUID in der Datenbankentit?t vorhanden ist. Wir verfolgen einen schrittweisen Ansatz und kombinieren JPA-Warehouse-Abfragen und Java-Streaming-API-Verarbeitung, um Klarheit, Lesbarkeit und Leistung des Codes sicherzustellen.

Gesch?ftsszenarien und Herausforderungen

W?hrend des Entwicklungsprozesses sto?en wir h?ufig auf die Notwendigkeit: Anhand einer Liste von UUIDs müssen wir feststellen, ob diese UUIDs in einem bestimmten Feld (z. B. serviceId) einer Datenbankentit?t (z. B. YourEntityHere) vorhanden sind. Das gewünschte Endergebnis ist eine Map, wobei der Schlüssel der Map jede UUID in der ursprünglichen UUID-Liste ist und der Wert ein boolescher Typ ist, der angibt, ob die UUID in der Datenbank gefunden wird.

Das direkte Generieren dieser Zuordnungsbeziehung durch eine komplexe SQL-Abfrage auf Datenbankebene kann dazu führen, dass die Abfrageanweisung schwer zu verstehen und zu warten ist und in einigen Datenbankdialekten sogar eine schlechte Leistung erbringt. Daher empfehlen wir eine Optimierungsl?sung, die Spring Data JPA und Java Streaming API kombiniert.

Empfohlener Implementierungsplan

Um Lesbarkeit, Leistung und Wartbarkeit in Einklang zu bringen, empfehlen wir, diesen Prozess in zwei Schritte zu unterteilen:

1. Datenbankabfrageschicht: Fragen Sie nur UUIDs ab, die tats?chlich in der Datenbank vorhanden sind.
2. Anwendungsdienstschicht: Basierend auf den Abfrageergebnissen wird die Java-Streaming-API verwendet, um die endgültige Map zu erstellen.

Durch diese Trennungsstrategie bleiben Datenbankabfragen einfach und effizient, w?hrend die Zuordnungslogik im Anwendungsspeicher ausgeführt wird, wodurch die leistungsstarken Sammlungsverarbeitungsfunktionen von Java voll ausgenutzt werden.

1. JPA-Warehouse-Schicht: Vorhandene UUIDs abfragen

In der Spring Data JPA-Warehouse-Schnittstelle k?nnen wir die Annotation @Query verwenden, um eine benutzerdefinierte Abfrage zu definieren, um Service-IDs, die einer bestimmten UUID-Liste entsprechen, aus Entit?ten herauszufiltern.

Nehmen wir an, Ihre Entit?tsklasse hei?t YourEntityHere und Sie haben ein ID-Feld darin (oder ein UUID-Feld, das Sie abgleichen m?chten, z. B. serviceId).

 import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
java.util.List importieren;
java.util.UUID importieren;

?ffentliche Schnittstelle YourEntityHereRepository erweitert JpaRepository<yourentityhere uuid> {

    /**
     * Fragen Sie anhand der angegebenen UUID-Liste die UUIDs ab, die tats?chlich in der Datenbank vorhanden sind.
     *
     * @param uuids Liste der abzufragenden UUIDs.
     * @return Liste der in der Datenbank vorhandenen UUIDs.
     */
    @Query("SELECT yeh.id FROM YourEntityHere yeh WHERE yeh.id IN :uuids")
    List<uuid> findExistingServiceUuids(@Param("uuids") List<uuid> uuids);
}</uuid></uuid></yourentityhere>

Codebeschreibung:

• @Query("SELECT yeh.id FROM YourEntityHere yeh WHERE yeh.id IN :uuids"): Dies ist eine JPQL-Abfrage, die alle ID-Feldwerte aus der YourEntityHere-Entit?t ausw?hlt, vorausgesetzt, dass diese ID-Werte in der eingehenden :uuids-Parameterliste enthalten sind.
• @Param("uuids"): Wird verwendet, um Methodenparameter-UUIDs an benannte Parameter in JPQL-Abfragen zu binden: UUIDs.

2. Serviceschicht: Erstellen Sie UUID und Statuszuordnung

In Ihrer Serviceschicht (oder einer beliebigen Gesch?ftslogikschicht, die das Warehouse aufruft) k?nnen Sie die obige Warehouse-Methode aufrufen, um die Liste der vorhandenen UUIDs abzurufen, und dann die Streaming-API von Java 8 verwenden, um die endgültige Map zu erstellen.

 import org.springframework.stereotype.Service;
java.util.List importieren;
java.util.Map importieren;
java.util.UUID importieren;
import java.util.function.Function;
import java.util.stream.Collectors;

@Service
?ffentliche Klasse YourService {

    privates endgültiges YourEntityHereRepository-Repository;

    public YourService(YourEntityHereRepository-Repository) {
        this.repository = Repository;
    }

    /**
     * Erstellen Sie basierend auf der angegebenen Liste von UUIDs eine Zuordnung der UUIDs zu ihren Existenzzust?nden.
     *
     * @param uuids Liste der zu prüfenden UUIDs.
     * @return Eine Karte, der Schlüssel ist UUID, der Wert ist boolesch (true bedeutet, dass er existiert, false bedeutet, dass er nicht existiert).
     */
    public Map<uuid boolean> getUuidExistenceMap(List<uuid> uuids) {
        // 1. Tats?chlich vorhandene UUIDs aus der Datenbank abfragen
        List<uuid> FoundUuids = inventory.findExistingServiceUuids(uuids);

        // 2. Verwenden Sie die Java-Streaming-API, um eine Zuordnung zu erstellen. // Bestimmen Sie für jede UUID in der Originalliste, ob sie in ?foundUuids“ enthalten ist. return uuids.stream()
                .collect(Collectors.toMap(
                        Function.identity(), // Schlüssel: UUID selbst FoundUuids::contains // Wert: Bestimmen Sie, ob sich die UUID in der FoundUuids-Liste befindet));
    }
}</uuid></uuid></uuid>

Codebeschreibung:

• Repository.findExistingServiceUuids(uuids): Rufen Sie die Repository-Methode auf, um alle in der Datenbank gefundenen UUIDs abzurufen.
• uuids.stream().collect(Collectors.toMap(...)): Dies ist der Kern beim Erstellen einer Karte.
  • Function.identity(): Gibt an, dass der Schlüssel der Map das aktuelle Element im Stream ist (d. h. jede UUID in der ursprünglichen Liste der UUIDs).
  • FoundUuids::contains: Der Wert der angegebenen Map ist ein boolescher Ausdruck, um zu bestimmen, ob die aktuelle UUID in der FoundUuids-Liste enthalten ist. Die Methode List.contains() prüft, ob das Element in der Liste vorhanden ist und gibt true oder false zurück.

Hinweise und Leistungsüberlegungen

• Leistung von List.contains(): Die List.contains()-Methode ist normalerweise eine lineare Suche (O(n)) unter der Haube. Dies kann sich auf die Leistung auswirken, wenn die Liste der gefundenen UUIDs sehr umfangreich ist. In diesem Fall k?nnen Sie die Konvertierung von FoundUuids in HashSet in Betracht ziehen, sodass die durchschnittliche Zeitkomplexit?t von HashSet.contains() O(1) betr?gt, wodurch die Effizienz beim Erstellen von Map verbessert wird.

   // Optimierung: FoundUuids in HashSet konvertieren, um die Sucheffizienz zu verbessern Set<uuid> FoundUuidsSet = new HashSet(repository.findExistingServiceUuids(uuids));
  
  uuids.stream() zurückgeben
          .collect(Collectors.toMap(
                  Function.identity(),
                  FoundUuidsSet::contains // HashSet für O(1)-Suche verwenden));</uuid>

• Komplexit?t einer einzelnen Abfrage: Theoretisch k?nnen Sie versuchen, die für Map erforderlichen Daten durch komplexere Datenbankabfragen (z. B. mithilfe von LEFT JOIN- und CASE-Ausdrücken) direkt auf Datenbankebene zu generieren. Allerdings sind solche Abfragen in der Regel schlecht lesbar, schwer zu debuggen und basieren m?glicherweise auf einem bestimmten Datenbankdialekt. Für solche Mapping-Anforderungen ist es oft vorzuziehen, die Datenabruf- und Mapping-Logik zu trennen.

Zusammenfassen

Durch die Kombination der @Query-Annotation von Spring Data JPA und der Streaming-API von Java 8 k?nnen wir das Problem der Zuordnung von einer Liste von UUIDs zu ihrem Datenbankpr?senzstatus elegant und effizient l?sen. Diese zweistufige Strategie gew?hrleistet nicht nur Codeklarheit und Wartbarkeit, sondern kann bei Bedarf auch die Leistung durch Datenstrukturoptimierung (z. B. Verwendung von HashSet) weiter verbessern. Dies ist eine empfohlene Vorgehensweise für den Umgang mit solchen Gesch?ftsszenarien.

Das obige ist der detaillierte Inhalt vonVerwenden Sie Spring Data JPA, um UUID- und Existenzzustandszuordnungen effizient zu erstellen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!