Iniziare con Boot Spring 3.2.0: Creazione di un Hello World REST API con Integrazione NoSQL

Mettiti in viaggio verso le più recenti innovazioni nello sviluppo con Spring Boot versione 3.2.0 mentre ti guidiamo attraverso la creazione di un semplice “Hello World” application. In questo tutorial, il nostro focus si estende oltre l’introduzione consueta a Spring; approfondiamo le sfaccettature della costruzione di una REST API integrandola senza soluzione di continuità con un database NoSQL. Spring Boot 3.2.0, con la sua gamma di nuove funzionalità e ottimizzazioni, prepara il terreno per un coinvolgente esplorazione delle pratiche di sviluppo contemporanee. Questa guida è stata progettata sia per i principianti che per gli sviluppatori esperti, promettendo un’esperienza pratica nell’utilizzo del potenziale di Spring per applicazioni robuste e moderne. Iniziamo questo viaggio verso Spring 3.2.0, dove la semplicità incontra l’innovazione.

Cosa c’è di nuovo in Spring Boot 3.2.0

Spring Boot 3.2.0 rappresenta un significativo progresso nello sviluppo Java, richiedendo un ambiente minimo di Java 17 e estendendo il supporto al cutting-edge Java 21. Questa versione introduce molte funzionalità che ridefiniscono il panorama dell’uso del framework Spring.

Una delle caratteristiche impressionanti di Java è il supporto per thread virtuali, che migliora la scalabilità e la reattività utilizzando thread leggeri. Inoltre, Spring Boot 3.2.0 introduce un supporto iniziale per il Project CRaC (JVM Checkpoint Restore), che consente alle applicazioni di ripristinare lo stato dopo un riavvio della JVM, migliorando così la affidabilità e la resilienza.

La sicurezza è al centro dell’attenzione con il Reloading dei Bundle SSL, che consente il ricaricamento dinamico dei bundle SSL. Questa funzionalità consente ai sviluppatori di gestire i certificati SSL in modo più dinamico, garantendo sia agilità che sicurezza nelle loro applicazioni.

Miglioramenti nell’osservabilità sono distribuiti in tutta la release, fornendo ai sviluppatori capacità di monitoraggio e tracciamento potenziate per un’esperienza di sviluppo più trasparente e gestibile.

In linea con le pratiche di sviluppo moderne, Spring Boot 3.2.0 introduce client dedicati per operazioni RESTful (RestClient) e JDBC (JdbcClient). Queste aggiunte semplificano la comunicazione con i servizi esterni, migliorando le capacità di integrazione.

La compatibilità con Jetty 12 è un’altra inclusione degna di nota, consentendo ai sviluppatori di sfruttare le ultime funzionalità del server web Jetty. Spring Boot 3.2.0 espande la compatibilità del suo ecosistema con il supporto per Apache Pulsar, ampliando le capacità di messaggistica di Spring per costruire applicazioni robuste e guidate da eventi.

Riconoscendo la diffusione di Kafka e RabbitMQ, Spring Boot 3.2.0 introduce il supporto per i bundle SSL per questi popolari sistemi di messaggistica, rafforzando la postura di sicurezza delle applicazioni che si affidano a questi broker di messaggi.

Il rilascio affronta anche le complessità della gestione delle dipendenze con un approccio rivisto per gestire i JAR nidificati, assicurando distribuzioni di applicazioni più affidabili e prevedibili. Infine, la costruzione delle immagini Docker vede miglioramenti, semplificando il processo di containerizzazione e migliorando la portabilità e l’efficienza di distribuzione delle applicazioni Spring.

In conclusione, Spring Boot 3.2.0 si allinea alle ultime versioni di Java, introduce caratteristiche rivoluzionarie e affina le capacità esistenti. Questo rilascio consente ai sviluppatori di costruire con fiducia applicazioni moderne, resilienti e ad alte prestazioni nell’evolvente panorama dello sviluppo Java.

Show Me the Code

