java循环xml节点

❶ 您好！关于上次用java获取百度API返回的XML数据的节点值的问题，转发后出现了死循环

//获得转发器
RequestDispatcher rd = request
.getRequestDispatcher("Geocoding.do");
//转发
rd.forward(request, response);
你这里又转回来当前的Servlet,代码执行到这里又转回来,当然会出现死循环.

❷ 哪位兄台给一个用java来创建xml文件、更新xml节点的例子

java创建文件不都是一样吗？
至于更新xml文件，看下这个··
别人的
xml:

<?xml version="1.0" encoding="UTF-8"?>

<users>

<Messages>
<sendName>sendUsers</sendName>
<receiveName>snake</receiveName>
<date>2007-12-04 12:20:00</date>
<status>0</status>
<message>this is Content</message>
</Messages>

</users>

java:

package com.lianxi.DAO;
import java.io.File;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class UpdateXml {
public static boolean doc2XmlFile(Document document,String filename)
{
boolean flag = true;
try
{
/** 将document中的内容写入文件中 */
TransformerFactory tFactory = TransformerFactory.newInstance();
Transformer transformer = tFactory.newTransformer();
/** 编码 */
//transformer.setOutputProperty(OutputKeys.ENCODING, "GB2312");
DOMSource source = new DOMSource(document);
StreamResult result = new StreamResult(new File(filename));
transformer.transform(source, result);
}catch(Exception ex)
{
flag = false;
ex.printStackTrace();
}
return flag;
}

public static Document load(String filename)
{
Document document = null;
try
{
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
document=builder.parse(new File(filename));
document.normalize();
}
catch (Exception ex){
ex.printStackTrace();
}
return document;
}
/**
* 演示修改文件的具体某个节点的值
*/
public static void xmlUpdateDemo()
{
Document document = load("c://Message.xml");
Node root=document.getDocumentElement();
/** 如果root有子元素 */
if(root.hasChildNodes())
{
/** ftpnodes */
NodeList ftpnodes = root.getChildNodes();
/** 循环取得ftp所有节点 */
for (int i=0;i<ftpnodes.getLength();i++)
{
NodeList ftplist = ftpnodes.item(i).getChildNodes();
for (int k=0;k<ftplist.getLength();k++)
{
Node subnode = ftplist.item(k);
/** 删除ftp-chn节点 */
// if (subnode.getNodeType()==Node.ELEMENT_NODE&&subnode.getNodeName()=="ftp-chn")
// {
// ftpnodes.item(i).removeChild(subnode);
// }
/** 修改ftp-host的值为 192.168.0.1 */
if (subnode.getNodeType()==Node.ELEMENT_NODE&&subnode.getNodeName()=="status")
{
subnode.getFirstChild().setNodeValue("1");
}
}

}
}

doc2XmlFile(document,"c://Message.xml");
}
public static void main(String args[])throws Exception
{
UpdateXml.xmlUpdateDemo();
}
}

❸ java 如何循环读取xml下相同子节点

Reader reader = new InputStreamReader(con
.getInputStream());
SAXReader sax = new SAXReader();
// sax.setEncoding("GBK");

Document document = sax.read(reader);
document.setXMLEncoding("GBK");
Element root = document.getRootElement();
// Document doc = reader.read(read);
// Element root = doc.getRootElement();
readNode(root, "");

public static void readNode(Element root, String prefix) {
if (root == null) return;
// 获取属性
List attrs = root.attributes();
if (attrs != null && attrs.size() > 0) {
System.err.print(prefix);
for (Attribute attr : attrs) {
System.err.print(attr.getValue() + " ");
}
System.err.println();
}
// 获取他的子节点
List childNodes = root.elements();
prefix += "\t";
for (Element e : childNodes) {
//输出内容
System.err.println(e.getName()+":"+e.getData());
readNode(e, prefix);
}
}

❹ java中用dom4j如何循环XML各个节点，输出属性值到控制台请帮忙写出代码，谢谢！！急急、、急、、

要读的xml文件

<?xml version="1.0" encoding="GB2312"?>
<学生花名册>
<学生 性别 = "男">
<姓名>李华</姓名>
<年龄>14</年龄>
</学生>
<学生 性别 = "男">
<姓名>张三</姓名>
<年龄>16</年龄>
</学生>
</学生花名册>
Vector students_Vector;

