xs XMLSchema dom解析

最新推荐文章于 2023-01-13 17:18:22 发布
最新推荐文章于 2023-01-13 17:18:22 发布
阅读量1.1k 收藏
点赞数
文章标签： xml 解析
本文介绍了一个使用Java实现的DOM解析器，该解析器能够读取XML文件，并执行插入、删除和更新操作。此外，文章还展示了如何验证XML文件是否符合指定的XSD模式。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

package Domjiexi;
import java.io.File;  
import java.io.FileOutputStream;  
import java.io.IOException;  
  
import javax.xml.parsers.DocumentBuilder;  
import javax.xml.parsers.DocumentBuilderFactory;  
import javax.xml.parsers.ParserConfigurationException;  
import javax.xml.transform.Result;  
import javax.xml.transform.Source;  
import javax.xml.transform.Transformer;  
import javax.xml.transform.TransformerConfigurationException;  
import javax.xml.transform.TransformerException;  
import javax.xml.transform.TransformerFactory;  
import javax.xml.transform.dom.DOMResult;  
import javax.xml.transform.dom.DOMSource;  
import javax.xml.transform.stream.StreamResult;  
import javax.xml.validation.Schema;  
import javax.xml.validation.SchemaFactory;  
import javax.xml.validation.Validator;  
import javax.xml.xpath.XPath;  
import javax.xml.xpath.XPathConstants;  
import javax.xml.xpath.XPathExpressionException;  
import javax.xml.xpath.XPathFactory;

import org.apache.log4j.Logger;
import org.w3c.dom.Document;  
import org.w3c.dom.Element;  
import org.w3c.dom.Node;  
import org.w3c.dom.NodeList;  
import org.w3c.dom.Text;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
public class DomParser {
	   Logger logger=Logger.getLogger(DomParser.class);
	    private static final int FLAG_TRACE = 1;  
	  
	    private static final int FLAG_INSERT = 2;  
	  
	    private static final int FLAG_DELETE = 3;  
	  
	    private static final int FLAG_UPDATE = 4;  
	  
	    private static final String JAXP_SCHEMA_LANGUAGE = "http://java.sun.com/xml/jaxp/properties/schemaLanguage";  
	  
	    private static String W3C_XML_SCHEMA = "http://www.w3c.org/2001/XMLSchema";  
	  
	    private static String W3C_APACHE = "http://apache.org/xml/features/validation/schema";  
	  
	    File xmlFile = new File("src/student.xml");  
	  
	    DocumentBuilderFactory xmlfactory = null;  
	  
	    DocumentBuilder builder = null;  
	  
	    Document document = null;  
	  
	    Element root = null;  
	  
	    public DomParser() throws ParserConfigurationException, SAXException,  
	            IOException {  
	        xmlfactory = DocumentBuilderFactory.newInstance();  
	        xmlfactory.setValidating(true);  
	        xmlfactory.setNamespaceAware(true);  
	        xmlfactory.setAttribute(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);  
	        xmlfactory.setFeature(W3C_APACHE, true);  
	        xmlfactory.setIgnoringElementContentWhitespace(true);  
	        builder = xmlfactory.newDocumentBuilder();
	        builder.setErrorHandler(myErrorHandler()); 
	        builder = xmlfactory.newDocumentBuilder();  
	        document = builder.parse(xmlFile);  
	        root = document.getDocumentElement();  
	        removeWhilespace(root);  
	    }  
	  
	    private void doSth(int flag) {  
	        switch (flag) {  
	        case FLAG_TRACE:  
	            traceDomTree();  
	            break;  
	        case FLAG_INSERT:  
	            insertOneNode();  
	            break;  
	        case FLAG_DELETE:  
	            deleteOneNode();  
	            break;  
	        case FLAG_UPDATE:  
	            updateOneNode();  
	            break;  
	        }  
	    }  
	  
	    private void traceDomTree() {//遍历  
	        NodeList children = root.getChildNodes();  
	        for (int i = 0; i < children.getLength(); i++) {  
	            Element child = (Element) children.item(i);  
	            Element element = (Element) child.getFirstChild();  
	            while (element.getNextSibling() != null) {  
	                System.out.println(element.getTextContent());  
	                element = (Element) element.getNextSibling();  
	            }  
	            System.out.println(element.getTextContent());  
	        }  
	    }  
	    
