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

Inicie uma jornada pelas mais recentes avançadas no desenvolvimento com Spring Boot na versão 3.2.0, guiando-o através da criação de um aplicativo fundamental “Hello World”. 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 palco para uma exploração envolvente das práticas de desenvolvimento contemporâneas. Este guia é adaptado tanto para iniciantes quanto para desenvolvedores experientes, prometendo uma experiência prática no aproveitamento do potencial do Spring para aplicativos modernos e robustos. Vamos começar essa 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 salto significativo na Java desenvolvimento, exigindo um ambiente mínimo do Java 17 e estendendo o suporte ao inovador Java 21. Esta versão introduz muitos recursos que redefine o uso do quadro 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 as aplicações recuperem seu estado após um reinício do JVM, melhorando a confiabilidade e a resiliência.

A segurança está no centro das atenções com o Recarregamento Dinâmico 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 suas aplicações.

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 agilizam a comunicação com serviços externos, melhorando as capacidades de integração.

A compatibilidade com Jetty 12 é outra inclusão digna de nota, permitindo que os desenvolvedores aproveitem os últimos recursos do servidor web Jetty. O Spring Boot 3.2.0 expande sua compatibilidade com o ecossistema com suporte para o Apache Pulsar, ampliando as capacidades de mensagens do Spring para a construção de aplicações robustas e orientadas a eventos.

Reconhecendo 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, fortalecendo a postura de segurança de aplicativos 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 fim, 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 de 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 capacidades existentes. Esta versão capacita os desenvolvedores a construírem com confiança aplicativos modernos, resilientes e de alto desempenho na paisagem em constante evolução do desenvolvimento Java.

Mostre-me o código

Nesta sessão, iniciamos uma emocionante jornada 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 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 extrai 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á até 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 do 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 o 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 do 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 prosseguir para o código. Vamos criar uma classe de configuração no Spring, HarperDB, para gerenciar a conexão e torná-la uma parte integrante 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");
    }
}

Essa 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. Inicializamos com os detalhes de 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 demo, primeiro criaremos uma entidade imutável usando o recurso record do Java:

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

Essa 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. Utiliza o objeto Template que configuramos anteriormente para interagir com o HarperDB. O método findById recupera um Pokemon pelo 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);
    }
}

Essa classe PokemonController é anotada com @RestController e define três endpoints:

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

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

Com esses componentes em vigor, nossa API de Pokémon pode realizar operações básicas CRUD usando 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 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 você 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 simplificada integrada perfeitamente com o HarperDB. A última versão do Spring introduziu recursos-chave, melhorando a nossa capacidade de criar aplicações resilientes e escaláveis.

Aproveitando entidades imutáveis, Spring IoC 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 seja repleta de inovação e alegria de codificar! Feliz codificação!