private Vector readXMLFile(String file) throws Exception {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dbf.newDocumentBuilder();
Document doc = builder.parse(file); // 获取到xml文件

// 下面开始读取
Element root = doc.getDocumentElement(); // 获取根元素
NodeList students = root.getElementsByTagName_r("学生");
students_Vector = new Vector();
for (int i = 0; i < students.getLength(); i++) {
// 一次取得每一个学生元素
Element ss = (Element) students.item(i);

// 创建一个学生的实例
student stu = new student();
stu.setSex(ss.getAttribute("性别"));

NodeList names = ss.getElementsByTagName_r("姓名");
Element e = (Element) names.item(0);
Node t = e.getFirstChild();
stu.setName(t.getNodeValue());

NodeList ages = ss.getElementsByTagName_r("年龄");
e = (Element) ages.item(0);
t = e.getFirstChild();
stu.setAge(Integer.parseInt(t.getNodeValue()));

students_Vector.add(stu);
}
return students_Vector;
}

参照这个写

❺ java sax如何循环接收xml文件中的元素

package com.xk008.test;

import java.io.File;
import java.io.IOException;
import javax.xml.parsers.*;
//sax解析需要导入的三个包
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
/* ----------兴建此类的步骤：(1)File-->New命令；打开Object Gallery对话框；(2)在对话框左侧的数中选择"XML"节点，
* 然后在右侧选择"SAX Handler"，点"OK"；(3)在新对话框的"class name"处键入MySaxParser[也可以取其它的]作为类名；
* (4)在此新对话框数型结构处，展开"ContentHandler"节点，选中"characters","endDocument","endElemne",
* "startDocument","startElement"五个节点，点"Finish";
* ----------修改此类生成的代码：(1)删除带有"throws"方法的所有子句；(2)然后分别在带有"throws"方法中键入以下类容；
* (3)Main方法的子句可以不变；
*/

//一个继承org.xml.sax.helpers.DefaultHandler的类XX
public class Covert extends DefaultHandler {
//入口点Main
public static void main(String[] args) {
String uri = "table.xml";//获取被解析xml文档路径
//工厂模式
try {
//获取javax.xml.parsers.SAXParserFactory类的一个实例
SAXParserFactory parserFactory = SAXParserFactory.newInstance();
parserFactory.setValidating(false);
parserFactory.setNamespaceAware(false);
//创建一个javax.xml.parsers.SAXParser对象
SAXParser parser = parserFactory.newSAXParser();
//实例当前类
Covert covert = new Covert();
//解析路径为uri的XML文件
parser.parse(uri, covert);
} catch (IOException exception) {
exception.printStackTrace();
} catch (SAXException exception) {
exception.printStackTrace();
} catch (ParserConfigurationException exception) {
exception.printStackTrace();
} catch (FactoryConfigurationError exception) {
exception.printStackTrace();
}
}
/**
* @todo Implement method "characters"
* 以字符形式输出元素值，且判断是否为'换行符'
*/
public void characters(char[] ch, int start, int length) throws SAXException {
String str=new String(ch,start,length);
if( !str.startsWith("\n")){
System.out.println("值："+str+"");
}
}

/**
* @todo Implement method "endDocument"
*/
public void endDocument() throws SAXException {
System.out.println("解析XML文档结束");
}

/**
* @todo Implement method "endElement"
*/
public void endElement(String url, String localName, String qName) throws SAXException {
System.out.println(qName+"元素解析结束\n");
}

/**
* @todo Implement method "startDocument"
*/
public void startDocument() throws SAXException {
System.out.println("解析XML文档开始:\n");
}

/**
* @todo Implement method "startElement"
*/
public void startElement(String uri, String localName, String qName,Attributes attributes)
throws SAXException {
System.out.println(qName+"元素解析开始");
}
}

❻ Java怎么解析相同XML节点求大神指导一下。

packagecom.sun;

importjava.io.File;
importjava.util.List;

importorg.dom4j.Document;
importorg.dom4j.DocumentException;
importorg.dom4j.Element;
importorg.dom4j.io.SAXReader;

publicclassDom4jTest{

	publicvoidfun(){
		Filefile=newFile("d:\toRead.xml");
		//用SAXReader来加载xml文件
		SAXReadersaxReader=newSAXReader();
		//获取xml文件的Document对象
		Documentdocument=saxReader.read(file);
		//获得Document对象的根节点，就是UFIDA-FAHON-WebService节点
		ElementrootElement=document.getRootElement();
		//list里面装的就是你的xml文件根节点的所有子节点，就是所有的U8ArrivalVouch节点
		List<Element>list=rootElement.elements();
		//增强for循环来遍历所有的U8ArrivalVouch节点
		for(Elementelement:list){
			//待处理内容，可以继续用elements()方法继续获得所有的子节点
			;
		}
		
		
		
	}

}
//你的xml文件的最后应该是</UFIDA-FAHON-WebService>才对，这才符合xml规范
<UFIDA-FAHON-WebService>

