Golang xml.Unmarshal函数代码示例

func DecodeClientToClientMessage(msg []byte) (Type, *UserToUserPackage, error) {
	var m ClientToClientMessage
	err := xml.Unmarshal(msg, &m)
	if err != nil {
		return UNKNOWN_T, nil, err
	}
	switch m.Type {
	case VOTE:
		var v VoteMessage
		err := xml.Unmarshal(msg, &v)
		if err != nil {
			return UNKNOWN_T, nil, errors.New("Couldn't decode the message: Broadcast or direct message malformed")
		}
		uu := UserToUserPackage{
			VoteMessage: &v,
		}
		return VOTE_T, &uu, nil
	case COORDINATOR:
		var v CoordinatorMessage
		err := xml.Unmarshal(msg, &v)
		if err != nil {
			return UNKNOWN_T, nil, errors.New("Couldn't decode the message: Broadcast or direct message malformed")
		}
		uu := UserToUserPackage{
			CoordinatorMessage: &v,
		}
		return COORDINATOR_T, &uu, nil
	}
	return UNKNOWN_T, nil, errors.New("Couldn't decode the message: No matching type")
}

func RegisterDevice(token string, customData string, userId string,
	userSecret string, region string, applicationArn string) (arn string, err error) {
	values := url.Values{}
	values.Set("Action", "CreatePlatformEndpoint")
	values.Set("CustomUserData", customData)
	values.Set("Token", token)
	values.Set("PlatformApplicationArn", applicationArn)
	values.Set("Timestamp", time.Now().UTC().Format(time.RFC3339))

	response, err := makeRequest("http://sns."+region+".amazonaws.com/",
		values, userId, userSecret, region)

	if err != nil {
		return "", err
	}

	defer response.Body.Close()

	if response.StatusCode != 200 {
		content, _ := ioutil.ReadAll(response.Body)
		var errorResponse aws.ErrorResponse
		xml.Unmarshal(content, &errorResponse)
		return "", errors.New("Unable to register device. " + errorResponse.Error.Code + ": " + errorResponse.Error.Message)
	} else {
		content, _ := ioutil.ReadAll(response.Body)
		var createResponse CreateResponse
		xml.Unmarshal(content, &createResponse)
		return createResponse.CreatePlatformEndpointResult.EndpointArn, nil
	}
}

func (client *Client) loadCloudFormationResource(action string, params Values, i interface{}) error {
	req, e := client.signedCloudFormationRequest(action, params)

	rsp, e := httpClient.Do(req)
	if e != nil {
		return e
	}
	defer rsp.Body.Close()
	b, e := ioutil.ReadAll(rsp.Body)
	if e != nil {
		return e
	}
	switch rsp.StatusCode {
	case 404:
		return ErrorNotFound
	case 200:
		if i != nil {
			return xml.Unmarshal(b, i)
		}
		return nil
	default:
		ersp := &ErrorResponse{}
		dbg.Printf("ERROR=%q", string(b))
		e = xml.Unmarshal(b, ersp)
		if e != nil {
			return fmt.Errorf("expected status 2xx but got %s (%s)", rsp.Status, string(b))

		}
		if strings.Contains(ersp.Error.Message, "does not exist") {
			return ErrorNotFound
		}
		return fmt.Errorf(ersp.Error.Message)
	}
}

//解析配置文件内容至内存中
func Analyse() error {

	content, err := ioutil.ReadFile("../etc/config.xml")

	if err != nil {
		Log.Error(err)
		return err
	}

	err = xml.Unmarshal(content, &config)
	if err != nil {
		Log.Error(err)
		return err
	}

	content, err = ioutil.ReadFile("../etc/entity.xml")
	err = xml.Unmarshal(content, &entitys)

	if err != nil {
		Log.Error(err)
		return err
	}

	content, err = ioutil.ReadFile("../etc/url.xml")
	err = xml.Unmarshal(content, &urls)

	if err != nil {
		Log.Error(err)
		return err
	}

	return nil
}

func WexinHandler(resp http.ResponseWriter, req *http.Request) {

	log.Println("method:", req.Method)
	if req.Method == "GET" {
		weixinValid(resp, req)
	} else {

		data, err := ioutil.ReadAll(req.Body)
		if nil != err {
			log.Println("read body err:", err)
			return
		}
		log.Println("data:", string(data))

		request := &entry.ReqMessage{}
		er := xml.Unmarshal(data, request)
		if nil != er {
			log.Println("decode body err:", er)
			return
		}

		event := request.Event
		msgType := request.MsgType
		ch := make(chan interface{})
		defer close(ch)
		if "event" == msgType && event == "subscribe" {
			//添加关注事件
			go subEventProcess(*request, ch)

		} else if "event" == msgType && event == "unsubscribe" {
			//取消订阅
			go unsubEventProcess(*request, ch)

		} else if "location" == msgType {
			//地理位置
			var msg entry.LocRequest
			err := xml.Unmarshal(data, &msg)
			if nil != err {
				log.Println("decode txt request body err:", err)
				return
			}

			go locMessageProcess(msg, ch)

		} else {
			var msg entry.TxtRequest
			err := xml.Unmarshal(data, &msg)
			if nil != err {
				log.Println("decode txt request body err:", er)
				return
			}

			go txtMessageProcess(msg, ch)
		}

		brespons, _ := xml.Marshal(<-ch)
		log.Println(string(brespons))
		resp.Write(brespons)
	}
}

