Hello World Java

Questo esempio di codice è un'applicazione "Hello World" scritta in Java, che utilizza la libreria client Bigtable per Java. L'esempio illustra come completare le seguenti attività:

• Configura l'autenticazione
• Connettiti a un'istanza Bigtable.
• Crea una nuova tabella.
• Scrivi i dati nella tabella.
• Leggi di nuovo i dati.
• Elimina la tabella.

Esecuzione dell'esempio

Questo codice comunica con Bigtable utilizzando la libreria client Bigtable nelle Google Cloud librerie client per Java.

Prima di iniziare, segui i passaggi di configurazione descritti nella documentazione di riferimento.

Utilizzo delle librerie client di Cloud con Bigtable

L'applicazione di esempio si connette a Bigtable e mostra alcune operazioni di base.

Connessione a Bigtable

Per iniziare, hai bisogno di un client di dati che utilizzi per comunicare con la libreria client dell'API Data e di un client di amministrazione delle tabelle che utilizzi per comunicare con la libreria client dell'API Admin.

Innanzitutto, crea un'istanza di un oggetto BigtableDataSettings che includa l'ID progetto e l'ID istanza che l'applicazione hello world utilizzerà. Quindi, passa le impostazioni al BigtableDataClient.create() metodo per creare il client di dati.

Allo stesso modo, per il client di amministrazione, configura prima le impostazioni creando un BigtableTableAdminSettings oggetto, quindi utilizza le impostazioni per creare un BigtableTableAdminClient oggetto.

Come best practice, quando utilizzi Bigtable, devi sempre creare un client una sola volta e riutilizzarlo in tutta l'applicazione.

// Creates the settings to configure a bigtable data client.
BigtableDataSettings settings =
    BigtableDataSettings.newBuilder().setProjectId(projectId).setInstanceId(instanceId).build();

// Creates a bigtable data client.
dataClient = BigtableDataClient.create(settings);

// Creates a bigtable table admin client.
adminClient = BigtableTableAdminClientV2.create();

Creazione di una tabella

Per creare una tabella, crea un oggetto CreateTableRequest e passalo al metodo createTable() del client di amministrazione.

Nota: le colonne correlate una all'altra sono in genere raggruppate in una famiglia di colonne. Per saperne di più sulle famiglie di colonne, consulta il Bigtable modello di archiviazione.

// Checks if table exists, creates table if does not exist.
boolean exists = false;
try {
  adminClient.getTable(
      GetTableRequest.newBuilder()
          .setName("projects/" + projectId + "/instances/" + instanceId + "/tables/" + tableId)
          .setView(Table.View.NAME_ONLY)
          .build());
  exists = true;
} catch (NotFoundException e) {
  // ignore
}
if (!exists) {
  System.out.println("Creating table: " + tableId);
  String parent = "projects/" + projectId + "/instances/" + instanceId;
  CreateTableRequest request =
      CreateTableRequest.newBuilder()
          .setParent(parent)
          .setTableId(tableId)
          .setTable(
              Table.newBuilder()
                  .putColumnFamilies(COLUMN_FAMILY, ColumnFamily.getDefaultInstance())
                  .build())
          .build();
  adminClient.createTable(request);
  System.out.printf("Table %s created successfully%n", tableId);
}

Scrittura di righe in una tabella

Crea un array di stringhe greetings[] contenente tre saluti, da utilizzare come origine dei dati da scrivere nella tabella. Esegui un loop nell'array. In ogni iterazione del loop, crea un oggetto RowMutation e utilizza il metodo setCell() per aggiungere una voce alla mutazione.

Nota: in questa applicazione di esempio, setCell() viene chiamato una sola volta per mutazione, ma puoi chiamarlo fino a 10.000 volte per singola mutazione.

