Java笔记之网络编程（二十九）

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量76 收藏
点赞数
分类专栏： 自学Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44604159/article/details/126196969
版权

学习目录

一、InetAddress类和Socket

1.InetAddress类

相关方法

方法名功能
getLocalHost获取本机InetAddress对象
getByName根据指定主机名/域名获取ip地址对象
getHostName获取InetAddress对象的主机名
getHostAddress获取InetAddress对象的地址

快速入门

import java.net.InetAddress;
import java.net.UnknownHostException;

public class test {
    public static void main(String[] args) throws UnknownHostException {
        //获取本机 InetAddress 对象 getLocalHost
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);
        //根据指定主机名/域名获取 ip 地址对象 getByName
        InetAddress byName = InetAddress.getByName("DESKTOP-RT31TG6");
        System.out.println(byName);

        InetAddress byName1 = InetAddress.getByName("www.baidu.com");
        System.out.println(byName1);
        //获取 byName1 对象的主机名 getHostName
        String hostName = byName1.getHostName();
        System.out.println(hostName);
        //获取 byName1 对象的地址 getHostAddress
        String hostAddress = byName1.getHostAddress();
        System.out.println(hostAddress);
    }
}

2.Socket

基本介绍

Socket开发网络应用程序被广泛采用，以至于称为事实的标准。

  1. 通信的两端都要有Socket，是两台机器通信的端点
  2. 网络通信其实就是Socket间的通信
  3. Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO流进行传输的
  4. 一般主动发起通信的应用程序属于客户端，等待通信请求的为服务端

二、TCP网络通信编程

1.基本介绍

  1. 基于客户端—服务端的网络通信
  2. 底层使用的是TCP/IP协议
  3. 应用场景举例：客户端发送数据，服务端接受并显示控制台
  4. 基于Socket的TCP编程

在这里插入图片描述

注意：需先启动服务端，然后再启动客户端

2.应用案例

案例一

要求：

  1. 使用字节流
  2. 编写一个服务器端和客户端
  3. 服务器端在9999端口监听
  4. 客户端连接到服务器端，发送“hello server”，然后退出
  5. 服务器端接收到客户端发送的信息，输出，并退出

服务器Server端

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author wangbo
 * @version 1.0
 */
//服务端
public class SocketTCPServer {
    public static void main(String[] args) throws IOException {
        //在本机9999端口进行监听，(在本机的9999端口没有被占用的情况下)
        ServerSocket serverSocket= new ServerSocket(9999);
        System.out.println("服务端对9999进行端口监听，等待连接..");
        //等待连接
        //细节：serverSocket可以通过accept()返回多个Socket，多个客户端连接服务器的并发
        Socket socket = serverSocket.accept();
        System.out.println("服务端 socket =" + socket.getClass());

        //通过 socket.getInputStream() 读取客户端写入到数据通道的数据
        InputStream inputStream = socket.getInputStream();

        //再通过IO流进行读取
        byte[] bytes = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(bytes)) != -1){
            System.out.println(new String(bytes,0,readLen));
        }

        //关闭流和socket,必须关闭
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

客户端Client

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

/**
 * @author wangbo
 * @version 1.0
 */
//客户端
public class SocketTCPClient {
    public static void main(String[] args) throws IOException {
        //连接本机的 9999 端口, 如果连接成功，则返回 Socket 对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket返回为："+socket.getClass());
        //通过socket.getOutputStream()获取socket 对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //通过IO流，写入数据到数据通道
        outputStream.write("hello server".getBytes());

        //关闭流对象和 socket,必须关闭
        outputStream.close();
        socket.close();
        System.out.println("客户端退出....");
    }
}

案例二

要求：

  1. 使用字节流
  2. 编写一个服务器端和客户端
  3. 服务器端在9999端口监听
  4. 客户端连接到服务器端，发送“hello server”，并接收服务器端回发的 “hello client” 然后再退出
  5. 服务器端接收到客户端发送的信息，输出，并发送“hello client”给客户端，最后再退出

注意：当流写入数据通道后，需要设置结束标记

服务器Server端

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author wangbo
 * @version 1.0
 */
//服务端
public class SocketTCPServer {
    public static void main(String[] args) throws IOException {
        //在本机9999端口进行监听，(在本机的9999端口没有被占用的情况下)
        ServerSocket serverSocket= new ServerSocket(9999);
        System.out.println("服务端对9999进行端口监听，等待连接..");
        //等待连接
        //细节：serverSocket可以通过accept()返回多个Socket，多个客户端连接服务器的并发
        Socket socket = serverSocket.accept();
        System.out.println("服务端 socket =" + socket.getClass());

        //通过 socket.getInputStream() 读取客户端写入到数据通道的数据
        InputStream inputStream = socket.getInputStream();

        //再通过IO流进行读取
        byte[] bytes = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(bytes)) != -1){
            System.out.println(new String(bytes,0,readLen));
        }

        //获取socket相关联的输出流，写入数据到数据通道，使用字节流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello client".getBytes());

        //设置结束标记
        socket.shutdownOutput();

        //关闭流和socket,必须关闭
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

