jerseyAan de slag met jersey


Opmerkingen

Dit gedeelte geeft een overzicht van wat jersey is en waarom een ontwikkelaar het misschien wil gebruiken.

Het moet ook alle grote onderwerpen in jersey vermelden en een link naar de gerelateerde onderwerpen bevatten. Aangezien de Documentatie voor jersey nieuw is, moet u mogelijk eerste versies van die gerelateerde onderwerpen maken.

Voorbeeld van CRUD-operaties in Jersey

Dit voorbeeld toont het gebruik van HTTP-methoden GET, POST, PUT en DELETE bij het uitvoeren van CRUD-bewerkingen op een REST-bron

Ik gebruik de onderstaande software, frameworks en tools:

  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

Volg de onderstaande stappen voor het maken van de vereiste Jersey-applicatie

Stap 1: Maak een nieuw maven-project met maven-archetype-webapp archetype in Eclipse IDE door Bestand-> Nieuw-> Maven Project te kiezen

Stap 2: Voeg de onderstaande afhankelijkheden toe in het pom.xml-bestand van het project.

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

Stap 3: Application Resource Configuration

Maak een klasse die de org.glassfish.jersey.server.ResourceConfig- klasse uitbreidt en registreer de JAX-RS-componenten in de constructor. Hier registreren we alle bronnen onder het pakket 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");
    }    
}
 

Stap 4: Maak een eenvoudige Java-boonachtige werknemer met eigenschappen zoals id en naam. En overschrijf de methode is gelijk aan () en hashCode (). Ook moet de klasse een openbare constructor zonder argument hebben. Hieronder vindt u de code:

Medewerker Java-bonenklasse

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

Enkele aanvullende informatie over de code

  1. Annotaties @XmlRootElement en @XmlElement zijn vereist voor JAXB om de aanvraag- en antwoordberichten te rangschikken en ongedaan te maken.

Stap 5: Maak de werknemersresource aan zoals hieronder aangegeven:

EmployeeResource-serviceklasse

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

Opmerking: Hoewel zowel de POST- als de PUT-methode kan worden gebruikt voor het maken en / of bijwerken van een bron, beperken we hier de POST-methode voor het bijwerken van een bestaande bron en de PUT-methode voor het maken van een nieuwe bron. Ga voor meer informatie over het gebruik van deze methoden naar deze link

Stap 6: Voeg eindelijk de Jersey Servlet-configuratie toe aan het Deployment Descriptor-bestand (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>
 

Stap 7: Maak het project schoon en maak het na het verzekeren van de onderstaande mappenstructuur in uw project.

voer hier de afbeeldingsbeschrijving in

Stap 8: Voer de toepassing uit in Apache Tomcat.

Gebruik nu een REST-client zoals POSTMAN-extensie in chrome of SOAP UI om naar http: // {hostname}: {portnumber} / {projectName / applicationName} / ws / rest / werknemers te navigeren, met de juiste HTTP-methode en vergeet niet om Accept header met ofwel application / json of application / xml toe te voegen als waarde in het HTTP-verzoek.

Hallo wereld voorbeeld

dit is het eenvoudige voorbeeld van het ontvangen van het hallo wereld gewone sms-bericht als uitvoer bij het aanroepen van het GET-verzoek.

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

je moet ook het volgende toevoegen aan het web.xml-bestand om de api volledig in te stellen.

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

Daarna moet u dit op uw server implementeren en vervolgens de volgende URL in uw browser openen om de uitvoer te krijgen. your_server_name / your_appl_name / rust / hallo.

Installatie of instellingen

primaire vereiste is dat Java in uw systeem moet worden geïnstalleerd. Er zijn twee opties voor het instellen van de trui in de Eclipse IDE: download eerst handmatig de jerseypotten van deze link. en de in het project-> externe potten toevoegen kunt u deze bibliotheken toevoegen daar. [ https://jersey.java.net/download.htmlBuch cialis1]

en de tweede optie is via maven, je moet de maven-afhankelijkheid voor jersey-potten toevoegen en deze wordt automatisch voor je gedownload.

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