jerseyCommencer avec le maillot


Remarques

Cette section donne un aperçu de ce qu'est le maillot et pourquoi un développeur peut vouloir l'utiliser.

Il devrait également mentionner tous les grands sujets dans le maillot, et établir un lien avec les sujets connexes. La documentation de maillot étant nouvelle, vous devrez peut-être créer des versions initiales de ces rubriques connexes.

Exemple d'exploitation CRUD à Jersey

Cet exemple illustre l'utilisation des méthodes HTTP GET, POST, PUT et DELETE pour effectuer des opérations CRUD sur une ressource REST.

J'utilise les logiciels, frameworks et outils ci-dessous:

  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

Veuillez suivre les étapes ci-dessous pour créer l'application Jersey requise

Etape 1: Créez un nouveau projet maven en utilisant l' archétype maven-archetype-webapp dans Eclipse IDE en choisissant Fichier-> Nouveau-> Projet Maven

Étape 2: Ajoutez les dépendances ci-dessous dans le fichier pom.xml du projet.

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

Étape 3: Configuration de la ressource d'application

Créez une classe étendant la classe org.glassfish.jersey.server.ResourceConfig et enregistrez les composants JAX-RS dans son constructeur. Ici, nous enregistrons toutes les ressources sous le package 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");
    }    
}
 

Étape 4: Créez un bean Java simple comme Employee avec des propriétés telles que id et name. Et remplacez la méthode equals () et hashCode (). En outre, la classe doit avoir un constructeur public sans argument. Veuillez trouver le code ci-dessous:

Classe de bean Java d'employé

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;
}
}
 

Quelques informations supplémentaires sur le code

  1. Les annotations @XmlRootElement et @XmlElement sont nécessaires pour que JAXB regroupe et supprime les messages de demande et de réponse.

Étape 5: Créez la ressource employé comme indiqué ci-dessous:

Classe de service 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();
}
}
 

Remarque: Bien que les deux méthodes POST et PUT puissent être utilisées pour créer et / ou mettre à jour une ressource, nous limitons la méthode POST à ​​la mise à jour d'une ressource existante et à la méthode PUT pour créer une nouvelle ressource. Mais pour en savoir plus sur l'utilisation de ces méthodes, veuillez vous rendre sur ce lien

Étape 6: Enfin, ajoutez la configuration de Jersey Servlet dans le fichier de descripteur de déploiement (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>
 

Étape 7: Nettoyez et modifiez le projet après vous être assuré de la structure de dossier ci-dessous dans votre projet.

entrer la description de l'image ici

Étape 8: Exécutez l'application dans Apache Tomcat.

Maintenant, utilisez un client REST comme une extension POSTMAN en chrome ou une interface utilisateur SOAP pour accéder à http: // {nom_hôte}: {numéro_port} / {nom_projet / nom_application} / ws / rest / employees, avec la méthode HTTP appropriée et n'oubliez pas ajouter l'en-tête Accept avec application / json ou application / xml comme valeur dans la requête HTTP.

Bonjour Monde Exemple

Ceci est l'exemple simple d'obtenir le message texte en clair du monde comme sortie en appelant la requête 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"; 
   }  
}
 

Vous devez également ajouter les éléments suivants dans le fichier web.xml pour configurer complètement l’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>
 

Après cela, vous devrez le déployer sur votre serveur, puis ouvrir l'URL suivante dans votre navigateur pour obtenir la sortie. votre_nom_serveur / votre_nom_appl / rest / hello.

Installation ou configuration

L'exigence principale est que java devrait être installé dans votre système. Il y a deux options pour définir le maillot dans l'IDE Eclipse est d'abord télécharger manuellement les jar jars de ce lien.et le dans le projet-> ajouter des jars externes vous pouvez ajouter ces bibliothèques là [ https://jersey.java.net/download.html][1]

et la deuxième option est d'utiliser maven vous devez ajouter la dépendance de maven pour les pots de jersey et il sera automatiquement téléchargé pour vous.

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