java中使用SAX读取和写出XML文件

最新推荐文章于 2024-04-04 00:29:09 发布
最新推荐文章于 2024-04-04 00:29:09 发布
阅读量1.5w 收藏 13
点赞数 4
分类专栏： java技术 文章标签： xml java string notifications exception attributes
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chjttony/article/details/7610483
版权

SAX是一种事件驱动的流式XML文件处理方式，区别与DOM方式的是不需要在内存中建一棵DOM树，而是根据读取XML时遇到的标签事件来顺序处理，因此具有速度快，内存占用上的优点。SAX往往是大容量XML文件处理的首选方法，SAX读取XML相对比较简单，但是写XML就稍微比DOM方式复杂一些，网上的例子也不够全面和详细，刚好在工作中用到了XML读取和写出XML，记录下来以供参考。

读取XML文件：

首先，要读取的目标XML文件如下：

<?xml version="1.0" encoding="UTF-8" ?>
<oes:Notifications xmlns:oes="http://xml.sax.test.com/oesAccessNotification">
    <oes:Notification>
        <oes:NotificationID>11111</oes:NotificationID>
        <oes:NotificationType>AlarmNew</oes:NotificationType>
        <oes:timeStamp>2009-02-25T08:57:17</oes:timeStamp>
        <oes:Appendix>
            <oes:MapItem key="key" value="value"/>
        </oes:Appendix>
        <oes:Content>
            <alarmNew systemDN="PLMN-1/S3SN-1/SRME-BSS-2/SBSS-0">
                <alarmId>400951</alarmId>
                <alarmText>PIPE 0 IS SLOW OR NOT WORKING</alarmText>
                <eventTime>2009-02-25T08:57:17+02:00</eventTime>
                <eventType>processingError</eventType>
                <perceivedSeverity>critical</perceivedSeverity>
                <probableCause>0</probableCause>
                <specificProblem>86600</specificProblem>
                <additionalText1>A Raised by pipe supervision script, process ID 20848</additionalText1>
                <additionalText2>A test additional text2</additionalText2>
                <additionalText3>A test additional text3</additionalText3>
                <additionalText4>A test additional text4</additionalText4>
                <additionalText5>A Original Additional text: test alarm1 | Original Probable Cause: Toxic Leak1 Detected |
                    Original alarm time: 20090901183006+0530 | Automatic clearing:Y
                </additionalText5>
                <additionalText6>Original
                </additionalText6>
            </alarmNew>
        </oes:Content>
    </oes:Notification>
</oes:Notifications>
SAX读取该XML文件的过程如下：

(1).定义XML中各种标签：

class Constant {
	public static final String NAME_SPACE = "xmlns:oes";
	public static final String SCHEMA = "http://xml.sax.test.com/oesAccessNotification";        
	public static final String NOTIFICATIONS = "oes:Notifications";        
	public static final String NOTIFICATION = "oes:Notification";
        public static final String NOTIFICATION_ID = "oes:NotificationID";
	public static final String NOTIFICATION_TYPE ="oes:NotificationType";
	public static final String TIME_STAMP = "oes:timeStamp";
	public static final String APPENDIX = "oes:Appendix";
	public static final String MAP_ITEM = "oes:MapItem";
	public static final String KEY = "key";
	public static final String VALUE = "value";
	public static final String CONTENT = "oes:Content";
	public static final String ALARM_NEW = "alarmNew";
	public static final String SYSTEM_DN = "systemDN";
	public static final String ALARM_ID = "alarmId";
	public static final String ALRAM_TEXT = "alarmText";
	public static final String EVENT_TIME = "eventTime";
	public static final String EVENT_TYPE = "eventType";
	public static final String PERCEIVED_SEVERITY = "perceivedSeverity";
	public static final String PROBABLE_CAUSE= "probableCause";
	public static final String SPECIFIC_PROBLEM = "specificProblem";
	public static final String ADDITION_TEXT1 = "additionalText1";
	public static final String ADDITION_TEXT2 = "additionalText2";
	public static final String ADDITION_TEXT3 = "additionalText3";
	public static final String ADDITION_TEXT4 = "additionalText4";
	public static final String ADDITION_TEXT5 = "additionalText5";
	public static final String ADDITION_TEXT6 = "additionalText6";
	public static final String ADDITION_TEXT7 = "additionalText7";
}

