Crear cliente REST en Java

  2. HowTo
  3. Howtos de Java
  4. Crear cliente REST en Java
Jay Shaw 15 febrero 2024
Java Java REST
  1. Pasos para crear un cliente Java Rest usando Spring Boot
  2. Crear un cliente Java REST usando OkHttp
  3. Conclusión
Crear cliente REST en Java

REST es un conjunto de reglas y estipulaciones creadas para que los programas web interactúen fácilmente entre sí sin requerir mucho procesamiento.

Se requiere una aplicación del lado del cliente para acceder a los servicios REST que utilizan estos programas web, conocida como cliente REST.

Este artículo analizará diferentes herramientas para crear un cliente REST. El primer ejemplo demuestra los pasos para crear un cliente REST simple usando Spring Boot y OkHttp.

Pasos para crear un cliente Java Rest usando Spring Boot

Para crear un cliente REST, el IDE necesita un marco para funcionar. Un marco es un entorno que incluye todos los paquetes de biblioteca esenciales y componentes relacionados con el tiempo de ejecución.

Spring Boot es un marco Java de código abierto que se utiliza para crear microservicios. Necesitamos los siguientes recursos para crear un cliente REST con Java y Spring Boot.

  • Eclipse IDE o Spring Tool Suite
  • JDK 1.8 o posterior
  • Experto 3.2+

Crearemos un cliente REST paso a paso en las siguientes subsecciones con todas las herramientas anteriores.

Crear un proyecto vacío

El primer paso es crear un proyecto vacío. Esto se puede hacer de dos formas.

  1. Cree un proyecto vacío y agregue todas las dependencias manualmente.

    • Abra Spring Tool Suite, vaya a Archivo>Nuevo>Otro>Web>Proyecto web dinámico y haga clic en Siguiente.
    • Proporcione un nombre de proyecto, seleccione un servidor de tiempo de ejecución, elija la versión del módulo para Dynamic Web y haga clic en Siguiente.
    • La última sección muestra el árbol de la biblioteca. Cualquier cambio en el árbol de ruta de archivo general se puede realizar aquí.

  2. Utilice Spring Initializr para obtener un proyecto preinicializado.

Spring Initializr descarga un proyecto preinicializado configurado según la necesidad del programador de las dependencias, y se puede crear desde https://start.spring.io/.

Cliente de descanso de Java

Este servicio web crea un proyecto Maven o Gradle con todas las dependencias elegidas. Una vez que se hace clic en Generar, el navegador descarga un archivo .zip que contiene todos los archivos y bibliotecas necesarios para el proyecto web.

El proyecto de ejemplo utilizado aquí utiliza un servicio API REST para extraer comillas de una URL y devuelve el resultado cuando el cliente envía una solicitud GET.

El proyecto recibe un nombre: org.clientforquotes, y aquí solo se requiere una dependencia, por lo que solo se selecciona spring web.

Crear un servicio REST

Un servicio REST toma comandos como GET y POST y devuelve una respuesta.

Para crear una aplicación que ejecute un servicio REST, cree una clase Java y asígnele un nombre. En este ejemplo, la clase recibe un nombre: mainapplication.java, que se crea dentro de la carpeta src/main/java.

Esta clase contiene el método principal. Cuando se crea a través del inicializador, esta clase ya se puede encontrar allí.

Hay tres componentes principales en esta clase:

  1. Para ver la salida, se agrega un método de registrador.
  2. Los datos recibidos del dominio se procesan a través de la biblioteca JSON. Se realiza mediante el método RestTemplate.
  3. La aplicación extrae una cotización al inicio. Este proceso ocurre cuando la plantilla Rest se ejecuta usando CommandLineRunner.

A continuación se muestra el código fuente para crear el servicio REST. El archivo se llama MainApplication.java.

