31 votes

Pourquoi HTTP/SOAP est-il considéré comme "épais" ?

J'ai entendu certaines opinions selon lesquelles la pile d'appels de services Web SOAP/HTTP est "épaisse" ou "lourde", mais je n'arrive pas vraiment à savoir pourquoi. Serait-elle considérée comme lourde à cause de la sérialisation/désérialisation de l'enveloppe SOAP et du message ? S'agit-il vraiment d'une opération lourde ?

Ou est-il simplement considéré comme "épais" par rapport à un transfert de données brutes/binaires sur une connexion fixe ?

Ou est-ce une autre raison ? Quelqu'un peut-il m'éclairer à ce sujet ?

51voto

Tom Points 6758

SOAP est conçu pour être suffisamment abstrait pour utiliser d'autres transports que HTTP. Cela signifie, entre autres, qu'il n'est pas tirer parti de certains aspects du protocole HTTP (principalement l'utilisation RESTful des URL et des méthodes, par ex. PUT /customers/1234 o GET /customers/1234 ).

SOAP contourne également les mécanismes TCP/IP existants pour la même raison - pour être indépendant du transport. Encore une fois, cela signifie qu'il ne peut pas tirer parti du transport, comme la gestion des séquences, le contrôle des flux, la découverte de services (par exemple, le contrôle de l'accès à l'information). accept() l'établissement d'une connexion sur un port connu signifie que le service existe), etc.

SOAP utilise XML pour l'ensemble de sa sérialisation. Bien que cela signifie que les données sont "universellement lisibles" avec un simple analyseur XML, cela introduit tellement d'éléments passe-partout que vous avez vraiment besoin d'un analyseur SOAP pour fonctionner efficacement. Et à ce stade, vous (en tant que consommateur de logiciels) avez de toute façon perdu l'avantage du XML ; qui se soucie de l'aspect de la charge utile sur le fil si vous avez besoin d'un parseur SOAP ? libSOAP pour le gérer de toute façon.

SOAP requiert le WSDL afin de décrire les interfaces. Le WSDL lui-même n'est pas un problème, mais il a tendance à être présenté comme beaucoup plus "dynamique" qu'il ne l'est réellement. Dans de nombreux cas, un seul WSDL est créé, et le code producteur/consommateur est généré automatiquement à partir de celui-ci, et il ne change jamais. Dans l'ensemble, cela nécessite beaucoup d'outils sans pour autant résoudre au mieux le problème initial (comment communiquer entre différents serveurs). Et comme la plupart des services SOAP s'exécutent via HTTP, le problème initial était le suivant déjà en grande partie résolu pour commencer.

20voto

Brian Campbell Points 101107

SOAP et WSDL sont des normes extrêmement complexes, avec de nombreuses implémentations qui prennent en charge différents sous-ensembles de ces normes. SOAP ne correspond pas très bien à une simple interface de fonction étrangère de la même manière que XML-RPC fait. En revanche, vous devez comprendre les espaces de noms XML, les enveloppes, les en-têtes, le WSDL, les schémas XML, etc. pour produire des messages SOAP corrects. Tout ce que vous devez faire pour appeler un service XML-RPC est de définir un point de terminaison et d'appeler une méthode sur celui-ci. Par exemple, en Ruby :

require 'xmlrpc/client'

server = XMLRPC::Client.new2("http://example.com/api")
result = server.call("add", 1, 2)

Outre XML-RPC, il existe d'autres techniques qui peuvent également être beaucoup plus simples et légères, comme le XML simple ou le JSON sur HTTP (fréquemment appelé REST (bien que cela implique certaines autres considérations de conception). L'avantage de quelque chose comme XML ou JSON par rapport à HTTP est qu'il est facile à utiliser à partir de JavaScript ou même d'une simple page Web avec un formulaire à soumettre. Il est également possible de le scripter facilement à partir de la ligne de commande avec des outils tels que bouclette . Il fonctionne avec à peu près n'importe quel langage car les bibliothèques HTTP, XML et JSON sont disponibles presque partout, et même si un analyseur JSON n'est pas disponible, il est très facile d'écrire le vôtre.

Editar: Je dois préciser que je fais référence à la façon dont conceptuellement SOAP est un poids lourd, par opposition au poids lourd qu'il représente en termes de quantité brute de données. Je pense que la quantité brute de données est moins importante (bien qu'elle s'accumule rapidement si vous devez traiter de nombreuses petites requêtes), alors que la lourdeur conceptuelle est assez importante, car cela signifie qu'il y a beaucoup plus d'endroits où quelque chose peut mal tourner, où il peut y avoir une incompatibilité, etc.