这些定义会在读取XML的处理过程中用到。

(2).定义XML文件节点对应的java对象：

class EventFactory {

	private XMLReader xmlReader;

    public static class InternalEvent {
	    private String notificationType = "";
	    
	    private Map<String, String> props = new HashMap<String, String>();

		public String getNotificationType() {
			return notificationType;
		}
		
		public String getProp(String name) {
			String str = props.get(name);
			if (str == null) {
				return "";
			} else {
				return str;
			}
		}
		
		public Map<String, String> getProps(){
			return props;
		}

		public void setNotificationType(String notificationType) {
			this.notificationType = notificationType;
		}

        public void putAttribute(String name, String value) {
            this.props.put(name, value);
        }

	}
	//调用SAX读取XML的方法，XML文件的数据会被存放到该List中
	public List<InternalEvent> read(String xmlPath) throws ParserConfigurationException, SAXException {
	    SAXParserFactory spf = SAXParserFactory.newInstance();
	    SAXParser saxParser = spf.newSAXParser();
	    
	    xmlReader = saxParser.getXMLReader();
	    List<InternalEvent> container = new LinkedList<InternalEvent>();
	    ContentHandler handler = new ReadXMLHandler(container);
        xmlReader.setContentHandler(handler);
        try {
			xmlReader.parse(new InputSource(xmlPath));
		} catch (IOException e) {
			e.printStackTrace();
		}
        return container;
	}
	
}
该对象会在SAX读取XML文件时，将XML数据转换为内存中的java对象。

(3).SAX读取XML文件：

class ReadXMLHandler extends DefaultHandler {

    private List<EventFactory.InternalEvent> eventContainer;
    private StringBuilder buf = new StringBuilder();
    private EventFactory.InternalEvent event;
    private static final Set<String> ATTR_TAGS = new HashSet<String>();

    static {
        ATTR_TAGS.add(Constant.EVENT_TIME);
        ATTR_TAGS.add(Constant.SPECIFIC_PROBLEM);
        ATTR_TAGS.add(Constant.ALRAM_TEXT);
        ATTR_TAGS.add(Constant.PERCEIVED_SEVERITY);
        ATTR_TAGS.add(Constant.ADDITION_TEXT1);
        ATTR_TAGS.add(Constant.ADDITION_TEXT2);
        ATTR_TAGS.add(Constant.ADDITION_TEXT3);
        ATTR_TAGS.add(Constant.ADDITION_TEXT4);
        ATTR_TAGS.add(Constant.ADDITION_TEXT5);
        ATTR_TAGS.add(Constant.ADDITION_TEXT6);
        ATTR_TAGS.add(Constant.ADDITION_TEXT7);
        ATTR_TAGS.add(Constant.EVENT_TYPE);
    }

    public ReadXMLHandler(List<EventFactory.InternalEvent> eventContainer) {
        this.eventContainer = eventContainer;
    }

    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        buf.setLength(0);
        if (qName.equals("oes:Notification")) {
            event = new EventFactory.InternalEvent();
            eventContainer.add(event);
        }
        else if(qName.equals(Constant.MAP_ITEM)){
        	//获取元素中的属性值，如<a key="key" value="value"/>，获取key和value
        	String key = attributes.getValue(Constant.KEY);
        	event.putAttribute(Constant.KEY, key);
        	String value = attributes.getValue(Constant.VALUE);
        	event.putAttribute(Constant.VALUE, value);
        }
        else if(qName.equals(Constant.ALARM_NEW)){
        	String systemDn = attributes.getValue(Constant.SYSTEM_DN);
        	event.putAttribute(Constant.SYSTEM_DN, systemDn);
        }
    }

    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        if (qName.equals(Constant.NOTIFICATION_TYPE)) {
            event.setNotificationType(buf.toString());
        } 
        else if (ATTR_TAGS.contains(qName)){
            event.putAttribute(qName, buf.toString());
        }
    }

    //获取元素值，如<a>abc</a>，获取其中的abc
    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        buf.append(ch, start, length);
    }

}
至此XML就读取成功

