编辑“︁Kotlin XML处理”︁（章节）

= Kotlin XML处理 =

XML（可扩展标记语言）是一种广泛使用的数据交换格式，Kotlin提供了多种方式来处理XML数据。本章将介绍如何使用Kotlin解析、生成和操作XML文件，涵盖基础概念和高级技巧。

== 简介 ==
XML是一种用于存储和传输数据的标记语言，具有自我描述性和平台无关性。在Kotlin中，可以通过以下几种方式处理XML：
* DOM（文档对象模型）解析 - 将整个XML文档加载到内存中形成树结构
* SAX（简单API for XML）解析 - 基于事件驱动的流式解析
* XML Pull解析 - 更轻量级的流式解析
* 第三方库如SimpleXML、Jackson XML等

== DOM解析 ==
DOM解析器将整个XML文档读入内存，构建成节点树，适合小型XML文件。

=== 基本用法 ===
Kotlin使用`javax.xml.parsers`包中的`DocumentBuilderFactory`来创建DOM解析器：

<syntaxhighlight lang="kotlin">
import org.w3c.dom.Document
import javax.xml.parsers.DocumentBuilderFactory
import java.io.File

fun main() {
    val factory = DocumentBuilderFactory.newInstance()
    val builder = factory.newDocumentBuilder()
    
    // 解析XML文件
    val xmlFile = File("data.xml")
    val document: Document = builder.parse(xmlFile)
    
    // 规范化文档（可选）
    document.documentElement.normalize()
    
    // 获取根元素
    val root = document.documentElement
    println("根元素: ${root.nodeName}")
}
</syntaxhighlight>

=== 遍历节点 ===
<syntaxhighlight lang="kotlin">
fun printNodeInfo(node: org.w3c.dom.Node, indent: String = "") {
    println("$indent节点类型: ${node.nodeType}, 名称: ${node.nodeName}, 值: ${node.nodeValue}")
    
    // 处理子节点
    val children = node.childNodes
    for (i in 0 until children.length) {
        printNodeInfo(children.item(i), "$indent  ")
    }
}
</syntaxhighlight>

== SAX解析 ==
SAX是一种基于事件的解析方式，内存效率高，适合大型XML文件。

=== 基本实现 ===
<syntaxhighlight lang="kotlin">
import org.xml.sax.helpers.DefaultHandler
import javax.xml.parsers.SAXParserFactory

class MyHandler : DefaultHandler() {
    override fun startElement(uri: String, localName: String, 
                            qName: String, attributes: Attributes) {
        println("开始元素: $qName")
    }
    
    override fun characters(ch: CharArray, start: Int, length: Int) {
        val content = String(ch, start, length).trim()
        if (content.isNotEmpty()) {
            println("内容: $content")
        }
    }
}

fun main() {
    val factory = SAXParserFactory.newInstance()
    val saxParser = factory.newSAXParser()
    val handler = MyHandler()
    
    saxParser.parse(File("data.xml"), handler)
}
</syntaxhighlight>

== XML Pull解析 ==
Kotlin原生支持XML Pull解析，这是Android推荐的XML解析方式。

<syntaxhighlight lang="kotlin">
import org.xmlpull.v1.XmlPullParser
import org.xmlpull.v1.XmlPullParserFactory

fun parseXML(xml: String) {
    val factory = XmlPullParserFactory.newInstance()
    factory.isNamespaceAware = true
    val parser = factory.newPullParser()
    
    parser.setInput(xml.reader())
    var eventType = parser.eventType
    
    while (eventType != XmlPullParser.END_DOCUMENT) {
        when (eventType) {
            XmlPullParser.START_TAG -> println("开始标签: ${parser.name}")
            XmlPullParser.TEXT -> println("文本内容: ${parser.text}")
            XmlPullParser.END_TAG -> println("结束标签: ${parser.name}")
        }
        eventType = parser.next()
    }
}
</syntaxhighlight>

== XML生成 ==
Kotlin可以使用`javax.xml.transform`包生成XML文件。

<syntaxhighlight lang="kotlin">
import javax.xml.parsers.DocumentBuilderFactory
import javax.xml.transform.TransformerFactory
import javax.xml.transform.dom.DOMSource
import javax.xml.transform.stream.StreamResult
import org.w3c.dom.Document
import java.io.File

