Servlet和Tomcat的异同与单一性原则的体现

已于 2022-08-12 07:49:16 修改
阅读量147 收藏
点赞数
文章标签： servlet java tomcat web
于 2022-08-11 21:41:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45778538/article/details/126277745
版权

  • Tomcat和Servlet

  • Tomcat是一个轻量级的应用服务器。能够解析JAVA代码生成.class.文件，同时j将JAVA转换成相应的HTML代码，适用于解析JSP文件。Tomcat在实际应用中又被称为容器。
  • Servlet是JAVAEE的一部分，是一个普通的JAVA类，但能够处理HTTP的请求和响应过程，又被成为服务器连接器，常使用于数据操作层。

相异性

        1.Tomcat和Servlet都能处理HTTP的请求和响应过程，这是因为两者都支持HTTP协议。而HTTP协议是基于TCP协议上的，再者TCP协议是基于JAVA Socket类上的，从本质上说Tomcat和Servelt是对JAVA io流的不同程度的封装和应用。

        2.Tomcat有九大内置对象处理请求和响应还有配置信息，Servlet也有“九大对象”处理请求和响应还有配置信息。它们一一对象。原因其实是Tomcat实现了Servlet接口和ServeltConfig接口，但Tomcat中九大内置对象不用实例化就能直接使用，而在Servlet中需要实例化“九大对象”才能使用，其原因为容器（Tomcat）在底层对九大内置对象进行了实例化。由于Tomcat实现了Serclet接口因此“九大内置对象”和“九大对象是一一对应的：

  1. request        -->ServletRequest  request = new HttpServletRequest();
  2. responce     -->ServletResponse responce = new HttpServletResponce();
  3. session       -->HttpSession session = new request.getSession();
  4. application  -->ServletContext application = resquest.getServletContext()
  5. out              -->PrintWriter out = respoce.getWriter();
  6. config          -->ServletConfig config = this.getServletConfig()
  7. pageContext -->ServletContext context=this.getServletContext();
  8. page             -->Object page=this
  9. exception

        3.Tomecat和Servlet都需要配置依赖，其中Tomcat是Apache旗下的一个免费且开源的项目，可以在Apache官网自行下载。Servlet是JAVAEE的一部分，但为了轻量化JAVAEE而作为插件的方式安装并使用Servlet。

        Tomcat的pom.xml配置

//诺存在build标签应将所有相应的插件依赖配置在其中
<build>
        //可以包含多个依赖
        <plugins>
            //单个依赖
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>9090</port>        //配置端口号
                    <path>/</path>           //配置相对路径
                    <uriEncoding>UTF-8</uriEncoding>
                </configuration>
            </plugin>
        </plugins>
</build>

        Servlet的pom.xml配置

//可以包含多个依赖
<dependencies>
    //单个依赖
     <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.0</version>
            <scope>provided</scope>
        </dependency>
</dependencies>

         4.Tomcat和Servle都能t处理请求，请求包含：get、post、put、delete、options等，最常见的是get和post请求。其中get请求是绝大部分请求的默认请求方式，而post请求常见于form表单和json的数据传输。--Tomcat是在<%JAVA代码块%>小脚本中使用java语言处理请求、而Servlet中是通过相应的的方法处理请求，而Servlet是一个接口，无法实现方法，因此所有的请求实际上是后代实现处理的。

                4.1 Servlet作为一个接口，其代表的是一个服务的生命周期。其中主要有3个方法：

                4.1.1：void init(ServletConfig var1)：初始化，由于一个服务可能是长时间的，对于需要中途进行一些初始化的内容构造函数是无法进行中途初始化的

                4.1.2 void service(ServletRequest var1, ServletResponse var2)：服务，可以处理所有请求，并响应。

                4.1.3：void destroy()：销毁，在服务结束或者容器死亡（Tomcat碟机或者关闭）（容器有很多，本文中直指Tomcat）后执行。由于服务关闭或者容器死亡是有过程的：即需要时间，因此在时间较短时有可能destroy()方法不会执行，因此不建议将一些流的关闭放在该方法中

