`

java利用SAX解析XML

    博客分类:
  • java
阅读更多

java利用SAX解析XML

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class XmlTreateUtil extends DefaultHandler {

	@Override
	public void startElement(String uri, String localName, String qName,
			Attributes attributes) throws SAXException {
		depth++;
		leafValue = null;
		isChanged = true;
		if (startTagList.size() == 0) {
			root.setTagName(qName);
			if (attributes != null) {
				for (int i = 0; i < attributes.getLength(); i++) {
					String attributeName = attributes.getQName(i);
					if ("schema".equals(attributeName)) {
						root.setSchema(attributes.getValue("schema"));
					} else if ("version".equals(attributeName)) {
						root.setVersion(attributes.getValue("version"));
					} else {
						root.addAttribute(attributes.getQName(i),
								attributes.getValue(i));
					}
				}
			}
			cdoMap.put(qName, root);
		}
		startTagList.add(qName);
	}

	@Override
	public void endElement(String uri, String localName, String qName)
			throws SAXException {
		depth--;
		if (null != leafValue && !"".equals(qName)) {
			if(qName.contains(":")){
				leafElementMap.put(qName.substring(qName.indexOf(":")+1).toLowerCase(), leafValue);
			}else{
				leafElementMap.put(qName.toLowerCase(), leafValue);
			}
			leafValue = null;
		}
		int n = 0;
		XMLElement cdo = null;
		for (int index = startTagList.size() - 1; index > 0; index--) {
			if (startTagList.get(index).equals(qName)) {
				// 父节点判断
				if (cdoMap.get(qName) != null) {
					cdoMap.remove(qName);
					startTagList.remove(qName);
					return;
				}
				if (n <= 0) {
					cdo = processCdoMap(index - 1);
					cdo.addChild(qName, value);
				}
				startTagList.remove(qName);
				break;
			} else {
				n++;
			}
		}
	}

	private XMLElement processCdoMap(int i) {
		if (i == 0) {
			return root;
		}
		XMLElement cdo = cdoMap.get(startTagList.get(i));
		if (cdo == null) {
			cdo = new XMLElement();
			cdo.setTagName(startTagList.get(i));
			cdoMap.put(startTagList.get(i), cdo);
			XMLElement root = processCdoMap(i - 1);
			root.addChild(startTagList.get(i), cdo);
		}
		return cdo;
	}

	@Override
	public void characters(char[] ch, int start, int length)
			throws SAXException {
		leafValue = new String(ch, start, length);
		if (!isChanged) {
			value.append(new String(ch, start, length));
		} else {
			value = new StringBuffer(new String(ch, start, length));
		}
		isChanged = false;
	}

	public XMLElement parseXmlReqString(String xmlReq) {
		StringReader read = new StringReader(xmlReq);
		InputSource source = new InputSource(read);
		parse(source);
		root.setLeafElementMap(leafElementMap);
		return root;
	}

	public XMLElement parseXmlFromFile(String fileName) {
		try {
			InputSource source = new InputSource(new FileInputStream(fileName));
			parse(source);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		root.setLeafElementMap(leafElementMap);
		return root;
	}

	private void parse(InputSource source) {
		SAXParser sp;
		SAXParserFactory sf = SAXParserFactory.newInstance();
		try {
			sp = sf.newSAXParser();
			sp.parse(source, this);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// 标签值
	private StringBuffer value;
	private List<String> startTagList = new ArrayList<String>();
	private Map<String, XMLElement> cdoMap = new HashMap<String, XMLElement>();
	private XMLElement root = new XMLElement();
	// 是否是同一个标签
	private boolean isChanged;

	int depth = 0;
	/**
	 * 去重后的叶子节点,key为节点名称,value为文本值
	 */
	private Map<String, String> leafElementMap = new HashMap<String, String>();
	String leafValue = null;
}

 

import java.io.PrintWriter;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import javax.servlet.http.HttpServletResponse;
import sun.misc.BASE64Decoder;

@SuppressWarnings("restriction")
public class XMLElement implements Serializable {

	public XMLElement() {

	}

	public XMLElement(String version, String schema) {
		this.setVersion(version);
		this.setSchema(schema);
	}

	public XMLElement(String version, String schema, Map<String, Object> map) {
		this(version, schema);
		Set<Entry<String, Object>> set = map.entrySet();
		for (Entry<String, Object> entry : set) {
			this.addChild(entry.getKey(), entry.getValue());
		}
	}

	public XMLElement(String version, String schema, String nameValuePair) {
		this(version, schema);
		String[] nameValuePairs = nameValuePair.split("\\,");
		for (String nameValue : nameValuePairs) {
			this.addChild(nameValue.split("\\:")[0], nameValue.split("\\:")[1]);
		}
	}

	public String getVersion() {
		return version;
	}

	public void setVersion(String version) {
		this.version = version;
		addAttribute("version", version);
	}

	public String getSchema() {
		return schema;
	}

	public void setSchema(String schema) {
		this.schema = schema;
		addAttribute("schema", schema);
	}

	public void setTagName(String tagName) {
		this.tagName = tagName;
	}

	public void addAttribute(String key, String value) {
		this.attributeMap.put(key, value);
	}

	@SuppressWarnings("unchecked")
	public void addChild(String key, Object value) {
		if (value == null) {
			return;
		}

		childList.add(key);
		// 判断当前map中是否已有值
		List lis = this.childMap.get(key);
		if (lis != null) {
			lis.add(value);
			this.childMap.put(key, lis);
		} else {
			// childMap
			List list = new ArrayList();
			list.add(value);
			this.childMap.put(key, list);
		}
	}

	/**
	 * 添加唯一性子节点(会删掉旧有值,有的话)
	 * 
	 * @param key
	 * @param value
	 */
	public void addUniqueChild(String key, Object value) {
		if (value == null) {
			return;
		}

		childList.add(key);
		List<Object> list = new ArrayList<Object>();
		list.add(value);
		this.childMap.put(key, list);
	}

	/**
	 * 替换childMap中的key为给定key,替换规则:不区分大小写的情况下2个key相同
	 * 
	 * @param key
	 */
	public void replaceChildKey(String key) {
		try {
			Set<Entry<String, List<?>>> set = childMap.entrySet();
			String oldKey = null;
			for (Entry<String, List<?>> entry : set) {
				if (key.equals(entry.getKey())) {
					break;
				}
				if (key.equalsIgnoreCase(entry.getKey())) {
					oldKey = entry.getKey();
				}
			}
			if (oldKey != null) {
				// 添加新key
				addChild(key, childMap.get(oldKey).get(0));
				// 删除旧key
				removeChild(oldKey);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 删除节点
	 * 
	 * @param oldKey
	 */
	private void removeChild(String oldKey) {
		childList.remove(oldKey);
		childMap.remove(oldKey);
	}

	/**
	 * cdo对象转换成xml字符串
	 */
	public String toXML() {
		StringBuffer sb = new StringBuffer();
		return toXML(sb.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"),
				0);
	}

	private String toXML(StringBuffer sb, int n) {
		this.validKey = new HashMap<String, Boolean>();
		appendTabs(sb, n);
		sb.append("<").append(tagName);

		// 处理属性节点
		processAttributeMap(sb);

		sb.append(">\n");
		// 处理子节点
		processChildMap(sb, n + 1);

		appendTabs(sb, n);
		sb.append("</").append(tagName).append(">\n");
		return sb.toString();
	}

	private void appendTabs(StringBuffer sb, int n) {
		for (int i = 0; i < n; i++) {
			sb.append("\t");
		}
	}

	public double divide(String key, double divide, int scale, int roundingMode) {
		return BigDecimal.valueOf(Double.valueOf(this.getStringValue(key)))
				.divide(BigDecimal.valueOf(divide), scale, roundingMode)
				.doubleValue();
	}

	public double multiply(String key, double divide, int scale,
			int roundingMode) {
		return BigDecimal.valueOf(Double.valueOf(this.getStringValue(key)))
				.multiply(BigDecimal.valueOf(divide))
				.setScale(scale, roundingMode).doubleValue();
	}

	/**
	 * @param sb
	 */
	@SuppressWarnings("unchecked")
	private void processChildMap(StringBuffer sb, int n) {
		for (int i = 0; i < childList.size(); i++) {
			String key = childList.get(i);
			if (validKey.get(key) != null && validKey.get(key).booleanValue()) {
				continue;
			} else {
				validKey.put(key, true);
			}
			Object value = childMap.get(key);

			if (value instanceof XMLElement) {
				((XMLElement) value).toXML(sb, n);
			} else if (value instanceof List) {
				List list = (List) value;
				for (Object object : list) {
					if (object instanceof XMLElement) {
						((XMLElement) object).toXML(sb, n);
					} else if (object instanceof XMLElement[]) {
						for (XMLElement cdo : (XMLElement[]) object) {
							cdo.toXML(sb, n);
						}
					} else {
						appendTabs(sb, n);
						sb.append("<").append(key).append(">").append(object)
								.append("</").append(key).append(">\n");
					}
				}
			} else {
				appendTabs(sb, n);
				sb.append("<").append(key).append(">").append(value)
						.append("</").append(key).append(">\n");
			}
		}
	}

	/**
	 * @param sb
	 */
	private void processAttributeMap(StringBuffer sb) {
		Set<Entry<String, String>> set = attributeMap.entrySet();
		Iterator<Entry<String, String>> it = set.iterator();
		while (it.hasNext()) {
			Entry<String, String> entry = it.next();
			sb.append(" ").append(entry.getKey()).append("=\"")
					.append(entry.getValue()).append("\"");
		}
	}

	/**
	 * cdo对象转换成json格式字符串
	 */
	public String toJSON() {
		StringBuffer sb = new StringBuffer();
		this.validKey = new HashMap<String, Boolean>();
		// 处理子节点
		for (int i = 0; i < childList.size(); i++) {
			String key = childList.get(i);
			if (validKey.get(key) != null && validKey.get(key).booleanValue()) {
				continue;
			} else {
				validKey.put(key, true);
			}
			Object value = childMap.get(key);

			if (value instanceof XMLElement) {
				sb.append("\"").append(key).append("\":[")
						.append(((XMLElement) value).toJSON()).append("],");
			} else if (value instanceof List) {
				List list = (List) value;
				for (int j = 0; j < list.size(); j++) {
					Object object = list.get(j);
					if (object instanceof XMLElement) {
						sb.append("\"").append(key).append("\":{")
								.append(((XMLElement) object).toJSON())
								.append("},");
					} else if (object instanceof XMLElement[]) {
						XMLElement[] cdos = (XMLElement[]) object;
						sb.append("\"").append(key).append("\":[");
						String temp = "";
						for (XMLElement cdo : cdos) {
							temp += "{" + cdo.toJSON() + "},";
						}
						temp = temp.substring(0, temp.length() - 1);
						sb.append(temp).append("],");
					} else {
						sb.append("\"").append(key).append("\":\"")
								.append(object).append("\",");
					}
				}
			} else {
				sb.append("\"").append(key).append("\":\"").append(value)
						.append("\",");
			}
		}

		return sb.toString().length() > 0 ? sb.toString().substring(0,
				sb.toString().length() - 1) : sb.toString();
	}

	/**
	 * 输出xml格式字符串到指定response中
	 * 
	 * @param response
	 */
	public void printJSON(HttpServletResponse response) {
		response.setContentType("text/html;charset=UTF-8");
		PrintWriter out;
		try {
			out = response.getWriter();
			out.print("{" + toJSON() + "}");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 输出xml格式字符串到指定response中
	 * 
	 * @param response
	 */
	public void printXML(HttpServletResponse response) {
		response.setContentType("text/xml;charset=UTF-8");
		PrintWriter out;
		try {
			out = response.getWriter();
			out.print(toXML());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 获取当前对象中给定attribute值
	 * 
	 * @param key
	 * @return
	 */
	public String getAttributeValue(String key) {
		return this.attributeMap.get(key);
	}

	/**
	 * 获取当前对象中给定的子节点值
	 * 
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Object getChildObject(String key) {
		return ((List) getChildValue(key)).get(0);
	}

	/**
	 * 获取当前对象中给定的子节点值
	 * 
	 * @param key
	 * @return
	 */
	public Object getChildValue(String key) {
		return this.childMap.get(key) == null ? null : this.childMap.get(key);
	}

	/**
	 * 获取给定key值的List对象,List中的值可能为String、CDO类型
	 * 
	 * @param key
	 * @return
	 */
	public List<?> getListValue(String key) {
		return (List<?>) getChildValue(key);
	}

	/**
	 * 获取CDO数组
	 * 
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public XMLElement[] getCdoArrayValue(String key) {
		List<XMLElement[]> value = (List<XMLElement[]>) this.getListValue(key);
		if (value != null && value.size() > 0) {
			return value.get(0);
		} else {
			return null;
		}
	}

	@SuppressWarnings("unchecked")
	public XMLElement getCdoValue(String key) {
		List<XMLElement> value = (List<XMLElement>) this.getListValue(key);
		return value == null ? null : value.get(0);
	}

	/**
	 * 获取String数组
	 * 
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public String[] getStringArrayValue(String key) {
		List<String> value = (List<String>) this.getListValue(key);
		return value == null ? null : (String[]) value.toArray();
	}

	/**
	 * 获取标签值
	 * 
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public String getStringValue(String key) {
		return this.getChildValue(key) == null ? null : ((List) this
				.getChildValue(key)).get(0).toString();
	}

	public String getBigDecimalString(String key) {
		return new java.text.DecimalFormat("#.00").format(Double
				.valueOf(getStringValue(key)));
	}

	@SuppressWarnings("unchecked")
	public Boolean getBooleanValue(String key) {
		return (Boolean) (this.getChildValue(key) == null ? false
				: ((List) this.getChildValue(key)).get(0));
	}

	/**
	 * 获取标签值
	 * 
	 * @param key
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Integer getIntegerValue(String key) {
		return this.getChildValue(key) == null ? null : Integer
				.parseInt(((List) this.getChildValue(key)).get(0).toString());
	}

	/**
	 * 获取标签值
	 * 
	 * @param key
	 * @return
	 */
	public Long getLongValue(String key) {
		return this.getChildValue(key) == null ? null : Long
				.parseLong(((List) this.getChildValue(key)).get(0).toString());
	}

	/**
	 * 判断是否存在对应的key值
	 * 
	 * @param key
	 * @return true,false
	 */
	public boolean hasChild(String key) {
		return this.childMap.containsKey(key);
	}

	public Map<String, List<?>> getChildMap() {
		return this.childMap;
	}

	public byte[] getBytesFromBASE64(String b) throws Exception {
		if (b == null)
			return null;
		BASE64Decoder decode = new BASE64Decoder();
		return decode.decodeBuffer(b);
	}

	/**
	 * 把非CDO对象的子节点遍历到Map<String, String>中
	 * 
	 * @return Map<String, String>
	 */
	public Map<String, Object> getReqeustMap() {
		Set<Entry<String, List<?>>> set = childMap.entrySet();
		Map<String, Object> returnMap = new HashMap<String, Object>();

		for (Entry<String, List<?>> entry : set) {
			List<?> list = entry.getValue();
			if (list != null && list.size() != 0) {
				Object object = list.get(0);
				if (object instanceof XMLElement) {
					continue;
				}
				// 判断是否是byte[]类型:判断规则value值的长度大于1000
				if (!(object instanceof byte[])
						&& object.toString().length() > 1000) {
					try {
						returnMap.put(entry.getKey(),
								getBytesFromBASE64(object.toString()));
					} catch (Exception e) {
						e.printStackTrace();
					}
				} else {
					returnMap.put(entry.getKey(), object.toString());
				}
			}
		}

		return returnMap;
	}

	/**
	 * 把给定的Map对象中解析成CDO对象,数据存储到childMap属性中
	 * 
	 * @param map
	 * @return
	 */
	public static XMLElement getCDOFromMap(Map<String, String> map) {
		XMLElement cdo = new XMLElement();
		Set<Entry<String, String>> set = map.entrySet();
		for (Entry<String, String> entry : set) {
			cdo.addChild(entry.getKey(), entry.getValue());
		}

		return cdo;
	}

	/**
	 * 把给定的Map对象中解析成CDO对象,数据存储到childMap属性中
	 * 
	 * @param map
	 * @return
	 */
	public void setChildFromMap(Map<String, String> map) {
		Set<Entry<String, String>> set = map.entrySet();
		for (Entry<String, String> entry : set) {
			this.addChild(entry.getKey(), entry.getValue());
		}
	}

	/**
	 * 所要执行的sql标识: namespace.sqlId
	 */
	public void setNamespaceSql(String namespaceSql) {
		this.namespaceSql = namespaceSql;
	}

	public String getNamespaceSql() {
		return namespaceSql;
	}

	@Override
	public String toString() {
		return toXML();
	}

	public static XMLElement fromXML(String reqXml) {
		XmlTreateUtil dto = new XmlTreateUtil();
		if(null!=reqXml&&!reqXml.contains("<?xml ")){
			reqXml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"+ reqXml;
		}
		return dto.parseXmlReqString(reqXml);
	}

	public String getLeafValue(String key) {
		if(null==key) return null;
		return leafElementMap.get(key.toLowerCase());
	}

	public void setLeafElementMap(Map<String, String> leafElementMap) {
		this.leafElementMap = leafElementMap;
	}

	private static final long serialVersionUID = 1L;
	private Map<String, Boolean> validKey;
	private String version;
	private String schema;
	private Map<String, String> attributeMap = new HashMap<String, String>();
	private Map<String, List<?>> childMap = new HashMap<String, List<?>>(20);
	private String tagName = "root";
	private List<String> childList = new ArrayList<String>(20);
	public static XMLElement NOT_POST = new XMLElement("1.0", "accessLimit",
			"return:9011,description:请求类型错误,要求为POST请求。");
	public static XMLElement OK = new XMLElement("1.0", "processSuccess",
			"return:00,description:操作成功。");
	public static XMLElement ERROR = new XMLElement("1.0", "processFail",
			"return:01,description:操作失败。");
	private String namespaceSql;
	/**
	 * 去重后的叶子节点,key为节点名称,value为文本值
	 */
	private Map<String, String> leafElementMap = new HashMap<String, String>();
	
	public static void main(String[] args) {
		String xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"+
				"<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\"" +
				          " xmlns:SOAP-ENC=\"http://schemas.xmlsoap.org/soap/encoding/\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"" +
				          " xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:comm3=\"http://www.chinatelecom.com.cn/schema/ctcc/common/v2_1\"" +
				          " xmlns:sms7=\"http://www.chinatelecom.com.cn/schema/ctcc/sms/notification/v2_1/local\">" +
				          " <SOAP-ENV:Header>" +
				          "  <comm3:NotifySOAPHeader>" +
				          "   <spRevId>spRevId</spRevId>" +
				          "   <spRevpassword>password</spRevpassword>" +
				          "   <spId>1234</spId>" +
				          "   <SAN>tel:199999999</SAN>" +
				          "   <linkId>1111122222222222</linkId>" +
				          "  </comm3:NotifySOAPHeader>" +
				          " </SOAP-ENV:Header>" +
				          " <SOAP-ENV:Body>" +
				          "  <sms7:notifySmsReception>" +
				          "   <sms7:registrationIdentifier>3444444444444444</sms7:registrationIdentifier>" +
				          "   <sms7:message>" +
				          "    <message>sp</message>" +
				          "    <senderAddress>tel:sdfffffffff</senderAddress>" +
				          "    <smsServiceActivationNumber>tel:sdffffff</smsServiceActivationNumber>" +
				          "   </sms7:message>" +
				          "  </sms7:notifySmsReception>" +
				          " </SOAP-ENV:Body>" +
				          "</SOAP-ENV:Envelope>";
		XMLElement root = XMLElement.fromXML(xml);
		System.out.println(root.toJSON());
		// System.out.println(new HashMap());
		// System.out.println((((List<CDO>)root.getChildValue("mobileVerifyParam")).get(0)).getListValue("contactName"));
	}
}

 

 

分享到:
评论

相关推荐

    SAX解析XML文件实例

    一个项目同时用dom解析和sax解析xml文件貌似会报错,项目框架建一直是用sax和dom4j解析xml文件的。当我用dom解析xml文件。导入包后就报错识别不了xml文件的编码格式。于是做了一个sax解析xml文件的实例

    Java SAX解析Xml文档Demo

    本示例将详细解释如何在Java中使用SAX解析XML文档,并通过注释进行详细说明。 首先,我们需要引入SAX解析器的依赖库,通常这可以通过在项目构建配置中添加JAXB或Xerces实现来实现。 ```java // 引入必要的库,如...

    Sax解析XML文件解析

    **SAX解析XML的基本原理:** SAX解析器以流式的方式读取XML文档,当遇到文档的各个元素时,会触发相应的事件,如开始文档、开始元素、结束元素、字符数据等。程序员通过实现SAX解析器的回调接口来处理这些事件,从而...

    Servlet利用SAX解析XML文档

    本主题将深入探讨如何在Servlet中利用SAX解析XML文档。 首先,我们需要了解SAX解析的基本原理。SAX解析器不创建整个XML文档树,而是当遇到XML文档的各个部分(如元素、属性、文本等)时,触发相应的事件回调函数。...

    JAVA100例之实例69 JAVA使用SAX解析XML

    本实例“JAVA100例之实例69 JAVA使用SAX解析XML”将详细讲解如何利用SAX解析XML文件。SAX解析器通过触发一系列的回调事件来处理XML文档,程序员需要定义一个实现了`org.xml.sax.helpers.DefaultHandler`接口的类,...

    sax解析xml尤其是获取元素的值或者内容

    本文将深入探讨如何使用SAX解析XML并获取元素的值或内容。 首先,SAX解析器以流式方式读取XML文档,当遇到文档的不同部分时,会触发相应的事件,如开始文档、开始元素、结束元素等。开发者可以注册事件处理器来响应...

    Sax解析xml文件

    以下是一个使用SAX解析XML文件的基本步骤: 1. **创建解析器**: 首先,我们需要创建一个SAX解析器实例。在Java中,这通常通过`SAXParserFactory`类完成。设置解析器属性,然后调用`newSAXParser()`方法获取`...

    java解析xml数据---sax解析器

    以下是使用SAX解析XML的基本步骤: 1. 创建一个实现DefaultHandler或ContentHandler接口的类,重写其中的方法,如startElement()、endElement()和characters(),用于处理XML文档的结构和数据。 2. 实例化SAX解析器...

    sax解析xml文件

    总结来说,"saxloadxml"项目提供了使用SAX解析XML文件的一个实例,可以帮助开发者了解如何利用SAX解析器处理XML文档,尤其是在性能和内存使用方面有较高要求的情况下。通过学习和实践这个项目,你可以提升处理XML...

    JAVA SAX解析XML

    **JAVA SAX解析XML** 在Java编程中,XML(Extensible Markup Language)是一种广泛使用的数据交换格式,用于存储和传输结构化数据。为了处理XML文档,Java提供了两种主要的解析方式:DOM(Document Object Model)...

    javaSAX方式解析xml文档

    Java SAX方式解析XML文档是一种高效的处理大型XML文件的方法,它基于事件驱动模型,不将整个XML文档加载到内存中,而是逐个处理XML元素。这种方式非常适合处理大文件,因为它节省了内存,但需要编写更多的代码来处理...

    java sax 解析xml

    下面将详细介绍Java SAX解析XML的相关知识点。 1. **SAX解析原理**: - SAX解析器读取XML文件,遇到每个元素、属性、文本等,都会触发一个相应的事件。 - 应用程序通过实现SAX解析器的回调接口,定义处理这些事件...

    sax解析xml

    下面我们将深入探讨SAX解析XML的相关知识点。 1. **SAX解析器的初始化**:在Java中,我们通常使用`org.xml.sax.parsers.SAXParserFactory`类来创建并配置SAX解析器。首先,我们需要实例化一个SAXParserFactory对象...

    XML-java.rar_XML SAX_sax_sax xml_sax 解析 xml_xml using dom

    "sax_xml sax_解析_xml"标签表明了本压缩包包含使用SAX解析XML的示例代码。 3. **JDOM**:JDOM是一个Java API,专门用于读写XML文档。它提供了一个更面向Java的对象模型,使得XML处理更加直观。JDOM在DOM的基础上...

    SAX解析XML实例

    总的来说,SAX解析XML是一种高效且灵活的方法,适用于处理大型XML文档。通过自定义事件处理器,我们可以根据业务需求定制解析逻辑,从而有效地解析和利用XML数据。在实际项目中,结合源码分析和工具使用,如IDE中的...

    读取RSS-SAX解析XML实例(java版)

    标签中的"读取rss"、"SAX解析XML"、"sax"、"xml"、"rss"进一步强调了本实例的重点,即使用SAX解析器处理RSS数据。在实际开发中,这样的功能可能被用于构建RSS阅读器或者数据分析应用。 综上所述,这个Java实例是...

    java Sax解析Xml

    以下是一个简单的SAX解析XML的Java示例: ```java import org.xml.sax.XMLReader; import org.xml.sax.InputSource; import org.xml.sax.helpers.DefaultHandler; public class SaxDemo { public static void ...

    java-SAX解析XML、java正则表达式.

    使用SAX解析XML的基本步骤如下: 1. 创建`SAXParserFactory`实例,这是用于创建`SAXParser`的工厂类。 2. 使用`SAXParserFactory`的`newSAXParser()`方法创建`SAXParser`对象。 3. 创建一个实现了`org.xml.sax....

    sax解析xml本地读取xml

    以下是一个简单的SAX解析XML文件的Java代码示例: ```java import javax.xml.parsers.SAXParser; import javax.xml.parsers.SAXParserFactory; import org.xml.sax.Attributes; import org.xml.sax.ContentHandler;...

Global site tag (gtag.js) - Google Analytics