package com.example.clientforquotes;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class MainApplication {
  private static final Logger log = LoggerFactory.getLogger(MainApplication.class);

  public static void main(String[] args) {
    SpringApplication.run(MainApplication.class, args);
  }

  @Bean
  public RestTemplate restTemplate(RestTemplateBuilder builder) {
    return builder.build();
  }

  @Bean
  public CommandLineRunner run(RestTemplate restTemplate) throws Exception {
    return args -> {
      Quote qt =
          restTemplate.getForObject("https://quoters.apps.pcfone.io/api/random", Quote.class);
      log.info(qt.toString());
    };
  }
}

Crear una clase que almacene los datos del dominio

Cree otros dos archivos .java: pullquote.java y basevalues.java para agregar el método getter-setter, constructores y funciones To_String.

La clase pullquote almacena el valor citado obtenido del dominio URL y lo muestra cuando se llama a la clase. El siguiente es el código fuente del archivo pullquote.java.

package com.example.clientforquotes;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties(ignoreUnknown = true)
public class Pullquote {
  private String object_type;
  private Basevalue qt_value;

  public Pullquote() {}

  public String getType() {
    return object_type;
  }

  public void setType(String type) {
    this.object_type = type;
  }

  public Basevalue getValue() {
    return qt_value;
  }

  public void setValue(Basevalue value) {
    this.qt_value = value;
  }

  @Override
  public String toString() {
    return "The quote for you = {"
        + "type='" + object_type + '\'' + ", value=" + qt_value + '}';
  }
}

También crearemos una clase Basevalue en el archivo basevalue.java para almacenar la cita interna.

package com.example.clientforquotes;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties(ignoreUnknown = true)
public class Basevalue {
  private Long sr_no;
  private String qt;

  public Basevalue() {}

  public Long getId() {
    return this.sr_no;
  }

  public String getQuote() {
    return this.qt;
  }

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

  public void setQuote(String quote) {
    this.qt = quote;
  }

  @Override
  public String toString() {
    return "Value{"
        + "id=" + sr_no + ", quote='" + qt + '\'' + '}';
  }
}

Agregue cualquier nueva dependencia a pom.xml

Todo proyecto Web tiene un archivo pom.xml que almacena las dependencias que requiere el proyecto. Si se importa una nueva biblioteca dentro del proyecto, se debe agregar su dependencia a su pom.xml.

El siguiente es el archivo pom.xml para nuestro proyecto.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>client-for-quotes</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>client-for-quotes</name>
    <description>Project for fetching quotes</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Ejecute la aplicación

Hay muchas formas de ejecutar la aplicación.

  • Ejecútelo directamente en la aplicación Spring Boot.
  • Crear un archivo ejecutable .jar del proyecto.
  • Ejecutarlo a través de la línea de comando.

Puede ejecutar el cliente REST que creamos utilizando cualquiera de los métodos anteriores. Analicemos ahora la creación de un cliente Java REST utilizando otros marcos.

Crear un cliente Java REST usando OkHttp

Es un cliente ligero y eficiente para aplicaciones Java. Los programas web que lo usan supuestamente pueden cargar más rápido.

El programa publica una llamada JSON a un servicio cuando se realiza una solicitud. La URL está escrita dentro del parámetro .url, mientras que el tipo de solicitud está dentro del parámetro .post.

La función .build() crea una solicitud OkHttp. El siguiente es el código fuente para crear un cliente Java REST utilizando el marco OkHttp.

public static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");

OkHttpClient obj = new OkHttpClient();

String post(String domain, String call) throws IOException {
  RequestBody req_body = RequestBody.create(JSON, call);
  Request quest = new Requests.Builder().url(domain).post(req_body).build();
  Response resp = obj.newCall(quest).execute();
  return resp.req_body().string();
}

Conclusión

Hemos explicado la creación de un cliente Java REST de forma detallada pero sencilla. Después de leer este artículo, el lector puede crear un cliente Java REST utilizando algunos marcos populares como Spring Boot y OkHttp.