Servlet接口源码

                4.2 ServletConfig接口：一个完整的服务除了需要一个完整的生命周期外还需要提供相应的配置方便客户端访问，在JAVA中提供了ServletConfig接口，其作用为提供配置信息。注意，Servlet和ServletConfig时同级的接口

                4.2.1 String getServletName();获取服务名

                4.2.2 String getServletName();获取服务所在的上下文

                4.2.3 String getInitParameter(String var1);获取在pom.xml的配置

   ServletConfig接口源码      

                 4.3 单一性原则：GenericServlet抽象类，在JAVA中始终秉持着单一性原则，从类方面看，接口、抽象类、普通类其被赋予的职能是不同。从继承和实现上来看，为了高可复用性而甘愿逐层继承。例如，GenericServlet抽象，只是实现了Servlet接口和ServletConfig接口，并没有进行方法的拓展，而是将拓展任务遗留给后代，而多个后代可以进行多种的拓展！

GenericServlet源码

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package javax.servlet;

import java.io.IOException;
import java.io.Serializable;
import java.util.Enumeration;
import java.util.ResourceBundle;

public abstract class GenericServlet implements Servlet, ServletConfig, Serializable {
    private static final String LSTRING_FILE = "javax.servlet.LocalStrings";
    private static ResourceBundle lStrings = ResourceBundle.getBundle("javax.servlet.LocalStrings");
    private transient ServletConfig config;

    public GenericServlet() {
    }

    public void destroy() {
    }

    public String getInitParameter(String name) {
        ServletConfig sc = this.getServletConfig();
        if (sc == null) {
            throw new IllegalStateException(lStrings.getString("err.servlet_config_not_initialized"));
        } else {
            return sc.getInitParameter(name);
        }
    }

    public Enumeration<String> getInitParameterNames() {
        ServletConfig sc = this.getServletConfig();
        if (sc == null) {
            throw new IllegalStateException(lStrings.getString("err.servlet_config_not_initialized"));
        } else {
            return sc.getInitParameterNames();
        }
    }

    public ServletConfig getServletConfig() {
        return this.config;
    }

    public ServletContext getServletContext() {
        ServletConfig sc = this.getServletConfig();
        if (sc == null) {
            throw new IllegalStateException(lStrings.getString("err.servlet_config_not_initialized"));
        } else {
            return sc.getServletContext();
        }
    }

    public String getServletInfo() {
        return "";
    }

    public void init(ServletConfig config) throws ServletException {
        this.config = config;
        this.init();
    }

    public void init() throws ServletException {
    }

    public void log(String msg) {
        this.getServletContext().log(this.getServletName() + ": " + msg);
    }

    public void log(String message, Throwable t) {
        this.getServletContext().log(this.getServletName() + ": " + message, t);
    }

    public abstract void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;

    public String getServletName() {
        ServletConfig sc = this.getServletConfig();
        if (sc == null) {
            throw new IllegalStateException(lStrings.getString("err.servlet_config_not_initialized"));
        } else {
            return sc.getServletName();
        }
    }
}

         4.4 单一性原则：HttpServlet抽象类，HttpServlet继承了GenericServlet抽象类并在其原本的功能上进行了拓展

                4.4.1 各种请求处理的方法：doGet()、doPost（）、doHead（）、doPut（）等

                4.4.2 实现继承的service（）；

                4.4.3 重载service（）方法；并调用继承的service（）；

HttpServlet源码

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package javax.servlet.http;