......

</UFIDA-FAHON-WebService>

❼ 通过java如何操作xml向其节点中添加内容比如<say>想添加的内容</say>

<say>我是个字符串可以随便填</say>
你是要代码吗
InputStream is= this.getClass.getInputStream("my.xml");
在通过 is获得内容我就说他是 String xml=is....
String str="想添加的内容";
String newxml=xml.replace("我是个字符串可以随便填",str);

❽ java如何获取XML中子节点的内容

java中获取xml节点元素值 根据不同的处理xml方式不同而不同。
java中解析xml的方式：大体可以使用以下四种
------------------------------------------------------------
DOM(Document Object Model)
为 XML 文档的已解析版本定义了一组接口。解析器读入整个文档，
然后构建一个驻留内存的树结构，然后代码就可以使用 DOM 接口来操作这个树结构。
优点：整个文档树在内存中，便于操作；支持删除、修改、重新排列等多种功能；
缺点：将整个文档调入内存（包括无用的节点），浪费时间和空间；
使用场合：一旦解析了文档还需多次访问这些数据；硬件资源充足（内存、CPU）

SAX(Simple API for XML)
为解决DOM的问题，出现了SAX。SAX ，事件驱动。
当解析器发现元素开始、元素结束、文本、文档的开始或结束等时，发送事件，
程序员编写响应这些事件的代码，保存数据。优点：不用事先调入整个文档，占用资源少；
SAX解析器代码比DOM解析器代码小，适于Applet，下载。
缺点：不是持久的；事件过后，若没保存数据，那么数据就丢了；无状态性；
从事件中只能得到文本，但不知该文本属于哪个元素；
使用场合：Applet;只需XML文档的少量内容，很少回头访问；机器内存少；

DOM4J
DOM4J 是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，
同时它也是一个开放源代码的软件。如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML，
特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J

JDOM
为减少DOM、SAX的编码量，出现了JDOM；优点：20-80原则，极大减少了代码量。
使用场合：要实现的功能简单，如解析、创建等，但在底层，JDOM还是使用SAX（最常用）、DOM、Xanan文档。
------------------------------
参考代码
dom4j
------------------------------
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
---------------------------------------------
File f = new File("students.xml");
SAXReader reader = new SAXReader();
Document doc = reader.read(f);
Element root = doc.getRootElement();

for (Iterator iter = root.elementIterator(); iter.hasNext();) {
Element element = (Element) iter.next();
// System.out.println(element.attributeValue("email"));

String ids=element.elementText("stuId");
System.out.println(ids);
String names=element.elementText("stuName");
System.out.println(names);
String ages=element.elementText("age");
System.out.println(ages);
}
------------------------------------
dom 方式
---------------
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
------------------------

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
// 允许名字空间
// factory.setNamespaceAware(true);
// 允许验证
// factory.setValidating(true);
// 获得DocumentBuilder的一个实例

DocumentBuilder builder = null;
try {
builder = factory.newDocumentBuilder();
} catch (ParserConfigurationException pce) {
System.err.println(pce);
// 出异常时输出异常信息，然后退出，下同
System.exit(1);
}

Document doc = null;
// 解析文档，并获得一个Document实例。

try {
try {
// InputStream is=new FileInputStream("students.xml");
doc = builder.parse("students.xml");
// doc = builder.parse(is);

} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (DOMException dom) {
System.err.println(dom.getMessage());
System.exit(1);
} catch (IOException ioe) {
System.err.println(ioe);
// System.exit(1);
}
for (int i = 0; i < nlStudent.getLength(); i++) {

Element elmtStudent = (Element) nlStudent.item(i);
String email = elmtStudent.getAttribute("email");
System.out.println(email);

NodeList ids = elmtStudent.getElementsByTagName("stuId");
Element id = (Element)ids.item(0);
Node tId = id.getFirstChild();
System.out.println(tId.getNodeValue());

NodeList names = elmtStudent.getElementsByTagName("stuName");
Element e = (Element)names.item(0);
Node tName = e.getFirstChild();
System.out.println(tName.getNodeValue());
}