Exemple de code pour l'envoi de données - OpenSearch - Centre de documentation Alibaba Cloud

Utilisez le SDK OpenSearch pour Java V3.1 afin d'ajouter, de mettre à jour et de supprimer des documents dans une table OpenSearch en mode commit. En mode commit, vous regroupez les documents dans un tampon client et les envoyez vers l'index via un seul appel à la méthode commit().

Cette approche est particulièrement adaptée aux scénarios suivants :

Fusionner et envoyer des données de manière dynamique
Envoyer un document unique
Envoyer un petit nombre de documents à la fois

Important

Vous ne pouvez envoyer des données que vers les champs d'une même table. L'envoi de données entre plusieurs tables n'est pas pris en charge.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

Une application OpenSearch et une table vers laquelle envoyer les données
Une paire AccessKey associée à un utilisateur RAM disposant des autorisations accordées par le rôle lié au service AliyunServiceRoleForOpenSearch. Pour plus d'informations, consultez les Règles d'autorisation d'accès
Le SDK OpenSearch pour Java V3.1 ajouté à votre projet

Important

Utilisez la paire AccessKey d'un utilisateur RAM, et non les identifiants racine de votre compte Alibaba Cloud. Les identifiants racine accordent l'accès à toutes les opérations API et présentent un risque de sécurité plus élevé. Pour créer un utilisateur RAM et une paire AccessKey, consultez les rubriques Créer un utilisateur RAM et Créer une paire AccessKey.

Configurer les variables d'environnement

Stockez vos identifiants sous forme de variables d'environnement plutôt que de les coder en dur dans le code source. Des identifiants codés en dur peuvent être accidentellement envoyés vers un système de contrôle de version, ce qui compromettrait la sécurité de votre compte.

Linux et macOS

Remplacez <access_key_id> et <access_key_secret> par l'ID AccessKey et la clé secrète AccessKey de votre utilisateur RAM, puis exécutez la commande suivante :

export ALIBABA_CLOUD_ACCESS_KEY_ID=<access_key_id>
export ALIBABA_CLOUD_ACCESS_KEY_SECRET=<access_key_secret>

Windows

Créez un fichier de variables d'environnement et ajoutez les variables ALIBABA_CLOUD_ACCESS_KEY_ID et ALIBABA_CLOUD_ACCESS_KEY_SECRET avec leurs valeurs correspondantes.
Redémarrez Windows pour que les modifications prennent effet.

Fonctionnement du mode commit

Le mode commit utilise un tampon côté client pour regrouper les opérations sur les documents :

Créez un objet DocumentClient en chaînant les instances OpenSearch → OpenSearchClient → DocumentClient.
Appelez les méthodes add(), update() ou remove() pour préparer les documents dans le tampon.
Appelez la méthode commit(appName, tableName) pour envoyer toutes les opérations préparées vers OpenSearch.
Vérifiez le résultat : un envoi réussi renvoie la valeur "true" via la méthode osr.getResult(). Les erreurs survenant après l'envoi (telles que les échecs de conversion de champ) sont enregistrées dans les journaux d'erreurs de la console OpenSearch.

Se connecter à OpenSearch

Toutes les opérations sur les documents partagent la même configuration client. Remplacez les valeurs d'espace réservé par le nom de votre application, le nom de votre table et le point de terminaison API régional.

// Replace with your OpenSearch application name, table name, and regional API endpoint
private static String appName = "<your-app-name>";
private static String tableName = "<your-table-name>";
private static String host = "<your-api-endpoint>";

// Read credentials from environment variables
String accesskey = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID");
String secret = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET");

// Build the client chain: OpenSearch → OpenSearchClient → DocumentClient
OpenSearch openSearch = new OpenSearch(accesskey, secret, host);
OpenSearchClient serviceClient = new OpenSearchClient(openSearch);
DocumentClient documentClient = new DocumentClient(serviceClient);

Espace réservé	Description
`<your-app-name>`	Nom de l'application OpenSearch
`<your-table-name>`	Nom de la table vers laquelle envoyer les données
`<your-api-endpoint>`	Point de terminaison API OpenSearch pour votre région

Code de démonstration complet

L'exemple suivant illustre le flux de travail complet en mode commit : ajout d'un document, mise à jour, suppression et vérification de la suppression via une requête de recherche.

package com.aliyun.opensearch;

