Introdução ao Boot Spring 3.2.0: Criando um Hello World REST API com Integração NoSQL

Inicie uma jornada pelas mais recentes inovações no desenvolvimento com Spring Boot versão 3.2.0, enquanto orientamos você na criação de um aplicativo “Hello World” fundamental. Neste tutorial, nosso foco vai além da introdução habitual ao Spring; mergulhamos nas complexidades de construir uma API REST enquanto a integramos perfeitamente com um banco de dados NoSQL. O Spring Boot 3.2.0, com sua gama de novos recursos e otimizações, prepara o cenário para uma exploração envolvente das práticas de desenvolvimento contemporâneo. Este guia é adaptado tanto para iniciantes quanto para desenvolvedores experientes, prometendo uma experiência prática na utilização do potencial do Spring para aplicativos robustos e modernos. Vamos começar esta jornada no Spring 3.2.0, onde a simplicidade encontra a inovação.

Novidades no Spring Boot 3.2.0

O Spring Boot 3.2.0 representa um avanço significativo no desenvolvimento Java, exigindo um ambiente mínimo do Java 17 e estendendo o suporte ao inovador Java 21. Esta versão introduz muitos recursos que redefinem o uso do framework Spring.

Uma das características impressionantes do Java é o suporte a threads virtuais, que aumenta a escalabilidade e a responsividade ao utilizar threads leves. Além disso, o Spring Boot 3.2.0 introduz suporte inicial para o Projeto CRaC (Checkpoint Restore JVM), que permite que aplicativos recuperem seu estado após uma reinicialização do JVM, melhorando a confiabilidade e a resiliência.

A segurança ganha destaque com a Recarregamento de Conjuntos SSL, permitindo o recarregamento dinâmico de conjuntos SSL. Essa funcionalidade capacita os desenvolvedores a gerenciar certificados SSL de forma mais dinâmica, garantindo agilidade e segurança em seus aplicativos.

Melhorias na observabilidade estão presentes em todo o lançamento, fornecendo aos desenvolvedores capacidades aprimoradas de monitoramento e rastreamento para uma experiência de desenvolvimento mais transparente e gerenciável.

De acordo com as práticas de desenvolvimento modernas, o Spring Boot 3.2.0 introduz clientes dedicados para operações RESTful (RestClient) e JDBC (JdbcClient). Essas adições simplificam a comunicação com serviços externos, melhorando as capacidades de integração.

A compatibilidade com Jetty 12 é outra inclusão notável, permitindo que os desenvolvedores aproveitem os últimos recursos do servidor web Jetty. O Spring Boot 3.2.0 expande sua compatibilidade de ecossistema com o suporte ao Apache Pulsar, ampliando as capacidades de mensagens do Spring para construir aplicativos robustos e orientados a eventos.

Ao reconhecer a prevalência de Kafka e RabbitMQ, o Spring Boot 3.2.0 introduz o suporte a bundle SSL para esses sistemas de mensagens populares, reforçando a postura de segurança das aplicações que dependem desses brokers de mensagens.

A versão também aborda complexidades de gerenciamento de dependências com uma abordagem reelaborada para lidar com JARs aninhados, garantindo implantações de aplicativos mais confiáveis e previsíveis. Por último, a construção de imagens Docker é aprimorada, o que simplifica o processo de containerização e melhora a portabilidade e a eficiência de implantação dos aplicativos Spring.

Em conclusão, o Spring Boot 3.2.0 se alinha com as últimas versões do Java, introduz recursos inovadores e refina as capacidades existentes. Esta versão capacita os desenvolvedores a construírem com confiança aplicativos modernos, resilientes e de alto desempenho no cenário em constante evolução do desenvolvimento Java.

Mostre-me o código

Nesta sessão, embarcamos em uma jornada emocionante para desenvolver uma API de Pokémon, aproveitando o poder do Spring e integrando-o perfeitamente com o HarperDB. Nosso foco será na implementação de operações fundamentais CRUD (Create, Read, Update, Delete), com ênfase especial na utilização de identificadores únicos (IDs) para cada Pokémon. Ao final desta sessão, você não apenas terá um aplicativo Spring totalmente funcional, mas também uma API de Pokémon à sua disposição, pronta para ser estendida e integrada em projetos maiores. Vamos mergulhar no mundo dos Pokémon e do desenvolvimento com Spring, onde a simplicidade encontra a inovação.

Certifique-se de que seu banco de dados NoSQL, HarperDB, esteja funcionando usando Docker. Abra seu terminal e execute o seguinte 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 puxa a imagem Docker do HarperDB e inicia um contêiner com a configuração especificada. A opção -p mapeia as portas do contêiner para sua máquina local, tornando a interface do HarperDB acessível em http://localhost:9925.

