डब्ल्यूएसडीएल/एसओएपी समर्थन गो पर?

Question

मैंने चारों ओर देखा और मुझे लगता है कि एक्सएमएल के लिए समर्थन है।

क्या गो पर SOAP/WSDL का समर्थन करने के लिए कोई पैकेज हैं?

Answer 1

नहीं।

सोप बेकार है, लेकिन मैं पहले से ही एक-निर्धारित प्रोटोकॉल सोप का उपयोग करता है की एक सर्वर को लागू करने के लिए किया था, तो मैं net/http साथ सुना और encoding/xml साथ डीकोड/इनकोडिंग लिफाफे। कुछ ही मिनटों में, मैंने पहले ही गो के साथ अपना पहला लिफाफा पेश किया है।

Answer 2

गो में डब्लूएसडीएल के लिए समर्थन नहीं है। अन्य भाषाओं में समर्थन या तो स्थैतिक या गतिशील हैं: या तो स्ट्रक्चर डब्लूएसडीएल से पूर्व-उत्पन्न होते हैं, या यह हैश टेबल के साथ फ्लाई पर किया जाता है।

हालांकि, आप मैन्युअल रूप से एसओएपी अनुरोधों को एन्कोड और डीकोड कर सकते हैं। मैंने पाया कि मानक encoding/xml पैकेज SOAP के लिए अपर्याप्त होना है। विभिन्न सर्वरों में इतने सारे क्विर्क हैं, और encoding/xml में सीमाएं इन सर्वरों से अनुरोध करने में एक समस्या उत्पन्न करती हैं।

उदाहरण के लिए, कुछ सर्वरों को प्रत्येक स्ट्रिंग टैग पर xsi:type="xsd:string" की आवश्यकता होती है। आदेश में इस को ठीक से अपने struct करने के लिए encoding/xml के लिए इस तरह देखने के लिए की जरूरत है:

type MethodCall struct { 
    One XSI 
    Two XSI 
} 

type XSI struct { 
    Type string `xml:"xsi:type,attr"` 
    Vaue string `xml:",chardata"` 
} 

और आप इसे इस तरह का निर्माण:

<MethodCall> 
    <One xsi:type="xsd:string">One</One> 
    <Two xsi:type="xsd:string">Two</Two> 
</MethodCall> 

अब इस:

MethodCall{ 
    XSI{"xsd:string", "One"}, 
    XSI{"xsd:string", "Two"}, 
} 

जो तुम देता है ठीक हो सकता है यह निश्चित रूप से काम पूरा हो जाता है। लेकिन क्या होगा यदि आपको केवल string से अधिक की आवश्यकता है? encoding/xml वर्तमान में interface{} का समर्थन नहीं करता है।

जैसा कि आप देख सकते हैं कि यह जटिल हो जाता है। यदि आपके पास एकीकृत करने के लिए एक एसओएपी एपीआई था, तो शायद यह बहुत बुरा नहीं होगा। क्या होगा यदि आपके पास कई थे, प्रत्येक अपने स्वयं के quirks के साथ?

क्या यह अच्छा नहीं होगा अगर आप ऐसा कर सकें?

type MethodCall struct { 
    One string 
    Two string 
} 

फिर encoding/xml को कहते हैं: "यह सर्वर चाहते xsi प्रकार"।

इस समस्या को हल करने के लिए मैंने github.com/webconnex/xmlutil बनाया। यह एक काम प्रगति पर है। इसमें encoding/xml के एन्कोडर/डिकोडर की सभी सुविधाएं नहीं हैं, लेकिन एसओएपी के लिए इसकी आवश्यकता है।

package main 

import (
    "bytes" 
    "encoding/xml" 
    "fmt" 
    "github.com/webconnex/xmlutil" 
    "log" 
    //"net/http" 
) 

type Envelope struct { 
    Body `xml:"soap:"` 
} 

type Body struct { 
    Msg interface{} 
} 

type MethodCall struct { 
    One string 
    Two string 
} 

type MethodCallResponse struct { 
    Three string 
} 

