(三) 验证XML文档

sgq0085

浏览: 440604 次
性别:
来自: 吉林→上海

最近访客更多访客>>

sinkiangscorpio

yunzhu

angle_hxz

zenmash

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

Java基础-XML解析

解析XML parse xml DTD Schema

XML解析时，通过文档定义类型(DTD)或一个XML Schema定义自动检验某个文档的结构是否正确，减少处理空白字符或错误检查的工作。
例如，DTD包含一个规则<!ELEMENT font (name,size)>，表明一个font元素有两个子元素，分别是name和size。
XML Schema语言用于表示同样的约束形式如下

    <xsd:element name="font">
        <xsd:sequence>
            <xsd:element name="name" type="xsd:string"/>
            <xsd:element name="size" type="xsd:int"/>
        </xsd:sequence>
    </xsd:element>

Schema可以表达更复杂的验证条件(比如size元素必须包含一个整数)，与DTD语法不同，Schema使用XML，处理起来更方便。

1.文档定义类型(DTD Document Type Definition)
提供DTD的方式有多种
(1)直接写到XML文件中

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE root [
        <!Element configuration>
        more rules
    ]>
    <root>
      ...
    </root>

在该代码中使用[]来限定其界限。文档类型必须符合根元素的名字，比如上例中的root。该方法不常见，因为DTD会使XML文档变长。
(2)将DTD存储在XML文档外，并通过SYSTEM声明来实现。
可以设定一个包含DTD的URL

<!DOCTYPE root SYSTEM "config.dtd"/>

或

<!DOCTYPE root SYSTEM "http://myserver.com/config.dtd"/>

注意：如果使用的是DTD的相对URL(比如"config.dtd")，给解析器应该是一个文件或URL对象，而不是InputStream。如果必须从一个输入流来解析，需要提供实体渲染器。
(3)源于SGML的用于识别"众所周知"的DTD的机制，通过PUBLIC来定义，如果XML处理器知道如何定位带有公共标示符的DTD，则不需要URL。

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE web-app
        PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN"
        "http://java.sun.com/j2ee/dtds/web-app_2.2.dtd" >
    <web-app></web-app>

如果使用的是DTD解析器，并且想要支持公共标示符，需要调用DocumentBuilder类的setEntityResolver方法来安装EntityResolver接口的某一个实现类的一个对象，该接口只有一个方法resolveEntity

    import java.io.IOException;
    import org.xml.sax.EntityResolver;
    import org.xml.sax.InputSource;
    import org.xml.sax.SAXException;
    public class TestUsePublicDtdXML implements EntityResolver{
        @Override
        public InputSource resolveEntity(String publicId, String systemId)
                throws SAXException, IOException {
            if(publicId.equals(a know ID)){
                return new InputSource(DTD data);
            }
            return null;
        }
    }

可以从InputStream、Reader或字符串构建输入源。

