十二、网络编程

最新推荐文章于 2022-02-15 11:20:33 发布
最新推荐文章于 2022-02-15 11:20:33 发布
阅读量226 收藏
点赞数
分类专栏： Golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zq9017197/article/details/87828785
版权

1.TCP编程

  • 服务器：
func main() {
	//指定服务器通信协议、IP地址、端口号
	listener, err := net.Listen("tcp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer listener.Close() //关闭

	//阻塞监听客户端连接请求
	conn, err := listener.Accept()
	if err != nil {
		fmt.Println(err)
		return
	}
	defer conn.Close() //关闭

	//读取客户端发送的数据
	buf := make([]byte, 4096)
	n, err := conn.Read(buf)
	if err != nil {
		fmt.Println(err)
		return
	}

	//处理数据
	fmt.Println("服务器：", string(buf[:n]))
	conn.Write([]byte("reply：" + string(buf[:n])))
}
  • 客户端：
func main() {
	//指定服务器通信协议、IP地址、端口号
	conn, err := net.Dial("tcp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer conn.Close()  //关闭

	//主动写数据给服务器
	conn.Write([]byte("hello world"))

	//接收服务器回发的数据
	buf := make([]byte, 4096)
	n, err := conn.Read(buf)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(string(buf[:n]))
}
1.1并发版本
  • 服务器：
func HandlerConnect(conn net.Conn) {
	defer conn.Close() //关闭
	// 获取连接的客户端 Addr
	addr := conn.RemoteAddr()
	fmt.Println(addr, ",客户端成功连接！")

	//循环读取客户端发送的数据
	buf := make([]byte, 4096)
	for {
		n, err := conn.Read(buf)
		data := string(buf[:n])
		if strings.HasPrefix(strings.ToLower(data), "exit") {
			fmt.Println("服务器检测到客户端[", addr, "]退出...")
			return
		} else if n == 0 {
			fmt.Println("服务器检测到客户端[", addr, "]已关闭...")
			return
		} else if err != nil {
			fmt.Println("conn.Read err:", err)
			return
		}

		//处理数据
		fmt.Println(addr, ",服务器读到数据：", data)
		conn.Write([]byte("reply:" + data))
	}
}

func main() {
	//创建监听套接字
	listener, err := net.Listen("tcp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("net.Listen err:", err)
		return
	}
	defer listener.Close() //关闭

	//监听客户端连接请求
	for {
		fmt.Println("服务器等待客户端连接...")
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("listener.Accept err:", err)
			return
		}

		//具体完成服务器和客户端的数据通信
		go HandlerConnect(conn)
	}
}
  • 客户端：
func main() {
	//主动发起连接请求
	conn, err := net.Dial("tcp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("net.Dial err:", err)
		return
	}
	defer conn.Close() //关闭

	// 获取用户键盘输入( stdin )，将输入数据发送给服务器
	go func() {
		buf := make([]byte, 4096)
		for {
			n, err := os.Stdin.Read(buf)
			if err != nil {
				fmt.Println("os.Stdin.Read err:", err)
				continue
			}
			//写给服务器, 读多少，写多少！
			conn.Write(buf[:n])
		}
	}()

	// 回显服务器回发的数据
	buf := make([]byte, 4096)
	for {
		n, err := conn.Read(buf)
		if n == 0 {
			fmt.Println("客户端检测到服务器已关闭...")
			return
		} else if err != nil {
			fmt.Println("conn.Read err:", err)
			return
		}
		fmt.Println(string(buf[:n]))
	}
}

2.UDP编程

  • 服务器
func main() {
	//组织一个udp地址结构
	srvAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("net.ResolveUDPAddr err:", err)
		return
	}
	fmt.Println("UDP服务器地址结构创建完成。")

	//创建用于通信的socket
	udpConn, err := net.ListenUDP("udp", srvAddr)
	if err != nil {
		fmt.Println("net.ListenUDP err:", err)
		return
	}
	defer udpConn.Close() //关闭
	fmt.Println("UDP服务器通信socket创建完成。")

	//读取客户端发送的数据
	buf := make([]byte, 4096)
	//返回3个值，分别是读取到的字节数、客户端的地址、error
	n, cltAddr, err := udpConn.ReadFromUDP(buf)
	if err != nil {
		fmt.Println("udpConn.ReadFromUDP err:", err)
		return
	}

	//模拟处理数据
	fmt.Printf("服务器读到 %v 的数据：%s\n", cltAddr, string(buf[:n]))
	//回写数据给客户端
	_, err = udpConn.WriteToUDP([]byte("replay:"+string(buf[:n])), cltAddr)
	if err != nil {
		fmt.Println("udpConn.WriteToUDP err:", err)
		return
	}
}
  • 客户端
  • 参考 TCP 客户端。net.Dial(“udp”, “server 的IP+port”)
