ᐉ Cree una API REST de Spring Boot con Java - Guía completa

Introducción

Contenido

1 Introducción
2 Requisitos
3 Inicialización de un proyecto Spring Boot
- - 3.0.1 Usando Spring Initializr
4 Usando Spring CLI
5 Conexión de Spring Boot a la base de datos
6 Modelo de dominio: creación de un modelo de usuario
7 Capa de persistencia: creación de clases de repositorio
8 Capa empresarial: creación de un controlador
9 Compilar, construir y ejecutar
10 Probando las API
11 Conclusión

DESCANSO son las siglas de REpresentational State Transfer, un enfoque estandarizado para crear servicios web.

UN API REST es una interfaz de programación de aplicaciones intermediaria que permite que dos aplicaciones se comuniquen entre sí a través de HTTP, de forma muy similar a como se comunican los servidores con los navegadores.

RESTful es el enfoque más común para crear servicios web debido a lo fácil que es aprender y construir.

Supongamos que pide algo en un restaurante de comida rápida y el cajero le solicita la información necesaria para procesar su pedido. Una vez procesado, le entregan el pedido que solicitó. Esta transacción es un ejemplo de la vida real de cómo funciona la API REST.

En este tutorial, veremos cómo crear una API REST en Java con Spring Boot. Aceptará POST y GET solicitar cargas útiles para ver y agregar entradas de una entidad – User.

Requisitos

IDE o editor de texto
JDK 1.8+
Maven 3+ o Gradle 4+ (confiaremos en Maven para este artículo)

Inicialización de un proyecto Spring Boot

Usando Spring Initializr

Una forma sencilla de inicializar un nuevo proyecto de Spring Boot es utilizando Spring Initializr, que genera automáticamente un proyecto Spring Boot esqueleto para usted:

Agregaremos algunas dependencias aquí también, ya que queremos usarlas en nuestro proyecto:

Spring Web – Para incluir Spring MVC y Tomcat incrustado en su proyecto
Spring Data JPA – API de persistencia de Java e Hibernate
Spring Boot DevTools – Herramientas de desarrollo muy útiles
Controlador MySQL – Controlador JDBC (puede ser cualquier base de datos que desee utilizar)

Luego, presione generar. Luego se descargará un archivo zip que contiene el proyecto generado.

Usando Spring CLI

Si usted tiene Spring CLI instalado, entonces puede optar por usar la consola para construir su proyecto base usando este comando:

spring init --build=maven -p=jar UserDemo

Nota: Spring CLI llama directamente a Spring Initializr para realizar esta operación. Ambas opciones producirán el mismo proyecto.

Te puede interesar:Obtenga HTTP POST Body en Spring Boot con @RequestBody

Después de crear su proyecto base, descárguelo e impórtelo a su IDE o editor de texto de su elección. Si desea crear, compilar y ejecutar su aplicación a través de su IDE, asegúrese de importarla como un proyecto Maven o Gradle.

Al importar, la base generada pom.xml en su proyecto se verá así:

<!-- Project information-->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>
<!-- Build information -->

Todas las configuraciones que hizo se reflejarán en este archivo. Además de eso, dependencias predeterminadas, su instantánea base 0.0.1-SNAPSHOT, y el plugin de compilación de Maven también se configuran automáticamente.

Como referencia, si desea construir un Proyecto Gradle, tu build.gradle se verá así:

plugins {
	id 'org.springframework.boot' version '2.3.5.RELEASE'
	id 'io.spring.dependency-management' version '1.0.10.RELEASE'
	id 'java'
}

group = 'com.howto'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'

repositories {
	mavenCentral()
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
	implementation 'org.springframework.boot:spring-boot-starter-web'
	developmentOnly 'org.springframework.boot:spring-boot-devtools'
	runtimeOnly 'com.mysql:mysql-connector-java'
	testImplementation('org.springframework.boot:spring-boot-starter-test') {
		exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
	}
}

test {
	useJUnitPlatform()
}

Conexión de Spring Boot a la base de datos