	    private void insertOneNode() {  
	        Element theStudent = document.createElement("STUDENT");  
	        theStudent.setAttribute("STUDENT_ID", "2003710201");  
	  
	        Element theElement = document.createElement("PASSWORD");  
	        theElement.setTextContent("[137Joanna]");  
	        theStudent.appendChild(theElement);  
	  
	        theElement = document.createElement("FIRST_NAME");  
	        theElement.setTextContent("Chang");  
	        theStudent.appendChild(theElement);  
	  
	        theElement = document.createElement("LAST_NAME");  
	        theElement.setTextContent("Xiangzhong");  
	        theStudent.appendChild(theElement);  
	  
	        theElement = document.createElement("MAJOR_NUMBER");  
	        theElement.setTextContent("1");  
	        theStudent.appendChild(theElement);  
	  
	        root.appendChild(theStudent);  
	        
	        try {  
	            xml2File(root);  
	            validate(root);  
	            output(root);
	        } catch (SAXException e) {  
	            // TODO Auto-generated catch block  
	            e.printStackTrace();  
	        } catch (IOException e) {  
	            // TODO Auto-generated catch block  
	            e.printStackTrace();  
	        } catch (TransformerException e) {  
	            // TODO Auto-generated catch block  
	            e.printStackTrace();  
	        }  
	    }  
	  
	    private void deleteOneNode() {  
	        Element theStudent = (Element) selectSingleNode(  
	                "/STUDENTS/STUDENT[@STUDENT_ID='3']", root);  
	        output(theStudent.getParentNode());  
	        Node root = theStudent.getParentNode();  
	        root.removeChild(theStudent);  
	        output(root);  
	    }  
	  
	    private void updateOneNode() {  
	        Element theStudent = (Element) selectSingleNode(  
	                "/STUDENTS/STUDENT[FIRST_NAME='Miao']", root);  
	        output(theStudent.getParentNode());  
	        theStudent.getElementsByTagName("MAJOR_NUMBER").item(0).setTextContent(  
	                "99999999999999999999");  
	        output(theStudent.getParentNode());  
	    }  
	  
	    private Node selectSingleNode(String expression, Object source) {  
	        XPathFactory xPathFactory = XPathFactory.newInstance();  
	        XPath xPath = xPathFactory.newXPath();  
	        Node result = null;  
	        try {  
	            result = (Node) xPath.evaluate(expression, source,  
	                    XPathConstants.NODE);  
	        } catch (XPathExpressionException e) {  
	            // TODO Auto-generated catch block  
	            e.printStackTrace();  
	        }  
	        return result;  
	    }  
	  
	    public static NodeList selectNodes(String express, Object source) {  
	        NodeList result = null;  
	        XPathFactory xpathFactory = XPathFactory.newInstance();  
	        XPath xpath = xpathFactory.newXPath();  
	        try {  
	            result = (NodeList) xpath.evaluate(express, source,  
	                    XPathConstants.NODESET);  
	        } catch (XPathExpressionException e) {  
	            e.printStackTrace();  
	        }  
	  
	        return result;  
	    }  
	  
	    private void xml2File(Node node) throws IOException, TransformerException {  
	        TransformerFactory tFactory = TransformerFactory.newInstance();  
	        Transformer transformar = tFactory.newTransformer();  
	        File file = new File("src/student.xml");  
	        file.createNewFile();  
	        Source source = new DOMSource(node);  
	        FileOutputStream out = new FileOutputStream(file);  
	        transformar.transform(source, new StreamResult(out));  
	    }  
	  
	    private void validate(Node node) throws SAXException, IOException {  
	        SchemaFactory schemaFactory = SchemaFactory  
	                .newInstance("http://www.w3.org/2001/XMLSchema");  
	        File xsdFile = new File("src/students.xsd");  
	        Schema schema = schemaFactory.newSchema(xsdFile);  
	        Validator validator = schema.newValidator();  
	        Source source = new DOMSource(node);  
	        Result result = new DOMResult();  
	        validator.validate(source, result);  
	    }  
	  
