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/

Eclipse Vert.x

Vert.x es un framework políglota que se ejecuta en la JVM. Permite crear microservicios basados en el paradigma de programación reactiva.

¿Qué es la programación reactiva?

Se trata de un paradigma que se centra en los flujos de datos y la propagación del cambio.

Se enfoca en reaccionar a cambios en el flujo de datos de forma asíncrona y eficiente. En lugar de ejecutar instrucciones de manera secuencial, los sistemas reactivos responden automáticamente cuando ocurre un evento, como una nueva entrada de datos o una actualización en tiempo real,

Es como suscribirse a un canal de noticias: no sabes cuándo llegarán nuevos artículos, pero cuando lo hagan, recibirás una notificación instantánea. Aborda las ineficiencias de los mecanismos de sondeo tradicionales, que buscan constantemente actualizaciones, incluso cuando no las hay. Esto puede generar un desperdicio de recursos y tráfico de red innecesario.

Al suscribirse a un flujo de datos, la programación reactiva garantiza que su código solo reciba notificaciones cuando haya nuevos datos disponibles, lo que mejora significativamente el rendimiento y la utilización de recursos.

Vert.x es similar a Node JS y se centra en los microservicios.

Es como una caja de herramientas mágica para construir aplicaciones que reaccionan rápido, como cuando juegas y el videojuego responde al instante cuando presionas un botón.

Además podremos usar estos lenguajes (ya que no es exclusivo para Java):

• Java, obviamente. 
• Kotlin. 
• Javascript. 
• Python. 
• Groovy. 
• Ruby. 
• Scala. 
• Clojure. 
• Y mezclar varios en una sola aplicación.

Veamos un ejemplo en Kotlin:

class Server : VerticleBase() {
  override fun start(): Future<*> {
    return vertx.createHttpServer()
      .requestHandler { req ->
        req.response()
          .putHeader("content-type", "text/plain")
          .end("¡Hola, mundo desde Vert.x!")
      }
      .listen(8080)
  }
}

Y en Java:

public class Server extends VerticleBase {
  public Future<?> start() {
    return vertx.createHttpServer()
      .requestHandler(req ->
        req.response()
          .putHeader("content-type", "text/plain")
          .end("¡Hola, mundo desde Vert.x!")
      )
      .listen(8080);
  }
}

Trabajando con Vert.x

Para trabajar con esta herramienta necesitamos:

• JDK en su versión 11 o más actual. 
• Maven 3. 
• Contar con la herramienta curl, HTTPie o cualquier herramienta que permita solicitudes HTTP.

La dependencia que usaremos será: vertx-web

Al generar el proyecto debemos descomprimirlo en algún directorio. La clase principal es:

MainVerticle.java

package com.inforhomex.aprendevertx.holamundo;

import io.vertx.core.Future;
import io.vertx.core.VerticleBase;

public class MainVerticle extends VerticleBase {

  @Override
  public Future<?> start() {
    return vertx.createHttpServer().requestHandler(req -> {
      req.response()
        .putHeader("content-type", "text/plain")
        .end("Hola, mundo desde Vert.x!");
    }).listen(8888).onSuccess(http -> {
      System.out.println("El servidor escucha desde el puerto 8888");
    });
  }
}

Construimos el proyecto con Maven:

$ mvn clean package

Entramos al directorio ``target`` y ejecutamos la aplicación:

$ java -jar holamundo-1.0.0-SNAPSHOT-fat.jar 

Abrimos el navegador en la url de hhtp://localhost:8888/

Salida:

Hola, mundo desde Vert.x! 

¡Hemos creado nuestro primera aplicación con Vert.x!

Concluyendo, al usar Vert.x se espera construir aplicaciones que reaccionan a los cambios, manteniendo tiempos de respuesta rápidos, alta escalabilidad y resiliencia.

Enlaces:

https://vertx.io/
https://www.arquitecturajava.com/introduccion-a-vertx/
https://solutionsarchitecture.medium.com/reactive-programming-in-java-a-simplified-guide-dd24d7f440d4
https://www.reddit.com/r/java/comments/nlzpkq/why_vertx_javas_library_for_reactiveasync/?tl=es-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