A continuación, antes de empezar a trabajar en la aplicación, queremos configurar la base de datos. Esto se puede hacer fácilmente a través de Spring Data JPA, que nos permite configurar esta conexión con solo un par de parámetros.

Extrae todo lo que debe hacer el desarrollador y nos permite cambiar las bases de datos subyacentes si lo deseamos, simplemente cambiando un par de propiedades.

Para decirle a Spring cómo conectarse a su base de datos preferida, en su application.properties archivo, deberá agregar información rudimentaria:

spring.datasource.url = jdbc:mysql://localhost:3306/user
spring.datasource.username = user
spring.datasource.password = user
spring.jpa.hibernate.ddl-auto = update
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect

Aquí, hemos configurado el datasource.url a nuestra URL de conexión JDBC. Esto depende de su base de datos. Hemos proporcionado el username y password necesario para autenticarse en esa base de datos, así como establecer el ddl-auto propiedad a update. los jpa.hibernate.ddl-auto la propiedad influye directamente en el hibernate.hbm2ddl.auto propiedad, y esencialmente define cómo Hibernate debe manejar la administración de herramientas de esquema.

Para aplicaciones de producción, este valor generalmente se establece en none, como personal dedicado a la gestión de la conducta. En desarrollo, es más común usar update, para permitir que el esquema se actualice cada vez que reinicia la aplicación, lo que le permite flexibilidad mientras trabaja en el desarrollo.

Finalmente, hemos configurado el hibernate.dialect propiedad. Hibernate tiene diferentes dialectos para diferentes bases de datos. Puede establecer automáticamente el dialecto según su configuración, aunque, para mayor seguridad, siempre es una buena idea especificarlo explícitamente.

Modelo de dominio: creación de un modelo de usuario

Ahora que la conexión de la base de datos está funcionando, podemos continuar y saltar al Modelo de dominio. Este es un conjunto de clases, o más bien modelos, que usaremos en nuestra aplicación. Con Hibernate, también se denominan Entidades, así como anotadas por el @Entity anotación.

Te puede interesar:Uso de variables / constantes globales en Java

Cada @Entity es recogido por Hibernate, se crea una tabla para él, se mapean los campos y se convierte en una entidad administrada para la base de datos que ha configurado.

Primero, creemos un sencillo User entidad. Anotaremos la clase con @Entity y el opcional @Table anotación para especificar el nombre de nuestra tabla.

Si no se establece, solo usará el mismo nombre que la clase:

@Entity
@Table(name = "user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private long id;
    private String name;

    // Constructor, getters and setters   
}

Para anotar un campo como id de una entidad, utiliza el @Id anotación, y se establecerá como la clave principal de incremento automático de la tabla. Además, también puede configurar que sea un @GeneratedValue y establecer el GenerationType a AUTO.

Esta es la configuración predeterminada, si omite la @GeneratedValue anotación. Otros valores que puede establecer son IDENTITY, SEQUENCE y TABLE. Estos garantizan un artículo propio sobre Hibernate.

Además, puede configurar @Column anotaciones para cada uno de los campos, proporcionando un nombre para cada uno de ellos si desea nombres personalizados – @Column(name = "user_id"), salvaría el id campo como user_id en lugar de solo id.

Si desea automatizar la generación de constructores, captadores y definidores y simplemente evitar el código repetitivo en total, puede usar herramientas ingeniosas como Lombok.

Esta clase (entidad) ahora está registrada con Hibernate. Si ejecutamos la aplicación, considerando nuestro ddl-auto configuración, la tabla aparecerá en su base de datos respectiva, con la tabla correcta y las asignaciones para los tipos de datos.

Capa de persistencia: creación de clases de repositorio

A continuación, trabajemos en la capa de persistencia. Queremos tener un UserRepository para realizar operaciones CRUD en nuestro User entidades. Para hacer esto, especificaremos una interfaz que se extiende CrudRepositoryy anótelo con @Repository.

@Repository es una variante del @Component anotación, que le permite a Spring saber que es un componente que debe ser administrado por el contenedor de IoC. Específicamente, los repositorios están destinados a definir la lógica para la capa de persistencia.

