A continuación se van a enumerar cada uno de los pasos para nuestro servicio REST. Para esta tarea es fundamental contar con:
- Eclipse o cualquier entorno de desarrollo
- JDK 6.0 o superior
- Apache Maven 3.0.5
PASO 1:
Crear nuevo proyecto con Maven. En la primera pantalla que nos aparece, elegir maven-archetypes-webapp. Debemos esperar unos segundos hasta que aparezca dicha opción.
Finalmente completamos el Grupo, Arquetipo, Version y Package.
Después de unos segundos, tendremos nuestro proyecto Maven listo para comenzar a trabajar:
PASO 2:
Lo siguiente es configurar el archivo pom.xml en donde debemos modificar el nombre de nuestra aplicación, el repositorio de donde se descargaran las dependencias que utilizaremos para el proyecto y las mismas dependencia o librerias.
<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/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.restful.docker</groupId>
<artifactId>ServicioREST</artifactId>
<packaging>war</packaging>
<version>1.0.0</version>
<!-- nombre de la aplicación -->
<name>ServicioREST</name>
<url>http://maven.apache.org</url>
<!-- nombre del archivo WAR final -->
<build>
<finalName>ServicioREST</finalName>
</build>
<!-- repositorio -->
<repositories>
<repository>
<id>maven2-repository.java.net</id>
<name>Java.net Repository for Maven</name>
<url>http://download.java.net/maven/2/</url>
<layout>default</layout>
</repository>
</repositories>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>
<!-- dependecias -->
<dependencies>
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-server</artifactId>
<version>1.9</version>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.3.1</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.jboss.resteasy</groupId>
<artifactId>resteasy-jaxrs</artifactId>
<version>3.0.4.Final</version>
</dependency>
<dependency>
<groupId>org.jboss.resteasy</groupId>
<artifactId>resteasy-jackson-provider</artifactId>
<version>3.0.4.Final</version>
</dependency>
<dependency>
<groupId>com.thetransactioncompany</groupId>
<artifactId>cors-filter</artifactId>
<version>1.7.1</version>
</dependency>
<dependency>
<groupId>org.jboss.resteasy</groupId>
<artifactId>jaxrs-api</artifactId>
<version>3.0.4.Final</version>
</dependency>
</dependencies>
</project>
PASO 3:
Configuración del archivo web.xml indicando la ruta del restful service al que se va acceder por url, habilitando el cross domain el cual permite que otras aplicaciones puedan consumir el servicio estando en dominios diferentes.
<?xml version="1.0" encoding="UTF-8"?>
<web-app>
<display-name>ServicioREST</display-name>
<!-- Auto scan REST service -->
<context-param>
<param-name>resteasy.scan</param-name>
<param-value>true</param-value>
</context-param>
<!-- this should be the same URL pattern as the servlet-mapping property -->
<context-param>
<param-name>resteasy.servlet.mapping.prefix</param-name>
<param-value>/rest</param-value>
</context-param>
<listener>
<listener-class>
org.jboss.resteasy.plugins.server.servlet.ResteasyBootstrap
</listener-class>
</listener>
<servlet>
<servlet-name>resteasy-servlet</servlet-name>
<servlet-class>
org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher
</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>resteasy-servlet</servlet-name>
<url-pattern>/rest/*</url-pattern>
</servlet-mapping>
<!-- CROSS DOMAIN -->
<!-- permite que se pueda acceder desde una aplicación con otro dominio. -->
<filter>
<filter-name>CORS</filter-name>
<filter-class>com.thetransactioncompany.cors.CORSFilter</filter-class>
<init-param>
<param-name>cors.allowGenericHttpRequests</param-name>
<param-value>true</param-value>
</init-param>
<init-param>
<param-name>cors.allowOrigin</param-name>
<param-value>*</param-value>
</init-param>
<init-param>
<param-name>cors.supportedMethods</param-name>
<param-value>GET, HEAD, POST, OPTIONS, PUT, DELETE</param-value>
</init-param>
<init-param>
<param-name>cors.supportedHeaders</param-name>
<param-value>Content-Type, X-Requested-With, Accept, Authentication</param-value>
</init-param>
<init-param>
<param-name>cors.exposedHeaders</param-name>
<param-value>X-Test-1, X-Test-2</param-value>
</init-param>
<init-param>
<param-name>cors.supportsCredentials</param-name>
<param-value>true</param-value>
</init-param>
<init-param>
<param-name>cors.maxAge</param-name>
<param-value>3600</param-value>
</init-param>
</filter>
<!-- Cross Domain Mapping -->
<filter-mapping>
<filter-name>CORS</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
PASO 4:
Creamos la clase MainRest para el ejemplo de nuestro servicio REST que luego deployaremos en el Apache Tomcat. Dentro de dicha clase tendremos un método con el @path correspondiente para escuchar la ruta GET a la cual vamos a acceder pasando un parametro.
MainRest.java
package com.rest.main;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.rest.classes.Usuario;
@Path("/rest")
public class MainRest {
static final String JSON_UTF_8 = "application/json;charset=UTF-8";
protected Gson gson;
@GET
@Path("/user/{name}")
@Produces({JSON_UTF_8})
public Object getUserByName(@PathParam("name") String name){
Usuario user = new Usuario(name, "Hernández");
gson = new GsonBuilder().disableHtmlEscaping().create();
return gson.toJson(user);
}
}
Usuario.java
package com.rest.classes;
public class Usuario {
private String nombre;
private String apellido;
public Usuario(String nombre, String apellido){
this.nombre = nombre;
this.apellido = apellido;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getApellido() {
return apellido;
}
public void setApellido(String apellido) {
this.apellido = apellido;
}
Una vez que tengamos nuestras clases, el siguiente paso será generar el WAR de la aplicación por medio de Maven. Para ellos abrimos la consola y nos ubicamos dentro del proyecto. Luego ejecutamos el siguiente comando:
mvn clean install -DskipTests
Esto genera dentro de la carpeta "target" el archivo WAR que debemos copiar al webapps de Apache Tomcat. En el siguiente capitulo se hará el deploy del servicio RESTful.
En el siguiente vídeo se podrá visualizar los pasos mencionados en este capitulo.
No hay comentarios:
Publicar un comentario