	    private int removeWhilespace(Element element) {  
	        int count = 0;  
	        NodeList children = element.getChildNodes();  
	        if (children.getLength() <= 1) {  
	            return 0;  
	        } else {  
	            for (int i = children.getLength() - 1; i >= 0; i--) {  
	                Node child = children.item(i);  
	                if (child instanceof Text  
	                        && ((Text) child).getData().trim().length() == 0) {  
	                    element.removeChild(child);  
	                    count++;  
	                } else if (child instanceof Element) {  
	                    count += removeWhilespace((Element) child);  
	                }  
	            }  
	        }  
	        return count;  
	    }  
	     
	    // 解析错误处理
  public ErrorHandler myErrorHandler(){ 
    return   new ErrorHandler() {  
            @Override  
            public void warning(SAXParseException exception) throws SAXException {  
                logger.warn(exception.getMessage());  
            }  

            @Override  
            public void fatalError(SAXParseException exception) throws SAXException {  
                logger.error(exception.getMessage());  
            }  

            @Override  
            public void error(SAXParseException exception) throws SAXException {  
                logger.error(exception.getMessage());  
            }  
        };  
    

  } 
	    public static void output(Node node) {  
	        TransformerFactory transFactory = TransformerFactory.newInstance();  
	        try {  
	            Transformer transformer = transFactory.newTransformer();  
	            transformer.setOutputProperty("indent", "yes");  
	  
	            DOMSource source = new DOMSource();  
	            source.setNode(node);  
	            StreamResult result = new StreamResult();  
	            result.setOutputStream(System.out);  
	  
	            transformer.transform(source, result);  
	        } catch (TransformerConfigurationException e) {  
	            e.printStackTrace();  
	        } catch (TransformerException e) {  
	            e.printStackTrace();  
	        }  
	    }  
	  
	    public static void main(String[] args) throws ParserConfigurationException,  
	            SAXException, IOException {  
	        DomParser parser = new DomParser();  
	        //parser.doSth(FLAG_TRACE);  
	       parser.doSth(FLAG_INSERT);  
	       /*  parser.doSth(FLAG_DELETE);  
	        parser.doSth(FLAG_UPDATE);*/  
	    }  
	  
}

