Un servidor Restful con Java Spring

Hacer servidores RESTful con Java y spring es muy sencillo. Spring, con su versión springboot permite hacer por ti los mapeos, funciona como ORM y monta un servidor para vincular los handlers con las string url relacionada

En éste tutorial aprenderás a:

Montar un servidor SpringBoot desde cero.
Crear un Handler que permita vincular una url con su método correspondiente.

Requisitos:

Alguna Base de datos configurada en tu computadora (MongoDB, MYSQL MariaDB)
Java, preferentemente en su versión más reciente.
Un IDE de tu preferenciaa

Parte 1 - Generar y Configurar el proyecto.

Ingresa a Spring initializr y genera un proyecto con:

El grupo (group) en Maven se utiliza para organizar y categorizar los proyectos. Si el nombre de dominio de tu organización es "example.com", el grupo podría ser algo como "com.example".
El artefacto (artifact) representa el producto de construcción del proyecto. c Puede ser un archivo JAR, un archivo WAR (en el contexto de aplicaciones web), o cualquier otro resultado del proceso de construcción. Ejemplo: Si estás construyendo una biblioteca, el artefacto podría ser algo como "mi-biblioteca". Si es una aplicación web, podría ser "mi-aplicacion-web".
El nombre (name) es simplemente el nombre descriptivo del proyecto. Proporciona información adicional sobre la identidad del proyecto. Ejemplo: Si el proyecto es una aplicación de gestión de tareas, el nombre podría ser "Gestor de Tareas".
En este proyecto usaremos Maven, pero puedes ocupar cualquier gestionador.
En las dependencias agrega tu base de datos (en mi caso MariaDB), JPA (Java Persistence API) y Web

Ahora ya tienes el archivo, pero faltan algunas configuraciones. Ingresa a tu archivo src/main/resources/application.properties e ingresa las siguientes líneas: donde tienes que reemplazar tu base de datos, el nombre de la base de datos, tu usuario y tu contraseña.

    spring.datasource.url=jdbc:mariadb://localhost:3306/your_database_name
spring.datasource.username=your_username
spring.datasource.password=your_password
spring.datasource.driver-class-name=org.mariadb.jdbc.Drivers

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

Prueba compilar y ejecutar y deberias de ver algo como

Ya estamos listos para darle estructura al proyecto

Parte 2, creación de una entidad

Ahora, procederemos a crear una entidad. ¿Cuál es su propósito? Una entidad, también conocida como "entity" en inglés, desempeña un papel fundamental en el framework Spring, especialmente cuando se utiliza la tecnología JPA (Java Persistence API). En este contexto, una entidad representa una clase que será persistida en una base de datos.

La creación de una entidad es esencial para que Spring, a través de JPA, tenga la capacidad de mapear objetos Java a registros en la base de datos. En otras palabras, la entidad actúa como una representación de la estructura de datos en tu aplicación, permitiendo que los objetos de esa clase se almacenen y recuperen de la base de datos de manera eficiente.

Antes de crear la entidad, creamos un package nuevo llaado entity. Ahí irán todos los modelos de la base de datos.

Lo primero es indicarle a Spring que vamos a hacer una entidad:

 @Entity
public class Employee {
}

Forzosamente esta entidad te pide que generes un ID como atributo de la entidad.

    @Id@GeneratedValue
    private Long id;

Ingresamos los atributos que queramos en el empleado, en este caso name y role:

    @Id@GeneratedValue
    private Long id;    
    private String name;
    private String role;

y al generar el constructor por default, el constructor que llena los atributos y los getters y setters quedaría:

@Entity
public class Employee {

    @Id@GeneratedValue
    private Long id;


    private String name;


    private String role;

    public Employee(){}
    Employee(String name, String role){
        this.name = name;
        this.role = role;
    }

    public String getName() {
        return name;
    }
    public String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }

    public void setName(String name) {
        this.name = name;
    }



    public void setId(Long id) {
        this.id = id;
    }

    public Long getId() {
        return id;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", role='" + role + '\'' +
                '}';
    }
}

Recuerda que Java es muy verboso, pero realmente el código es muy sencillo.

Parte 3, creación de la interfáz repository.

Ahora, abordaremos una tarea muy sencilla: la creación de una interfaz que nos permita implementar JpaRepository. Dado que estamos trabajando con templates, es esencial indicar explícitamente que la interfaz operará con el tipo <Employee, Long>, donde Long será el tipo de dato del identificador (id).

public interface EmployeeRepository  extends JpaRepository<Employee, Long> {
}

Este repositorio constituye mi sección preferida de Spring. Se trata de una herramienta sumamente potente que, al ser invocada, nos capacita para gestionar los aspectos más fundamentales del CRUD.

¡Y listo! Hemos completado la sección de indexación de objetos en la base de datos. Ahora, adentrémonos en las solicitudes HTTP.

Parte 4, Creación de los controller

Ahora llegó el momento de la verdad. Hacer un handler para gestionar las peticiones http.

Primero creamos una clase con un atributo EmployeeRepository que creamos anteriormente.

  private final EmployeeRepository repository;

  EmployeeController(EmployeeRepository repository) {
    this.repository = repository;
  }

Y empezamos a añadir los handlers. En este ejemplo, ocuparemos tres, ya que hacer más controllers se sale del scope de este tutorial.

  @PostMapping("/employees")
  Employee newEmployee(@RequestBody Employee newEmployee) {
    return repository.save(newEmployee);
  }

  @GetMapping("/employees/{id}")
  Employee one(@PathVariable Long id) {
    
    return repository.findById(id)
      .orElseThrow(() -> new EmployeeNotFoundException(id));
  }

  @GetMapping("/employees")
  List<Employee> all() {
    return repository.findAll();
  }

Hay algunas cosas interesantes. El decorator de arriba de la función handler indica a spring cómo tratar la solicitud, en este caso usamos:

GetMapping
PostMapping
getMapping(con path param)

Y con cada controller usamos alguno de los métodos que spring ya nos ofrece para buscar en la base de datos.

repository.findAll()
repository.findById(id)
repository.save(newEmployee)

Y listo. Básicamente ya tenemos un muy simple servidor RESTFul, puedes hacer las prruebas de post con curl

curl -X POST -H "Content-Type: application/json" -d '{"name":"Mauserion","role":"Developer"}' http://localhost:8080/employees

Y para provar el get, puedes ingresar desde tu navegador ingresando a localhost:8080/employees

[{"id":1,"name":"Bilbo Baggins","role":"burglar"},{"id":2,"name":"Frodo Baggins","role":"thief"},{"id":52,"name":"John Doe","role":"Developer"},{"id":53,"name":"Mausito","role":"Tech lead"},{"id":102,"name":"Mauserion","role":"Developer"}]

Para finalizar, obviamente puedes cambiar lo que sea para tu implementación, pero siempre recordando que Spring usa la siguiente estructura de implementación:

Visita los siguientes enlaces para obtener más información:

Last modified: 17 January 2024