Node JS

 

Node es considerado un entorno de ejecución de JavaScript orientado a eventos asíncronos (más información en https://nodejs.org/es/about/). 

Creamos un archivo *.js

test.js

const http = require('http');

const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/html');
  res.end('<h1>Hola Node JS</h1>');
});

server.listen(port, hostname, () => {
  console.log(`El servidor se está ejecutando en http://${hostname}:${port}/`);
});

Ejecutamos:

$ node test.js

Abrimos el navegador en http://localhost:3000

Ahora crearemos un módulo.

1. Creamos una carpeta llamada testNodeJS
2. Tecleamos npm init
3. Tecleamos npm install

Si todo va bien, debe haber un archivo llamado package.json. 

{
  "name": "app-node",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

Por defecto tendremos un index.js Ahora sustituimos su contenido por esto:

const http = require('http');
const hostname = '127.0.0.1';
const port = 8088;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/html');
  res.write('<h1>Node JS</h1><br/>');
  res.end();
});

server.listen(port, hostname, () => {
  console.log(`Servidor corriendo en http://${hostname}:${port}/`);
});

Ejecutamos:

$ node index.js

Abrimos el navegador en http://localhost:8088/

Veremos el mensaje Node JS

Ahora crearemos un módulo

listaString.js

exports.listaString=["Java","Kotlin","Scala","Groovy","Ceylon"];

Ahora modificaremos el archivo index.js, importamos el módulo de la siguiente manera:

var identificador = require('nombre_modulo')

index.js

//importamos nuestro módulo listaString.js
var listaStr = require('./app/listaString.js');


const http = require('http');
const hostname = '127.0.0.1';
const port = 8088;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/html');
  res.write('<h1>Node JS</h1><br/>');
  res.write("<ul>");
  for(elemento in listaStr.listaString){
   res.write("<li>"+listaStr.listaString[elemento]+"</li>");
  }
  res.write("</ul>");
  res.end();
});

server.listen(port, hostname, () => {
  console.log(`Servidor corriendo en http://${hostname}:${port}/`);
});

Es preciso notar esto:

res.write("<ul>");
  for(elemento in listaStr.listaString){
   res.write("<li>"+listaStr.listaString[elemento]+"</li>");
  }
  res.write("</ul>");

Así la lista se verá en nuestro index.js

Links:

https://linuxize.com/post/how-to-install-node-js-on-ubuntu-18.04/

https://codemonkeyjunior.blogspot.com/2016/11/un-vistazo-nodejs.html 

https://nodejs.org/es/

Node en ejemplos: importando paquetes

 

Node JS es una plataforma que nos permite correr aplicaciones Javascript del lado del servidor.  En post pasados hemos visto su instalación y algunos ejemplos. 

Instalación en distribuciones Ubuntu.

$ curl -fsSL https://deb.nodesource.com/setup_14.x | sudo -E bash -
$ sudo apt-get install -y nodejs

Comprobamos su instalación:

$ npm -v
$ node -v

Paquetes en Node JS.

Un paquete son archivos JS empaquetados. Es una parte fundamental en la reutlización de código.

Node JS nos permite importar paquetes para realizar ciertas funciones especiales, así como importar nuestros propios paquetes.

Ejemplo. Importar el paquete 'path' de Node Js. Para ello necesitamos tener un archivo texto.txt.

const path = require('path');
const print = console.log;

print("Archivo:");
print(path.parse("/home/codemonkey/Documentos/pruebasNodeJS/texto.txt"));

La salida:

Archivo:
{
  root: '/',
  dir: '/home/codemonkey/Documentos/pruebasNodeJS',
  base: 'texto.txt',
  ext: '.txt',
  name: 'texto'
}

Ejemplo. Crear un paquete llamado suma e importarlo en otro archivo denominado test_suma.js.
suma.js

exports.sumar = (x,y) => x+y;

test_suma.js

