1. Panoramica
Google Cloud Datastore è un database di documenti NoSQL creato per offrire scalabilità automatica, prestazioni elevate e facilità dello sviluppo di applicazioni.
Cosa imparerai a fare
- Come utilizzare Cloud Datastore per salvare e recuperare gli oggetti Java in Spring Boot
Che cosa ti serve
Come utilizzerai questo tutorial?
Come giudichi la tua esperienza di utilizzo dei servizi della piattaforma Google Cloud?
2. Configurazione e requisiti
Configurazione dell'ambiente da seguire in modo autonomo
- Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.
- Il Nome progetto è il nome visualizzato dei partecipanti del progetto. Si tratta di una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarla.
- L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). La console Cloud genera automaticamente una stringa univoca. di solito non ti importa cosa sia. Nella maggior parte dei codelab, dovrai fare riferimento al tuo ID progetto (in genere identificato come
PROJECT_ID). Se l'ID generato non ti soddisfa, potresti generarne un altro casuale. In alternativa, puoi provarne una personalizzata per verificare se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto. - Per informazione, c'è un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.
- Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare risorse/API Cloud. L'esecuzione di questo codelab non ha alcun costo. Per arrestare le risorse ed evitare di incorrere in fatturazione dopo questo tutorial, puoi eliminare le risorse che hai creato o eliminare il progetto. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.
Attiva Cloud Shell
- Dalla console Cloud, fai clic su Attiva Cloud Shell
.
Se è la prima volta che avvii Cloud Shell, ti verrà mostrata una schermata intermedia che descrive di cosa si tratta. Se ti è stata presentata una schermata intermedia, fai clic su Continua.
Il provisioning e la connessione a Cloud Shell dovrebbero richiedere solo qualche istante.
Questa macchina virtuale viene caricata con tutti gli strumenti di sviluppo necessari. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Gran parte, se non tutto, del lavoro in questo codelab può essere svolto con un browser.
Una volta stabilita la connessione a Cloud Shell, dovresti vedere che hai eseguito l'autenticazione e che il progetto è impostato sul tuo ID progetto.
- Esegui questo comando in Cloud Shell per verificare che l'account sia autenticato:
gcloud auth list
Output comando
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Esegui questo comando in Cloud Shell per confermare che il comando gcloud è a conoscenza del tuo progetto:
gcloud config list project
Output comando
[core] project = <PROJECT_ID>
In caso contrario, puoi impostarlo con questo comando:
gcloud config set project <PROJECT_ID>
Output comando
Updated property [core/project].
3. Inizializza Cloud Datastore
Nella console Google Cloud, vai a Menu -> Datastore (nella sezione Archiviazione) oppure fai clic qui.
Se non hai mai utilizzato Datastore nel progetto attuale, vedrai la schermata "Seleziona una modalità Cloud Firestore". Seleziona l'opzione "Modalità datastore".
Viene visualizzata la schermata "Scegli dove archiviare i tuoi dati". Seleziona us-east1 o qualsiasi altra località regionale e fai clic su "Crea database":
4. Esegui il bootstrap di una nuova applicazione Java Spring Boot
Dall'ambiente CloudShell, utilizza il comando seguente per inizializzare e avviare una nuova applicazione Spring Boot con il bootstrap:
$ curl https://start.spring.io/starter.tgz \ -d packaging=war \ -d dependencies=cloud-gcp \ -d type=maven-project \ -d baseDir=datastore-example \ -d bootVersion=3.0.5 | tar -xzvf -
Verrà creata una nuova directory datastore-example/ con un nuovo progetto Maven, oltre al pom.xml di Maven, un wrapper Maven e un punto di ingresso dell'applicazione.
La nostra applicazione fornirà agli utenti un'interfaccia a riga di comando per inserire comandi e vedere i risultati. Creeremo una classe per rappresentare un libro e quindi la salveremo in Cloud Datastore utilizzando Datastore Repository.
Dobbiamo anche aggiungere un'altra dipendenza necessaria a pom.xml.
Apri l'editor di codice web facendo clic su Apri editor nel menu di Cloud Shell.
Dopo il caricamento dell'editor, modifica il file pom.xml per aggiungere le dipendenze di Google Cloud Datastore Starter e Spring Shell Starter:
pom.xml
<project>
...
<dependencies>
...
<!-- Add GCP Datastore Starter -->
<dependency>
<groupId>com.google.cloud</groupId>
<artifactId>spring-cloud-gcp-starter-data-datastore</artifactId>
</dependency>
<!-- Add Spring Shell Starter -->
<dependency>
<groupId>org.springframework.shell</groupId>
<artifactId>spring-shell-starter</artifactId>
<version>3.0.2</version>
</dependency>
</dependencies>
</project>
5. Creare il corso Book
Utilizzando l'editor, crea la classe Book con i seguenti contenuti:
datastore-example/src/main/java/com/example/demo/Book.java
package com.example.demo;
import com.google.cloud.spring.data.datastore.core.mapping.Entity;
import org.springframework.data.annotation.Id;
@Entity(name = "books")
public class Book {
@Id
Long id;
String title;
String author;
int year;
public Book(String title, String author, int year) {
this.title = title;
this.author = author;
this.year = year;
}
public long getId() {
return this.id;
}
@Override
public String toString() {
return "Book{" +
"id=" + this.id +
", title='" + this.title + '\'' +
", author='" + this.author + '\'' +
", year=" + this.year +
'}';
}
}
Come puoi vedere, si tratta di un POJO semplice. La classe è annotata con @Entity per indicare che può essere archiviata in Datastore e viene fornito il nome del tipo (pensa a un tipo come a una tabella nei database SQL; consulta la documentazione per maggiori dettagli). Il nome del tipo è facoltativo. Se viene omesso, verrà generato in base al nome della classe.
Tieni presente che abbiamo annotato la proprietà id con @Id. Ciò indica che vogliamo che questo campo venga utilizzato come parte dell'identificatore della chiave Datastore. Ogni entità Datastore richiede un identificatore. I tipi supportati sono String e Long.
Il metodo toString viene sostituito per rendere più leggibile la rappresentazione in formato stringa degli oggetti. sarà utile quando li stamperemo.
6. Crea l'interfaccia BookRepository
Crea la classe BookRepository con i seguenti contenuti:
datastore-example/src/main/java/com/example/demo/BookRepository.java
package com.example.demo;
import java.util.List;
import com.google.cloud.spring.data.datastore.repository.DatastoreRepository;
public interface BookRepository extends DatastoreRepository<Book, Long> {
List<Book> findByAuthor(String author);
List<Book> findByYearGreaterThan(int year);
List<Book> findByAuthorAndYear(String author, int year);
}
L'interfaccia estende DatastoreRepository<Book, Long> dove Book è la classe del dominio e Long è il tipo Id. Nel nostro repository dichiariamo tre metodi di query per i quali le implementazioni vengono generate automaticamente in background.
Il primo è findByAuthor. Come puoi intuire, l'implementazione di questo metodo eseguirà una query che utilizzerà un valore fornito dall'utente nel filtro della condizione per il campo di uguaglianza rispetto all'autore.
Il metodo findByYearGreaterThan esegue una query che filtra per il campo dell'anno in base al valore fornito dall'utente.
findByAuthorAndYear esegue una query che cerca entità in cui i campi dell'autore e dell'anno corrispondono ai valori forniti dall'utente.
7. Crea l'applicazione dell'interfaccia a riga di comando interattiva
Apri la classe DemoApplication dell'applicazione principale e modificala in modo che abbia il seguente aspetto:
datastore-example/src/main/java/com/example/demo/DemoApplication.java
package com.example.demo;
import java.util.List;
import com.google.common.collect.Lists;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.shell.standard.ShellComponent;
import org.springframework.shell.standard.ShellMethod;
@ShellComponent
@SpringBootApplication
public class DemoApplication {
@Autowired
BookRepository bookRepository;
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@ShellMethod("Saves a book to Cloud Datastore: save-book <title> <author> <year>")
public String saveBook(String title, String author, int year) {
Book savedBook = this.bookRepository.save(new Book(title, author, year));
return savedBook.toString();
}
@ShellMethod("Loads all books")
public String findAllBooks() {
Iterable<Book> books = this.bookRepository.findAll();
return Lists.newArrayList(books).toString();
}
@ShellMethod("Loads books by author: find-by-author <author>")
public String findByAuthor(String author) {
List<Book> books = this.bookRepository.findByAuthor(author);
return books.toString();
}
@ShellMethod("Loads books published after a given year: find-by-year-after <year>")
public String findByYearAfter(int year) {
List<Book> books = this.bookRepository.findByYearGreaterThan(year);
return books.toString();
}
@ShellMethod("Loads books by author and year: find-by-author-year <author> <year>")
public String findByAuthorYear(String author, int year) {
List<Book> books = this.bookRepository.findByAuthorAndYear(author, year);
return books.toString();
}
@ShellMethod("Removes all books")
public void removeAllBooks() {
this.bookRepository.deleteAll();
}
}
Nota come abbiamo annotato il corso con @ShellComponent. Questo informa Spring che vogliamo utilizzare questa classe come fonte per i comandi dell'interfaccia a riga di comando. I metodi annotati con @ShellMethod verranno esposti come comandi dell'interfaccia a riga di comando nella nostra applicazione.
Qui utilizziamo i metodi che abbiamo dichiarato nell'interfaccia BookRepository: findByAuthor, findByYearGreaterThan, findByAuthorAndYear. Inoltre, usiamo tre metodi integrati: save, findAll e deleteAll.
Esaminiamo il metodo saveBook. Creiamo un oggetto Book utilizzando i valori forniti dall'utente per titolo, autore e anno. Come puoi vedere, non forniamo un valore id, quindi verrà assegnato e assegnato automaticamente al campo id al momento del salvataggio. Il metodo save accetta un oggetto di tipo Book e lo salva in Cloud Datastore. Restituisce un oggetto Book con tutti i campi compilati, incluso il campo id. Alla fine viene restituita una rappresentazione in formato stringa dell'oggetto.
Gli altri metodi funzionano in modo simile: accettano i parametri trasferiti ai metodi di repository appropriati e restituiscono risultati sotto forma di stringa.
8. Eseguire l'applicazione
Per creare e avviare l'applicazione, assicurati innanzitutto che JAVA_HOME sia impostata sulla versione corretta:
$ export JAVA_HOME=/usr/lib/jvm/java-1.17.0-openjdk-amd64
Esegui questo comando in Cloud Shell (dalla radice del progetto datastore-example/ in cui si trova pom.xml):
$ ./mvnw spring-boot:run export JAVA_HOME=/usr/lib/jvm/java-1.17.0-openjdk-amd64
Dopo una fase di creazione riuscita, verrà visualizzato il logo della primavera e il prompt della shell:
. ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |_\__, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: (v3.0.5) shell:>
Ora puoi utilizzare i comandi definiti in precedenza per sperimentare. Per visualizzare l'elenco dei comandi, utilizza il comando help:
shell:> help ... find-all-books: Loads all books find-by-author: Loads books by author: find-by-author <author> find-by-author-year: Loads books by author and year: find-by-author-year <author> <year> find-by-year-after: Loads books published after a given year: find-by-year-after <year> remove-all-books: Removes all books save-book: Saves a book to Cloud Datastore: save-book <title> <author> <year>
Procedi nel seguente modo:
- Crea alcuni libri usando il comando
save-book - Esegui una ricerca utilizzando il comando
find-all-books - Trova libri di uno specifico autore:
find-by-author <author> - Trova i libri pubblicati dopo un anno specifico:
find-by-year-after <year> - Trova libri per autore e anno specifici:
find-by-author-year <author> <year>
9. Visualizza gli elementi archiviati in Datastore utilizzando l'interfaccia web
Per visualizzare come vengono archiviate le entità in Cloud Datastore, vai alla console Google Cloud. Inserisci "libri" nel campo del tipo, se necessario.
10. Esegui la pulizia
Per eseguire la pulizia, rimuovi tutti i libri dalla shell dell'applicazione con il comando remove-all-books con un nome appropriato.
shell:> remove-all-books
Per uscire dall'applicazione, usa il comando quit, quindi Ctrl+C.
11. Complimenti!
In questo codelab hai creato un'applicazione dell'interfaccia a riga di comando interattiva che può archiviare e recuperare oggetti da Cloud Datastore.
Scopri di più
- Cloud Datastore: https://cloud.google.com/datastore/
- Shell primaverile: https://projects.spring.io/spring-shell/
- Progetto Spring su Google Cloud: https://spring.io/projects/spring-cloud-gcp
- Repository GitHub di Google Cloud Spring: https://github.com/GoogleCloudPlatform/spring-cloud-gcp
- Java su Google Cloud: https://cloud.google.com/java/
Licenza
Questo lavoro è concesso in licenza ai sensi di una licenza Creative Commons Attribution 2.0 Generic.