func main() {
	//指定服务器通信协议、IP地址、端口号
	conn, err := net.Dial("udp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer conn.Close()  //关闭

	//主动写数据给服务器
	conn.Write([]byte("hello world"))

	//接收服务器回发的数据
	buf := make([]byte, 4096)
	n, err := conn.Read(buf)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(string(buf[:n]))
}
2.1并发版本
  • 服务器
  • UDP默认支持客户端并发访问，服务器处理 ReadFromUDP 和 WriteToUDP操作分开。提高并发效率。
func main() {
	//组织一个udp地址结构
	srvAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("net.ResolveUDPAddr err:", err)
		return
	}
	fmt.Println("UDP服务器地址结构创建完成。")

	//创建用于通信的socket
	udpConn, err := net.ListenUDP("udp", srvAddr)
	if err != nil {
		fmt.Println("net.ListenUDP err:", err)
		return
	}
	defer udpConn.Close() //关闭
	fmt.Println("UDP服务器通信socket创建完成。")

	//读取客户端发送的数据
	buf := make([]byte, 4096)
	for {
		//返回3个值，分别是读取到的字节数、客户端的地址、error
		n, cltAddr, err := udpConn.ReadFromUDP(buf)
		if err != nil {
			fmt.Println("udpConn.ReadFromUDP err:", err)
			return
		}

		//模拟处理数据
		fmt.Printf("服务器读到 %v 的数据：%s\n", cltAddr, string(buf[:n]))

		go func() {
			//回写数据给客户端
			_, err = udpConn.WriteToUDP([]byte("replay:"+string(buf[:n])), cltAddr)
			if err != nil {
				fmt.Println("udpConn.WriteToUDP err:", err)
				return
			}
		}()
	}
}
  • 客户端（参考TCP客户端）