转换并写出XML文件：

比起SAX读取XML来，SAX写XML要相对复杂一些，流程如下：

(1).对读取的XML对象做一个简单的转换：

class Convert {
	public static String convertString(String value){
		return value + "_TEST";
	} 
}
转换很简单，即将XML标签加一个“_TEST”，同时给值也加一个“_TEST“

(2).写XML文件：

class WriteXML {

	SAXTransformerFactory fac = (SAXTransformerFactory) SAXTransformerFactory.newInstance();

	private TransformerHandler handler = null;
	private OutputStream outStream = null;
	private String fileName;
	private AttributesImpl atts;
	private String rootElement;
	//元素层次，用于控制XML缩进
	private static int level = 0;
	//每个层次父级缩进4个空格，即一个tab
	private static String tab = "    ";
	//系统换行符，Windows为："\n"，Linux/Unix为："/n"
	private static final String separator = System.getProperties().getProperty("os.name").toUpperCase().indexOf("WINDOWS") != -1 ? "\n" : "/n";
	
	public WriteXML(String fileName, String rootElement) {
		this.fileName = fileName;
		this.rootElement = rootElement;
		init();
	}

	public void init() {
		try {
			handler = fac.newTransformerHandler();
			Transformer transformer = handler.getTransformer();
			//设置输出采用的编码方式
			transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
			//是否自动添加额外的空白
			transformer.setOutputProperty(OutputKeys.INDENT, "yes");
			//是否忽略xml声明
			transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
			outStream = new FileOutputStream(fileName);
			Result resultxml = new StreamResult(outStream);
			handler.setResult(resultxml);
			atts = new AttributesImpl();
			start();
		}catch (Exception e) {
			e.printStackTrace();
		}
	}

