REST API: Java Spring Boot y MongoDB

¿Porque Spring Boot?

El framework Java Spring Boot proporciona un conjunto poderoso de herramientas para el

desarrollo web tanto en el front-end como en el back-end. Tiene una configuración incorporada
para la seguridad y el acceso a la base de datos, así como asignaciones de solicitud simples. Este
marco es altamente configurable y hace que el desarrollo web sea extremadamente simple.

Herramientas usadas en este tutorial

1. Java

2. Spring Boot

3. Maven

4. MongoDB

Usando Spring Initializr

Spring ofrece una herramienta llamada Spring Initializr para ayudar a poner en marcha su proyecto
Spring Boot. Acceda a Initializr en https://start.spring.io/ e ingrese la siguiente información:

• Grupo: este es el nombre del paquete

Ejemplo: com.services

• Artefacto: este es el nombre del proyecto

Ejemplo: cosmo

• Dependencias: estas son las características que se agregarán a su proyecto (recuerde, siempre
puede agregarlas más adelante)

Nuestro tutorial utilizará las dependencias "Web" y "MongoDB"

Luego haga clic en Generar proyecto para descargar un archivo .zip con la estructura básica del
proyecto.

Añadiendo modelo a Spring Boot Project

Con el proyecto descargado de Spring Initializr, ahora puede abrirlo en su IDE favorito para
comenzar a editar el proyecto. Primero, deseamos agregar el modelo de usuario para que Spring
sepa qué tipo de datos devolverá la base de datos. Podemos hacer esto creando una nueva carpeta
en src/main/java/[nombre del paquete]/ llamado "modelos". En la nueva carpeta de
"modelos", podemos crear un archivo llamado Usuario.java. Esta clase de Java mantendrá la
estructura básica de un documento en la colección de "usuario", por lo que la clase tiene el siguiente
aspecto

package com.services.cosmo.models;

