golang web学习随便记7-XML、JSON、Web服务

已于 2023-06-01 13:33:17 修改
阅读量581 收藏
点赞数
文章标签： 前端 json 学习
于 2023-05-18 14:42:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sjg20010414/article/details/130745516
版权

XML解析与生成

Unmarshal方式解析

xml的解析比json复杂，最起码xml在元素的属性中也能蕴藏信息。下面是一个xml文件post1.xml：

<?xml version="1.0" encoding="utf-8" ?>
<post id="1">
    <content>你好，Golang</content>
    <author id="2">张三</author>
</post>

表面上看，上述xml就是外层元素post里面有两个子元素content和author，但post和author都是带有id属性的，其实这意味着author有2项信息，不能用一个字段表达，所以，下面的代码为author定义了结构体。

package main

import (
	"encoding/xml"
	"fmt"
	"io/ioutil"
	"os"
)

type Post struct {
	XMLName xml.Name `xml:"post"`      // 元素名
	Id      string   `xml:"id,attr"`   // 元素的属性，模式标志 attr
	Content string   `xml:"content"`   // “常规”子元素
	Author  Author   `xml:"author"`    // 复合型子元素
	Xml     string   `xml:",innerxml"` // 元素内部的原始xml，模式标志 innerxml
}

type Author struct {
	Id   string `xml:"id,attr"`
	Name string `xml:",chardata"` // 元素的字符数据，模式标志 chardata
}

func main() {
	xmlFile, err := os.Open("post1.xml")
	if err != nil {
		fmt.Println("打开xml文件错误：", err)
		return
	}
	defer xmlFile.Close()
	xmlData, err := ioutil.ReadAll(xmlFile)
	if err != nil {
		fmt.Println("读取xml数据错误：", err)
		return
	}
	var post Post
	xml.Unmarshal(xmlData, &post)
	fmt.Println(post)
}

运行后输出结构为：

sjg@sjg-PC:~/go/src/xml$ go run .
{{ post} 1 你好，Golang {2 张三} 
    <content>你好，Golang</content>
    <author id="2">张三</author>
}

我们修改一下post1.xml为以下post2.xml，设想返回该帖子时同时返回了对应的2条评论：

<?xml version="1.0" encoding="utf-8" ?>
<post id="1">
    <content>你好，Golang</content>
    <author id="2">张三</author>
    <comments>
        <comment id="1">
            <content>C++才是好语言</content>
            <author id="3">李四</author>
        </comment>
        <comment id="2">
            <content>Rust比C++好</content>
            <author id="4">王五</author>
        </comment>        
    </comments>
</post>

在修改解析代码前，我们先需要考虑：是否需要为comments元素定义一个结构体，然后再为comment元素定义一个结构体，前者是后者的列表？更广泛的，我们是否必须定义上级元素才能获取到下一级元素？答案是否定的。我们可以使用`xml:"a>b>c"`这样的结构标签实现不指定树状结构的情况下直接获取指定的XML元素（即跳过中间元素a和b，直接获取c）。代码添加或修改如下：

// ....................................................
type Post struct {
    // ...................................
	Xml      string    `xml:",innerxml"` // 元素内部的原始xml，模式标志 innerxml
	Comments []Comment `xml:"comments>comment"`
}

type Author struct {
    // ...................................
}

type Comment struct {
	Id      string `xml:"id,attr"`
	Content string `xml:"content"`
	Author  Author `xml:"author"`
}

func main() {
	xmlFile, err := os.Open("post2.xml")
	// ......................................
}

注意上面对列表的处理。结果输出为：

sjg@sjg-PC:~/go/src/xml$ go run .
{{ post} 1 你好，Golang {2 张三} 
    <content>你好，Golang</content>
    <author id="2">张三</author>
    <comments>
        <comment id="1">
            <content>C++才是好语言</content>
            <author id="3">李四</author>
        </comment>
        <comment id="2">
            <content>Rust比C++好</content>
            <author id="4">王五</author>
        </comment>        
    </comments>
 [{1 C++才是好语言 {3 李四}} {2 Rust比C++好 {4 王五}}]}

Decoder方式解析