fun createXML() {
    val factory = DocumentBuilderFactory.newInstance()
    val builder = factory.newDocumentBuilder()
    val doc: Document = builder.newDocument()
    
    // 创建根元素
    val root = doc.createElement("users")
    doc.appendChild(root)
    
    // 添加用户元素
    val user = doc.createElement("user")
    user.setAttribute("id", "1")
    
    val name = doc.createElement("name")
    name.appendChild(doc.createTextNode("张三"))
    user.appendChild(name)
    
    root.appendChild(user)
    
    // 写入文件
    val transformer = TransformerFactory.newInstance().newTransformer()
    val source = DOMSource(doc)
    val result = StreamResult(File("output.xml"))
    transformer.transform(source, result)
}
</syntaxhighlight>

== 实际应用案例 ==
=== 配置文件解析 ===
许多应用程序使用XML作为配置文件格式。例如解析以下配置：

<syntaxhighlight lang="xml">
<config>
    <database>
        <url>jdbc:mysql://localhost:3306/mydb</url>
        <username>admin</username>
        <password>secret</password>
    </database>
    <settings>
        <cache-enabled>true</cache-enabled>
        <max-connections>10</max-connections>
    </settings>
</config>
</syntaxhighlight>

=== Web服务响应处理 ===
处理SOAP或REST服务返回的XML响应是常见用例：

<syntaxhighlight lang="kotlin">
data class WeatherData(val city: String, val temperature: Double, val condition: String)

fun parseWeatherResponse(xml: String): WeatherData {
    val factory = XmlPullParserFactory.newInstance()
    val parser = factory.newPullParser()
    parser.setInput(xml.reader())
    
    var city = ""
    var temp = 0.0
    var condition = ""
    
    while (parser.next() != XmlPullParser.END_DOCUMENT) {
        if (parser.eventType == XmlPullParser.START_TAG) {
            when (parser.name) {
                "city" -> city = parser.nextText()
                "temperature" -> temp = parser.nextText().toDouble()
                "condition" -> condition = parser.nextText()
            }
        }
    }
    
    return WeatherData(city, temp, condition)
}
</syntaxhighlight>

== 性能比较 ==
以下是不同XML处理方式的性能特点比较：

<mermaid>
pie
    title XML解析方式比较
    "DOM解析" : 35
    "SAX解析" : 25
    "Pull解析" : 40
</mermaid>

* DOM解析：内存占用高，适合小型文件，支持随机访问
* SAX解析：内存效率高，适合大型文件，只读
* Pull解析：内存效率高，适合流式处理，可读可写

== 高级技巧 ==
=== 命名空间处理 ===
处理带有命名空间的XML需要特别注意：

<syntaxhighlight lang="kotlin">
fun handleNamespaces(doc: Document) {
    val xpath = XPathFactory.newInstance().newXPath()
    xpath.namespaceContext = object : NamespaceContext {
        override fun getNamespaceURI(prefix: String): String {
            return when (prefix) {
                "ns" -> "http://example.com/ns"
                else -> XMLConstants.NULL_NS_URI
            }
        }
        // 其他必要方法...
    }
    
    val node = xpath.evaluate("//ns:element", doc, XPathConstants.NODE)
}
</syntaxhighlight>

=== XML验证 ===
可以使用XSD或DTD验证XML文档的有效性：

<syntaxhighlight lang="kotlin">
fun validateXML(xmlFile: File, schemaFile: File) {
    val factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI)
    val schema = factory.newSchema(schemaFile)
    val validator = schema.newValidator()
    validator.validate(StreamSource(xmlFile))
}
</syntaxhighlight>

== 常见问题 ==
* '''Q: 处理大型XML文件时内存不足怎么办？'''
  A: 使用SAX或Pull解析代替DOM解析

* '''Q: 如何提高XML处理性能？'''
  A: 1. 避免重复解析 2. 使用缓存 3. 考虑使用二进制格式如Protocol Buffers

* '''Q: XML和JSON哪个更好？'''
  A: 取决于使用场景：XML更适合文档型数据，JSON更适合数据交换

== 总结 ==
Kotlin提供了多种XML处理方式，各有优缺点。选择合适的方法取决于：
* 文件大小
* 内存限制
* 是否需要修改XML
* 性能要求

掌握XML处理是Kotlin开发者的重要技能，特别是在处理遗留系统、配置文件或Web服务时。

[[Category:编程语言]]
[[Category:Kotlin]]
[[Category:Kotlin文件处理]]