(4)ELEMENT规则用于规范某个元素可以拥有什么样的子元素。可以设定一个正则表达式，它由元素内容规则表所示组件构成。

                元素内容的规则
        规则                          含义
        E*                          0或多个E
        E+                          1或多个E
        E?                          0或1个E
        E1|E2|...|En                E1,E2...En中的一个
        E1,E2,...En                 E1,随后是E2...En
        #PCDATA                     文本
        (#PCDATA|E1|E2|...En)       0或多个任意顺序的文本和E1，E2...En(混合式内容)
        ANY                         允许任意子元素
        EMPTY                       不允许有子元素

例1，menu元素包含0或多个item元素

    <!ELEMENT menu (item)*>

例2，font是用一个name后面跟一个size来描述的，它们都包含了文本

    <!ELEMENT font (name,size)>
    <!ELEMENT name (#PCDATA)>
    <!ELEMENT size (#PCDATA)>

缩写PCDTAT标识已解析的字符数据，这些数据称为“已解析的”，是因为解析器解释了该文本字符串，并正在寻找表示一个新标签起始的<字符或表示一个实体起始的&字符。
例3，元素的规范可以包含嵌套的和复杂的正则表达式，例如一个描述本书中一章的结构的规则

    <!ELEMENT chapter (intro,(heading,(para|image|table|note)+)+)>

每章都以简介开头，后面是一个或多个小节，每一个小节有一个标题和1个或多个段落、图片、表格或说明组成。
例4，当一个元素可以包含文本时，只有两种情况，一种只包含文本。

<!Element name (#PCDATA)>

另一种元素包含任意顺序的文本和标签

<!ELEMENT para (#PCDATA|strong|code)*>

其他包含#PCDATA规则的类型都是非法的，比如

<!ELEMENT captionedImage (image,#PCDATA)>

就是非法的,需要引入另一个标签来包含文本

    <!ELEMENT captionedImage (image,caption)>
    <!ELEMENT caption (#PCDATA)>

注意：在设计DTD时，其中所有的元素，要么包含其他元素，要么只有文本。
例5，XML标准允许解析器假设DTD都是非二义性的。比如((x,y)|(x,z))是错误的，可以修改为(x,(y|z))。((x,y)*|x?)也是错误的，但无法修改，这时并不会发出警告，而是选取第一个匹配项，这将导致拒绝一些正确的输入。

(5)ATTLIST用于描述合法元素属性的规则。通常语法是：

    <!ATTLIST关键字 element元素 attribute属性 type类型 default默认值>

例: font元素的style属性，有4个合法属性值，默认值是plain

    <!ATTLIST font style (plain|bold|italic|bold-italic) "plain">

size元素的unit属性可以包含任意字符串数据序列

    <!ATTLIST size unit CDATA #IMPLIED>

              属性类型
    类型                含义
    CDATA               任意字符串
    (A1|A2|...|An)      A1、A2...An之一
    NMTOKEN,NMTOKENS    1或多个名字标记
    ID                  一个唯一的ID
    IDREF,IDREFS        1或多个唯一ID的引用
    ENTITY,ENTITIES     1或多个未经解析的实体

CDTAT属性值的处理与#PCDATA有差别，并且与<![CDATA[...]]>部分没有多大关系。属性值首先被规范化，解析器会处理字符和实体的引用(比如é或<)，并且用空格来替换空白字符。
NMTOKEN(名字标记)与CDATA相似，但是大多数非字母数字字符和内部空白字符是不允许使用的，而且解析器会删除起始和结尾的空白字符。NMTOKENS是一个空白字符分隔的名字标记列表。
ID是在文档中唯一的名字标记，解析器会检查唯一性。
IDREF是对同一文档中存在的ID的引用，解析器也会对它进行检查。IDREFS是空白字符分隔的ID引用列表。
ENTITY是指一个“未经解析的外部实体”，是由SGML沿用下来的，实际应用中很少见到。DTD也可以定义实体，或者定义解析过程中被替换的缩写。

    例: <!ENTITY back.label "Back">

在其他地方，文本可以包含实体的引用

    <menuitem label="&back.label;">

解析器用替换字符串来替换实体的引用。如果对应用程序进行国际化，只需修改实体定义中的字符串。其他实体的使用更加复杂，不常用。

              属性的默认值
    默认值              含义
    #REQUIRED           属性是必须的
    #IMPLIED            属性是可选的
    A                   属性是可选的；若未指定，解析器报告的属性是A
    #FIXED A            属性必须是未设定的或者是A；两者情况下，解析器报告的属性是A

一般情况下，推荐用元素而非属性来描述数据，比如font style应该是一个独立的元素<font><style>plain</style></font>，但对于枚举类型，属性有一个优点，解析器能确认它是否合法。

(6)配置解析器来使用DTD
1)通知文档生成工厂打开验证特性。

    factory.setValidating(true);

2)指定由此工厂创建的解析器在解析 XML 文档时，必须删除元素内容中的空格

    factory.setIgnoringElementContentWhitespace(true);

3)访问子元素

    Element nameElement = (Element)children.item(0);
    Element sizeElement = (Element)children.item(1);

而不用

    for(int i=0;i<childNodes.getLength();i++){
        Node child = childNodes.item(i);
        if(child instanceof Element){
            Element childElement = (Element)child;
        }
    }

该工厂生产的所有文档生成器都将根据DTD来验证输入。验证最大的好处是忽略元素内容中的空白字符。
例:

    <font>
        <name>Helvetica</name>
        <size>36</size>
    </font>

一旦设定子元素是(name,size)，解析器就知道它们之间的空白字符不是文本
4)错误处理器。当解析器报告错误时，应用程序可以对该错误执行某些操作。例如，记录到日志中，把它显示给用户，或抛出一个异常以放弃解析。因此，在验证时，应该安装一个错误处理器
错误处理器是一个实现了ErrorHandler接口的对象，这个接口有三个方法

    public void warning(SAXParseException exception) throws SAXException;
    public void error(SAXParseException exception) throws SAXException;
    public void fatalError(SAXParseException exception) throws SAXException;

可以通过DocumentBuilder类的setErrorHandler方法来安装错误处理器。

  builder.setErrorHandler(handler);

2.XML Schema
(1)如果要在文档中引用Schema文件，需要在根元素中加上属性

<?xml version="1.0">
<configuration xmlns:xsi="http://w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="config.xsd">
    ...
</configuration>

(2)Schema定义了每个元素的类型。类型可以是简单类型、格式受限的字符串或复制类型。
一些简单类型已经被内建到了XML Schema内，包括：

    xsd:string
    xsd:int
    xsd:boolean

注意：前缀 xsd: 来表示XML Schema定义的命名空间。也有用 XS: 作为前缀。
(3)可以自己定义简单类型simpeType
例如：定义一个枚举类型

<xsd:simpleType name="StyleType">
    <xsd:restriction base="xsd:string">
        <xsd:enumeration value="PLAIN">
        <xsd:enumeration value="BOLD">
        <xsd:enumeration value="ITALIC">
        <xsd:enumeration value="BQLD_ITALIC">
    </xsd:restriction>
</xsd:simpleType>

当定义元素时，要设定它的类型:

<xsd:element name="name" type="xsd:string">
<xsd:element name="size" type="xsd:int">
<xsd:element name="style" type="simpleType">

类型约束了元素的内容，例如下面的元素将被正确验证:

<size>10</size>
<style>PLAIN</style>

下面的元素将会被解析器拒绝

<size>default</size>
<style>SLANTED</style>

(4)可以将类型组合成复制类型complexType，例如：

<xsd:complexType name="FontType">
    <xsd:sequence>
        <xsd:element ref="name"/>
        <xsd:element ref="size"/>
        <xsd:element ref="style"/>
    </xsd:sequence>
</xsd:compleType>

FontType是name,size和style的序列，在这个类型定义中，通过ref属性来引用在Schema中位于别处的定义。
也可以嵌套定义，例如：

<xsd:complexType name="FontType">
    <xsd:sequence>
        <xsd:element name="name" type="xsd:string"/>
        <xsd:element name="size" type="xsd:int"/>
        <xsd:element name="style" type="StyleType">
            <xsd:simpleType>
                <xsd:restriction base="xsd:string">
                    <xsd:enumeration value="PLAIN">
                    <xsd:enumeration value="BOLD">
                    <xsd:enumeration value="ITALIC">
                    <xsd:enumeration value="BQLD_ITALIC">
                </xsd:restriction>
            </xsd:simpleType>
        </xsd:element>
    </xsd:sequence>
</xsd:compleType>

注意：其中StyleType元素的匿名定义
(5)xsd:sequence和DTD中的连接符号等价。xsd:choice和|操作符等价。例如

<xsd:complexType name="contactinfo">
    <xsd:choice>
        <xsd:element ref="email">
        <xsd:element ref="phone">
    </choice>
</xsd:complexType>

这和DTD中的类型email|phone类型是等价的。
(6)如果要允许重复元素，可以使用minoccurs和maxoccurs属性，例如，与DTD类型item*的等价形式如下：

<xsd:element name="item" type="..." minoccurs="0" maxoccurs="unbounded">

(7)如果要设定属性，可以把xsd:attribute元素加到complexType定义中：

<xsd:element name="size">
    <xsd:complexType>
        ...
        <xsd:attribute name="unit" type="xsd:string" use="optional" default="cm"/>
    </xsd:complexType>
</xsd:element>

这是与DTD声明等价的形式：

<!ATTLIST size unit CDTAT #IMPLIED "cm">

(8)可以把Schema的元素和类型定义封装到xsd:schema元素中：

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    ...
<xsd:schema>

(9)解析带有Schema的XML文件和解析带有DTD的文件类似，但有3点区别:
1)必须打开对命名空间的支持，即使在XML文件里不使用它:

    factory.setNamespaceAware(true);

2)必须通过如下代码来准备处理Schema的工厂：

    final String JAXP_SCHEMA_LANGUAGE = "http://java.sun.com/xml/jaxp/properties/schemaLanguage";
    final String W3C_XML_SCHEMA = "http://www.w3.org/2001/XMLSchema";
    factory.setAttribute(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);

3)解析器不会丢弃元素中的空白字符