客户端Client

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

/**
 * @author wangbo
 * @version 1.0
 */
//客户端
public class SocketTCPClient {
    public static void main(String[] args) throws IOException {
        //连接本机的 9999 端口, 如果连接成功，则返回 Socket 对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket返回为："+socket.getClass());
        //通过socket.getOutputStream()获取socket 对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //通过IO流，写入数据到数据通道
        outputStream.write("hello server".getBytes());

        //设置结束标记
        socket.shutdownOutput();

        //获取socket相关联的输入流，读取数据并显示。使用的字节流
        InputStream inputStream = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(bytes)) != -1){
            System.out.println(new String(bytes,0,readLen));
        }

        //关闭流对象和 socket,必须关闭
        outputStream.close();
        socket.close();
        System.out.println("客户端退出....");
    }
}

案例三

要求：

  1. 使用字符流
  2. 编写一个服务器端和客户端
  3. 服务器端在9999端口监听
  4. 客户端连接到服务器端，发送“hello server”，并接收服务器端回发的 “hello client” 然后再退出
  5. 服务器端接收到客户端发送的信息，输出，并发送“hello client”给客户端，最后再退出

将字节流转换为字符流，需要用到转换流

注意：这里设置结束标记除了使用socket.shutdownOutput();也可以用 如：writer.newLine()设置结束标记，而且对面接收数据需要使用readLine来接收

服务器Server端

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author wangbo
 * @version 1.0
 */
//服务端
public class SocketTCPServer {
    public static void main(String[] args) throws IOException {
        //在本机9999端口进行监听，(在本机的9999端口没有被占用的情况下)
        ServerSocket serverSocket= new ServerSocket(9999);
        System.out.println("服务端对9999进行端口监听，等待连接..");
        //等待连接
        //细节：serverSocket可以通过accept()返回多个Socket，多个客户端连接服务器的并发
        Socket socket = serverSocket.accept();
        System.out.println("服务端 socket =" + socket.getClass());

        //通过 socket.getInputStream() 读取客户端写入到数据通道的数据
        InputStream inputStream = socket.getInputStream();

        //再通过IO流进行读取，使用字符流读取
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);

        //获取socket相关联的输出流，写入数据到数据通道
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello client");
        bufferedWriter.newLine();   //插入一个换行符，表示写入的内容结束，但是要求对面使用readLine()进行读取
        bufferedWriter.flush(); //如果使用字符流，则需要手动刷新，否则不会写数据通道

        //关闭流和socket,必须关闭,这里只需要关闭外层流即可，按照先打开后关闭的原则
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        serverSocket.close();
    }
}

客户端Client

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;

/**
 * @author wangbo
 * @version 1.0
 */
//客户端
public class SocketTCPClient {
    public static void main(String[] args) throws IOException {
        //连接本机的 9999 端口, 如果连接成功，则返回 Socket 对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        System.out.println("客户端 socket返回为："+socket.getClass());
        //通过socket.getOutputStream()获取socket 对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //通过IO流，写入数据到数据通道,这里使用字符流
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello server");
        bufferedWriter.newLine();   //插入一个换行符，表示写入的内容结束，但是要求对面使用readLine()进行读取
        bufferedWriter.flush(); //如果使用字符流，则需要手动刷新，否则不会写数据通道

        //获取socket相关联的输入流，读取数据并显示。
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);

        //关闭流对象和 socket,必须关闭,这里只需要关闭外层流即可,按照先打开后关闭的原则
        bufferedReader.close();
        bufferedWriter.close();
        socket.close();
        System.out.println("客户端退出....");
    }
}

2.网络上传文件

案例四

要求：

  1. 编写一个服务器端和客户端
  2. 服务器端在9999端口监听
  3. 客户端连接服务端，发送一张图片 F:\\java.jpeg
  4. 服务器端接收到客户端发送的图片，保存到src下，发送“收到图片”，然后再退出
  5. 客户端接收到服务端发送的“收到图片”，再退出
  6. 需使用一个工具类StreamUtils.java

StreamUtils工具类

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * 此类用于演示关于流的读写方法
 *
 */
