Spring Boot: consumiendo un sencillo servicio de Node

En está ocasión haremos un sencillo servicio Spring Boot que consuma otro servicio hecho en Node. 

Para ello necesitaremos:

• Tener instalado el JDK 17 o 21.
• Tener Maven instalado.
• Tener instalado Node.
• Tener un editor de código como VsCode o un IDE como Eclipse.
• Tener conocimiento sobre Java y Spring Boot, además de Node.

¿De qué trata el servicio a consumir?

Consumiremos desde una aplicación Spring Boot un sencillo JSON hecho en un servicio Node como este:

{
 "id": 123,
 "name": "Thomas Muller",
 "message": "Este es un sencillo mensaje"
}

Cremos la aplicación Spring Boot: https://start.spring.io/

La dependencia a usar será (ademas de la de swagger):

<dependency>	
	  <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Creamos la configuración de nuestro proyecto. La cual nos servirá para poder usar RestTemplate, el cual es un cliente síncrono que realiza solicitudes HTTP para consumir servicios web RESTful. Bastante útil para el caso.

WebConfig.java

package com.inforhomex.alquimista.config;


import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;

import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@Configuration
public class WebConfig {
    
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**").allowedOrigins("*").allowedMethods("GET", "POST", "PUT", "DELETE");
    }

    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

}

Esta clase no solo permitirá la configuración de solicitudes HTTP sino que además nos permite usar un bean RestTemplate que servirá para consumir el servicio Node.

Creamos la clase DTO.

ParamDto.java

package com.inforhomex.alquimista.dto;

public class ParamDto {
    private Long id;
    private String name;
    private String message;

    public ParamDto(){

    }

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    @Override
    public String toString() {
        return "{id:"+id+", name:"+name+", message"+message+"}";
    }
}

Esta clase DTO contiene los atributos id, name y message del JSON a consumir.

Creamos el servicio.

ParamDtoService.java

package com.inforhomex.alquimista.services;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import com.inforhomex.CursoSpring.dto.ParamDto;

@Service
public class ParamDtoService{
    @Autowired
    private RestTemplate restTemplate;
    
    public ParamDto getParamaDtoFromNodeService(){
        final String url = "http://localhost:3000/api/paramdto";
        ParamDto paramDTO = restTemplate.getForObject(url, ParamDto.class);
        return paramDTO; 
    }

}

Desde esta clase tipo Service podremos acceder a la URL del servicio Node y obtener el objeto JSON. Es necesario que la clase que reciba el objeto contenga las mismas propiedades id, name y message.

Creamos la clase RestController.

ConsumeApiController.java

package com.inforhomex.alquimista.controller;

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.GetMapping;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.inforhomex.CursoSpring.dto.ParamDto;
import com.inforhomex.CursoSpring.services.ParamDtoService;
import org.springframework.beans.factory.annotation.Autowired;

@RestController
@RequestMapping("/api/consume")
@Tag(name = "RestController de consumir otras APIs.")
public class ConsumeApiController {

    private static final Logger  logger = LoggerFactory.getLogger(ConsumeApiController.class);

    @Autowired 
    private ParamDtoService paramDtoService;

    @GetMapping
     @Operation(summary = "get a ParamDto object from a node service.")
    public ParamDto getParamDTO(){
        logger.info("\t Obtener un objeto desde un servicio Node.");
        return paramDtoService.getParamaDtoFromNodeService();
    }
    
    
}

Esta clase contiene el método HTTP (GET) que podrá obtener el resultado del servicio Node. El cual se podrá ver en la url http://localhost:8083/api/consume una vez que iniciemos el proyecto.

Creamos el proyecto Node.

$ mkdir proyecto-node
$ cd proyecto-node
$ npm init -y

Esto creará la carpeta del proyecto, nos ubicará en ella y creará un proyecto Node.

Instalamos Express.

$ npm install express

Esto nos instalará la dependencia de Express JS.

Creamos la clase módulo paramdto.js

export default class ParamDto{
    constructor(id, name, message){
        this.id = id;
        this.name = name;
        this.message = message;
    }

    static getData(){
        return "{id:"+this.id+",name:"+this.name+",message:"+this.message+"}";
    }
}

Esta es la clase Javascript que contiene los atributos del JSON: id, name y message. Es importante que sea "exportable" y que tenga un método static.

Creamos la aplicación index.js

import express from 'express';
import ParamDto from './paramdto.js'; 

const app = express();
const port = 3000;

app.get('/', (req, res) => {
    res.send('Hola, mundo desde Node JS y Express.');
});

app.get('/api/paramdto', (req, res) => {
    let paramDto = new ParamDto(123, "Thomas Muller", "Este es un simple mensaje");
    res.json(paramDto);
});

app.listen(port, () => {
    console.log(`Escuchando desde el puerto: http://localhost:${port}`);
});

En este archivo Javascript importamos la clase anteriormente creada y la dependencia de Express. Definimos tres métodos para un simple "Hola, mundo", el servicio JSON basado en los atributos de la clase ParamDto de Javascript y un listener donde especificamos el puerto donde escucha la aplicación.

Ajustamos el package.json

{
  "name": "proyecto-node",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "Alquimista de Codigo",
  "license": "ISC",
  "description": "Un sencillo servicio con Node JS",
  "type": "module",
  "dependencies": {
    "express": "^5.1.0"
  }
}

Este archivo JSON nos ayudará a especifircar los atributos de nuestra aplicación Node y que no tengamos problemas a la hora de su ejecución.

Ahora ejecutaremos la aplicación Node.

$ npm start

Abrimos el navegador en la ruta http://localhost:3000/ y nos mostrará un mensaje de Hola, mundo desde Node JS y Express.

Ahora ejecutamos la aplicación de Spring Boot desde una terminal ( también puedes usar Eclipse o VsCode ):

$ mvn spring-boot:run

Si no hay problema alguno, abre el navegador en la ruta: http://localhost:8083/api/consume y verás un JSON como este:

{
"id": 123,
"name": "Thomas Muller",
"message": "Este es un simple mensaje"
}

¡Hemos consumido un servicio Node desde una aplicación Spring Boot con RestTemplate!

Enlaces:

https://alquimistadecodigo.blogspot.com/2025/09/spring-boot-conociendo-las-anotaciones_6.html
https://alquimistadecodigo.blogspot.com/2025/05/node-js-y-clojurescript.html
https://codemonkeyjunior.blogspot.com/2019/01/node-js.html