Eu tenho sido um tempo muito ocupado com webservices a quem devo chamar com PHP e hoje eu tive que lidar com os cabeçalhos SOAP. A verdade é que é um mundo completamente escuro e eu me encontrei com muitos obstáculos. Vou dizer-lhe onde e como eu resolvi, mas primeiro vamos olhar para alguma teoria.

Os serviços web se tornaram o principal modo de troca de informações entre aplicações, independentemente das plataformas, sistemas operacionais e linguagens de programação. SOAP é um dos protocolos em que são trocados dados e é baseado em XML, de modo que as pesquisas cliente o servidor com um formato XML e recebe a resposta em um outro XML. Para entender o que queremos dizer, vamos olhar para a estrutura de um pedido e resposta SOAP.

Call (pedido):

  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:> entidade
  8. <ns1:language>
  9. <code> 1 </ code>
  10. <desc> </> Desc
  11. </ Ns1:> língua
  12. <ns1:userId>
  13. <code> 1 </ code>
  14. <desc> </> Desc
  15. </ Ns1: usuário>
  16. </ SOAP-ENV:> Cabeçalho
  17. <SOAP-ENV:Body>
  18. </ SOAP-ENV: Body>
  19. </ SOAP-ENV: Envelope>

Answer (resposta):

  1. encoding = "utf-8" ?> <? Xml version = "1.0" encoding = "-8" utf?>
  2. xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd = "http://www.w3.org/2001/XMLSchema" > <Novelas: 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. > Xmlns = <status "com.xplota.ws">
  5. <code> 0 </ code>
  6. <desc> Ok </ desc>
  7. </ Status>
  8. </ Soap:> Cabeçalho
  9. <soap:Body>
  11. </ Soap: Body>
  12. </ Soap: Envelope>

Como visto na listagem anterior, tanto o pedido ea resposta é composto de dois nós XML, cabeçalho e corpo. O comumente usado é o corpo (que deixei em branco porque não estamos interessados neste momento) e que contêm os parâmetros que são enviadas para o webservice no pedido de retornados na resposta.

Enviando os cabeçalhos de sabão

No presente caso, deve enviar certos parâmetros no cabeçalho e ler a partir daí os códigos de erro potencial se tivesse havido. A transferência, apesar de ser uma estrutura em vez de um parâmetro simples, foi simples, você define uma classe com os parâmetros adequados e é enviada diretamente. O PHP motor SOAP é responsável pela tradução. Considere-se um estudo de caso.

  1. / / Definir os cabeçalhos de classe
  2. classe wsHeader
  3. (
  4. = 0 ; public $ Code = 0;
  5. = ” ; public $ desc = ";
  7. $code , $desc ) { public function __construct ($ code, $ desc) (
  8. = $code ; $ This -> Code = $ código;
  9. = $desc ; $ This -> Desc = $ desc;
  10. )
  11. )
  13. / / Uma instância do cliente SOAP
  14. ( ) ; Par $ = array ();
  15. SoapClient ( "http://midominio.com/ws?wsdl" , $par ) ; $ Cliente novo SoapClient = ("http://midominio.com/ws?wsdl", $ par);
  17. / / Adicionar os cabeçalhos dos pedidos
  18. ( ) ; $ Headers = array ();
  19. = new SoapHeader ( "com.xplota.ws" , 'entity' , new wsHeader ( 1 , ” ) ) ; Cabeçalhos $] = new SoapHeader [(com.xplota.ws ", entidade ', wsHeader Novo (1"));
  20. = new SoapHeader ( "com.xplota.ws" , 'language' , new wsHeader ( 1 , ” ) ) ; Cabeçalhos $] = new SoapHeader [(com.xplota.ws "," linguagem ", wsHeader Novo (1"));
  21. = new SoapHeader ( "com.xplota.ws" , 'userId' , new wsHeader ( 1 , ” ) ) ; Cabeçalhos $] = new SoapHeader [(com.xplota.ws "," UserID ", wsHeader Novo (1"));
  22. $headers ) ; $ Client - __setSoapHeaders> ($ headers);
  24. / / Iniciar a chamada para o método foi
  25. -> TuMetodo ( $parametros ) ; $ Resultado = $ cliente -> TuMetodo ($ params);

Como você pode ver é bastante simples de entender. Ao adicionar um cabeçalho deve indicar o espaço que pertence ao motor SOAP sabe como tratá-la, é dado um nome e um objeto que o contém.

Com isso, ter resolvido o lado de entrega de nossas cabeças e tem um pedido SOAP como indicado no XML primeiro.

Recebendo cabeçalhos SOAP

Agora que o método em nosso webservice diz com alguns cabeçalhos de outros que sabemos como interpretar a resposta de XML como a segunda lista. Então nós temos um problema muito grande. Não há nenhuma maneira de obter estes títulos, o motor SOAP do PHP retorna apenas o corpo, nunca cabeçalhos.

