jersey Tutorial => Erste Schritte mit Trikot

Bemerkungen

In diesem Abschnitt erhalten Sie einen Überblick darüber, was Trikot ist und warum ein Entwickler es verwenden möchte.

Es sollte auch alle großen Themen im Trikot erwähnen und auf die verwandten Themen verweisen. Da die Dokumentation für Jersey neu ist, müssen Sie möglicherweise erste Versionen dieser verwandten Themen erstellen.

Installation oder Setup

Hauptanforderung ist, dass Java in Ihrem System installiert sein sollte. Es gibt zwei Möglichkeiten, das Trikot in der Eclipse-IDE festzulegen. Zuerst müssen Sie die Trikot-Dosen manuell von diesem Link herunterladen dort. [ https://jersey.java.net/download.html([1]

Die zweite Möglichkeit besteht darin, dass Sie die Maven-Abhängigkeit für Trikotdosen hinzufügen müssen, und es wird automatisch für Sie heruntergeladen.

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

Hallo Weltbeispiel

Dies ist das einfache Beispiel für das Abrufen der Hallo-Welt-Klartextnachricht als Ausgabe beim Aufruf der GET-Anforderung.

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

Sie müssen außerdem Folgendes in die Datei web.xml einfügen, um die API vollständig zu konfigurieren.

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

Danach müssen Sie dies auf Ihrem Server bereitstellen und anschließend die folgende URL in Ihrem Browser öffnen, um die Ausgabe zu erhalten. Ihr_Servername / Ihr_Anwendungsname / Rest / Hallo.

CRUD Operationsbeispiel in Jersey

In diesem Beispiel wird die Verwendung von GET-, POST-, PUT- und DELETE-HTTP-Methoden bei CRUD-Vorgängen für eine REST-Ressource veranschaulicht

Ich verwende folgende Software, Frameworks und Tools:

Jersey 2.25.1
JDK 1.7.x (Java 7)
Eclipse IDE Kepler
Apache Maven 3.3.9
Apache Tomcat 7.x

Bitte befolgen Sie die folgenden Schritte zum Erstellen der erforderlichen Jersey-Anwendung

Schritt 1: Erstellen Sie ein neues Maven-Projekt unter Verwendung des Maven-Archetype-Webapp- Archetyps in der Eclipse-IDE, indem Sie Datei-> Neu-> Maven-Projekt wählen

Schritt 2: Fügen Sie die folgenden Abhängigkeiten in der Datei pom.xml des Projekts hinzu.

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

Schritt 3: Konfiguration der Anwendungsressource

Erstellen Sie eine Klasse, die die Klasse org.glassfish.jersey.server.ResourceConfig erweitert , und registrieren Sie die JAX-RS-Komponenten in ihrem Konstruktor. Hier registrieren wir alle Ressourcen unter dem Paket 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");
    }    
}

Schritt 4: Erstellen Sie eine einfache Java-Bean wie Employee mit Eigenschaften wie ID und Name. Und überschreiben Sie die equals () - und hashCode () -Methode. Die Klasse sollte auch keinen öffentlichen Konstruktor mit Argumenten enthalten. Den Code finden Sie unten:

Java-Bean-Klasse für Angestellte

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

Einige zusätzliche Informationen zum Code

Die Anmerkungen @XmlRootElement und @XmlElement sind erforderlich, damit JAXB die Anforderungs- und Antwortnachrichten marshallt und das Marshalling aufhebt.

Schritt 5: Erstellen Sie die Mitarbeiterressource wie folgt:

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

Anmerkung: Obwohl sowohl die POST- als auch die PUT-Methode zum Erstellen und / oder Aktualisieren einer Ressource verwendet werden kann, beschränken wir hier die POST-Methode beim Aktualisieren einer vorhandenen Ressource und der PUT-Methode beim Erstellen einer neuen Ressource. Um mehr über die Verwendung dieser Methoden zu erfahren, besuchen Sie bitte diesen Link

Schritt 6: Fügen Sie schließlich die Jersey Servlet-Konfiguration in die Implementierungsdeskriptordatei (web.xml) hinzu.

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

Schritt 7: Bereinigen und erstellen Sie das Projekt, nachdem Sie die folgende Ordnerstruktur in Ihrem Projekt festgelegt haben.

Schritt 8: Führen Sie die Anwendung in Apache Tomcat aus.

Verwenden Sie nun einen REST-Client wie die POSTMAN-Erweiterung in Chrome oder die SOAP-Benutzeroberfläche, um mit der entsprechenden HTTP-Methode zu http: // {Hostname}: {Portnummer} / {Projektname / Anwendungsname} / Ws / Rest / Mitarbeiter zu navigieren den Accept- Header mit entweder application / json oder application / xml als Wert in der HTTP-Anforderung hinzuzufügen.

Modified text is an extract of the original Stack Overflow Documentation

Lizenziert unter CC BY-SA 3.0

Nicht angeschlossen an Stack Overflow

jersey Tutorial
Erste Schritte mit Trikot

Suche…

Bemerkungen

Installation oder Setup

Hallo Weltbeispiel

CRUD Operationsbeispiel in Jersey