los CrudRepository extenssion acepta la clase de entidad, así como la id tipo de datos que debe usar para consultar:

Te puede interesar:@Controller y @RestController Anotaciones en Spring Boot

@Repository
public interface UserRepository extends CrudRepository<User, Long> {}

CrudRepository declara métodos como findAll(), findOne()y save() que constituyen la funcionalidad CRUD básica de un repositorio. Puedes usar esto UserRepository tal cual, para realizar operaciones CRUD en User entidades ahora, sin más configuración requerida.

Puede anular parte de este comportamiento, si lo desea, sin embargo, se configura automáticamente para ayudarlo a iniciar algunas funciones básicas.

Capa empresarial: creación de un controlador

Finalmente, llegamos a la capa empresarial, donde implementamos la lógica empresarial real del procesamiento de información y usamos los componentes de la capa de persistencia, junto con el modelo de dominio para almacenar datos.

Creemos un controlador, márquelo como @RestController, ya que estamos creando una API REST y agregamos una @RequestMapping lo. @RestController es solo una combinación de @Controller y @ResponseBody, lo que significa que en lugar de representar páginas, solo responderá con los datos que le hemos proporcionado. Esto es natural para las API REST: devuelve información una vez que se ha alcanzado un punto final de la API.

Si desea leer más sobre @RequestMapping y sus variantes derivadas, ¡tenemos un excelente artículo dedicado solo a ese tema!

Sigamos adelante y hagamos un UserController:

@RestController
@RequestMapping("/api/user")
public class UserController {

    @Autowired
    private UserRepository userRepository;
        
