Uso de APIs en Java

Uso de APIs en Java

¿Qué es una API?

El término API es una abreviatura de Application Programming Interfaces, que en español significa interfaz de programación de aplicaciones. Se trata de un conjunto de definiciones y protocolos que se utiliza para desarrollar e integrar el software de las aplicaciones, permitiendo la comunicación entre dos aplicaciones de software a través de un conjunto de reglas. El uso de Apis en java u otros lenguajes de programación, está siendo muy demandado hoy en día.

Así pues, podemos hablar de una API como una especificación formal que establece cómo un módulo de un software se comunica o interactúa con otro para cumplir una o muchas funciones. Todo dependiendo de las aplicaciones que las vayan a utilizar, y de los permisos que les dé el propietario de la API a los desarrolladores de terceros.

Algunos ejemplos de APIS:

• Aplicación del tiempo

Nuestros dispositivos, siempre nos muestran el tiempo que hace en nuestra ciudad, esta información la reciben de un api.

La aplicación de tiempo, hará una request al api, buscando la temperatura de la ciudad que escribamos:

• Inicio de sesión XYZ

La forma en que funciona es bastante simple. Cada vez que se carga la aplicación, utiliza la API para verificar si el usuario ya inició sesión a través de cualquier plataforma de redes sociales.

• Pagos con PayPal

Igual que con el inicio de sesión, para realizar pagos la mayoría de tiendas de comercios electrónicos, utilizan estas apis para garantizar que la aplicación final solo pueda hacer lo que necesita, sin estar expuesta a datos confidenciales ni tener acceso a permisos no deseados.

Uso de APIs con Java

En este artículo vamos a aprender a recoger datos de un api en Java y utilizarnos en nuestras aplicaciones.

En primer lugar, una API debe tener una URL de host (o URL base), que es la dirección principal con la que interactuará.

Además, las API tienen un conjunto predefinido de puntos finales: direcciones únicas dentro de la URL del host, responsables de su funcionalidad. Además, las API deben tener documentación que explique todos los puntos finales, tipos de valores devueltos, etc.

Después de encontrar una API interesante y leer la documentación, debe enviar una solicitud: una sola tarea para el servidor (lado receptor). Metafóricamente, es como una conversación entre dos personas: alguien (usted) hace una pregunta (request) y el interlocutor (punto final) responde (response).

Tipos de requests de API

 

Hay muchos tipos diferentes de requests que la API podría manejar, pero estas son las más utilizadas:

GET: devuelve datos del servidor. Por cierto, la solicitud más popular.

POST: agrega nuevos datos en el servidor. A menudo, este tipo se usa para registrar o cargar archivos.

PUT/PATCH: actualiza datos, solicitud útil pero no tan solicitada.

ELIMINAR: elimina datos del servidor.

Nosotros nos enfocaremos en el GET para obtener datos para nuestras aplicaciones.

El api que escogeré para este artículo es el siguiente: https://pokeapi.co/

En esta pagina podemos hacer la request del Pokémon que queramos, dándonos así, toda su información.

El URL host, tal y como pone en la página web es la siguiente: https://pokeapi.co/api/v2/, añadiremos el Pokémon que deseamos consultar al final: https://pokeapi.co/api/v2/pikachu

Para hacer el get request de esta url debemos importar las librerías URL y HttpURLConnection y escribir el código dentro de un try catch block, ya que la conexión puede fallar.

import java.net.HttpURLConnection;

import java.net.URL;

Crearemos un objeto URL con el enlace a la API. También. podemos crear una variable String pokemon que se sumará a la URL para darnos la información.

try {
    String pokemon="pikachu";
    URL url=new URL("https://pokeapi.co/api/v2/pokemon/"+ pokemon);
} catch (Exception e) {
    e.printStackTrace();
}

 

A continuación generaremos un objeto “HttpURLConnection para hacer la conexión a la api, mediante el método de la URL openConnection().

try {
    String pokemon="pikachu";
    URL url=new URL("https://pokeapi.co/api/v2/pokemon/"+ pokemon);
    HttpURLConnection con=(HttpURLConnection)url.openConnection(); 
} catch (Exception e) {
    e.printStackTrace();
}

Una vez creado el objeto connection, vamos a llamar a la request GET. Cuando hacemos una request (solicitud), normalmente recibimos un código de respuesta (responseCode). El código de respuesta, por ejemplo: 200, significa que el GET request ha sido satisfactorio y el servidor devolverá los contenidos del documento solicitado. Otro ejemplo es 404 Not Found, el servidor no ha encontrado el resource solicitado.

try {
    String pokemon="pikachu";
    URL url=new URL("https://pokeapi.co/api/v2/pokemon/"+ pokemon);
    HttpURLConnection con=(HttpURLConnection)url.openConnection(); 
    con.setRequestMethod("GET");
    int responsecode=con.getResponseCode();
} catch (Exception e) {
    e.printStackTrace();
}

 

