Go和Java实现责任链模式

最新推荐文章于 2024-03-08 08:57:49 发布
最新推荐文章于 2024-03-08 08:57:49 发布
阅读量593 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式 java golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30614345/article/details/130446714
版权

Go和Java实现责任链模式

下面通过一个审批流程的案例来说明责任链模式的使用。

1、责任链模式

责任链模式为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这

种类型的设计模式属于行为型模式。

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的

请求传给下一个接收者，依此类推。

  • 意图：避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且

    沿着这条链传递请求，直到有对象处理它为止。

  • 主要解决：职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细

    节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。

  • 何时使用：在处理消息的时候以过滤很多道。

  • 如何解决：拦截的类都实现统一接口。

  • 关键代码：Handler 里面聚合它自己，在 HandlerRequest 里判断是否合适，如果没达到条件则向下传递，向

    谁传递之前 set 进去。

  • 应用实例：1、红楼梦中的"击鼓传花"。 2、JS 中的事件冒泡。 3、JAVA WEB 中 Apache Tomcat 对 Encoding

    的处理，Struts2 的拦截器，jsp servlet 的 Filter。

  • 优点：1、降低耦合度。它将请求的发送者和接收者解耦。 2、简化了对象。使得对象不需要知道链的结构。

    3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责

    任。 4、增加新的请求处理类很方便。

  • 缺点：1、不能保证请求一定被接收。 2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能

    会造成循环调用。 3、可能不容易观察运行时的特征，有碍于除错。

  • 使用场景：1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。 2、在不明

    确指定接收者的情况下，向多个对象中的一个提交一个请求。 3、可动态指定一组对象处理请求。

  • 注意事项：在 JAVA WEB 中遇到很多应用。

  • 适用性：

    有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。

    你在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。

    可处理一个请求的对象集合应被动态指定。

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一个链，并随着

这条链传递该请求，直到有一个对象处理它为止。这一模式的想法是，给多个对象处理一个请求的机会，从而解耦

发送者和接受者。

2、Go实现责任链模式1

package chainofresponsibility

// ========== 定义一个处理请求的接口Request ==========
type Request interface {
	Processing()
}

package chainofresponsibility

import "fmt"

// ========== 离职DimissionRequest ==========
type DimissionRequest struct {
}

func (dimissionRequest *DimissionRequest) Processing() {
	fmt.Println("处理离职!")
}

package chainofresponsibility

import "fmt"

// ========== 请假LeaveRequest ==========
type LeaveRequest struct {
}

func (LeaveRequest *LeaveRequest) Processing() {
	fmt.Println("处理请假!")
}

package chainofresponsibility

import "fmt"

// ========== 加薪AddMoneyRequest ==========
type AddMoneyRequest struct {
}

func (addMoneyRequest *AddMoneyRequest) Processing() {
	fmt.Println("处理加薪!")
}

package chainofresponsibility

// 处理它所负责的请求,可访问它的后继者,如果可处理该请求,就处理请求,否则将该请求转发给它的后继者
// ========== RequestHandle ==========
type RequestHandle interface {
	HandleRequests(Request)
	Next(RequestHandle)
}

package chainofresponsibility

import "fmt"

// ========== HRRequestHandle ==========
type HRRequestHandle struct {
	requestHandle RequestHandle
}

func (hRRequestHandle *HRRequestHandle) HandleRequests(request Request) {
	if req, ok := request.(*DimissionRequest); ok {
		fmt.Println("要离职,人事审批!")
		req.Processing()
	}
	fmt.Println("请求完成！")
}

func (hRRequestHandle *HRRequestHandle) Next(requestHandle RequestHandle) {
	hRRequestHandle.requestHandle = requestHandle
}

package chainofresponsibility

import "fmt"

// ========== PMRequestHandle ==========
type PMRequestHandle struct {
	requestHandle RequestHandle
}

func (pMRequestHandle *PMRequestHandle) HandleRequests(request Request) {
	if req, ok := request.(*AddMoneyRequest); ok {
		fmt.Println("要加薪,项目经理审批!")
		req.Processing()
	} else {
		pMRequestHandle.requestHandle.HandleRequests(request)
	}
}

func (pMRequestHandle *PMRequestHandle) Next(requestHandle RequestHandle) {
	pMRequestHandle.requestHandle = requestHandle
}

package chainofresponsibility

import "fmt"

// ========== TLRequestHandle ==========
type TLRequestHandle struct {
	requestHandle RequestHandle
}

func (tLRequestHandle *TLRequestHandle) HandleRequests(request Request) {
	if req, ok := request.(*LeaveRequest); ok {
		fmt.Println("要请假,项目组长审批!")
		req.Processing()
	} else {
		tLRequestHandle.requestHandle.HandleRequests(request)
	}
}

