Java-网络编程-完全自学指南

最新推荐文章于 2022-04-15 00:08:44 发布
最新推荐文章于 2022-04-15 00:08:44 发布
阅读量308 收藏 1
点赞数 1
分类专栏： Java基础 文章标签： 网络 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45523411/article/details/121172328
版权

吹爆 狂神老师的 B站课程

网络编程

1.1 概述

计算机网络：

计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

网络编程的目的：

传播交流信息，数据交换，通信

想要达到这个效果需要什么：

  1. 如何准确的定位网络上的一台主机？ 通过 IP地址+端口，例如 192.168.16.124:端口号，定位到这个计算机上的某个资源
  2. 找到主机后，如何传输数据呢？ 通过网络编程

Javaweb：网页编程 B/S

网络编程：TCP/IP C/S

1.2 网络通信的要素

如何实现网络的通信？

通信双方的地址：

  • ip
  • 端口号

规则：网络通信的协议

TCP/IP参考模型：

图片.png

小结：

  1. 网络编程中主要有两个问题
    • 如何准确的定位到网络上的一台或多台主机
    • 找到主机之后如何进行通信
  2. 网络编程中的要素
    • IP 和 端口号 IP
    • 网络通信协议 tcp，udp
  3. Java 中 万物皆对象

1.3 IP

ip 地址：InetAddress

  • 唯一定位一台网络上计算机

  • 127.0.0.1：本机 localhost

  • ip 地址的分类

    • IP 地址分类：IPV4 / IPV6
      • IPV4 127.0.0.1，4个字节组成。0~255，42亿；30亿在北美，4亿在亚洲。2011年就用尽了
      • IPV6 2001:abba:1274:1a1a:0000:0000:aefe:1234​，128位，8个无符号整数
    • 公网（互联网）- 私网（局域网）

  • 域名：为了记忆 IP 问题！

InetAddress 类 示例

package InetAddress;

import com.sun.javafx.image.impl.IntArgb;

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

public class TestInetAddress {
    public static void main(String[] args) {
        try {
            // 查询 本机 地址
            InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
            System.out.println(inetAddress1);
            InetAddress inetAddress3 = InetAddress.getByName("localhost");
            System.out.println(inetAddress3);
            InetAddress inetAddress4 = InetAddress.getLocalHost();
            System.out.println(inetAddress4);

            // 查询 百度 地址
            InetAddress inetAddress2 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress2);

            // 常用方法
            // System.out.println(inetAddress2.getAddress());
            // System.out.println(inetAddress2.getCanonicalHostName());  // 规范名字
            System.out.println(inetAddress2.getHostAddress());  // ip
            System.out.println(inetAddress2.getHostName());  // 域名，或者自己电脑的名字

        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

1.4 端口

端口表示计算机上的一个程序的进程；

  • 不同的进程有不同的端口号！用来区分软件！

  • 被规定 0~65535

  • TCP，UDP：65535 * 2，单个协议下端口号不能冲突

  • 端口分类

    • 公有端口 0~1023

      • HTTP：80
      • HTTPS：443
      • FTP：21
      • Telent：23

    • 程序注册端口：1024~49151，分配给用户或者程序

      • Tomcat：8080
      • MySQL：3306
      • Oracle：1521

    • 动态、私有：49152~65535（尽量不用）

      netstat -ano #查看所有的端口
netstat -ano|findstr ""  #查看指定端口
tasklist|findstr "8696"  #查看指定端口进程

    •   // InetSocketAddress 类 示例
  package InetAddress;
  
  import java.net.InetSocketAddress;
  
  public class TestInetSocketAddress {
  
      public static void main(String[] args) {
          InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 8080);
          System.out.println(socketAddress);
  
          InetSocketAddress socketAddress2 = new InetSocketAddress("localhost", 8080);
          System.out.println(socketAddress2);
  
          System.out.println(socketAddress.getAddress());
          System.out.println(socketAddress.getHostName()); // 地址
          System.out.println(socketAddress.getPort()); // 端口
      }
  }

1.5 通信协议

协议：约定

网络通信协议：速率，传输速率，代码结构， 传输控制……

大事化小：分层！

TCP/IP协议簇：实际上是一组协议

重要：

  • TCP：用户传输协议
  • UDP：用户数据报协议

TCP：打电话

  • 连接，稳定

  • 三次握手，四次挥手

    •   A: 你瞅啥？
  B: 瞅你咋地？
  A: 干一场！
  
  
  A: 我要走了。
  B: 你真的要走了吗？
  B: 你真的真的要走了吗？
  A: 我真的要走了！

  • 客户端、服务端

  • 传输完成，释放连接，效率低

UDP：发短信