import java.io.IOException;
import java.lang.reflect.Method;
import java.text.MessageFormat;
import java.util.Enumeration;
import java.util.ResourceBundle;
import javax.servlet.GenericServlet;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public abstract class HttpServlet extends GenericServlet {
    private static final String METHOD_DELETE = "DELETE";
    private static final String METHOD_HEAD = "HEAD";
    private static final String METHOD_GET = "GET";
    private static final String METHOD_OPTIONS = "OPTIONS";
    private static final String METHOD_POST = "POST";
    private static final String METHOD_PUT = "PUT";
    private static final String METHOD_TRACE = "TRACE";
    private static final String HEADER_IFMODSINCE = "If-Modified-Since";
    private static final String HEADER_LASTMOD = "Last-Modified";
    private static final String LSTRING_FILE = "javax.servlet.http.LocalStrings";
    private static ResourceBundle lStrings = ResourceBundle.getBundle("javax.servlet.http.LocalStrings");

    public HttpServlet() {
    }

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_get_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }

    }

    protected long getLastModified(HttpServletRequest req) {
        return -1L;
    }

    protected void doHead(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        NoBodyResponse response = new NoBodyResponse(resp);
        this.doGet(req, response);
        response.setContentLength();
    }

    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_post_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }

    }

    protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_put_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }

    }

    protected void doDelete(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_delete_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }

    }

    private Method[] getAllDeclaredMethods(Class<? extends HttpServlet> c) {
        Class<?> clazz = c;

        Method[] allMethods;
        for(allMethods = null; !clazz.equals(HttpServlet.class); clazz = clazz.getSuperclass()) {
            Method[] thisMethods = clazz.getDeclaredMethods();
            if (allMethods != null && allMethods.length > 0) {
                Method[] subClassMethods = allMethods;
                allMethods = new Method[thisMethods.length + allMethods.length];
                System.arraycopy(thisMethods, 0, allMethods, 0, thisMethods.length);
                System.arraycopy(subClassMethods, 0, allMethods, thisMethods.length, subClassMethods.length);
            } else {
                allMethods = thisMethods;
            }
        }

        return allMethods != null ? allMethods : new Method[0];
    }

    protected void doOptions(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Method[] methods = this.getAllDeclaredMethods(this.getClass());
        boolean ALLOW_GET = false;
        boolean ALLOW_HEAD = false;
        boolean ALLOW_POST = false;
        boolean ALLOW_PUT = false;
        boolean ALLOW_DELETE = false;
        boolean ALLOW_TRACE = true;
        boolean ALLOW_OPTIONS = true;

        for(int i = 0; i < methods.length; ++i) {
            String methodName = methods[i].getName();
            if (methodName.equals("doGet")) {
                ALLOW_GET = true;
                ALLOW_HEAD = true;
            } else if (methodName.equals("doPost")) {
                ALLOW_POST = true;
            } else if (methodName.equals("doPut")) {
                ALLOW_PUT = true;
            } else if (methodName.equals("doDelete")) {
                ALLOW_DELETE = true;
            }
        }

        StringBuilder allow = new StringBuilder();
        if (ALLOW_GET) {
            allow.append("GET");
        }

        if (ALLOW_HEAD) {
            if (allow.length() > 0) {
                allow.append(", ");
            }

            allow.append("HEAD");
        }

        if (ALLOW_POST) {
            if (allow.length() > 0) {
                allow.append(", ");
            }

            allow.append("POST");
        }

        if (ALLOW_PUT) {
            if (allow.length() > 0) {
                allow.append(", ");
            }

            allow.append("PUT");
        }

        if (ALLOW_DELETE) {
            if (allow.length() > 0) {
                allow.append(", ");
            }

            allow.append("DELETE");
        }

        if (ALLOW_TRACE) {
            if (allow.length() > 0) {
                allow.append(", ");
            }

            allow.append("TRACE");
        }

        if (ALLOW_OPTIONS) {
            if (allow.length() > 0) {
                allow.append(", ");
            }

            allow.append("OPTIONS");
        }

        resp.setHeader("Allow", allow.toString());
    }

    protected void doTrace(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String CRLF = "\r\n";
        StringBuilder buffer = (new StringBuilder("TRACE ")).append(req.getRequestURI()).append(" ").append(req.getProtocol());
        Enumeration reqHeaderEnum = req.getHeaderNames();

        while(reqHeaderEnum.hasMoreElements()) {
            String headerName = (String)reqHeaderEnum.nextElement();
            buffer.append(CRLF).append(headerName).append(": ").append(req.getHeader(headerName));
        }

        buffer.append(CRLF);
        int responseLength = buffer.length();
        resp.setContentType("message/http");
        resp.setContentLength(responseLength);
        ServletOutputStream out = resp.getOutputStream();
        out.print(buffer.toString());
    }

    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getMethod();
        long lastModified;
        if (method.equals("GET")) {
            lastModified = this.getLastModified(req);
            if (lastModified == -1L) {
                this.doGet(req, resp);
            } else {
                long ifModifiedSince = req.getDateHeader("If-Modified-Since");
                if (ifModifiedSince < lastModified) {
                    this.maybeSetLastModified(resp, lastModified);
                    this.doGet(req, resp);
                } else {
                    resp.setStatus(304);
                }
            }
        } else if (method.equals("HEAD")) {
            lastModified = this.getLastModified(req);
            this.maybeSetLastModified(resp, lastModified);
            this.doHead(req, resp);
        } else if (method.equals("POST")) {
            this.doPost(req, resp);
        } else if (method.equals("PUT")) {
            this.doPut(req, resp);
        } else if (method.equals("DELETE")) {
            this.doDelete(req, resp);
        } else if (method.equals("OPTIONS")) {
            this.doOptions(req, resp);
        } else if (method.equals("TRACE")) {
            this.doTrace(req, resp);
        } else {
            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[]{method};
            errMsg = MessageFormat.format(errMsg, errArgs);
            resp.sendError(501, errMsg);
        }

    }

    private void maybeSetLastModified(HttpServletResponse resp, long lastModified) {
        if (!resp.containsHeader("Last-Modified")) {
            if (lastModified >= 0L) {
                resp.setDateHeader("Last-Modified", lastModified);
            }

        }
    }

    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        if (req instanceof HttpServletRequest && res instanceof HttpServletResponse) {
            HttpServletRequest request = (HttpServletRequest)req;
            HttpServletResponse response = (HttpServletResponse)res;
            this.service(request, response);
        } else {
            throw new ServletException("non-HTTP request or response");
        }
    }
}