// Importamos suma.js
const operacion = require('./suma');
var x = 4, y = 3;
console.log(`Suma de ${x} + ${y} es: ${operacion.sumar(x,y)}`);

// Creamos una clase
class Operacion{
   getOperacion(x,y){
      const operacion = require('./suma.js');
      return operacion.sumar(x,y);
   }
}

x = 7;
y = 8;
let my_operacion = new Operacion().getOperacion(x,y);
console.log(`Suma de ${x} + ${y} es: ${my_operacion}`);

Ejecutamos:

$ node test_suma.js

Resultado:

Suma de 4 + 3 es: 7
Suma de 7 + 8 es: 15

Nota:  Cuando es un paquete de Node JS no es necesario poner el punto y diagonal. Solo cuando es un paquete hecho por nosotros. También se puede omitir la extensión *.js en paquetes propios como se puede ver:

// Importo paquete de Node JS
const path = require("path");

// Importo mi paquete 
const path = require("./saludo");

Y un ejemplo más...

const path = require('path');
const print = console.log;

print("Archivo:");
print(path.parse("/home/codemonkey/Documentos/pruebasNodeJS/texto.txt"));


const saludo = require('./saludo');
saludo.saludo();
saludo.despedida();

const opera = require('./suma');
let x = 87.5;
let y = 45.8;
console.log(`Numeros >> x = ${x}, y = ${y} `);
console.log("Suma: ",opera.sumar(x,y));

const os = require('os');
console.log("Info del sistema:");
console.log("Arquitectura:",os.arch());
console.log("Hostname:",os.hostname());

Enlaces:
https://codemonkeyjunior.blogspot.com/search?q=node
https://nodejs.org

Programando en C# no. 11 (consumiendo una API)

En está ocasión veremos cómo consumir una API desde una aplicación hecha con C#.

Se tratará de una aplicación sencilla y sin usar un framework web.

Tendremos una aplicación Cliente y otra Servidor.

En este caso el cliente lo haremos con C# y la aplicación servidor con Node JS.

Comencemos.

1. Creamos una aplicación C# con dotnet.

$ mkdir proyecto-api
$ cd proyecto-api
$ dotnet new webapi

2. Modificamos el programa principal:

Program.cs

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web;

class Program
{
    static async Task Main(string[] args)
    {
        using (var client = new HttpClient())
        {
            var query = System.Web.HttpUtility.ParseQueryString(string.Empty);
            query["id"] = "1234";
            var uriBuilder = new UriBuilder("http://localhost:3000/api/saludo");
            uriBuilder.Query = query.ToString();
            var request = new HttpRequestMessage
            {
                Method = HttpMethod.Get,
                RequestUri = uriBuilder.Uri
            };
            request.Headers.Add("application-name", "Aplicacion .NET");
            var response = await client.SendAsync(request);
            var responseBody = await response.Content.ReadAsStringAsync();
            Console.WriteLine(responseBody);
        }
    }
}

Este será nuestro programa cliente que accederá a un servicio de Node Js. Le mandaremos un id y el nombre de la aplicación (este en los encabezados). Colocaremos la URL del servicio y el método HTTP a usar, en este caso será el método GET, pues queremos obtener un resultado.

Ahora el servicio con Node JS.

1. Creamos el proyecto:

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

Esto nos generará un package.json. Lo editaremos más adelante. Ahora es necesario instalar Express JS en caso de no tenerlo.

$ npm install express

2. Creamos un archivo JS que será nuestro programa servidor.

index.js

import express from 'express';


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

// Parsear JSON
app.use(express.json());

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



app.get('/api/saludo', (req, res) => {
  const id = req.query.id || 'desconocido';
  const appName = req.headers['application-name'] || 'sin nombre';

  res.json({
    mensaje: `¡Hola! Recibí tu ID: ${id}`,
    origen: `Aplicación: ${appName}`
  });
});



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

Nuestro servicio estará expuesto en la URL: http://localhost:3000/saludo

3. Editamos el archivo ``package.json``

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

Ahora podremos ejecutar el proyecto Node JS con este comando:

