I've been a very busy time with webservices to whom should I call with PHP and today I have had to deal with SOAP headers. The truth is that it is a world quite dark and I met with many obstacles. I will tell you where and how I solved, but first let's look at some theory.

The web services have become the primary mode of exchange of information between applications regardless of platforms, operating systems and programming languages. SOAP is one of the protocols on which are exchanged data and is based on XML, so that the client polls the server with a XML format and receives the answer in another XML. To understand what we mean let's look at the structure of a SOAP request and response.

Call (request):

  1. encoding = "UTF-8" ?> <? Xml version = "1.0" encoding = "UTF-8"?>
  2. xmlns:ns1= "com.xplota.ws" > Xmlns:SOAP-ENV = "http://schemas.xmlsoap.org/soap/envelope/" xmlns:ns1= <SOAP-ENV:Envelope "com.xplota.ws">
  3. <SOAP-ENV:Header>
  4. <ns1:entity>
  5. <code> 1 </ Code>
  6. <Desc> </ Desc>
  7. </ Ns1: entity>
  8. <ns1:language>
  9. <code> 1 </ Code>
  10. <Desc> </ Desc>
  11. </ Ns1: language>
  12. <ns1:userId>
  13. <code> 1 </ Code>
  14. <Desc> </ Desc>
  15. </ Ns1: user>
  16. </ SOAP-ENV: Header>
  17. <SOAP-ENV:Body>
  18. </ SOAP-ENV: Body>
  19. </ SOAP-ENV: Envelope>

Answer (response):

  1. encoding = "utf-8" ?> <? Xml version = "1.0" encoding = "utf-8"?>
  2. xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd = "http://www.w3.org/2001/XMLSchema" > <Soap: Envelope xmlns: soap = "http://schemas.xmlsoap.org/soap/envelope/" xmlns: xsi = "http://www.w3.org/2001/XMLSchema-instance" xmlns: xsd = " http://www.w3.org/2001/XMLSchema ">
  3. <soap:Header>
  4. > <status Xmlns = "com.xplota.ws">
  5. <code> 0 </ Code>
  6. <Desc> Ok </ Desc>
  7. </ Status>
  8. </ Soap: Header>
  9. <soap:Body>
  11. </ Soap: Body>
  12. </ Soap: Envelope>

As seen in previous listings, both the request and the response consists of two XML nodes, header and body. The commonly used is the body (which I left blank because we are not interested at this time) and which contain both the parameters that are sent to the webservice in the request as returned in the response.

Sending soap headers

