`
Sev7en_jun
  • 浏览: 1227651 次
  • 性别: Icon_minigender_1
  • 来自: 广州
博客专栏
84184fc0-d0b6-3f7f-a3f0-4202acb3caf5
Apache CXF使用s...
浏览量:111479
社区版块
存档分类
最新评论

自定义简单XML的读与存,便捷工具类

 
阅读更多
主要依赖jar包dom4j.jar ,main方法中有使用方法
import java.io.Serializable;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * XML数据元素操作基类
 * 
 * @author Administrator
 * 
 */
public class CacheNodeBaseVO implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 3821539085598864455L;

	// 参数传递
	protected HashMap<String,Object> parameters = null;

	public CacheNodeBaseVO() {
		this.parameters = new HashMap<String, Object>();
	}
	
	/**
	 * 加参数
	 */
	public void addParam(String name, Object value) {
		this.parameters.put(name, value);
	}

	/**
	 * 增加加参数
	 * 
	 * @param map
	 */
	public void addParam(Map map) {
		if(map==null || map.size()<=0){
			return;
		}
		Iterator it = map.keySet().iterator();
		while (it.hasNext()) {
			String key = String.valueOf(it.next());			
			Object value = map.get(key);
			addParam(key, value);
		}
	}

	/**
	 * 删除参数
	 * 
	 * @param key
	 */
	public void removeParam(String key) {
		this.parameters.remove(key);
	}

	public void removeAllParams() {
		this.parameters.clear();
	}

	public String getParam(String key) {
		return (String) this.parameters.get(key);
	}
	
	public Object getParamObj(String key) {
		return this.parameters.get(key);
	}

	public HashMap<String,Object> getParameters() {
		return parameters;
	}

	public void setParameters(HashMap parameters) {
		this.parameters = parameters;
	}

	public String toString() {
		StringBuffer sb = new StringBuffer();
		Iterator it = this.parameters.keySet().iterator();
		while (it.hasNext()) {
			String key = (String) it.next();
			sb.append(key + ":" + this.parameters.get(key) + ";");
		}
		return sb.toString();
	}
	
	public static void main(String[] args) {
		CacheNodeBaseVO vo = new CacheNodeBaseVO();
		vo.addParam("fdiId","22");
		vo.addParam("fdiId2","22");
		vo.addParam("fdiId3","22");
		vo.addParam("fdiId4","22");
		vo.addParam("fdiId5","22");
		System.out.println(vo.toString());
		
	}
}

 

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;

import com.etone.util.XMLUtils;

/**
 * XML数据元素操作基类
 * 
 * @author Administrator
 * 
 */
public class CacheNodeVO extends CacheNodeBaseVO implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 3821539085598864455L;

	private Document node = null;

	private Element root = null;

	private List subNodes = null;

	private Element parent = null;

	// fdc属性为null时的默认值
	private String fdcDefaultValue = "";

	// fdi属性为null时的默认值
	private String fdiDefaultValue = "0";

	// fdd属性为null时的默认值
	private String fddDefaultValue = "00:00";

	/**
	 * 构造方法,root名称为"root"
	 * 
	 */
	public CacheNodeVO() {
		this("Node");
	}

	/**
	 * 构造方法
	 * 
	 * @param rootName
	 *            根据元素名
	 */
	public CacheNodeVO(String rootName) {
		this.node = DocumentHelper.createDocument();
		this.root = this.node.addElement(rootName);
		this.subNodes = new ArrayList();
		this.parent = this.node.getParent();
	}

	/**
	 * 修改本结果的name
	 * 
	 * @param name
	 */
	public void setNodeName(String name) {
		this.root.setName(name);
	}

	/**
	 * 把属性加到本节点元素中
	 */
	public Element addAttribute(String name, String value) {
		if (name == null) {
			return null;
		}
		if (value == null) {
			if (name.startsWith("fdi")) {
				value = fdiDefaultValue;
			} else if (name.startsWith("fdc")) {
				value = fdcDefaultValue;
			} else if (name.startsWith("fdd")) {
				value = fddDefaultValue;
			} else
				value = "-";
		}
		return this.root.addAttribute(name, value);
	}

	/**
	 * 取属性值
	 * 
	 * @param name
	 * @return String
	 * @date 2008-3-20
	 * @package com.etone.dao.vo
	 */
	public String getAttribute(String name) {
		return this.root.attributeValue(name);
	}

	/**
	 * 把属性加到本节点元素中
	 */
	public Element addAttribute(Attribute attribute) {
		this.root.add(attribute);
		return root;
	}

	/**
	 * 从本节点元素中移除某指定属性
	 */
	public boolean removeAttribute(String key) {
		return this.root.remove(this.root.attribute(key));
	}

	/**
	 * 从本节点元素中移除某指定属性
	 */
	public boolean removeAttribute(int index) {
		return this.root.remove(this.root.attribute(index));
	}

	/**
	 * 删除所有属性
	 * 
	 */
	public void removeAllAttribute() {
		List list = new ArrayList();
		Iterator it = this.root.attributeIterator();
		while (it.hasNext()) {
			list.add(it.next());
		}
		for (int i = 0; i < list.size(); i++) {
			this.root.remove((Attribute) list.get(i));
		}
	}

	/**
	 * 返回XML元素文本形式
	 */
	public String toString() {
		// TODO Auto-generated method stub
		if (this.root != null) {
			return XMLUtils.toXMLString(this.root, "gb2312");
		}
		return null;
	}

	/**
	 * 返回XML文档文本形式
	 */
	public String toXMLString() {
		if (this.node != null) {
			return XMLUtils.toXMLString(this.node, "gb2312");
		}
		return null;
	}

	/**
	 * 生成到xml文件
	 * 
	 * @param fileNamePath
	 *            目标XML文件路径名 void
	 * @date 2008-3-13
	 * @package com.etone.dao.vo
	 */
	public void toFile(String fileNamePath) {
		try {
			/*
			 * OutputFormat format = OutputFormat.createPrettyPrint();
			 * format.setEncoding("gb2312"); XMLWriter writer = new
			 * XMLWriter(new FileWriter(fileNamePath), format );
			 * writer.write(this.node); writer.close();
			 */
			OutputFormat format = OutputFormat.createPrettyPrint();
			format.setEncoding("UTF-8");
			FileOutputStream fos = new FileOutputStream(new File(fileNamePath));
			// XMLWriter writer = new XMLWriter(new FileWriter(fileNamePath),
			// format );
			XMLWriter writer = new XMLWriter(fos, format);
			writer.write(this.node);
			writer.close();
		} catch (IOException ex) {
			System.out.println("生成xml文件时出错." + fileNamePath);
			ex.printStackTrace();
		}
	}

	public Document getNode() {
		return node;
	}

	public void setNode(Document node) {
		this.node = node;
		this.root = this.node.getRootElement();
		this.parent = this.node.getParent();
	}

	public Element getParent() {
		return parent;
	}

	public void setParent(Element parent) {
		this.parent = parent;
	}

	public Element getRoot() {
		return root;
	}

	public void setRoot(Element root) {
		this.root = root;
	}

	public List getSubNodes() {
		return subNodes;
	}

	public String getFdcDefaultValue() {
		return fdcDefaultValue;
	}

	public void setFdcDefaultValue(String fdcDefaultValue) {
		this.fdcDefaultValue = fdcDefaultValue;
	}

	public String getFddDefaultValue() {
		return fddDefaultValue;
	}

	public void setFddDefaultValue(String fddDefaultValue) {
		this.fddDefaultValue = fddDefaultValue;
	}

	public String getFdiDefaultValue() {
		return fdiDefaultValue;
	}

	public void setFdiDefaultValue(String fdiDefaultValue) {
		this.fdiDefaultValue = fdiDefaultValue;
	}

	/**
	 * 删除原有子结点,再增加新结点
	 * 
	 * @param subNodes
	 */
	public void setSubNodes(List subNodes) {
		if (subNodes == null) {
			return;
		}
		Iterator it = this.root.elementIterator();
		while (it.hasNext()) {
			this.root.remove((Element) it.next());
		}

		this.subNodes = subNodes;
		it = subNodes.iterator();
		while (it.hasNext()) {
			Element e = (Element) ((CacheNodeVO) it.next()).getRoot();
			this.root.add(e);
		}
	}

	/**
	 * 增加子结点
	 * 
	 * @param subNodes
	 */
	public void addSubNodes(List subNodes) {
		if (subNodes == null) {
			return;
		}
		Iterator it = subNodes.iterator();
		while (it.hasNext()) {
			CacheNodeVO mapVo = (CacheNodeVO) it.next();
			this.subNodes.add(mapVo);
			Element e = (Element) mapVo.getRoot();
			this.root.add(e);
		}
	}

	/**
	 * 增加子结点
	 * 
	 * @param subNodes
	 */
	public void addSubNode(CacheNodeVO subNode) {
		this.subNodes.add(subNode);
		this.root.add(subNode.getRoot());
	}

	public static void main(String[] args) {

		CacheNodeVO mapVo = new CacheNodeVO("Data");
		mapVo.addAttribute("version", "1.1");
		mapVo.addAttribute("name", "flash map data");
		mapVo.addAttribute("time", "2008-01-01");

		CacheNodeVO mapVo1 = new CacheNodeVO("Rtds");
		mapVo1.addAttribute("fdiId", "1");
		mapVo1.addAttribute("name", "RTD1");
		mapVo1.addAttribute("time", "2008-01-01");

		CacheNodeVO mapVo2 = new CacheNodeVO("Rtds");
		mapVo2.addAttribute("fdiId", "2");
		mapVo2.addAttribute("name", "RTD2");
		mapVo2.addAttribute("time", "2008-01-01");

		CacheNodeVO mapVo3 = new CacheNodeVO("Rtds");
		mapVo3.addAttribute("fdiId", "2");
		mapVo3.addAttribute("name", "RTD2");
		mapVo3.addAttribute("time", "2008-01-01");

		List subNodes = new ArrayList();
		subNodes.add(mapVo1);
		subNodes.add(mapVo2);
		subNodes.add(mapVo3);
		mapVo.setSubNodes(subNodes);
		mapVo.setSubNodes(subNodes);
		// 写入文件
		mapVo.toFile("C:/test.xml");
		System.out.println("-----------");
		System.out.println(mapVo.toXMLString());
		// 读取
		CacheNodeVO cnv = new CacheNodeVO();
		cnv.setNode(XMLUtils.read("C:/test.xml"));
		Element root = cnv.getRoot();//获取根节点
		List nodes = root.elements("test");//获取根节点下的所有test节点

	}


}

 

import java.io.File;
import java.io.FileWriter;
import java.io.StringWriter;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

/**
 * XML工具类
 * 
 * @author kstrive
 * @since 2008-01-02
 */
public class XMLUtils {

	/**
	 * 返回格式化的XML字段串
	 * 
	 * @param document
	 *            要格式化的文档
	 * @param encoding
	 *            使用的编码,如果为null刚使用默认编码(gb2312)
	 * @return 格式化的XML字段串
	 */
	public static String toXMLString(Document document, String encoding) {
		if (encoding == null) {
			encoding = "gb2312";
		}
		StringWriter writer = new StringWriter();
		OutputFormat format = OutputFormat.createPrettyPrint();
		format.setEncoding("gb2312");
		XMLWriter xmlwriter = new XMLWriter(writer, format);
		try {
			xmlwriter.write(document);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return writer.toString();
	}

	/**
	 * 返回格式化的XML字段串
	 * 
	 * @param element
	 *            要格式化的节点元素
	 * @param encoding
	 *            使用的编码,如果为null刚使用默认编码(gb2312)
	 * @return 格式化的XML字段串
	 */
	public static String toXMLString(Element element, String encoding) {
		if (encoding == null) {
			encoding = "gb2312";
		}
		StringWriter writer = new StringWriter();
		OutputFormat format = OutputFormat.createPrettyPrint();
		format.setEncoding(encoding);
		XMLWriter xmlwriter = new XMLWriter(writer, format);
		try {
			xmlwriter.write(element);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return writer.toString();
	}

	/**
	 * 格式化文档并输出到文件
	 * 
	 * @param document
	 *            要输出的文档
	 * @param filename
	 *            XML文件名
	 * @param encoding
	 *            使用的编码,如果为null刚使用默认编码(gb2312)
	 * @return true or false
	 */
	public static boolean toXMLFile(Document document, String filename,
			String encoding) {
		if (encoding == null) {
			encoding = "gb2312";
		}
		boolean returnValue = false;
		try {
			XMLWriter output = null;
			/** 格式化输出,类型IE浏览一样 */
			OutputFormat format = OutputFormat.createPrettyPrint();
			/** 指定XML字符集编码 */
			format.setEncoding(encoding);
			output = new XMLWriter(new FileWriter(new File(filename)), format);
			output.write(document);
			output.close();
			/** 执行成功,需返回1 */
			returnValue = true;
		} catch (Exception ex) {
			ex.printStackTrace();
			returnValue = false;
		}
		return returnValue;
	}

	/**
	 * 格式化XML文件并保存
	 * 
	 * @param srcFileName
	 *            源XML文件
	 * @param desFileName
	 *            格式化后的XML文件,如果为null,则使用srcFileName
	 * @param encoding
	 *            使用的编码,如果为null刚使用默认编码(gb2312)
	 * @return true or false
	 */
	public static boolean toXMLFile(String srcFileName, String desFileName,
			String encoding) {
		if (encoding == null) {
			encoding = "gb2312";
		}
		if (desFileName == null) {
			desFileName = srcFileName;
		}
		boolean returnValue = false;
		try {
			SAXReader saxReader = new SAXReader();
			Document document = saxReader.read(new File(srcFileName));
			XMLWriter output = null;
			/** 格式化输出,类型IE浏览一样 */
			OutputFormat format = OutputFormat.createPrettyPrint();
			/** 指定XML字符集编码 */
			format.setEncoding(encoding);
			output = new XMLWriter(new FileWriter(new File(desFileName)),
					format);
			output.write(document);
			output.close();
			/** 执行成功,需返回1 */
			returnValue = true;
		} catch (Exception ex) {
			ex.printStackTrace();
			returnValue = false;
		}
		return returnValue;
	}

	/**
	 * 从读取XML文件
	 * 
	 * @param fileName
	 * @return Document对象
	 */
	public static Document read(String fileName) {
		SAXReader reader = new SAXReader();
		Document document = null;
		try {
			document = reader.read(new File(fileName));
		} catch (DocumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return document;
	}

	/**
	 * 从XML字符串转换到document
	 * 
	 * @param xmlStr
	 *            XML字符串
	 * @return Document
	 */
	public static Document parseText(String xmlStr) {
		Document document = null;
		try {
			document = DocumentHelper.parseText(xmlStr);
		} catch (DocumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return document;
	}
}

 

分享到:
评论

相关推荐

    xml解析工具类

    本教程将详细介绍一个名为"WXML"的XML解析工具类,该工具类能便捷地将XML数据转换为Java对象,从而简化开发流程。 首先,XML解析分为两种主要方式:DOM(Document Object Model)和SAX(Simple API for XML)。DOM...

    java开发工具类(14个)

    - Log工具类:自定义日志打印,便于调试和分析程序运行情况。 - SharedPreferences工具类:简化SharedPreferences的读写操作。 - Android权限管理工具类:处理Android运行时权限的请求和检查。 - 网络状态检测...

    JXAB进行接口开发解析xml的工具类

    在"JXAB进行接口开发解析xml的工具类"这个主题中,我们将深入探讨如何利用JXAB这一工具进行XML解析,以及在接口开发中应用这些技术。 首先,JXAB可能是一个自定义的Java库,专门为处理XML数据提供便利的工具集。在...

    Java工具类之Apache的Commons Lang和BeanUtils

    Java工具类是开发过程中不可或缺的一部分,它们提供了许多实用的功能,帮助开发者提高代码的效率和可维护性。Apache Commons Lang和BeanUtils是两个非常著名的Java工具库,由Apache软件基金会开发和维护。这两个库...

    C# .Net 工具类大部分全部集成

    "C# .Net 工具类大部分全部集成"这个压缩包文件显然包含了多种实用的工具类,涵盖了验证、缓存、加密解密、时间处理、XML处理以及图片处理等多个关键领域。下面将对这些知识点进行详细阐述。 首先,我们来看验证...

    excel导出工具类

    6. **自定义配置**:为了满足不同需求,工具类可能提供接口,让用户可以自定义导出的细节,如设置特定列的宽度、排序方式等。 7. **多线程支持**:在处理大量数据或者并发请求时,工具类可能支持多线程导出,提高...

    java高效开发26个工具类

    1. **字符串处理**:在Java中,String类虽然强大,但有时仍需自定义工具类来增强功能,如字符串格式化、去除空白、替换、分割等。 2. **集合操作**:可能包括对ArrayList、LinkedList、HashMap等集合的便捷操作,如...

    Android-安卓常用工具类

    在Android开发过程中,工具类(Utility Class)是开发者经常使用的一种设计模式,它们通常包含一组静态方法,用于执行特定的任务或者提供便捷的功能。这些工具类可以极大地提高代码的复用性和可维护性。"Android-...

    Android-轻量级android工具类辅助类通用类

    1. **UI工具类**:这部分可能包括了处理视图、动画、颜色转换等与界面相关的功能,如`ViewUtils`,`AnimationUtils`等。 2. **网络工具类**:可能包含了网络请求的辅助方法,如`HttpUtils`,可以方便地进行GET、...

    JAVA一键操作 XML简单API

    8. **兼容性和扩展性**:考虑到Java的广泛使用,这个XML工具类可能已经考虑到了与各种Java版本的兼容性,并且可能提供了一些扩展点,允许用户根据需要自定义行为。 在项目中使用这个API时,你需要先将其`lib`目录下...

    工具类_java工具类_java_

    这个工具类还可能包含线程安全的工具、异常处理、日志记录、网络操作、加密解密、XML或JSON序列化与反序列化等功能,以满足不同场景的需求。 这个全面的Java工具类是开发中的得力助手,它通过集成了各种常见功能,...

    Android开发工具类

    Android的日志系统是调试的重要手段,工具类可能提供自定义日志标签、级别控制、格式化输出等功能,便于追踪程序运行状态。 7. **权限管理工具类** 针对Android 6.0及以上版本的运行时权限管理,工具类可能会有...

    C#JSon XML序列化与反序列化工具

    本文将详细讲解C#中JSON和XML的序列化与反序列化工具,以及如何自制一个实用的解析工具。 首先,JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,易于人阅读和编写,同时也方便机器解析和生成。在...

    基于tinyxml2的xml操作库再封装

    总结来说,"基于tinyxml2的xml操作库再封装"项目为C++开发者提供了一个高效、易用的XML处理工具,通过优化和扩展tinyxml2的功能,使得XML数据的处理变得更加直观和便捷。这将极大地提高开发效率,降低开发成本,尤其...

    Android开发中解析xml文件XmlUtils工具类与用法示例

    总结起来,`XmlUtil`工具类简化了Android开发中XML文件的解析过程,通过反射机制将XML数据自动绑定到Java对象上,使得数据解析变得更加便捷。然而,对于大型项目或复杂XML结构,可能需要更强大的XML解析库来提供更高...

    安卓开发框架工具类相关-可以修改标题栏颜色的工具类Demo.rar

    总结来说,这个工具类Demo提供了一种便捷的方式去修改Android应用标题栏的颜色,对于开发者而言,可以快速实现界面的个性化设计,提升应用的视觉效果。同时,通过学习和研究此类,也能加深对Android UI编程的理解,...

    Android-BDLocationUtil百度地图定位工具类

    BDLocationUtil工具类封装了百度地图SDK中的定位接口,如LocationClient、OnMyLocationChangeListener等。它简化了配置过程,使得开发者不再需要直接处理复杂的初始化和设置监听器的步骤。例如,通过BDLocationUtil...

    实体类生成XML格式字符串

    在Java编程中,有时我们需要将实体类对象转换成XML格式的字符串,这在数据交换...总的来说,Java提供了一套完整的工具链来帮助开发者将实体类转换为XML格式的字符串,这使得在Java应用程序中处理XML数据变得更加便捷。

    EasyExcel2.0工具类

    本文将深入探讨如何使用SpringBoot 2.0框架结合EasyExcel 2.0工具类来实现高效、便捷的Excel导入导出功能。EasyExcel是阿里巴巴提供的一款轻量级Java处理Excel的库,它基于Apache POI,但优化了内存占用,非常适合大...

Global site tag (gtag.js) - Google Analytics