Introducción a Boot Spring 3.2.0: Creación de una API REST de Hello World con Integración NoSQL

Emprende un viaje a través de los últimos avances en el desarrollo de Spring Boot con la versión 3.2.0 mientras te guiamos en la creación de una aplicación fundamental “Hello World”. En este tutorial, nuestro enfoque se extiende más allá de la introducción habitual a Spring; profundizamos en las complejidades de construir una API REST mientras la integramos de manera fluida con una base de datos NoSQL. Spring Boot 3.2.0, con su conjunto de nuevas características y optimizaciones, establece el escenario para una exploración enganchante de las prácticas de desarrollo contemporáneas. Esta guía está diseñada tanto para principiantes como para desarrolladores experimentados, prometiendo una experiencia práctica en la explotación del potencial de Spring para aplicaciones robustas y modernas. Comencemos este viaje hacia Spring 3.2.0, donde la simplicidad se encuentra con la innovación.

Novedades en Spring Boot 3.2.0

Spring Boot 3.2.0 marca un salto importante en el desarrollo de Java, exigiendo un entorno mínimo de Java 17 y extendiendo el soporte al innovador Java 21. Esta versión introduce muchas características que redefinen el panorama del uso del marco de trabajo de Spring.

Una de las características impresionantes de Java es el soporte para hilos virtuales, que aumenta la escalabilidad y la capacidad de respuesta mediante el uso de hilos ligeros. Además, Spring Boot 3.2.0 introduce soporte inicial para el Proyecto CRaC (JVM Checkpoint Restore), lo que permite a las aplicaciones recuperar su estado después de un reinicio de JVM, mejorando así la confiabilidad y la resistencia.

La seguridad ocupa un lugar destacado con la recarga dinámica de paquetes SSL, permitiendo la recarga dinámica de paquetes SSL. Esta función permite a los desarrolladores gestionar los certificados SSL de manera más dinámica, asegurando tanto la agilidad como la seguridad en sus aplicaciones.

Las mejoras en la observabilidad están integradas en toda la versión, proporcionando a los desarrolladores capacidades de monitoreo y seguimiento mejoradas para una experiencia de desarrollo más transparente y manejable.

De acuerdo con las prácticas de desarrollo modernas, Spring Boot 3.2.0 introduce clientes dedicados para operaciones RESTful (RestClient) y JDBC (JdbcClient). Estas adiciones facilitan la comunicación con servicios externos, mejorando las capacidades de integración.

La compatibilidad con Jetty 12 es otra incorporación digna de mención, permitiendo a los desarrolladores aprovechar las últimas características del servidor web Jetty. Spring Boot 3.2.0 amplía su compatibilidad con el ecosistema al apoyar Apache Pulsar, ampliando las capacidades de mensajería de Spring para construir aplicaciones sólidas y orientadas a eventos.

Reconociendo la prevalencia de Kafka y RabbitMQ, Spring Boot 3.2.0 introduce soporte para paquetes SSL en estos sistemas de mensajería populares, fortaleciendo la postura de seguridad de las aplicaciones que dependen de estos brokers de mensajes.

El lanzamiento también aborda las complejidades de la gestión de dependencias con un enfoque reelaborado para manejar JARs anidados, asegurando despliegues de aplicaciones más confiables y predecibles. Por último, la construcción de imágenes Docker ve mejoras, facilitando el proceso de contenerización y mejorando la portabilidad y la eficiencia de despliegue de las aplicaciones de Spring.

En conclusión, Spring Boot 3.2.0 se alinea con las últimas versiones de Java, introduce características innovadoras y refina las capacidades existentes. Este lanzamiento capacita a los desarrolladores para construir con confianza aplicaciones modernas, resilientes y de alto rendimiento en el siempre cambiante panorama del desarrollo en Java.

Muestrame el Código

En esta sesión, emprendemos un emocionante viaje para desarrollar una API de Pokémon, aprovechando el poder de Spring e integrándolo de manera fluida con HarperDB. Nuestro enfoque será implementar operaciones fundamentales de CRUD (Crear, Leer, Actualizar, Eliminar), con un énfasis especial en la utilización de identificadores únicos (IDs) para cada Pokémon. Al final de esta sesión, no solo tendrás una aplicación de Spring completamente funcional sino también una API de Pokémon a tu disposición, lista para ser extendida e integrada en proyectos más grandes. ¡Adentrémonos en el mundo de Pokémon y el desarrollo de Spring, donde la simplicidad se encuentra con la innovación.

Asegúrate de que tu base de datos NoSQL, HarperDB, esté funcionando utilizando Docker. Abre tu terminal y ejecuta el siguiente 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

Este comando extrae la imagen de Docker de HarperDB y comienza un contenedor con la configuración especificada. La opción -p mapea los puertos del contenedor a tu máquina local, haciendo que la interfaz de HarperDB sea accesible en http://localhost:9925.

