jodm解析xml

xml文件

<?xml version="1.0" encoding="UTF-8"?>
<root>
 <person id="1">
  <username>张三</username>
  <password>123123</password>
 </person>
 <person id="2">
  <username>1111111112</username>
  <password>password2</password>
 </person>
</root>

Jdom解析代码

 String xmlpath="test.xml";
        SAXBuilder builder=new SAXBuilder(false);
         try {
           //构造文档
           Document doc=builder.build(Sample.class.getClassLoader().getResourceAsStream(xmlpath));
           Element root=doc.getRootElement();//获得根元素
           List<Element> rootlist=root.getChildren("person");//获得名为person的标签
           for (Iterator<Element> iterator = rootlist.iterator(); iterator.hasNext();){
               Element element=(Element)iterator.next();
               String id=element.getAttributeValue("id");
               String username=element.getChildText("username");//取得标签的子元素
               String password=element.getChildText("password");
               System.out.println("ID:"+id+" 用户名:"+username+"  密码:"+password);
           }
         } catch (JDOMException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }        

dom4j

//指定xml文件名称及地址，存在在项目根目录
	private static String xmlPath = "pr.xml";

	/**
	 * 通过xml地址获得document
	 * @param xmlPath
	 * @return
	 */
	public static Document parse2Document(String xmlPath) {
		SAXReader reader = new SAXReader();
		Document document = null;
		try {
			InputStream in = new FileInputStream(xmlPath);
			document = reader.read(in);
			return document;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 读取解析XML
	 * 
	 * @param map
	 */
	public static void readXmlOut(Map<String, Object> map) {
		// 产生一个解析器对象
		SAXReader reader = new SAXReader();
		// 将xml文档转换为Document的对象
		Document document = parse2Document(xmlPath);
		// 获取文档的根元素
		Element root = document.getRootElement();
		// 遍历当前元素(在此是根元素)的子元素
		Iterator it = map.entrySet().iterator();
		while (it.hasNext()) {
			Entry entry = (Entry) it.next();
			String name = entry.getKey().toString();
			String value = null;
			for (Iterator<Element> i_pe = root.elementIterator(); i_pe.hasNext();) {
				Element element = i_pe.next();
				if (map.get("root").equals(element.getName())) {
					value = element.elementText(name);
				}
			}
			if (!"root".equals(name)) {
				map.put(name, value);
			}
		}
	}

	/**
	 * 修改xml节点信息 map root 代表根节点 其它要与要修改根节点下的节点名称相同
	 * 
	 * @param newValue
	 */
	public void updateXml(Map newValue) {
		Document doc = parse2Document(xmlPath);
		// 获得要修改的节点信息
		List<Element> nameList = doc.selectNodes("/root/"
				+ newValue.get("root"));
		Iterator<Element> iterator = nameList.iterator();
		// 便利获得的节点信息 其中包含root 和 newValue.get("root")两个节点
		while (iterator.hasNext()) {
			Element element = iterator.next();
			// 判断便利的名称是否与输入的Map中的root信息相同
			if (newValue.get("root").equals(element.getName())) {
				// 获得该节点的子节点
				List<Element> childList = element.elements();
				// 便利子节点
				for (int i = 0; i < childList.size(); i++) {
					// 遍历Map信息
					Iterator<Element> valueSet = newValue.entrySet().iterator();
					while (valueSet.hasNext()) {
						Entry<String, Object> entry = (Entry<String, Object>) valueSet.next();
						String nodeName = childList.get(i)
								.getName();
						String key = entry.getKey().toString();
						// 判断key是否与节点名称相同
						// 相同则进行修改节点信息
						if (key != null && key.equals(nodeName)) {
							childList.get(i).setText((String) entry
									.getValue());
						}
					}
				}
			}
		}
		writeToFile(doc);
	}
	
	/**
	 * 写文档
	 * @param doc
	 */
	public void writeToFile(Document doc) {
		try {
			Writer writer = new FileWriter(xmlPath);
			OutputFormat format = OutputFormat.createPrettyPrint();
			format.setEncoding("UTF-8");
			XMLWriter xmlWriter = new XMLWriter(writer, format);
			xmlWriter.write(doc);
			xmlWriter.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 创建XML文件
	 * 
	 * @param map
	 */
	public void createXML(Map<String, Object> map) {
		Document document = null;
		// 建立document对象
		try {
			// 判断xml是否存在
			document = DocumentHelper.createDocument();
			// 创建根节点
			Element root = document.addElement("root");
			// 由map中取出根节点，创建所需要的根节点
			Element request = root.addElement(map.get("root").toString());
			// 添加子节点
			// 遍历map
			Iterator<Entry<String, Object>> valueSet = map.entrySet().iterator();
			while (valueSet.hasNext()) {
				Entry<String, Object> entry = valueSet.next();
				// 排除根节点
				if (!"root".equals(entry.getKey())) {
					Element node = request.addElement(entry.getKey());
					node.addText((String) entry.getValue());
				}
			}
			// 输出数据到编辑器中
			OutputFormat format = OutputFormat.createPrettyPrint();
			// 设置文档编码
			format.setEncoding("utf-8");
			// 根据需要设置编码
			XMLWriter writer = new XMLWriter(System.out, format);
			document.normalize();
			writer.write(document);
			writer.close();
			// 保存XML到文件
			XMLWriter writer2 = new XMLWriter(
					new FileWriter(new File(xmlPath)), format);
			writer2.write(document);
			// 输出到文件
			writer2.close();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 添加修改节点
	 * @param map
	 * @return
	 */
	public String updAndAddXML(Map<String, Object> map) {
		try {
			//获得文档
			Document xmlDoc = parse2Document(xmlPath);
			//获得根节点
			Element root = xmlDoc.getRootElement();
			//从根节点开始读取
			Iterator<Element> it = root.elementIterator();
			boolean flag=false;
			while (it.hasNext()) {
				Element element = it.next();
				//判断是否与提交的根节点相同
				if(map.get("root").equals(element.getName())){
					//添加修改节点
					this.nodesUpdAndAddXml(element, map);
					flag=true;
				}
			}
			//防止root下的map中的root元素不存在 无法对节点进行修改或者添加
			if(!flag){
				//判断map中的root节点是否存在
				Element request=root.addElement(map.get("root").toString());
				//添加修改子节点
				this.nodesUpdAndAddXml(request, map);
			}
			// 输出全部原始数据，在编译器中显示
			OutputFormat format = OutputFormat.createPrettyPrint();
			format.setEncoding("utf-8");
			XMLWriter writer = new XMLWriter(System.out, format);
			writer.write(xmlDoc);
			writer.close();
			// 输出全部原始数据，并用它生成新的我们需要的XML文件
			XMLWriter writer2 = new XMLWriter(new FileWriter(new File(
					xmlPath)), format);
			writer2.write(xmlDoc); // 输出到文件
			writer2.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return xmlPath;
	}
	/**
	 * 添加 修改子节点
	 * @param element节点
	 * @param map
	 */
	public void nodesUpdAndAddXml(Element element,Map<String, Object> map){
		//获得要修改的节点下的所有子节点
		List<Element> childList = element.elements();
		//便利map
		Iterator<Entry<String, Object>> valueSet = map.entrySet().iterator();
		while(valueSet.hasNext()){
			Entry<String, Object> entry = valueSet.next();
			String key = entry.getKey().toString();
			//排除map中的root元素
			if(!"root".equals(key)){
				//设置boolean值 用于节点是否存在
				boolean flag=false;
				for (Element child : childList) {
					String nodeName = child.getName();
					//判断key与节点的名称是否相同
					if(key!=null && key.equals(nodeName)){
						child.setText(entry.getValue().toString());
						flag=true;
					}
				}
				//节点不存在 需要添加
				if(!flag){
					//添加节点
					Element new_cdata=element.addElement(key);
					new_cdata.setText(entry.getValue().toString());
				}
			}
		}
	}
	public static void main(String[] args) {
		
		// readXmlOut(map);
		// Iterator it = map.entrySet().iterator();
		// while (it.hasNext()) {
		// Entry entry = (Entry) it.next();
		// System.out.println(map.get(entry.getKey()) + "-------"
		// + entry.getKey());
		// }
		// updXmlNode();
		// delXml();

		// new dom4jParse().updateXml(map);
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("root", "jdk");
		map.put("type", "123---------");
		map.put("path", "321----------");
		map.put("url","这是一个新的");
		new dom4jParse().updAndAddXML(map);
	}