In the present case should send certain parameters in the header and read from there potential error codes if there had been. The shipment, despite being a structure instead of a simple parameter, was simple, you define a class with the appropriate parameters and is sent directly. The PHP SOAP engine is responsible for the translation. Consider a case study.

  1. / / Define the class headers
  2. wsHeader class
  3. (
  4. = 0 ; public $ Code = 0;
  5. = ” ; public $ Desc = ";
  7. $code , $desc ) { public function __construct ($ code, $ desc) (
  8. = $code ; $ This -> Code = $ code;
  9. = $desc ; $ This -> Desc = $ desc;
  10. )
  11. )
  13. / / An instance of the SOAP client
  14. ( ) ; $ Par = array ();
  15. SoapClient ( "http://midominio.com/ws?wsdl" , $par ) ; $ Client = new SoapClient ("http://midominio.com/ws?wsdl", $ par);
  17. / / Add the headers to requests
  18. ( ) ; $ Headers = array ();
  19. = new SoapHeader ( "com.xplota.ws" , 'entity' , new wsHeader ( 1 , ” ) ) ; $ Headers [] = new SoapHeader (com.xplota.ws ", 'entity', new wsHeader (1"));
  20. = new SoapHeader ( "com.xplota.ws" , 'language' , new wsHeader ( 1 , ” ) ) ; $ Headers [] = new SoapHeader (com.xplota.ws', 'language', new wsHeader (1 "));
  21. = new SoapHeader ( "com.xplota.ws" , 'userId' , new wsHeader ( 1 , ” ) ) ; $ Headers [] = new SoapHeader (com.xplota.ws', 'userId', new wsHeader (1 "));
  22. $headers ) ; $ Client -> __setSoapHeaders ($ headers);
  24. / / Launch the call to the method of ws
  25. -> TuMetodo ( $parametros ) ; $ Result = $ client -> TuMetodo ($ params);

As you can see is quite simple to understand. By adding a header must indicate the namespace it belongs to the SOAP engine knows how to treat it, is given a name and the object that contains it.

With this we have solved the delivery side of our heads and have a SOAP request as we indicated in the first XML.

Receiving SOAP headers

Now that the method in our webservice says with some other headers that we know how to interpret the XML response as the second listing. Then we have a very big problem. There is no way to get these headers, the SOAP engine of PHP only returns the body, never headers.

According to the PHP manual method __soapCall SOAP client to define an array which will return these headers, but I was not able to run the invocation of a webservice method with this syntax while invoking them directly on the client (how documentation states that can be done) I worked it perfectly. That is, the theory says that the first method I can get headers but I worked while I worked the second but it returns the headers and there is no way to recover them.

After a long quarrel with SOAP and research functions but not yet arrived at any conclusion, it is as if it had happened to anyone, I did not find anything useful. I only had a solution, make my own class from the SOAP original response to process the XML by hand to obtain the data needed. Said and done. Let the solution.

First I create my own kind of SOAP and I check if I can do what I want.

  1. SoapClient { XSoapClient class extends SoapClient (
  2. $wsdl , $options ) { public function __construct ($ wsdl, $ options) (
  3. , $options ) ; parent:: __construct ($ wsdl, $ options);
  4. )
  6. $request , $location , $action , $version ) { public function __doRequest ($ request, $ location, $ action, $ version) (
  7. $request , $location , $action , $version ) ; $ Response = parent:: __doRequest ($ request, $ location, $ action, $ version);
  8. ; return $ response;
  9. )
  10. )
  11. XSoapClient ( "http://midominio.com/ws?wsdl" , $par ) ; $ Client = new XSoapClient (http://midominio.com/ws?wsdl ", $ par);

Think I'll be lucky if I try this new SOAP client works perfectly, but also if I check the contents of $ response I see that contains the full XML webservice response. How you see the only thing that changes is that it happened instantiate the name of the new class. Good start, if I play my cards right I can get the headers in the method __doRequest :) .

Let us since this XML to get what we want. Thanks to the functions DOM and XPath in PHP is very simple. This is the end result of my client recovery SOAP headers:

  1. SoapClient class SoapClient extends XSoapClient
  2. (
  3. = array ( ) ; private $ responseHeaders = array ();
  5. $wsdl , $options ) { public function __construct ($ wsdl, $ options) (
  6. , $options ) ; parent:: __construct ($ wsdl, $ options);
  7. )
  9. $request , $location , $action , $version ) { public function __doRequest ($ request, $ location, $ action, $ version) (
  10. $request , $location , $action , $version ) ; $ Response = parent:: __doRequest ($ request, $ location, $ action, $ version);
  12. DOMDocument; $ Dom = new DOMDocument;
  13. ( $response , LIBXML_NOWARNING ) ; $ Dom -> loadXML ($ response, LIBXML_NOWARNING)
  14. DOMXPath ( $dom ) ; $ Path = new DOMXPath ($ dom);
  15. ( 'soap' , 'http://schemas.xmlsoap.org/soap/envelope/' ) ; $ Path -> registerNamespace ('soap', 'http://schemas.xmlsoap.org/soap/envelope/');
  16. -> query ( '//soap:Header/*' ) ; $ Xml = $ path -> query ('/ / soap: Header / *');
  17. = $this -> headers2array ( $xml ) ; $ This -> responseHeaders = $ this -> headers2array ($ xml);
  19. ; return $ response;
  20. )
  22. getResponseHeaders public function () (
  23. -> responseHeaders ; return $ this -> responseHeaders;
  24. )
  26. $response ) { headers2array private function ($ response) (
  27. ( ) ; $ Headers = array ();
  28. $response as $node ) { foreach ($ response as $ node) (
  29. $node -> hasChildNodes ( ) ) { if ($ node -> hasChildNodes ()) (
  30. $node -> nodeName ] = $this -> headers2array ( $node -> childNodes ) ; $ Headers [$ node -> nodeName] = $ this -> headers2array ($ node -> childNodes);
  31. { Else ()
  32. $node -> nodeName ] = $node -> nodeValue ; $ Headers [$ node -> nodeName] = $ node -> nodeValue;
  33. )
  34. )
  35. ; return $ headers;
  36. )
  37. )
  38. = new XSoapClient ( "http://midominio.com/ws?wsdl" , $par ) ; lang= <pre "php"> $ client = new XSoapClient (http://midominio.com/ws?wsdl ", $ par);
  39. -> TuMetodo ( $parametros ) ; $ Result = $ client -> TuMetodo ($ params);
  40. -> getResponseHeaders ( ) ; $ Soapheaders = $ client -> getResponseHeaders ();

Problem solved and quite elegant. If anyone knows how to get the headers without assembling all this mess you tell me please.

If you have proved useful this article ... Share!