6voto

Ted Johnson Points 3195

Je suis d'accord avec la première affiche, mais j'aimerais y ajouter quelque chose. La définition de l'épaisseur et de la finesse est relative. Avec des transports tels que JSON ou REST, SOAP semble lourd en surface pour des exemples de type "hello world". Or, comme vous le savez peut-être déjà, ce qui rend SOAP lourd et WS 2.0 en général, ce sont les caractéristiques d'entreprise/robustes. JSON n'est pas sécurisé de la même manière que WS 2.0 peut l'être. Je n'ai pas entendu parler de SOAP comme étant lourd, mais beaucoup d'amateurs de non-XML considèrent ces spécifications comme étant lourdes ou épaisses. Pour être clair, je ne me prononce pas pour ou contre l'une ou l'autre car les deux ont leur place. Le XML est plus verbeux et plus lisible pour l'homme et donc plus "épais". Enfin, certaines personnes considèrent que le protocole HTTP, un protocole de connexion persistant, est lourd étant donné les nouvelles tendances du Web, comme AJAX, plutôt que de servir sur une grande page. La surcharge de connexion est importante alors qu'il n'y a pas vraiment d'avantage.

En résumé, aucune raison réelle à part le fait que quelqu'un veuille appeler SOAP/HTTP épais, tout est relatif. Peu de normes sont parfaites et conviennent à tous les scénarios. Si je devais deviner, je dirais qu'un développeur web intelligent pense qu'il est très intelligent en parlant de la façon dont les technologies XML sont pensées et de la façon dont JSON est super. Chacune a sa place.

5voto

le dorfier Points 27267

Le rapport signal/bruit de SOAP est trop faible. Pour une simple conversation, il y a trop de frais généraux structurels sans valeur de données ; et il y a trop de configuration explicite requise (par rapport à la configuration implicite, comme JSON).

Cela n'a pas commencé ainsi, mais cela a fini par devenir un exemple de ce qui arrive à une bonne idée lorsqu'un comité de normalisation s'en mêle.

3voto

KristoferA Points 8036

Tout d'abord, cela dépend beaucoup de la façon dont vos services sont mis en œuvre (vous pouvez faire beaucoup pour réduire la charge utile en faisant simplement attention à la façon dont les signatures de vos méthodes sont faites).

Cela dit, non seulement l'enveloppe du savon mais aussi le message lui-même peuvent être beaucoup plus volumineux en xml plutôt que dans un format binaire simplifié. Il suffit de choisir les bons noms de classes et de membres pour réduire considérablement ce volume...

Considérez les exemples suivants de retours sérialisés de méthodes retournant une collection d'un objet. Le simple fait de choisir le bon nom [de sérialisation] pour les classes/enveloppes et les membres peut faire une grande différence dans la verbosité de la demande/réponse sérialisée du soap si vous renvoyez des données répétées (par exemple, des listes/collections/rays).

Noms brefs / courts :

<?xml version="1.0" encoding="utf-8"?>
<ArrayOfShortIDName xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://tempuri.org/">
  <ShortIDName>
    <id>0</id>
    <name>foo 0</name>
  </ShortIDName>
  <ShortIDName>
    <id>1</id>
    <name>foo 1</name>
  </ShortIDName>
  <ShortIDName>
    <id>2</id>
    <name>foo 2</name>
  </ShortIDName>
  ...
</ArrayOfShortIDName>

Les noms longs :

<?xml version="1.0" encoding="utf-8"?>
<ArrayOfThisClassHasALongClassNameIDName xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://tempuri.org/">
  <ThisClassHasALongClassNameIDName>
    <MyLongMemberNameObjectID>0</MyLongMemberNameObjectID>
    <MyLongMemberNameObjectName>foo 0</MyLongMemberNameObjectName>
  </ThisClassHasALongClassNameIDName>
  <ThisClassHasALongClassNameIDName>
    <MyLongMemberNameObjectID>1</MyLongMemberNameObjectID>
    <MyLongMemberNameObjectName>foo 1</MyLongMemberNameObjectName>
  </ThisClassHasALongClassNameIDName>
  <ThisClassHasALongClassNameIDName>
    <MyLongMemberNameObjectID>2</MyLongMemberNameObjectID>
    <MyLongMemberNameObjectName>foo 2</MyLongMemberNameObjectName>
  </ThisClassHasALongClassNameIDName>
  ...
</ArrayOfThisClassHasALongClassNameIDName>

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X