Crear una API REST Java con JAX-RS y Jersey

A continuación, explicaré cómo crear una API REST Java con JAX-RS y Jersey. Usaremos los métodos comunes para publicar los servicios en nuestra máquina local.

¿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.

Las operaciones de un sistema REST y la especificación HTTP son cuatro:

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

Lo primero que hay que hacer es crear un proyecto web dinámico Java (mejor la última versión Java JDK 1.8) y configurarlo para poder trabajar con Maven. Yo he utilizado Eclipse como entorno de desarrollo. Si tienes dudas en cómo hacerlo, puedes consultar el tutorial Crear un proyecto web dinámico.

Modificar fichero pom.xml

Introduciremos 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 el resto de clases

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 nuestros Servicios

Lo primero es levantar la aplicación. Para ello, selecciona el proyecto y ejecútalo sobre un servidor Apache previamente configurado. Si no sabes como configurarlo, puedes ver el tutorial Configurar Proyecto web y ver la sección Añadir Servidor Apache Tomcat a Eclipse.

Crear una API REST Java con 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 una API REST Java con JAX-RS y Jersey

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 esto es todo!! Esta es una forma sencilla para empezar a crear servicios REST JAVA y crear una API REST Java con JAX-RS y Jersey.

Espero que te haya sido de utilidad y nos vemos en el próximo tutorial.

Comparte si te ha gustado!!

También te podría gustar...

Deja una respuesta

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