unmarshal这种方式可以一次性获取所有信息，但这种方式适合体积不太大的xml。对于大个头xml，我们需要使用 Decoder 来手动解码：

//  ..........................
	defer xmlFile.Close()

	decoder := xml.NewDecoder(xmlFile)
	for {
		t, err := decoder.Token()
		if err == io.EOF {
			break
		}
		if err != nil {
			fmt.Println("解码 xml 到令牌出错：", err)
			return
		}
		switch se := t.(type) {        // 判断令牌类型
		case xml.StartElement:        // 是xml某个元素起始标签
			if se.Name.Local == "comment" {  // 元素名为 comment
				var comment Comment
				decoder.DecodeElement(&comment, &se)
				fmt.Println(comment)
			}
		}
	}
}

sjg@sjg-PC:~/go/src/xml$ go run .
{1 C++才是好语言 {3 李四}}
{2 Rust比C++好 {4 王五}}

Marshal方式生成

要生成xml比解析要容易一些，并且也有2种方式：marshal方式或者encoder方式

// .............结构体与前面的代码相同....................

func main() {
	post := Post{
		Id:      "1",
		Content: "你好，Golang",
		Author: Author{
			Id:   "2",
			Name: "张三",
		},
		Comments: []Comment{
			{
				Id:      "1",
				Content: "C++才是好语言",
				Author: Author{
					Id:   "3",
					Name: "李四",
				},
			},
			{
				Id:      "2",
				Content: "Rust比C++好",
				Author: Author{
					Id:   "4",
					Name: "王五",
				},
			},
		},
	}
	output, err := xml.MarshalIndent(&post, "", "    ") // 用 Marshal 则不缩进
	if err != nil {
		fmt.Println("列集到xml出错：", err)
		return
	}
	err = ioutil.WriteFile("post.xml", []byte(xml.Header+string(output)), 0644)
	if err != nil {
		fmt.Println("写入xml文件出错：", err)
		return
	}
}

生成的文件带了缩进，这里不再列出。

encoder方式生成

下面改写的代码，是用编码器方式生成xml文件：

	post := Post{
//  ..........................................
    }
	xmlFile, err := os.Create("post2.xml")
	if err != nil {
		fmt.Println("创建xml文件出错：", err)
		return
	}
	xmlFile.WriteString(xml.Header)
	encoder := xml.NewEncoder(xmlFile)
	encoder.Indent("", "\t")
	err = encoder.Encode(&post)
	if err != nil {
		fmt.Println("编码xml到文件出错：", err)
		return
	}

JSON生成与解析

对于JSON，我们先来看如何创建。同样，我们可以用marshal方式或者encoder方式。

Marshal方式生成

下面是marshal方式生成JSON，不过我们先需要适当改造前述代码中的结构体，使它们符合JSON标签的格式（JSON标签比xml简单些，也不需要头部声明，本身结构体赋值还和JSON数据很像）：

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
)

type Post struct {
	Id       int       `json:"id"`
	Content  string    `json:"content"`
	Author   Author    `json:"author"`
	Comments []Comment `json:"comments"`
}

type Author struct {
	Id   int    `json:"id"`
	Name string `json:"name"`
}

type Comment struct {
	Id      int    `json:"id"`
	Content string `json:"content"`
	Author  Author `json:"author"`
}

func main() {
	post := Post{
		Id:      1,
		Content: "你好，Golang",
		Author: Author{
			Id:   2,
			Name: "张三",
		},
		Comments: []Comment{
			{
				Id:      1,
				Content: "C++才是好语言",
				Author: Author{
					Id:   3,
					Name: "李四",
				},
			},
			{
				Id:      2,
				Content: "Rust比C++好",
				Author: Author{
					Id:   4,
					Name: "王五",
				},
			},
		},
	}
	output, err := json.MarshalIndent(&post, "", "\t")
	if err != nil {
		fmt.Println("列集到JSON时出错：", err)
		return
	}
	err = ioutil.WriteFile("post.json", output, 0644)
	if err != nil {
		fmt.Println("写入JSON到文件出错：", err)
		return
	}
}

encoder方式生成