  • 不连接，不稳定
  • 客户端、服务端：没有明确的界限
  • DDOS：洪水攻击（饱和攻击）

1.6 TCP

客户端

  1. 连接服务器 Socket
  2. 发送消息
package InetAddress;

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

// 客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream os = null;
        try {
            // 1. 要知道服务器地址
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            // 2. 创建一个 socket 连接
            socket = new Socket(serverIP, port);
            // 3. 发送消息 IO 流
            os = socket.getOutputStream();
            os.write("你好，欢迎学习狂神说Java".getBytes());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

服务器

  1. 建立服务的端口
  2. 等待用户的连接 accept
  3. 接受用户的消息
package InetAddress;

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

// 服务端
public class TcpServerDemo01 {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            // 1. 得有一个地址
            serverSocket = new ServerSocket(9999);
            // 2. 等待客户端连接过来
            while (true) {
                socket = serverSocket.accept();
                // 3. 读取客户端的消息
                is = socket.getInputStream();

                // 管道流
                baos = new ByteArrayOutputStream();
                byte[] buffer = new byte[1024];
                int len;
                while ((len = is.read(buffer)) != -1) {
                    baos.write(buffer, 0, len);
                }

                System.out.println(baos.toString());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭资源
            if (baos != null) {
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

文件上传

服务器端

package InetAddress;

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

// 服务端 接收文件
public class TcpServerDemo02 {
    public static void main(String[] args) throws IOException {
        // 1. 创建服务
        ServerSocket serverSocket = new ServerSocket(9000);

        // 2. 监听等待连接
        Socket socket = serverSocket.accept();// 阻塞时监听，会一直等待客户端连接

        // 3. 获取输入流
        InputStream is = socket.getInputStream();

        // 4. 文件输出
        FileOutputStream fos = new FileOutputStream(new File("receive.jpg"));

        byte[] buffer = new byte[1024];
        int len;
        while ((len = is.read(buffer)) != -1) {
            fos.write(buffer, 0, len);
        }

        // 通知客户端，接收完毕
        OutputStream os = socket.getOutputStream();
        os.write("我接受完毕了，你可以断开了".getBytes());

        // 5. 关闭资源
        fos.close();
        is.close();
    }
}

客户端

package InetAddress;

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

// 客户端 发送上传文件
public class TcpClientDemo02 {
    public static void main(String[] args) throws IOException {
        // 1. 创建 Socket 连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);

        // 2. 创建一个输出流
        OutputStream os = socket.getOutputStream();

        // 3. 读取文件
        FileInputStream fis = new FileInputStream(new File("baobao.jpg"));

        // 4. 写出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len = fis.read(buffer)) != -1) {
            os.write(buffer, 0, len);
        }

        // 通知服务器，已经传输完毕
        socket.shutdownOutput();

        // 确定服务器接收完毕，才能断开连接
        InputStream is = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer2 = new byte[1024];
        int len2;
        while ((len2 = is.read(buffer2)) != -1) {
            baos.write(buffer2, 0, len2);
        }

        System.out.println(baos.toString());

        // 5. 关闭资源
        baos.close();
        is.close();
        fis.close();
        os.close();
        socket.close();
    }
}

Tomcat

服务端

  • 自定义
  • Tomcat 服务器

服务器

  • 自定义 C
  • 浏览器 B

1.7 UDP

发短信：不用连接，但是需要知道对方的地址！

发送端 示例

package InetAddress;

import java.io.IOException;
import java.net.*;

// 不需要连接服务器
public class UdpClient {
    public static void main(String[] args) throws IOException {
        // 1. 建立一个 Socket
        DatagramSocket socket = new DatagramSocket();

        // 2. 建个包
        String msg = "Hello Server!";

        // 接收者
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9090;

        // 数据，数据的长度起始，接收者
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);

        // 3. 发送包
        socket.send(packet);

        // 4. 关闭流
        socket.close();
    }
}

接收端 示例

package InetAddress;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

// 注意：UDP 没有服务端和客户端的概念
// 还是要等待客户端的连接！
public class UdpServer {
    public static void main(String[] args) throws IOException {
        // 开放端口
        DatagramSocket socket = new DatagramSocket(9090);

        // 接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);

        socket.receive(packet);  // 阻塞接收
        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(), 0, packet.getLength()));

        // 关闭连接
        socket.close();
    }
}

单向发送消息

发送发 示例

package chat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class UdpSender {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(8888);

        // 准备数据：控制台读取
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        while (true) {
            String data = reader.readLine();
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket(datas, 0, data.length(), new InetSocketAddress("127.0.0.1", 6666));

            socket.send(packet);

            if (data.equals("bye")) {
                break;
            }
        }
        socket.close();
    }
}