func main() {
	//指定服务器通信协议、IP地址、端口号
	conn, err := net.Dial("udp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer conn.Close() //关闭

	//获取用户键盘输入数据
	go func() {
		buf := make([]byte, 4096)
		for {
			n, err := os.Stdin.Read(buf)
			if err != nil {
				fmt.Println("os.Stdin.Read err:", err)
				continue
			}
			//主动写数据给服务器
			conn.Write(buf[:n])
		}
	}()

	buf := make([]byte, 4096)
	for {
		//接收服务器回发的数据
		n, err := conn.Read(buf)
		if err != nil {
			fmt.Println(err)
			return
		}
		fmt.Println(string(buf[:n]))
	}
}

3.文件传输

  • 发送端:
func SendFile(conn net.Conn, filePath string) {
	//只读打开文件
	file, err := os.Open(filePath)
	if err != nil {
		fmt.Println("os.Open err:", err)
		return
	}
	defer file.Close()

	//从本地文件中读数据，写给接收端。读多少写多少
	buf := make([]byte, 4096)
	for {
		n, err := file.Read(buf)
		if err != nil {
			if err == io.EOF {
				fmt.Println("发送文件完毕...")
			} else {
				fmt.Println("file.Read err:", err)
			}
			return
		}
		//写到网络socket中
		_, err = conn.Write(buf[:n])
		if err != nil {
			fmt.Println("conn.Write err:", err)
			return
		}
	}
}

func main() {
	//go run Client.go D:\books\golang\netcat-win32-1.12.zip
	list := os.Args //获取命令行参数
	if len(list) != 2 {
		fmt.Println("格式为：go run xxx.go 文件绝对路径")
		return
	}

	//提取文件的绝对路径
	filePath := list[1]

	//提取文件名
	fileInfo, err := os.Stat(filePath)
	if err != nil {
		fmt.Println("os.Stat err:", err)
		return
	}
	fileName := fileInfo.Name()

	//主动发起连接请求
	conn, err := net.Dial("tcp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("net.Dial err:", err)
		return
	}
	defer conn.Close()

	//发送文件名给接收端
	_, err = conn.Write([]byte(fileName))
	if err != nil {
		fmt.Println("conn.Write err:", err)
		return
	}

	//读取服务器回发的数据
	buf := make([]byte, 4096)
	n, err := conn.Read(buf)
	if err != nil {
		fmt.Println("conn.Read err:", err)
		return
	}

	//判断是否收到服务器回发的“ok”
	data := string(buf[:n])
	if strings.HasPrefix(strings.ToLower(data), "ok") {
		//写文件内容给服务器
		SendFile(conn, filePath)
	}
}
  • 接收端
func RecvFile(conn net.Conn, fileName string) {
	//按照文件名创建新文件
	file, err := os.Create(fileName)
	if err != nil {
		fmt.Println("os.Create err:", err)
		return
	}
	defer file.Close()

	//从网络中读数据，写入本地文件
	buf := make([]byte, 4096)
	for {
		n, err := conn.Read(buf)
		if n == 0 {
			fmt.Println("接收文件完毕...")
			return
		} else if err != nil {
			fmt.Println("conn.Read err:", err)
			return
		}
		//写入本地文件，读多少写多少
		file.Write(buf[:n])
	}
}

func main() {
	//创建用户监听的socket
	listen, err := net.Listen("tcp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("net.Listen err:", err)
		return
	}
	defer listen.Close()

	//阻塞监听
	conn, err := listen.Accept()
	if err != nil {
		fmt.Println("listen.Accept err:", err)
		return
	}
	defer conn.Close()

	//获取文件名，保存
	buf := make([]byte, 4096)
	n, err := conn.Read(buf)
	if err != nil {
		fmt.Println("conn.Read err:", err)
		return
	}
	fileName := string(buf[:n])

	//会写ok给发送端
	_, err = conn.Write([]byte("ok"))
	if err != nil {
		fmt.Println("conn.Write err:", err)
		return
	}

	//获取文件内容
	RecvFile(conn, fileName)
}

4.HTTP编程

4.1http请求报文
  • 服务器代码：
func errFunc(info string, err error) {
	if err != nil {
		fmt.Println(info, err)
		os.Exit(1)
	}
}

func main() {
	listener, err := net.Listen("tcp", "127.0.0.1:8000")
	errFunc("net.Listen err:", err)
	defer listener.Close()

	conn, err := listener.Accept()
	errFunc("listener.Accept err:", err)
	defer conn.Close()

	buf := make([]byte, 4096)
	n, err := conn.Read(buf)
	if n == 0 {
		return
	}
	errFunc("conn.Read err:", err)
	fmt.Printf("|%s|\n", string(buf[:n]))
}
  • 把上面这段代码运行起来，然后在浏览器输入：http://127.0.0.1:8000/
  • 就可以在服务器控制台得到请求报文：
|GET /favicon.ico HTTP/1.1
Host: 127.0.0.1:8000
Connection: keep-alive
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Cookie: __guid=96992031.1246173382985738200.1550026754561.2637; monitor_count=2

|
4.2http响应报文
  • 服务代码：
func handler(resp http.ResponseWriter, req *http.Request){
	resp.Write([]byte("hello world"))
}

func main() {
	//注册回调函数，该回调函数会在服务器被访问时，自动调用。
	http.HandleFunc("/test.do", handler)

	//绑定服务器监听地址
	http.ListenAndServe("127.0.0.1:8000", nil)
}
  • 客户端代码：
func errFunc2(info string, err error) {
	if err != nil {
		fmt.Println(info, err)
		os.Exit(1)
	}
}

func main() {
	conn, err := net.Dial("tcp", "127.0.0.1:8000")
	errFunc2("net.Dial err:", err)
	defer conn.Close()

	httpRequest := "GET /test.do HTTP/1.1\r\nHost:127.0.0.1:8000\r\n\r\n"
	conn.Write([]byte(httpRequest))

	buf := make([]byte, 4096)
	n, err := conn.Read(buf)
	if n == 0 {
		return
	}
	errFunc2("conn.Read err:", err)
	fmt.Printf("|%s|\n", string(buf[:n]))
}

|HTTP/1.1 200 OK
Date: Wed, 13 Feb 2019 03:08:51 GMT
Content-Length: 11
Content-Type: text/plain; charset=utf-8

hello world|
4.3HTTP服务端
  • 用TCP来开发服务端，就是做web应用，类似发布到Tomcat上面那些。
  • 用TCP来开发客户端，就是做类似爬虫那些。
func myHandler(resp http.ResponseWriter, req *http.Request) {
	//从客户端读到的内容
	fmt.Println("Header:", req.Header)
	fmt.Println("URL:", req.URL)
	fmt.Println("Method:", req.Method)
	fmt.Println("Host:", req.Host)
	fmt.Println("RemoteAddr:", req.RemoteAddr)
	fmt.Println("Body:", req.Body)

	//写给客户端的数据内容
	url := req.URL.String()
	if "/test" == url {
		resp.Write([]byte("This Is A Web Server"))
	} else if "/hello" == url {
		resp.Write([]byte("Hello World"))
	} else {
		resp.Write([]byte("404 Page Not Found"))
	}
}

func main() {
	//注册回调函数，该回调函数会在服务器被访问时，自动调用。
	//指定"/"，则http://127.0.0.1:8000/* 都可以访问服务器
	//指定"/project/"，则http://127.0.0.1:8000/project/* 都可以访问服务器
	http.HandleFunc("/", myHandler)

	//绑定服务器监听地址
	http.ListenAndServe("127.0.0.1:8000", nil)
}
4.4HTTP客户端
func main() {
	//使用Get方法获取服务器响应包数据
	//resp, err := http.Get("http://www.baidu.com")
	resp, err := http.Get("http://127.0.0.1:8000/test")
	if err != nil {
		fmt.Println("http.Get err:", err)
		return
	}
	defer resp.Body.Close()

	// 获取服务器端读到的数据
	fmt.Println("Status = ", resp.Status)         // 状态
	fmt.Println("StatusCode = ", resp.StatusCode) // 状态码
	fmt.Println("Header = ", resp.Header)         // 响应头部
	fmt.Println("Body = ", resp.Body)             // 响应包体

	buf := make([]byte, 4096) // 定义切片缓冲区，存读到的内容
	var result string
	// 获取服务器发送的数据包内容
	for {
		n, err := resp.Body.Read(buf) // 读body中的内容。
		if n == 0 {
			fmt.Println("-> Read finish!")
			break
		}
		if err != nil && err != io.EOF {
			fmt.Println("resp.Body.Read err:", err)
			return
		}
		result += string(buf[:n]) // 累加读到的数据内容
	}
	// 打印从body中读到的所有内容
	fmt.Println("result = ", result)
}
  • 输出结果
Status =  200 OK
StatusCode =  200
Header =  map[Date:[Wed, 13 Feb 2019 12:41:06 GMT] Content-Length:[20] Content-Type:[text/plain; charset=utf-8]]
Body =  &{0xc0420f0240 {0 0} false <nil> 0x5cee00 0x5ceda0}
-> Read finish!
result =  This Is A Web Server
事后诸葛亮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
十五、网络编程
weixin_44063529的博客
07-22 854
这篇文章介绍了网络编程的基本概念，包括IP地址、端口号、socket以及如何使用Python实现基于UDP和TCP的网络通信。
十一、网络编程
一杯咖啡
02-13 198
3r
tcp简单例子（客户端通过键盘输入运算（加减乘除）发送给服务器，服务器接收后计算并返回计算结果）
qq_45772158的博客
10-07 2108
基于TCP的Socket网络编程应用实验报告 1.1 实验目的 了解tcp的基本原理。 熟悉java中的socket，serversocket类的使用 。 创建最简单的服务器，客户端交互系统。 1.2 实验要求 上机实验应二人一组，独立实验。 上机过程中出现的问题，除了是系统的问题以外，不要轻易举手问老师。 尤其对“出错信息”，应善于分析判断，找出出错的行，然后检查该行或其上一行。 1.3 实验内容 客户端通过键盘输入运算（加减乘除）发送给服务器，服务器接收后计算并返回计算结果。 1.4 思路分析
十五、标准输入输出
屈帅波的技术博客
03-19 210
package main import ( “bufio” “fmt” “os” ) func main() { //os.Stdin //os.Stdout fmt.Println(“xxx”) os.Stdout.Write([]byte(“xxx”)) bytes := make([]byte,10) n,err := os.Stdin.Read(bytes) fmt.Println(n,e...
Python 判断文件是否存在，存在则删除
桃子小迷妹
09-22 8131
# filepath为文件路径 import os # 判断文件是否存在 if (os.path.exists(filepath)) : #存在，则删除文件 os.remove(filepath)
golang 标准输入stdin
翔云
10-06 1万+
例子如下：package mainimport ( "bufio" "fmt" "os" ) func main() { reader := bufio.NewReader(os.Stdin) result, err := reader.ReadString('\n') if err != nil {
golang使用SQLite数据库对指定扩展名文件进行批量加密（七、完整代码）
咸甜适中
02-15 1034
package main import ( "bufio" "crypto/sha256" "database/sql" "encoding/hex" "fmt" "io" "io/ioutil" "os" "strings" "sync" "time" _ "github.com/mattn/go-sqlite3" ) // 加密字符串 func GetNegation(strb []byte) []byte { var strsN []byte for i, b :=.
基于TCP或UDP的客户端与服务器编程网络聊天-课程设计（含课程报告和代码）.rar
12-28
在IT领域，网络编程是计算机通信的核心部分，而TCP（传输控制协议）和UDP（用户数据报协议）是两种广泛使用的传输层协议。本课程设计的主题聚焦于利用这两种协议进行客户端与服务器之间的实时聊天应用开发，旨在让...
网络编程网络编程网络编程
最新发布
05-13
根据提供的文件信息，我们可以深入探讨网络编程的基本概念与关键技术点。 ### 一、网络编程概述 网络编程是指通过编写程序来实现计算机之间的网络通信。它涉及到多种协议和技术，旨在实现不同计算机之间数据的有效...
Java程序员面试宝典视频课程之网络编程（十二）
06-10
本"Java程序员面试宝典视频课程之网络编程（十二）"旨在帮助学者掌握面试所需的网络编程技能，提升求职竞争力，从而顺利突破面试难关。 网络编程是计算机科学中的一个重要分支，它主要研究的是计算机之间如何通过...
实验十二 Linux网络编程 实验报告
12-22
Linux 网络编程实验报告 Linux 网络编程实验报告主要目的是了解套接字编程的主要函数和功能，掌握网络程序的基本结构和设计方法，从而体会 C/S 结构网络程序系统的特点。 知识点一：套接字编程 套接字编程是指在...
Linux网络编程 视频 教程
08-16
Linux网络编程（总共41集） 讲解Linux网络编程知识，分以下四个篇章。 Linux网络编程之TCP/IP基础篇 Linux网络编程之socket编程篇 Linux网络编程之进程间通信篇 Linux网络编程之线程篇 Linux网络编程之TCP/IP...
golang TCP 实现文件发送接收
Waller_的博客
08-03 2109
首先获取文件名,借助os包中都得stat()函数来获取文件属性信息,在函数返回的文件属性中包含文件名和文件大小,Stat参数中name传入的是文件访问的绝对路径,FileInfo中的Name()函数可以将文件名单独提取出来 os.Stat func (f *File) Stat() (fi FileInfo, err error) Stat返回描述文件f的FileInfo类型值。如果出错，错误底层类型是*PathError。 type FileInfo type FileInfo interf
Go 存储基础 | 怎么使用 direct io ？
flynetcn的专栏
10-08 837
Go 存储编程怎么使用 O_DIRECT 模式？今天就分享这个存储细节， 之前提过很多次，操作系统的 IO 过文件系统的时候，默认是会使用到 page cache，并且采用的是 write back 的方式，系统异步刷盘的。由于是异步的，如果在数据还未刷盘之前，掉电的话就会导致数据丢失。 如果想要明确数据写到磁盘有两种方式：要么就每次写完主动 sync 一把，要么就使用 direct io 的方式，指明每一笔 io 数据都要写到磁盘才返回。 那么在 Go 里面怎么使用 direct io 呢？...
go语言重大bug，make缓存读取数据漏洞，4096漏洞
咸甜适中
02-09 1414
做一个小程序，需要对文件内容分片读取，但是读取过程中发现数据读取不全，经测试多个make缓存读取文件时发现问题。 一、生成测试文件（AAA.txt） // 创建一个AAA.txt文件，写入1万个A wFile, _ := os.OpenFile("AAA.txt", os.O_WRONLY|os.O_CREATE, 0666) defer wFile.Close() for i := 0; i < 10000; i++ { wFile.WriteString("A") } 二、多缓存读
【Go】优雅的读取http请求或响应的数据
weixin_33774615的博客
01-26 1898
原文链接：https://blog.thinkeridea.com/... 从 http.Request.Body 或 http.Response.Body 中读取数据方法或许很多，标准库中大多数使用 ioutil.ReadAll 方法一次读取所有数据，如果是 json 格式的数据还可以使用 json.NewDecoder 从 io.Re...
Go语言文件读取的一些总结
allen的博客
08-25 863
Go语言在进行文件操作的时候，可以有多种方法。最常见的比如直接对文件本身进行Read和Write； 除此之外，还可以使用bufio库的流式处理以及分片式处理；如果文件较小，使用ioutil也不失为一种方法。 面对这么多的文件处理的方式，那么初学者可能就会有困惑：我到底该用那种？它们之间有什么区别？笔者试着从文件读取来对go语言的几种文件处理方式进行分析。 os.File、bufio、ioutil比较 效率测试 文件的读取效率是所有开发者都会关心的话题，尤其是当文件特别大的时候。为了尽可能的展示这三者
十九、Beego框架快速入门
热门推荐
事后诸葛亮的程序人生（微信：zq9017197）
03-06 7万+
Beego框架快速入门 1.框架了解 go语言的web框架：beego,gin,echo等等，那为什么我们选择beego呢？ 第一，beego是中国人开发的，开发文档比较详细，beego官网网址: https://beego.me/ 。 第二，现在公司里面用beego的也比较多，比如今日头条，百度云盘，腾讯，阿里等。 2.环境搭建 这里默认大家已经搭建好了go语言的开发环境。 需要安装Bee...
《网络编程》实践课程指导书
"《网络编程》实践课程指导书" 《网络编程》实践课程指导书是计算机科学与技术专业、电子科学与技术专业、信息安全专业和网络工程专业的专业实践课程，旨在通过独立程序设计过程和实践，巩固《Java语言与网络编程》...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值