jerseyEmpezando con jersey


Observaciones

Esta sección proporciona una descripción general de qué es una camiseta y por qué un desarrollador podría querer usarla.

También debe mencionar cualquier tema importante dentro de jersey, y vincular a los temas relacionados. Dado que la Documentación para jersey es nueva, es posible que deba crear versiones iniciales de esos temas relacionados.

Ejemplo de operaciones de CRUD en Jersey

Este ejemplo demuestra el uso de los métodos GET, POST, PUT y DELETE HTTP al realizar operaciones CRUD en un recurso REST

Estoy utilizando el siguiente software, marcos y herramientas:

  1. Jersey 2.25.1
  2. JDK 1.7.x (Java 7)
  3. Eclipse IDE Kepler
  4. Apache Maven 3.3.9
  5. Apache Tomcat 7.x

Siga los pasos a continuación para crear la aplicación de Jersey requerida

Paso 1: cree un nuevo proyecto de maven utilizando el arquetipo maven-archetype-webapp en Eclipse IDE seleccionando Archivo-> Nuevo-> Proyecto de Maven

Paso 2: Agregue las dependencias a continuación en el archivo pom.xml del proyecto.

<dependencies>
    <dependency>
        <groupId>org.glassfish.jersey.containers</groupId>
        <!-- if your container implements Servlet API older than 3.0, use "jersey-container-servlet-core" -->
        <artifactId>jersey-container-servlet-core</artifactId>
        <version>2.25.1</version>
    </dependency>
    <dependency>
        <groupId>org.glassfish.jersey.media</groupId>
        <artifactId>jersey-media-jaxb</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>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.25</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-simple</artifactId>
        <version>1.7.25</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>3.8.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>
 

Paso 3: Configuración de recursos de la aplicación

Cree una clase de extensión org.glassfish.jersey.server.ResourceConfig y registre los componentes JAX-RS en su constructor. Aquí estamos registrando todos los recursos en el paquete com.stackoverflow.ws.rest.

package com.stackoverflow.ws.rest;

import org.glassfish.jersey.server.ResourceConfig;

public class MyApplication extends ResourceConfig {

    public MyApplication() {
        packages("com.stackoverflow.ws.rest");
    }    
}
 

Paso 4: Cree un bean Java simple como Employee con propiedades como id y name. Y anule el método equals () y hashCode (). Además, la clase debe tener un constructor público sin argumentos. Por favor encuentre el código a continuación:

Empleado de Java clase de frijol

package com.stackoverflow.ws.rest.model;

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class Employee {

private int id;
private String name;
    
public Employee(){
    super();
}

public Employee(int id, String name) {
    super();
    this.id = id;
    this.name = name;
}

@XmlElement
public int getId() {
    return id;
}
public void setId(int id) {
    this.id = id;
}

@XmlElement
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}

@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + id;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
}

@Override
public boolean equals(Object obj) {
    if (this == obj) {
        return true;
    }
    if (obj == null) {
        return false;
    }
    if (!(obj instanceof Employee)) {
        return false;
    }
    Employee other = (Employee) obj;
    if (id != other.id) {
        return false;
    }
    if (name == null) {
        if (other.name != null) {
            return false;
        }
    } else if (!name.equals(other.name)) {
        return false;
    }
    return true;
}
}
 

Alguna información adicional sobre el código.

  1. Las anotaciones @XmlRootElement y @XmlElement son necesarias para que JAXB marque y elimine todos los mensajes de solicitud y respuesta.

Paso 5: Crea el Recurso del empleado como se indica a continuación:

Clase de servicio EmployeeResource

package com.stackoverflow.ws.rest;

import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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.core.Context;
import javax.ws.rs.core.GenericEntity;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;

import com.stackoverflow.ws.rest.model.Employee;

@Path("/employees")
public class EmployeeResource {