使用编码方式生成JSON的代码：

	jsonFile, err := os.Create("post.json")
	if err != nil {
		fmt.Println("创建JSON文件出错：", err)
		return
	}
	encoder := json.NewEncoder(jsonFile)
	encoder.SetIndent("", "\t")
	err = encoder.Encode(&post)
	if err != nil {
		fmt.Println("编码JSON到文件出错：", err)
		return
	}

解析JSON也是两种方式：unmarshal或decoder。一般地Body，对于流式输入（如http.Request的），用解码方式较好；对于字符串或者内存的JSON数据，用unmarshal更好。

Unmarshal方式解析

// .................................................
func main() {
	jsonFile, err := os.Open("post.json")
	if err != nil {
		fmt.Println("打开JSON文件出错：", err)
		return
	}
	defer jsonFile.Close()
	jsonData, err := ioutil.ReadAll(jsonFile)
	if err != nil {
		fmt.Println("读取JSON数据出错：", err)
		return
	}

	var post Post
	json.Unmarshal(jsonData, &post)
	fmt.Println(post)
}

decoder方式解析

// ..............................................
	defer jsonFile.Close()
	decoder := json.NewDecoder(jsonFile)
	for {
		var post Post
		err := decoder.Decode(&post)
		if err == io.EOF {
			break
		}
		if err != nil {
			fmt.Println("解码JSON出错：", err)
			return
		}
		fmt.Println(post)
	}
}

Web服务

下面我们仅就posts表来编写web服务：需要准备好mariadb 10.3数据库，另外，基本的表操作代码基本上是拷贝 golang web学习随便记4-内存、文件、数据库_sjg20010414的博客-CSDN博客 一文中的，只是 Post 结构体添加JSON标签。下面是main包中的data.go文件：

package main

import (
	"database/sql"
	"log"

	_ "github.com/go-sql-driver/mysql"
)

type Post struct {
	Id      int    `json:"id"`
	Content string `json:"content"`
	Author  string `json:"author"`
}

var Db *sql.DB

func init() { // 此 init 不显式调用，自动隐式调用，实现初始化全局变量 Db
	var err error
	Db, err = sql.Open("mysql", "gwp:dbpassword@tcp(172.17.0.1:3306)/gwp?charset=utf8mb4,utf8")
	if err != nil {
		panic(err)
	}
}

func Posts(limit int) (posts []Post, err error) {
	rows, err := Db.Query("SELECT id, content, author FROM posts LIMIT ?", limit) // Query(..) 预期返回多行结果集
	if err != nil {
		return
	}
	for rows.Next() { // 用循环遍历多行结果集
		post := Post{}
		err = rows.Scan(&post.Id, &post.Content, &post.Author) // Scan(..) 将结果集当前列值绑定到变量
		if err != nil {
			return
		}
		posts = append(posts, post) // 结果依次放入切片 posts
	}
	rows.Close() // 关闭结果集，清理内存
	return
}

func GetPost(id int) (post Post, err error) {
	post = Post{}
	err = Db.QueryRow("SELECT id, content, author FROM posts WHERE id = ?", id). // QueryRow(..) 预期返回单行结果集
											Scan(&post.Id, &post.Content, &post.Author) // pgsql 可以 RETURNING id
	return
}

func (post *Post) Create() (err error) {
	sql := "INSERT INTO posts (content, author) VALUES (?, ?)"
	stmt, err := Db.Prepare(sql) // 对于插入使用准备语句
	if err != nil {
		log.Fatal(err)
		return
	}
	defer stmt.Close()

	// err = stmt.QueryRow(post.Content, post.Author).Scan(&post.Id)  // pgsql 可以一步设置 post.id
	if result, err := stmt.Exec(post.Content, post.Author); err != nil { // Exec(..)返回执行结果
		log.Fatal(err)
	} else {
		if last_insert_id, err := result.LastInsertId(); err != nil {
			log.Fatal(err)
		} else {
			post.Id = int(last_insert_id) // Mariadb/MySQL应该支持执行结果的 LastInsertId()
		}
	}
	return
}

func (post *Post) Update() (err error) {
	_, err = Db.Exec("UPDATE posts SET content = ?, author = ? WHERE id = ?",
		post.Content, post.Author, post.Id)
	return
}

