Crear API REST JAVA

A continuación, explicaré cómo crear servicios web desarrollando una API REST JAVA con la librería JAX-RS y Jersey.

¿Qué es REST? Sus siglas significan Transferencia de Estado Representacional. No es un protocolo de comunicación, sino una definición de arquitectura donde la comunicación se realiza vía HTTP utilizando los métodos GET, POST, PUT, DELETE y PATCH. La respuesta de esos métodos admiten formatos como JSON (Notación de Objeto de JavaScript), XML, HTML o TEXTO PLANO, entre otros. Así, cuando se habla de aplicación RESTful quiere decir que implementa este tipo de arquitectura.

¿Qué es JAX-RS? Java API for RESTful Web Services. Es una especificación para crear Servicios Web REST que se basa en anotaciones para simplificar el desarrollo y despliegue de los clientes.

¿Qué es Jersey? Es un cliente RESTful e implementa JAX-RS. Facilita a los desarrolladores crear servicios web RESTful con Java.

api rest

Operaciones REST

Las principales operaciones de un sistema REST y la especificación HTTP son las siguientes:

  • GET (leer)
  • POST (crear)
  • PUT (editar)
  • DELETE (eliminar)
  • PATCH (actualizar)

Crear proyecto

Lo primero que hay que hacer es crear un proyecto web dinámico Java y configurarlo para poder trabajar con Maven. Como entorno de desarrollo he utilizado Eclipse.

Modificar fichero pom.xml

A continuación, introducimos las dependencias en el fichero de configuración de Maven.

pom.xml

<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>API_REST_WS-RS</groupId>
	<artifactId>API_REST_WS-RS</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>
	<build>
		<sourceDirectory>src</sourceDirectory>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.8.0</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
			<plugin>
				<artifactId>maven-war-plugin</artifactId>
				<version>3.2.1</version>
				<configuration>
					<warSourceDirectory>WebContent</warSourceDirectory>
				</configuration>
			</plugin>
		</plugins>
	</build>

	<dependencies>
		<dependency>
			<groupId>javax.ws.rs</groupId>
			<artifactId>javax.ws.rs-api</artifactId>
			<version>2.1.1</version>
		</dependency>

		<dependency>
			<groupId>org.glassfish.jersey.containers</groupId>
			<artifactId>jersey-container-servlet</artifactId>
			<version>2.25.1</version>
		</dependency>
		<dependency>
			<groupId>org.glassfish.jersey.media</groupId>
			<artifactId>jersey-media-json-jackson</artifactId>
			<version>2.25.1</version>
		</dependency>
	</dependencies>
</project>

Crear clases

A continuación, vamos a crear las clases User.java, ServicioUsers.java y Configuration.java.

User.java

package es.rosamarfil.modelo;

import java.io.Serializable;

public class User implements Serializable {

	private static final long serialVersionUID = 1L;

	public String name;

	public String username;

	public User() {
		super();
	}
	
	public User(String name, String username) {
		super();
		this.name = name;
		this.username = username;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

}

ServicioUsers.java

package es.rosamarfil.services;

import java.util.ArrayList;
import java.util.List;

import javax.ws.rs.BeanParam;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.client.Entity;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;

import es.rosamarfil.modelo.User;

@Path("/users")
public class ServicioUsers {

	private static List<User> listaUsuarios = new ArrayList<User>() {
		{
			add(new User("Rosa", "Marfil"));
			add(new User("Pepito", "Grillo"));
			add(new User("Manuela", "Lago"));
		}
	};

	/**
	 * URL: http://localhost:8080/API_REST_WS-RS/api/users
	 * @return Response list Users
	 */
	@GET
	@Produces(MediaType.APPLICATION_JSON)
	public Response getUsers() {
		return Response.ok(listaUsuarios).build();
	}


	/**
	 * URL: http://localhost:8080/API_REST_WS-RS/api/users/Rosa
	 * 
	 * @param name String
	 * @return Response
	 */
	@GET
	@Path("/{name}")
	@Consumes(MediaType.APPLICATION_JSON)
	@Produces(MediaType.APPLICATION_JSON)
	public Response getUserById(@PathParam("name") String name) {
		User found = null;
		for (int i = 0; i < listaUsuarios.size(); i++) {
			if (listaUsuarios.get(i).getName().equalsIgnoreCase(name)) {
				found = listaUsuarios.get(i);
			}
		}
		if (found == null) {
			return Response.status(Status.BAD_REQUEST).entity("User not found").build();
		} else {
			return Response.ok(found).build();
		}
	}