func (c *AliOSSClient) GetLocationOfBucket(bucket string) (string, error) {
	uri := fmt.Sprintf("/%s/?location", bucket)
	query := make(map[string]string)
	query["location"] = ""
	s := &oss_agent{
		AccessKey:            c.AccessKey,
		AccessKeySecret:      c.AccessKeySecret,
		Verb:                 "GET",
		Url:                  fmt.Sprintf("http://%s.%s", bucket, c.EndPoint),
		CanonicalizedHeaders: make(map[string]string),
		CanonicalizedUri:     uri,
		CanonicalizedQuery:   query,
		Content:              &bytes.Reader{},
		ContentType:          "",
		Debug:                c.Debug,
		logger:               c.logger,
	}

	v := ""
	e := &AliOssError{}
	resp, xml_result, err := s.send_request(false)
	if err != nil {
		return "", err
	}
	if resp.StatusCode == 200 {
		xml.Unmarshal(xml_result, &v)
		return v, nil
	} else {
		xml.Unmarshal(xml_result, e)
		return "", e
	}
}

func callRet(ret interface{}, resp *http.Response) (code int, err error) {
	var (
		b  []byte
		er errRet
	)
	code = resp.StatusCode
	if code/100 == 2 {
		if ret == nil || resp.ContentLength == 0 {
			return
		}
		b, err = ioutil.ReadAll(resp.Body)
		if err != nil {
			return
		}
		ct := resp.Header.Get("Content-Type")
		if strings.Contains(ct, "application/json") {
			err = json.Unmarshal(b, ret)
		} else { // default decoding
			err = xml.Unmarshal(b, ret)
		}
	} else {
		if resp.ContentLength == 0 {
			return
		}
		b, err = ioutil.ReadAll(resp.Body)
		if err != nil {
			return
		}
		if err = xml.Unmarshal(b, &er); err != nil {
			return
		}
		err = errors.New(er.Code)
	}
	return
}

func main() {
	data, err := ioutil.ReadFile("page.xml")
	if nil != err {
		fmt.Println(err)
	}
	{
		v := new(BlogContainer)
		err = xml.Unmarshal(data, v)
		if nil != err {
			fmt.Println(err)
			return
		}

		fmt.Printf("XMLName: %#v\n", v.XMLName)
		fmt.Printf("XMLName: %#v\n", v.Chapter.XMLName)
		fmt.Printf("Title: %v\n", v.Chapter.Title)
		for i, x := range v.Chapter.Name {
			fmt.Printf("Chapter %d: %v\n", i, x)
		}
	}
	{
		v := new(Blog)
		err = xml.Unmarshal(data, v)
		if nil != err {
			fmt.Println(err)
			return
		}
		fmt.Println(v.Title)
		fmt.Println(v.Tags)
		fmt.Println(v.Chapters)
	}
}

func (r *Request) cachingReadEntity(contentType string, entityPointer interface{}) (err error) {
	var buffer []byte
	if r.bodyContent != nil {
		buffer = *r.bodyContent
	} else {
		buffer, err = ioutil.ReadAll(r.Request.Body)
		if err != nil {
			return err
		}
		r.bodyContent = &buffer
	}
	if strings.Contains(contentType, MIME_XML) {
		return xml.Unmarshal(buffer, entityPointer)
	}
	if strings.Contains(contentType, MIME_JSON) {
		return json.Unmarshal(buffer, entityPointer)
	}
	if MIME_XML == defaultRequestContentType {
		return xml.Unmarshal(buffer, entityPointer)
	}
	if MIME_JSON == defaultRequestContentType {
		return json.Unmarshal(buffer, entityPointer)
	}
	return NewError(400, "Unable to unmarshal content of type:"+contentType)
}

func ReadCommandsFile(basedir string) (*CommandsXML, error) {
	commandsdata, err := ioutil.ReadFile(filepath.Join(basedir, "doc", "commands-xml", "commands.xml"))
	if err != nil {
		return nil, err
	}
	cs := &CommandsXMLSimple{}
	err = xml.Unmarshal(commandsdata, cs)
	if err != nil {
		return nil, err
	}

	c := &CommandsXML{}
	c.de = make(map[string]CommandsxmlCommand)
	c.en = make(map[string]CommandsxmlCommand)
	commandTranslationsEnDe = make(map[string]string)

	for _, v := range cs.Commands {
		commandTranslationsEnDe[v.En] = v.De
	}
	err = xml.Unmarshal(commandsdata, c)
	if err != nil {
		return nil, err
	}
	for _, v := range c.Commands {
		c.de[v.De] = v
		c.en[v.En] = v
	}
	return c, err
}