In questa sessione, iniziamo un’esplorazione emozionante per sviluppare un’API Pokémon, sfruttando il potere di Spring e integrandolo in modo fluido con HarperDB. Il nostro focus sarà sull’implementazione delle operazioni fondamentali CRUD (Create, Read, Update, Delete), con un’enfasi particolare sull’utilizzo di identificatori unici (ID) per ogni Pokémon. Alla fine di questa sessione, non solo avrai un’applicazione Spring completamente funzionale, ma anche un’API Pokémon a tua disposizione, pronta per essere estesa e integrata in progetti più ampi. Immergiamoci nel mondo dei Pokémon e dello sviluppo Spring, dove la semplicità incontra l’innovazione.

Assicurati che il tuo database NoSQL, HarperDB, sia in funzione utilizzando Docker. Apri il tuo terminale ed esegui il seguente comando:

docker run -d -e HDB_ADMIN_USERNAME=root -e HDB_ADMIN_PASSWORD=password -e HTTP_THREADS=4 -p 9925:9925 -p 9926:9926 harperdb/harperdb

Questo comando estrae l’immagine Docker di HarperDB e avvia un contenitore con la configurazione specificata. L’opzione -p mappa i porte del contenitore sul tuo computer locale, rendendo l’interfaccia HarperDB accessibile all’indirizzo http://localhost:9925.

Vai al Spring Initializer per impostare il nostro applicazione Spring. Segui questi passaggi:

1. Seleziona le impostazioni del progetto desiderate (ad esempio, Maven o Gradle, versione di Java).
2. Aggiungi dipendenze: scegli “Spring Web” dall’elenco delle dipendenze.
3. Fai clic su “Genera” per scaricare il progetto come file ZIP.

Estrai il file ZIP scaricato e importa il progetto nel tuo ambiente di sviluppo integrato (IDE) preferito, come IntelliJ IDEA o Eclipse.

Ora che il nostro applicazione Spring è impostata, il passo cruciale successivo è integrarla con HarperDB. Per realizzare ciò, dobbiamo includere la dipendenza HarperDB nel nostro progetto. Aggiungi la seguente dipendenza Maven al tuo file pom.xml:

<dependency>
    <groupId>io.harperdb</groupId>
    <artifactId>harpderdb-core</artifactId>
    <version>0.0.1</version>
</dependency>

Con la dipendenza in posizione, passiamo al codice. Creeremo una classe di configurazione in Spring, HarperDB, per gestire la connessione e renderla parte integrante del contenitore di Inversion of Control (IoC) di Spring:

@Configuration
public class HarperDB {

    @Bean
    public Template template() {
        Server server = ServerBuilder.of("http://localhost:9925")
                .withCredentials("root", "password");
        server.createDatabase("pokemons");
        server.createTable("pokemon").id("id").database("pokemons");
        return server.template("pokemons");
    }
}

Questa classe di configurazione, annotata con @Configuration, crea un bean Spring denominato template. L’oggetto Template è un componente chiave per interagire con HarperDB. Lo inizializziamo con i dettagli di connessione al server, inclusa l’URL del server e le credenziali di accesso. Inoltre, creiamo un database chiamato “pokemons” e una tabella chiamata “pokemon” con una colonna “id”. Questo prepara il terreno per memorizzare le nostre entità Pokemon in HarperDB.

Per migliorare la demo, creeremo prima un’entità immutabile utilizzando la funzione record di Java:

public record Pokemon(String id, String name, String location) {
}

Questa semplice classe record Pokemon incapsula i principali attributi di un Pokemon – il suo ID, nome e posizione – in modo immutabile.

Successivamente, stabiliamo la comunicazione con il database creando il PokemonService per fungere da ponte verso HarperDB:

@Service
public class PokemonService {

    private final Template template;

    public PokemonService(Template template) {
        this.template = template;
    }

    public Optional<Pokemon> findById(String id) {
        return template.findById(Pokemon.class, id);
    }

    public void save(Pokemon pokemon) {
        template.upsert(pokemon);
    }

    public void delete(String id) {
        template.delete(Pokemon.class, id);
    }
}