Instalar Angular Cli

 

He aquí los pasos para configurar Node e instalar Angular Cli.

1. Abrir Chrome, dar F12 para abrir consola.

2. En la consola escribir:

btoa('ID:PASSWD');

3. Copiar la cadena resultante (sin comillas).

4. Abrir una terminal (CMD, etc.) e ingresar los siguientes comandos:

npm config set progress true
npm config set registry http://url_nexus
npm config set strict-ssl false
npm config set always-auth true
npm config set _auth CADENA_RESULTANTE

5. Teclear el siguiente comando para instalar Angular Cli.

npm install -g @angular/cli

Nota: en caso de no tener chrome usar el servicio de https://www.base64encode.net/javascript-btoa

What is AngularJS ? ... What do you eat this with?

AngularJS es un framework pensado para crear aplicaciones SPA (aplicaciones de una sola página).  Se puede combinar con NodeJS, MongoDB y Express JS. Formando así el MEAN (MongoDB + Express JS + Angular + Node JS).

 ¿Por qué usarlo?

• Es bueno usarlo en desarrollos web dinámicos pues ofrece herramientas para el acceso a los datos y no sólo de manipulación del DOM de la página.
• Emplea el Modelo Vista Vista-Modelo.
• Mejora el rendimiento y las pruebas.
• ¿Necesito saber DOM, Javascript, jQuery? Mejor enfócate  en el rendimiento de la aplicación.
• Etc.

¿En serio no necesito saber Javascript y/o jQuery?

Sí, debes tener bases de Javascript y no, no es necesario saber jQuery. AngularJS se enfoca más en el rendimiento y las pruebas y no se preocupa mucho por la manipulación del DOM.

¿Cómo trabaja AngularJS?

AngularJS permite ampliar el vocabulario HTML, pues el HTML puro es insuficiente para ofrecer contenido dinámico.

Modelo + Plantilla   ------- { AngularJS } -----  HTML

Algunos conceptos de AngularJS. 

Directiva: son atributos que se agregan a los elementos HTML, por lo regular comienzan con ng-.
Módulo: podemos verlo como un paquete en java.
Controlador: es el nombre de una función que se ejecuta cuando se carga el código html que tiene la directiva ng-controller.
$scope: es la variable de AngularJS donde se guarda toda la información de Javascript de la página.
Angular sólo muestra en el HTML mediante {{ }} el valor de las variables definidas en $scope, no de todas las variables.
$rootScope: es el scope del que heredan los demás scopes, una variable o función agregada a él es accesible por todos los controladores.

Directivas. 
ng-model: asocia el valor de una variable con el elemento HTML.
ng-show: permite que un elemento de la página se haga visible.
ng-repeat: hace un ciclo sobre un objeto.
ng-bind: enlaza un valor del scope con un elemento html sin necesidad de {{ }}

Módulos. 
Un módulo como un paquete en Java, aquí se agregarán artefactos que podemos usar en otros lados.

Los Artefactos que pueden ir dentro de un módulo son:

• Controladores. 
• Directivas. 
• Filtros. 
• Constantes. 
• Config. 
• Run. 
• Etc. 

Un módulo puede depender de otros, para eso se usan los corchetes [].

Servicio $http.
Un servicio no tiene relación directa con la página, más bien, es un objeto Javascript que nos permite obtener información. El servicio $http nos permite hacer peticiones AJAX a un servidor. Ejemplo, ocuparlo para hacer peticiones Webservices enviándole algunos parámetros y obteniendo los datos solicitados. Un Webservice podría hacer la función de controlador (hablando en términos de Java).

Servicio $routeProvider.
El servicio tiene dos métodos:

1. when: Asocia una ruta con una página HTML. 
2. otherwise: Indica a qué ruta debemos redirigirnos cuando hay una ruta desconocida. 

El código de la página se agregará dónde coloquemos el siguiente elemento. El servicio $location ayuda a definir el path al que queremos ir. Para que funcione, se debe agregar a nuestro módulo el módulo ng-route con su respectivo archivo js.

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/