func (tLRequestHandle *TLRequestHandle) Next(requestHandle RequestHandle) {
	tLRequestHandle.requestHandle = requestHandle
}

package main

import (
	"fmt"
	. "proj/chainofresponsibility"
)

func main() {
	hr := HRRequestHandle{}
	pm := PMRequestHandle{}
	tl := TLRequestHandle{}

	tl.Next(&pm)
	pm.Next(&hr)

	fmt.Println("===========")
	// 人事处理离职请求
	tl.HandleRequests(&DimissionRequest{})

	fmt.Println("===========")
	// 项目经理处理加薪请求
	tl.HandleRequests(&AddMoneyRequest{})

	fmt.Println("========")
	// 组长处理请假请求
	tl.HandleRequests(&LeaveRequest{})
}

# 程序输出
===========
要离职,人事审批!
处理离职!
请求完成！
===========
要加薪,项目经理审批!
处理加薪!
========
要请假,项目组长审批!

3、Java实现责任链模式1

package com.chainofresponsibility;

// ========== 定义一个处理请求的接口Request ==========
public interface Request {
    void processing();
}

package com.chainofresponsibility;

// ========== 请假LeaveRequest ==========
public class LeaveRequest implements Request{
    @Override
    public void processing() {
        System.out.println("处理请假!");
    }
}

package com.chainofresponsibility;

// ========== 加薪AddMoneyRequest ==========
public class AddMoneyRequest implements Request {
    @Override
    public void processing() {
        System.out.println("处理加薪!");
    }
}

package com.chainofresponsibility;

// ========== 离职DimissionRequest ==========
public class DimissionRequest implements Request{
    @Override
    public void processing() {
        System.out.println("处理离职!");
    }
}

package com.chainofresponsibility;

// 处理它所负责的请求,可访问它的后继者,如果可处理该请求,就处理请求,否则将该请求转发给它的后继者
// ========== RequestHandle ==========
public abstract class RequestHandle {
    RequestHandle requestHandle;
    abstract void handleRequest(Request request);
    void next(RequestHandle requestHandle){
        this.requestHandle = requestHandle;
    }
}

package com.chainofresponsibility;

// ========== HRRequestHandle ==========
public class HRRequestHandle extends RequestHandle {

    @Override
    public void handleRequest(Request request) {
        if (request instanceof DimissionRequest) {
            System.out.println("要离职,人事审批!");
            request.processing();
        }
        System.out.println("请求完成");
    }
}

package com.chainofresponsibility;

// ========== PMRequestHandle ==========
public class PMRequestHandle extends RequestHandle {

    @Override
    public void handleRequest(Request request) {
        if (request instanceof AddMoneyRequest) {
            System.out.println("要加薪,项目经理审批!");
            request.processing();
        } else {
            requestHandle.handleRequest(request);
        }
    }
}

package com.chainofresponsibility;

public class TLRequestHandle extends RequestHandle {

    @Override
    public void handleRequest(Request request) {
        if (request instanceof LeaveRequest) {
            System.out.println("要请假,项目组长审批!");
            request.processing();
        } else {
            requestHandle.handleRequest(request);
        }
    }
}

package com.chainofresponsibility;

public class Test {

    public static void main(String[] args) {

        RequestHandle hr = new HRRequestHandle();
        RequestHandle pm = new PMRequestHandle();
        RequestHandle tl = new TLRequestHandle();

        tl.next(pm);
        pm.next(hr);

        System.out.println("===========");
        // 人事处理离职请求
        Request request = new DimissionRequest();
        tl.handleRequest(request);

        System.out.println("===========");
        // 项目经理处理加薪请求
        request = new AddMoneyRequest();
        tl.handleRequest(request);

        System.out.println("========");
        // 组长处理请假请求
        request = new LeaveRequest();
        tl.handleRequest(request);
    }
}

# 程序输出
===========
要离职,人事审批!
处理离职!
请求完成
===========
要加薪,项目经理审批!
处理加薪!
========
要请假,项目组长审批!
处理请假!

4、Go实现责任链模式2

创建 AbstractLogger，带有详细的日志记录级别，然后我们创建三种类型的记录器，都扩展了AbstractLogger。

每个记录器消息的级别是否属于自己的级别，如果是则相应打印出来，否则将消息传递给下一个记录器。

package chainofresponsibility

// ========== Logger ==========
type Logger interface {
	LogMessage(level int, message string, logger Logger)
	Write(message string)
}

package chainofresponsibility

