Usar Cloud Datastore con Java

En esta parte del tutorial de Bookshelf para Java se muestra cómo crear, leer, actualizar y eliminar datos estructurados en Google Cloud Datastore.

Esta página forma parte de un tutorial de varias páginas. Para empezar desde el principio y ver las instrucciones de configuración, consulta Aplicación Bookshelf de Java.

Ajustes de configuración

El archivo pom.xml contiene información de configuración para todas las partes del tutorial de Bookshelf. Para esta parte del tutorial, no es necesario que agregues ninguna información de configuración. El único requisito es que la propiedad bookshelf.storageType se establezca en datastore, lo cual ya está hecho para ti.

Ejecutar la aplicación en tu máquina local

Para ejecutar la aplicación de forma local, sigue estas instrucciones:

  1. En el directorio getting-started-java/bookshelf/2-structured-data, introduce este comando para iniciar un servidor web local:

    mvn -Plocal clean jetty:run-exploded -DprojectID=[YOUR-PROJECT-ID]
  2. En el navegador web, accede a http://localhost:8080.

Ahora puedes navegar por las páginas web de la aplicación, donde podrás agregar, editar y eliminar libros.

Desplegar la aplicación en el entorno flexible de App Engine

  1. Introduce este comando para desplegar la aplicación:

    mvn appengine:deploy -DprojectID=YOUR-PROJECT-ID
    
  2. En el navegador web, introduce la siguiente dirección. Sustituye [YOUR_PROJECT_ID] por el ID del proyecto:

    https://[YOUR_PROJECT_ID].appspot-preview.com
    

Si actualizas la aplicación, podrás desplegar la versión actualizada con el mismo comando que el utilizado para desplegar la aplicación por primera vez. El nuevo despliegue crea una nueva versión de la aplicación y la establece como la versión predeterminada. Se conservan las versiones anteriores de la aplicación, al igual que las instancias de máquina virtual asociadas. Ten en cuenta que todas estas versiones de aplicaciones e instancias de máquina virtual son recursos facturables.

Si eliminas las versiones no predeterminadas de la aplicación, puedes reducir los costes.

Para eliminar una versión de la aplicación:

  1. In the GCP Console, go to the Versions page for App Engine.

    Go to the Versions page

  2. Select the checkbox for the non-default app version you want to delete.
  3. Click Delete to delete the app version.

Si quieres obtener información completa sobre cómo limpiar los recursos facturables, consulta la sección sobre cómo limpiar los recursos en el último paso de este tutorial.

Estructura de la aplicación

En el siguiente diagrama se muestran los componentes de la aplicación y cómo interaccionan.

Proceso y estructura de despliegue de la aplicación Bookshelf

Información sobre el código

En esta sección se explica detalladamente el código de la aplicación y su funcionamiento.

Interactuar con Cloud Datastore

La aplicación utiliza un objeto de servicio Datastore autorizado para interactuar con Cloud Datastore. Se trata de un objeto pesado, debido a que ha intercambiado credenciales por un token para acceder a las API de Datastore. La aplicación también crea un objeto KeyFactory de tipo "Book". El libro es el único tipo de datos que esta aplicación almacena. Sin embargo, en general, puedes almacenar cualquier tipo de datos. Cloud Datastore admite una gran variedad de tipos de datos.

private Datastore datastore;
private KeyFactory keyFactory;

public DatastoreDao() {
  datastore = DatastoreOptions.getDefaultInstance().getService(); // Authorized Datastore service
  keyFactory = datastore.newKeyFactory().setKind("Book2");      // Is used for creating keys later
}

Crear libros

Para guardar un libro, la aplicación almacena una entidad en Cloud Datastore. Una entidad tiene una clave y una colección de pares de nombres y valores. El método createBook comienza con una IncompleteKey, a la que se le asigna un valor cuando la entidad se agrega al almacén de datos. El código crea la entidad de acuerdo con el patrón de diseño de Builder mediante llamadas repetidas al método set.