接收方 示例

package chat;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UdpReceiver {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(6666);

        // 准备接收包裹
        byte[] container = new byte[1024];
        while (true) {
            container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            socket.receive(packet);  // 阻塞式接收包裹

            byte[] data = packet.getData();
            String receiveData = new String(data, 0, packet.getLength());

            System.out.println(receiveData);

            // 断开连接
            if (receiveData.equals("bye")) {
                break;
            }

        }
        socket.close();
    }
}

多线程实现双人聊天

发送线程

package chat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class TlakSend implements Runnable{
    DatagramSocket socket = null;
    BufferedReader reader = null;

    private int fromPort;
    private String toIP;
    private int toPort;

    public TlakSend(int fromPort, String toIP, int toPort) throws SocketException {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;

        socket = new DatagramSocket(fromPort);
        reader = new BufferedReader(new InputStreamReader(System.in));
    }

    @Override
    public void run() {

        while (true) {
            try {
                String data = reader.readLine();
                byte[] datas = data.getBytes();
                DatagramPacket packet = new DatagramPacket(datas, 0, data.length(), new InetSocketAddress(this.toIP, this.toPort));

                socket.send(packet);

                if (data.equals("bye")) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

接收线程

package chat;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class TalkReceive implements Runnable{
    DatagramSocket socket = null;
    private int port;

    public TalkReceive(int port) throws SocketException {
        this.port = port;

        socket = new DatagramSocket(port);

    }

    @Override
    public void run() {

        while (true) {
            try {
                // 准备接收包裹
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);
                socket.receive(packet);  // 阻塞式接收包裹

                byte[] data = packet.getData();
                String receiveData = new String(data, 0, packet.getLength());

                System.out.println(packet.getPort() + ": " + receiveData);

                // 断开连接
                if (receiveData.equals("bye")) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

TalkerA

package chat;

import java.net.SocketException;

public class TalkerA {
    public static void main(String[] args) throws SocketException {

        new Thread(new TlakSend(7777, "localhost", 9999)).start();
        new Thread(new TalkReceive(8888)).start();
    }
}

TalkerB

package chat;

import java.net.SocketException;

public class TalkerB {
    public static void main(String[] args) throws SocketException {
        new Thread(new TlakSend(5555, "localhost", 8888)).start();
        new Thread(new TalkReceive(9999)).start();
    }
}

1.8 URL 下载网络资源

https://www.baidu.com/

统一资源定位符：定位互联网上的某一个资源

协议://ip地址:端口/项目名/资源

示例

package URL;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class URLDown {
    public static void main(String[] args) throws IOException {
        URL url = new URL("https://m701.music.126.net/20211107224102/9e1ffbefe22635383c9d506b72278609/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/11518403401/53d9/3013/dc76/928a32f8a24746e235218c01c2cf3de4.m4a");

        HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();

        InputStream inputStream =  urlConnection.getInputStream();

        FileOutputStream fos = new FileOutputStream("wyy.m4a");

        byte[] buffer = new byte[1024];
        int len;
        while ((len = inputStream.read(buffer)) != -1) {
            fos.write(buffer, 0, len); // 写出数据
        }
        fos.close();
        inputStream.close();
        urlConnection.disconnect();
    }
}

完结撒花

下一步 - Java 注解和反射

风落_
关注
专栏目录
中国电信浙江分公司java笔试题-LearnCS-ByYourself:CS自学指南（Java编程语言、数据库、数据结构与算法、计算机组成原理
06-20
自学指南（Java编程语言、数据库、数据结构与算法、计算机组成原理、操作系统、计算机网络、英语、简历、面试） 所涉及到的电子书，可以通过另外一个仓库下载： 前言 回想起我的大学之路，难免觉得有些遗憾，因为...
leetcode手册JAVA-Resources-used-for-self-learning:用于自学的资源
06-30
leetcode手册JAVA !!WIP！！ 有一位导师来指导你是我最好的建议。 我从 School 42 piscine 开始。 这是一个月的紧张编程，有很多练习。 您可以在此处找到练习的 pdf 文件：（向下滚动）视频课程（法语） :...
【狂神】JAVA学习全套笔记（完整版）
03-12
内容包含： 1、JAVA SE 2、MySQL + JDBC 3、JAVA WEB 4、Mybatis 5、SSM 6、大前端 7、Vue 8、SpringBoot 9、Spring Security 10、Shiro 11、Spring Cloud 12、JVM 13、JUC 14、Git 15、Linux 16、Redis 17、ElasticSearch 18、Docker
Java网络编程简单笔记
weixin_51418572的博客
12-03 376
网络编程 概述 就是用来实现网络互连的不同计算机上运行的程序间可以进行数据交 计算机网络： 计算机网络是指将地理地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。 网络编程的目的： 无线电台。。。传播交流信息，数据交换。通信 想要达到这个效果需要的是什么： 如何准确的定位网络上的一台主机 192.168.xxx.xxx：端口,定位到这个计算机上的某个资源 找到了这个主机，如何传输数据？
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 端口号
狂神说Java--Java学习笔记(合集)
qq_41924554的博客
07-22 2560
笔记参考来源狂神说Java视频 https://www.bilibili.com/video/BV12J41137hu 本篇笔记有点长，可以根据目录定位，建议配合视频学习。 Java流程控制 用户交互Scanner 之前我们学的基本语法并没有实现程序和人的交互，Java给我们提供了一个工具类，可以获取用户的输入。 java.util.Scanner是Java5的新特征，我们通过Scanner类来获取用户的输入。 基本语法 Scanner s = new Scanner(System.in); .
网络编程--架起计算机通信的桥梁
weixin_40154786的博客
12-05 502
网络编程 本章目标 理解网络相关概念 会使用基于TCP协议的Socket编程 会使用基于UDP协议的Socket编程 1. 查看IP地址 关键步骤如下： 打开命令提示窗口 输入命令查看本机的IP地址 1.1 认识网络 1. 网络的概念和分类 简单来说，网络就是连接在一起共享数据和资源的一组计算机。 按照地理覆盖范围，计算机网络可以划分为局域网、城域网和广域网 (1) 局域网 局域网局限在小的地理区域内或单独的建筑物内，被用于连接公司办公室、实验室或工厂里的个人计算机和工作站。比如办公室局域网
Java开源项目之「自学编程之路」：学习指南+面试指南+资源分享+技术文章
06-19
「自学编程之路」是一个致力于 Java 编程学习的开源项目，提供了全面的学习指南、面试指南、资源分享和技术文章，帮助自学者快速掌握 Java 编程技术。这一项目整合了从基础到高级的知识点，并包含了大量实用的学习...
JAVA自学指南.docx
最新发布
07-03
### JAVA自学指南知识点详解 #### 一、Java基础知识与入门 **1.1 Java基础语法** - **变量**: Java中的变量用于存储数据。变量需要声明数据类型，并且必须先声明后使用。 - **数据类型**: 包括基本数据类型（如`...
Java开源项目之「自学编程之路」
10-25
这个项目不仅涵盖了基础理论，还包括实战经验和技术文章，帮助你更好地理解和掌握Java编程。 首先，学习Java编程的基础至关重要。这包括理解基本语法、数据类型、控制结构（如if语句和循环）、类与对象的概念，以及...
狂神Java学习笔记————前端入门——html、css、JavaScript学习代码
06-17
此资源为我跟着B站up主【遇见狂神说】java系列视频中前端入门部分学习过程中所写 大部分和视频保持一致，有一些自己的理解和一些扩展的部分
狂神java笔记
weixin_52122727的博客
04-15 877
方法: 方法的调用： 类与对象的创建： 使用new关键字创建对象 类只包括属性与方法，类是抽象的，需要实例化 构造器的详解： 一个类即使什么都不写，也会存在一个构造器（方法）。 作用：1、使用new关键字，本质是在调用构造器 2、初始化对象的值 注意点： 1、定义有参构造之后，如果想使用无参构造，显示定义一个无参的构造 alt+insert 快速生成有参/无参构造函数 this. 代表当前类，后面=为传进来的值 package Kua...
网络编程
Aming_he博客
08-28 1056
网络编程概述 计算机网络：         是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。 网络编程：         就是用来实现网络互连的不同计算机上运行的程序间可以进行数据交换。 网络模型 计算机网络之间以何种规则进行通信，就是网络模型研究问题。 网络模型一般...
Java 网络编程
ZaynFox的博客
05-30 6万+
网络编程 一、网络编程基础概念 首先理清一个概念：网络编程不等于网站编程，网络编程即使用套接字来达到进程间通信，现在一般称为TCP/IP编程。 计算机网络： 把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大，功能强的网络系统，从而使众多的计算机可以方便的互相传递信息，共享硬件，软件，数据信息等资源。 计算机网络的主要功能： 资源共享 信息传输与集中处理 均衡负荷与分布处理 ...
Java网络高级编程入门指南
"《最新Java网络编程》是殷兆麟、张永平、姜淑娟编著的一本高等学校计算机科学与技术教材，专注于讲解Java在网络编程中的应用，适合初学者。书中涵盖了网络进程通信、RMI、CORBA、Web技术（如JavaBean、Servlet、JSP...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

风落_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值