	private void start() {
		try {
			handler.startDocument();
			//设置schema和名称空间
			atts.addAttribute("", "", Constant.NAME_SPACE, String.class.getName(), Constant.SCHEMA);
			handler.startElement("", "", rootElement, atts);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	//元素里面会嵌套子节点，因此元素的开始和结束分开写
	//如：<a><b>bcd</b></a>
	private void startElement(String objectElement, AttributesImpl attrs)
			throws SAXException {
		if(attrs == null){
			attrs = new AttributesImpl();
		}
		level++;
		appendTab();
		if (objectElement != null) {
			//注意，如果atts.addAttribute设置了属性，则会输出如：<a key="key" value="value">abc</a>格式
			//如果没有设置属性，则输出如：<a>abc</a>格式
			handler.startElement("", "", objectElement, attrs);
		}	
	}
	
	//正常元素结束标记，如：</a>
	private void endElement(String objectElement) throws SAXException{
		level--;
		appendTab();
		if (objectElement != null) {
			handler.endElement("", "", objectElement);
		}
	}

	//自封闭的空元素，如<a key="key" value="value"/>，不用换行，写在一行时XML自动会自封闭
	private void endEmptyElement(String objectElement) throws SAXException{
		handler.endElement("", "", objectElement);
	}
	
	//无子节点的元素成为属性，如<a>abc</a>
	private void writeAttribute(String key, String value) throws SAXException{
		atts.clear();
		level++;
		appendTab();
		handler.startElement("", "", key, atts);
		handler.characters(value.toCharArray(), 0, value.length());
		handler.endElement("", "", key);
		level--;
	}

	public void end() {
		try {
			handler.endElement("", "", rootElement);
			// 文档结束,同步到磁盘
			handler.endDocument();
			outStream.close();
		}catch (Exception e) {
			e.printStackTrace();
		}
	}

	//Tab缩进，SAX默认不自动缩进，因此需要手动根据元素层次进行缩进控制
	private void appendTab() throws SAXException{
		String indent = separator + "    ";
		for(int i = 1 ; i< level; i++){
		   indent += tab;
	   }
	   	handler.characters(indent.toCharArray(), 0, indent.length());
	}
	
	public void writeNotification(InternalEvent event) throws SAXException{
		Map<String, String> props = event.getProps();
		Set<String> keys = props.keySet();
		
		level = 0;
		//写<oes:Notification>节点
		startElement(Constant.NOTIFICATION, null);
		
		//写oes:NotificationID
		writeAttribute(Convert.convertString(Constant.NOTIFICATION_ID), Convert.convertString(props.get(Constant.NOTIFICATION_ID)));
		keys.remove(Constant.NOTIFICATION_ID);
		//写oes:NotificationType
		writeAttribute(Convert.convertString(Constant.NOTIFICATION_TYPE), Convert.convertString(event.getNotificationType()));
		//写oes:timeStamp
		writeAttribute(Convert.convertString(Constant.TIME_STAMP), Convert.convertString(props.get(Constant.TIME_STAMP)));
		keys.remove(Constant.TIME_STAMP);
		
		//写<oes:Appendix>节点
		startElement(Constant.APPENDIX, null);
		//写oes:MapItem
		atts = new AttributesImpl();
		atts.addAttribute("", "", Convert.convertString(Constant.KEY), String.class.getName(), Convert.convertString(props.get(Constant.KEY)));
		keys.remove(Constant.KEY);
		atts.addAttribute("", "", Convert.convertString(Constant.VALUE), String.class.getName(), Convert.convertString(props.get(Constant.VALUE)));
		keys.remove(Constant.VALUE);
		startElement(Constant.MAP_ITEM, atts);
		//结束oes:MapItem，由于MapItem是个自封闭的元素，需要特殊处理
		endEmptyElement(Constant.MAP_ITEM);
		keys.remove(Constant.MAP_ITEM);
		//结束oes:MapItem节点
		endElement(Constant.APPENDIX);
		keys.remove(Constant.APPENDIX);
		
		//写oes:Content节点
		startElement(Constant.CONTENT, null);
		keys.remove(Constant.CONTENT);
		
		//写alarmNew节点
		atts = new AttributesImpl();
		atts.addAttribute("", "", Convert.convertString(Constant.SYSTEM_DN), String.class.getName(), Convert.convertString(props.get(Constant.SYSTEM_DN)));
		startElement(Constant.ALARM_NEW, atts);
		keys.remove(Constant.ALARM_NEW);
		
		//写Alarm节点内的属性
		for(String key : keys){
			writeAttribute(Convert.convertString(key), Convert.convertString(props.get(key)));
		}
		
		//结束alarmNew节点
		endElement(Constant.ALARM_NEW);
		
		//结束oes:Content节点
		endElement(Constant.CONTENT);
		
		//结束<oes:Notification>节点
		endElement(Constant.NOTIFICATION);
	}
}
(3).先用SAX读取XML文件，然后使用SAX处理写出的demo程序如下： 

public class FlexMapping {
	private static String inputFile = "input/input.xml";
	private static String outputFile = "output/output.xml";
	private static List<InternalEvent> events;
	public static void main(String[] args) {
		long start = System.currentTimeMillis();
		try {
			events = new EventFactory().read(inputFile);
			WriteXML xml = new WriteXML(outputFile, Constant.NOTIFICATIONS);
			for(InternalEvent event : events){
				xml.writeNotification(event);
			}
			xml.end();
		}catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("耗时：" + (System.currentTimeMillis() - start) + "ms.");
	}
}
写出的XML文件如下： 

<?xml version="1.0" encoding="UTF-8"?>
<oes:Notifications xmlns:oes="http://xml.sax.test.com/oesAccessNotification">
    <oes:Notification>
        <oes:NotificationID_TEST>11111_TEST</oes:NotificationID_TEST>
        <oes:NotificationType_TEST>AlarmNew_TEST</oes:NotificationType_TEST>
        <oes:timeStamp_TEST>2009-02-25T08:57:17_TEST</oes:timeStamp_TEST>
        <oes:Appendix>
            <oes:MapItem key_TEST="key_TEST" value_TEST="value_TEST"/>
        </oes:Appendix>
            <oes:Content>
                <alarmNew systemDN_TEST="PLMN-1/S3SN-1/SRME-BSS-2/SBSS-0_TEST">
                    <additionalText1_TEST>A Raised by pipe supervision script, process ID 20848_TEST</additionalText1_TEST>
                    <systemDN_TEST>PLMN-1/S3SN-1/SRME-BSS-2/SBSS-0_TEST</systemDN_TEST>
                    <additionalText2_TEST>A test additional text2_TEST</additionalText2_TEST>
                    <eventTime_TEST>2009-02-25T08:57:17+02:00_TEST</eventTime_TEST>
                    <probableCause_TEST>0_TEST</probableCause_TEST>
                    <additionalText3_TEST>A test additional text3_TEST</additionalText3_TEST>
                    <alarmText_TEST>PIPE 0 IS SLOW OR NOT WORKING_TEST</alarmText_TEST>
                    <specificProblem_TEST>86600_TEST</specificProblem_TEST>
                    <additionalText6_TEST>Original_TEST</additionalText6_TEST>
                    <additionalText5_TEST>A Original Additional text: test alarm1 | Original Probable Cause: Toxic Leak1 Detected |
                    Original alarm time: 20090901183006+0530 | Automatic clearing:Y
                _TEST</additionalText5_TEST>
                    <perceivedSeverity_TEST>critical_TEST</perceivedSeverity_TEST>
                    <additionalText4_TEST>A test additional text4_TEST</additionalText4_TEST>
                    <alarmId_TEST>400951_TEST</alarmId_TEST>
                    <eventType_TEST>processingError_TEST</eventType_TEST>
            </alarmNew>
        </oes:Content>
    </oes:Notification>
</oes:Notifications>
Demo例子，仅供参考，不过已经基本上涵盖了SAX读写XML的流程。

chjttony
关注
  • 4
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
JAVA中使用SAX写XML文档
qq_43542074的博客
10-29 542
new一个class文件，为TestXml.java 其内容如下： import java.io.File; import java.io.FileWriter; import org.dom4j.Document; import org.dom4j.DocumentHelper; import org.dom4j.Element; import org.dom4j.io.OutputFormat...
java使用dom4j操作xml示例代码
09-04
Java中的DOM4J库是一个强大的XML处理工具，它提供了丰富的API来读取、修改和写入XML文档。DOM4J的灵活性和高效性使得它在处理XML数据时成为Java开发者的一个首选选择。以下是对DOM4J操作XML的详细说明： 1. **DOM4J...
Java之xml解析（Sax方式）
qq_44166712的博客
03-09 2258
Sax(Simple API for XML)采用事件驱动的方式边读边解析文档。
java 中用dom4j将文本写入xml
ray_352801250的博客
12-28 960
public void test(){ //目标文件路径 String xmlFilePath = "D:\\Program Files\\apache-maven-3.5.2\\conf\\conhig.xml"; //目标文件对象 File file = new File(xmlFilePath); XMLWriter writer = null;// 声明写XML的对象
JAX深度学习库入门
最新发布
ZhengrongYue的博客
04-04 1249
JAX深度学习库入门
使用Sax生成xml文件
红雨瓢泼的博客
07-22 804
本文介绍如何使用Sax通过实体类生成对应的xml文件 一、实体类如下 public class Book { private String id; private String name; private String author; private String price; private String year; private String edition; publi
SAX事件驱动方式解析大数据量Excel文件（亲测3万行Excel数据无压力读取）
laizhenghua的博客
05-17 4196
最近在做项目功能时，发现传统`Apache POI`提供的API去解析大量数据Excel文件时，很容易抛出内存溢出的异常，导致Excel数据很难读到内存上去。因此在网上找了很多资料，最后找到了`SAX事件驱动`方式解析Excel文件，完美解决了大数据量读取问题，在这里简单做下整理分享给大家！
使用SAX写XML文档
hairongtian的专栏
05-01 4093
http://blog.sina.com.cn/s/blog_647275f80100gie9.html（完整引用） 在Java中，我们用得最多的读写xml文件的方式是DOM，但DOM是将整个xml以DOM树的形式加载到内存中，再对DOM树进行操作，这样虽然很方便，但是，如果该xml文件较大时，就会造成内存溢出，写入xml也存在此问题，关于DOM解析的例子网上一堆一堆的，在此不作
JAVA_API1.6文档（中文）
04-12
javax.imageio.stream Java Image I/O API 的一个包，用来处理从文件和流中产生的低级别 I/O。 javax.management 提供 Java Management Extensions 的核心类。 javax.management.loading 提供实现高级动态加载的类...
java对大数据量文件内容的多线程读取和排序.pdf
10-30
下面我们将讨论如何使用 Java 对大数据量文件内容进行多线程读取和排序。 首先，我们需要生成一个随机的文本文件，其中包含至少 1 亿行，每一行必须包含 100 个字符。然后，我们需要编写一个 Java 程序，对此文本...
JAVA与XML.rar
11-10
书中的主题如下： XML基础，包括DTD、命名空间（namespace）、XML Schema和数据格式转换（Transformation） SAX应用程序编程接口，包括处理器接口、过滤器接口和写出接口 DOM应用程序编程接口，包括DOM第2层、第3层...
Java解析XML文档(二):sax读取xml文件导出excel
05-28
NULL 博文链接：https://suky.iteye.com/blog/621169
SAXParser-用SAX读取大于100M的xml文件(java)
09-24
压缩包里面有两个文件：SAX.java和SAXparse.java 用来解析大于100M的xml文件，SAX读取xml不同于DOM方式，DOM方式在解析xml前需要全部加载xml文件，当xml文件很大时，就会出现内存不足的问题，而SAX则是逐行读取xml文件，适合读取大的xml文件，例如大于100M甚至大于1G的xml数据库文件。
使用SAX方式生成XML文档
在字节里改BUG
09-21 571
先前准备工作：
java 解析xml saxreader_Java中使用DOM和SAX解析XML文件的方法示例
weixin_39970369的博客
02-16 311
dom4j介绍　　dom4j的项目地址：http://sourceforge.net/projects/dom4j/?source=directorydom4j是一个简单的开源库，用于处理XML、 XPath和XSLT，它基于Java平台，使用Java的集合框架，全面集成了DOM，SAX和JAXP。dom4j的使用下载了dom4j项目之后，解压缩，将其jar包(我的当前版本叫做dom4j-1.6....
Java解析xml文档之SAX解析
new___Smile的博客
07-16 7789
sax解析是一种边读边解析，仅向前读取，不能修改，用来读。sax创建XMLReader三步：SAXParserFactory factory = SAXParserFactory.newInstance(); SAXParser parser = factory.newSAXParser(); XMLReader reader = parser.getXMLReade
Java如何使用SAX(Simple API for XML)解析XML呢?
qq_25073223的博客
08-07 826
Java使用SAX(Simple API for XML)解析XML的方法分享
使用dom4j工具：XMLWriter写出文件（五）
weixin_30666401的博客
05-20 310
package dom4j_write; import java.io.File; import java.io.FileOutputStream; import java.io.OutputStream; import org.dom4j.Document; import org.dom4j.io.SAXReader; import org.dom4j.io.XML...
Java&Xml教程（三）使用DOM方式修改XML文件内容
weixin_33795833的博客
12-09 281
DOM解析方式也可用于修改XML数据，我们可以使用它完成新增元素、删除元素、修改元素值、修改元素属性等操作。 我们的XML文件，内容如下： employee.xml <?xml version="1.0" encoding="UTF-8" standalone="no"?> <Employees> <Employee id="1"...
java sax 创建xml_使用SAX和Java生成XML
06-01
下面是一个使用 SAX 和 Java 创建 XML 文件的示例代码： ```java import javax.xml.parsers.*; import org.xml.sax.*; import org.xml.sax.helpers.*; import java.io.*; public class CreateXMLWithSAX { public...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值