func main() { 
    x := xmlutil.NewXmlUtil() 
    x.RegisterNamespace("http://www.w3.org/2001/XMLSchema-instance", "xsi") 
    x.RegisterNamespace("http://www.w3.org/2001/XMLSchema", "xsd") 
    x.RegisterNamespace("http://www.w3.org/2003/05/soap-envelope", "soap") 
    x.RegisterTypeMore(Envelope{}, xml.Name{"http://www.w3.org/2003/05/soap-envelope", ""}, 
     []xml.Attr{ 
      xml.Attr{xml.Name{"xmlns", "xsi"}, "http://www.w3.org/2001/XMLSchema-instance"}, 
      xml.Attr{xml.Name{"xmlns", "xsd"}, "http://www.w3.org/2001/XMLSchema"}, 
      xml.Attr{xml.Name{"xmlns", "soap"}, "http://www.w3.org/2003/05/soap-envelope"}, 
     }) 
    x.RegisterTypeMore("", xml.Name{}, []xml.Attr{ 
     xml.Attr{xml.Name{"http://www.w3.org/2001/XMLSchema-instance", "type"}, "xsd:string"}, 
    }) 

    buf := new(bytes.Buffer) 
    buf.WriteString(`<?xml version="1.0" encoding="utf-8"?>`) 
    buf.WriteByte('\n') 
    enc := x.NewEncoder(buf) 
    env := &Envelope{Body{MethodCall{ 
     One: "one", 
     Two: "two", 
    }}} 
    if err := enc.Encode(env); err != nil { 
     log.Fatal(err) 
    } 
    // Print request 
    bs := buf.Bytes() 
    bs = bytes.Replace(bs, []byte{'>', '<'}, []byte{'>', '\n', '<'}, -1) 
    fmt.Printf("%s\n\n", bs) 

    /* 
     // Send response, SOAP 1.2, fill in url, namespace, and action 
     var r *http.Response 
     if r, err = http.Post(url, "application/soap+xml; charset=utf-8; action="+namespace+"/"+action, buf); err != nil { 
      return 
     } 
     dec := x.NewDecoder(r.Body) 
    */ 
    // Decode response 
    dec := x.NewDecoder(bytes.NewBufferString(`<?xml version="1.0" encoding="utf-8"?> 
    <soap:Envelope> 
     <soap:Body> 
      <MethodCallResponse> 
       <Three>three</Three> 
      </MethodCallResponse> 
     </soap:Body> 
    </soap:Envelope>`)) 
    find := []xml.Name{ 
     xml.Name{"", "MethodCallResponse"}, 
     xml.Name{"http://www.w3.org/2003/05/soap-envelope", "Fault"}, 
    } 
    var start *xml.StartElement 
    var err error 
    if start, err = dec.Find(find); err != nil { 
     log.Fatal(err) 
    } 
    if start.Name.Local == "Fault" { 
     log.Fatal("Fault!") // Here you can decode a Soap Fault 
    } 
    var resp MethodCallResponse 
    if err := dec.DecodeElement(&resp, start); err != nil { 
     log.Fatal(err) 
    } 
    fmt.Printf("%#v\n\n", resp) 
} 

ऊपर के उदाहरण के साथ

मैं Find विधि का उपयोग प्रतिक्रिया ऑब्जेक्ट, या एक दोष पाने के लिए:

यहाँ एक काम कर उदाहरण है। यह कड़ाई से जरूरी नहीं है। आप इसे इस तरह भी कर सकते हैं:

x.RegisterType(MethodCallResponse{}) 
... 
// Decode response 
dec := x.NewDecoder(bytes.NewBufferString(`<?xml version="1.0" encoding="utf-8"?> 
<soap:Envelope> 
    <soap:Body> 
     <MethodCallResponse> 
      <Three>three</Three> 
     </MethodCallResponse> 
    </soap:Body> 
</soap:Envelope>`)) 
var start *xml.StartElement 
var resp Envelope 
if err := dec.DecodeElement(&resp, start); err != nil { 
    log.Fatal(err) 
} 
fmt.Printf("%#v\n\n", resp) 

आप जब अपने डेटा इस तरह दिखता है Find विधि उपयोगी मानते हैं:

<soap:Envelope> 
    <soap:Body> 
    <MethodResponse> 
     <MethodResult> 
     <diffgr:diffgram> 
      <NewDataSet> 
      <Table1 diffgr:id="Table1" msdata:rowOrder="0" diffgr:hasChanges="inserted"> 
       <Three>three</Three> 
      </Table1> 
      </NewDataSet> 
     </diffgr:diffgram> 
     </MethodResult> 
    </MethodResponse> 
    </soap:Body> 
</soap:Envelope> 

यह एक DiffGram, Microsoft .NET का हिस्सा है।Table1 पर जाने के लिए आप Find विधि का उपयोग कर सकते हैं। Decode और DecodeElement विधि स्लाइस पर भी काम करता है। तो में NewDataSet में एक से अधिक परिणाम होने पर आप पास कर सकते हैं।

मैं ज़िप्पर से सहमत हूं कि SOAP चूसता है। लेकिन दुर्भाग्यवश बहुत से उद्यम SOAP का उपयोग करते हैं, और आपको कभी-कभी इन API का उपयोग करने के लिए मजबूर किया जाता है। Xmlutil पैकेज के साथ मैं काम करने के लिए थोड़ा कम दर्दनाक बनाने की उम्मीद करता हूं।

Answer 3

बेस्ट विकल्प gsoap जो एक सी डबल्यूएसडीएल ग्राहक पैदा करता है का उपयोग करने के लिए और फिर वहाँ अभी भी जाओ अपने आप में कुछ भी नहीं है जबकि cgo

Answer 4

के साथ जाने के माध्यम से है कि ग्राहक का उपयोग है, वहाँ gowsdl है। अब तक, ऐसा लगता है कि कई एसओएपी सेवाओं के साथ इंटरफेस करने के लिए मेरे लिए काफी अच्छा काम है।

मैं एसओएपी प्रॉक्सी का उपयोग नहीं करता, जो मुझे विश्वास है कि यह समर्थन नहीं करता है, लेकिन gowsdl डब्लूएसडीएल से मार्शल अनुरोधों और अनमर्शल प्रतिक्रियाओं के लिए आवश्यक स्ट्रक्चर और कोड उत्पन्न करता है - एक बड़ी जीत।

Answer 5

wsdl-go भी है।
लेकिन मैंने इसका उपयोग नहीं किया है, इसलिए मैं वास्तव में नहीं कह सकता।