public class StreamUtils {
	/**
	 * 功能：将输入流转换成byte[]， 即可以把文件的内容读入到byte[]
	 * @param is
	 * @return
	 * @throws Exception
	 */
	public static byte[] streamToByteArray(InputStream is) throws Exception{
		ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
		byte[] b = new byte[1024];//字节数组
		int len;
		while((len=is.read(b))!=-1){//循环读取
			bos.write(b, 0, len);//把读取到的数据，写入bos	
		}
		byte[] array = bos.toByteArray();//然后将bos 转成字节数组
		bos.close();
		return array;
	}
	/**
	 * 功能：将InputStream转换成String
	 * @param is
	 * @return
	 * @throws Exception
	 */
	
	public static String streamToString(InputStream is) throws Exception{
		BufferedReader reader = new BufferedReader(new InputStreamReader(is));
		StringBuilder builder= new StringBuilder();
		String line;
		while((line=reader.readLine())!=null){
			builder.append(line+"\r\n");
		}
		return builder.toString();
		
	}

}

服务器Server端

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author wangbo
 * @version 1.0
 */
//服务端
public class SocketTCPServer {
    public static void main(String[] args) throws Exception {
        //在本机9999端口进行监听，(在本机的9999端口没有被占用的情况下)
        ServerSocket serverSocket= new ServerSocket(9999);
        System.out.println("服务端对9999进行端口监听，等待连接..");
        //等待连接
        Socket socket = serverSocket.accept();

        //读取客户端发送的数据
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        //读取管道传过来的文件字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //将得到的字节数组，写入到指定的路径，得到一个文件
        String newFilePath = "src\\java.jpeg";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFilePath));
        bos.write(bytes);

        //向客户端回复信息，字符流
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        bufferedWriter.write("收到图片！");
        bufferedWriter.newLine();
        bufferedWriter.flush();

        //关闭资源
        bufferedWriter.close();
        bos.close();
        bis.close();
        socket.close();
        serverSocket.close();
    }
}

客户端Client

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;

/**
 * @author wangbo
 * @version 1.0
 */
//客户端
public class SocketTCPClient {
    public static void main(String[] args) throws Exception {
        //连接本机的 9999 端口, 如果连接成功，则返回 Socket 对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        String filepath = "F://java.jpeg";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filepath));

        //把读取的内容转换成字节数组，使用工具类
        byte[] bytes = StreamUtils.streamToByteArray(bis);

        //通过socket获取输出流，将bytes数据发送给服务器
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);   //将文件写入数据通道
        socket.shutdownOutput();