// ========== AbstractLogger ==========
type AbstractLogger struct {
	Level      int
	NextLogger Logger
}

func (s *AbstractLogger) Write(message string) {
}

func (s *AbstractLogger) LogMessage(level int, message string, logger Logger) {
	if s.Level <= level {
		logger.Write(message)
	} else {
		if s.NextLogger != nil {
			s.NextLogger.LogMessage(level, message, s.NextLogger)
		}
	}
}

func (s *AbstractLogger) SetNextLogger(logger Logger) {
	s.NextLogger = logger
}

package chainofresponsibility

import "fmt"

// ========== FileLogger ==========
type FileLogger struct {
	AbstractLogger AbstractLogger
}

func (f *FileLogger) Write(message string) {
	fmt.Println("File::Logger: " + message)
}

func (f *FileLogger) LogMessage(level int, message string, logger Logger) {
	f.AbstractLogger.LogMessage(level, message, f)
}

package chainofresponsibility

import "fmt"

// ========== ConsoleLogger ==========
type ConsoleLogger struct {
	AbstractLogger
}

func (c *ConsoleLogger) Write(message string) {
	fmt.Println("Standard Console::Logger: " + message)
}

func (c *ConsoleLogger) LogMessage(level int, message string, logger Logger) {
	c.AbstractLogger.LogMessage(level, message, c)
}

package chainofresponsibility

import "fmt"

// ========== ErrorLogger ==========
type ErrorLogger struct {
	AbstractLogger AbstractLogger
}

func (e *ErrorLogger) Write(message string) {
	fmt.Println("Error Console::Logger: " + message)
}

func (e *ErrorLogger) LogMessage(level int, message string, logger Logger) {
	e.AbstractLogger.LogMessage(level, message, e)
}

package constant

const (
	DEBUG = iota + 1
	INFO
	ERROR
)

package main

import (
	. "proj/chainofresponsibility"
	. "proj/constant"
)

func main() {

	fileLogger := new(FileLogger)
	fileLogger.AbstractLogger.Level = DEBUG

	consoleLogger := new(ConsoleLogger)
	consoleLogger.AbstractLogger.Level = INFO

	errorLogger := new(ErrorLogger)
	errorLogger.AbstractLogger.Level = ERROR

	errorLogger.AbstractLogger.SetNextLogger(consoleLogger)
	consoleLogger.AbstractLogger.SetNextLogger(fileLogger)

	errorLogger.LogMessage(DEBUG, "This is a debug level information.", nil)
	errorLogger.LogMessage(INFO, "This is an info level information.", nil)
	errorLogger.LogMessage(ERROR, "This is an error level information.", nil)

}

# 程序输出
File::Logger: This is a debug level information.
Standard Console::Logger: This is an info level information.
Error Console::Logger: This is an error level information.

5、Java实现责任链模式2

package com.chainofresponsibility;

// ========== AbstractLogger ==========
public abstract class AbstractLogger {

    protected int level;

    // 责任链中的下一个元素
    protected AbstractLogger nextLogger;

    public void setLevel(int level) {
        this.level = level;
    }

    public void setNextLogger(AbstractLogger nextLogger) {
        this.nextLogger = nextLogger;
    }

    public void logMessage(int level, String message) {
        if (this.level <= level) {
            write(message);
        }else{
           if(nextLogger != null) {
               nextLogger.logMessage(level, message);
           }
        }
    }

    abstract protected void write(String message);
}

package com.chainofresponsibility;

// ========== FileLogger ==========
public class FileLogger extends AbstractLogger {

    @Override
    protected void write(String message) {
        System.out.println("File::Logger: " + message);
    }
}

package com.chainofresponsibility;

// ========== ConsoleLogger ==========
public class ConsoleLogger extends AbstractLogger {

    @Override
    protected void write(String message) {
        System.out.println("Standard Console::Logger: " + message);
    }
}

package com.chainofresponsibility;

// ========== ErrorLogger ==========
public class ErrorLogger extends AbstractLogger {

    @Override
    protected void write(String message) {
        System.out.println("Error Console::Logger: " + message);
    }
}

package com.chainofresponsibility;

public class Constant {
    public static int DEBUG = 1;
    public static int INFO = 2;
    public static int ERROR = 3;
}

package com.chainofresponsibility;

public class Test {