@Override
public Long createBook(Book book) {
  IncompleteKey key = keyFactory.newKey();          // Key will be assigned once written
  FullEntity<IncompleteKey> incBookEntity = Entity.newBuilder(key)  // Create the Entity
      .set(Book.AUTHOR, book.getAuthor())           // Add Property ("author", book.getAuthor())
      .set(Book.DESCRIPTION, book.getDescription())
      .set(Book.PUBLISHED_DATE, book.getPublishedDate())
      .set(Book.TITLE, book.getTitle())
      .build();
  Entity bookEntity = datastore.add(incBookEntity); // Save the Entity
  return bookEntity.getKey().getId();                     // The ID of the Key
}

Leer desde Cloud Datastore

El método readBook toma el identificador de un libro y lo convierte en una clave. A continuación, pasa la clave al método get, que devuelve un objeto Entity.

@Override
public Book readBook(Long bookId) {
  Entity bookEntity = datastore.get(keyFactory.newKey(bookId)); // Load an Entity for Key(id)
  return entityToBook(bookEntity);
}

El método entityToBook convierte la entidad devuelta desde Cloud Datastore en un objeto Book mediante métodos get para cada tipo (por ejemplo, set o tomar valores de String como nombre de propiedad).

public Book entityToBook(Entity entity) {
  return new Book.Builder()                                     // Convert to Book form
      .author(entity.getString(Book.AUTHOR))
      .description(entity.getString(Book.DESCRIPTION))
      .id(entity.getKey().getId())
      .publishedDate(entity.getString(Book.PUBLISHED_DATE))
      .title(entity.getString(Book.TITLE))
      .build();
}

Actualizar libros

La actualización solo requiere llamar al método update con Entity.

@Override
public void updateBook(Book book) {
  Key key = keyFactory.newKey(book.getId());  // From a book, create a Key
  Entity entity = Entity.newBuilder(key)         // Convert Book to an Entity
      .set(Book.AUTHOR, book.getAuthor())
      .set(Book.DESCRIPTION, book.getDescription())
      .set(Book.PUBLISHED_DATE, book.getPublishedDate())
      .set(Book.TITLE, book.getTitle())
      .build();
  datastore.update(entity);                   // Update the Entity
}

La eliminación con Datastore requiere llamar al método delete con Key.

Eliminar libros

@Override
public void deleteBook(Long bookId) {
  Key key = keyFactory.newKey(bookId);        // Create the Key
  datastore.delete(key);                      // Delete the Entity
}

Enumerar libros

El método listBooks devuelve una lista de libros, de diez en diez, junto con un Cursor seguro para direcciones URL:

@Override
public Result<Book> listBooks(String startCursorString) {
  Cursor startCursor = null;
  if (startCursorString != null && !startCursorString.equals("")) {
    startCursor = Cursor.fromUrlSafe(startCursorString);    // Where we left off
  }
  Query<Entity> query = Query.newEntityQueryBuilder()       // Build the Query
      .setKind("Book2")                                     // We only care about Books
      .setLimit(10)                                         // Only show 10 at a time
      .setStartCursor(startCursor)                          // Where we left off
      .setOrderBy(OrderBy.asc(Book.TITLE))                  // Use default Index "title"
      .build();
  QueryResults<Entity> resultList = datastore.run(query);   // Run the query
  List<Book> resultBooks = entitiesToBooks(resultList);     // Retrieve and convert Entities
  Cursor cursor = resultList.getCursorAfter();              // Where to start next time
  if (cursor != null && resultBooks.size() == 10) {         // Are we paging? Save Cursor
    String cursorString = cursor.toUrlSafe();               // Cursors are WebSafe
    return new Result<>(resultBooks, cursorString);
  } else {
    return new Result<>(resultBooks);
  }
}

Indexar

Datastore crea automáticamente un índice para cada una de tus propiedades de forma predeterminada, aunque se puede cambiar este comportamiento. Algunas consultas necesitan más de una sola propiedad en el índice para completarse, como la consulta por usuario, ordenada por la consulta de título anterior. El emulador de Datastore sugerirá índices que tu aplicación necesitará.

Crea estos índices ahora:

gcloud datastore create-indexes index.yaml
¿Te ha resultado útil esta página? Enviar comentarios: