Informazioni su questo codelab
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 oggetti Java in Spring Boot
Che cosa ti serve
Come utilizzerai questo tutorial?
Come giudichi la tua esperienza con l'utilizzo dei servizi Google Cloud Platform?
2. Configurazione e requisiti
Configurazione automatica dell'ambiente
Se non hai ancora un Account Google (Gmail o Google Apps), devi crearne uno. Accedi alla console di Google Cloud Platform (console.cloud.google.com) e crea un nuovo progetto.
Ricorda l'ID progetto, un nome univoco in tutti i progetti Google Cloud (il nome sopra riportato è già stato utilizzato e non funzionerà per te). Vi verrà fatto riferimento più avanti in questo codelab come PROJECT_ID.
Il prossimo passaggio consiste nell'attivare la fatturazione in Cloud Console per utilizzare le risorse di Google Cloud.
L'esecuzione di questo codelab non dovrebbe costare più di qualche euro, ma potrebbe essere di più 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 sono idonei per una prova senza costi di 300 $.
Attiva Google Cloud Shell
Nella console di GCP, fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra:
Quindi fai clic su "Start Cloud Shell":
Bastano pochi istanti per eseguire il provisioning e connettersi all'ambiente:
Questa macchina virtuale è dotata di tutti gli strumenti di sviluppo di cui hai bisogno. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. Gran parte del lavoro in questo lab, se non tutto, può essere svolto semplicemente con un browser o con Google Chromebook.
Una volta connesso a Cloud Shell, dovresti vedere che sei già autenticato e che 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].
3. Inizializza Cloud Datastore
Nella console di GCP, vai a Menu -> Datastore (nella sezione Storage).
Se non hai mai utilizzato Datastore nel progetto corrente, verrà visualizzata la schermata "Select a Cloud Firestore mode". Seleziona l'opzione "Modalità datastore".
Dopodiché vedrai la schermata "Scegli dove memorizzare i dati". Seleziona us-east1 o un'altra località a livello di area geografica e fai clic su "Crea database".
4. Avvia una nuova applicazione Java Spring Boot
Dall'ambiente CloudShell, utilizza il comando seguente 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 Maven, un wrapper Maven e un punto di contatto per l'applicazione.
La nostra applicazione fornirà un'interfaccia a riga di comando in cui gli utenti possono inserire comandi e visualizzare risultati. Verrà creata una classe per rappresentare un libro e quindi verrà salvata in Cloud Datastore utilizzando Datastore Repository.
Dobbiamo anche aggiungere un'ulteriore dipendenza necessaria a pom.xml.
Apri l'editor di codice web facendo clic su Avvia editor di codice dal menu Cloud Shell.
Dopo aver caricato l'editor, modifica il file pom.xml per aggiungere la dipendenza Spring Boot, avviatore da Cloud Datastore Cloud Storage:
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>5. Creare la classe 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 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 vedi, questo è un POJO semplice. La classe è annotata con @Entity per indicare che può essere archiviata in Datastore e fornire il nome del tipo (pensa a un tipo di tabella nei database SQL, consulta la documentazione per maggiori dettagli). Il nome del tipo è facoltativo: se viene omesso, il nome del tipo viene generato in base al nome della classe.
Abbiamo annotato la proprietà id con @Id. Questo indica che vogliamo che questo campo venga utilizzato come parte identificatore della chiave Datastore. Ogni entità Datastore richiede un identificatore. I tipi supportati sono String e Long.
Eseguiamo l'override del metodo toString per rendere la rappresentazione della stringa degli oggetti più leggibile. Questo sarà utile quando li stampiamo.
Non dimenticare di salvare il file.
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 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 del dominio e Long è il tipo Id. Dichiariamo tre metodi di query nel nostro repository per i quali le implementazioni vengono generate automaticamente dietro le quinte.
Il primo è findByAuthor. Come puoi intuire, l'implementazione di questo metodo eseguirà una query che utilizzerà un valore fornito dall'utente nel filtro delle condizioni per l'uguaglianza dell'autore.
Il metodo findByYearGreaterThan esegue una query che filtra in base al campo dell'anno con un valore maggiore dell'utente.
findByAuthorAndYear esegue una query che cerca le entità in cui i campi autore e anno corrispondono ai valori forniti dagli utenti.
7. Crea l'applicazione di interfaccia a riga di comando interattiva
Apri la classe DemoApplication dell'applicazione principale e modificala in modo simile a questa:
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();
}
}Abbiamo annotato la classe con @ShellComponent. Questo indica a Spring che vogliamo utilizzare questa classe come fonte di 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 di BookRepository: findByAuthor, findByYearGreaterThan, findByAuthorAndYear. Inoltre, utilizziamo tre metodi integrati: save, findAll e deleteAll.
Diamo un'occhiata al metodo saveBook . Creiamo un oggetto Book utilizzando valori forniti dall'utente per titolo, autore e anno. Come puoi vedere, non forniamo un valore id, che verrà assegnato automaticamente e assegnato 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 completati, incluso il campo id. Alla fine restituiamo una rappresentazione di stringa di questo oggetto.
Gli altri metodi funzionano allo stesso modo: accettano il passaggio di parametri ai metodi del repository appropriati e restituiscono risultati stringati.
8. Eseguire l'applicazione
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
Al termine della fase di compilazione, verrà visualizzato il logo primavera e verrà mostrato il prompt di shell:
. ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |_\__, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: (v2.1.1.RELEASE) shell:>
Ora puoi sperimentare con i comandi che abbiamo definito in precedenza. Per visualizzare l'elenco di 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:
- Creare alcuni libri con il comando
save-book - Eseguire una ricerca utilizzando il comando
find-all-books - Trovare libri di un autore specifico (
find-by-author <author>) - Trova libri pubblicati dopo un anno specifico (
find-by-year-after <year>) - Trova libri di un autore e di un anno specifici (
find-by-author-year <author> <year>)
9. Visualizzare i contenuti archiviati in Datastore utilizzando l'interfaccia web
Per informazioni su come vengono archiviate le entità in Cloud Datastore, vai alla console di GCP e vai a Menu -> Datastore (nella sezione Storage) -> Entities (seleziona "[default]" spazio dei nomi e "libri" tipo, se necessario).
10. Esegui la pulizia
Per la pulizia, rimuovi tutti i libri utilizzando il comando remove-all-books appropriato dalla shell dell'applicazione.
shell:> remove-all-books
Per uscire dall'applicazione, utilizza il comando esci, quindi Ctrl + C.
11. Complimenti!
In questo codelab, hai creato un'applicazione dell'interfaccia a riga di comando 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.source.io/Spring-shell/
- Progetto Spring su GCP: http://cloud.primavera.io/primavera-cloud-gcp/
- Spring nel repository GitHub di GCP: https://github.com/molla-cloud/primavera-cloud-gcp
- Java su Google Cloud Platform: https://cloud.google.com/java/
Licenza
Questo lavoro è concesso in licenza ai sensi di una licenza Creative Commons Attribution 2.0 Generic.