Vá para o Spring Initializer para configurar nosso aplicativo Spring. Siga estas etapas:

1. Selecione as configurações do projeto desejadas (por exemplo, Maven ou Gradle, versão Java).
2. Adicione dependências: escolha “Spring Web” na lista de dependências.
3. Clique em “Generate” para baixar o projeto como um arquivo ZIP.

Extraia o arquivo ZIP baixado e importe o projeto em seu ambiente de desenvolvimento integrado (IDE) preferido, como IntelliJ IDEA ou Eclipse.

Agora que nosso aplicativo Spring está configurado, o próximo passo crucial é integrá-lo com o HarperDB. Para isso, devemos incluir a dependência do HarperDB em nosso projeto. Adicione a seguinte dependência Maven ao seu arquivo pom.xml:

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

Com a dependência em vigor, vamos avançar para o código. Criaremos uma classe de configuração em Spring, HarperDB, para gerenciar a conexão e torná-la uma parte integral do contêiner de Inversão de Controle (IoC) do 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 classe de configuração, anotada com @Configuration, cria um bean do Spring chamado template. O objeto Template é um componente chave para interagir com o HarperDB. Nós inicializamos com os detalhes da conexão do servidor, incluindo o URL do servidor e as credenciais de login. Além disso, criamos um banco de dados chamado “pokemons” e uma tabela chamada “pokemon” com uma coluna “id”. Isso prepara o cenário para armazenar nossas entidades Pokemon no HarperDB.

Para aprimorar a demonstração, primeiro criaremos uma entidade imutável usando o recurso record do Java:

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

Esta classe simples de registro Pokemon encapsula os atributos básicos de um Pokemon—seu ID, nome e localização—de maneira imutável.

Em seguida, vamos estabelecer comunicação com o banco de dados criando o PokemonService para servir como ponte para o 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);
    }
}

A classe PokemonService é um serviço Spring que lida com operações básicas relacionadas a entidades Pokemon. Ele utiliza o objeto Template que configuramos anteriormente para interagir com o HarperDB. O método findById recupera um Pokemon por seu ID, salva adiciona ou atualiza um Pokemon e exclui e remove-o do banco de dados.

Por fim, vamos criar o PokemonController para expor essas operações como endpoints 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 classe PokemonController é anotada com @RestController e define três endpoints:

• GET /pokemons/{id} recupera um Pokemon por seu ID.
• PUT /pokemons cria um novo Pokemon ou atualiza um existente.
• DELETE /pokemons/{id} exclui um Pokemon por seu ID.

O controlador depende do PokemonService para gerenciar essas operações, proporcionando uma separação limpa de responsabilidades em nossa aplicação Spring.

Com esses componentes em vigor, nossa API de Pokémon pode executar operações básicas CRUD usando o HarperDB. Sinta-se à vontade para testar os endpoints e ver a integração perfeita do Spring com o banco de dados NoSQL em ação!

Sua aplicação Spring, integrada com o HarperDB e equipada com uma API de Pokémon, agora está pronta para testes e execução. Vamos explorar alguns cenários comuns usando comandos curl. Antes de prosseguir, certifique-se de que sua aplicação Spring esteja em execução.

Criar um Pokémon

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

Este comando cria um novo Pokémon com ID 1, nome Pikachu e localização Floresta.

Recuperar um Pokémon por ID

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

Substitua {id} pelo ID real do Pokémon que você acabou de criar.

Atualizar um Pokémon

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

Este comando atualiza o Pokémon existente com ID 1 para ter o nome Raichu e localização Tempestade.

Excluir um Pokémon por ID

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

Substitua {id} pelo ID real do Pokémon que deseja excluir.

Esses cenários fornecem um teste abrangente das operações básicas CRUD em sua API de Pokémon, começando com a criação de um Pokémon. Ajuste os comandos conforme necessário com base em seu caso de uso e dados específicos. Boa sorte nos testes!

Conclusão

Neste tutorial, aproveitamos as capacidades do Spring Boot 3.2.0 para criar uma API Pokémon enxuta integrada perfeitamente com o HarperDB. A última versão do Spring introduziu recursos-chave, melhorando nossa capacidade de criar aplicativos resilientes e escalonáveis.

Aproveitando entidades imutáveis, IoC do Spring e HarperDB, demonstramos a simplicidade do desenvolvimento moderno em Java. O código de demonstração, disponível aqui, é uma base para seus projetos, pronta para customização.

Para atualizações e insights aprofundados, consulte o blog oficial do Spring. Que sua jornada com o Spring Boot e HarperDB esteja repleta de inovação e alegria de codificar! Feliz codificação!