<?xml version="1.0" encoding="UTF-8"?>
<STUDENTS xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:noNamespaceSchemaLocation="students.xsd">
	<STUDENT STUDENT_ID="1">
		<PASSWORD>19841230</PASSWORD>
		<FIRST_NAME>Xiangzhong</FIRST_NAME>
		<LAST_NAME>Chang</LAST_NAME>
		<MAJOR_NUMBER>7</MAJOR_NUMBER>
	</STUDENT>
	<STUDENT STUDENT_ID="2">
		<PASSWORD>19841230</PASSWORD>
		<FIRST_NAME>Miao</FIRST_NAME>
		<LAST_NAME>Wu</LAST_NAME>
		<MAJOR_NUMBER>7</MAJOR_NUMBER>
	</STUDENT>
	<STUDENT STUDENT_ID="3">
		<PASSWORD>19841230</PASSWORD>
		<FIRST_NAME>Juntai</FIRST_NAME>
		<LAST_NAME>Wang</LAST_NAME>
		<MAJOR_NUMBER>7</MAJOR_NUMBER>
	</STUDENT>
	<STUDENT STUDENT_ID="2003710201">
		<PASSWORD>[137Joanna]</PASSWORD>
		<FIRST_NAME>Chang</FIRST_NAME>
		<LAST_NAME>Xiangzhong</LAST_NAME>
		<MAJOR_NUMBER>1</MAJOR_NUMBER>
	</STUDENT>
	<STUDENT STUDENT_ID="2003710201">
		<PASSWORD>[137Joanna]</PASSWORD>
		<FIRST_NAME>Chang</FIRST_NAME>
		<LAST_NAME>Xiangzhong</LAST_NAME>
		<MAJOR_NUMBER>1</MAJOR_NUMBER>
	</STUDENT>
	<STUDENT STUDENT_ID="2003710201">
		<PASSWORD>[137Joanna]</PASSWORD>
		<FIRST_NAME>Chang</FIRST_NAME>
		<LAST_NAME>Xiangzhong</LAST_NAME>
		<MAJOR_NUMBER>1</MAJOR_NUMBER>
	</STUDENT>
	<STUDENT STUDENT_ID="2003710201">
		<PASSWORD>[137Joanna]</PASSWORD>
		<FIRST_NAME>Chang</FIRST_NAME>
		<LAST_NAME>Xiangzhong</LAST_NAME>
		<MAJOR_NUMBER>1</MAJOR_NUMBER>
	</STUDENT>
	<STUDENT STUDENT_ID="2003710201">
		<PASSWORD>[137Joanna]</PASSWORD>
		<FIRST_NAME>Chang</FIRST_NAME>
		<LAST_NAME>Xiangzhong</LAST_NAME>
		<MAJOR_NUMBER>1</MAJOR_NUMBER>
	</STUDENT>
	<STUDENT STUDENT_ID="2003710201">
		<PASSWORD>[137Joanna]</PASSWORD>
		<FIRST_NAME>Chang</FIRST_NAME>
		<LAST_NAME>Xiangzhong</LAST_NAME>
		<MAJOR_NUMBER>1</MAJOR_NUMBER>
	</STUDENT>
	<STUDENT STUDENT_ID="2003710201">
		<PASSWORD>[137Joanna]</PASSWORD>
		<FIRST_NAME>Chang</FIRST_NAME>
		<LAST_NAME>Xiangzhong</LAST_NAME>
		<MAJOR_NUMBER>1</MAJOR_NUMBER>
	</STUDENT>
	<STUDENT STUDENT_ID="2003710201">
		<PASSWORD>[137Joanna]</PASSWORD>
		<FIRST_NAME>Chang</FIRST_NAME>
		<LAST_NAME>Xiangzhong</LAST_NAME>
		<MAJOR_NUMBER>1</MAJOR_NUMBER>
	</STUDENT>
	<STUDENT STUDENT_ID="2003710201">
		<PASSWORD>[137Joanna]</PASSWORD>
		<FIRST_NAME>Chang</FIRST_NAME>
		<LAST_NAME>Xiangzhong</LAST_NAME>
		<MAJOR_NUMBER>1</MAJOR_NUMBER>
	</STUDENT>
	<STUDENT STUDENT_ID="2003710201">
		<PASSWORD>[137Joanna]</PASSWORD>
		<FIRST_NAME>Chang</FIRST_NAME>
		<LAST_NAME>Xiangzhong</LAST_NAME>
		<MAJOR_NUMBER>1</MAJOR_NUMBER>
	</STUDENT>
	<STUDENT STUDENT_ID="2003710201">
		<PASSWORD>[137Joanna]</PASSWORD>
		<FIRST_NAME>Chang</FIRST_NAME>
		<LAST_NAME>Xiangzhong</LAST_NAME>
		<MAJOR_NUMBER>1</MAJOR_NUMBER>
	</STUDENT>
	<STUDENT STUDENT_ID="2003710201">
		<PASSWORD>[137Joanna]</PASSWORD>
		<FIRST_NAME>Chang</FIRST_NAME>
		<LAST_NAME>Xiangzhong</LAST_NAME>
		<MAJOR_NUMBER>1</MAJOR_NUMBER>
	</STUDENT>
	<STUDENT STUDENT_ID="2003710201">
		<PASSWORD>[137Joanna]</PASSWORD>
		<FIRST_NAME>Chang</FIRST_NAME>
		<LAST_NAME>Xiangzhong</LAST_NAME>
		<MAJOR_NUMBER>1</MAJOR_NUMBER>
	</STUDENT>
