jerseyजर्सी के साथ शुरुआत करना


टिप्पणियों

इस खंड में यह बताया गया है कि जर्सी क्या है, और क्यों एक डेवलपर इसका उपयोग करना चाहता है।

इसमें जर्सी के भीतर किसी भी बड़े विषयों का उल्लेख करना चाहिए, और संबंधित विषयों के लिए लिंक करना चाहिए। चूंकि जर्सी के लिए प्रलेखन नया है, इसलिए आपको उन संबंधित विषयों के प्रारंभिक संस्करण बनाने की आवश्यकता हो सकती है।

जर्सी में CRUD संचालन उदाहरण

यह उदाहरण GEST, POST, PUT और DELETE HTTP मेथड के उपयोग को दर्शाता है, जो एक REST संसाधन पर CRUD ऑपरेशन करने में है

मैं नीचे दिए गए सॉफ्टवेयर, फ्रेमवर्क और टूल्स का उपयोग कर रहा हूं:

  1. जर्सी 2.25.1
  2. JDK 1.7.x (जावा 7)
  3. ग्रहण आईडीई केपलर
  4. अपाचे मावेन ३.३.९ 3.3
  5. अपाचे तोमकैट 7.x

आवश्यक जर्सी एप्लिकेशन बनाने के लिए कृपया नीचे दिए गए चरणों का पालन करें

चरण 1: फ़ाइल-> नई-> मावेन परियोजना का चयन करके ग्रहण आईडीई में maven-archetype-webapp archetype का उपयोग करके एक नया मावेन प्रोजेक्ट बनाएं।

चरण 2: प्रोजेक्ट की pom.xml फ़ाइल में नीचे निर्भरताएँ जोड़ें।

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

चरण 3: अनुप्रयोग संसाधन कॉन्फ़िगरेशन

एक वर्ग बनाएँ। org.glassfish.jersey.server.ResourceConfig वर्ग और इसके निर्माता में JAX-RS घटकों को पंजीकृत करें। यहां हम 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");
    }    
}
 

चरण 4: आईडी और नाम जैसी संपत्तियों के साथ कर्मचारी की तरह एक साधारण जावा बीन बनाएँ। और समतुल्य () और हैशकोड () विधि को ओवरराइड करें। इसके अलावा, कक्षा में कोई तर्क सार्वजनिक निर्माता नहीं होना चाहिए। कृपया नीचे कोड खोजें:

कर्मचारी जावा बीन क्लास

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

कोड पर कुछ अतिरिक्त जानकारी

  1. JAXB से मार्शेल और अनमर्सहॉल अनुरोध और प्रतिक्रिया संदेशों के लिए @XmlRootElement और @XmlElement की आवश्यकता है।

चरण 5: नीचे दिए गए अनुसार कर्मचारी संसाधन बनाएँ:

कर्मचारी वर्ग सेवा वर्ग

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

नोट: हालांकि POST और PUT विधि दोनों का उपयोग किसी संसाधन को बनाने और / या अपडेट करने के लिए किया जा सकता है, यहाँ हम एक मौजूदा संसाधन और PUT विधि को एक नया संसाधन बनाने से अपडेट करने से POST विधि को प्रतिबंधित कर रहे हैं। लेकिन इन विधियों के उपयोग के बारे में अधिक जानने के लिए कृपया इस लिंक पर जाएं

चरण 6: अंत में परिनियोजन वर्णक फ़ाइल (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>
 

चरण 7: अपनी परियोजना में नीचे फ़ोल्डर संरचना सुनिश्चित करने के बाद स्वच्छ और मावेन परियोजना का निर्माण करें।

यहाँ छवि विवरण दर्ज करें

चरण 8: अपाचे टोमाकट में एप्लिकेशन को चलाएं।

अब, http: // {hostname}: {portnumber} / {projectName / applicationName} / ws / rest / कर्मचारी, उपयुक्त HTTP विधि के साथ नेविगेट करने के लिए क्रोम या SOAP UI में POSTMAN एक्सटेंशन जैसे कुछ REST क्लाइंट का उपयोग करें। HTTP अनुरोध में मूल्य के रूप में आवेदन / json या अनुप्रयोग / xml के साथ स्वीकार हेडर जोड़ने के लिए।

हैलो वर्ल्ड उदाहरण

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

आप भी पूरी तरह से एपीआई सेटअप करने के लिए web.xml फ़ाइल में निम्नलिखित जोड़ने के लिए nedd।

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

उसके बाद आपको इसे अपने सर्वर पर तैनात करना होगा और फिर आउटपुट प्राप्त करने के लिए अपने ब्राउज़र में निम्न यूआरएल खोलें। Your_Server_Name / your_appl_name / बाकी / हैलो।

स्थापना या सेटअप

प्राथमिक आवश्यकता यह है कि आपके सिस्टम में जावा को स्थापित किया जाना चाहिए। ग्रहण आईडीई में जर्सी को सेट करने के लिए दो विकल्प हैं। पहली बार इस लिंक से जर्सी जार को मैन्युअल रूप से डाउनलोड करें। और परियोजना में-> बाहरी जार जोड़ें जो आप इन पुस्तकालयों को जोड़ सकते हैं वहाँ। [ https://jersey.java.net/download.html][1]

और दूसरा विकल्प मावेन के माध्यम से है आपको जर्सी जार के लिए मावेन निर्भरता को जोड़ना होगा और यह स्वचालित रूप से आपके लिए डाउनलोड करेगा।

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