$ npm start

Y ejecutamos el cliente:

$ dotnet build
$ dotnet run

Si todo va bien veremos esto en la consola:

{"mensaje":"¡Hola! Recibí tu ID: 1234","origen":"Aplicación: Aplicacion .NET"}

Con esto hemos creado nuestra aplicación que consume una sencilla API de Node JS.

Enlaces:

https://alquimistadecodigo.blogspot.com/2025/09/node-consumiendo-una-api-publica.html

Un vistazo a Node.js

Node.js es un entorno de ejecución para aplicaciones hechas con Javascript. Posee un ecosistema de paquetes (npm) que nos provee una manera más fácil para el desarrollo de nuestras aplicaciones.

Existen diversas maneras de instalar Node.js. Una de ellas es mediante nvm.

Para ello podemos teclear la siguiente orden en la terminal de comandos (si usas Linux, debo aclarar):

curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.32.1/install.sh | bash

Para que surja efecto hay que teclear:

source ~/.bashrc

Listo, tenemos instalado nvm:

nvm --version

Para instalar node tecleamos: 

nvm install node

Para instalar el gestor de paquetes npm:

nvm install npm

Comprobamos su instalación:

node -v

npm -v 

Ahora a crear el primer ejemplo.
1. Creamos un archivo llamado hola.js
2. Ejecutamos el script mediante node


hola.js
console.log("Hola, Codemonkeys");


En terminal tecleamos:

node hola.js

Ya tenemos nuestro primer ejemplo en Node.js

Links
https://github.com/creationix/nvm
https://nodejs.org/es/

WebSockets: un canal permanente para enviar y recibir datos

Los WebSockets son un protocolo que permite comunicación bidireccional en tiempo real entre cliente y servidor, a diferencia de HTTP que funciona en modo solicitud-respuesta.

Es como un canal permanente, donde ambos lados (cliente y servidor) pueden enviar datos en cualquier momento.

Son útiles en cualquier escenario donde se requiera interacción instantánea:

• Chats y mensajería: WhatsApp Web, Slack, Discord. 
• Juegos online: sincronización de movimientos en tiempo real. 
• Colaboración en documentos: Google Docs, Notion, donde ves cambios de otros usuarios al instante.
• Notificaciones en vivo: alertas de bolsa, actualizaciones deportivas, sistemas de monitoreo. 
• Aplicaciones financieras: transmisión de precios de criptomonedas o acciones en tiempo real. 
• IoT y dashboards: dispositivos que envían datos continuamente a una interfaz web .

Entre las ventajas principales encontramos:

• Baja latencia: no hay que abrir y cerrar conexiones constantemente. 
• Menor consumo de recursos: menos overhead que múltiples peticiones HTTP. 
• Escalabilidad: ideal para aplicaciones con miles de usuarios conectados simultáneamente.  
• Flexibilidad: permite enviar datos en ambos sentidos (cliente ↔ servidor).

Entre los riesgos y consideraciones a tomar tenemos:

• Seguridad: al ser persistentes, requieren cifrado (wss://) para evitar ataques de interceptación. 
• Escalabilidad: manejar miles de conexiones simultáneas exige servidores optimizados. 
• Compatibilidad: aunque ampliamente soportados, algunos entornos antiguos pueden no tener soporte completo.

WebSockets

Iniciemos pues con los WebSockets. Haremos un sencillo ejemplo. Para ello necesitamos:

• Tener Node instalado en nuestras máquinas. 
• Tener conocimiento de Javascript y Node. 
• Instalar Express y Socket.IO

¿Qué haremos? Una aplicación que nos muestre un ejemplo del uso de WebSockets, con ayuda de JS y Node.

1. Crearemos un directorio y nos ubicaremos en el:

$ mkdir websocket-demo
$ cd websocket-demo

2. Una vez dentro del directorio, crearemos un proyecto Node:

$ npm init -y

Esto nos generará el proyecto Node.

3. Instalar las dependencias (Express y Socket.IO) con ayuda de la herramienta ``npm``:

$ npm install express socket.io

Podemos validar la descarga con este comando:

$ npm list

Salida:

+-- express@5.2.1
`-- socket.io@4.8.3

4. Creando un servidor que escuche ``server.js``:

const express = require('express');
const http = require('http');
const { Server } = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = new Server(server);

app.use(express.static('public'));

io.on('connection', (socket) => {
  console.log('Un usuario se conectó');

  socket.on('chat message', (msg) => {
    console.log('Mensaje recibido: ' + msg);
    io.emit('chat message', msg);
  });

  socket.on('disconnect', () => {
    console.log('Un usuario se desconectó');
  });
});

server.listen(3000, () => {
  console.log('Servidor escuchando en http://localhost:3000');
});

5. Crearemos un cliente para hacer petciones al servidor:

public\index.html

<!DOCTYPE html>
<html>
<head>
  <title>Chat con Socket.IO</title>
</head>
<body>
  <h1>Chat sencillo</h1>
  <ul id="mensajes"></ul>
  <form id="form">
    <input id="input" autocomplete="off" /><button>Enviar</button>
  </form>
  <script src="/socket.io/socket.io.js"></script>
  <script>
    const socket = io();

    const form = document.getElementById('form');
    const input = document.getElementById('input');
    const messages = document.getElementById('mensajes');

    form.addEventListener('submit', (e) => {
      e.preventDefault();
      if (input.value) {
        socket.emit('chat message', input.value);
        input.value = '';
      }
    });

    socket.on('chat message', (msg) => {
      const item = document.createElement('li');
      item.textContent = msg;
      messages.appendChild(item);
    });
  </script>
</body>
</html>

6. Ejecutamos la aplicación:

$ node server.js

Si todo va bien veremos este mensaje:

Servidor escuchando en http://localhost:3000

Abrimos un navegador en la ruta: http://localhost:3000/

Veremos lo siguiente:

Mandamos un mensaje y obtendremos una respuesta:

¡Hemos creado nuestra primera aplicación con WebSockets!

Continuaremos con estos temas en próximas entregas.

Enlaces:

https://en.wikipedia.org/wiki/WebSocket
https://socket.io/
https://expressjs.com/

Programando en Java no. 10: Consumir una API con la librería OkHttp

En el post anterior vimos como consumir una API desde C#. Ahora lo haremos con Java y OkHttp, un cliente HTTP que es muy eficiente y que ofrece:

• La compatibilidad con HTTP/2 permite que todas las solicitudes al mismo host compartan un socket. 
• La agrupación de conexiones reduce la latencia de las solicitudes (si HTTP/2 no está disponible). GZIP transparente reduce el tamaño de las descargas. 
• El almacenamiento en caché de respuestas evita por completo que la red reciba solicitudes repetidas.

Además de seguir especificaciones HTTP modernas como:

• Semántica HTTP - RFC 9110.
• Almacenamiento en caché HTTP - RFC 9111 
• HTTP/1.1 - RFC 9112 
• HTTP/2 - RFC 9113 
• WebSockets - RFC 6455
• SSE - Eventos enviados por el servidor.

1. Comencemos creando el proyecto con Maven:

$ mvn archetype:generate \
        -DgroupId=com.inforhomex.app \
        -DartifactId=proyecto \
        -DarchetypeArtifactId=maven-archetype-quickstart \
        -DarchetypeVersion=1.4 \
        -DinteractiveMode=false

Nos posicionamos en el directorio creado y modificamos la clase principal.

App.java

package com.inforhomex.app;

import okhttp3.*;
import java.io.IOException;
import static java.lang.System.out;
import static java.lang.System.err;

/**
 * @author Codemonkey Junior
 */
public class App {

    public static final String URL_STRING = "http://localhost:3000/api/saludo";
    public static void main(String[] args) {
        out.println("\t [ Consumiendo una API con okhttp ]");
        hacerPeticionEnApi(args);
    }

    private static void hacerPeticionEnApi(String... args){
        OkHttpClient client = new OkHttpClient();
        HttpUrl.Builder urlBuilder = HttpUrl.parse(URL_STRING).newBuilder();
        urlBuilder.addQueryParameter("id", "765421");
        final String finalUrl = urlBuilder.build().toString();
        Request.Builder requestBuilder = new Request.Builder()
        .url(finalUrl).method("GET", null)
        .addHeader("application-name", "application-java");
        Request request = requestBuilder.build();
        try(Response response = client.newCall(request).execute()){
            out.println(response.code());
            if(response.body() != null){
                out.println(response.body().string());
            }else{
                out.println("La respuesta es: null");
            }
        }catch(IOException ioex){
            err.printf("Excepcion: %s\n", ioex.getMessage());
        }

    }

}

En esta clase creamos un cliente gracias a la librería okhttp3 y en específico a la clase ``OkHttpClient``. Indicamos la URL del servicio (hecho en Node JS). Indicamos el valor a mandar (id) y el nombre de la aplicación en las cabeceras (header).

Compilamos la aplicación:

$ mvn clean compile

Reusaremos el servicio creado en el post anterior.

index.js

import express from 'express';


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

// Parsear JSON
app.use(express.json());

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



app.get('/api/saludo', (req, res) => {
  const id = req.query.id || 'desconocido';
  const appName = req.headers['application-name'] || 'sin nombre';

  res.json({
    mensaje: `¡Hola! Recibí tu ID: ${id}`,
    origen: `Aplicación: ${appName}`
  });
});



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

Ejecutamos el proyecto node e iniciará el servicio en la url: http://localhost:3000

$ npm start

Ejecutamos la aplicación Java con Maven, pero antes debemos hacer unos ajustes al ``pom.xml``

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.inforhomex.app</groupId>
  <artifactId>proyecto-okhtpp</artifactId>
  <version>1.0</version>

  <name>proyecto-okhtpp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.release>17</maven.compiler.release>
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.junit</groupId>
        <artifactId>junit-bom</artifactId>
        <version>5.11.0</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>

      <dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>okhttp-bom</artifactId>
        <version>5.2.0</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>

    </dependencies>
  </dependencyManagement>

  <dependencies>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <scope>test</scope>
    </dependency>
    <!-- Optionally: parameterized tests support -->
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-params</artifactId>
      <scope>test</scope>
    </dependency>

    <!-- https://mvnrepository.com/artifact/com.squareup.okhttp/okhttp -->
    <dependency>
      <groupId>com.squareup.okhttp3</groupId>
      <artifactId>okhttp-jvm</artifactId>
      <version>5.1.0</version>
    </dependency>

    <dependency>
      <groupId>com.squareup.okhttp3</groupId>
      <artifactId>mockwebserver3</artifactId>
    </dependency>

    <dependency>
      <groupId>com.squareup.okhttp3</groupId>
      <artifactId>logging-interceptor</artifactId>
    </dependency>
  </dependencies>

  <build>
    <pluginManagement>
      <plugins>

        <plugin>
          <groupId>org.codehaus.mojo</groupId>
          <artifactId>exec-maven-plugin</artifactId>
          <version>1.4.0</version>
          <configuration>
            <mainClass>com.inforhomex.app.App</mainClass>
          </configuration>
        </plugin>


        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.4.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.3.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.13.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>3.3.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.4.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>3.1.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>3.1.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.12.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.6.1</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

Esto nos permitirá agregar las librerías y ejecutar la aplicación con Maven:

$ mvn exec:java

Si todo es correcto, veremos en consola el resultado:

         [ Consumiendo una API con okhttp ]
200
{"mensaje":"¡Hola! Recibí tu ID: 765421","origen":"Aplicación: application-java"}

¡Hemos consumido un servicio Node JS con Java y la librería okhttp!

Más ejemplos en próximas entregas.

Enlaces:

https://square.github.io/okhttp/