        //接收信息
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);

        bufferedReader.close();
        bos.close();
        bis.close();
        socket.close();
    }
}
王博1999
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
网络编程-狂神说Java学习笔记
07-20
网络编程—狂神说Java学习笔记
网络编程学习笔记.md
05-08
网络编程 （狂神说Java）学习笔记 + 自己的一些理解
JavaWeb笔记（一）Java网络编程
qq_25928447的博客
11-13 1万+
Java网络编程 在JavaSE阶段，我们学习了I/O流，既然I/O流如此强大，那么能否跨越不同的主机进行I/O操作呢？这就要提到Java的网络编程了。 **注意：**本章会涉及到计算机网络相关内容（只会讲解大致内容，不会完整的讲解计算机网络知识） 计算机网络基础 利用通信线路和通信设备，将地理位置不同的、功能独立的多台计算机互连起来，以功能完善的网络软件来实现资源共享和信息传递，就构成了计算机网络系统。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ykjZ8oQY-163
网络安全-自学笔记
热门推荐
关注网络安全、云原生安全
12-01 16万+
目录 WEB（应用）安全 前端安全 xss攻击 后端安全 文件上传漏洞 WebShell 解析安全 数据安全 sql注入 通信安全 WEB（应用）安全 前端安全 xss攻击 后端安全 文件上传漏洞 WebShell 解析安全 数据安全 sql注入 网络安全-sqlmap学习笔记 通信安全 网络-http协议学习笔记（消息结构、请求方法、状态码等） ...
Java编程思想笔记目录
小名同学
10-24 4万+
祝各位 程序???? 节日快乐???? ![在这里插入图片描述](https://img-blog.csdnimg.cn/2020102311591445.gif#pic_center) 写在前面：   前阵子，小名“偷偷地”发了一批文章，是小名的一些读书笔记✍，那么为什么要把笔记发出来呢，嘻嘻，当然是小名的????不太灵光啦????但是吧，小名坐地铁或者走在大街上的时候，脑袋里总是会想一些有的没的，不排除会想一些Java基础的知识，时常联系不起来，就有可能别扭一整天。所以呢，把它发出来一方面是为了和大
【Java】流式编程学习笔记
知不足而奋进，望远山而前行
01-17 1万+
流式 API 从 Java8 开始引入，支持链式书写。流在管道中流通，在节点被处理。Stream是独特的，既不同于io，也不同于List。Stream在理论上能容纳无限对象，List不能流不是一种数据结构，流存储的只是一种数据视图。流的计算是惰性计算，真正的计算通常只发生在最后的结果获取时。流式计算存在第一步、中间一步、最后一步的说法，只有当到达最后一步执行函数的时候，整个惰性函数才会执行。流只能消费一次，不能被两次消费如下的代码，对stream进行了两次遍历，所以会报错。
java Stream编程笔记
个人博客，记录了本人学习的各种有趣的技术。
12-31 7327
Stream（流）是一个来自数据源的元素队列并支持聚合操作元素是特定类型的对象，形成一个队列。Java中的Stream并不会存储元素，而是按需计算。数据源 流的来源。可以是集合，数组，I/O channel， 产生器generator 等。聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。不可变性：Stream 是不可变的，它不会修改原始数据源，也不会产生中间状态或副作用。
Java 网络编程（超级详细）
imByte的博客
06-10 2万+
1. 网络编程 1.1 网络编程概述 计算机网络 是指将地理位置相同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统、网络管理软件及通信协议的管理和协调下，实现资源共享和信息传递的计算机系统 1.2 网络编程三要素 1、IP地址 要想让网络中的计算机能够互相通信，必须为计算机指定一个标识号，通过这个标识号来指定要接受数据的计算机和识别发送的计算机，而IP地址就是这个标识号，也就是设备的标识。 2、端口 网络的通信，本质上是两个应用程序的通信。每台计算机都有很多的应用程
Java笔记网络编程-socket编程（UDP连接）
活在当下的博客
12-02 2199
将数据源和目的封装成数据报中，不需要建立连接 每个数据报的大小在限制在64k 因无需连接，是不可靠协议 不需要连接，速度快
Java学习笔记 —— 链式编程学习笔记
Marinda_Speed的博客
12-16 1340
链式编程大家可能有些熟悉也有些许陌生，我们今天来揭开这个神秘面纱。每次方法调用后都返回当前对象，非常不可思议吧，没想到还可以那么玩！我们今天来学习一下使用Lombok和原生的代码来实现链式编程。
JAVA网络编程实战（笔记）
Frank---7的博客
12-23 6万+
计算机网络简介 网络编程的目的： 无限电台。。。。传播交流信息，数据交换。通信 想要达到这个效果需要什么： 1.如何准确的定位网络上的一台主机 ip地址192.168.16.124： 端口，定位到这个计算机上的某个资源 2.找到了这个主机，如何传输数据 Javaweb： 网页编程 B/s Brower/Server(浏览器/服务器)架构 网络编程：TCP/IP C/S Client/Server(客户端/服务器) 网络通信的要素 如何实现网络的通信？ 通信双方地址： IP 端口号
网络socket编程java（b站韩顺平笔记)
zhangtao2247274465的博客
02-18 2469
java笔记
笔记，1、Java网络编程基础2
08-08
2.视频、音频等多媒体通信（即时通信） 3.限定于 LAN 等特定网络中的应用通信 4.广播通信（广播、多播）
笔记，1、Java网络编程基础1
08-08
2.视频、音频等多媒体通信（即时通信） 3.限定于 LAN 等特定网络中的应用通信 4.广播通信（广播、多播）
笔记，1、Java网络编程基础3
08-08
2.视频、音频等多媒体通信（即时通信） 3.限定于 LAN 等特定网络中的应用通信 4.广播通信（广播、多播）
进阶2 探索图形化编程：扩展图形组件与切片开发的魅力
优树搭的博客
05-30 1284
当这些切片成功地通过图形程序串联起来后，在后续进行程序升级或维护时，大家会惊喜地发现，图形程序就如同清晰的路标一般，可以非常便捷地通过图形程序准确地定位到相关切片，并对这些切片进行在线查看、编辑和执行等操作。而且，这些切片的代码长度通常不会太长，相比传统开发的代码，阅读起来要容易得多，这无疑会给系统后续的工作带来极大的便利。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 854
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1187
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 480
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java编程思想笔记
10-20
Java编程思想是一本经典的Java编程入门书籍，它详细介绍了Java编程语言的基础知识和高级特性，包括面向对象编程、异常处理、泛型、集合框架、多线程、网络编程等方面的内容。这本书的作者Bruce Eckel是一位Java编程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王博1999

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值