jersey Handledning => Komma igång med tröja

Anmärkningar

Det här avsnittet ger en översikt över vad tröja är och varför en utvecklare kanske vill använda den.

Den bör också nämna alla stora ämnen inom tröjan och koppla till de relaterade ämnena. Eftersom dokumentationen för tröjan är ny, kan du behöva skapa initialversioner av relaterade ämnen.

Installation eller installation

det primära kravet är att java ska installeras i ditt system.Det finns två alternativ för att ställa in tröjan i Eclipse IDE är först manuellt ladda ner tröjorna från denna länk.og i projektet-> lägg till externa burkar du kan lägga till dessa bibliotek där. [ https://jersey.java.net/download.html????1]

och det andra alternativet är genom maven måste du lägga till mavenberoende för jerseyburkar och det kommer automatiskt att ladda ner åt dig.

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

Hej världsexempel

detta är det enkla exemplet på att få hej världen vanligt textmeddelande som output när du ringer GET begäran.

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

du nedd också för att lägga till följande i web.xml-filen för att konfigurera api helt.

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

Efter det måste du distribuera detta på din server och sedan öppna följande URL i din webbläsare för att få utdata. namn_på_servern / your_appl_name / vila / hej.

CRUD Exempel i Jersey

Detta exempel visar användningen av GET, POST, PUT och DELETE HTTP-metoder för att utföra CRUD-operationer på en REST-resurs

Jag använder nedanstående programvara, ramar och verktyg:

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

Följ nedanstående steg för att skapa önskad Jersey-applikation

Steg 1: Skapa ett nytt maven-projekt med maven-archetype-webapp- arketyp i Eclipse IDE genom att välja File-> New-> Maven Project

Steg 2: Lägg till nedanstående beroenden i projektets pom.xml-fil.

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

Steg 3: Konfiguration av applikationsresurs

Skapa en klass som förlänger org.glassfish.jersey.server.ResourceConfig- klassen och registrera JAX-RS-komponenterna i sin konstruktor. Här registrerar vi alla resurser under 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");
    }    
}

Steg 4: Skapa en enkel Java-böna som anställd med egenskaper som id och namn. Och åsidosätta metoden lika () och hashCode (). Klassen borde också ha en icke-argumenterad offentlig konstruktör. Vänligen hitta koden nedan:

Anställd Java bönaklass

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

Lite ytterligare information om koden

Annoteringar @XmlRootElement och @XmlElement krävs för att JAXB ska marschera och avbryta begäran och svarsmeddelanden.

Steg 5: Skapa anställdes resursen enligt nedan:

EmployeeResource serviceklass

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

Obs! Även om både POST- och PUT-metoden kan användas för att skapa och / eller uppdatera en resurs, här begränsar vi POST-metoden från att uppdatera en befintlig resurs och PUT-metoden från att skapa en ny resurs. Men för att veta mer om hur dessa metoder används, gå till den här länken

Steg 6: Lägg till äntligen Jersey Servlet-konfiguration i Deployment Descriptor-fil (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>

Steg 7: Rensa och maven bygga projektet efter att ha garanterat nedanstående mappstruktur i ditt projekt.

Steg 8: Kör applikationen i Apache Tomcat.

Använd nu någon REST-klient som POSTMAN-förlängning i krom eller SOAP UI för att navigera till http: // {hostname}: {portnumber} / {projectName / applicationName} / ws / rest / anställda, med lämplig HTTP-metod och glöm inte för att lägga till Accept header med antingen program / json eller applikation / xml som värde i HTTP-begäran.

Modified text is an extract of the original Stack Overflow Documentation

Licensierat under CC BY-SA 3.0

Inte anslutet till Stack Overflow

jersey Handledning
Komma igång med tröja

Sök…

Anmärkningar

Installation eller installation

Hej världsexempel

CRUD Exempel i Jersey