func (post *Post) Delete() (err error) {
	_, err = Db.Exec("DELETE FROM posts WHERE id = ?", post.Id)
	return
}

下面是main包中的main.go文件：

package main

import (
	"encoding/json"
	"net/http"
	"path"
	"strconv"
)

func main() {
	server := http.Server{
		Addr: "127.0.0.1:8088",
	}
	http.HandleFunc("/post/", handleRequest)
	http.HandleFunc("/posts/", handleList)
	server.ListenAndServe()
}

func handleRequest(w http.ResponseWriter, r *http.Request) {
	var err error
	switch r.Method {
	case "GET":
		err = handleGet(w, r)
	case "POST":
		err = handlePost(w, r)
	case "PUT":
		err = handlePut(w, r)
	case "DELETE":
		err = handleDelete(w, r)
	}
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

func handleGet(w http.ResponseWriter, r *http.Request) (err error) {
	id, err := strconv.Atoi(path.Base(r.URL.Path)) // 路径中最后一个元素转换成整数
	if err != nil {
		return
	}
	post, err := GetPost(id)
	if err != nil {
		return
	}
	output, err := json.MarshalIndent(&post, "", "\t")
	if err != nil {
		return
	}
	w.Header().Set("Content-Type", "application/json")
	w.Write(output)
	return
}

func handlePost(w http.ResponseWriter, r *http.Request) (err error) {
	len := r.ContentLength
	body := make([]byte, len)
	r.Body.Read(body)
	var post Post
	json.Unmarshal(body, &post)
	err = post.Create()
	if err != nil {
		return
	}
	w.WriteHeader(200)
	return
}

func handlePut(w http.ResponseWriter, r *http.Request) (err error) {
	id, err := strconv.Atoi(path.Base(r.URL.Path)) // 路径中最后一个元素转换成整数
	if err != nil {
		return
	}
	post, err := GetPost(id)
	if err != nil {
		return
	}
	len := r.ContentLength
	body := make([]byte, len)
	r.Body.Read(body)
	json.Unmarshal(body, &post)
	err = post.Update()
	if err != nil {
		return
	}
	w.WriteHeader(200)
	return
}

func handleDelete(w http.ResponseWriter, r *http.Request) (err error) {
	id, err := strconv.Atoi(path.Base(r.URL.Path)) // 路径中最后一个元素转换成整数
	if err != nil {
		return
	}
	post, err := GetPost(id)
	if err != nil {
		return
	}
	err = post.Delete()
	if err != nil {
		return
	}
	w.WriteHeader(200)
	return
}

func handleList(w http.ResponseWriter, r *http.Request) {
	posts, err := Posts(10)
	if err != nil {
		return
	}
	output, err := json.MarshalIndent(&posts, "", "\t")
	if err != nil {
		return
	}
	w.Header().Set("Content-Type", "application/json")
	w.Write(output)
	return
}

从 docker 启动 mariadb数据库，go get github.com/go-sql-driver/mysql 添加依赖包，然后 go run .运行服务。我们用 curl 来测试各项服务：

sjg@sjg-PC:~$ curl -i -X POST -H "Content-Type: application/json" -d '{"content":"我的第一条帖子","author":"赵六"}' http://127.0.0.1:8088/post/
HTTP/1.1 200 OK
Date: Thu, 18 May 2023 08:50:42 GMT
Content-Length: 0

sjg@sjg-PC:~$ curl -i -X GET http://127.0.0.1:8088/posts/
HTTP/1.1 200 OK
Content-Type: application/json
Date: Thu, 18 May 2023 08:52:35 GMT
Content-Length: 316

[
        {
                "id": 1,
                "content": "你好， C++! 08:33:04",
                "author": "李四"
        },
        {
                "id": 2,
                "content": "你好， C++! 08:46:48",
                "author": "李四"
        },
        {
                "id": 3,
                "content": "你好， C++! 08:51:08",
                "author": "李四"
        },
        {
                "id": 4,
                "content": "我的第一条帖子",
                "author": "赵六"
        }
]
sjg@sjg-PC:~$ curl -i -X GET http://127.0.0.1:8088/post/4
HTTP/1.1 200 OK
Content-Type: application/json
Date: Thu, 18 May 2023 08:53:28 GMT
Content-Length: 70

{
        "id": 4,
        "content": "我的第一条帖子",
        "author": "赵六"
}
sjg@sjg-PC:~$  curl -i -X PUT -H "Content-Type: application/json" -d '{"content":"我的第一条帖子（修改版）","author":"赵六"}' http://127.0.0.1:8088/post/4
HTTP/1.1 200 OK
Date: Thu, 18 May 2023 08:55:08 GMT
Content-Length: 0

sjg@sjg-PC:~$ curl -i -X DELETE http://127.0.0.1:8088/post/3
HTTP/1.1 200 OK
Date: Thu, 18 May 2023 08:56:18 GMT
Content-Length: 0

最后的结果是：

sjg@sjg-PC:~$ curl -i -X GET http://127.0.0.1:8088/posts/HTTP/1.1 200 OK
Content-Type: application/json
Date: Thu, 18 May 2023 08:56:59 GMT
Content-Length: 252

[
        {
                "id": 1,
                "content": "你好， C++! 08:33:04",
                "author": "李四"
        },
        {
                "id": 2,
                "content": "你好， C++! 08:46:48",
                "author": "李四"
        },
        {
                "id": 4,
                "content": "我的第一条帖子（修改版）",
                "author": "赵六"
        }
]

sjg20010414
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
golang xml和json的解析与生成
weixin_33901926的博客
01-21 363
golang中解析xml时我们通常会创建与之对应的结构体，一层层嵌套，完成复杂的xml解析。 package main; import ( "encoding/xml" "fmt" ) //我们通过定义一个结构体，来解析xml //注意，结构体中的字段必须是可导出的 type Books struct { //如果有类型为xml.Name的XMLName字段，则...
Golang创建XML
Map的博客
06-02 1373
package main import ( "encoding/xml" "fmt" "io/ioutil" ) type Post struct { XMLName xml.Name `xml:"post"` Id string `xml:"id,attr"` Content string `xml:"content"` Author Author `xml:"author"` } type Author struct { Id string `xml:.
Go语言开发中API 返回Xml数据实例
Json的知识梦工厂
02-19 850
GO交流群：874512552。 //返回xml type xmlIp struct { XmlList []xmlList } type xmlList struct { Ip string `xml:"ip"` Port string `xml:"port"` Country string `xml:"country"` City string `xml:"...
Go基础学习记录之如何解析并生成XML
weixin_34211761的博客
11-07 212
XML XML是Web服务中常用的数据通信格式。今天，它在Web开发中扮演着越来越重要的角色。本次分享将介绍如何通过Go的标准库使用XML。我不会尝试教授XML的语法或约定。你可以去阅读有关XML本身的更多文档。我只关注如何在Go中编码和解码XML文件。假设您在IT中工作，并且您必须处理以下XML配置文件： <?xml versio...
golang接收post接收xml或者json数据
淡淡忧桑
12-01 1万+
今天测试用GO语言链接微信公众平台，一切都很顺利，但是发来的XML数据一直收不到。 将所有有可能的函数和值都测试过了，例如Request.Form，Request.PostForm，Request.MultiPartForm等都没有…… golang接收post接收xml或者json数据 Request.Body里的数据是i
golang web学习随便记8-应用测试
sjg20010414的专栏
06-01 601
上述测试函数中，用 testing.Short() 判断测试是否处于短时模式，如果处于短时模式，就跳过当前测试函数。结尾，一般测试文件名字和被测试源码文件是对应的（如 server_test.go 文件测试的是 server.go 文件中的函数或功能），并且。decoder方式解析），把解码的功能打包到函数 decode 中，然后函数 decode 作为我们测试的目标函数。运行测试用例的方式类似如下：（显然，我们可以从 VSCode等 IDE 直接点击函数左侧三角形来运行单个测试函数）
golang web学习随便记3-响应有关
sjg20010414的专栏
05-06 265
理解这一点的要点在于，http/server.go文件中定义的 ResponseWriter 是一个 interface 而非具体化的结构体，该接口约定了3个方法：Write、WriteHeader、Header，而 Response 类型在实现接口方法时，接收者使用的是指针式接收者，从而在调用接口方法时，可以用“值”形式的语法，而作为其他函数的参数或者赋值时的右值时，必须使用地址。中 方法接收者T和*T的差别）。前一篇中的例子已经“庞大”，我们这篇将编写新的例子来学习服务器的响应和cookie。
svc：Web API服务
02-10
在本文中，我们将深入探讨Web API服务的概念、Go语言（Golang）在构建Web API服务中的应用，以及如何使用Go创建一个SVC（服务）。 Web API是一种允许应用程序通过HTTP协议进行通信的接口。它们主要用于构建分布式...
反向代理，可提高Web应用程序的性能！-Golang开发
05-26
缩小CSS，JS，HTML，XML，JSON。 Gzip每个缩小的文件。 在Lightify上合并并内联自托管CSS，js让我们动态地最小化，压缩和合并静态文件。 特色简单而愚蠢。 缩小CSS，JS，HTML，XML，JSON。 Gzip每个缩小的文件。 ...
trygo:Golang框架的http和Web服务
05-25
trygo 是基于Golang的http、web服务框架。此框架的目标并不是想做一个大而全的web服务容器，它主要用于开发底层高性能高可靠性的http服务。支持如下特性：RESTful,MVC,类型内方法路由、正则路由,JSON/JSON(JQuery...
render：Go包，用于轻松呈现JSON，XML，二进制数据和HTML模板响应
02-02
渲染 Render是一个软件包，提供了轻松呈现JSON，XML，文本，二进制数据和HTML模板的功能。 该程序包基于工作。区块弃用通知Go 1.6引入了一个新的动作。 这与Render包含的block模板功能冲突。 为了提供简单的迁移路径...
Golang标准库-180910.7z
09-11
9. **JSON和XML处理**：encoding/json和encoding/xml包提供了序列化和反序列化这两种常用数据格式的功能。 10. **数学和随机数**：math和math/rand包提供了数学运算和随机数生成的函数。 11. **命令行参数处理**：...
Golang发送post表单请求
热门推荐
闷骚的Gopher
04-03 2万+
先写一个可以接收post请求的服务器： package main import ( "fmt" "net/http" ) func main() { http.HandleFunc("/postpage", func(w http.ResponseWriter, r *http.Request) { //接受post请求，然后打印表单中key和value字段的值 if r.Me
前端技术学习记录-基础知识（二）JavaScript基本语法
最新发布
adanjeep的博客
07-11 191
/ 声明一个String类型的变量name name = "Alice";// 初始化变量name int age;// 声明一个int类型的变量age age = 25;// 初始化变量age。静态强类型：Java语言，在申明变量时，需要明确定于变量的类型。对明确申明的变量，需要做强制转换，才会发生变化，否则不变。//数字 a = "hahaha";//字符串 </script>动态弱类型语言：变量可以存放在不同类型的值（动态）=== 比较相等（不会进行隐式类型转换）>>> 无符号右移（逻辑右移）
golang web服务器
09-14
Golang Web服务器是使用Go语言编写的网络服务器，它可以接收HTTP请求并返回相应的响应。在Golang中，我们可以使用标准库中的"net/http"包来实现Web服务器功能。 下面是一个简单的Golang Web服务器的示例代码： ``` package main import ( "fmt" "log" "net/http" ) // 定义一个处理函数，处理"/hello"路径的请求 func HelloWorld(w http.ResponseWriter, r *http.Request) { _, err := fmt.Fprintf(w, "Hello World!") if err != nil { log.Panic(err) } } func main() { // 设置访问路由，当URL中的路径为"/hello"时，服务器调用HelloWorld函数作为处理函数 http.HandleFunc("/hello", HelloWorld) // 监听端口8080，并启动服务器 if err := http.ListenAndServe(":8080", nil); err != nil { log.Panic(err) } } ``` 以上代码创建了一个处理函数`HelloWorld`，当访问路径为"/hello"时，服务器会调用该函数处理请求，并返回"Hello World!"作为响应。 通过运行该程序，并在浏览器中输入"http://127.0.0.1:8080/hello"，你将会在浏览器中看到"Hello World!"的结果。 请注意，这只是一个简单的示例，你可以根据自己的需求来编写更复杂的Web服务器。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值