Restful Web Services Tutorial in Java

Welkom bij de Tutorial voor Restful Web Services in Java. REST is het acroniem voor REpresentational State Transfer. REST is een architecturale stijl voor het ontwikkelen van toepassingen die via het netwerk toegankelijk zijn. De architecturale stijl van REST werd in 2000 belicht door Roy Fielding in zijn proefschrift.

Restful Web Services

Restful Web Services is een stateless client-server-architectuur waar webdiensten resources zijn en kunnen worden geïdentificeerd aan de hand van hun URI’s. REST-clienttoepassingen kunnen HTTP GET/POST-methoden gebruiken om Restful-webdiensten aan te roepen. REST specificeert geen specifiek protocol om te gebruiken, maar in bijna alle gevallen wordt het gebruikt via HTTP/HTTPS. In vergelijking met SOAP-webdiensten zijn deze lichtgewicht en volgen ze geen enkele standaard. We kunnen XML, JSON, tekst of elk ander type gegevens gebruiken voor aanvraag en reactie.

Java RESTful Web Services API

Java API voor RESTful Web Services (JAX-RS) is de Java API voor het maken van REST-webdiensten. JAX-RS gebruikt annotaties om de ontwikkeling en implementatie van webdiensten te vereenvoudigen. JAX-RS maakt deel uit van JDK, dus je hoeft niets toe te voegen om de annotaties te gebruiken.

Restful Web Services Annotations

Sommige van de belangrijke JAX-RS annotaties zijn:

• @Path: gebruikt om het relatieve pad van klasse en methoden aan te geven. We kunnen de URI van een webservice krijgen door de waarde van de Path annotatie te scannen.
• @GET, @PUT, @POST, @DELETE en @HEAD: gebruikt om het HTTP-verzoekstype voor een methode aan te geven.
• @Produces, @Consumes: gebruikt om de verzoek- en antwoordtypes aan te geven.
• @PathParam: gebruikt om de methodeparameter aan de padwaarde te binden door het te parseren.

Restful Web Services and SOAP

1. SOAP is een protocol terwijl REST een architectuurstijl is.
2. SOAP-server- en clienttoepassingen zijn sterk gekoppeld en gebonden aan het WSDL-contract, terwijl er geen contract is bij REST-webservices en de client.
3. Het leercurve is makkelijk voor REST in vergelijking met SOAP-webservices.
4. REST-webservices verzoek- en antwoordtypes kunnen XML, JSON, tekst, enz. zijn, terwijl SOAP alleen met XML werkt.
5. JAX-RS is de Java API voor REST-webdiensten, terwijl JAX-WS de Java API is voor SOAP-webdiensten.

Implementaties van REST API

Er zijn twee belangrijke implementaties van de JAX-RS API.

1. Jersey: Jersey is de referentie-implementatie die wordt geleverd door Sun. Om Jersey te gebruiken als onze JAX-RS-implementatie, hoeven we alleen maar zijn servlet te configureren in web.xml en de vereiste afhankelijkheden toe te voegen. Let op dat de JAX-RS API deel uitmaakt van JDK en niet van Jersey, dus we moeten de afhankelijkheids-JAR’s toevoegen aan onze applicatie.
2. RESTEasy: RESTEasy is het JBoss-project dat een JAX-RS-implementatie biedt.

Java Restful Web Services Tutorial

Laten we eens kijken hoe eenvoudig het is om een Restful webservice te maken met behulp van Jersey en vervolgens RESTEasy. We zullen de volgende methoden blootstellen via HTTP en de Chrome Postman-extensie gebruiken om deze te testen.

Jersey Restful Web Services

Maak een dynamisch webproject en converteer het vervolgens naar Maven om het skelet van je webdienstenproject te verkrijgen. De onderstaande afbeelding toont de projectstructuur van het uiteindelijke project. Laten we kijken naar de Jersey-afhankelijkheden die we hebben in het pom.xml-bestand.

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

We hoeven geen jersey-client afhankelijkheden toe te voegen, maar als je een Java-programma schrijft om een REST-webservice aan te roepen met behulp van Jersey, is het vereist. Laten we nu naar het inzetbeschrijvingsbestand kijken om te leren hoe we Jersey kunnen configureren om onze webtoepassing te maken.

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

Dat is alles wat nodig is om Jersey in onze webtoepassing te integreren. In onze Java-code zullen we JAX-RS-annotaties gebruiken. Let op de waarde van de init-parameter com.sun.jersey.config.property.packages om het pakket op te geven dat moet worden gescand op webdienstbronnen en -methoden.

REST Voorbeeld Model Klassen

Allereerst zullen we twee model beans maken – Person voor onze toepassingsgegevens en Response voor het verzenden van een respons naar clientsystemen. Aangezien we een XML-respons zullen verzenden, moeten de beans zijn geannoteerd met @XmlRootElement, vandaar deze 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 Zelfstudie Services

Op basis van onze URI-structuur, hieronder vindt u de service-interface en de implementatiecode.

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

}

De meeste code spreekt voor zich, neem de tijd om vertrouwd te raken met JAX-RS-annotaties @Path, @PathParam, @POST, @GET, @Consumes en @Produces.

Restful Web Services Test

Dat is het. Onze webservice is klaar, exporteer deze gewoon als WAR-bestand en plaats het in de webapps-map van Tomcat of implementeer het in een andere container naar keuze. Hieronder staan enkele tests die zijn uitgevoerd met behulp van de Postman Chrome-extensie voor deze webservice. Let op dat we “application/xml” moeten opgeven als waarden voor Accept en Content-Type in de verzoekheader, zoals getoond in onderstaande afbeelding.

• getDummy
• toevoegen
• ophalen
• allesOphalen
• verwijderen

Dat is alles voor het maken van webdiensten met behulp van de Jersey JAX-RS-implementatie. Zoals je kunt zien, maakt het grootste deel van de code gebruik van JAX-RS-annotaties en is Jersey geïntegreerd via het inzetdescriptor en de afhankelijkheden.

RESTEasy RESTful Web Services Voorbeeld

We zullen alle bedrijfslogica gebruiken die ontwikkeld is in het Jersey-project, maar in plaats van wijzigingen aan te brengen in hetzelfde project, heb ik een nieuw project gemaakt. Maak een dynamisch webproject en converteer het naar een Maven-project. Kopieer vervolgens alle java-klassen – Person, Response, PersonService en PersonServiceImpl. Hieronder staat het uiteindelijke project nadat we klaar zijn met alle wijzigingen. Voeg hieronder RESTEasy-afhankelijkheden toe in het pom.xml-bestand.

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

Hieronder staat het web.xml-bestand waar we de Resteasy-servlet configureren.

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

Let op de init-param waar we de klasse MyApp opgeven als waarde, hier breiden we de klasse javax.ws.rs.core.Application uit zoals hieronder getoond.

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

Dat is het. Onze webservice is klaar met de RESTEasy JAX-RS-implementatie. Hieronder staan enkele uitvoerresultaten van de Postman Chrome-extensietest.

• getDummy
• toevoegen
• ophalen

Dat is alles voor de Restful Web Services Tutorial. Ik hoop dat je meer hebt geleerd over JAX-RS-annotaties en de voordelen hebt begrepen van het hebben van een standaard API die ons helpt bij het hergebruiken van code en het eenvoudig overstappen van Jersey naar RESTEasy.