try {
  System.out.println("\nWriting some greetings to the table");
  String[] names = {"World", "Bigtable", "Java"};
  for (int i = 0; i < names.length; i++) {
    String greeting = "Hello " + names[i] + "!";
    RowMutation rowMutation =
        RowMutation.create(TableId.of(tableId), ROW_KEY_PREFIX + i)
            .setCell(COLUMN_FAMILY, COLUMN_QUALIFIER_NAME, names[i])
            .setCell(COLUMN_FAMILY, COLUMN_QUALIFIER_GREETING, greeting);
    dataClient.mutateRow(rowMutation);
    System.out.println(greeting);
  }
} catch (NotFoundException e) {
  System.err.println("Failed to write to non-existent table: " + e.getMessage());
}

Lettura di una riga in base alla chiave di riga

Utilizza il metodo readRow() del client di dati per leggere la prima riga che hai scritto.

try {
  System.out.println("\nReading a single row by row key");
  Row row = dataClient.readRow(TableId.of(tableId), ROW_KEY_PREFIX + 0);
  System.out.println("Row: " + row.getKey().toStringUtf8());
  for (RowCell cell : row.getCells()) {
    System.out.printf(
        "Family: %s    Qualifier: %s    Value: %s%n",
        cell.getFamily(), cell.getQualifier().toStringUtf8(), cell.getValue().toStringUtf8());
  }
  return row;
} catch (NotFoundException e) {
  System.err.println("Failed to read from a non-existent table: " + e.getMessage());
  return null;
}
try {
  System.out.println("\nReading specific cells by family and qualifier");
  Row row = dataClient.readRow(TableId.of(tableId), ROW_KEY_PREFIX + 0);
  System.out.println("Row: " + row.getKey().toStringUtf8());
  List<RowCell> cells = row.getCells(COLUMN_FAMILY, COLUMN_QUALIFIER_NAME);
  for (RowCell cell : cells) {
    System.out.printf(
        "Family: %s    Qualifier: %s    Value: %s%n",
        cell.getFamily(), cell.getQualifier().toStringUtf8(), cell.getValue().toStringUtf8());
  }
  return cells;
} catch (NotFoundException e) {
  System.err.println("Failed to read from a non-existent table: " + e.getMessage());
  return null;
}

Scansione di tutte le righe della tabella

Poi, scansiona l'intera tabella. Crea un oggetto Query, passalo al metodo readRows() e assegna i risultati a uno stream di righe.

try {
  System.out.println("\nReading the entire table");
  Query query = Query.create(TableId.of(tableId));
  ServerStream<Row> rowStream = dataClient.readRows(query);
  List<Row> tableRows = new ArrayList<>();
  for (Row r : rowStream) {
    System.out.println("Row Key: " + r.getKey().toStringUtf8());
    tableRows.add(r);
    for (RowCell cell : r.getCells()) {
      System.out.printf(
          "Family: %s    Qualifier: %s    Value: %s%n",
          cell.getFamily(), cell.getQualifier().toStringUtf8(), cell.getValue().toStringUtf8());
    }
  }
  return tableRows;
} catch (NotFoundException e) {
  System.err.println("Failed to read a non-existent table: " + e.getMessage());
  return null;
}

Eliminazione di una tabella

Infine, elimina la tabella con il deleteTable() metodo.

System.out.println("\nDeleting table: " + tableId);
try {
  String tableName =
      "projects/" + projectId + "/instances/" + instanceId + "/tables/" + tableId;
  adminClient.deleteTable(tableName);
  System.out.printf("Table %s deleted successfully%n", tableId);
} catch (NotFoundException e) {
  System.err.println("Failed to delete a non-existent table: " + e.getMessage());
}

In sintesi

Ecco il esempio di codice completo senza commenti.

package com.example.bigtable;


import static com.google.cloud.bigtable.data.v2.models.Filters.FILTERS;