    private static Map<Integer, Employee> employeesRepository = new HashMap<Integer, Employee>();

// Read - get all the employees
@GET
@Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
public Response getEmployees() {
    List<Employee> employees = new ArrayList<Employee>(
            employeesRepository.values());
    GenericEntity<List<Employee>> entity = new GenericEntity<List<Employee>>(
            employees) {
    };
    return Response.ok(entity).build();
}

// Read - get an employee for the given ID
@GET
@Path("/{key}")
@Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
public Response getEmployee(@PathParam("key") int key) {

    if (employeesRepository.containsKey(key)) {

        return Response.ok(employeesRepository.get(key)).build();
    } else {

        return Response.status(404).build();
    }
}

// Create - create an employee
@POST
@Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
public Response addEmployee(Employee employee, @Context UriInfo uriInfo) {

    if(employee.getId()!=0){
        
        return Response.status(400).build();
    }
    
    int createdEmployeeId = 1;
    
    if(!employeesRepository.isEmpty()){
        
        createdEmployeeId = Collections.max(employeesRepository.keySet()) + 1;
    }
    
    employee.setId(createdEmployeeId);
    employeesRepository.put(createdEmployeeId, employee);
    
    UriBuilder builder = uriInfo.getAbsolutePathBuilder();
    URI createdURI = builder.path(Integer.toString(createdEmployeeId)).build();
    return Response.created(createdURI).build();
}

// Update - updates an existing employee
@PUT
@Path("/{key}")
@Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
public Response updateEmployee(@PathParam("key") int key, Employee employee) {

    int status = 0;

    if (employeesRepository.containsKey(key)) {
        // update employeeRepostory
        employeesRepository.put(key, employee);
        status = 204;
    } else {
        status = 404;
    }
    return Response.status(status).build();
}

// Delete - deletes an existing employee
@DELETE
@Path("/{key}")
public Response deleteEmployee(@PathParam("key") int key) {

    employeesRepository.remove(key);
    return Response.noContent().build();
}

// Delete - deletes all the employees
@DELETE
public Response deleteEmployees() {

    employeesRepository.clear();
    return Response.noContent().build();
}
}
 

Nota: Aunque los métodos POST y PUT se pueden usar para crear y / o actualizar un recurso, aquí estamos restringiendo el método POST de actualizar un recurso existente y el método PUT de crear un nuevo recurso. Pero para saber más sobre el uso de estos métodos, por favor vaya a este enlace

Paso 6: Finalmente, agregue la configuración de Jersey Servlet en el archivo Descriptor de implementación (web.xml)

<web-app>
  <display-name>Jersey 2.25.1 based REST Application</display-name>

   <servlet>
        <servlet-name>JerseyFrontController</servlet-name>
        <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
        <init-param>
            <param-name>javax.ws.rs.Application</param-name>
            <param-value>com.stackoverflow.ws.rest.MyApplication</param-value>
        </init-param>
    </servlet>

    <servlet-mapping>
        <servlet-name>JerseyFrontController</servlet-name>
        <url-pattern>/ws/rest/*</url-pattern>
    </servlet-mapping>
</web-app>
 

Paso 7: Limpie y cree el proyecto, después de asegurarse de que la estructura de carpetas de su proyecto sea la siguiente.

introduzca la descripción de la imagen aquí

Paso 8: Ejecutar la aplicación en Apache Tomcat.

Ahora, use algún cliente REST como la extensión POSTMAN en Chrome o SOAP UI para navegar a http: // {hostname}: {número de puerto} / {projectName / applicationName} / ws / rest / employee, con el método HTTP apropiado y no lo olvide para agregar el encabezado Aceptar con application / json o application / xml como valor en la solicitud HTTP.

Hola mundo ejemplo

Este es el ejemplo simple de obtener el mensaje de texto simple hello world como salida al llamar a la solicitud GET.

import javax.ws.rs.GET; 
import javax.ws.rs.Path; 
import javax.ws.rs.Produces; 
import javax.ws.rs.core.MediaType;  
@Path("/hello") 
public class HelloExample {  
   @GET 
   @Produces(MediaType.APPLICATION_TEXT) 
   public String getUsers(){ 
      return "Hello World"; 
   }  
}
 

También es necesario agregar lo siguiente en el archivo web.xml para configurar completamente la api.

   <display-name>User Message</display-name> 
   <servlet> 
      <servlet-name>Jersey REST Api</servlet-name> 
      <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servletclass> 
      <init-param> 
         <param-name>jersey.config.server.provider.packages</param-name> 
         <param-value>your_package_name</param-value> 
      </init-param> 
   </servlet> 
   <servlet-mapping> 
      <servlet-name>Jersey REST Api</servlet-name> 
      <url-pattern>/rest/*</url-pattern> 
   </servlet-mapping>
 

Después de eso, deberá implementar esto en su servidor y luego abrir la siguiente URL en su navegador para obtener el resultado. su_servidor_nombre / su_appl_nombre / resto / hola.

Instalación o configuración

El requisito principal es que java se instale en su sistema. Hay dos opciones para configurar la camiseta en el IDE de Eclipse. Primero, descargue manualmente los tarros de la camiseta desde este enlace. Y en el proyecto -> Agregar jarras externas, puede agregar estas bibliotecas. allí [ https://jersey.java.net/download.html◆◆1]

y la segunda opción es a través de maven: tiene que agregar la dependencia de maven para los tarros de jersey y se descargará automáticamente para usted.

<dependency>
    <groupId>org.glassfish.jersey.containers</groupId>
    <artifactId>jersey-container-servlet-core</artifactId>
    <version>2.6</version>
</dependency>