5.自定义Servlet类，需要继承HttpServlet抽象类，重写service（）方法或者其他的请求处理方法（doxxx）

weixin_45778538
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
servlet和tomcat_动力节点Java学院整理
09-30
主要介绍了servlet和tomcat，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
JavaWeb之Tomcat如何找到并实例化Servlet
IT_Helianthus的博客
06-16 1704
1、浏览器发送请求 如下图所示： 第一步：在浏览器地址栏输入访问路径，向服务器发送请求； 第二步：服务器根据访问路径去web.xml文件中和<url-pattern>标签中的虚拟路径进行匹配，匹配成功后，找到已注册的servlet名称，即图中的DataServlet； 第三步：根据映射找到对应的servlet名，注意：<servlet-mapping>下的<serv...
关于Tomcat 和 Servlet
qq_43117978的博客
09-10 310
Tomcat 就是一个 servlet容器，用于在第一次请求时加载和实例化（如果特殊指定，则在容器启动时进行加载）。 servlet 一经加载，一般不会从容器中删除，直至应用服务器关闭或重新启动。但当容器做存储器回收动作时，servlet有可能被删除。也正是因为这个原因，第一次访问servlet所用的时间要大大多于以后访问所用的时间。 Tomcat的主要组件有:服务器server，服务service，连接器connector，容器container；其中 连接器和 容器 时 Tomact的两大核心 一个服.
Tomcat与Servlet的笔记
Mooneal的博客
10-26 1340
最近要使用springMvc框架做一个项目。突然想研究一下，Tomcat服务器和Servlet的关系。一.Tomcat的模块结构和简单流程看了很多关于介绍Tomcat服务器的资料，这里写一个总结。Tomcat服务器主要有几个模块构成 ，Server，Service，Connector，Container（Engine、Host、Context、Wrapper） 它们的关系如下： Server：代
Servlet简述
Asker
03-22 764
Servlet 是什么？ API是啥？ 各个版本的规范是什么？ 重大版本变化的分水岭是哪个版本？ 最新版本是什么？有什么新特性？以何种方式解决了哪些问题？ 在Spring中，占据了怎样的地位？ 它和Spring的容器，比如ApplicationContext等有什么异同? 它和Spring（的容器）是如何相互配合作用的？ 另外，web容器、Spring容器、Servlet，这三者之间的区别和联系是什么？ 正在更新中… ...
Java框架学习（一）JavaWeb基础：Maven、Spring、Tomcat、Mybatis、Springboot
芸兮的博客
06-27 876
命名规范：Spring官方提供的启动依赖包名命名时都是spring-boot-starter-功能。其他的技术提供的启动依赖包名则会将功能命名置前：功能-spring-boot-starter自定义starter需要完成两个包：启动依赖和自动配置，分别完成依赖管理功能和自动配置功能。第一步：创建两个模块，启动器和自动配置。启动器是依赖于自动配置的：第二步：完成阿里云OSS逻辑功能的实现。
java 面试题库
u011683001的专栏
03-31 2072
JAVA程序员面试宝典 面向对象的特征有哪些方面    1. 抽象：抽象就是忽略一个主题中与当前目标2. 无关的那些方面，3. 以便更充分地注意与当前目标4. 有关的方面。抽象并不5. 打算了解全部问题，而6. 只是选择其中的一部分，7. 暂时不8. 用部分细节。抽象包括两个方面，9. 一是过程抽象，10. 二是数据抽象。 11. 继承：继承是一种联结类的层次模型，12. 并且允许和鼓励
手撕面试官系列（五）：Tomcat+Mysql+设计模式面试专题
weixin_45067120的博客
04-05 140
Tomcat1 、Tomcat 的缺省端口是多少，怎么修改？2 、tomcat 有哪几种 Connector 运行模式( 优化) ？3 、Tomcat 有几种部署方式？4 、tomcat 容器是如何创建 servlet 类实例？用到了什么原理？5.tomcat 如何优化？6. 内存调优7. 垃圾回收策略调优8. 共享 session 处理9. 添加 JMS 远程监控10. 专业点的分析工具有11....
JAVA程序员笔试面试题汇总及答案 .
xcbeyond|疯狂源自梦想，技术成就辉煌
05-21 6705
1、面向对象的特征有哪些方面 (1)抽象： 抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只 是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。 (2)继承： 继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派 生，这个
JSP中include指令和include动作的区别
the blog of Lee
09-05 2639
1.include指令 语法格式:&lt;%@include file="文件的URL" %&gt; 2.include动作 语法格式: 1)&lt;jsp:include page="文件的URL"/&gt; 2)&lt;jsp:include page="文件的URL"&gt; &lt;!--param子标记如下--&gt; &lt;jsp:p
tomcat中Servlet的工作机制详细介绍
01-20
tomcat中Servlet的工作机制 在研究Servlet在tomcat中的工作机制前必须先看看Servlet规范的一些重要的相关规定，规范提供了一个Servlet接口，接口中包含的重要方法是init、service、destroy等方法，Servlet在初始化时...
JSP+Servlet+Tomcat开发新闻系统
01-28
利用JSP技术开发的新闻发布系统，主要有五大功能模块：前台查看模块，登陆验证模块，管理员管理模块，新闻类型管理模块，新闻信息管理模块，实现了对网站新闻的动态管理。因为可以用来动态发布新闻信息，所以对信息...
基于servlet+tomcat+mysql的二手物品交易平台+sql数据库.zip
08-21
基于servlet+tomcat+mysql的二手物品交易平台+sql数据库.zip基于servlet+tomcat+mysql的二手物品交易平台+sql数据库.zip基于servlet+tomcat+mysql的二手物品交易平台+sql数据库.zip基于servlet+tomcat+mysql的二手...
Linux下网络编程-简易Epll服务器和客户端
weixin_45256307的博客
05-06 419
Linux下网络编程-简易Epll服务器和客户端
一篇文章，系统性聊聊Java注解
架构风清扬
05-06 1060
一篇文章，系统性聊聊Java注解
Java代码基础算法练习-删除有序数组中的重复项-2024.05.07
最新发布
Sakurapaid的博客
05-07 188
给一个有序数组（共10个元素），请在不新建数组的情况下，删除重复出现的元素，使 每个元素只出现一次，最后请输出删除重复元素后数组的新长度和数组元素。要删除有序数组中的重复项，且不使用额外数组，可以采用。
Nacos 配置中心实例分析实践
m0_73557631的博客
05-03 1078
​ 浏览器: http://localhost:5000/nacos/config/ip。先创建e-commerce-nacos-config-client5000 模块。​ 启动e-commerce-nacos-config-client5000。​ 启动Nacos Server。
Java基础（三）：Java异常机制以及底层实现原理
Lee的博客
05-07 705
除了Java中提供的异常之外，我们也可以自定义一些异常，自定义异常可以自定义运行时异常和非运行时异常两种方式。自定义运行时异常之需要继承这个方法即可，这里我们加了一个构造方法，这样可以创建异常对象时加一些描述异常信息。自定义非运行时异常只需要继承Exception，这里也是加了一个构造方法，描述异常信息。
Servlet和tomcat的关系
03-27
Servlet是Java Web应用程序中的一个Java类，用于接收和处理来自客户端的HTTP请求，并生成HTTP响应。Tomcat是一个Java Web服务器，它可以运行Servlet和JSP（JavaServer Pages）等Web组件。Tomcat实际上是一个Servlet容器，它负责管理和执行Servlet和其他Web组件，如JSP。因此，Servlet和Tomcat之间的关系是，Tomcat提供了一个容器来运行Servlet，并对Servlet进行管理和控制。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值