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 oggetti Java in Spring Boot
Che cosa ti serve
Come utilizzerai questo tutorial?
Come valuti la tua esperienza di utilizzo dei servizi Google Cloud Platform?
Configurazione dell'ambiente autonoma
Se non hai ancora un Account Google (Gmail o Google Apps), devi crearne uno. Accedi alla console di Google Cloud (console.cloud.google.com) e crea un nuovo progetto:
Ricorda l'ID progetto, un nome univoco per tutti i progetti Google Cloud (il nome riportato sopra è già stato utilizzato e non funzionerà per te, mi dispiace). In questo codelab verrà chiamato PROJECT_ID.
Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare le risorse Google Cloud.
L'esecuzione di questo codelab non dovrebbe costarti più di qualche dollaro, ma potrebbe essere più cara se decidi di utilizzare più risorse o se le lasci in esecuzione (vedi la sezione "Pulizia" alla fine di questo documento).
I nuovi utenti di Google Cloud Platform possono beneficiare di una prova senza costi di 300$.
Attiva Google Cloud Shell
Nella console GCP, fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra:
Poi fai clic su "Avvia Cloud Shell":
Bastano pochi istanti per eseguire il provisioning e connettersi all'ambiente:
Questa macchina virtuale è caricata con tutti gli strumenti di sviluppo di cui avrai bisogno. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Gran parte, se non tutto, il lavoro in questo lab può essere svolgersi semplicemente con un browser o con Google Chromebook.
Una volta eseguita la connessione a Cloud Shell, dovresti vedere che il tuo account è già autenticato e il progetto è già impostato sul tuo PROJECT_ID.
Esegui questo comando in Cloud Shell per verificare che l'account sia autenticato:
gcloud auth list
Output comando
Credentialed accounts: - <myaccount>@<mydomain>.com (active)
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].
Nella console di GCP, vai a Menu -> Datastore (nella sezione Storage).
Se non hai mai utilizzato Datastore nel progetto corrente, visualizzerai la schermata "Seleziona una modalità di Cloud Firestore". Seleziona l'opzione "Modalità Datastore".
Dopodiché, vedrai la schermata "Scegli dove archiviare i tuoi dati". Seleziona us-east1 o qualsiasi altra località regionale e fai clic su "Crea database":
Dall'ambiente Cloud Shell, utilizza questo comando per inizializzare e avviare una nuova applicazione Spring Boot:
$ curl https://start.spring.io/starter.tgz \ -d packaging=war \ -d dependencies=cloud-gcp \ -d baseDir=datastore-example \ -d bootVersion=2.1.1.RELEASE | tar -xzvf -
Verrà creata una nuova directory datastore-example/ con un nuovo progetto Maven, insieme a pom.xml, un wrapper Maven, e a un punto di ingresso dell'applicazione.
La nostra applicazione fornirà una CLI per consentire agli utenti di inserire comandi e visualizzare i risultati. Creeremo una classe per rappresentare un libro e poi 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 Avvia editor di codice dal menu di Cloud Shell.
Dopo il caricamento dell'editor, modifica il file pom.xml per aggiungere la dipendenza Spring Data Cloud Datastore Spring Boot Starter:
pom.xml
<project>
...
<dependencies>
...
<!-- Add GCP Datastore Starter -->
<dependency>
<groupId>org.springframework.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>2.0.0.RELEASE</version>
</dependency>
</dependencies>
</project>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 org.springframework.cloud.gcp.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 semplice POJO. La classe è annotata con @Entity per indicare che può essere archiviata in Datastore e fornire il nome del tipo (pensa a un tipo come a una tabella nei database SQL. Per ulteriori dettagli, consulta la documentazione). 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 ha bisogno di un identificatore. I tipi supportati sono String e Long.
Eseguiamo l'override del metodo toString per rendere più leggibile la rappresentazione di stringa degli oggetti, il che sarà utile quando li stampiamo.
Non dimenticare di salvare il file.
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 org.springframework.cloud.gcp.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 di 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 immaginare, l'implementazione di questo metodo eseguirà una query che utilizzerà un valore fornito dall'utente nel filtro della condizione per l'uguaglianza al campo Autore.
Il metodo findByYearGreaterThan esegue una query che filtra il campo dell'anno in base a un valore superiore a quello fornito dall'utente.
findByAuthorAndYear esegue una query che cerca entità in cui i campi autore e anno corrispondono ai valori forniti dall'utente.
Apri la classe dell'applicazione principale DemoApplication 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 la classe con @ShellComponent. In questo modo, Spring sa che vogliamo utilizzare questa classe come origine per i comandi CLI. I metodi annotati con @ShellMethod verranno esposti come comandi CLI nella nostra applicazione.
Qui utilizziamo i metodi dichiarati nell'interfaccia BookRepository: findByAuthor, findByYearGreaterThan, findByAuthorAndYear. Inoltre, utilizziamo 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à allocato 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 restituiamo una rappresentazione stringa di questo oggetto.
Il resto dei metodi funziona in modo simile: accettano i parametri passati ai metodi del repository appropriati e restituiscono i risultati in formato stringa.
Per creare e avviare l'applicazione, esegui questo comando in Cloud Shell (dalla radice del progetto datastore-example/ in cui si trova pom.xml) :
$ mvn spring-boot:run
Dopo una fase di build riuscita, viene visualizzato il logo di Spring e il prompt della shell:
. ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |_\__, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: (v2.1.1.RELEASE) shell:>
Ora puoi sperimentare con i comandi che abbiamo definito in precedenza. 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 utilizzando il comando
save-book. - Esegui una ricerca utilizzando il comando
find-all-books. - Trovare libri di un autore specifico (
find-by-author <author>) - Trovare libri pubblicati dopo un anno specifico (
find-by-year-after <year>) - Trovare libri di un autore e di un anno specifici (
find-by-author-year <author> <year>)
Per vedere come vengono archiviate le entità in Cloud Datastore, vai alla console GCP e seleziona Menu -> Datastore (nella sezione Storage) -> Entità (se necessario, seleziona lo spazio dei nomi "[default]" e il tipo "books").
Per fare pulizia, rimuovi tutti i libri utilizzando il comando remove-all-books dall'interfaccia dell'applicazione.
shell:> remove-all-books
Per uscire dall'applicazione, utilizza il comando quit, quindi Ctrl+C.
In questo codelab hai creato un'applicazione CLI interattiva in grado di archiviare e recuperare oggetti da Cloud Datastore.
Scopri di più
- Cloud Datastore: https://cloud.google.com/datastore/
- Spring Shell: https://projects.spring.io/spring-shell/
- Progetto Spring on GCP: http://cloud.spring.io/spring-cloud-gcp/
- Repository GitHub di Spring su GCP: https://github.com/spring-cloud/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.