XStream互转String和XML，以及如何读取web的下的文件

在项目开发中有时要传输xm文件，要转换成字符串传输，而无法使用对象传输，所以要进行转换，所用进行总结下利用XStream进行string与XML对象之间的互转，以及在转换某一包下所有的类。

XML文件的解析和创建，请参考：http://blog.csdn.net/oyyz111/article/details/22730983

首先，利用Spring的PathMatchingResourcePatternResolver进行某包下的class文件的读取，其中用ant的匹配模式,例如congfig/**/*.class,是匹配config文件下一个目录或多个目录下的class文件，config/a/a.class或者config/a/b/b.class

代码如下：

import java.io.File;
import java.io.IOException;
import java.util.LinkedHashSet;
import java.util.Set;

import org.apache.log4j.Logger;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;

public class AchieveFileUtils {
   private static Logger logger = Logger.getLogger(AchieveFileUtils.class);
   
   /**
    * 获取某包下所有类的实例
    * @param packagePath 包名
    * @return class集合
    */
 public static Set> getClasses(String packagePath){
 Set> classes = new LinkedHashSet>();
 String packageClassPath = packagePath.replace(".", "/")+"/**/*.class" ;
ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
try {
Resource[] resources = resolver.getResources("classpath*:"+packageClassPath);
for(int i = 0;i Resource resource = resources[i];
String completeFilePath = resource.getFile().getPath().replace(File.separator, "/");
logger.info("completeFilePath:"+completeFilePath);
String className =  completeFilePath.substring(completeFilePath.lastIndexOf(packagePath.replace(".", "/")), completeFilePath.length()-6);
try {
classes.add(Class.forName(className.replace("/", ".")));
} catch (ClassNotFoundException e) {
logger.error("没有加载到此类");
logger.error(e.getMessage(), e.getCause());
}
logger.info("className:"+className);
}
} catch (IOException e) {
logger.error(e.getMessage(), e.getCause());
}
 return classes; 
 }

}

XStream转换XML为对象，是需要对象的class的，所以前者获取class文件为后面的转换做铺垫

要转换的对象实例，User.java

@XStreamAlias("User") 表示别名

@XStreamAsAttribute 表示作为属性

import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.annotations.XStreamAsAttribute;


@XStreamAlias("User")
public class User {
@XStreamAsAttribute
@XStreamAlias("ID")
private int id;
@XStreamAlias("Name")
@XStreamAsAttribute
private String name;
@XStreamAlias("PassWord")
@XStreamAsAttribute
private String password;


public int getId() {
return id;
}


public void setId(int id) {
this.id = id;
}


public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}


public String getPassword() {
return password;
}


public void setPassword(String password) {
this.password = password;
}


}

private XStream xstream = new XStream(new XppDriver(newXmlFriendlyNameCoder("_-", "_")));

如果没有new XppDriver(new XmlFriendlyNameCoder("_-", "_")),，

别名取的是@XStreamAlias("ID_"),就被解析成@XStreamAlias("ID__")

xstream.processAnnotations(clazz);将要转换的class进行扫描

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.util.Set;

import org.apache.log4j.Logger;



import com.frame.model.User;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.io.xml.XmlFriendlyNameCoder;
import com.thoughtworks.xstream.io.xml.XppDriver;

public class XStreamUtils {
private static Logger logger = Logger.getLogger(XStreamUtils.class);
private XStream xstream = new XStream(new XppDriver(
new XmlFriendlyNameCoder("_-", "_")));
public static XStreamUtils xStreamUtils = null;

/**
 * 获取唯一的实例对象，通过双层锁
 * @param packagePath 包名
 * @return XStreamUtils对象
 */
public static XStreamUtils getInstance(String packagePath) {
if (xStreamUtils == null) {
synchronized (XStreamUtils.class) {
if (xStreamUtils == null) {
xStreamUtils = new XStreamUtils(packagePath);
}
}
}
return xStreamUtils;
}

/**
 *  获取唯一的实例对象，通过双层锁
 * @return XStreamUtils对象
 */
public static XStreamUtils getInstance(){
if(xStreamUtils == null){
synchronized (XStreamUtils.class) {
if(xStreamUtils == null)
xStreamUtils = new XStreamUtils();
}
}
return xStreamUtils;
}

/**
 * XStreamUtils 构造方法
 * @param packagePath
 */
private XStreamUtils(String packagePath) {
this.initXStream(packagePath);
}
/**
 * 无参数构造
 * XStreamUtils 构造方法
 */
private XStreamUtils() {

}

/**
 * 根据传入的包名，将包下所有标有XStreamAlias注解的类进行扫描
 * @param packagePath 包名
　
 */
private void initXStream(String packagePath) {
xstream.autodetectAnnotations(true);
Set> classes = AchieveFileUtils.getClasses(packagePath);
for (Class clazz : classes) {
Annotation annotation = clazz.getAnnotation(XStreamAlias.class);
if (annotation != null) {
xstream.processAnnotations(clazz);
} else {
for (Field field : clazz.getFields()) {
Annotation annotatiOnFiled= field
.getAnnotation(XStreamAlias.class);
if (annotationFiled != null) {
xstream.processAnnotations(clazz);
break;
}
}
}
}
}

    /**
     * 将包下的object转换成string xml形式,object的class已经初始化了。
     * @param obj 要转换的对象
     * @return 字符串
     */
public String toXml(Object obj) {
return xstream.toXML(obj);
}

/**
 * 将某一对象转换成string xml形式
 * @param obj 要转换的对象
 * @return 字符串的xml
 */
public String toXmlSingle(Object obj){
xstream.processAnnotations(obj.getClass());
return xstream.toXML(obj);
}

/**
 * 将string的xml字符串转换成对象
 * @param xml 要转换的string
 * @param clazz 要转换成相应的clazz对象
 * @return 转换后的对象
 */
public  T fromObjectSingle(String xml,Class clazz){
xstream.processAnnotations(clazz);
T object = (T)xstream.fromXML(xml);
return object;
}

/**
 * 将包下string的xml转换成对象，对象的class已经初始化
 * @param xml 要进行转换的string
 * @return 转换后的对象
 */
public Object fromObject(String xml) {
return xstream.fromXML(xml);
}
}

测试代码：

public static void main(String[] args) {
//XStreamUtils x = XStreamUtils.getInstance();
XStreamUtils x = XStreamUtils.getInstance("com.frame.model");
User user = new User();
user.setId(17);
user.setName("c");
    user.setPassword("123");
 //String stringXml = x.toXmlSingle(user);
     String stringXml = x.toXml(user);
    System.out.println(stringXml);
// User sUser  =  x.fromObjectSingle(stringXml, User.class);
    User sUser  =  (User) x.fromObject(stringXml);
    System.out.println(sUser.getName());
}

结果：

c