Question

用java实现 xml文件转实体类

各位大侠，小弟现在有个项目，需要读取xml文件内容，格式大体如下：
<Response><Method><Name>load</Name><Time>2010</Time></Method><Code>001</Code><Name>anding</Name></Response>

这种xml文件对应一系列的java类，所展现的是一个实体的值，请问如何一个通用方法得到这个xml对应的值！
请求相关代码！

Answer 1

使用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();
}
}

Answer 2

嗯，就是XML的文件marshall成JAVA类咯？用JAXB吧，不过你得有这个XML的XSD，DTD之类的，看你用哪个版本，推荐2.0以上。

如果手上没有XML的schema么，那你用JDOM好了，但貌似不能直接生成类，怎么办？读出来放到你自己的类里面....

Answer 3

读取xml文件，可以用dom4j，现在很流行，很多框架都使用它。
上面的文件格式，<Response><Name>anding</Name></Response>这一段应该是类的名字吧，还应该加上包名吧，这样读取这个节点，然后通过反射获得这个类，再把其他节点的信息添加到这个类中就行了。
比如，这个类的名字是anding，这些写就是他没有包名，
Class.forName("anding").newInstance();//得到该类名的类实例，需要强制转换.
方法、构造函数都是可以通过反射创建的。

Answer 4

这个问题很常见
就是java解析xml的问题，应用很多
解析主要有2种模式
1、DOM解析，这里里面包括JDOM，DOM4J等等，解析的思想类似，化为一类，这类解析思路清晰明白，元素读取直观，缺点是对大型xml文件解析会发生内存溢出错误，因为这类解析占用内存较高
2、SAX解析，此解析方法的思想是把xml看成文本读取入内存，然后以为事件触发模式检索元素信息，所以解析占用内存不高，适合大xml文档的解析

具体解析楼主随便找个例子看看就会了，比较简单

Answer 5

package com.wds.excelxml;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.NumberFormat;
import java.text.ParseException;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFDataFormat;
import org.apache.poi.hssf.usermodel.HSSFDataFormatter;
import org.apache.poi.hssf.usermodel.HSSFHyperlink;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;

import nu.xom.Attribute;
import nu.xom.Document;
import nu.xom.Element;
import nu.xom.Elements;
import nu.xom.Serializer;
public class Excelxml {

public static void main(String[] args) {
excelxml();
}

/**
* 从Excel到xml
* 从xml到Excel
*/
private static void excelxml(){
/*
* 首先创建一个xml文档
* 要创建xml文档，首先创建一个根元素
*/
Element reportRoot=new Element("sheet");
Document xmlReport=new Document(reportRoot);

try {
//读取Excel文件
FileInputStream excelFIS=new FileInputStream("D:\\JavaTest\\Employee_List.xls");
//创建Excel工作表
HSSFWorkbook excelWB=new HSSFWorkbook(excelFIS);
//获得Excel工作簿
HSSFSheet excelSheet=excelWB.getSheetAt(0);
//获得工作簿的行数
int rows=excelSheet.getPhysicalNumberOfRows();
//遍历工作簿的行
for(int rowIndex=0; rowIndex<rows;rowIndex++){
HSSFRow oneRow=excelSheet.getRow(rowIndex);
if(oneRow==null){
continue;
}
//在迭代每一行的时候，创建xml的行元素
Element rowElement=new Element("row");
//获得当前行的单元格数
int cells=oneRow.getPhysicalNumberOfCells();
//遍历行中的每一个单元格
for(int cellIndex=0;cellIndex<cells;cellIndex++){
HSSFCell oneCell=oneRow.getCell(cellIndex);
if(oneCell==null){
continue;
}
//设置元素的默认名称
String elementName="header";
//获得单元格所在列位置
int cellColumnIndex=oneCell.getColumnIndex();
if(rowIndex>0){
elementName=reportRoot.getFirstChildElement("row").getChild(cellColumnIndex).getValue();
}
/*
* 去掉非法字符
*/
elementName = elementName.replaceAll("[\\P{ascii}]","");
elementName = elementName.replaceAll(" ", "");

Element cellElement = new Element(elementName);
//添加属性和元素
//String attributeValue=oneCell.getCellStyle().getDataFormatString();
//Attribute dataFormatAttribute=new Attribute("dataFormat", attributeValue);
//cellElement.addAttribute(dataFormatAttribute);

/*
* 根据不同的属性添加
*/
Attribute strTypeAttribute=null;
switch (oneCell.getCellType()) {
case HSSFCell.CELL_TYPE_STRING:
strTypeAttribute=new Attribute("dataType","String");
cellElement.addAttribute(strTypeAttribute);
cellElement.appendChild(oneCell.getStringCellValue());
rowElement.appendChild(cellElement);
break;
case HSSFCell.CELL_TYPE_NUMERIC:
strTypeAttribute=new Attribute("dataType","Numeric");
cellElement.addAttribute(strTypeAttribute);
HSSFDataFormatter dataFormatter=new HSSFDataFormatter();
String cellFormatted=dataFormatter.formatCellValue(oneCell);
cellElement.appendChild(cellFormatted);
rowElement.appendChild(cellElement);
break;
}
}
if(rowElement.getChildCount()>0){
reportRoot.appendChild(rowElement);
}
//System.out.println(xmlReport.toXML());
}