Restful Web Services Tutorial in Java

Tutorials
Java

Willkommen zum Tutorial für Restful Web Services in Java. REST ist das Akronym für REpresentational State Transfer. REST ist ein architektonischer Stil zur Entwicklung von Anwendungen, die über das Netzwerk zugänglich sind. Der REST-Architekturstil wurde von Roy Fielding in seiner Doktorarbeit im Jahr 2000 beleuchtet.

Restful Web Services

Restful Web Services ist eine zustandslose Client-Server-Architektur, bei der Webdienste Ressourcen sind und anhand ihrer URIs identifiziert werden können. REST-Clientanwendungen können die HTTP GET/POST-Methoden verwenden, um Restful-Webdienste aufzurufen. REST spezifiziert kein bestimmtes Protokoll, das verwendet werden soll, aber in fast allen Fällen wird es über HTTP/HTTPS verwendet. Im Vergleich zu SOAP-Webdiensten sind diese leichtgewichtig und folgen keinem Standard. Wir können XML, JSON, Text oder jeden anderen Datentyp für Anfragen und Antworten verwenden.

Java RESTful Web Services API

Java API für RESTful Web Services (JAX-RS) ist die Java API zum Erstellen von REST-Webdiensten. JAX-RS verwendet Annotationen, um die Entwicklung und Bereitstellung von Webdiensten zu vereinfachen. JAX-RS ist Teil des JDK, sodass Sie nichts hinzufügen müssen, um seine Annotationen zu verwenden.

Restful Web Services Annotations

Einige der wichtigen JAX-RS Annotationen sind:

  • @Path: wird verwendet, um den relativen Pfad von Klassen und Methoden anzugeben. Wir können die URI eines Webservices erhalten, indem wir den Wert der Pfadannotation scannen.
  • @GET, @PUT, @POST, @DELETE und @HEAD: werden verwendet, um den HTTP-Anforderungstyp für eine Methode anzugeben.
  • @Produces, @Consumes: werden verwendet, um die Anforderungs- und Antworttypen anzugeben.
  • @PathParam: wird verwendet, um den Methodenparameter an den Pfadwert zu binden, indem er geparst wird.

Restful Web Services und SOAP

  1. SOAP ist ein Protokoll, während REST einen architektonischen Stil darstellt.
  2. SOAP-Server- und Clientanwendungen sind eng gekoppelt und mit dem WSDL-Vertrag verbunden, während es bei REST-Webservices und Clients keinen Vertrag gibt.
  3. Die Lernkurve ist bei REST im Vergleich zu SOAP-Webservices einfach.
  4. REST-Webservice-Anforderungs- und Antworttypen können XML, JSON, Text usw. sein, während SOAP nur mit XML funktioniert.
  5. JAX-RS ist die Java-API für REST-Webdienste, während JAX-WS die Java-API für SOAP-Webdienste ist.

Implementierungen von REST-APIs

Es gibt zwei wichtige Implementierungen der JAX-RS-API.

  1. Jersey: Jersey ist die Referenzimplementierung, die von Sun bereitgestellt wird. Um Jersey als unsere JAX-RS-Implementierung zu verwenden, müssen wir lediglich sein Servlet in der web.xml konfigurieren und die erforderlichen Abhängigkeiten hinzufügen. Beachten Sie, dass die JAX-RS-API Teil des JDK ist und nicht von Jersey stammt. Daher müssen wir die Abhängigkeitsjars in unserer Anwendung hinzufügen.
  2. RESTEasy: RESTEasy ist das JBoss-Projekt, das eine JAX-RS-Implementierung bereitstellt.

Java Restful Web Services Tutorial

Lassen Sie uns sehen, wie einfach es ist, einen Restful-Webdienst mit Jersey und dann RESTEasy zu erstellen. Wir werden die folgenden Methoden über HTTP freigeben und die Chrome Postman-Erweiterung verwenden, um diese zu testen.

URI HTTP Method Description
/person/{id}/getDummy GET Returns a dummy person object
/person/add POST Adds a person
/person/{id}/delete GET Delete the person with ‘id’ in the URI
/person/getAll GET Get all persons
/person/{id}/get GET Get the person with ‘id’ in the URI

Jersey Restful Web Services