import com.aliyun.opensearch.sdk.dependencies.com.google.common.collect.Lists;
import com.aliyun.opensearch.sdk.dependencies.com.google.common.collect.Maps;
import com.aliyun.opensearch.sdk.dependencies.org.json.JSONObject;
import com.aliyun.opensearch.sdk.generated.OpenSearch;
import com.aliyun.opensearch.sdk.generated.commons.OpenSearchClientException;
import com.aliyun.opensearch.sdk.generated.commons.OpenSearchException;
import com.aliyun.opensearch.sdk.generated.commons.OpenSearchResult;
import com.aliyun.opensearch.sdk.generated.search.Config;
import com.aliyun.opensearch.sdk.generated.search.SearchFormat;
import com.aliyun.opensearch.sdk.generated.search.SearchParams;
import com.aliyun.opensearch.sdk.generated.search.general.SearchResult;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.Map;
import java.util.Random;

public class testCommitSearch {

  private static String appName = "The name of the OpenSearch application to which you want to commit data";
  private static String tableName = "The name of the table to which you want to commit data";
  private static String host = "Endpoint of the OpenSearch API in your region";

  public static void main(String[] args) {
    // Read AccessKey credentials from environment variables.
    // Configure the environment variables before running this code.
    String accesskey = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID");
    String secret = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET");

    // Print the default file encoding and charset for debugging purposes.
    System.out.println(
      String.format("file.encoding: %s", System.getProperty("file.encoding"))
    );
    System.out.println(
      String.format("defaultCharset: %s", Charset.defaultCharset().name())
    );

    // Use a random integer as the primary key for this demo.
    Random rand = new Random();
    int value = rand.nextInt(Integer.MAX_VALUE);

    // ── Step 1: Add a document ───────────────────────────────────────────────

    // Build doc1 as a Map. Each key corresponds to a field in the table.
    Map<String, Object> doc1 = Maps.newLinkedHashMap();
    doc1.put("id", value);                        // primary key

    // Encode the title string as UTF-8 explicitly.
    String title_string = "Upload doc1 in commit mode";
    byte[] bytes;
    try {
      bytes = title_string.getBytes("utf-8");
      String utf8_string = new String(bytes, "utf-8");
      doc1.put("name", utf8_string);
    } catch (UnsupportedEncodingException e) {
      e.printStackTrace();
    }

    doc1.put("phone", "1381111****");
    doc1.put("int_arr", new int[]{ 33, 44 });
    doc1.put("literal_arr", new String[]{
      "Upload doc1 in commit mode",
      "Test uploading doc1 in commit mode]"
    });
    doc1.put("float_arr", new float[]{ 1.1f, 1.2f });
    doc1.put("cate_id", 1);

    // Build the client chain.
    OpenSearch openSearch1 = new OpenSearch(accesskey, secret, host);
    OpenSearchClient serviceClient1 = new OpenSearchClient(openSearch1);
    DocumentClient documentClient1 = new DocumentClient(serviceClient1);

    // Stage doc1 as a new document in the client buffer.
    documentClient1.add(doc1);
    System.out.println(doc1.toString());

    try {
      // Flush the buffer. All staged documents are submitted in one request.
      OpenSearchResult osr = documentClient1.commit(appName, tableName);

      // osr.getResult() returns "true" when the commit request itself succeeds.
      // Post-commit errors (e.g., field conversion failures) appear in the
      // OpenSearch console error logs, not in this result.
      if (osr.getResult().equalsIgnoreCase("true")) {
        System.out.println("Commit succeeded. Request ID: " +
          osr.getTraceInfo().getRequestId());
      } else {
        System.out.println("Commit failed: " + osr.getTraceInfo());
      }
    } catch (OpenSearchException e) {
      e.printStackTrace();
    } catch (OpenSearchClientException e) {
      e.printStackTrace();
    }

    // Wait 10 seconds for the document to be indexed before querying.
    try {
      Thread.sleep(10000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    // ── Step 2: Update the document ─────────────────────────────────────────

    // Build doc2 with the same primary key as doc1 to target the same document.
    Map<String, Object> doc2 = Maps.newLinkedHashMap();
    doc2.put("id", value);                        // must match doc1's primary key

    String title_string2 = "Update doc2 in commit mode";
    byte[] bytes2;
    try {
      bytes2 = title_string2.getBytes("utf-8");
      String utf8_string2 = new String(bytes2, "utf-8");
      doc2.put("name", utf8_string2);
    } catch (UnsupportedEncodingException e) {
      e.printStackTrace();
    }

    doc2.put("phone", "1390000****");
    doc2.put("int_arr", new int[]{ 22, 22 });
    doc2.put("literal_arr", new String[]{
      "Update doc1 in commit mode",
      "Update doc1 in commit mode"
    });
    doc2.put("float_arr", new float[]{ 1.1f, 1.2f });
    doc2.put("cate_id", 1);

    // Stage doc2 as an update. The primary key must be valid for the update to succeed.
    documentClient1.update(doc2);
    System.out.println(doc2.toString());

    try {
      OpenSearchResult osr = documentClient1.commit(appName, tableName);
      if (osr.getResult().equalsIgnoreCase("true")) {
        System.out.println("Commit succeeded. Request ID: " +
          osr.getTraceInfo().getRequestId());
      } else {
        System.out.println("Commit failed: " + osr.getTraceInfo());
      }
    } catch (OpenSearchException e) {
      e.printStackTrace();
    } catch (OpenSearchClientException e) {
      e.printStackTrace();
    }

    // Wait 10 seconds for the update to be indexed.
    try {
      Thread.sleep(10000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    // ── Step 3: Delete the document ─────────────────────────────────────────

    // Only the primary key is required to delete a document.
    Map<String, Object> doc3 = Maps.newLinkedHashMap();
    doc3.put("id", value);

    documentClient1.remove(doc3);
    System.out.println(doc3.toString());

    try {
      OpenSearchResult osr = documentClient1.commit(appName, tableName);
      if (osr.getResult().equalsIgnoreCase("true")) {
        System.out.println("Commit succeeded. Request ID: " +
          osr.getTraceInfo().getRequestId());
      } else {
        System.out.println("Commit failed: " + osr.getTraceInfo());
      }
    } catch (OpenSearchException e) {
      e.printStackTrace();
    } catch (OpenSearchClientException e) {
      e.printStackTrace();
    }

    // Wait at least 1 second (10 seconds here) before querying after a delete.
    // Querying immediately after removal may still return the deleted document.
    try {
      Thread.sleep(10000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    // ── Step 4: Verify the deletion with a search query ──────────────────────

    OpenSearch openSearch2 = new OpenSearch(accesskey, secret, host);
    OpenSearchClient serviceClient2 = new OpenSearchClient(openSearch2);
    SearcherClient searcherClient2 = new SearcherClient(serviceClient2);

    // Configure paging: start at offset 0, return up to 30 hits per page.
    // Supported formats: XML and JSON. FULLJSON is not supported.
    Config config = new Config(Lists.newArrayList(appName));
    config.setStart(0);
    config.setHits(30);
    config.setSearchFormat(SearchFormat.JSON);

    SearchParams searchParams = new SearchParams(config);
    searchParams.setQuery("id:'" + value + "'");

    try {
      SearchResult searchResult = searcherClient2.execute(searchParams);
      String result = searchResult.getResult();
      JSONObject obj = new JSONObject(result);
      System.out.println("Search results: " + obj.toString());
    } catch (OpenSearchException e) {
      e.printStackTrace();
    } catch (OpenSearchClientException e) {
      e.printStackTrace();
    }
  }
}

Notes d'utilisation

Résultat de l'envoi et erreurs d'indexation

Un envoi réussi (la méthode osr.getResult() renvoie "true") signifie qu'aucune erreur ne s'est produite lors de l'envoi des données. Cela ne garantit pas que chaque document a été indexé avec succès, car l'indexation dépend également de l'absence d'erreurs signalées dans la console OpenSearch. Les erreurs post-envoi, telles que les échecs de conversion de type de champ, sont enregistrées dans les journaux d'erreurs de la console OpenSearch. Consultez ces journaux après l'envoi pour confirmer que tous les documents ont bien été indexés.

Délai après l'envoi

OpenSearch indexe les documents envoyés de manière asynchrone. Attendez au moins une seconde avant d'effectuer une requête après une opération de suppression ; les documents supprimés peuvent encore apparaître dans les résultats de recherche si vous interrogez immédiatement le système. La démo utilise un délai d'attente de 10 secondes pour laisser suffisamment de temps à l'indexation.