    public static void main(String[] args) {

        AbstractLogger fileLogger = new FileLogger();
        fileLogger.setLevel(Constant.DEBUG);

        AbstractLogger consoleLogger = new ConsoleLogger();
        consoleLogger.setLevel(Constant.INFO);

        AbstractLogger errorLogger = new ErrorLogger();
        errorLogger.setLevel(Constant.ERROR);

        errorLogger.setNextLogger(consoleLogger);
        consoleLogger.setNextLogger(fileLogger);

        errorLogger.logMessage(Constant.DEBUG, "This is a debug level information.");
        errorLogger.logMessage(Constant.INFO, "This is an info level information.");
        errorLogger.logMessage(Constant.ERROR, "This is an error level information.");
    }
}

# 程序输出
File::Logger: This is a debug level information.
Standard Console::Logger: This is an info level information.
Error Console::Logger: This is an error level information.
242030
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang 责任链模式（链式调用）
qq_40500045的博客
05-17 2146
golang 链式调用 文章目录golang 链式调用前言一、什么是「责任链模式」？二、「责任链模式」的具体优势三、代码案例search.goorders.go总结 前言 我们在写golang 代码的时候经常会出现我想有一个可变参数来确认初始化变量的问题或者针对于按照多种条件查询返回查询结果。 我个人比较推崇使用责任链模式（链式调用）的方式来处理，这样的代码维护简单容易理解。 一、什么是「责任链模式」？ 首先把一系列业务按职责划分成不同的对象，接着把这一系列对象构成一个链，然后在这一系列对象中传递请求
golang设计模式---责任链模式
IT艺术家-rookie的博客
12-26 681
设计模式-责任链模式
责任链模式Golang版本「附详细案例」
最新发布
pengyachuan的博客
03-08 633
责任链模式很早前学习且简单用于项目里。最近有一个 case 更复杂，结合工厂模式和策略模式一起使用，顺带把一些思考总结下来。
golang设计模式——职责链模式
qq_53267860的博客
08-15 560
通过Gin中间件的例子，可以很好证明职责链的扩展性。简单使用Use增加自己创建的中间件，每一个请求都会被新增的中间件所处理。所以开发者可以方便的增加鉴权、限流、脱敏、拦截等操作。这就是所谓的优雅吧。...
设计模式--责任链(Responsibility_Chain)模式
weixin_38299404的博客
07-26 168
模式定义 使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间耦合关系，将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止 类图 要点总结 Chain of Responsibility模式的应用场合在于“一个请求可能有多个接受者，但是最后真正的接受者只有一个”，这时候请求发送者与接受者的耦合有可能出现“变化脆弱”的症状，职责链的目的就是将二者解耦，从而更好地应对变化 应用了Chain of Responsibility模式后，对象的职责分配将更具灵活性，我们可以在运行时动态添
设计模式——Go语言（Golang）版：14_责任链模式
weixin_42117918的博客
04-07 337
示例代码： package main import "fmt" type Manager interface { HaveRight(money int)bool //有权做 HandleFeeRequest(name string,money int)bool //处理费用请求 } type RequestChain struct { Manager successor *RequestChain //后续者(链式结构，链表) } func (rc *RequestChain)HaveR
go-stream:Java Stream API的golang实现
04-25
go-stream在golang中提供Java Stream API类似于流操作 用法 package main import ( "github.com/aagu/go-stream" ) func main () { ints := [] int { 1 , 2 , 3 , 4 , 5 , 6 , 7 } stream . New ( ints ). Filter...
java:基于 go-cqhttp 和 java 的 qq 机器人
05-06
基于 go-cqhttp 和 java 的 qq 机器人 使用前 在 下载对应平台的可执行文件, 放到 go-cqhttp 目录中 运行 go-cqhttp/下载的文件, 根据提示填写 QQ 号和密码等信息, 参考文档 根据文档将go-cqhttp的上报方式修改为...
golang实现java uuid的序列化方法
01-19
目前只实现了java生成的固定的uuid：85bb94b8-fd4b-4e1c-8f49-3cedd49d8f28的序列化 package main import ( encoding/binary encoding/json fmt log os strings time github.com/Shopify/sarama github....
go语言设计模式待代码简单实现
05-08
go语言设计模式待代码简单实现
JAVA与GO语言实现的RSA加密算法的互通
09-11
关键：（1）Java支持NoPadding填充方式，并且已经封装好相应的接口，可通过Cipher.getInstance来指定RSA/ECB/NoPadding该对齐和填充方式； （2）Golang中不支持NoPadding的填充方式，需要自己处理；
Golang责任链设计模式（十三）
王佳宇的个人博客
06-04 6526
github:https://github.com/zhumengyifang/GolangDesignPatterns 上一篇代理设计模式:https://blog.csdn.net/weixin_40165163/article/details/90760219 责任链模式 顾名思义，责任链模式为请求创建了一个接受者对象的链，这种模式给予请求的类型，对请求的发送者和接受者进行解偶。这种类...
《大话设计模式-Golang》责任链模式
weixin_45717355的博客
03-08 168
责任链模式（Chain of Responsibility）：使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，指导有一个对象处理它为止。
设计模式 -责任链模式
好好学习，天天向上
12-06 482
责任链模式 ​ 在现实生活中，一个事件需要经过多个对象处理是很常见的场景。例如，采购审批流程、请假流程等。公司员工请假，可批假的领导有部门负责人、副总经理、总经理等，但每个领导能批准的天数不同，员工必须根据需要请假的天数去找不同的领导签名，也就是说员工必须记住每个领导的姓名、电话和地址等信息，这无疑增加了难度。 ​ 在计算机软硬件中也有相关例子，如总线网中数据报传送，每台计算机根据目标地址是否同自己的地址相同来决定是否接收；还有异常处理中，处理程序根据异常的类型决定自己是否处理该异常；还有 Strut.
【寒江雪】Go实现责任链模式
寒江雪的博客
03-14 2134
Chain of Responsibility Pattern   责任链模式为请求创建了一个接收者对象的链。处理请求的对象是一系列链条，或者一个集合。每个处理节点都保存有其他处理节点的引用。接收到请求的时候，会判断该请求是否需要自己处理，处理完毕传给下一个处理节点，有点像流水线作业。 例子   让我举一个复杂一点的例子。我就不用链条的形式来写了，我用一个map来保存处理器的引用。  ...
思考（五十四）：Golang 编程之责任链模式
范安崇的博客
06-08 1205
责任链模式 责任链模式：在处理核心业务前后，可能会有很多道自定义的工序，每道工序间存在线性依赖关系。简单粗暴的，是所有代码揉成一团 责任链模式使得每道工序可以自由拼接，传递顺序明确，便于扩展 典型的应用是 http 请求处理， github 上有一个项目使用了该模式，网址如下： https://github.com/gin-gonic/gin#using-middleware 下面先给一个感性的例...
责任链模式(Chain of Responsibility)
Go的全部
01-22 278
责任链模式(Chain of Responsibility) 1.意图 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。 2.适用性 在以下条件下使用Responsibility链： 有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。 你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 可处理一个请求的对象集合应被动态指定。 3.结构 一个典型的对象结构可能如下图所示: 4.
Golang设计模式——11责任链模式
清风
09-25 798
package ResponsibilityChain import ( "strconv" ) type Handler interface { Handler(handlerID int) string } type handler struct { name string next Handler handlerID int } func NewHandler(name string, next Handler, handlerID int) *handler {
go实现混合责任链和工厂模式demo
05-31
好的，下面是一个简单的示例代码，实现了混合责任链和工厂模式： ```go package main import ( "fmt" ) // 定义一个接口，表示责任链节点 type Handler interface { Handle(data interface{}) (interface{}, error) } // 定义一个具体的责任链节点 type UpperCaseHandler struct { nextHandler Handler } // 实现责任链节点的处理方法 func (h *UpperCaseHandler) Handle(data interface{}) (interface{}, error) { str, ok := data.(string) if !ok { return nil, fmt.Errorf("data is not a string") } result := fmt.Sprintf("upper case: %s", str) if h.nextHandler != nil { return h.nextHandler.Handle(result) } return result, nil } // 定义另一个具体的责任链节点 type LowerCaseHandler struct { nextHandler Handler } // 实现责任链节点的处理方法 func (h *LowerCaseHandler) Handle(data interface{}) (interface{}, error) { str, ok := data.(string) if !ok { return nil, fmt.Errorf("data is not a string") } result := fmt.Sprintf("lower case: %s", str) if h.nextHandler != nil { return h.nextHandler.Handle(result) } return result, nil } // 定义工厂方法，根据参数创建不同的责任链节点 func NewHandler(name string, nextHandler Handler) Handler { switch name { case "upper": return &UpperCaseHandler{nextHandler} case "lower": return &LowerCaseHandler{nextHandler} default: return nil } } func main() { // 创建一个混合责任链 handler := NewHandler("upper", NewHandler("lower", nil)) // 处理数据 result, err := handler.Handle("Hello World") if err != nil { fmt.Println(err) } else { fmt.Println(result) } } ``` 在上面的代码中，我们定义了一个 `Handler` 接口，表示责任链节点，具体的责任链节点实现了 `Handle` 方法，用于处理数据，并将处理结果传递给下一个节点。我们还定义了一个工厂方法 `NewHandler`，根据参数创建不同的责任链节点。在 `main` 函数中，我们创建了一个混合责任链，并用它来处理数据。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值