Erstellen Sie ein dynamisches Webprojekt und konvertieren Sie es dann in Maven, um das Grundgerüst Ihres Webdienstprojekts zu erhalten. Das folgende Bild zeigt die Projektstruktur des endgültigen Projekts. Werfen wir einen Blick auf die Jersey-Abhängigkeiten, die wir in der pom.xml-Datei haben. 

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>JAXRS-Example</groupId>
  <artifactId>JAXRS-Example</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  
  <dependencies>
        <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-server</artifactId>
            <version>1.19</version>
        </dependency>
        <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-servlet</artifactId>
            <version>1.19</version>
        </dependency>
        <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-client</artifactId>
            <version>1.19</version>
        </dependency>
  </dependencies>
  
  <build>
    <sourceDirectory>src</sourceDirectory>
    <plugins>
      <plugin>
        <artifactId>maven-war-plugin</artifactId>
        <version>2.6</version>
        <configuration>
          <warSourceDirectory>WebContent</warSourceDirectory>
          <failOnMissingWebXml>false</failOnMissingWebXml>
        </configuration>
      </plugin>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.3</version>
        <configuration>
          <source>1.7</source>
          <target>1.7</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

Es ist nicht erforderlich, jersey-client-Abhängigkeiten hinzuzufügen, aber wenn Sie ein Java-Programm zum Aufrufen eines REST-Webdiensts mit Jersey schreiben, ist es erforderlich. Werfen wir nun einen Blick auf den Bereitstellungsdeskriptor, um zu erfahren, wie Jersey konfiguriert wird, um unsere Webanwendung zu erstellen. 

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns="https://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="https://xmlns.jcp.org/xml/ns/javaee https://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  <display-name>JAXRS-Example</display-name>

<!-- Jersey Servlet configurations -->
    <servlet>
    <servlet-name>Jersey REST Service</servlet-name>
    <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
    <init-param>
      <param-name>com.sun.jersey.config.property.packages</param-name>
      <param-value>com.journaldev</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>Jersey REST Service</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>
  <!-- Jersey Servlet configurations -->

</web-app>

Das ist alles, was erforderlich ist, um Jersey in unsere Webanwendung einzubinden. In unserem Java-Code verwenden wir JAX-RS-Annotationen. Beachten Sie den Wert des Init-Parameters com.sun.jersey.config.property.packages, um das Paket anzugeben, das nach Webdienstressourcen und -methoden gescannt werden soll.

Beispielmodellklassen für REST

Zunächst erstellen wir zwei Modell-Beans – Person für unsere Anwendungsdaten und Response für die Übermittlung von Antworten an Client-Systeme. Da wir XML-Antworten senden werden, sollten die Beans mit @XmlRootElement annotiert sein, daher haben wir diese Klasse.

package com.journaldev.jaxrs.model;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement (name="person")
public class Person {
	private String name;
	private int age;
	private int id;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}
	
	@Override
	public String toString(){
		return id+"::"+name+"::"+age;
	}

}

package com.journaldev.jaxrs.model;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class Response {

	private boolean status;
	private String message;

	public boolean isStatus() {
		return status;
	}

	public void setStatus(boolean status) {
		this.status = status;
	}

	public String getMessage() {
		return message;
	}

	public void setMessage(String message) {
		this.message = message;
	}
}

REST Web Services Tutorial Services

Basierend auf unserer URI-Struktur finden Sie unten die Service-Schnittstelle und deren Implementierungscode.

package com.journaldev.jaxrs.service;

import com.journaldev.jaxrs.model.Person;
import com.journaldev.jaxrs.model.Response;

public interface PersonService {

	public Response addPerson(Person p);
	
	public Response deletePerson(int id);
	
	public Person getPerson(int id);
	
	public Person[] getAllPersons();

}

package com.journaldev.jaxrs.service;


import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import com.journaldev.jaxrs.model.Person;
import com.journaldev.jaxrs.model.Response;

@Path("/person")
@Consumes(MediaType.APPLICATION_XML)
@Produces(MediaType.APPLICATION_XML)
public class PersonServiceImpl implements PersonService {

	private static Map<Integer,Person> persons = new HashMap<Integer,Person>();
	
	@Override
	@POST
    @Path("/add")
	public Response addPerson(Person p) {
		Response response = new Response();
		if(persons.get(p.getId()) != null){
			response.setStatus(false);
			response.setMessage("Person Already Exists");
			return response;
		}
		persons.put(p.getId(), p);
		response.setStatus(true);
		response.setMessage("Person created successfully");
		return response;
	}

	@Override
	@GET
    @Path("/{id}/delete")
	public Response deletePerson(@PathParam("id") int id) {
		Response response = new Response();
		if(persons.get(id) == null){
			response.setStatus(false);
			response.setMessage("Person Doesn't Exists");
			return response;
		}
		persons.remove(id);
		response.setStatus(true);
		response.setMessage("Person deleted successfully");
		return response;
	}

	@Override
	@GET
	@Path("/{id}/get")
	public Person getPerson(@PathParam("id") int id) {
		return persons.get(id);
	}
	
	@GET
	@Path("/{id}/getDummy")
	public Person getDummyPerson(@PathParam("id") int id) {
		Person p = new Person();
		p.setAge(99);
		p.setName("Dummy");
		p.setId(id);
		return p;
	}