Una vez tenemos el código de respuesta, comprobamos si es 200, para continuar.

Generaremos un StringBuilder, este objeto mantiene un búfer para dar cabida a las expansiones a la cadena. Si hay espacio disponible, se anexan nuevos datos al búfer.

Si todo funcionar perfectamente necesitaremos un bucle while para añadir toda la información que estamos recibiendo de la url, añadiéndola al StringBuilder con la ayuda de un Scanner.

El método openStream() de la url, inicia una nueva conexión con el servidor en el que se resuelve la URL. A continuación, se envía una solicitud HTTP GET a través de la conexión. Si todo va bien (es decir, 200 que ya hemos comprobado con anterioridad), el servidor devuelve el mensaje de respuesta HTTP que lleva los datos.

try {
    String pokemon="pikachu";
    URL url=new URL("https://pokeapi.co/api/v2/pokemon/"+ pokemon);
    HttpURLConnection con=(HttpURLConnection)url.openConnection(); 
    con.setRequestMethod("GET");
    int responsecode=con.getResponseCode();
    if(responsecode!=200) {
        System.out.println("Error"+ responsecode);
    }
    else{
        StringBuilder informationstring= new StringBuilder();
        Scanner sc=new Scanner(url.openStream());
        while(sc.hasNext()){
            informationstring.append(sc.nextLine());
        }
        sc.close();
    }
} catch (Exception e) {
    e.printStackTrace();
}

 

El siguiente paso, consiste en transformar este StringBuilder (texto con muchísimos datos) para poder acceder a la información específica del Pokémon.

JSON es un formato de texto sencillo para el intercambio de datos. Se trata de un subconjunto de la notación literal de objetos de JavaScript, aunque, debido a su amplia adopción como alternativa a XML, se considera un formato independiente del lenguaje.

Necesitaremos añadir la librería de JSON para intercambiar los datos de nuestro StringBuilder.

https://jar-download.com/artifacts/org.json

Hay que descargar la librería y añadirla al proyecto. Lo importaremos al archivo de esta forma:

import org.json.JSONObject;

Normalmente las estructuras de los JSON son parecidas a los diccionarios (HashMap), con keys y values:

Para transformar el StringBuilder a JSONObject haremos uso de la librería:

JSONObject dataObject=new JSONObject (String.valueOf(informationstring));

Para buscar la información que nos interesa debemos ir a la documentación del api. También podemos utilizar el método names(), que nos devuelve el nombre de las JSONArrays que hay.

System.out.println(dataObject.names());

["location_area_encounters","types","base_experience","held_items","weight","is_default","past_types","sprites","abilities","game_indices","species","stats","moves","name","id","forms","height","order"]

Si queremos seleccionar los types, usaremos getJSONArray(“types”):

System.out.println(dataObject.getJSONArray("types"));

[{"slot":1,"type":{"name":"electric","url":"https://pokeapi.co/api/v2/type/13/"}}]

Este array nos devuelve 1 solo objeto, que contiene distintos elementos, como slot, type… queremos sacar el tipo del Pokémon. Cogemos el único elemento del array.

System.out.println(dataObject.getJSONArray("types").getJSONObject(0));

{"slot":1,"type":{"name":"electric","url":"https://pokeapi.co/api/v2/type/13/"}}

System.out.println(dataObject.getJSONArray("types").getJSONObject(0).getJSONObject("type"));

{"name":"electric","url":"https://pokeapi.co/api/v2/type/13/"}

Vamos entrado dentro de los elementos hasta llegar al tipo.

System.out.println(dataObject.getJSONArray("types").getJSONObject(0).getJSONObject("type").getString("name"));

Electric

Finalmente hemos llegado al tipo del Pokémon, es importante saber moverse entre objetos JSON para escoger la información que necesitemos.

Pensad en todas las oportunidades y el uso de las que nos dan las Apis en Java para hacer nuestras aplicaciones.

¡Espero que os haya servido el artículo!

Código final:

try {
    String pokemon="pikachu";
    URL url=new URL("https://pokeapi.co/api/v2/pokemon/"+ pokemon);
    HttpURLConnection con=(HttpURLConnection)url.openConnection(); 
    con.setRequestMethod("GET");
    int responsecode=con.getResponseCode();
    if(responsecode!=200) {
        System.out.println("Error"+ responsecode);
    }
    else {
        StringBuilder informationstring= new StringBuilder();
        Scanner sc=new Scanner(url.openStream());
        while(sc.hasNext()) {
            informationstring.append(sc.nextLine());
        }
        sc.close();
        JSONObject dataObject=new JSONObject(String.valueOf(informationstring));
        System.out.println(dataObject.getJSONArray("types").getJSONObject(0).getJSONObject("type").getString("name"));
    }
} catch (Exception e) {
    e.printStackTrace();
}