La classe PokemonService è un servizio Spring che gestisce operazioni di base relative alle entità Pokemon. Utilizza l’oggetto Template che abbiamo configurato in precedenza per interagire con HarperDB. Il metodo findById recupera un Pokemon per il suo ID, salva aggiunge o aggiorna un Pokemon e lo elimina e rimuove dal database.

Infine, creiamo il PokemonController per esporre queste operazioni come endpoint REST:

@RestController
public class PokemonController {

    private final PokemonService service;

    public PokemonController(PokemonService service) {
        this.service = service;
    }

    @GetMapping("/pokemons/{id}")
    Pokemon findById(@PathVariable String id) {
        return service.findById(id).orElseThrow(() -> new PokemonNotFoundException(id));
    }

    @PutMapping("/pokemons")
    Pokemon newPokemon(@RequestBody Pokemon pokemon) {
        service.save(pokemon);
        return pokemon;
    }

    @DeleteMapping("/pokemons/{id}")
    void deleteEmployee(@PathVariable String id) {
        service.delete(id);
    }
}

Questa classe PokemonController è annotata con @RestController e definisce tre endpoint:

• GET /pokemons/{id} recupera un Pokemon per il suo ID.
• PUT /pokemons crea un nuovo Pokemon o aggiorna uno esistente.
• DELETE /pokemons/{id} elimina un Pokemon per il suo ID.

Il controller si basa su PokemonService per gestire queste operazioni, garantendo una chiara separazione delle responsabilità nel nostro applicazione Spring.

Con questi componenti in posizione, il nostro API Pokemon può eseguire operazioni CRUD di base utilizzando HarperDB. Sentiti libero di testare gli endpoint e vedere l’integrazione senza soluzione di continuità di Spring con il database NoSQL in azione!

La tua applicazione Spring, integrata con HarperDB e dotata di un API Pokemon, è ora pronta per i test e l’esecuzione. Esploriamo alcuni scenari comuni utilizzando comandi curl. Prima di procedere, assicurati che la tua applicazione Spring sia in esecuzione.

Crea un Pokemon

   curl -X PUT -H "Content-Type: application/json" -d '{"id": "1", "name": "Pikachu", "location": "Forest"}' http://localhost:8080/pokemons

Questo comando crea un nuovo Pokemon con ID 1, il nome Pikachu e la location Forest.

Recupera un Pokemon per ID

curl http://localhost:8080/pokemons/{id}

Sostituisci {id} con l’ID effettivo del Pokemon che hai appena creato.

Aggiorna un Pokemon

   curl -X PUT -H "Content-Type: application/json" -d '{"id": "1", "name": "Raichu", "location": "Thunderstorm"}' http://localhost:8080/pokemons

Questo comando aggiorna il Pokemon esistente con ID 1 per avere il nome Raichu e la location Thunderstorm.

Elimina un Pokemon per ID

curl -X DELETE http://localhost:8080/pokemons/{id}

Sostituisci {id} con l’ID effettivo del Pokemon che desideri eliminare.

Questi scenari forniscono un test completo delle operazioni CRUD di base nel tuo API Pokemon, a partire dalla creazione di un Pokemon. Regola i comandi come necessario in base al tuo caso d’uso e ai dati specifici. Buon testing!

Conclusione

In questo tutorial, abbiamo sfruttato le capacità di Spring Boot 3.2.0 per creare un’API Pokemon semplificata integrata in modo fluido con HarperDB. La versione più recente di Spring ha introdotto caratteristiche chiave, migliorando la nostra capacità di creare applicazioni resilienti e scalabili.

Utilizzando entità immutabili, Spring IoC e HarperDB, abbiamo dimostrato la semplicità dello sviluppo moderno in Java. Il codice dimostrativo, disponibile qui, costituisce una base per i tuoi progetti, pronta per essere personalizzata.

Per aggiornamenti e approfondimenti, fare riferimento al blog ufficiale di Spring. Che il tuo viaggio con Spring Boot e HarperDB sia pieno di innovazione e gioia nella programmazione! Buon codice!