Como usar o Cloud Datastore com Java

Nesta parte do tutorial do Bookshelf para Java, aprenda a criar, ler, atualizar e excluir dados do Google Cloud Datastore.

Esta página faz parte de um tutorial com várias páginas. Para começar do início e ver as instruções de configuração, acesse App Bookshelf para Java.

Como definir configurações

Em pom.xml, você encontra informações sobre configuração para todas as partes do tutorial do Bookshelf. Nesta parte do tutorial, não é necessário adicionar informações de configuração. Só é necessário definir a propriedade bookshelf.storageType como datastore, que você já fez.

Como executar o app na máquina local

Para executar o app localmente:

  1. No diretório getting-started-java/bookshelf/2-structured-data, insira este comando para iniciar um servidor da Web local:

    mvn -Plocal clean jetty:run-exploded -DprojectID=[YOUR-PROJECT-ID]
  2. No seu navegador, acesse http://localhost:8080.

Agora, navegue nas páginas da Web do app e adicione, edite e exclua livros.

Como implantar o app no ambiente flexível do App Engine

  1. Digite este comando para implantar o app:

    mvn appengine:deploy -DprojectID=YOUR-PROJECT-ID
    
  2. No navegador da Web, digite este endereço. Substitua [YOUR_PROJECT_ID] pelo código do projeto:

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

Para atualizar o app, implante a versão atualizada digitando o mesmo comando usado para implantá-lo pela primeira vez. A implantação cria uma nova versão do aplicativo e a define como padrão. As versões mais antigas são mantidas, bem como as instâncias de VM associadas. Esteja ciente de que essas versões e as instâncias de VM são recursos passíveis de cobrança.

Reduza custos excluindo as versões não padrão do app.

Para excluir uma versão do aplicativo:

  1. No Console do GCP, acesse a página "Versões do App Engine".

    Acessar a página Versões

  2. Clique na caixa de seleção ao lado da versão do aplicativo não padrão que você quer excluir.
  3. Clique no botão Excluir na parte superior da página para excluir a versão do aplicativo.

Para informações detalhadas sobre a remoção de recursos faturáveis, consulte a seção Como fazer a limpeza na etapa final deste tutorial.

Estrutura do aplicativo

Este diagrama mostra os componentes do aplicativo e como eles se encaixam:

Processo e estrutura de implantação do aplicativo Bookshelf

Como entender o código

Nesta seção, vamos analisar o código do aplicativo e explicar como ele funciona.

Como interagir com o Cloud Datastore

O app usa um objeto de serviço Datastore autorizado para interagir com o Cloud Datastore. Esse objeto é pesado, porque as credenciais foram trocadas por um token que pode ser usado para acessar as APIs do Datastore. Com o app também é criado um objeto KeyFactory do tipo "Book". Esse livro é o único tipo de dado armazenado por esse app. Via de regra, você pode armazenar quantos tipos de dados desejar. O Cloud Datastore é compatível com uma grande variedade de tipos de dados.

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
}

Como criar livros

Para salvar um livro, o app armazena uma entidade no Cloud Datastore. Uma entidade tem uma chave e um conjunto de pares de nome/valor. O método createBook é iniciado com uma IncompleteKey, que recebe a atribuição de um valor quando a entidade é adicionada ao armazenamento de dados. A entidade é criada com o código de acordo com o padrão de design do Builder fazendo chamadas repetidas ao 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
}

Como ler do Cloud Datastore

Com o método readBook, um código de livro é convertido em uma chave. A chave é passada para o método get, que retorna um objeto Entity.

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

Com o método entityToBook, a entidade retornada do Cloud Datastore é convertida em um objeto Book usando métodos get para cada tipo, como set, usando uma String como nome próprio.

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();
}

Como atualizar livros

Para atualizar, basta chamar o método update com uma 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
}

Para excluir com o Datastore é necessário chamar o método delete com uma Key.

Como excluir livros

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

Como listar livros

Com o método listBooks, uma lista de livros é retornada, com dez livros de cada vez, junto com um Cursor seguro de 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);
  }
}

Como criar o índice

Com o Datastore, um índice é criado automaticamente para cada uma das suas propriedades por padrão. Porém, é possível mudar esse comportamento. É necessário mais do que uma única propriedade para algumas consultas ao índice serem concluídas, como a consulta acima "Consultar por usuário", solicitada pela consulta "Título" acima. Índices necessários no seu app são sugeridos pelo emulador do Datastore.

Crie este índices agora:

gcloud datastore create-indexes index.yaml
Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…