¿Alguna vez has querido crear una aplicación web o un microservicio con Java, pero te has sentido abrumado por la complejidad y la configuración que implica? Si es así, no estás solo. Muchos desarrolladores luchan con los desafíos del desarrollo web, como configurar el servidor, administrar las dependencias, manejar la base de datos y más.
Es por eso que Spring Boot cambia las reglas del juego. Spring Boot es un framework que simplifica el desarrollo web con Java. Proporciona características como la autoconfiguración, servidores integrados, dependencias de inicio y más. Con Spring Boot, puedes concentrarte en escribir tu lógica de negocio, en lugar de lidiar con el código repetitivo.
Pero crear una aplicación web o un microservicio no es suficiente. También necesitas probarlo. Las pruebas son cruciales para garantizar la calidad y la fiabilidad de tu software. Te ayudan a encontrar y corregir errores, mejorar el rendimiento y prevenir errores.
Ahí es donde entra Apidog.
En esta entrada de blog, aprenderás a construir y probar una API de Spring Boot con Apidog. Crearás una API RESTful simple con Spring Boot y la probarás con Apidog.
¿Qué es Spring Boot y por qué usarlo?
Spring Boot es un framework que simplifica el desarrollo de aplicaciones Spring. Proporciona muchas características y convenciones que facilitan la creación, configuración, ejecución e implementación de aplicaciones Spring. Algunos de los beneficios de usar Spring Boot son:
- Tiene un sistema de gestión de dependencias de inicio que añade automáticamente las bibliotecas y versiones necesarias para tu proyecto.
- Tiene un servidor web integrado que te permite ejecutar tu aplicación sin ninguna configuración o instalación adicional.
- Tiene un mecanismo de autoconfiguración que detecta y aplica la configuración óptima para tu aplicación en función de las dependencias y el entorno.
- Tiene un soporte listo para producción que incluye características como comprobaciones de estado, métricas, registro y seguridad.
Con Spring Boot, puedes concentrarte en escribir tu lógica de negocio y dejar que el framework se encargue del resto.
¿Qué es Apidog y cómo puede ayudarte a probar tu API?
Apidog es una herramienta que te ayuda a probar tus APIs de una manera sencilla e intuitiva. Te permite conectarte a tu API, explorar los endpoints y crear y ejecutar casos de prueba para tu API. Algunas de las características de APIdog son:
- Tiene una interfaz gráfica de usuario que facilita la interacción con tu API y la visualización de los resultados.
- Tiene un editor de código que te permite escribir y editar tus casos de prueba utilizando JavaScript y aserciones Chai.
- Tiene un ejecutor de pruebas que ejecuta tus casos de prueba y te muestra el estado, la salida y los errores de cada prueba.
- Tiene un generador de informes que crea un informe completo y personalizable de los resultados de tus pruebas.
Con Apidog, puedes probar tu API de forma rápida y fiable y garantizar su calidad y funcionalidad.
Configurando el proyecto
El primer paso es crear un proyecto Spring Boot con Spring Initializr. Spring Initializr es una herramienta web que genera una estructura de proyecto básica y una configuración para ti en función de tus preferencias. Para usar Spring Initializr, sigue estos pasos:
Ve a https://start.spring.io/ y rellena los detalles de tu proyecto. Para este ejemplo, usaré la siguiente configuración:
- Proyecto: Proyecto Maven
- Lenguaje: Java
- Spring Boot: 3.2.3
- Metadatos del proyecto:
- Grupo: com.example
- Artefacto: apidog-demo
- Nombre: apidog-demo
- Descripción: Proyecto de demostración para Spring Boot
- Nombre del paquete: com.example.apidog-demo
- Empaquetado: Jar
- Java: 17
- Dependencias: Spring Web, Spring Data JPA, H2 Database
Haz clic en el botón GENERATE y descarga el archivo zip de tu proyecto.
Extrae el archivo zip y abre el proyecto en tu IDE favorito.
Añadiendo las dependencias para Spring Web y Spring Data JPA
El siguiente paso es añadir las dependencias para Spring Web y Spring Data JPA. Spring Web es un módulo que proporciona el soporte web esencial para construir APIs RESTful con Spring. Spring Data JPA es un módulo que simplifica el acceso y la manipulación de datos en bases de datos relacionales utilizando JPA e Hibernate.
Para añadir estas dependencias, puedes usar Spring Initializr como se mencionó anteriormente, o puedes editar manualmente el archivo pom.xml de tu proyecto y añadir las siguientes dependencias:
<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 las propiedades de la aplicación
El siguiente paso es configurar las propiedades de la aplicación. El archivo application.properties es un archivo que contiene los pares clave-valor que definen el comportamiento y la configuración de tu aplicación. Para este ejemplo, usaremos las siguientes propiedades:
# Enable the H2 console for accessing the database
spring.h2.console.enabled=true
# Set the path of the H2 console
spring.h2.console.path=/h2-console
# Set the URL of the database
spring.datasource.url=jdbc:h2:mem:testdb
# Set the username of the database
spring.datasource.username=sa
# Set the password of the database
spring.datasource.password=
# Set the dialect of the database
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
# Show the SQL statements in the console
spring.jpa.show-sql=true
# Generate the database schema from the entity classes
spring.jpa.hibernate.ddl-auto=update
# Enable the Swagger UI for documenting the API
springdoc.swagger-ui.enabled=true
# Set the path of the Swagger UI
springdoc.swagger-ui.path=/swagger-ui.html
Creando la API
El siguiente paso es crear la API. La API consistirá en un modelo de dominio, un repositorio y un controlador para una entidad simple llamada Book. Un Book tendrá las siguientes propiedades: id, title, author y price.
Creando el modelo de dominio y un repositorio para una entidad simple
El modelo de dominio es una clase que representa los datos y el comportamiento de la entidad. El repositorio es una interfaz que extiende la interfaz JpaRepository y proporciona los métodos para acceder y manipular los datos de la entidad.
Para crear el modelo de dominio y el repositorio para la entidad Book, sigue estos pasos:
- Crea un nuevo paquete llamado com.example.apidogdemo.model y crea una nueva clase llamada Book.java dentro de él.
- Anota la clase con @Entity para marcarla como una entidad JPA y @Table para especificar el nombre de la tabla en la base de datos.
- Define las propiedades de la clase y anótalas con @Id, @GeneratedValue, @Column y @NotNull para especificar la clave primaria, la estrategia de generación, el nombre de la columna y la restricción de validación respectivamente.
- Genera los getters y setters, el constructor y el método toString para la clase.
La clase Book.java debería verse así:
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 +
'}';
}
}
- Crea un nuevo paquete llamado com.example.apidogdemo.repository y crea una nueva interfaz llamada BookRepository.java dentro de él.
- Anota la interfaz con @Repository para marcarla como un repositorio Spring Data JPA.
- Extiende la interfaz JpaRepository y especifica el tipo de entidad y el tipo de clave primaria como los parámetros genéricos.
- Opcionalmente, puedes definir métodos personalizados para consultar los datos de la entidad.
La interfaz BookRepository.java debería verse así:
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> {
// You can define custom methods here
}
Creando un controlador y definiendo los endpoints para las operaciones CRUD
El controlador es una clase que maneja las peticiones y respuestas de la API. El controlador define los endpoints para las operaciones CRUD (crear, leer, actualizar y eliminar) para la entidad.
Para crear el controlador y definir los endpoints para la entidad Book, sigue estos pasos:
- Crea un nuevo paquete llamado com.example.apidogdemo.controller y crea una nueva clase llamada BookController.java dentro de él.
- Anota la clase con @RestController para marcarla como un controlador Spring MVC que devuelve respuestas JSON.
- Anota la clase con @RequestMapping para especificar la ruta base de los endpoints.
- Inyecta la instancia BookRepository usando la anotación @Autowired.
- Define los endpoints para las operaciones CRUD usando las anotaciones @GetMapping, @PostMapping, @PutMapping y @DeleteMapping y especifica la ruta y los parámetros de cada endpoint.
- Usa la clase ResponseEntity para envolver los datos de la respuesta y el código de estado para cada endpoint.
- Usa la anotación @Valid para validar el cuerpo de la petición para los endpoints de crear y actualizar.
- Usa las anotaciones @ExceptionHandler y @ResponseStatus para manejar las excepciones y devolver el código de estado y el mensaje apropiados.
La clase BookController.java debería verse así:
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;
// Get all books
@GetMapping
public ResponseEntity<List<Book>> getAllBooks() {
List<Book> books = bookRepository.findAll();
return new ResponseEntity<>(books, HttpStatus.OK);
}
// Get a book by 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, "Book not found");
}
}
// Create a book
@PostMapping
public ResponseEntity<Book> createBook(@Valid @RequestBody Book book) {
Book savedBook = bookRepository.save(book);
return new ResponseEntity<>(savedBook, HttpStatus.CREATED);
}
// Update a book by 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, "Book not found");
}
}
// Delete a book by 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, "Book not found");
}
}
// Handle the validation exceptions
@ExceptionHandler(javax.validation.ConstraintViolationException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
public String handleValidationExceptions(javax.validation.ConstraintViolationException ex) {
return ex.getMessage();
}
}
Probando la API de Spring Boot con APIdog
El paso final es probar la API con Apidog. Apidog es una herramienta que te ayuda a probar tus APIs de una manera sencilla e intuitiva. Te permite conectarte a tu API, explorar los endpoints y crear y ejecutar casos de prueba para tu API.
Para probar la API con Apidog, sigue estos pasos:
- Inicia Apidog y crea un nuevo proyecto haciendo clic en el botón New Project.
- Introduce el nombre y la descripción de tu proyecto y haz clic en el botón Create.
- Introduce la URL base de tu API y haz clic en el botón Connect.
- Puedes ver la lista de endpoints de tu API en el panel izquierdo. Puedes hacer clic en cada endpoint para ver los detalles y los ejemplos en el panel derecho.
- Puedes crear y ejecutar casos de prueba para tu API haciendo clic en la pestaña Test Cases en el panel derecho. Puedes usar el editor de código para escribir y editar tus casos de prueba usando JavaScript y aserciones Chai.
Puedes usar el ejecutor de pruebas para ejecutar tus casos de prueba y ver el estado, la salida y los errores de cada prueba. Puedes usar el generador de informes para crear un informe completo y personalizable de los resultados de tus pruebas.
Conclusión
En esta entrada de blog, has aprendido a construir y probar una API de Spring Boot con Apidog. Has creado una API RESTful simple con Spring Boot y la has probado con Apidog.
Spring Boot es un framework que simplifica el desarrollo web con Java. Proporciona características como la autoconfiguración, servidores integrados, dependencias de inicio y más. Con Spring Boot, puedes concentrarte en escribir tu lógica de negocio, en lugar de lidiar con el código repetitivo.
Apidog es una herramienta que te ayuda a probar y depurar tus APIs. Te permite conectarte a tu API y explorar los endpoints, crear y ejecutar casos de prueba y generar informes. Con Apidog, puedes probar tu API de forma más rápida y sencilla, sin escribir ningún código.
