xml生成java
Ⅰ 如何用java生成一个xml文件
一个XML文档，可以先构造一个DOM，然后将DOM转化为xml序列，输出或者生成文件。package test;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
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.Element;
public class Test {
public static void generate(){
try {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.newDocument();
document.setXmlVersion("1.0");
document.setXmlStandalone(true);
Element root = document.createElement_x("MobileNet"); //创建根节点
document.appendChild(root); //将根节点添加到Document对象中
Element pageElement = document.createElement_x("page"); //设置第一个page元素到
pageElement.setAttribute("name", "list.jsp"); //设置page节点的name属性
Element methodElement = document.createElement_x("method"); //设置method节点
methodElement.setTextContent("get"); //给method设置值
pageElement.appendChild(methodElement); //添加method节点到page节点内
Element displayElement = document.createElement_x("display"); //设置method节点
displayElement.setTextContent("list撒旦发放"); //给display设置值
pageElement.appendChild(displayElement); //添加display节点到page节点内
Element request_paramElement = document.createElement_x("request_param");
request_paramElement.setTextContent("request_param1|request_param2");
pageElement.appendChild(request_paramElement);
root.appendChild(pageElement);
pageElement = document.createElement_x("page"); //设置第二个page元素到
pageElement.setAttribute("name", "content.jsp"); //设置page节点的name属性
methodElement = document.createElement_x("method");
methodElement.setTextContent("post");
pageElement.appendChild(methodElement);
displayElement = document.createElement_x("display");
displayElement.setTextContent("content");
pageElement.appendChild(displayElement);
Element url_titleElement = document.createElement_x("url_title"); //设置url_title节点
url_titleElement.setTextContent("title,publisher,published_calendar"); //给url_title设置值
pageElement.appendChild(url_titleElement); //添加url_title节点到page节点内
root.appendChild(pageElement); //将page段加人根节点内
TransformerFactory transFactory = TransformerFactory.newInstance(); //开始把Document映射到文件
Transformer transFormer = transFactory.newTransformer();
DOMSource domSource = new DOMSource(document); //设置输出结果
File file = new File("MobileNetRule.xml"); //生成xml文件
if (!file.exists()) {
file.createNewFile();
}
FileOutputStream out = new FileOutputStream(file); //文件输出流
StreamResult xmlResult = new StreamResult(out); //设置输入源
transFormer.transform(domSource, xmlResult); //输出xml文件
System.out.println(file.getAbsolutePath()); //测试文件输出的路径
TransformerFactory tf = TransformerFactory.newInstance();
Transformer t = tf.newTransformer();
t.setOutputProperty("{/encoding/}","GB2312/");
ByteArrayOutputStream boc = new ByteArrayOutputStream();
t.transform(new DOMSource(document), new StreamResult(boc));
String xmlstring = boc.toString();
System.out.println(xmlstring);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args){
Test.generate();
}
}
Ⅱ JAVA 生成xml格式，具体格式如下，请问JAVA方法怎么写
importjava.io.File;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
importorg.w3c.dom.*;
importorg.xml.sax.SAXException;
importjavax.xml.parsers.*;
importjavax.xml.transform.*;
importjavax.xml.transform.dom.DOMSource;
importjavax.xml.transform.stream.*;
importjavax.xml.xpath.*;
publicclassTest{
publicstaticvoidmain(String[]args){
DocumentBuilderFactoryfactory=DocumentBuilderFactory.newInstance();
ElementtheBook=null,theElem=null,root=null;
try{
factory.(true);
DocumentBuilderdb=factory.newDocumentBuilder();
Documentxmldoc=db.parse(newFile("Test1.xml"));
root=xmldoc.getDocumentElement();
theBook=(Element)selectSingleNode("/books/book[name='哈里波特']",root);
System.out.println("---查询找《哈里波特》----");
ElementnameNode=(Element)theBook.getElementsByTagName("price").item(0);
Stringname=nameNode.getFirstChild().getNodeValue();
System.out.println(name);
output(theBook);
System.out.println("=============selectSingleNode(books/book[name='哈里波特'],root)==================");
//---新建一本书开始----
theBook=xmldoc.createElement("book");
theElem=xmldoc.createElement("name");
theElem.setTextContent("新书");
theBook.appendChild(theElem);
theElem=xmldoc.createElement("price");
theElem.setTextContent("20");
theBook.appendChild(theElem);
theElem=xmldoc.createElement("memo");
theElem.setTextContent("新书的更好看。");
theBook.appendChild(theElem);
root.appendChild(theBook);
System.out.println("---新建一本书开始----");
output(xmldoc);
System.out.println("==============================");
//---新建一本书完成----
//---下面对《哈里波特》做一些修改。----
//---查询找《哈里波特》----
//---此时修改这本书的价格-----
theBook.getElementsByTagName("price").item(0).setTextContent("15");//getElementsByTagName返回的是NodeList，所以要跟上item(0)。另外，getElementsByTagName("price")相当于xpath的".//price"。
System.out.println("---此时修改这本书的价格----");
output(theBook);
//---另外还想加一个属性id，值为B01----
theBook.setAttribute("id","B01");
System.out.println("---另外还想加一个属性id，值为B01----");
output(theBook);
//---对《哈里波特》修改完成。----
//---要用id属性删除《三国演义》这本书----
theBook=(Element)selectSingleNode("/books/book[@id='B02']",root);
System.out.println("---要用id属性删除《三国演义》这本书----");
output(theBook);
theBook.getParentNode().removeChild(theBook);
System.out.println("---删除后的XML----");
output(xmldoc);
//---再将所有价格低于10的书删除----
NodeListsomeBooks=selectNodes("/books/book[price<10]",root);
System.out.println("---再将所有价格低于10的书删除---");
System.out.println("---符合条件的书有"+someBooks.getLength()+"本。---");
for(inti=0;i<someBooks.getLength();i++){
someBooks.item(i).getParentNode().removeChild(someBooks.item(i));
}
output(xmldoc);
saveXml("Test1_Edited.xml",xmldoc);
}catch(ParserConfigurationExceptione){
e.printStackTrace();
}catch(SAXExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}
}
publicstaticvoidoutput(Nodenode){//将node的XML字符串输出到控制台
=TransformerFactory.newInstance();
try{
Transformertransformer=transFactory.newTransformer();
transformer.setOutputProperty("encoding","gb2312");
transformer.setOutputProperty("indent","yes");
DOMSourcesource=newDOMSource();
source.setNode(node);
StreamResultresult=newStreamResult();
result.setOutputStream(System.out);
transformer.transform(source,result);
}catch(){
e.printStackTrace();
}catch(TransformerExceptione){
e.printStackTrace();
}
}
(Stringexpress,Objectsource){//查找节点，并返回第一个符合条件节点
Noderesult=null;
XPathFactoryxpathFactory=XPathFactory.newInstance();
XPathxpath=xpathFactory.newXPath();
try{
result=(Node)xpath.evaluate(express,source,XPathConstants.NODE);
}catch(XPathExpressionExceptione){
e.printStackTrace();
}
returnresult;
}
(Stringexpress,Objectsource){//查找节点，返回符合条件的节点集。
NodeListresult=null;
XPathFactoryxpathFactory=XPathFactory.newInstance();
XPathxpath=xpathFactory.newXPath();
try{
result=(NodeList)xpath.evaluate(express,source,XPathConstants.NODESET);
}catch(XPathExpressionExceptione){
e.printStackTrace();
}
returnresult;
}
publicstaticvoidsaveXml(StringfileName,Documentdoc){//将Document输出到文件
=TransformerFactory.newInstance();
try{
Transformertransformer=transFactory.newTransformer();
transformer.setOutputProperty("indent","yes");
DOMSourcesource=newDOMSource();
source.setNode(doc);
StreamResultresult=newStreamResult();
result.setOutputStream(newFileOutputStream(fileName));
transformer.transform(source,result);
}catch(){
e.printStackTrace();
}catch(TransformerExceptione){
e.printStackTrace();
}catch(FileNotFoundExceptione){
e.printStackTrace();
}
}
}
XML：
<?xmlversion="1.0"encoding="GBK"?>
<books>
<book>
<name>哈里波特</name>
<price>10</price>
<memo>这是一本很好看的书。</memo>
</book>
<bookid="B02">
<name>三国演义</name>
<price>10</price>
<memo>四大名着之一。</memo>
</book>
<bookid="B03">
<name>水浒</name>
<price>6</price>
<memo>四大名着之一。</memo>
</book>
<bookid="B04">
<name>红楼</name>
<price>5</price>
<memo>四大名着之一。</memo>
</book>
</books>
Ⅲ 100分求高手帮我将xml文件转为java类
奋斗了20个小时，终于完成了，本类无需导入任何额外的包，底层细节全部在本类中完成！
说明，本类通过读入xml文件，并把信息正确分成存入到Guird列表中。通过调用getGuirdList()将返回结果集。要使用其中的某一项，只接到对象中用方法获取即可，希望能够满足楼主的需求！！
TransXml.java
import java.io.*;
import java.util.Vector;
import java.util.Scanner;
import java.io.InputStreamReader;
import java.util.LinkedList;
public class TransXml{
private String xmlAddress;
private Vector<Guird> guir;//表示一级子目录下的Guird向量
private FileInputStream inStr;
private InputStreamReader inRea;
private int whLayer=0;//标志表的层次，为0表示根表，为1表示第一层子表
private int whiLab=0;//表示当前标签是第几层
boolean isend=false;
boolean isguirs=false;
boolean isguir=false;
StringBuffer str=new StringBuffer();//表示<>中的词
String strVul;
StringBuffer value=new StringBuffer();//表示具体类容
boolean isWorld=false;
boolean isValue=false;
boolean isSubgu=false;
boolean notEnd=true;
LinkedList<Guird> linList;
public TransXml(){
}
public TransXml(String xmlAdd){
guir=new Vector<Guird>();
linList=new LinkedList<Guird>();
this.xmlAddress=xmlAdd;
System.out.println("开始读取xml文件");
try{
inStr=new FileInputStream(xmlAddress);
inRea=new InputStreamReader(inStr);
}catch(IOException e){
System.out.println("Xml文件地址无效");
}
System.out.println("开始读取xml文件完成！");
Translate();
}
public void Translate(){
Guird theGu=new Guird();
while(notEnd)
{
int tt=-1;
try{
tt=inRea.read();
}catch(IOException e){
System.out.println("字符读取失败！");
}
if(tt==-1){//文件已经读完了
notEnd=false;
break;
}
char ch=(char)tt;
if(ch=='<'){
//说明，前面如果有类容的话，内容完结
isValue=false;//说明内容已经完了
isWorld=true;//表示下面是<>里德内容
}
if(ch=='>'){
isWorld=false;//表示括号内的字符串结束了
strVul=str.toString();//表示当前的目录层次
if(strVul.equalsIgnoreCase("guirds")){//这是配置文件正式开始的标志
isguirs=true;
}else if(strVul.equalsIgnoreCase("guird")){//说明已经进入guird类
isguir=true;
}else if(strVul.equalsIgnoreCase("id")){//进入id属性
isValue=true;
}else if(strVul.equalsIgnoreCase("name")){//进入name属性
isValue=true;
}else if(strVul.equalsIgnoreCase("ename")){//进入ename属性
isValue=true;
}else if(strVul.equalsIgnoreCase("parentid")){//进入parentid属性
isValue=true;
}else if(strVul.equalsIgnoreCase("subguirds")){//进入subguirds属性,说明它还有一个字表
isSubgu=true;
linList.addLast(theGu);//做入栈操作,添加到结尾
whLayer++;//原始的值为0，它表示当前操作guird的级数
//那么下面的读取将是新的Guird类，所以要把现在的theGu保存后重新初始化
theGu=new Guird();//初始化，后面接着用
}else if(strVul.equalsIgnoreCase("/guirds")){//这是配置文件结束的标志
isguirs=false;//程序已经阅读完毕XML文件
notEnd=false;
}else if(strVul.equalsIgnoreCase("/guird")){//说明已经结束guird类
isguir=false;//说明一条记录已经完成，所以要对其存储
//theGu的属性是在</标签>前就写入完毕了,那么应该写入上级目录中，
//如果是定定及目录，则直接写入给定的Vector
if(whLayer>0){//说明还不是根目录
Guird tempguir=linList.getLast();
Vector<Guird> tempqq=(Vector)tempguir.getSubGuird();
if(tempqq==null){//说明前面的集合为空
tempqq=new Vector();
}
tempqq.add(theGu);//集合中增加这一项
tempguir.setSubGuird(tempqq);
linList.removeLast();//移动原来的换新的内容
linList.add(tempguir);
theGu=new Guird();//重新初始化供后面使用，并不要去改变whLayer值
}else if(whLayer==0){//这说明当前的theGu是指1级子目录，
guir.add(theGu);//添加一条记录到Vector
theGu=new Guird();// 重新初始化以便下次正确用到
}else{
System.out.println("xml文件标签错误！");
notEnd=false;
}
}else if(strVul.equalsIgnoreCase("/id")){//结束id属性
isValue=false;
theGu.setId(new Integer(value.toString()));
value=new StringBuffer();
}else if(strVul.equalsIgnoreCase("/name")){//结束name属性
isValue=false;
theGu.setName(value.toString());
// System.out.println("这里写入的名字是："+theGu.getName());
value=new StringBuffer();
}else if(strVul.equalsIgnoreCase("/ename")){//结束ename属性
isValue=false;
theGu.setEname(value.toString());
value=new StringBuffer();
}else if(strVul.equalsIgnoreCase("/parentid")){//结束parentid属性
isValue=false;
theGu.setParentId(new Integer(value.toString()));
value=new StringBuffer();
}else if(strVul.equalsIgnoreCase("/subguirds")){//结束subguirds属性,字表完成
isSubgu=false;
//刚刚结束的这个Guird就是whLayer级子目录
//要判断是根类还是那一级子目录
whLayer--;//表示上一级目录
if(whLayer>0){
theGu=linList.getLast();//成为当前节点
//所以当前操作对象又将是刚从LinkedListed中取出的那个
linList.removeLast();//已经用过了，最后一个移除，相当于退栈
}
else if(whLayer==0){//根节点下
theGu=linList.getLast();
linList.removeLast();
}else{
notEnd=false;//因为whLayer不可能小于0
System.out.println(xmlAddress+"标签不完整！请检查！");
break;
}
}
strVul="";
str=new StringBuffer();//重新初始化，准备后面使用
}
if(isWorld==true){
if((char)tt!='<'&&(char)tt!='>')//因为具有延时性所以要增加这个条件
if(tt!=32&&tt!=9)//它不为空格和Tab,即在xml中标签内的内容将忽略Tab和空格
str.append((char)tt);
}
if(isValue==true){//当前是类容属性值
if((char)tt!='<'&&(char)tt!='>'){
if(tt!=32&&tt!=9)//它不为空格和Tab
value.append((char)tt);
}
}
/**
* 为什么这里注释掉了，因为前面以当发现value值取到最后一位后就设置isValue为false
* 但是要当下一个</>结尾标签完才会调用value值并进行操作，所以，value不能立刻变为空内容
* 那么当它被使用后，采设置新的对象是可取的
* else{
* value=new StringBuffer();//避免干扰下次
* }
*/
}
try{
inRea.close();
inStr.close();
}catch(IOException e){
System.out.println("流关闭失败！");
}
}
public Vector getGuirdList(){
return this.guir;//获得最终的子目录列表
}
/**
* 原来写的main方法进行测试，在这里就省略了
*/
}
Xml文件中<guirds>标签中，有几对<guird>标签就会返回几条结果，当然<guird>是指在<guirds>目录下的第一层标签，而其他的二级<guird>标签中的内容则存在相应的List<Guird> subGuird中。
That's all !
Ⅳ 如何根据xml和schema文件生成java类（用程序实现）！
验证应该好写吧，主要是解析xml
可以使用工具包dom4j
类似例子
dom4j参见http://javacrazyer.iteye.com/blog/727298
publicstaticvoidreadXML()throwsDocumentException{
SAXReadersr=newSAXReader();//获取读取xml的对象。
Documentdoc=sr.read("src/com/pzr/test//test.xml");//得到xml所在位置。然后开始读取。并将数据放入doc中
Elementel_root=doc.getRootElement();//向外取数据，获取xml的根节点。
Iteratorit=el_root.elementIterator();//从根节点下依次遍历，获取根节点下所有子节点
while(it.hasNext()){//遍历该子节点
Objecto=it.next();//再获取该子节点下的子节点
Elementel_row=(Element)o;
Strings=el_row.getText();
Iteratorit_row=el_row.elementIterator();
while(it_row.hasNext()){//遍历节点
Elementel_ename=(Element)it_row.next();//获取该节点下的所有数据。
System.out.println(el_ename.getText());
}
}
}
Ⅳ 怎样将xml文件生成java代码
xml是有格式的文件，到底里面保存了什么数据，得知道，才能办法处理
Ⅵ java 生成xml文件
我这有一段代码，你应该能用上
fso = new ActiveXObject("Scripting.FileSystemObject");
tf = fso.CreateTextFile("保存路径", true);
tf.WriteLine(xml串内容);
tf.Close();
Ⅶ 如何把xml内容转换为java格式
使用XStream完成 java 类与 XML 互换。
下面代码实现了以下4种基本功能：
1. object类型转换为xml类型，在控制台打印
2. xml类型转换为object类型，在控制台打印
3. 将object类型转换为xml类型，并写入XML文件
4. 读取XML文件，加载进相应Object类型
====================================================
1。加载 XStream 需要的jar包 xstream-1.4.2.jar
xpp3_min-1.1.4c.jar
xmlpull-1.1.3.1.jar
2。创建实体类User.java
package com.entity;
/**
* 实体类
*/
public class User {
private String userName;
private String passWord;
private String registeredTime;
public User() { }
public User(String userName, String passWord, String registeredTime) {
this.userName = userName;
this.passWord = passWord;
this.registeredTime = registeredTime;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassWord() {
return passWord;
}
public void setPassWord(String passWord) {
this.passWord = passWord;
}
public String getRegisteredTime() {
return registeredTime;
}
public void setRegisteredTime(String registeredTime) {
this.registeredTime = registeredTime;
}
}
3。编写功能实现类
package com.switcher;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import com.entity.User;
import com.thoughtworks.xstream.XStream;
/**
*
* 使用 XStream不用任何映射就能实现多数 Java 对象的序列化。
* 在生成的 XML中对象名变成了元素名，类中的字符串组成了 XML中的元素内容。
* 使用 XStream 序列化的类不需要实现 Serializable 接口。
* XStream 是一种序列化工具而不是数据绑定工具
* 不能从XML 或者 XML Schema Definition (XSD) 文件生成类。
*/
public class SwitchXML {
/*
* XStream 不关心序列化/逆序列化的类的字段的可见性。
* 序列化/逆序列化类的字段不需要 getter 和 setter 方法。
* 序列化/逆序列化的类不需要有默认构造函数。
*/
private XStream xStream = new XStream();
private String xmlPath = "D:/userdata.xml";
// 1. obj -> xml(object类型转换为xml类型)
public String printXML(User user) {
System.out.println("obj -> xml");
String xml = xStream.toXML(user);
System.out.println(xml);
return xml;
}
// 2. xml->obj(xml类型转换为object类型，并打印)
public void printObj(String xml) {
System.out.println("xml -> obj");
User u = (User) xStream.fromXML(xml);
System.out.println(u.getUserName() + " " + u.getPassWord() + " " + u.getRegisteredTime());
}
// 3. 将object类型转换为xml类型，并写入XML文件(其他格式也可以，比如txt文件)
public void writerXML(User user) {
try {
FileOutputStream fs = new FileOutputStream(xmlPath);
xStream.toXML(user, fs);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
// 4. 读取XML文件，加载进相应Object类型
public void readerXML() {
User user = new User();
FileInputStream fis = null;
try {
fis = new FileInputStream(xmlPath);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
xStream.fromXML(fis, user);
// 打印对象信息
System.out.println(user.toString());
// 打印对象的属性值
System.out.println(user.getUserName() + "-" + user.getPassWord() + "-"
+ user.getRegisteredTime());
}
public static void main(String[] args) {
// 用户名
String username = "admin";
// 密码
String password = "admin";
// 注册时间
Date now = new Date();
SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss");
String registeredtime = format.format(now);
User user = new User(username, password, registeredtime);
SwitchXML switchXML = new SwitchXML();
// 1. object类型转换为xml类型，在控制台打印
String xml = switchXML.printXML(user);
System.out.println("---------------------");
// 2. xml类型转换为object类型，在控制台打印
switchXML.printObj(xml);
System.out.println("---------------------");
// 3. 将object类型转换为xml类型，并写入XML文件
switchXML.writerXML(user);
System.out.println("---------------------");
// 4. 读取XML文件，加载进相应Object类型
switchXML.readerXML();
}
}
Ⅷ java 生成xml文件怎么有格式
需要jdom.jar和dom4j.jar这两个包
/**
* 将crash信息打包成xml格式
* @param hashMap 原始crash信息的hashmap形式
* @throws IOException
* @throws JDOMException
*/
public void BuildXMLDoc(HashMap<String, String> hashMap) throws IOException, JDOMException {
int size = hashMap.size();
Iterator iter = hashMap.entrySet().iterator();
Map.Entry entry;
String key;
String val;
int id = 1;
// 创建根节点 list;
Element root = new Element("phoneInfo");
// 根节点添加到文档中；
Document Doc = new Document(root);
// 此处 迭代器的遍历 可替换成循环遍历 数据库表的结果集操作;
while (iter.hasNext()) {
entry = (Map.Entry)iter.next();
key = (String)entry.getKey();
val = hashMap.get(key);
if (val == null || val.length() == 0)
{
val = "null";
}
// 创建节点 user;
Element elements = new Element("category");
// 给 user 节点添加属性 id;
elements.setAttribute("id", "" + id);
id ++;
// 给 user 节点添加子节点并赋值；
// new Element("name")中的 "name" 替换成表中相应字段，setText("xuehui")中 "xuehui
// 替换成表中记录值；
elements.addContent(new Element(key).setText(val));
// 给父节点list添加user子节点;
root.addContent(elements);
}
//带有缩进格式的xml 更美观
Format format = Format.getPrettyFormat();
XMLOutputter XMLOut = new XMLOutputter(format);
XMLOut.output(Doc, new FileOutputStream(FileUtil.CRASHPATH));
System.out.println("完成了文件写入");
}
上面虽然是对hashmap的遍历，但是对于其他容器的遍历形式不变，只是换成你需要的信息即可
下面是其他文章找到的
生成XML的时候，处理特殊字符
element.addContent(new CDATA("<xml> content"));
生成XML的时候，设置编码
XMLOutputter XMLOut = new XMLOutputter();
XMLOut.setEncoding("gb2312");
XMLOut.output(Doc, new FileOutputStream("test1.xml"));
Ⅸ XML转JAVA对象
你在网上下载一个java的xml文件处理包，然后再查“java解析xml”就会有很多的例程，xml的解析器有很多，都是把XML解析成DOM树形结构，直接读取属性值，非常简单的。然后你建立一个类，构建对象把这个属性赋值给对象属性。