博客

前一段时间和Xstream打过交道，发现Xstream在支持json以及XML方面还是相当强大的。提供annotation注解，可以在JavaBean中完成对xml节点、属性的描述。在根据xsd转换为Xstream模型之后，希望利用Xstream来生成XML并且满足XSD要求。例如：

package nju.software.ExecutionInterfaces.service.XstreamModels;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

import com.thoughtworks.xstream.annotations.XStreamAlias;


@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "userId",
    "infoCode",
    "departId"
})

@XmlRootElement(name = "info")
@XStreamAlias("info")
@Annotation(documentation="信息")
public class Info {


    @XmlElement(name = "user_id")
@XStreamAlias("user_id")
@Annotation(documentation="用户ID")
    protected int userId;

    @XmlElement(name = "info_code", required = true)
@XStreamAlias("info_code")
@Annotation(documentation="信息密码")
    protected String infoCode;

    @XmlElement(name = "depart_id", required = true, type = Integer.class, nillable = true)
@XStreamAlias("depart_id")
@Annotation(documentation="部门ID")
    protected Integer departId;
}

根据XSD生成的模型加上Xstream注解。利用xStream中toXML()方法将Model转换成XML字符串。预想是仅仅使用processAnnotations方式注入注解就自动将XML中节点名称写好。但是生成的XML却无法通过XSD的验证。经过检查发现是xsd中类型设置的原因。比如departId字段。required = true, type = Integer.class, nillable = true，表示为Integer类型且可为空。但是当真正将值设为空时又通不过验证。因为XSD在检查数字类型的时候需要至少写一个0。<depart_id/>或者<depart_id></depart_id>都不行。于是想到了使用Xstream中的Converter接口。在园子里也看到了有关nullConverter的说明。在其基础上进行了修改。

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.List;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.converters.Converter;
import com.thoughtworks.xstream.converters.MarshallingContext;
import com.thoughtworks.xstream.converters.UnmarshallingContext;
import com.thoughtworks.xstream.io.HierarchicalStreamReader;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;

public class NullConverter implements Converter {

	@SuppressWarnings("unchecked")
	public void marshal(Object source, HierarchicalStreamWriter writer,
			MarshallingContext context) {
		if (null == source)
			return;
		Class cType = source.getClass();
		Field[] fields = cType.getDeclaredFields();
		if (source instanceof List) {
			List list = (List) source;
			for (Object obj : list) {
				XStreamAlias alias = obj.getClass().getAnnotation(XStreamAlias.class);
				if (alias != null) {
					writer.startNode(alias.value());
					marshal(obj, writer, context);
					writer.endNode();
				}else {
					marshal(obj, writer, context);
				}
			}
		} else {
			for (Field field : fields) {
			//获得get方法
				String temp1 = "get"
						+ field.getName().substring(0, 1).toUpperCase()
						+ field.getName().substring(1);
				Method m = null;
				try {
					m = cType.getMethod(temp1, null);
				} catch (SecurityException e1) {
					e1.printStackTrace();
				} catch (NoSuchMethodException e1) {
					e1.printStackTrace();
				}
				String methodName = m.getName();
				if (methodName.indexOf("get") != -1 && methodName != "getClass") {
					boolean isBaseType = isBaseType(m.getReturnType());
					String name = methodName.substring(3);
					Object o = null;
					try {
						o = m.invoke(source, null);
					} catch (Exception e) {
						e.printStackTrace();
					}
					//递归打出基础类型值
					if (isBaseType) {
							writer.startNode(getAliasByNameAndType(name, cType).value());
							writeData(o, m.getReturnType(), writer);
							writer.endNode();
					} else {
						XStreamAlias alias = getAliasByNameAndType(name, cType);
							if (alias == null) {
								marshal(o, writer, context);
							} else {
								writer.startNode(alias.value());
								marshal(o, writer, context);
								writer.endNode();
							}
					}
				}
			}
		}
	}

	/**
	 * 根据Name和类获得Xstream注解
	 * @param name
	 * Name
	 * @param cType
	 * 类
	 * @return
	 * XStreamAlias
	 */
	private XStreamAlias getAliasByNameAndType(String name,Class<?> cType){
		String temp = name.substring(0, 1).toLowerCase()
		+ name.substring(1);
		Field f = null;
		try {
			f = cType.getDeclaredField(temp);
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		}
		XStreamAlias alias = f.getAnnotation(XStreamAlias.class);
		return alias;
	}
	
	/**
	 * 改写输出XML
	 * @param o
	 * @param ReturnType
	 * @param writer
	 */
	private void writeData(Object o,Class<?> ReturnType,HierarchicalStreamWriter writer) {
		//如果是数字类型的话就要预设为0而不能为空
		if (isNumValueType(ReturnType)) {
			if (o == null) {
				writer.setValue("0");
			}else if (ReturnType.equals(Double.class)||ReturnType.equals(double.class)||ReturnType.equals(BigDecimal.class)) {
				DecimalFormat df = new DecimalFormat("#.##");
				writer.setValue(df.format(o));
			}else {
				writer.setValue(o.toString());
			}
		} else {
			writer.setValue(o == null ? "" : o.toString());
		}
	}
	
	public Object unmarshal(HierarchicalStreamReader reader,
			UnmarshallingContext context) {
		return null;
	}

	public boolean canConvert(Class type) {
		return true;
	}


	/**
	 * 判断是否为基本类型
	 * @param type
	 * @return
	 * boolean
	 */
	private boolean isBaseType(Class<?> type) {
		if (type.equals(Integer.class) || type.equals(Double.class)
				|| type.equals(String.class) || type.equals(Boolean.class)
				|| type.equals(Long.class) || type.equals(Short.class)
				|| type.equals(Byte.class) || type.equals(Float.class)
				|| type.equals(BigDecimal.class) || type.equals(int.class)
				|| type.equals(float.class) || type.equals(long.class)
				|| type.equals(double.class) || type.equals(short.class)
				|| type.equals(boolean.class) || type.equals(byte.class)) {
			return true;
		}
		return false;
	}

		/**
	 * 判断是否为数字类型
	 * @param type
	 * @return
	 * boolean
	 */
	public boolean isNumValueType(Class<?> type) {
		if (type.equals(Integer.class) || type.equals(Double.class)
				|| type.equals(Long.class) || type.equals(Short.class)
				|| type.equals(Float.class) || type.equals(BigDecimal.class)
				|| type.equals(int.class) || type.equals(float.class)
				|| type.equals(long.class) || type.equals(double.class)
				|| type.equals(short.class)) {
			return true;
		}
		return false;
	}

}

基本思想还是利用递归的思想，主要修改有这么几点：

1打出一个类中属性XML节点的方式。原始方式是通过拼接出get方法，便利获得属性上的Xstream注解生成。但是这样生成不能保证属性的顺序，于是改成getAliasByNameAndType方法中首先获得属性。根据属性拼接get方法。

2由于需求原因增加了数字类型的判断，并在输出时也做了判断。

这是第一次在园子里发随笔，写的不好但是是想从现在开始记录自己的学习生活。想养成写博客的习惯。