jersey Samouczek
Rozpoczęcie pracy z koszulką
Szukaj…
Uwagi
Ta sekcja zawiera przegląd tego, czym jest koszulka i dlaczego deweloper może chcieć z niej korzystać.
Powinien również wymieniać wszelkie duże tematy w koszulce i zawierać linki do powiązanych tematów. Ponieważ Dokumentacja dla koszulki jest nowa, konieczne może być utworzenie początkowych wersji tych pokrewnych tematów.
Instalacja lub konfiguracja
podstawowym wymaganiem jest zainstalowanie java w twoim systemie. istnieją dwie opcje ustawienia koszulki w Eclipse IDE: najpierw ręcznie pobierz słoiki z tego linku. a w projekcie-> dodaj słoiki zewnętrzne możesz dodać te biblioteki tam. [ https://jersey.java.net/download.html][1]
a drugą opcją jest maven, musisz dodać zależność maven dla słoików z dżersejem i zostanie ona automatycznie pobrana dla Ciebie.
<dependency>
<groupId>org.glassfish.jersey.containers</groupId>
<artifactId>jersey-container-servlet-core</artifactId>
<version>2.6</version>
</dependency>
Przykład Hello World
jest to prosty przykład otrzymania wiadomości tekstowej hello world jako wyjścia po wywołaniu żądania 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";
}
}
musisz także dodać następujące elementy w pliku web.xml, aby całkowicie skonfigurować interfejs 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>
Następnie musisz wdrożyć to na serwerze, a następnie otworzyć następujący adres URL w przeglądarce, aby uzyskać dane wyjściowe. twoja_nazwa_serwera / twoja_aplikacja / rest / hello.
Przykład operacji CRUD w Jersey
W tym przykładzie pokazano użycie metod GET, POST, PUT i DELETE HTTP podczas wykonywania operacji CRUD na zasobie REST
Korzystam z poniższego oprogramowania, ram i narzędzi:
- Jersey 2.25.1
- JDK 1.7.x (Java 7)
- Eclipse IDE Kepler
- Apache Maven 3.3.9
- Apache Tomcat 7.x
Wykonaj poniższe kroki, aby utworzyć wymaganą aplikację Jersey
Krok 1: Utwórz nowy projekt maven za pomocą archetypu maven-archetype-webapp w Eclipse IDE, wybierając Plik-> Nowy-> Projekt Maven
Krok 2: Dodaj poniższe zależności do pliku pom.xml projektu.
<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>
Krok 3: Konfiguracja zasobów aplikacji
Utwórz klasę rozszerzającą klasę org.glassfish.jersey.server.ResourceConfig i zarejestruj komponenty JAX-RS w swoim konstruktorze. Tutaj rejestrujemy wszystkie zasoby w pakiecie 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");
}
}
Krok 4: Utwórz prostą fasolę Java, taką jak Pracownik, o właściwościach takich jak identyfikator i nazwa. I przesłonić metody equals () i hashCode (). Ponadto klasa powinna mieć konstruktor publiczny bez argumentów. Poniżej znajdziesz kod:
Klasa pracownika Java Bean
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;
}
}
Kilka dodatkowych informacji o kodzie
- Adnotacje @XmlRootElement i @XmlElement są wymagane, aby JAXB mógł rozdzielić i odznaczyć komunikaty żądania i odpowiedzi.
Krok 5: Utwórz zasób pracownika, jak podano poniżej:
Klasa usługi 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();
}
}
Uwaga: Chociaż do tworzenia i / lub aktualizowania zasobu można używać zarówno metody POST, jak i PUT, tutaj ograniczamy metodę POST do aktualizowania istniejącego zasobu, a metodę PUT - do tworzenia nowego zasobu. Aby dowiedzieć się więcej na temat korzystania z tych metod, przejdź do tego linku
Krok 6: Na koniec dodaj konfigurację Jersey Servlet w pliku deskryptora wdrażania (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>
Krok 7: Oczyść i zrób kompilację projektu po upewnieniu się, że w twoim projekcie znajduje się poniższa struktura folderów.
Krok 8: Uruchom aplikację w Apache Tomcat.
Teraz użyj klienta REST, takiego jak rozszerzenie POSTMAN w chrome lub SOAP UI, aby przejść do http: // {nazwa hosta}: {numer_portu} / {nazwa projektu / nazwa_aplikacji} / ws / rest / workers, z odpowiednią metodą HTTP i nie zapomnij dodać nagłówek Accept z wartością application / json lub application / xml jako wartość w żądaniu HTTP.