En este post te mostraré cómo crear una API REST usando el lenguaje de programación Java, el framework Spring Boot y la base de datos MySQL. Va a ser un proyecto simple pero a partir del mismo vas a poder crear más endpoints o rutas para consumir distintos modelos.

Lo que tendremos al final será un proyecto sencillo que expone una API REST con los métodos HTTP GET, POST, PUT y DELETE, interactuando con la base de datos en MySQL y además soportando CORS.

Por cierto, para el intercambio y consumo de datos vamos a usar JSON.

Creación del proyecto

Puedes crear un proyecto usando gradle, o usando Spring Initializr. También puedes descargar el proyecto ya terminado que te dejaré al final del post.

Dependencias

Nuestro archivo build.gradle debe tener al menos las siguientes dependencias. Obviamente no debe ser idéntico, sino parecido a:

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

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

repositories {
 mavenCentral()
}

dependencies {
 implementation 'org.springframework.boot:spring-boot-starter'
    implementation 'org.springframework.boot:spring-boot-starter-web'
 testImplementation('org.springframework.boot:spring-boot-starter-test') {
  exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
 }
    // Para conectar a bases de datos
    compile 'org.springframework.boot:spring-boot-starter-data-jpa'
    compile 'mysql:mysql-connector-java'

}

test {
 useJUnitPlatform()
}

Estamos usando spring-boot-starter-web para tener las anotaciones para poder crear la API REST, parsear automáticamente la petición a una clase de Java, etcétera.

También estamos usando JPA y el conector de MySQL para poder consumir datos de esta base de datos y realizar las migraciones pertinentes.

Configuración de base de datos

Recuerda que debes contar con MySQL instalado. También debes crear una base de datos que será exclusiva para el proyecto. Para esto puedes usar phpmyadmin, workbench o la terminal. Al final debes tener una base de datos vacía.

Luego, en la carpeta de resources vamos a crear un archivo llamado application.properties para configurar las credenciales. Se debe ver así, cambiando obviamente tus credenciales:

spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:mysql://localhost:3306/consumo_api?useUnicode=true&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

En mi caso mi base de datos se llama consumo_api; mi usuario es root y no tengo contraseña, por lo que es una cadena vacía.

Definiendo la entidad

Cada entidad será una tabla de la base de datos. En este caso vamos a definir la clase Alumno, pues la API se tratará de un CRUD de alumnos. Queda así:

package me.parzibyte.api;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Alumno {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Long id;

    public String nombre;


}

Analicemos. Antes de la declaración de la clase colocamos la anotación de @Entity para indicar que será una entidad. Después definimos las propiedades de nuestra clase, en este caso necesitamos el id y el nombre.

Para el id estamos usando la anotación de @Id y de @GeneratedValue, esto es para indicar que ese es el ID a nivel de base de datos. Con esto, haremos que a partir de la entidad se genere una tabla en la base de datos.

Repositorio

En SpringBoot, un repositorio permite relacionar la entidad y la base de datos. A través del repositorio hacemos las operaciones de SELECT, UPDATE, DELETE e INSERT con los métodos findAll, save, deleteById y de nuevo save, en ese orden.

Lo bueno de todo esto es que simplemente es un interfaz que indica la Entidad, y el Id. La misma extiende de CrudRepository y queda así:

package ControlEscolarSpringBoot;

import org.springframework.data.repository.CrudRepository;

public interface AlumnosRepository extends CrudRepository<Alumno, Long> {
}

En este caso la entidad es Alumno y el tipo de dato del ID es Long.

Controlador

Finalmente el controlador se encarga de:

1. Definir las rutas para la API
2. En cada método, invocar al repositorio para acceder o guardar datos en la base de datos

Si te fijas, se está inyectando de manera automática gracias a la anotación @Autowired. Queda así:

package me.parzibyte.api;

import org.springframework.web.bind.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;

@RestController
@RequestMapping(path = "/alumnos")
@CrossOrigin(origins = "http://localhost")
public class AlumnosController {
    @Autowired
    private AlumnosRepository alumnosRepository;

    @RequestMapping(value = "/crear", method = RequestMethod.POST)
    public Alumno crearAlumno(@RequestBody Alumno alumno) {
        return alumnosRepository.save(alumno);
    }

    @RequestMapping(value = "/obtener", method = RequestMethod.GET)
    public Iterable<Alumno> obtenerTodos() {
        return alumnosRepository.findAll();
    }

    @RequestMapping(value = "/eliminar/{id}", method = RequestMethod.DELETE)
    public boolean eliminar(@PathVariable() Long id) {
        alumnosRepository.deleteById(id);
        return true;
    }

    @RequestMapping(value = "/actualizar", method = RequestMethod.PUT)
    public Alumno editar(@RequestBody Alumno alumno) {
        return alumnosRepository.save(alumno);
    }
}

Por ejemplo, para guardar un nuevo dato usamos el método POST e invocamos al método save del repositorio. En el caso de eliminar, extraemos un valor de la ruta y usamos deleteById.

También es importante mencionar que con @RequestMapping(path = "/alumnos") hacemos que todas las rutas definidas en los métodos sean relativas a /alumnos. Por lo tanto, para consumir los datos debemos acceder a /alumnos/obtener, /alumnos/crear, etcétera.

Finalmente fíjate en que estamos permitiendo CORS en la línea 8. Esto puede ser cambiado a tu gusto.

Código completo

Aquí dejo el código completo de la API, en mi repositorio de GitHub.

Recuerda que debes contar con gradle instalado. Una vez instalado simplemente ejecuta:

gradlew bootRun

Y  luego navega a localhost:8080.

Consumo de API

Puedes consumir la API con cualquier lenguaje que hable HTTP. También puedes usar Postman.

Pronto subiré un vídeo a YouTube demostrando cómo desarrollar la API y cómo consumirla con Postman. Actualización: a continuación dejo el vídeo.

Mientras tanto te recomiendo ver un sistema de ventas que hice hace algún tiempo usando este framework.