import org.bson.types.ObjectId;
import org.springframework.data.annotation.Id;
public class Usuario {
@Id
public ObjectId _id;

public String correo;

public String contrasenia;

// Constructors
public Usuario() {}

public Usuario(ObjectId _id, String correo, String contrasenia) {

this._id = _id;
this.correo = correo;
this.contrasenia = contrasenia;
}

// ObjectId needs to be converted to string

public String get_id() { return _id.toHexString(); }
public void set_id(ObjectId _id) { this._id = _id; }

public String getcorreo() { return correo; }

public void setcorreo(String correo) { this.correo = correo; }

public String getcontrasenia() { return contrasenia; }

public void setcontrasenia(String contrasenia) { this.contrasenia =
contrasenia; }

La anotación @Id le dice a spring que el campo _id se usará como el identificador principal. El resto
de la clase contiene los constructores, getters y setters básicos para el objeto Usuario.

Agregando Repository a Spring Boot Project

Ahora que tenemos un modelo que identifica la estructura de datos almacenados en la base de
datos para Spring Boot, podemos crear el conector entre el modelo y MongoDB. Esto se hace a
través de una interfaz de Repository. Podemos crear esto primero haciendo una nueva carpeta
llamada "repositories" en src/main/java/[nombre del paquete]/.
En la nueva carpeta de "repositories", podemos crear un archivo llamado UsuarioRepository.java.
El nombre de este repositorio es extremadamente importante porque le dice a MongoDB la
colección que consultará (en este caso, la colección de usuario). Esta interfaz ampliará la clase
MongoRepository, que ya contiene métodos genéricos como save o guardar (para crear /
actualizar documentos) y delete o eliminar (para eliminar documentos), pero necesitaremos
especificar métodos adicionales para nosotros mismos.

Afortunadamente, no necesitamos implementar manualmente estas consultas, simplemente

podemos usar las convenciones de nomenclatura del repositorio de Spring Boot, y MongoRepository
construirá las consultas de forma inteligente en tiempo de ejecución. Esto significa que nuestra
interfaz será extremadamente simple, como sigue:

package com.services.cosmo.repositories;
import com.services.cosmo.models.Usuario;
import org.bson.types.ObjectId;
import org.springframework.data.mongodb.repository.MongoRepository;
public interface UsuarioRepository extends MongoRepository<Usuario, String> {
Usuario findBy_id(ObjectId _id);
}

Agregando la información de conexión de MongoDB

Para decirle a Spring la información de conexión para nuestro MongoDB, debemos agregar detalles
de conexión al archivo application.properties, ubicado en la carpeta "src/main/resources". Agregue
las siguientes líneas al archivo, reemplazando la información entre paréntesis con la información
específica de su instancia de MongoDB:
spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.authentication-database=admin
spring.data.mongodb.username=CosmoAdmin
spring.data.mongodb.password=cosmo
spring.data.mongodb.database=cosmo

Esta es toda la información que Spring necesitará para conectarse a la base de datos.

Creación del controlador REST

Spring ahora debería poder conectarse a MongoDB, por lo que ahora podemos establecer los
endpoints con los que podemos contactar para interactuar con la base de datos. Esto se hará en un
Controlador Spring Rest, que utiliza Request Mappings o mapeos para asignar solicitudes con
funciones. Podemos crear un controlador Rest agregando un archivo llamado
UsuarioController.java en la carpeta src/main/java/[nombre del paquete]/. La estructura
básica de archivos se verá como sigue:
package com.services.cosmo;
import com.services.cosmo.models.Usuario;
import com.services.cosmo.repositories.UsuarioRepository;

import org.bson.types.ObjectId;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import javax.validation.Valid;
import java.util.List;
@RestController
@RequestMapping("/usuario")

public class UsuarioController {

@Autowired
private UsuarioRepository repository;

La anotación @RestController le dice a Spring que esta clase será solicitada por la URL y
devolverá los datos al solicitante. La anotación @RequestMapping especifica la URL base que
manejará el controlador, por lo que cualquier solicitud al host que comience con "/usuario" se
dirigirá a este controlador. La anotación @Autowired crea una instancia del objeto
UsuarioRepository que nos permitirá acceder y modificar la base de datos de usuario.

Añadiendo los Endpoints a REST

Todos los siguientes endpoint serán agregados directamente a la clase UsuarioController.

GET
@RequestMapping(value = "findAll/", method = RequestMethod.GET)
public List<Usuario> getAllUsuarios() {
return repository.findAll();
}
@RequestMapping(value = "findById/{id}", method = RequestMethod.GET)
Public Usuario getUsuarioById(@PathVariable("id") ObjectId id) {
return repository.findBy_id(id);
}

La primera asignación o mapeo lleva a cualquier solicitud GET al host con una URL de
/usuario/findAll/ y las asigna al método getAllUsuarios(), que solicita todos los
documentos de la colección de usuario.

La segunda asignación y las solicitudes GET al host con una URL de /usuario/findById/ seguido
por un ObjectId que es un id en nuestra colección de usuario y las asigna al método
getUsuarioById(), que busca en la colección de usuario el documento con un campo _id igual
al ObjectId en la URL .
PUT
@RequestMapping(value = "/updateOne/{id}", method = RequestMethod.PUT)
public void modifyUsuarioById(@PathVariable("id") ObjectId id, @Valid
@RequestBody Usuario usuario) {
usuario.set_id(id);
repository.save(usuario);
}

Esta asignación espera un request body o cuerpo de solicitud (en formato JSON) con cada uno de
los campos que contiene un objeto Usuario (correo y contrasenia). El id en el URL de la solicitud
es el _id del documento a modificar.

POST
@RequestMapping(value = "/insertOne/", method = RequestMethod.POST)
public Usuario createUsuario(@Valid @RequestBody Usuario usuario) {
usuario.set_id(ObjectId.get());
repository.save(usuario);
return usuario;
}

Esta asignación espera un request body o cuerpo de solicitud (en formato JSON) con cada uno de
los campos que contiene un objeto Usuario (correo y contrasenia), y le asigna un nuevo
ObjectId. Este objeto se inserta en la colección de usuario y se devuelve el nuevo objeto Usuario.

DELETE
@RequestMapping(value = "deleteOne/{id}", method =
RequestMethod.DELETE)
public void deleteUsuario(@PathVariable ObjectId id) {
repository.delete(repository.findBy_id(id));
}

Este endpoint toma el _id de un documento en la colección de usuario y elimina ese documento de
la colección.

Controlador completo
package com.services.cosmo;
import com.services.cosmo.models.Usuario;
import com.services.cosmo.repositories.UsuarioRepository;

import org.bson.types.ObjectId;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import javax.validation.Valid;
import java.util.List;
@RestController
@RequestMapping("/usuario")
public class UsuarioController {
@Autowired
private UsuarioRepository repository;

@RequestMapping(value = "findAll/", method = RequestMethod.GET)

public List<Usuario> getAllUsuarios() {
return repository.findAll();
}
@RequestMapping(value = "findById/{id}", method = RequestMethod.GET)
public Usuario getUsuarioById(@PathVariable("id") ObjectId id) {
return repository.findBy_id(id);
}

@RequestMapping(value = "/updateOne/{id}", method = RequestMethod.PUT)

public void modifyUsuarioById(@PathVariable("id") ObjectId id, @Valid
@RequestBody Usuario usuario) {
usuario.set_id(id);
repository.save(usuario);
}

@RequestMapping(value = "/insertOne/", method = RequestMethod.POST)

public Usuario createUsuario(@Valid @RequestBody Usuario usuario) {
usuario.set_id(ObjectId.get());
repository.save(usuario);
return usuario;
}

@RequestMapping(value = "deleteOne/{id}", method =

RequestMethod.DELETE)
public void deleteUsuario(@PathVariable ObjectId id) {
repository.delete(repository.findBy_id(id));
}
}

Probando tu API

Ahora que el controlador tiene todos nuestros endpoints, ¡podemos comenzar a probar nuestra
API! Desde la línea de comandos, en la raíz del proyecto, ejecute el comando ‘mvn spring-boot: run’
para compilar el código e iniciar el servidor Spring con el puerto predeterminado 8080.

Una vez que se inicia el servidor, puede probar su API como lo desee.

POST 'http://localhost:8080/usuario/insertOne/'

Con cuerpo: {“correo” : “correo@correo.com”, “contrasenia” : “test123”}

Y header: Content-Type: application/json

Retorna:
{
"_id": "[idGeneradoDelUsuario]",
 "correo": "correo@dominio.com",
"contrasenia": "test123"
}

PUT ‘http://localhost:8080/usuario/updateOne/[idGeneradoDelUsuario]’

Con cuerpo: {"correo" : "correoactualizado@dominio.com", "contrasenia" :

"actualizado"}

Y header: Content-Type : application/json

Retorna: response vacio

GET ‘http://localhost:8080/usuario/findById/[idGeneradoDelUsuario]’

Retorna:
{
"_id": "5c61a88f2ecb0c2bc06c8f90",
"correo": "correoactualizado@dominio.com",
"contrasenia": "actualizado"
}

DELETE ‘http://localhost:8080/usuario/deleteOne/[idGeneradoDelUsuario]’

Retorna: response vacio

GET ‘http://localhost:8080/findAll’

Retorna:
[
{
"_id": "5c5c46974631402a9c278e8e",
"correo": "softcap@gmail.com",
"contrasenia": "softcap"
},
{
"_id": "5c5c4a562ecb0c0688e3fa02",
 "correo": "softcap1234@gmail.com",
"contrasenia": "softcap1234"
},
{
"_id": "5c5c56992ecb0c1a28c33c54",
"correo": "linuxionist@gmail.com",
"contrasenia": "venezuela"
},
{
"_id": "5c61aeca2ecb0c2bc06c8f91",
"correo": "correo@dominio.com",
"contrasenia": "actualizado123"
}
]