Dirígete al Spring Initializer para configurar nuestra aplicación Spring. Sigue estos pasos:

1. Selecciona las configuraciones del proyecto deseadas (por ejemplo, Maven o Gradle, versión de Java).
2. Agrega dependencias: elige “Spring Web” de la lista de dependencias.
3. Haz clic en “Generate” para descargar el proyecto como un archivo ZIP.

Extrae el archivo ZIP descargado e importa el proyecto en tu entorno de desarrollo integrado (IDE) preferido, como IntelliJ IDEA o Eclipse.

Ahora que nuestra aplicación Spring está configurada, el siguiente paso crucial es integrarla con HarperDB. Para lograr esto, debemos incluir la dependencia de HarperDB en nuestro proyecto. Agrega la siguiente dependencia de Maven a tu archivo pom.xml:

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

Con la dependencia en su lugar, avancemos al código. Crearemos una clase de configuración en Spring, HarperDB, para gestionar la conexión y hacerla parte integral del contenedor de Inversión de Control (IoC) de 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");
    }
}

Esta clase de configuración, anotada con @Configuration, crea un bean de Spring llamado template. El objeto Template es un componente clave para interactuar con HarperDB. Lo inicializamos con los detalles de conexión del servidor, que incluyen la URL del servidor y las credenciales de inicio de sesión. Además, creamos una base de datos llamada “pokemons” y una tabla llamada “pokemon” con una columna “id”. Esto establece el escenario para almacenar nuestras entidades Pokemon en HarperDB.

Para mejorar la demo, primero crearemos una entidad inmutable utilizando la función record de Java:

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

Esta sencilla clase de registro Pokemon encapsula los atributos básicos de un Pokemon—su ID, nombre y ubicación—de manera inmutable.

A continuación, establezcamos la comunicación con la base de datos creando el PokemonService para servir como puente a 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 clase PokemonService es un servicio de Spring que maneja operaciones básicas relacionadas con las entidades Pokemon. Utiliza el objeto Template que configuramos anteriormente para interactuar con HarperDB. El método findById recupera un Pokemon por su ID, guarda agrega, o actualiza un Pokemon, y elimina y lo elimina de la base de datos.

Por último, creemos el PokemonController para exponer estas operaciones como puntos finales 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);
    }
}

Esta clase PokemonController está anotada con @RestController y define tres puntos finales:

• GET /pokemons/{id} recupera un Pokemon por su ID.
• PUT /pokemons crea un nuevo Pokemon o actualiza uno existente.
• DELETE /pokemons/{id} elimina un Pokemon por su ID.

El controlador se basa en el PokemonService para gestionar estas operaciones, proporcionando una clara separación de preocupaciones en nuestra aplicación Spring.

Con estos componentes en su lugar, nuestra API de Pokémon puede realizar operaciones básicas de CRUD utilizando HarperDB. No dude en probar los endpoints y ver la integración perfecta de Spring con la base de datos NoSQL en acción!

Su aplicación Spring, integrada con HarperDB y equipada con una API de Pokémon, ahora está lista para pruebas y ejecución. Exploremos algunos escenarios comunes utilizando comandos curl. Antes de proceder, asegúrese de que su aplicación Spring esté en funcionamiento.

Crear un Pokémon

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

Este comando crea un nuevo Pokémon con el ID 1, el nombre Pikachu y la ubicación Bosque.

Recuperar un Pokémon por ID

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

Reemplace {id} con el ID real del Pokémon que acaba de crear.

Actualizar un Pokémon

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

Este comando actualiza el Pokémon existente con el ID 1 para que tenga el nombre Raichu y la ubicación Tormenta.

Eliminar un Pokémon por ID

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

Reemplace {id} con el ID real del Pokémon que desea eliminar.

Estos escenarios proporcionan una prueba integral de las operaciones básicas de CRUD en su API de Pokémon, comenzando con la creación de un Pokémon. Ajuste los comandos según sea necesario en función de su caso de uso y datos específicos. ¡Felices pruebas!

Conclusión

En este tutorial, aprovechamos las capacidades de Spring Boot 3.2.0 para crear una API de Pokémon simplificada integrada de manera fluida con HarperDB. La última versión de Spring introdujo características clave, mejorando nuestra capacidad para crear aplicaciones resilientes y escalables.

Utilizando entidades inmutables, el Control de Inyección de Spring y HarperDB, demostramos la simplicidad del desarrollo moderno en Java. El código de demostración, disponible aquí, es una base para tus proyectos, lista para ser personalizada.

Para actualizaciones e información detallada, consulta el blog oficial de Spring. Que tu viaje con Spring Boot y HarperDB esté lleno de innovación y alegría de programar! ¡Feliz codificación!