    @GetMapping
    public List<User> findAllUsers() {
        // Implement
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> findUserById(@PathVariable(value = "id") long id) {
       // Implement
    }

    @PostMapping
    public User saveUser(@Validated @RequestBody User user) {
        // Implement
    }
}

Tenemos @Autowired nuestra UserRepository. Se usa para la inyección de dependencias, ya que la clase de repositorio es una dependencia aquí. Si desea leer más sobre las anotaciones de Core Spring Framework, consulte nuestra guía.

También hemos utilizado el @GetMapping y @PostMapping anotaciones para especificar qué tipos de solicitudes HTTP aceptan y manejan nuestros métodos. Estas son variantes derivadas del @RequestMapping anotación, con una method = RequestMethod.METHOD establecido para los tipos respectivos.

Comencemos con la implementación del findAll() punto final:

@GetMapping
public List<User> findAllUsers() {
    return userRepository.findAll();
}

Este método simplemente llama al userRepository a findAll() usuarios y devuelve la lista como respuesta.

A continuación, implementemos el punto final para obtener a cada usuario por su id:

Te puede interesar:Guía para la clase StringUtils de Apache Commons en Java

@GetMapping("/{id}")
public ResponseEntity<User> findUserById(@PathVariable(value = "id") long id) {
    Optional<User> user = userRepository.findById(id);

    if(user.isPresent()) {
        return ResponseEntity.ok().body(user.get());
    } else {
        return ResponseEntity.notFound().build();
    }
}

A con lo dado id podría no estar presente en la base de datos, por lo que ajustamos el devuelto User en un Optional. Si desea leer más sobre Opcional en Java 8, ¡tenemos una guía detallada!

Entonces, si el user.isPresent(), devolvemos un 200 OK Respuesta HTTP y establezca el user instancia como el cuerpo de la respuesta. De lo contrario, devolvemos un ResponseEntity.notFound().

Finalmente, creemos un punto final para salvar a los usuarios:

@PostMapping
public User saveUser(@Validated @RequestBody User user) {
    return userRepository.save(user);
}

los save() El método del repositorio de usuarios guarda un nuevo usuario si aún no existe. Si el usuario con el id ya existe, lanza una excepción. Si tiene éxito, devuelve el usuario persistente.

los @Validated La anotación es un validador de los datos que proporcionamos sobre el usuario y refuerza la validez básica. Si la información del usuario no es válida, los datos no se guardan. También el @RequestBody anotación mapea el cuerpo del POST solicitud enviada al punto final al User instancia que nos gustaría guardar.

Si desea leer más sobre cómo obtener el cuerpo HTTP en Spring Boot, ¡lo tenemos cubierto!

Ahora es el momento de ejecutar la aplicación y probar si funciona.

Compilar, construir y ejecutar

El puerto predeterminado en el que se ejecuta Spring Boot es 8080. Si desea cambiar el puerto por cualquier motivo, puede configurarlo en su application.properties archivo:

server.port = 9090

Si tiene un IDE como IntelliJ que tiene un amplio soporte para ejecutar proyectos Spring Boot, entonces puede seguir adelante y ejecutarlo de esa manera.

De lo contrario, usaremos la línea de comando para ejecutar nuestro proyecto. Podemos ejecutar la aplicación directamente ejecutando ./mvnw spring-boot:run (o ./gradlew bootRun si está usando Gradle) en la línea de comando desde la carpeta de su proyecto base donde pom.xml se encuentra.

Otra opción es empaquetar su aplicación en un jar archivo y ejecutarlo de esa manera.

Te puede interesar:Eliminar elemento de una matriz en Java

Para hacer esto, solo tenemos que ejecutar ./mvnw clean package (.gradlew build en Gradle) y ejecute el archivo jar ejecutando este comando:

$ java -jar target/DemoUser-0.0.1-SNAPSHOT.jar

Si está utilizando Gradle, la ruta al archivo jar será diferente:

$ java -jar build/libs/DemoUser-0.0.1-SNAPSHOT.jar

Sabrá cuándo su aplicación se ha ejecutado correctamente si ve estos registros de auditoría al final de su línea de comando:

2020-11-05 13:27:05.073  INFO 21796 --- [  restartedMain] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
2020-11-05 13:27:05.108  INFO 21796 --- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2020-11-05 13:27:05.121  INFO 21796 --- [  restartedMain] com.howto.DemoUser.DemoUserApplication   : Started DemoUserApplication in 1.765 seconds (JVM running for 2.236)

Probando las API

Ahora que su aplicación está funcionando en http://localhost:8080/, ahora podemos probar los puntos finales para ver si funcionan.

Para el GET solicitudes, podemos utilizar navegadores, curl o cartero – lo que sea más conveniente para usted.

Vamos a golpear el http://localhost:8080/api/user punto final con un GET solicitud:

$ curl http://localhost:8080/api/user

O, en la barra de direcciones de su navegador, visite http://localhost:8080/api/user, y su navegador mostrará una respuesta JSON:

[
   {
      "id": 1,
      "name":"John"
   },
   {
      "id": 2,
      "name":"Jane"
   },
   {
      "id": 3,
      "name": "Juan"
   }
]

Podemos modificar esta URL para incluir un parámetro de ruta, el id para obtener un usuario específico. Enviemos una solicitud HTTP GET a http://localhost:8080/api/user/3:

{
    "id": 3,
    "name": "Juan"
}

Finalmente, enviemos una solicitud HTTP POST y agreguemos un usuario a nuestra base de datos, proporcionando los datos requeridos en nuestro modelo. Los campos de la carga útil JSON deben coincidir con los nombres de los campos en nuestra base de datos / modelo:

$ curl --location --request POST 'http://localhost:8080/api/user' 
--header 'Content-Type: application/json' 
--data-raw '{ "id": 4, "name": "Jason" }'

La API devolverá 200 como respuesta con esto como el cuerpo de respuesta del usuario persistente:

{
    "id": 4,
    "name": "Jason"
}

Conclusión

Ahí tienes. ¡Ha creado con éxito su propia API REST de Spring Boot!

Te puede interesar:Cómo dividir una cadena en Java

En este tutorial, hemos creado un proyecto Spring Boot en pleno funcionamiento que expone una API al usuario final. Con esta API, un usuario puede realizar operaciones CRUD en un User entidad.

Hemos cubierto el modelo de dominio, la capa de persistencia y la capa de negocio, después de configurar la conexión a la base de datos y configurar el proyecto.

5/5 - (2 votos)

Cree una API REST de Spring Boot con Java – Guía completa