Llamar un API con Netbeans 11 y Java 12
Vamos a
usar la librería HttpClient de Java para poder hacer llamados a Rest APIs, con
esta librería podemos desarrollar un cliente de Rest muy fácil. Podemos
encontrar el Api aquí http://dummy.restapiexample.com/
En este
caso utilizaremos una aplicación de console app de Java 12 desde donde vamos a
consumir el servicio de APIs con datos genéricos.
Cuando tenemos
listo el proyecto vamos a crear dos clases que nos permitirán interactuar fácilmente
con los objetos json del API. Primero creamos la clase EmployeesPojo y luego la
clase EmployeePojo.
La clase
EmployeesPojo nos permite mapear los datos que retorna el servidor en objetos
de Java para poder manipularlos fácilmente.
public class EmployeesPoco {
private String id;
private String employee_name;
private String employee_age;
private String profile_image;
La clase
EmployeePojo la utilizaremos para agregar nuevos objetos en el servidor.
public class EmployeePojo {
private String name;
private String salary;
private String age;
Antes de
continuar requerimos descargar un Jar para convertir los resultados de json a
objetos de Java de una manera muy simple. En este ejemplo vamos a utilizar la librería
Gson de Google, está la pueden encontrar en Maven o pueden agregar el Jar al
proyecto.
Repositorio
de Gson: https://github.com/google/gson
Lo primero
que debemos hacer es agregar las siguientes referencias en la clase donde queremos
usar el HttpClient
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.util.List;
En el caso
de este ejemplo lo estamos haciendo en la clase Main.
public static void main(String[] args) {
var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder().uri(URI.create("http://dummy.restapiexample.com/api/v1/employees")).header("Content-Type", "application/json").build();
client.sendAsync(request, BodyHandlers.ofString())
.thenApply(HttpResponse::body)
.thenAccept(response -> {
List<EmployeesPoco> employees = new Gson().fromJson(response, new TypeToken<List<EmployeesPoco>>() {
}.getType());
employees.forEach((employee) -> {
System.out.println("Name: " + employee.getEmployee_name());
});
}).join();
var newEmployee = new EmployeePojo("Java Test", "1000", "30");
var json = new Gson().toJson(newEmployee);
request = HttpRequest.newBuilder().uri(URI.create("http://dummy.restapiexample.com/api/v1/create")).header("Content-Type", "application/json")
.POST(BodyPublishers.ofString(json)).build();
client.sendAsync(request, BodyHandlers.ofString()).thenApply(response -> {
System.out.println(response.statusCode());
return response;
}).thenAccept(response -> {
System.out.println(response);
}).join();
}
Primero creamos un objeto de tipo
HttpClient con el que podemos realizar la peticion de los datos del API. Despues
de esto creamos un objeto HttpRequest donde indicamos el url de nuestro
servicio de Rest. La direccion del servicio se debe indicar con un objeto de
tipo URI el cual tiene el método create para construir lo necesario para
consumir el servicio. En este primer ejemplo vamos a utilizar el método de GET.
Ahora vamos a usar el método sendAsync
del cliente http que desarrollamos anteriormente. Este requiere dos paramteros
uno con el request que construimos y el segudo parametro es como vamos a
manejar la respuesta del servicio. En nuestro ejemplo esperamos un String con
los datos del servidor.
En el método thenAccept vamos
a maniopular el resultado del servidor. En este caso usando la librería de Gson
tenemos que crear un objeto nuevo de Gson y convertir el resutlado del servidor
en una lista de Java sobre esta lista usamos un forEach para ver cada uno de
los elementos y desplegamos el nombre de cada uno de los empleados. Ahora bien
en ese mismo mitodo se puede crear otro tipo de manipulaciones de estos datos.
Para hacer uso del verbo POST
de Rest lo primero que vamos hacer es crear un objeto de tipo EmployeePoco y le
pasamos los datos que deseamos almacenar en el servidor.
Nuevamente con la librería Gson
creamos un objeto que nos permite convertir el EmployeePoco a un text con el
json que deseamos enviar al servidor.
Creamos un nuevo HttpRequest y
le indicamos que el método que deseamos usar es un post en el cual asignamos el
json que se va a guardar en el servicio.
Usando nuevamente el método sendAsync
invocamos el post con el URI que creamos en el request y esperamos la respuesta
en el método thenAccept si este nos responde un codigo 200 quiere decir que
nuestro objeto se guardo correctamente.
Ejemplo
Ejemplo
¿Quieres aprender java y C#?
Etiquetas: Apache Netbeans, API, Java, Java 12, Netbean11, Rest
entrada de JC @ septiembre 18, 2019
0 comentarios