import com.google.api.gax.rpc.NotFoundException;
import com.google.api.gax.rpc.ServerStream;
import com.google.bigtable.admin.v2.ColumnFamily;
import com.google.bigtable.admin.v2.CreateTableRequest;
import com.google.bigtable.admin.v2.GetTableRequest;
import com.google.bigtable.admin.v2.Table;
import com.google.cloud.bigtable.admin.v2.BigtableTableAdminClientV2;
import com.google.cloud.bigtable.data.v2.BigtableDataClient;
import com.google.cloud.bigtable.data.v2.BigtableDataSettings;
import com.google.cloud.bigtable.data.v2.models.Filters.Filter;
import com.google.cloud.bigtable.data.v2.models.Query;
import com.google.cloud.bigtable.data.v2.models.Row;
import com.google.cloud.bigtable.data.v2.models.RowCell;
import com.google.cloud.bigtable.data.v2.models.RowMutation;
import com.google.cloud.bigtable.data.v2.models.TableId;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;


public class HelloWorld {

  private static final String COLUMN_FAMILY = "cf1";
  private static final String COLUMN_QUALIFIER_GREETING = "greeting";
  private static final String COLUMN_QUALIFIER_NAME = "name";
  private static final String ROW_KEY_PREFIX = "rowKey";
  private final String projectId;
  private final String instanceId;
  private final String tableId;
  private final BigtableDataClient dataClient;
  private final BigtableTableAdminClientV2 adminClient;

  public static void main(String[] args) throws Exception {

    if (args.length != 2) {
      System.out.println("Missing required project id or instance id");
      return;
    }
    String projectId = args[0];
    String instanceId = args[1];

    HelloWorld helloWorld = new HelloWorld(projectId, instanceId, "test-table");
    helloWorld.run();
  }

  public HelloWorld(String projectId, String instanceId, String tableId) throws IOException {
    this.projectId = projectId;
    this.instanceId = instanceId;
    this.tableId = tableId;

    BigtableDataSettings settings =
        BigtableDataSettings.newBuilder().setProjectId(projectId).setInstanceId(instanceId).build();

    dataClient = BigtableDataClient.create(settings);

    adminClient = BigtableTableAdminClientV2.create();
  }

  public void run() throws Exception {
    createTable();
    writeToTable();
    readSingleRow();
    readSpecificCells();
    readTable();
    filterLimitCellsPerCol(tableId);
    deleteTable();
    close();
  }

  public void close() {
    dataClient.close();
    adminClient.close();
  }

  public void createTable() {
    boolean exists = false;
    try {
      adminClient.getTable(
          GetTableRequest.newBuilder()
              .setName("projects/" + projectId + "/instances/" + instanceId + "/tables/" + tableId)
              .setView(Table.View.NAME_ONLY)
              .build());
      exists = true;
    } catch (NotFoundException e) {
    }
    if (!exists) {
      System.out.println("Creating table: " + tableId);
      String parent = "projects/" + projectId + "/instances/" + instanceId;
      CreateTableRequest request =
          CreateTableRequest.newBuilder()
              .setParent(parent)
              .setTableId(tableId)
              .setTable(
                  Table.newBuilder()
                      .putColumnFamilies(COLUMN_FAMILY, ColumnFamily.getDefaultInstance())
                      .build())
              .build();
      adminClient.createTable(request);
      System.out.printf("Table %s created successfully%n", tableId);
    }
  }

  public void writeToTable() {
    try {
      System.out.println("\nWriting some greetings to the table");
      String[] names = {"World", "Bigtable", "Java"};
      for (int i = 0; i < names.length; i++) {
        String greeting = "Hello " + names[i] + "!";
        RowMutation rowMutation =
            RowMutation.create(TableId.of(tableId), ROW_KEY_PREFIX + i)
                .setCell(COLUMN_FAMILY, COLUMN_QUALIFIER_NAME, names[i])
                .setCell(COLUMN_FAMILY, COLUMN_QUALIFIER_GREETING, greeting);
        dataClient.mutateRow(rowMutation);
        System.out.println(greeting);
      }
    } catch (NotFoundException e) {
      System.err.println("Failed to write to non-existent table: " + e.getMessage());
    }
  }

