2021.07.23 Java学习笔记之网络编程

最新推荐文章于 2024-09-13 17:30:19 发布
最新推荐文章于 2024-09-13 17:30:19 发布
阅读量108 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mxxxxxx_/article/details/119043169
版权
本文详细阐述了网络编程与网页编程的区别，包括它们各自的关注点、协议、IP地址、端口、URL等核心概念。通过Java实例展示了如何进行IP查找、端口操作、URL解析以及Socket通信。此外，还探讨了网络爬虫的基本流程和TCP/UDP套接字通信，并提供了客户端和服务端的登录示例，涵盖了多线程服务端的实现。
摘要由CSDN通过智能技术生成

网页编程和网络编程的区别

        网页编程：上层的应用，

        网络编程：底层，关注数据如何传输，如何存储

                节点：网络电子设备

                        节点和节点之间组成网络

                IP ：表示节点

                端口：区分不同的软件

                URL ：互联网中资源的指针，统一资源定位符

                协议：合同，规范，标准

                传输层协议：

                        UDP ：相当于写信，只管写只管发，效率高，但是不安全 ，传输数据的大小存在限制。

                        TCP： 相当于打电话，面向连接，安全性高，效率低，传输数据的大小没有限制

                IP：定义网络中的节点（网络电子设备，手机，电脑，路由器。。。。）

                        分为：IPV4(4个字节，32位） IPV6(128位)

                        特殊IP:192.168.0.0~192.168.255.255  非注册IP,供组织内部使用
                                    127.0.0.1 本地IP
                                    localhost : 本地域名
                                    域名与IP之间的关系:  DNS解析器

java.net包
        InetAddress  类表示Internet协议（IP）地址

public static void main(String[] args) throws UnknownHostException {
        //static InetAddress getByName(String host) 根据主机名称确定主机的IP地址。
        //static InetAddress getLocalHost() 返回本地主机的地址。
        InetAddress address1 = InetAddress.getLocalHost();
        System.out.println(address1); //DESKTOP-KHNV6UD/192.168.16.236
        System.out.println(address1.getHostName());
        System.out.println(address1.getHostAddress());

        InetAddress address2 =  InetAddress.getByName("www.baidu.com");
        System.out.println(address2);
        System.out.println(address2.getHostName());
        System.out.println(address2.getHostAddress());
    }

端口：区分软件

        端口号 2个字节  0~65535
        同一协议下端口号不能冲突
        建议使用8000以上的,8000以下称为预留端口好 

        常见的端口:
               80 : http
                8080 : tomcat
                1521 : Oracle
               3306  : Mysql

  InetSocketAddress 此类实现IP套接字地址（IP地址+端口号）它也可以是一对（主机名+端口）

public static void main(String[] args)  {
        //InetSocketAddress(String hostname, int port) 根据主机名和端口号创建套接字地址。
        //InetSocketAddress(InetAddress addr, int port) 根据IP地址和端口号创建套接字地址。
        InetSocketAddress in = new InetSocketAddress("localhost",8989);
        System.out.println(in);
        System.out.println(in.getHostName());
        System.out.println(in.getPort());
    }

URL        

         同一资源定位符,指向万维网上的“资源”的指针。 

        组成:
                协议: http
                域名: www.baidu.com
                端口号: 80
                资源: index.html
                    提交数据: name=zhangsan&pwd=123
                    锚点: #a

            互联网 的三大基石:
                html
                http
                url

 public static void main(String[] args) throws MalformedURLException {
        //URL(String spec) 从 String表示创建 URL对象。
        //URL(String protocol, String host, int port, String file)
        URL url = new URL("https://www.baidu.com:80/index.html?name=zhangsan&pwd=123#a");

        System.out.println(url);
        System.out.println("协议:"+url.getProtocol());
        System.out.println("域名:"+url.getHost());
        System.out.println("端口:"+url.getPort());
        System.out.println("资源:"+url.getFile());
        System.out.println("资源:"+url.getPath());
        System.out.println("资源:"+url.getQuery());
        System.out.println("资源:"+url.getRef());
    }

  网络爬虫

 

public static void main(String[] args) throws IOException {
        //1.定义URL
        URL url = new URL("https://www.baidu.com/index.html");
        //2.获取流 : InputStream openStream() 打开与此 URL的连接并返回 InputStream以从该连接读取。
        InputStream is = url.openStream();
        //InputStreamReader 字节输入流转位字符输入流的节点流-->功能流
        BufferedReader rd = new BufferedReader(new InputStreamReader(is));
        String msg = null;
        //3.读入操作
        while((msg = rd.readLine())!=null){
            System.out.println(msg);
        }
        //4.关闭
        rd.close();
        is.close();
    }

套接字 

        传输层为应用层开配的小口子

        不同协议下的Socket实现不同

         UDP : 相当于写信|有包裹|发短信  非面向连接   协议简单,开销小,效率高   不安全    大小由限制(一般不超过60k)
        TCP : 相当于打电话       面向连接    效率低  安全      大小没有限制 基于三次握手

         UDP协议下发送端和接收端两端平等 

                DatagramSocket  此类表示用于发送和接收数据报包的套接字。
                DatagramSocket(int port) 构造一个数据报套接字并将其绑定到本地主机上的指定端口。
                void receive(DatagramPacket p) 从此套接字接收数据报包。
                void send(DatagramPacket p) 从此套接字发送数据报包。

        DatagramPacket 该类表示数据报包。
                    byte[] getData() 返回数据缓冲区。
                    int getLength() 返回要发送的数据的长度或接收的数据的长度。 

数据的传输基于字节数组 

 UDP实现发送端: 基本流程
            1.定义我是发送端
            2.准备数据
            3.打包
            4.发送
            5.关闭

 public static void main(String[] args) throws IOException {
            // 1.定义我是发送端
            DatagramSocket s = new DatagramSocket(9090);

            System.out.println("-------------我是发送端-------------");

            // 2.准备数据
            byte[] arr = "你好".getBytes();
            // 3.打包
            DatagramPacket packet = new DatagramPacket(arr,0,arr.length,new InetSocketAddress("127.0.0.1",8989));
            // 4.发送
            s.send(packet);
            // 5.关闭
            s.close();
        }

UDP实现接收端: 基本流程
        1.定义我是接收端
        2.准备字节数组,打包
        3.接收数据
        4.处理数据
        5.关闭

注意;  统一协议下端口号不能冲突

 

ublic static void main(String[] args) throws IOException {
        //1.定义我是接收端
        DatagramSocket r = new DatagramSocket(8989);

        System.out.println("-----------我是接收端------------");

        //2.准备字节数组,打包
        byte[] arr = new byte[1024];
        DatagramPacket packet = new DatagramPacket(arr,arr.length);
        //3.接收数据
        r.receive(packet);
        //4.处理数据
        //byte[] getData() 返回数据缓冲区。
        //int getLength() 返回要发送的数据的长度或接收的数据的长度。
        byte[] newArr = packet.getData();
        int len = packet.getLength();

        System.out.println(new String(newArr,0,len));

        //5.关闭
        r.close();
    }

客户端  Socket

        Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号。
        InputStream getInputStream()
        OutputStream getOutputStream()
    服务器  ServerSocket 该类实现服务器套接字。
        ServerSocket(int port) 创建绑定到指定端口的服务器套接字。
        Socket accept() 侦听对此套接字的连接并接受它。

 TCP 协议下传输数据基于IO流

        客户端的实现基本流程：

                1.定义我是客户端-->指定要请求的服务器的IP+端口
​                2.准备数据
​                3.获取输出流
​                4.输出-->IO操作
​                5.刷出
​                6.关闭

ublic static void main(String[] args) throws IOException {
​        System.out.println("-----------我是客户端--------------");
​        //  1.定义我是客户端-->指定要请求的服务器的IP+端口
​        Socket client = new Socket("localhost",9999);
​        System.out.println("-----------与服务器端建立连接--------------");
​        //  2.准备数据
​        String str = "你好";
​        //  3.获取输出流
​        DataOutputStream os = new DataOutputStream(new BufferedOutputStream(client.getOutputStream()));
​        //  4.输出-->IO操作
​        os.writeUTF(str);
​        //  5.刷出
​        os.flush();
​        //  6.关闭
​        os.close();
​        client.close();
​    }

 tcp协议实现基本流程 : 服务端
        1.定义我是服务端
        2.阻塞式监听
        3.获取输入流-->接收客户端的请求数据
        4.处理数据
        5.关闭

 

public static void main(String[] args) throws IOException {
        System.out.println("-----------我是服务器端-----------");
        // 1.定义我是服务端
        ServerSocket server = new ServerSocket(9999);
        // 2.阻塞式监听
        Socket client = server.accept();

        System.out.println("-----------一个客户端连接成功----------");

        // 3.获取输入流-->接收客户端的请求数据
        DataInputStream is = new DataInputStream(new BufferedInputStream(client.getInputStream()));
        String msg = is.readUTF();
        // 4.处理数据
        System.out.println(msg);
        // 5.关闭
        is.close();
        client.close();
        server.close();
    }

TCP 单向登录: 客户端和服务端

public static void main(String[] args) throws IOException {
        System.out.println("-------我是客户端---------");
        //1.定义客户端
        Socket client = new Socket("localhost",9898);
        //2.准备数据(用户输入)
        //    1)输入流
        BufferedReader rd = new BufferedReader(new InputStreamReader(System.in));
        //    2)用户名与密码
        System.out.println("请输入用户名");
        String username = rd.readLine();
        System.out.println("请输入密码");
        String password = rd.readLine();
        System.out.println(username+"-->"+password);
        //3.获取输出流向服务器端发送数据(用户名与密码)
        DataOutputStream os = new DataOutputStream(client.getOutputStream());
        //username=laopei&password=1234
        os.writeUTF("username="+username+"&password="+password);
        //4.刷出
        os.flush();
        //5.关闭
        os.close();
        rd.close();
        client.close();
    }

 

public static void main(String[] args) throws IOException {
        System.out.println("--------我是服务器-------");
        //1.定义我是服务器
        ServerSocket server = new ServerSocket(9898);
        //2.阻塞式监听
        Socket client = server.accept();
        System.out.println("一个客户端连接成功........");
        //3.获取输入流接收客户端发动的数据
        DataInputStream is = new DataInputStream(client.getInputStream());
        String msg = is.readUTF();  //username=laopei&password=1234
        //4.处理数据
        System.out.println(msg);
        //5.关闭
        is.close();
        client.close();
        server.close();
    }

TCP 双向登录: 客户端和服务端

public static void main(String[] args) throws IOException {
        System.out.println("-------我是客户端---------");
        //1.定义客户端
        Socket client = new Socket("localhost",9898);
        //2.准备数据(用户输入)
        //    1)输入流
        BufferedReader rd = new BufferedReader(new InputStreamReader(System.in));
        //    2)用户名与密码
        System.out.println("请输入用户名");
        String username = rd.readLine();
        System.out.println("请输入密码");
        String password = rd.readLine();
        System.out.println(username+"-->"+password);
        //3.获取输出流向服务器端发送数据(用户名与密码)
        DataOutputStream os = new DataOutputStream(client.getOutputStream());
        //username=laopei&password=1234
        os.writeUTF("username="+username+"&password="+password);
        //4.刷出
        os.flush();

        //5.获取输入流 从服务器端读取响应
        DataInputStream is = new DataInputStream(client.getInputStream());
        System.out.println(is.readUTF());;

        //6.关闭
        is.close();
        os.close();
        rd.close();
        client.close();
    }

 

 public static void main(String[] args) throws IOException {
        System.out.println("--------我是服务器-------");
        //1.定义我是服务器
        ServerSocket server = new ServerSocket(9898);
        //2.阻塞式监听
        Socket client = server.accept();
        System.out.println("一个客户端连接成功........");
        //3.获取输入流接收客户端发动的数据
        DataInputStream is = new DataInputStream(client.getInputStream());
        String msg = is.readUTF();  //username=laopei&password=1234
        //4.处理数据
        System.out.println(msg);
        //处理1)
        /*String str = "username=laopei&password=1234";
        if(str.equals(msg)){
            System.out.println("登录成功");
        }else{
            System.out.println("登录失败");
        }*/

        //2)
        String username = null;
        String password = null;
        String[] strs = msg.split("&");
        for(String s:strs){
            String[] arr = s.split("=");
            if("username".equals(arr[0])){
                username = arr[1];
            }else if("password".equals(arr[0])){
                password = arr[1];
            }
        }

        //5.获取输出流 把结果响应 给客户端
        DataOutputStream os = new DataOutputStream(client.getOutputStream());

        if("laopei".equals(username) && "1234".equals(password)){
            os.writeUTF("登录成功");
        }else{
            os.writeUTF("登录失败");
        }

        //6.刷出
        os.flush();
        //7.关闭
        os.close();
        is.close();
        client.close();
        server.close();
    }

TCP 双向登录: 服务端（多线程实现）

        通过循环

public static void main(String[] args) throws IOException {
        System.out.println("--------我是服务器-------");
        //1.定义我是服务器
        ServerSocket server = new ServerSocket(9898);
        //2.阻塞式监听
        boolean flag = true;
        while(flag){
           Socket client = server.accept();
           System.out.println("一个客户端连接成功........");
           //3.获取输入流接收客户端发动的数据
           DataInputStream is = new DataInputStream(client.getInputStream());
           String msg = is.readUTF();
           //4.处理数据
           String username = null;
           String password = null;
           String[] strs = msg.split("&");
           for(String s:strs){
               String[] arr = s.split("=");
               if("username".equals(arr[0])){
                   username = arr[1];
               }else if("password".equals(arr[0])){
                   password = arr[1];
               }
           }

           //5.获取输出流 把结果响应 给客户端
           DataOutputStream os = new DataOutputStream(client.getOutputStream());

           if("laopei".equals(username) && "1234".equals(password)){
               os.writeUTF("登录成功");
           }else{
               os.writeUTF("登录失败");
           }

           //6.刷出
           os.flush();
           //7.关闭
           os.close();
           is.close();
           client.close();
       }
        server.close();
    }

多线程实现

public static void main(String[] args) throws IOException {
        System.out.println("--------我是服务器-------");
        //1.定义我是服务器
        ServerSocket server = new ServerSocket(9898);
        //2.阻塞式监听
        boolean flag = true;
        while(flag){
           Socket client = server.accept();
           System.out.println("一个客户端连接成功........");

           //开启线程为上面监听到客户端响应
            new Thread(new Channel(client)).start();

       }
        server.close();
    }

    static class Channel implements Runnable{
        private Socket client = null;
        private DataInputStream is = null;
        private  DataOutputStream os = null;

        public Channel(Socket client) {
            this.client = client;
            try {
                is = new DataInputStream(client.getInputStream());
                os = new DataOutputStream(client.getOutputStream());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        //读入数据
        public String read(){
            String msg = null;
            try {
                msg = is.readUTF();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return msg;
        }

        //写出
        public void write(String msg){
            try {
                os.writeUTF(msg);
                os.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        //关闭资源
        public void close(){
            if(os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(client!=null){
                try {
                    client.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


        @Override
        public void run() {
            //获取输入流接收客户端发动的数据
            String msg = read();

            //处理数据
            String username = null;
            String password = null;
            String[] strs = msg.split("&");
            for(String s:strs){
                String[] arr = s.split("=");
                if("username".equals(arr[0])){
                    username = arr[1];
                }else if("password".equals(arr[0])){
                    password = arr[1];
                }
            }

            //获取输出流 把结果响应 给客户端
            if("laopei".equals(username) && "1234".equals(password)){
                write("登录成功");
            }else{
                write("登录失败");
            }

            //关闭
            close();
        }
    }

这里MMMMMM东西吗？
关注
【android学习记录】socket的初步学习
ladyishenlong的博客
02-26 125
/** * Created by 123 on 2018/2/26. * * http通信是“请求——响应”的方式 * socket则是双方连接起来之后进行实时通信 * * TCP/IP * * 使用UDP方式android端和服务器端接收可以看出， * 其实android端和服务器端的发送和接收大庭相径， * 只要端口号正确，相互通信就没有问题。 * TCP使用的是流的方式...
2021.07.12 Java学习笔记之数组
Mxxxxxx_的博客
07-12 132
数组 数组对于每个编程语言来说都是重要的数据结构之一，不过每个语言对于数组的实现以及处理也不相同。 Java中提供的数组是用来存储固定大小的同类型元素。 数组就是相同数据的有序集合，在内存中是一段连续的内存空间 数组： 1. 引用数据类型 2. 长度一旦确定就不可以改变， 3. 存储的多个数据要求数据类型保持一致 ...
2021.07.20 Java学习笔记之 Set
Mxxxxxx_的博客
07-21 110
List ： 有序的，可重复的 新增了一些根据索引操作的方法 ArrayList
Java 学习笔记 2021.6.72021.6.8
qq_的博客
06-08 153
Java学习笔记210 日期类-Calendar类概述213 异常214 异常-异常处理异常-Throwable的成员方法217 异常-编译时异常和运行时异常的区别![在这里插入图片描述](https://img-blog.csdnimg.cn/20210607115137929.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4MTI4N
命令模式 (学习笔记2021.07.15)
志豪的博客
07-15 107
命令模式(学习笔记2021.07.15) 前言: 命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。 **意图：**将一个请求封装成一个对象，从而使您可以用不同的请求对客户进行参数化。 (解耦) **主要解决：**在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，比如需要对行为进行记录、撤销或重做、事务等处理时，这种无法抵
java学习笔记之面向对象编程1—2021-03/07
hyiter的博客
03-12 109
一 、学习面向对象内容的三条主线 - 1.java类及类的成员 - 2.面向对象的三大特征 - 3.其他关键字 二、学习内容 - 1.面向对象与面向过程 - 2.JAVA语言的基本元素：类和对象 - 3.类的成员之一：属性 - 4.累的成员之二：方法 - 5.对象的创建和使用 - 6.面向对象特征之一：封装和隐藏 - 7.类的成员之三：构造器（构造方法） - 8.几个关键字：super、this、package、import 三、面向对象与面向过程 1、面向对象（OOP）与面向过程（POP） - 二者都
Java学习笔记2021/07/23
joker_r4511的博客
07-23 104
网络编程 IP地址和端口号 IP地址被分成了A、B、C、D、E五类，每个类别的网络标识和主机标识各有规则。 ➢ A类：10.0.0.0～10.255.255.255 ➢ B类：172.16.0.0～172.31.255.255 ➢ C类：192.168.0.0～192.168.255.255 IP地址用于唯一地标识网络上的一个通信实体，但一个通信实体可以有多个通信程序同时提供网络服务，此时还需要使用端口。端口是一个16位的整数，用于表示数据交给哪个通信程序处理。 端口号可以从0到65535，通常将它分为如下
[ 一 ] JAVA概述-学习笔记
Jenlibein的博客
07-23 947
JAVA学习概述本文章为JAVA学习笔记，参考尚硅谷教程。
TypeScript学习笔记（2021.08.02）
weixin_45817987的博客
08-02 893
一.TypeScript快速上手 初识 TypeScript 1. 初识 TypeScript TypeScript 的介绍 TypeScript是一种由微软开发的开源、跨平台的编程语言。它是JavaScript的超集，最终会被编译为JavaScript代码。 2012年10月，微软发布了首个公开版本的TypeScript，2013年6月19日，在经历了一个预览版之后微软正式发布了正式版TypeScript TypeScript的作者是安德斯·海尔斯伯格，C#的首席架构师。它是开源和跨平台的编程语言。 T
第一周期(2021_07_10-2021_07_19).pdf
09-09
【标题】：“第一周期(2021_07_10-2021_07_19).pdf”通常代表着一个学习或工作计划的文档，涵盖了一段时间内的学习内容，例如从2021年7月10日到2021年7月19日的学习笔记或项目进展。 【描述】：“第一周期(2021_07_...
2021年 第12届 蓝桥杯 Java B组 省赛真题详解及小结【第1场省赛 2021.04.18】
upward
01-28 8623
2021年 第12届 蓝桥杯 Java B组 省赛真题详解及小结【第1场省赛 2021.04.18】
Java语言学习笔记——20121220课程笔记
z542785951的博客
12-26 1308
一、计算机的基础知识 1、什么是计算机 能够处理海量数据，并且能高速运行程序的一套电子设备 应用场景：云计算（一码通）/多媒体应用看电影/科学计算/计算机辅助设计（CAD工程制图）/数据的处理 组成：软件/硬件 计算机硬件 软件：系统软件；应用软件 系统软件：DOS (Disk Operating:使用命令行方式) Windows/Linux/Mac 应用软件： ...
PYTHON学习笔记之（一）2020.08
guofeng_0的博客
08-22 2076
PYTHON学习笔记之（一）2020.08 Python基础 数据类型 1 列表 list 1.1 列表转换字符串 stu = ['王一', '李二', '张三'] print(stu) nStu = ' - '.join(stu) print(nStu) [‘王一’, ‘李二’, ‘张三’] 王一 - 李二 - 张三 1.2 字符串转列表 strT = 'a good day' lst = strT.split(' ') print(lst) [‘a’, ‘good’, ‘day’] 2 字典
spring事务详细讲解-深入浅出
小电玩
09-08 526
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1511
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
自动生成不重复的订单id
最新发布
ClaireCheney的博客
09-13 157
【代码】自动生成不重复的订单id。
Java集合：Stack详解
yang_brother的博客
09-10 570
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 604
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值