RPC or REST; Which one is best suited for your Web API ?

|
When we design an api for our software components, then a couple of confusing terms are just at the front of us.
Let's first cope with the conceptual confusion about the terms in this question.

What is an API ?

API is the acronym for the Application Programming Interface.

  • It is a group of methods 
  • that is exported by a provider software components/modules 
  • and is supplied to its consumer software components/modules
  • and the messages(XML, JSON, etc.) of these method calls are transported accross the client and server sides.

Web API

In the context of web, an API is refered as a group of methods that is
  • the web protocol HTTP is used for the communication 
  • by transferring the messages, 
  • generally of the form; XML or JSON format.
Okay then, if a consumer is using an API; then
  • it is communicating via a service provider
  • with dependency to a contract defined by the API
  • over some communication protocols such as HTTP
  • and exchanging the messages in a structured formats such as XML, JSON etc.

RPC or RPC style ?

The big confusion is about the term RPC. 
Is the context of the term RPC used is of the distributed communication protocol or about the api design ?
This is the key question that i think, makes the confusion about the term.

RPC Protocol

  • RPC stands for Remote Procedure Call.
  • Simply meaning that, making a call in your local host and having that call execute a service/procedure on a remote host.
The idea is simple but different implementations of RPC is out there to mention about:
  • Implementation over seperate interface definition using messaging protocols such as SOAP, thrift etc.
    • With that kind of RPC implementation, client and server can communicate over an agreed messaging protocol such as SOAP 
    • even if they are different technology stack such as one is Java and other is .net.
  • A more technology-dependent implementation of RPC is Java RMI. 
    • It is a tighter coupled implementation in which both client and server sides must be implemented with Java.
RPC is said to be protocol-agnostic, meaning that; RPC implementations can run with different networking protocols
  • XML-RPC and SOAP-RPC, in which messages are serialized/deserialized as using XML, nominally make requests using HTTP POST.
  • Other implementations can use of different networking protocols such as TCP
A key challenge when using RPC is the binary stub generation which leads to tightly coupled client and server deployments.

 Okay, now we have a general idea about the RPC protocol, then what is RPC-style ?
Let's firstly inspect the REST side.

Why is the REST architecture style needed ?

RPC is a remote procedure call technique that can run over any communication protocol. However, any of the rpc-based distributed communication techniques like CORBA, DCOM, RMI have some drawbacks in communication since of the concerns;
  • lack of standardized messaging template (mostly a binary messaging protocol is used)
  • lack of standardized application layer protocol
  • tightly coupling between client and server
  • difficulty for designing in case of client and server sides are of different programming models.

And here comes; the Simple Object Access Protocol, SOAP

In that part of the game, SOAP has come to play, as a successor of XML-RPC, with using a standardized XML-based messaging template driven by Microsoft with the benefits:
  • standardized XML-based messaging template
  • communcation-protocol agnostic, mostly HTTP; but HTTP, SMTP, TCP, UDP or JMS can be used.
  • implementable easily by any programming languages
SOAP is well-suited and mostly used for implementing service oriented architectures(SOA) and still has the place of in the game.
However it has some drawbacks;
  • requires overmuch bandwith since of its generality and XML markups
  • altough its name begins with SIMPLE, in reality it's a bit complicated.
And so, the distributed computing ecosystem heads for an alternative player, which leads us to REST.
REST has come to play with using HTTP as a communication protocol which is the standardized application-layer protocol for webservers and nominally JSON or less of XML as the messaging template.

REST

  • REST stands for Representational State Transfer.
  • RESTful means; an architecture that satisfies the constraints of REST architecture style.
  • HTTP is the de facto communication protocol when working REST since;
  • the key idea on REST is manipulating resources identified by URIs with CRUD operations 
  • that semantically projects to standard HTTP verbs; GET, POST, PUT, DELETE
  • and that makes us name it simply; CRUD over HTTP.