3.XML解析实例

gridbag.dtd

<?xml version="1.0" encoding="UTF-8"?>
<!ELEMENT gridbag (row)*>
<!ELEMENT row (cell)*>
<!ELEMENT cell (bean)>
<!ATTLIST cell gridx CDATA #IMPLIED>
<!ATTLIST cell gridy CDATA #IMPLIED>
<!ATTLIST cell gridwidth CDATA "1">
<!ATTLIST cell gridheight CDATA "1">
<!ATTLIST cell weightx CDATA "0">
<!ATTLIST cell weighty CDATA "0">
<!ATTLIST cell fill (NONE|BOTH|HORIZONTAL|VERTICAL) "NONE">
<!ATTLIST cell anchor 
    (CENTER|NORTH|NORTHEAST|EAST|SOUTHEAST|SOUTH|SOUTHWEST|WEST|NORTHWEST) "CENTER">
<!ATTLIST cell ipadx CDATA "0">
<!ATTLIST cell ipady CDATA "0">

<!ELEMENT bean (class, property*)>
<!ATTLIST bean id ID #IMPLIED>

<!ELEMENT class (#PCDATA)>
<!ELEMENT property (name, value)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT value (int|string|boolean|bean)>
<!ELEMENT int (#PCDATA)>
<!ELEMENT string (#PCDATA)>
<!ELEMENT boolean (#PCDATA)>

gridbag.xsd

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" >

<!-- 
<schema xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.example.org/gridbag" 
    xmlns:tns="http://www.example.org/gridbag" elementFormDefault="qualified">
 -->
 
    <xsd:element name="gridbag" type="GridBagType"/>
     
    <xsd:element name="bean" type="BeanType"/>

    <xsd:complexType name="GridBagType">
        <xsd:sequence>
            <xsd:element name="row" type="RowType" minOccurs="0" maxOccurs="unbounded"/>
        </xsd:sequence>
    </xsd:complexType>
    
    <xsd:complexType name="RowType">
        <xsd:sequence>
            <xsd:element name="cell" type="CellType"  minOccurs="0" maxOccurs="unbounded"/>
        </xsd:sequence>
    </xsd:complexType>
    
    <xsd:complexType name="CellType">
        <xsd:sequence>
            <xsd:element ref="bean" />
        </xsd:sequence>
        <xsd:attribute name="gridx" type="xsd:int" use="optional" />
        <xsd:attribute name="gridy" type="xsd:int" use="optional" />
        <xsd:attribute name="gridwidth" type="xsd:int" use="optional" default="1" />
        <xsd:attribute name="gridheight" type="xsd:int" use="optional" default="1" />
        <xsd:attribute name="weightx" type="xsd:int" use="optional" default="0" />
        <xsd:attribute name="weighty" type="xsd:int" use="optional" default="0" />
        <xsd:attribute name="fill" use="optional" default="NONE">
            <xsd:simpleType>
                <xsd:restriction base="xsd:string" >
                    <xsd:enumeration value="NONE" />
                    <xsd:enumeration value="BOTH" />
                    <xsd:enumeration value="HORIZONTAL" />
                    <xsd:enumeration value="VERTICAL" />
                </xsd:restriction>
            </xsd:simpleType>
        </xsd:attribute>
        <xsd:attribute name="anchor" use="optional" default="CENTER">
            <xsd:simpleType>
                <xsd:restriction base="xsd:string">
                    <xsd:enumeration value="CENTER" />
                    <xsd:enumeration value="NORTH" />
                    <xsd:enumeration value="NORTHEAST" />
                    <xsd:enumeration value="EAST" />
                    <xsd:enumeration value="SOUTHEAST" />
                    <xsd:enumeration value="SOUTH" />
                    <xsd:enumeration value="SOUTHWEST" />
                    <xsd:enumeration value="WEST" />
                    <xsd:enumeration value="NORTHWEST" />
                </xsd:restriction>
            </xsd:simpleType>
        </xsd:attribute>
        <xsd:attribute name="ipady" type="xsd:int" use="optional" default="0" />
        <xsd:attribute name="ipadx" type="xsd:int" use="optional" default="0" />
    </xsd:complexType>
    
    <xsd:complexType name="BeanType">
        <xsd:sequence>
            <xsd:element name="class" type="xsd:string" />
            <xsd:element name="property" type="PropertyType" 
                minOccurs="0" maxOccurs="unbounded" />
        </xsd:sequence>
        <xsd:attribute name="id" type="xsd:ID" use="optional" />
    </xsd:complexType>
    
    <xsd:complexType name="PropertyType">
        <xsd:sequence>
            <xsd:element name="name" type="xsd:string" />
            <xsd:element name="value" type="ValueType" />
        </xsd:sequence>
    </xsd:complexType>
        
    <xsd:complexType name="ValueType">
        <xsd:choice>
            <xsd:element ref="bean" />
            <xsd:element name="int" type="xsd:int" />
            <xsd:element name="string" type="xsd:string" />
            <xsd:element name="boolean" type="xsd:boolean" />
        </xsd:choice>
    </xsd:complexType>
</xsd:schema>

fontdialog.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE gridbag SYSTEM "gridbag.dtd" >
<!-- 如果使用上级目录中的Schema验证XML文档 将<gridbag> 修改为
<gridbag xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
     xsi:noNamespaceSchemaLocation="../gridbag.xsd">
-->
 <gridbag>
    <row>
        <cell anchor="EAST">
            <bean>
                <class>
                </class>
                <property>
                    <name>text</name>
                    <value><string>Face: </string></value>
                </property>
            </bean>
        </cell>
        <cell fill="HORIZONTAL" weightx="100">
            <bean id="face">
                <class>javax.swing.JComboBox</class>
            </bean>
        </cell>
        <cell gridheight="4" fill="BOTH" weightx="100" weighty="100">
            <bean id="sample">
                <class>javax.swing.JTextArea</class>
                <property>
                    <name>text</name>
                    <value><string>Thequick brown fox jumps over the lazy dog</string></value>
                </property>
                <property>
                    <name>editable</name>
                    <value><boolean>false</boolean></value>
                </property>
                <property>
                    <name>lineWrap</name>
                    <value><boolean>true</boolean></value>
                </property>
                <property>
                    <name>border</name>
                    <value>
                        <bean>
                             <class>javax.swing.border.EtchedBorder</class>
                        </bean>
                    </value>
                </property>
            </bean>
        </cell>
    </row>
    <row>
        <cell anchor="EAST">
            <bean>
                <class>javax.swing.JLable</class>
                <property>
                    <name>text</name>
                    <value><string>Size: </string></value>
                </property>
            </bean>
        </cell>
        <cell fill="HORIZONTAL" weightx="100">
            <bean id="size">
                <class>javax.swing.JComboBox</class>
            </bean>
        </cell>
    </row>
    <row>
        <cell gridheight="2" weighty="100">
            <bean id="bold">
                <class>javax.swing.JCheckBox</class>
                <property>
                    <name>text</name>
                    <value><string>Bold</string></value>
                </property>
            </bean>
        </cell>
    </row>
    <row>
        <cell gridwidth="2" weighty="100">
            <bean id="italic">
                <class>javax.swing.JCheckBox</class>
                <property>
                    <name>text</name>
                    <value><string>Italic</string></value>
                </property>
            </bean>
        </cell>
    </row>
</gridbag>

ParseXMLDemo

package demo;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;

public class ParseXMLDemo {
	
	private static final Integer PARSE_TYPE_DOM = 1;
	private static final Integer PARSE_TYPE_SAX = 2;
	
	public static void main(String[] args) {
		ParseXMLDemo demo = new ParseXMLDemo();
		String fileName = System.getProperty("user.dir") + File.separator + "conf" 
				+ File.separator + "xml" + File.separator + "fontdialog.xml";
		Element root = demo.getRoot(fileName, PARSE_TYPE_SAX);
		if(null==root){
			System.out.println("文件不存在或存在其它问题");
			System.exit(0);
		}
		
		demo.parseXML(root, PARSE_TYPE_DOM);
	}


	private void parseXML(Element element, Integer parseType) {
		//该节点名称
		String nodeName = element.getNodeName();
		//当节点为Element时，可以通过getTagName方法获取节点名称
		String tagName = element.getTagName();
		//分析该节点属性
		NamedNodeMap attrs = element.getAttributes();
        for(int i=0;i<attrs.getLength();i++){
            Node attribute = attrs.item(i);
            String name = attribute.getNodeName();
            String value = attribute.getNodeValue();
            System.out.println();
        }
        
        
		//分析该节点下子节点
		NodeList children = element.getChildNodes();
		System.out.println(children.getLength());
		List<Integer> whitespaceList = new ArrayList<Integer>();
		for(int i=0;i<children.getLength();i++){
			Node child = children.item(i);
			if(child instanceof Text){
				String text = ((Text)child).getData();
				if("".equals(text.trim())){
					whitespaceList.add(i);
				}
			}else if(child instanceof Element){
				parseXML((Element)child, parseType);
			}
		}
		if(whitespaceList.size()>0){
			for(int i=whitespaceList.size()-1;i>=0;i--){
				Node child = children.item(i);
				element.removeChild(child);
			}
		}
	}


	private Element getRoot(String fileName, Integer parseType) {
		try{
			//得到一个DocumentBuilderFactory实例用于生成DocumentBuilder
			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
			//通知文档生成工厂打开验证特性
			factory.setValidating(true);
			//当通过Schema验证时必须加入以下代码
			if(parseType == PARSE_TYPE_SAX){
				//必须打开对命名空间的支持，即使在XML文件里不使用它
				factory.setNamespaceAware(true);
				//必须通过如下代码来准备处理Schema的工厂
			    final String JAXP_SCHEMA_LANGUAGE = "http://java.sun.com/xml/jaxp/properties/schemaLanguage";
			    final String W3C_XML_SCHEMA = "http://www.w3.org/2001/XMLSchema";
			    factory.setAttribute(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);
			}
			//指定由此工厂创建的解析器在解析 XML 文档时，必须删除元素内容中的空格
			factory.setIgnoringElementContentWhitespace(true);
			//从DocumentBuilderFactory中得到DocumentBuilder对象
			DocumentBuilder builder = factory.newDocumentBuilder();
			//读入文档
			File file = new File(fileName);
			if(!file.exists()){
				return null;
			}
			Document doc = builder.parse(new File(fileName));
			
			return doc.getDocumentElement();
		}catch(Exception e){
			e.printStackTrace();
			return null;
		}
		
	}
}

分享到：

(四) 使用XPath来定位信息 | (二) 解析XML文档(parse xml)

2012-02-09 22:09
浏览 2379
评论(0)
分类:编程语言
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论