在项目开发中有时要传输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<Class<?>> getClasses(String packagePath){
	 Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
	 String packageClassPath = packagePath.replace(".", "/")+"/**/*.class" ;
	ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
	try {
		Resource[] resources = resolver.getResources("classpath*:"+packageClassPath);
		for(int i = 0;i < resources.length;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; 
 }

}

要转换的对象实例，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;
	}


}

如果没有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<Class<?>> 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> T fromObjectSingle(String xml,Class<T> 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());
	}

<User ID="17" Name="c" PassWord="123"/>
c