`

dom 解析XML

XMLBean数据结构Web 
阅读更多
Java代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>   
  2. <memcaches version="1">   
  3.     <memcache type="AAAA">   
  4.         <ip>11.11.1.244:11211</ip>   
  5.         <prefix>aaaa_</prefix>   
  6.     </memcache>   
  7.     <memcache type="BBBB">   
  8.         <ip>11.22.1.243:11211</ip>   
  9.         <prefix>bbbb_</prefix>   
  10.     </memcache>   
  11.     <memcache type="CCCC">   
  12.         <ip>11.33.33.152:11211</ip>   
  13.         <prefix>cccc_</prefix>   
  14.     </memcache>   
  15.     <memcache type="DDDD">   
  16.         <ip>11.44.15.244:11211</ip>   
  17.         <prefix>dddd_</prefix>   
  18.     </memcache>   
  19.     <memcache type="EEEEEEE">   
  20.         <ip>11.66.16.152:11211</ip>   
  21.         <prefix>eeeee_</prefix>   
  22.     </memcache>   
  23.     <memcache type="FFFFF">   
  24.         <ip>11.77.170.152:11211</ip>   
  25.         <prefix>fffff_</prefix>   
  26.     </memcache>   
  27. </memcaches>  
<?xml version="1.0" encoding="UTF-8"?>
<memcaches version="1">
	<memcache type="AAAA">
		<ip>11.11.1.244:11211</ip>
		<prefix>aaaa_</prefix>
	</memcache>
	<memcache type="BBBB">
		<ip>11.22.1.243:11211</ip>
		<prefix>bbbb_</prefix>
	</memcache>
	<memcache type="CCCC">
		<ip>11.33.33.152:11211</ip>
		<prefix>cccc_</prefix>
	</memcache>
	<memcache type="DDDD">
		<ip>11.44.15.244:11211</ip>
		<prefix>dddd_</prefix>
	</memcache>
	<memcache type="EEEEEEE">
		<ip>11.66.16.152:11211</ip>
		<prefix>eeeee_</prefix>
	</memcache>
	<memcache type="FFFFF">
		<ip>11.77.170.152:11211</ip>
		<prefix>fffff_</prefix>
	</memcache>
</memcaches>



解析上面xml文件的java代码：

Java代码 复制代码
  1.   
  2. import javax.xml.parsers.DocumentBuilder;   
  3. import javax.xml.parsers.DocumentBuilderFactory;   
  4. import java.io.*; //Java基础包，包含各种IO操作   
  5. import java.util.*; //Java基础包，包含各种标准数据结构操作   
  6. import javax.xml.parsers.*; //XML解析器接口   
  7. import org.w3c.dom.*;   
  8.   
  9. import com.happyelements.apollo.config.type.AppType;   
  10. import com.happyelements.apollo.util.ApolloCollectionsUtil;   
  11.   
  12. public class ParseMemXML {   
  13.   
  14.     public static final Map<String, MemBean> memMap = ApolloCollectionsUtil.newMap();//将MemBean放到map中存放   
  15.   
  16. //解析xml文件并将得到的实例放入map中   
  17.     public static void initXMLFile(String filename) throws Exception {   
  18.         // 为解析xml做准备   
  19.         // 创建DocumentBuilderFactory实例,指定DocumentBuilder   
  20.         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();   
  21.         DocumentBuilder db = null;   
  22.         try {   
  23.             db = dbf.newDocumentBuilder();   
  24.         } catch (ParserConfigurationException pce) {   
  25.             System.out.println(pce);   
  26.             // 出异常时输出异常信息，然后退出，下同   
  27.             System.exit(1);   
  28.         }   
  29.         Document doc = null;   
  30.         try {   
  31.             doc = db.parse(filename);   
  32.         } catch (DOMException dom) {   
  33.             System.err.println(dom.getMessage());   
  34.             System.exit(1);   
  35.         } catch (IOException ioe) {   
  36.             System.err.println(ioe);   
  37.             System.exit(1);   
  38.         }   
  39.   
  40.         // 下面是解析XML的全过程，   
  41.         // 比较简单，先取根元素"memcaches"   
  42.         Element root = doc.getDocumentElement();   
  43.         // 取"memcache"元素列表   
  44.         NodeList memcaches = root.getElementsByTagName("memcache");   
  45.         for (int i = 0; i < memcaches.getLength(); i++) {   
  46.             // 创建一个memcache的Bean实例   
  47.                       MemBean memBean = new MemBean();   
  48.             // 依次取每个"memcache"元素   
  49.             Element memcache = (Element) memcaches.item(i);   
  50.             // 取memcache的type属性   
  51.             memBean.setType(memcache.getAttribute("type"));   
  52.             // 取"ip"元素，下面类同   
  53.             NodeList ips = memcache.getElementsByTagName("ip");   
  54.             if (ips.getLength() == 1) {   
  55.                 Element e = (Element) ips.item(0);   
  56.                 Text t = (Text) e.getFirstChild();   
  57.                 memBean.setIp(t.getNodeValue());   
  58.                 System.out.println(memBean.getIp());   
  59.             }   
  60.             NodeList prefixs = memcache.getElementsByTagName("prefix");   
  61.             if (prefixs.getLength() == 1) {   
  62.                 Element e = (Element) prefixs.item(0);   
  63.                 Text t = (Text) e.getFirstChild();   
  64.                 memBean.setPrefix(t.getNodeValue());   
  65.                 System.out.println(memBean.getPrefix());   
  66.             }   
  67.             memMap.put(memBean.getType().toString(), memBean);   
  68.         }   
  69.     }   
  70.   
  71.     public static void main(String[] args) throws Exception {   
  72.         ParseMemXML.initXMLFile("E:\\workplace\\Tool2\\WebRoot\\WEB-INF\\memconf.xml");   
  73.         System.out.println(ParseMemXML.memMap.size());   
  74.         MemBean memBean = ParseMemXML.memMap.get(AppType.AAAA.toString());   
  75.         System.out.println("ip=====" + memBean.getIp());   
  76.         System.out.println("prefix===" + memBean.getPrefix());   
  77.   
  78.     }   
  79. }  
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.*; //Java基础包，包含各种IO操作
import java.util.*; //Java基础包，包含各种标准数据结构操作
import javax.xml.parsers.*; //XML解析器接口
import org.w3c.dom.*;

import com.happyelements.apollo.config.type.AppType;
import com.happyelements.apollo.util.ApolloCollectionsUtil;

public class ParseMemXML {

	public static final Map<String, MemBean> memMap = ApolloCollectionsUtil.newMap();//将MemBean放到map中存放

//解析xml文件并将得到的实例放入map中
	public static void initXMLFile(String filename) throws Exception {
		// 为解析xml做准备
		// 创建DocumentBuilderFactory实例,指定DocumentBuilder
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		DocumentBuilder db = null;
		try {
			db = dbf.newDocumentBuilder();
		} catch (ParserConfigurationException pce) {
			System.out.println(pce);
			// 出异常时输出异常信息，然后退出，下同
			System.exit(1);
		}
		Document doc = null;
		try {
			doc = db.parse(filename);
		} catch (DOMException dom) {
			System.err.println(dom.getMessage());
			System.exit(1);
		} catch (IOException ioe) {
			System.err.println(ioe);
			System.exit(1);
		}

		// 下面是解析XML的全过程，
		// 比较简单，先取根元素"memcaches"
		Element root = doc.getDocumentElement();
		// 取"memcache"元素列表
		NodeList memcaches = root.getElementsByTagName("memcache");
		for (int i = 0; i < memcaches.getLength(); i++) {
			// 创建一个memcache的Bean实例
                      MemBean memBean = new MemBean();
			// 依次取每个"memcache"元素
			Element memcache = (Element) memcaches.item(i);
			// 取memcache的type属性
			memBean.setType(memcache.getAttribute("type"));
			// 取"ip"元素，下面类同
			NodeList ips = memcache.getElementsByTagName("ip");
			if (ips.getLength() == 1) {
				Element e = (Element) ips.item(0);
				Text t = (Text) e.getFirstChild();
				memBean.setIp(t.getNodeValue());
				System.out.println(memBean.getIp());
			}
			NodeList prefixs = memcache.getElementsByTagName("prefix");
			if (prefixs.getLength() == 1) {
				Element e = (Element) prefixs.item(0);
				Text t = (Text) e.getFirstChild();
				memBean.setPrefix(t.getNodeValue());
				System.out.println(memBean.getPrefix());
			}
			memMap.put(memBean.getType().toString(), memBean);
		}
	}

	public static void main(String[] args) throws Exception {
		ParseMemXML.initXMLFile("E:\\workplace\\Tool2\\WebRoot\\WEB-INF\\memconf.xml");
		System.out.println(ParseMemXML.memMap.size());
		MemBean memBean = ParseMemXML.memMap.get(AppType.AAAA.toString());
		System.out.println("ip=====" + memBean.getIp());
		System.out.println("prefix===" + memBean.getPrefix());

	}
}



MemBean的java源文件

Java代码 复制代码
  1. import java.io.Serializable;   
  2.   
  3. import org.simpleframework.xml.Attribute;   
  4. import org.simpleframework.xml.Element;   
  5. import org.simpleframework.xml.Root;   
  6.   
  7. @Root(name = "memconf")   
  8. public class MemBean implements Serializable {   
  9.   
  10.     private static final long serialVersionUID = 2209681159359089305L;   
  11.   
  12.     @Attribute  
  13.     private String type;   
  14.     @Element  
  15.     private String ip;   
  16.     @Element  
  17.     private String prefix;   
  18.   
  19.     public String getType() {   
  20.         return type;   
  21.     }   
  22.   
  23.     public void setType(String type) {   
  24.         this.type = type;   
  25.     }   
  26.   
  27.     public String getIp() {   
  28.         return ip;   
  29.     }   
  30.   
  31.     public void setIp(String ip) {   
  32.         this.ip = ip;   
  33.     }   
  34.   
  35.     public String getPrefix() {   
  36.         return prefix;   
  37.     }   
  38.   
  39.     public void setPrefix(String prefix) {   
  40.         this.prefix = prefix;   
  41.     }   
  42.   
  43. }  
import java.io.Serializable;

import org.simpleframework.xml.Attribute;
import org.simpleframework.xml.Element;
import org.simpleframework.xml.Root;

@Root(name = "memconf")
public class MemBean implements Serializable {

	private static final long serialVersionUID = 2209681159359089305L;

	@Attribute
	private String type;
	@Element
	private String ip;
	@Element
	private String prefix;

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

	public String getIp() {
		return ip;
	}

	public void setIp(String ip) {
		this.ip = ip;
	}

	public String getPrefix() {
		return prefix;
	}

	public void setPrefix(String prefix) {
		this.prefix = prefix;
	}

}




AppType源文件

Java代码 复制代码
  1.   
  2. public enum AppType {   
  3. AAAA，   
  4. BBBB，   
  5. CCCC，   
  6. DDDD，   
  7. EEEE，   
  8. FFFF，   
  9.   
  10. ;   
  11. }  
分享到：
| tamcat - 中struts2 问题
评论
发表评论

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

相关推荐

    java dom 解析 xml 实例

    Java DOM 解析 XML 实例是 Java 语言中常用的 XML 解析方法之一，使用 W3C 推荐的文档对象模型（Document Object Model，DOM）来解析 XML 文档。DOM 提供了一个树形结构的对象模型，通过遍历树形结构可以访问和操作 ...

    DOM解析XML文件例子

    在这个例子中，我们将深入探讨如何使用DOM解析XML文件，以理解和掌握XML文档的结构，并进行数据提取、修改和创建。 首先，XML（Extensible Markup Language）是一种标记语言，用于存储和传输数据，具有自描述性和...

    DOM解析xml文件实例讲解

    本篇文章将深入探讨DOM解析XML文件在Android中的应用实例。 首先，DOM解析的基本思想是将整个XML文件加载到内存中，形成一个树形结构，即DOM树。这样做的优点是解析后的数据可以方便地进行任意位置的查找和修改，但...

    Android Dom解析XML

    总结来说，Android中使用DOM解析XML是一种常见且直观的方式，适合处理小规模的数据。结合ButterKnife库，可以方便地将解析结果与UI组件进行绑定，提高代码的可读性和维护性。但请注意，对于大文件，考虑使用SAX或者...

    DOM解析XML应用实例（入门经典案例）

    本教程“DOM解析XML应用实例（入门经典案例）”旨在帮助初学者快速掌握DOM解析XML的基本方法和实践技巧。 XML（Extensible Markup Language）是一种标记语言，常用于存储和传输数据，特别是在Web应用程序中。它具有...

    java_dom解析xml xml java

    标题“java_dom解析xml xml java”表明了本文档的主题是关于如何使用Java中的DOM技术来解析XML文件。 #### 描述分析 描述中提到这是一个适合新手入门的内容，并给出了一个简单的XML示例。该XML文档包含了一个`...

    java平台中使用DOM解析xml文件

    使用DOM解析XML的基本步骤如下： 1. **导入必要的库**：在Java中，DOM解析功能主要由`javax.xml.parsers`和`org.w3c.dom`包提供。因此，首先需要在代码中导入这些库： ```java import javax.xml.parsers....

    用dom解析xml文件

    使用DOM解析XML文件的步骤如下： 1. 加载XML文件：首先，你需要创建一个`DocumentBuilderFactory`对象，然后通过`newDocumentBuilder()`方法得到一个`DocumentBuilder`实例。接着，调用`parse()`方法，传入XML文件...

    DOM_XML.rar_DOM_dom xml_dom xml java_dom解析xml_java解析xml

    标题中的"DOM_XML.rar"可能是一个包含DOM解析XML相关示例的压缩文件，"DOM_dom xml_dom xml java_dom解析xml_java解析xml"这部分描述了文件的主要内容，即关于DOM（Document Object Model）在XML解析中的应用，特别...

    android Dom解析xml文件

    本篇文章将深入探讨Android中的DOM解析XML文件，包括其基本原理、实现步骤和一些实用技巧。 ### 1. DOM解析的基本概念 DOM解析是一种将XML文件转换为内存中对象模型的方法。它将XML文档视为一棵树，其中每个元素、...

    DOM解析XML 创建XML

    下面我们将深入探讨DOM解析XML以及如何创建XML。 DOM解析XML的过程分为以下几个步骤： 1. **加载XML文档**：首先，我们需要通过DOM解析器加载XML文档。在JavaScript中，可以使用`DOMParser`对象的`parseFromString...

    java使用dom解析xml

    在 Java 中，DOM 解析允许开发者将整个 XML 文件加载到内存中，形成一个树形结构，然后通过这个结构来访问和操作 XML 的各个部分。 首先，我们需要引入 Java 的核心解析库，即 javax.xml.parsers 命名空间。这个库...

    经典的DOM解析XML范例

    【DOM解析XML】 在Java中，解析XML文档有多种方式，其中DOM（Document Object Model）和SAX（Simple API for XML）是最常见的两种。DOM是一种基于树形结构的XML处理方式，它将整个XML文档加载到内存中，形成一个完整...

    dom解析XML,普通解析

    DOM解析XML是处理XML数据的一种常见方式，尤其在Java编程中广泛使用。下面我们将深入探讨DOM解析XML的相关知识点。 1. DOM解析原理： DOM解析器读取整个XML文件，将其转换为内存中的对象树，每个XML元素、属性、...

    DOM解析XML文档

    在本文中，我们将深入探讨DOM解析XML文档的相关知识点，包括DOM的基本概念、解析过程、节点操作以及实际应用。 一、DOM基本概念 DOM是一种与平台和语言无关的接口，它允许程序和脚本动态地访问和更新文档的内容、...

    dom解析xml的demo

    在本示例中，我们将深入探讨DOM解析XML的基本原理和实践方法，通过一个简单的示例帮助你理解其核心概念。 XML（eXtensible Markup Language）是一种标记语言，常用于数据交换和存储，具有自描述性和严格的语法规则...

    android上使用DOM解析XML

    下面将详细介绍在Android中使用DOM解析XML的基本步骤和关键知识点。 1. **导入XML解析库** 在Android项目中，我们不需要额外导入库，因为DOM解析器是Java标准库的一部分，已经包含在Android SDK中。这意味着你可以...

    dom解析xml BS结构

    "dom解析xml BS结构"这一主题，意味着我们将探讨如何在基于浏览器的客户端应用（Browser-Server，BS结构）中利用DOM解析XML数据。BS架构中，通常由前端浏览器接收服务器传递的XML数据，并通过JavaScript进行解析和...

    使用dom4j 和本地dom 解析xml 文件

    在压缩包文件"复件 dom"中，可能包含了示例代码或教程，用于演示如何使用DOM4J和本地DOM解析XML文件。通过查看这些文件，你可以更深入地了解两种方法的具体实现，并在实际项目中选择合适的方式处理XML数据。 总结来...

Magicbox
Global site tag (gtag.js) - Google Analytics