  public Row readSingleRow() {
    try {
      System.out.println("\nReading a single row by row key");
      Row row = dataClient.readRow(TableId.of(tableId), ROW_KEY_PREFIX + 0);
      System.out.println("Row: " + row.getKey().toStringUtf8());
      for (RowCell cell : row.getCells()) {
        System.out.printf(
            "Family: %s    Qualifier: %s    Value: %s%n",
            cell.getFamily(), cell.getQualifier().toStringUtf8(), cell.getValue().toStringUtf8());
      }
      return row;
    } catch (NotFoundException e) {
      System.err.println("Failed to read from a non-existent table: " + e.getMessage());
      return null;
    }
  }

  public List<RowCell> readSpecificCells() {
    try {
      System.out.println("\nReading specific cells by family and qualifier");
      Row row = dataClient.readRow(TableId.of(tableId), ROW_KEY_PREFIX + 0);
      System.out.println("Row: " + row.getKey().toStringUtf8());
      List<RowCell> cells = row.getCells(COLUMN_FAMILY, COLUMN_QUALIFIER_NAME);
      for (RowCell cell : cells) {
        System.out.printf(
            "Family: %s    Qualifier: %s    Value: %s%n",
            cell.getFamily(), cell.getQualifier().toStringUtf8(), cell.getValue().toStringUtf8());
      }
      return cells;
    } catch (NotFoundException e) {
      System.err.println("Failed to read from a non-existent table: " + e.getMessage());
      return null;
    }
  }

  public List<Row> readTable() {
    try {
      System.out.println("\nReading the entire table");
      Query query = Query.create(TableId.of(tableId));
      ServerStream<Row> rowStream = dataClient.readRows(query);
      List<Row> tableRows = new ArrayList<>();
      for (Row r : rowStream) {
        System.out.println("Row Key: " + r.getKey().toStringUtf8());
        tableRows.add(r);
        for (RowCell cell : r.getCells()) {
          System.out.printf(
              "Family: %s    Qualifier: %s    Value: %s%n",
              cell.getFamily(), cell.getQualifier().toStringUtf8(), cell.getValue().toStringUtf8());
        }
      }
      return tableRows;
    } catch (NotFoundException e) {
      System.err.println("Failed to read a non-existent table: " + e.getMessage());
      return null;
    }
  }

  public void filterLimitCellsPerCol(String tableId) {
    Filter filter = FILTERS.limit().cellsPerColumn(1);
    readRowFilter(tableId, filter);
    readFilter(tableId, filter);
  }


  private void readRowFilter(String tableId, Filter filter) {
    String rowKey =
        Base64.getEncoder().encodeToString("greeting0".getBytes(StandardCharsets.UTF_8));
    Row row = dataClient.readRow(TableId.of(tableId), rowKey, filter);
    printRow(row);
    System.out.println("Row filter completed.");
  }


  private void readFilter(String tableId, Filter filter) {
    Query query = Query.create(TableId.of(tableId)).filter(filter);
    ServerStream<Row> rows = dataClient.readRows(query);
    for (Row row : rows) {
      printRow(row);
    }
    System.out.println("Table filter completed.");
  }


  public void deleteTable() {
    System.out.println("\nDeleting table: " + tableId);
    try {
      String tableName =
          "projects/" + projectId + "/instances/" + instanceId + "/tables/" + tableId;
      adminClient.deleteTable(tableName);
      System.out.printf("Table %s deleted successfully%n", tableId);
    } catch (NotFoundException e) {
      System.err.println("Failed to delete a non-existent table: " + e.getMessage());
    }
  }

  private static void printRow(Row row) {
    if (row == null) {
      return;
    }
    System.out.printf("Reading data for %s%n", row.getKey().toStringUtf8());
    String colFamily = "";
    for (RowCell cell : row.getCells()) {
      if (!cell.getFamily().equals(colFamily)) {
        colFamily = cell.getFamily();
        System.out.printf("Column Family %s%n", colFamily);
      }
      String labels =
          cell.getLabels().size() == 0 ? "" : " [" + String.join(",", cell.getLabels()) + "]";
      System.out.printf(
          "\t%s: %s @%s%s%n",
          cell.getQualifier().toStringUtf8(),
          cell.getValue().toStringUtf8(),
          cell.getTimestamp(),
          labels);
    }
    System.out.println();
  }
}