func ParseFileList(in io.Reader, out *FileListing) (err error) {
	defer func() { out.Name = out.Base }()
	data, err := ioutil.ReadAll(in)
	if err != nil {
		return
	}

	/* First, try just reading it */
	err = xml.Unmarshal(data, out)
	if err == nil {
		return
	}

	/* If that failed, then try to read in another charset. This happens because
	 * microdc2 is known to lie by saying that the content is utf-8 when it's
	 * actually iso-8859-1 */
	translator, err := charset.TranslatorFrom("iso-8859-1")
	if err != nil {
		return
	}
	_, data, err = translator.Translate(data, true)
	if err != nil {
		return
	}
	return xml.Unmarshal(data, out)
}

//get cores rule
func (c *AliOSSClient) GetCoreRule(bucket string) (*CORSConfiguration, error) {
	uri := fmt.Sprintf("/%s/?cors", bucket)
	query := make(map[string]string)
	header := make(map[string]string)
	query["cors"] = ""
	s := &oss_agent{
		AccessKey:            c.AccessKey,
		AccessKeySecret:      c.AccessKeySecret,
		Verb:                 "GET",
		Url:                  fmt.Sprintf("http://%s.%s", bucket, c.EndPoint),
		CanonicalizedHeaders: header,
		CanonicalizedUri:     uri,
		CanonicalizedQuery:   query,
		Content:              &bytes.Reader{},
		Debug:                c.Debug,
		logger:               c.logger,
	}

	v := &CORSConfiguration{}
	e := &AliOssError{}
	resp, xml_result, err := s.send_request(false)
	if err != nil {
		return nil, err
	}
	if resp.StatusCode/100 == 2 {
		xml.Unmarshal(xml_result, v)
		return v, nil
	} else {
		xml.Unmarshal(xml_result, e)
		return nil, e
	}
}

//Init multipart upload
func (c *AliOSSClient) GetInitMultipartUpload(bucket string, key string) (*MultiUploadInit, error) {
	uri := fmt.Sprintf("/%s/%s?uploads", bucket, key)
	query := make(map[string]string)
	header := make(map[string]string)
	query["uploads"] = ""
	s := &oss_agent{
		AccessKey:            c.AccessKey,
		AccessKeySecret:      c.AccessKeySecret,
		Verb:                 "POST",
		Url:                  fmt.Sprintf("http://%s.%s/%s", bucket, c.EndPoint, key),
		CanonicalizedHeaders: header,
		CanonicalizedUri:     uri,
		CanonicalizedQuery:   query,
		Content:              &bytes.Reader{},
		Debug:                c.Debug,
		logger:               c.logger,
	}

	v := &MultiUploadInit{}
	e := &AliOssError{}
	resp, xml_result, err := s.send_request(false)
	if err != nil {
		return nil, err
	}
	if resp.StatusCode/100 == 2 {
		xml.Unmarshal(xml_result, v)
		return v, nil
	} else {
		xml.Unmarshal(xml_result, e)
		return nil, e
	}
}

func main() {
	f, err := ioutil.ReadFile("example.xml")
	check(err)

	a := new(lib.Spells)

	err = xml.Unmarshal(f, &a)
	check(err)
	fmt.Printf("%+v", a)
	fmt.Println(" ")

	result, err := json.MarshalIndent(a, "", "  ")
	check(err)
	fmt.Printf("%+v", string(result))

	data := []byte("<cells><cell><name>Thomas</name></cell><cell><name>Janes</name></cell></cells>")

	b := new(Cells)

	err = xml.Unmarshal(data, &b)
	check(err)
	fmt.Printf("%+v", b)

	dataJson, err := json.MarshalIndent(b, "", "  ")
	check(err)
	fmt.Println(string(dataJson))

	c := new(TmpJson)

	err = json.Unmarshal(dataJson, &c)
	check(err)
	fmt.Printf("\n\n%+v", c)

}

func (c *AliOSSClient) CloseBucketLogging(name string) error {
	xml_content := `<?xml version="1.0" encoding="UTF-8"?><BucketLoggingStatus></BucketLoggingStatus>`
	uri := fmt.Sprintf("/%s/?logging", name)
	query := make(map[string]string)
	header := make(map[string]string)
	query["logging"] = ""

	s := &oss_agent{
		AccessKey:            c.AccessKey,
		AccessKeySecret:      c.AccessKeySecret,
		Verb:                 "PUT",
		Url:                  fmt.Sprintf("http://%s.%s", name, c.EndPoint),
		CanonicalizedHeaders: header,
		CanonicalizedUri:     uri,
		CanonicalizedQuery:   query,
		Content:              bytes.NewReader([]byte(xml_content)),
		ContentType:          "application/xml",
		Debug:                c.Debug,
		logger:               c.logger,
	}

	v := &BucketList{}
	e := &AliOssError{}
	resp, xml_result, err := s.send_request(false)
	if err != nil {
		return err
	}
	if resp.StatusCode/100 == 2 {
		xml.Unmarshal(xml_result, v)
		return nil
	} else {
		xml.Unmarshal(xml_result, e)
		return e
	}
}