	@Override
	@GET
	@Path("/getAll")
	public Person[] getAllPersons() {
		Set<Integer> ids = persons.keySet();
		Person[] p = new Person[ids.size()];
		int i=0;
		for(Integer id : ids){
			p[i] = persons.get(id);
			i++;
		}
		return p;
	}

}

Der Großteil des Codes erklärt sich von selbst. Nehmen Sie sich Zeit, um sich mit JAX-RS-Annotationen @Path, @PathParam, @POST, @GET, @Consumes und @Produces vertraut zu machen.

Restful Web Services Test

Das war’s. Unser Webdienst ist bereit. Exportieren Sie ihn einfach als WAR-Datei und legen Sie ihn im Tomcat-Webapps-Verzeichnis ab oder deployen Sie ihn in einem anderen Container Ihrer Wahl. Hier sind einige Tests, die mit der Postman-Chrome-Erweiterung für diesen Webdienst durchgeführt wurden. Beachten Sie, dass wir im Request-Header die Werte „application/xml“ für Accept und Content-Type angeben müssen, wie im untenstehenden Bild gezeigt.

  • getDummy
  • hinzufügen
  • erhalten
  • alle erhalten
  • löschen

Das ist alles zur Erstellung von Webdiensten mit der Jersey JAX-RS-Implementierung. Wie Sie sehen können, verwendet der Großteil des Codes JAX-RS-Annotationen und Jersey wird über den Bereitstellungsbeschreibungs- und Abhängigkeitsmechanismus eingebunden.

RESTEasy RESTful Web Services Beispiel

Wir werden alle Geschäftslogik verwenden, die im Jersey-Projekt entwickelt wurde, aber anstatt Änderungen am selben Projekt vorzunehmen, habe ich ein neues Projekt erstellt. Erstellen Sie ein dynamisches Webprojekt und konvertieren Sie es in ein Maven-Projekt. Kopieren Sie dann alle Java-Klassen – Person, Response, PersonService und PersonServiceImpl. Unten ist das endgültige Projekt, nachdem wir alle Änderungen vorgenommen haben. Fügen Sie unten die RESTEasy-Abhängigkeiten in die pom.xml-Datei ein. 

<dependency>
	<groupId>org.jboss.resteasy</groupId>
	<artifactId>resteasy-jaxrs</artifactId>
	<version>3.0.13.Final</version>
</dependency>
<dependency>
	<groupId>org.jboss.resteasy</groupId>
	<artifactId>resteasy-jaxb-provider</artifactId>
	<version>3.0.13.Final</version>
</dependency>

Unten ist die web.xml-Datei, in der wir das Resteasy-Servlet konfigurieren. 

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns="https://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="https://xmlns.jcp.org/xml/ns/javaee https://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  <display-name>JAXRS-Example-RestEasy</display-name>
     
    <listener>
      <listener-class>
         org.jboss.resteasy.plugins.server.servlet.ResteasyBootstrap
      </listener-class>
   	</listener>
   
    <servlet>
        <servlet-name>resteasy-servlet</servlet-name>
        <servlet-class>
            org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher
        </servlet-class>
        <init-param>
        <param-name>javax.ws.rs.Application</param-name>
        <param-value>com.journaldev.jaxrs.resteasy.app.MyApp</param-value>
    </init-param>
    </servlet>
  
    <servlet-mapping>
        <servlet-name>resteasy-servlet</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
	
</web-app>

Beachten Sie das init-param, in dem wir die Klasse MyApp als Wert angeben. Hier erweitern wir die Klasse javax.ws.rs.core.Application, wie unten gezeigt. 

package com.journaldev.jaxrs.resteasy.app;

import java.util.HashSet;
import java.util.Set;

import javax.ws.rs.core.Application;

import com.journaldev.jaxrs.service.PersonServiceImpl;

public class MyApp extends Application {
	
	private Set<Object> singletons = new HashSet<Object>();

	public MyApp() {
		singletons.add(new PersonServiceImpl());
	}

	@Override
	public Set<Object> getSingletons() {
		return singletons;
	}

}

RESTEasy Web Services Test

Das ist alles. Unser Webdienst ist bereit mit der RESTEasy JAX-RS-Implementierung. Unten sind einige Ausgaben des Postman Chrome-Erweiterungstests.

  • getDummy
  • hinzufügen
  • erhalten

Das ist alles für das Restful Web Services Tutorial. Ich hoffe, Sie haben etwas über JAX-RS-Annotationen gelernt und die Vorteile verstanden, die uns eine standardisierte API bietet, die es uns ermöglicht, Code wiederzuverwenden und leicht von Jersey zu RESTEasy zu wechseln.

Source:
https://www.digitalocean.com/community/tutorials/restful-web-services-tutorial-java