As it seems, REST is much like a specialized version of RPC protocol as such;
  • It is a way of calling a remote execution as in RPC
  • It uses nominally HTTP(altough it does not define a communication protocol); while RPC is protocol-agnostic
  • The procedures that REST will execute are certain which are CRUD operations that semantically span HTTP verbs.

Then here comes a brain burner;

If REST is of CRUD based architecture design, then how can it fit for domain driven design concept ?

 To be continued..

References

https://martinfowler.com/articles/richardsonMaturityModel.html
https://www.smashingmagazine.com/2016/09/understanding-rest-and-rpc-for-http-apis
https://blog.thriftly.io/know-your-api-protocols
http://geeknizer.com/rest-vs-soap-using-http-choosing-the-right-webservice-protocol 
https://medium.com/@natemurthy/rest-rpc-and-brokered-messaging-b775aeb0db3
https://apisyouwonthate.com/blog/understanding-rpc-rest-and-graphql
http://www.25hoursaday.com/DistributedComputingTechnologiesExplained.html
https://stackoverflow.com/questions/26830431/web-service-differences-between-rest-and-rpc
https://blog.cloudobjects.io/api-design/2017/04/10/api-design-paradigms/
https://www.moesif.com/blog/api-guide/comparisons-of-api-architectural-styles

Yorumlar

Yorum Gönder

Popular

Java 14 New Features

|
Java SE 14 was released in March 2020. The full list of new features in JDK 14 can be found here: https://openjdk.org/projects/jdk/14/   In this tutorial, we will look over some of these new features and examine some of them. 1. JEP 305: Pattern Matching for instanceof (Preview) With this JEP, instanceof now allows casting of the checked object to a variable. Before Java 14: if (obj instanceof String) { String s = (String) obj; // use s } With Java 14: if (obj instanceof String s) { // can use s here } else { // can't use s here } 2. JEP 345: NUMA-Aware Memory Allocation for G1 This JEP i mproves G1 performance on large machines by implementing NUMA-aware( non-uniform memory access ) memory allocation. Use the  +XX:+UseNUMA option to enable it. 3. JEP 358: Helpful NullPointerExceptions This JEP  improves the usability of  NullPointerException  generated by the JVM by describing precisely which variable was  null . Let's look over the following code which throw
Devamı

Pretenders, Contenders and Liars

|
Life is a way to the uncertainity. This is an exact fact. In this uncertain journey, we meet kinds of people of having different behaviours, and generally label them according to their behaviours. In this writing, i will try to write my understanding of three of these labels; pretenders, contenders and liars. Pretenders A pretender is a kind of people who pretends :) It does not do what it seems to do. It does what it does not seem to do. We frequently meet pretenders in our daily life. And if we catch a person pretending, then we feel that is not sincere. Okay, then here is a question sincerely to ask yourself; do you ever find yourself pretending ? Contenders A contender is a person who has a goal to reach and do not hesitate to fight for that goal. So a contender is sincere ? Absolutely yes, you may be completely opposite to a contender, but if you know that it's a contender, then you know that it's sincere in its behaviours. And sure it is, if you trus
Devamı

Java 12 New Features

|
Java SE 12 was released in March 2019. The full list of new features in JDK 12 can be found here: https://openjdk.org/projects/jdk/12/   In this tutorial, we will look at some of these new features and examine some of them. 1. JEP 189:  Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) Shenandoah is a new garbage collection (GC) algorithm which reduces GC pause times,  independent of heap size. This GC algorithm is experimental so in order to use it with Java 12, you have to enable it : -XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC 2. JEP 325:  Switch Expressions (Preview) This JEP extends the switch statement to be used as either a statement or an expression. Meaning that we can now return a value from a switch expression. Before Java 12, we can return a value by assigning it to a variable: String getColor(int num) { String result = ""; switch (number) { case 1, 2, 3: result = "red, green or blue"; break;
Devamı