</STUDENTS>




    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"    
        elementFormDefault="qualified">    
        <xs:element name="STUDENTS" type="students-type" />    
        <xs:complexType name="students-type">    
            <xs:sequence maxOccurs="unbounded">    
                <xs:element name="STUDENT" type="student-type" />    
            </xs:sequence>    
        </xs:complexType>    
        <xs:complexType name="student-type">    
            <xs:sequence>    
                <xs:element name="PASSWORD" type="xs:string" />    
                <xs:element name="FIRST_NAME" type="xs:string" />    
                <xs:element name="LAST_NAME" type="xs:string" />    
                <xs:element name="MAJOR_NUMBER" type="xs:integer" />    
                <xs:any minOccurs="0" />    
            </xs:sequence>    
            <xs:attribute name="STUDENT_ID" type="xs:integer" use="required"/>    
        </xs:complexType>    
    </xs:schema>  



                

        

    

    
  



    

      

        

            

              
                
                  wcy10086
                
              
            

            

                关注
              
            

        

        

          
      

      










                



	

		

			

				
					
java设置标签内容为空_java  –  JAXB没有为空的xs：element标签创建类

				
			

			

				

					weixin_42439576的博客
				

				

					02-27
					
					653
					
				

			

		

		

			
				
好消息是你不需要生成“缺失的类”,我将在下面举例说明.schema.xsd下面是XML架构的简化版本.elementFormDefault="unqualified">富JAXB(JSR-222)实现将为每个复杂类型(命名或匿名)创建一个类.在上面的XML模式中,只有一个复杂类型(foo),因此只生成模型类.package forum12990635;import javax.xml.bin...

			
		

	



                

            
              



	

		

			

				
					
XSD中如何定义节点(Element)包含属性(Attribute)和上下文(Context)？

				
			

			

				

					weixin_30551963的博客
				

				

					03-30
					
					965
					
				

			

		

		

			
				
XSD(XML Schema Define)中一个复杂的纯文本元素可以包含文本和属性。-------------------------------------------------- ------------------------------复合纯文本元素这种类型只包含简单的内容（文本和属性），所以我们可以先添加一个xs:simpleContent元素，接着在xs:simpleCo...

			
		

	



              


  
              

                


	

		

			

				
					
XSD工具简介

				
			

			

				

					weixin_30699235的博客
				

				

					07-13
					
					1954
					
				

			

		

		

			
				
XSD使用方法介绍
XSD工具位于：C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin目录下。XSD工具有很多功能，如下：

1、将XDR 转换 XSD 
使用精简 XML 数据架构文件生成 XML 架构。 XDR 为早期基于 XML 的架构格式。

2、XML转换XSD 
使用 XML 文件生成 XML 架构。

3、XSD...

			
		

	





	

		

			

				
					
DOM 与 DOM 解析详解（四）以DOM方式解析XML

				
			

			

				

					边走边唱
				

				

					06-02
					
					144
					
				

			

		

		

			
				
    以 DOM 方式解析XML文档，示例如下（标有详细注释）

 
package Test_DOM;

import java.io.File;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFact...

			
		

	



		

			
		



	

		

			

				
					
xml文件的xsd验证失败信息

				
			

			

				

					u013862444的博客
				

				

					03-12
					
					8298
					
				

			

		

		

			
				
Referenced file contains errors http://www.springframework.org/schema/aop/spring-aop-4.1.xsd最近一个java web工程中常出现xml文件的xsd验证失败信息，异常如下：Multiple annotations found at this line:
	- Referenced file contains ...

			
		

	





	

		

			

				
					
xml dom,sax解析，schema验证

				
			

			

				

					01-28
				

			

		

		

			
				
DOM解析是将XML文档加载到内存中形成一棵树状结构，称为DOM树。每个节点代表XML文档的一个部分，如元素、属性、文本等。通过DOM，开发者可以方便地查找、修改和遍历XML文档。在C++中，Xerces-C++库提供了实现DOM解析...

			
		

	





	

		

			

				
					
XML Schema教程

				
			

			

				

					11-24
				

			

		

		

			
				
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">  <xs:element name="note">  <xs:complexType>  <xs:sequence>  <xs:element name="to" type="xs:string"/>  <xs:element name="from" type="xs:string"/>...

			
		

	





	

		

			

				
					