	/**
	 * URL: http://localhost:8080/API_REST_WS-RS/api/users/createUser Parameters in
	 * Postman: {"name":"Rosa3333","username":"Marfi3333l"}
	 * 
	 * @param User
	 * @return Response list NOTA: Si no existe el constructor vacío de User, da un
	 *         error y el userRequest viene null.
	 */
	@POST
	@Path("/createUser")
	@Consumes(MediaType.APPLICATION_JSON)
	@Produces(MediaType.APPLICATION_JSON)
	public Response createUser(User userRequest) {

		this.listaUsuarios.add(userRequest);
		//return Response.status(Status.CREATED).build();
		return Response.ok(listaUsuarios).build();

	}

	/**
	 * URL: http://localhost:8080/API_REST_WS-RS/api/users/updateUser Parameters in
	 * Postman: {"name":"Rosa","username":"Marfil3333"}
	 * 
	 * @param User
	 * @return user modified NOTA: Si no existe el constructor vacío de User, da un
	 *         error y el userRequest viene null.
	 */
	@PUT
	@Path("/updateUser")
	@Consumes(MediaType.APPLICATION_JSON)
	@Produces(MediaType.APPLICATION_JSON)
	public Response updateUser(User userUpdate) {
		User found = null;
		for (int i = 0; i < listaUsuarios.size(); i++) {
			if (listaUsuarios.get(i).getName().equalsIgnoreCase(userUpdate.getName())) {
				found = listaUsuarios.get(i);
			}
		}

		if (found == null) {
			return Response.status(Status.BAD_REQUEST).entity("User not found").build();
		} else {
			found.setUsername(userUpdate.getUsername());
			return Response.ok(found).build();
		}
	}

	/**
	 * URL: http://localhost:8080/API_REST_WS-RS/api/users/deleteUser/Rosa
	 * 
	 * @param User
	 * @return Response
	 */
	@DELETE
	@Path("/deleteUser/{name}")
	@Produces(MediaType.APPLICATION_JSON)
	public Response deleteUser(@PathParam("name") String name) {
		User found = null;
		for (int i = 0; i < listaUsuarios.size(); i++) {
			if (listaUsuarios.get(i).getName().equalsIgnoreCase(name)) {
				found = listaUsuarios.get(i);
				listaUsuarios.remove(found);
			}
		}

		if (found == null) {
			return Response.status(Status.BAD_REQUEST).entity("User not found").build();
		} else {
			return Response.ok(listaUsuarios).build();
		}
	}

}

Configuration.java

package es.rosamarfil.services;

import javax.ws.rs.ApplicationPath;
import javax.ws.rs.core.Application;


@ApplicationPath("api")
public class Configuration extends Application {
	
}

Probar nuestra API REST

Para poder acceder a los servicios creados, lo primero que hay que hacer es publicarlos a través de un servidor. Para ello, desde Eclipse arrancaremos nuestro proyecto. Previamente necesitaremos tener un servidor configurado, como por ejemplo Apache.

Una vez hecho esto, nos situaremos sobre nuestro proyecto, desplegaremos el menú contexual y seleccionaremos Run As -> Run on Server.

Crear API REST JAVA - JAX-RS y Jersey

Una vez arrancado el servidor con nuestra aplicación, podemos probar los servicios o bien desde la barra de direcciones de un navegador o desde algún programa cliente como Postman. La dirección base de nuestra aplicación es: http://localhost:8080/API_REST_WS-RS

Vamos a ver los parámetros a introducir:

GET (leer)

En la barra de direcciones introduce:

http://localhost:8080/API_REST_WS-RS/api/users

GET (leer) a partir de un parámetro. En este caso buscaremos un usuario por nombre.

En la barra de direcciones introduce:

http://localhost:8080/API_REST_WS-RS/api/users/Rosa

POST (crear)

En Postman, introduce: http://localhost:8080/API_REST_WS-RS/api/users/createUser

y en la sección Body, introduce un usuario en formato json, como se muestra en la imagen:

Crear API REST JAVA - JAX-RS y Jersey - Postman

PUT (editar)

En Postman, introduce: http://localhost:8080/API_REST_WS-RS/api/users/updateUser

y en la sección Body de Postman introduce:

{«name»:»Rosa»,»username»:»Marfil3333″}


DELETE (eliminar)

En la barra de direcciones introduce:

http://localhost:8080/API_REST_WS-RS/api/users/deleteUser/Rosa

Y hasta aquí la creación de tu primera API REST. Como ves, con unos simples pasos es posible crear servicios web basados en REST.

Espero que te haya sido de utilidad. Comparte si te ha gustado!!

Comparte:

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *