Você já quis criar uma aplicação web ou um microserviço com Java, mas se sentiu sobrecarregado pela complexidade e configuração envolvidas? Se sim, você não está sozinho. Muitos desenvolvedores enfrentam os desafios do desenvolvimento web, como configurar o servidor, gerenciar as dependências, lidar com o banco de dados, e mais.
É por isso que o Spring Boot é um divisor de águas. O Spring Boot é um framework que simplifica o desenvolvimento web com Java. Ele fornece recursos como auto-configuração, servidores embutidos, dependências iniciais e mais. Com o Spring Boot, você pode se concentrar em escrever sua lógica de negócio, em vez de lidar com o código repetitivo.
Mas criar uma aplicação web ou um microserviço não é o suficiente. Você também precisa testá-lo. Testar é crucial para garantir a qualidade e confiabilidade do seu software. Isso ajuda você a encontrar e corrigir bugs, melhorar o desempenho e prevenir erros.
É aí que o Apidog entra.
Neste post do blog, você aprenderá como construir e testar uma API Spring Boot com Apidog. Você criará uma API RESTful simples com Spring Boot e a testará com Apidog.
O que é Spring Boot e por que usá-lo?
Spring Boot é um framework que simplifica o desenvolvimento de aplicações Spring. Ele oferece muitos recursos e convenções que facilitam a criação, configuração, execução e implantação de aplicações Spring. Alguns dos benefícios de usar o Spring Boot são:
- Ele possui um sistema de gerenciamento de dependências inicial que adiciona automaticamente as bibliotecas e versões necessárias para o seu projeto.
- Ele tem um servidor web embutido que permite que você execute sua aplicação sem nenhuma configuração ou instalação adicional.
- Ele possui um mecanismo de auto-configuração que detecta e aplica as configurações ideais para sua aplicação com base nas dependências e ambiente.
- Ele oferece suporte pronto para produção que inclui recursos como verificações de saúde, métricas, registro e segurança.
Com o Spring Boot, você pode focar em escrever sua lógica de negócio e deixar o framework cuidar do resto.
O que é Apidog e como ele pode ajudar você a testar sua API?
Apidog é uma ferramenta que ajuda você a testar suas APIs de maneira simples e intuitiva. Ele permite que você se conecte à sua API, explore os endpoints e crie e execute casos de teste para sua API. Alguns dos recursos do Apidog são:
- Ele conta com uma interface gráfica do usuário que facilita a interação com sua API e a visualização dos resultados.
- Ele possui um editor de código que permite que você escreva e edite seus casos de teste usando JavaScript e asserções Chai.
- Ele tem um executor de testes que executa seus casos de teste e mostra o status, a saída e os erros de cada teste.
- Ele inclui um gerador de relatórios que cria um relatório abrangente e personalizável dos resultados dos seus testes.
Com o Apidog, você pode testar sua API de maneira rápida e confiável, garantindo sua qualidade e funcionalidade.
Configurando o projeto
O primeiro passo é criar um projeto Spring Boot com o Spring Initializr. O Spring Initializr é uma ferramenta web que gera uma estrutura básica de projeto e configuração para você com base em suas preferências. Para usar o Spring Initializr, siga estes passos:
Vá para https://start.spring.io/ e preencha os detalhes do seu projeto. Para este exemplo, usarei as seguintes configurações:
- Projeto: Maven Project
- Linguagem: Java
- Spring Boot: 3.2.3
- Metadados do Projeto:
- Grupo: com.example
- Artifact: apidog-demo
- Nome: apidog-demo
- Descrição: Projeto demo para Spring Boot
- Nome do pacote: com.example.apidog-demo
- Empacotamento: Jar
- Java: 17
- Dependências: Spring Web, Spring Data JPA, H2 Database
Clique no botão GERAR e baixe o arquivo zip do seu projeto.
Extraia o arquivo zip e abra o projeto no seu IDE favorito.
Adicionando as dependências para Spring Web e Spring Data JPA
O próximo passo é adicionar as dependências para Spring Web e Spring Data JPA. O Spring Web é um módulo que fornece suporte web essencial para construir APIs RESTful com Spring. O Spring Data JPA é um módulo que simplifica o acesso e manipulação de dados em bancos de dados relacionais usando JPA e Hibernate.
Para adicionar essas dependências, você pode usar o Spring Initializr como mencionado acima, ou pode editar manualmente o arquivo pom.xml do seu projeto e adicionar as seguintes dependências:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
Configurando as propriedades da aplicação
O próximo passo é configurar as propriedades da aplicação. O arquivo application.properties é um arquivo que contém os pares chave-valor que definem o comportamento e as configurações da sua aplicação. Para este exemplo, usaremos as seguintes propriedades:
# Habilitar o console H2 para acessar o banco de dados
spring.h2.console.enabled=true
# Definir o caminho do console H2
spring.h2.console.path=/h2-console
# Definir a URL do banco de dados
spring.datasource.url=jdbc:h2:mem:testdb
# Definir o nome de usuário do banco de dados
spring.datasource.username=sa
# Definir a senha do banco de dados
spring.datasource.password=
# Definir o dialeto do banco de dados
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
# Mostrar as instruções SQL no console
spring.jpa.show-sql=true
# Gerar o esquema do banco de dados a partir das classes de entidade
spring.jpa.hibernate.ddl-auto=update
# Habilitar a Swagger UI para documentar a API
springdoc.swagger-ui.enabled=true
# Definir o caminho da Swagger UI
springdoc.swagger-ui.path=/swagger-ui.html
Criando a API
O próximo passo é criar a API. A API consistirá em um modelo de domínio, um repositório e um controlador para uma entidade simples chamada Livro. Um Livro terá as seguintes propriedades: id, título, autor e preço.
Criando o modelo de domínio e um repositório para uma entidade simples
O modelo de domínio é uma classe que representa os dados e o comportamento da entidade. O repositório é uma interface que estende a interface JpaRepository e fornece os métodos para acessar e manipular os dados da entidade.
Para criar o modelo de domínio e o repositório para a entidade Livro, siga estes passos:
- Criar um novo pacote chamado com.example.apidogdemo.model e criar uma nova classe chamada Book.java dentro dele.
- Anotar a classe com @Entity para marcá-la como uma entidade JPA e @Table para especificar o nome da tabela no banco de dados.
- Definir as propriedades da classe e anotá-las com @Id, @GeneratedValue, @Column e @NotNull para especificar a chave primária, a estratégia de geração, o nome da coluna e a restrição de validação, respectivamente.
- Gerar os getters e setters, o construtor e o método toString para a classe.
A classe Book.java deve ficar assim:
package com.example.apidogdemo.model;
import javax.persistence.*;
import javax.validation.constraints.NotNull;
import java.math.BigDecimal;
@Entity
@Table(name = "books")
public class Book {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "title")
@NotNull
private String title;
@Column(name = "author")
@NotNull
private String author;
@Column(name = "price")
@NotNull
private BigDecimal price;
public Book() {
}
public Book(Long id, String title, String author, BigDecimal price) {
this.id = id;
this.title = title;
this.author = author;
this.price = price;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public BigDecimal getPrice() {
return price;
}
public void setPrice(BigDecimal price) {
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"id=" + id +
", title='" + title + '\'' +
", author='" + author + '\'' +
", price=" + price +
'}';
}
}
- Criar um novo pacote chamado com.example.apidogdemo.repository e criar uma nova interface chamada BookRepository.java dentro dele.
- Anotar a interface com @Repository para marcá-la como um repositório Spring Data JPA.
- Estender a interface JpaRepository e especificar o tipo da entidade e o tipo da chave primária como os parâmetros genéricos.
- Opcionalmente, você pode definir métodos personalizados para consultar os dados da entidade.
A interface BookRepository.java deve ficar assim:
package com.example.apidogdemo.repository;
import com.example.apidogdemo.model.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
// Você pode definir métodos personalizados aqui
}
Criando um controlador e definindo os endpoints para operações CRUD
O controlador é uma classe que lida com as solicitações e respostas da API. O controlador define os endpoints para as operações CRUD (criar, ler, atualizar e deletar) para a entidade.
Para criar o controlador e definir os endpoints para a entidade Livro, siga estes passos:
- Criar um novo pacote chamado com.example.apidogdemo.controller e criar uma nova classe chamada BookController.java dentro dele.
- Anotar a classe com @RestController para marcá-la como um controlador Spring MVC que retorna respostas JSON.
- Anotar a classe com @RequestMapping para especificar o caminho base dos endpoints.
- Injetar a instância de BookRepository usando a anotação @Autowired.
- Definir os endpoints para as operações CRUD usando as anotações @GetMapping, @PostMapping, @PutMapping e @DeleteMapping e especificar o caminho e os parâmetros de cada endpoint.
- Usar a classe ResponseEntity para encapsular os dados da resposta e o código de status para cada endpoint.
- Usar a anotação @Valid para validar o corpo da solicitação para os endpoints de criação e atualização.
- Usar as anotações @ExceptionHandler e @ResponseStatus para lidar com exceções e retornar o código de status e a mensagem apropriados.
A classe BookController.java deve ficar assim:
package com.example.apidogdemo.controller;
import com.example.apidogdemo.model.Book;
import com.example.apidogdemo.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.server.ResponseStatusException;
import javax.validation.Valid;
import java.util.List;
import java.util.Optional;
@RestController
@RequestMapping("/api/books")
public class BookController {
@Autowired
private BookRepository bookRepository;
// Obter todos os livros
@GetMapping
public ResponseEntity<List<Book>> getAllBooks() {
List<Book> books = bookRepository.findAll();
return new ResponseEntity<>(books, HttpStatus.OK);
}
// Obter um livro por id
@GetMapping("/{id}")
public ResponseEntity<Book> getBookById(@PathVariable Long id) {
Optional<Book> book = bookRepository.findById(id);
if (book.isPresent()) {
return new ResponseEntity<>(book.get(), HttpStatus.OK);
} else {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Livro não encontrado");
}
}
// Criar um livro
@PostMapping
public ResponseEntity<Book> createBook(@Valid @RequestBody Book book) {
Book savedBook = bookRepository.save(book);
return new ResponseEntity<>(savedBook, HttpStatus.CREATED);
}
// Atualizar um livro por id
@PutMapping("/{id}")
public ResponseEntity<Book> updateBook(@PathVariable Long id, @Valid @RequestBody Book book) {
Optional<Book> existingBook = bookRepository.findById(id);
if (existingBook.isPresent()) {
book.setId(id);
Book updatedBook = bookRepository.save(book);
return new ResponseEntity<>(updatedBook, HttpStatus.OK);
} else {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Livro não encontrado");
}
}
// Deletar um livro por id
@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteBook(@PathVariable Long id) {
Optional<Book> existingBook = bookRepository.findById(id);
if (existingBook.isPresent()) {
bookRepository.deleteById(id);
return new ResponseEntity<>(HttpStatus.NO_CONTENT);
} else {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Livro não encontrado");
}
}
// Lidar com as exceções de validação
@ExceptionHandler(javax.validation.ConstraintViolationException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
public String handleValidationExceptions(javax.validation.ConstraintViolationException ex) {
return ex.getMessage();
}
}
Testando a API Spring Boot com Apidog
A etapa final é testar a API com Apidog. O Apidog é uma ferramenta que ajuda você a testar suas APIs de maneira simples e intuitiva. Ele permite que você se conecte à sua API, explore os endpoints e crie e execute casos de teste para sua API.
Para testar a API com Apidog, siga estes passos:
- Inicie o Apidog e crie um novo projeto clicando no botão Novo Projeto.
- Insira o nome e a descrição do seu projeto e clique no botão Criar.
- Insira a URL base da sua API e clique no botão Conectar.
- Você pode ver a lista de endpoints da sua API no painel esquerdo. Você pode clicar em cada endpoint para ver os detalhes e os exemplos no painel direito.
- Você pode criar e executar casos de teste para sua API clicando na aba Casos de Teste no painel direito. Você pode usar o editor de código para escrever e editar seus casos de teste usando JavaScript e asserções Chai.
Você pode usar o executor de testes para executar seus casos de teste e ver o status, a saída e os erros de cada teste. Você pode usar o gerador de relatórios para criar um relatório abrangente e personalizável dos resultados dos seus testes.
Conclusão
Neste post do blog, você aprendeu como construir e testar uma API Spring Boot com Apidog. Você criou uma API RESTful simples com Spring Boot e a testou com Apidog.
O Spring Boot é um framework que simplifica o desenvolvimento web com Java. Ele fornece recursos como auto-configuração, servidores embutidos, dependências iniciais e mais. Com o Spring Boot, você pode se concentrar em escrever sua lógica de negócio, em vez de lidar com o código repetitivo.
O Apidog é uma ferramenta que ajuda você a testar e debugar suas APIs. Ele permite que você se conecte à sua API e explore os endpoints, crie e execute casos de teste e gere relatórios. Com o Apidog, você pode testar sua API de forma mais rápida e fácil, sem escrever nenhum código.