XML、XML Schema及XSL的应用——信息组织实验报告

				
			

			

				

					oneJiu的博客
				

				

					01-08
					
					659
					
				

			

		

		

			
				
信息组织实验：使用XML spy2011实现对XML、XML Schema及XSL的简单应用。

			
		

	





	

		

			

				
					
Python中的XML schema验证指南：结合xml.dom.minidom的实例

				
			

			

				

					
				

			

		

		

			
				
[Python中的XML schema验证指南：结合xml.dom.minidom的实例](https://i0.wp.com/rowelldionicio.com/wp-content/uploads/2019/11/Parsing-XML-with-Python-Minidom.png?fit=1024%2C576&ssl=1) # 1. XML Schema基础...

			
		

	





	

		

			

				
					
C#实现XML Schema验证程序示例

				
			

			

				

					
				

			

		

		

			
				
在C#程序中加载XML Schema文档通常涉及XmlSchema类的实例化，并且使用XmlTextReader类或其他XML读取器类来解析包含Schema定义的XML文件。  4. 如何编写验证逻辑 验证XML文档是否符合特定的XML Schema涉及使用...

			
		

	





	

		

			

				
					
xml中xsd/xsi/xsl/xmlns的区别和联系

				
			

			

				

					LiangDongPath的博客
				

				

					01-13
					
					3160
					
				

			

		

		

			
				
xml中xsd/xsi/xsl/xmlns的区别和联系

			
		

	





	

		

			

				
					
xml中schema的element元素

				
			

			

				

					李昆鹏的博客
				

				

					07-02
					
					3335
					
				

			

		

		

			
				
---------------------------------------------xml中schema的element元素------------------------------------------------element    作用：声明一个元素属性：Name：元素的名称Type：元素的类型ref：引用已定义的元素minOccurs ：至少出现的次数maxOccurs ：最多出...

			
		

	





	

		

			

				
					
Web Service （二）   WSDL详解

				
			

			

				

					xx510long的博客
				

				

					04-30
					
					1466
					
				

			

		

		

			
				
 
1.Web Service的一些相关概念
web service:远程调用的一种方案。一种解决跨平台、跨语言间的分布式系统的集成（整合）方案
esb:enterprise service bus企业服务总线
soap:simple object access protocal简单对象访问协议（http + xml）
soa:service oriented acrchietectur...

			
		

	





	

		

			

				
					
XML基础，Schema

				
			

			

				

					qq_51545380的博客
				

				

					12-14
					
					867
					
				

			

		

		

			
				
学习webservice时的部分笔记——xml，schema

			
		

	





	

		

			

				
					
xml:schema详解

				
			

			

				

					yippeelyl的专栏
				

				

					05-20
					
					4831
					
				

			

		

		

			
				
XMLSchema 详解

博客分类： 

XML
XML数据结构正则表达式Struts 



什么是Schema？ 
在计算机软件中，Schema这个词在不同的应用中有不同的含义，可以翻译为：架构、结构、规则、模式等。在XML中，Schema指的是定义和描述XML文档的规则，翻译为模式。



XML Schema与DTD的比较

我们看例4-3所示的XML文档

			
		

	





	

		

			

				
					
XML三部曲之Schema详解

				
			

			

				

					航帆远洋
				

				

					11-28
					
					5323
					
				

			

		

		

			
				
前几篇博客讨论了XML及DTD的用法，通过讨论了解到XML是一种元标记语言，通过它可以定义新的标记语言。另外，文档定义模型为XML文档提供了规范，DTD的引入虽然解决了XML文档的规范化问题，但它文件格式类型和XML文件格式类型不一致，同时DTD提供的数据类型有限有时候无法满足行业的需求，所以引入了Schema。Schema模式可以确定XML文档的元素和属性的结构、元素的顺

			
		

	





	

		

			

				
					
Dom4j：XML生成与解析实例详解

				
			

			

				

					
				

			

		

		

			
				
 Namespace namespace1 = new DefaultNamespace("xs", "http://www.w3.org/2001/XMLSchema");  Namespace namespace2 = new DefaultNamespace("", namespace);  root.add(namespace1);  root.add(namespace2);  ``` ...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值