De acordo com o método manual PHP __soapCall cliente SOAP para definir uma matriz que irá retornar esses cabeçalhos, mas eu não era capaz de executar a invocação de um método de webservice com esta sintaxe, enquanto invoca-los diretamente no cliente (como documentação indica que pode ser feito) eu trabalhei na perfeição. Ou seja, a teoria diz que o primeiro método que eu possa ver os cabeçalhos, mas eu trabalhei quando eu trabalhei no segundo, mas ele retorna os cabeçalhos e não há maneira de recuperá-los.

Após uma longa disputa com SOAP e funções de pesquisa, mas ainda não chegaram a qualquer conclusão, é como se tivesse acontecido com qualquer um, eu não encontrei nada útil. Eu só tinha uma solução, fazer a minha própria classe a partir do original de resposta SOAP para processar o XML manualmente para obter os dados necessários. Dito e feito. Deixe a solução.

Primeiro eu criar o meu próprio tipo de SOAP e eu verificar se posso fazer o que eu quero.

  1. SoapClient { classe XSoapClient estende SoapClient (
  2. $wsdl , $options ) { public function __construct ($ wsdl, $ options) (
  3. , $options ) ; parent:: __construct ($ wsdl, $ options);
  4. )
  6. $request , $location , $action , $version ) { __doRequest função pública ($ pedido, $ local, $ action, $ version) (
  7. $request , $location , $action , $version ) ; $ Resposta = pai: __doRequest ($ pedido, $ local, $ action, $ version);
  8. ; $ Resposta de retorno;
  9. )
  10. )
  11. XSoapClient ( "http://midominio.com/ws?wsdl" , $par ) ; $ Cliente novo XSoapClient = (http://midominio.com/ws?wsdl ", $ par);

Acho que vou ter sorte se eu tentar esse novo cliente SOAP funciona perfeitamente, mas se eu verificar o conteúdo de $ resposta vejo que contém o XML webservice resposta completa. Como você vê a única coisa que muda é que isso aconteceu instanciar o nome da nova classe. Bom começo, se eu jogar minhas cartas bem eu posso obter os cabeçalhos no __doRequest método :) .

Vamos uma vez que este XML para conseguir o que queremos. Graças às funções DOM e XPath em PHP é muito simples. Este é o resultado final do meu cliente SOAP cabeçalhos de recuperação:

  1. SoapClient SoapClient classe estende XSoapClient
  2. (
  3. = array ( ) ; privado responseHeaders $ = array ();
  5. $wsdl , $options ) { public function __construct ($ wsdl, $ options) (
  6. , $options ) ; parent:: __construct ($ wsdl, $ options);
  7. )
  9. $request , $location , $action , $version ) { __doRequest função pública ($ pedido, $ local, $ action, $ version) (
  10. $request , $location , $action , $version ) ; $ Resposta = pai: __doRequest ($ pedido, $ local, $ action, $ version);
  12. DOMDocument; Dom DOMDocument $ = novo;
  13. ( $response , LIBXML_NOWARNING ) ; $ Dom -> resposta ($ loadXML, LIBXML_NOWARNING)
  14. DOMXPath ( $dom ) ; $ Caminho = DOMXPath novo ($ dom);
  15. ( 'soap' , 'http://schemas.xmlsoap.org/soap/envelope/' ) ; $ Caminho - registerNamespace> ("sabão", "http://schemas.xmlsoap.org/soap/envelope/ ');
  16. -> query ( '//soap:Header/*' ) ; $ Xml = $ caminho - consulta> ('/ / soap: Header / *');
  17. = $this -> headers2array ( $xml ) ; $ This -> responseHeaders = $ this - headers2array> ($ xml);
  19. ; $ Resposta de retorno;
  20. )
  22. getResponseHeaders função pública () (
  23. -> responseHeaders ; return $ this - responseHeaders>;
  24. )
  26. $response ) { headers2array função privada ($ resposta) (
  27. ( ) ; $ Headers = array ();
  28. $response as $node ) { foreach ($ resposta quanto $ node) (
  29. $node -> hasChildNodes ( ) ) { if ($ node - hasChildNodes> ()) (
  30. $node -> nodeName ] = $this -> headers2array ( $node -> childNodes ) ; Cabeçalhos [$ nó -] nodeName> = $ this - headers2array> ($ node - childNodes>);
  31. { Else ()
  32. $node -> nodeName ] = $node -> nodeValue ; Cabeçalhos [$ nó -] nodeName> = $> - nodeValue nó;
  33. )
  34. )
  35. ; $ Headers de retorno;
  36. )
  37. )
  38. = new XSoapClient ( "http://midominio.com/ws?wsdl" , $par ) ; lang = <pre "php"> $ client = XSoapClient novo (http://midominio.com/ws?wsdl ", $ par);
  39. -> TuMetodo ( $parametros ) ; $ Resultado = $ cliente -> TuMetodo ($ params);
  40. -> getResponseHeaders ( ) ; Soapheaders $ = $ cliente - getResponseHeaders> ();

Problema resolvido e muito elegante. Se alguém sabe como obter os cabeçalhos sem montar toda essa bagunça que você me diga, por favor.

Se você tem revelado útil este artigo ... Compartilhe!