java万能的数据结构

1.支持Model对象转xml

2.支持Model对象转json

3.xml转为Model对象

4.支持数据对象的任意嵌套

请看最终的输出结果：

package com.gavin.model;


import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import com.gavin.utils.DateUtils;
import com.gavin.utils.XMLElement;

/**
 * ------------------------------
 *  数据模板
 *  支持转化成xml，json
 *  支持xml转化成Model对象
 *  仅支持String和基本数据类型，及其数组类型的数据
 * ------------------------------
 * @author wdm（[email protected]）  @date 2018年3月20日
 * @version 1.0
 */
public  class Model  implements Serializable, Cloneable {

	/**
	 * Comment for <code>serialVersionUID</code>
	 */
	private static final long serialVersionUID = 1L;

	private Map<String, JObject> kv;
	private Set<String> fields;// 属性名
	
	public Model() {
		kv = new HashMap<String, JObject>();
		fields = new HashSet<String>();
//		this.set("PRINT_GAVIN_TRANS_LOG", true);//默认打印事务日志
	}
	
	public Map<String, JObject> kv(){
		return kv;
	}

	// get start------------------------------------------------------------------------------------------------------
	public Object getObject(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return -1;
		} else {
			return jObj.obj;
		}
	}
	
	public JObject getJObject(String field) {
		if(kv.get(field)!=null){
			return kv.get(field);
		}
		
		int start=field.indexOf("[");
		int end=field.indexOf("]");
		if(start<end && start>0){
			String dmsField=field.substring(0,start);
			String subField=field.substring(end+2);
			String indexField=field.substring(start+1, end);
			int index=(Integer)kv.get(indexField).getValue();
			JObject jo=kv.get(dmsField);
			Model[] dms=(Model[]) jo.getValue();
			Model dm=dms[index];
			return dm.getJObject(subField);
		}
		
		return kv.get(field);
	}
	
	public Object get(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return jObj.obj;
		}
	}		

	public Model getModel(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (Model) jObj.obj;
		}
	}

	public Model[] getModels(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (Model[]) jObj.obj;
		}
	}

	public String[] getStrings(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (String[]) jObj.obj;
		}
	}
	
	public int[] getIntegers(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (int[])jObj.obj;
		}
	}

	public short[] getShorts(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (short[]) jObj.obj;
		}
	}

	public float[] getFloats(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (float[]) jObj.obj;
		}
	}

	public String[] getDates(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (String[]) jObj.obj;
		}
	}

	public String[] getDateTimes(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (String[]) jObj.obj;
		}
	}

	public String[] getTimes(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (String[]) jObj.obj;
		}
	}

	public double[] getDoubles(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (double[]) jObj.obj;
		}
	}

	public byte[] getBytes(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (byte[]) jObj.obj;
		}
	}

	public boolean[] getBooleans(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (boolean[]) jObj.obj;
		}
	}

	public long[] getLongs(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (long[])jObj.obj;
		}
	}
	
	public String getString(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (String) jObj.obj;
		}
	}
	
	public Integer getInteger(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return Integer.valueOf(String.valueOf(jObj.obj));
		}
	}

	public Short getShort(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (Short) jObj.obj;
		}
	}

	public Float getFloat(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (Float) jObj.obj;
		}
	}

	public String getDate(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (String) jObj.obj;
		}
	}

	public String getDateTime(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (String) jObj.obj;
		}
	}

	public String getTime(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (String) jObj.obj;
		}
	}

	public Double getDouble(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (Double) jObj.obj;
		}
	}

	public Byte getByte(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (Byte) jObj.obj;
		}
	}

	public Boolean getBoolean(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return (Boolean) jObj.obj;
		}
	}

	public Long getLong(String field) {
		JObject jObj = kv.get(field);
		if (jObj == null) {
			return null;
		} else {
			return Long.valueOf(String.valueOf(jObj.obj));
		}
	}	
	// get end------------------------------------------------------------------------------------------------------
	
	

	// set field start------------------------------------------------------------------------------------------------------------------------------------
	public Model doPage(){
		if(!this.exists("pageNumber")){
			kv.put("pageNumber", new JObject(DataType._long,0L));
			fields.add("pageNumber");
		}
		if(!this.exists("pageSize")){
			kv.put("pageSize", new JObject(DataType._long,10L));
			fields.add("pageSize");
		}
		kv.put("startIndex", new JObject(DataType._long,this.getLong("pageSize")*this.getLong("pageNumber")));
		fields.add("startIndex");
		return this;
	}	
	
	public void setPageNumber(java.lang.Long pageNumber) {
		if(pageNumber!=null){set("pageNumber", pageNumber);}
	}
	
//	public java.lang.Long getPageNumber() {
//		return getLong("pageNumber");
//	}
	public void setPageSize(java.lang.Long pageSize) {
		if(pageSize!=null){set("pageSize", pageSize);}
	}
	
//	public java.lang.Long getPageSize() {
//		return getLong("pageSize");
//	}
	public void setTotalPage(java.lang.Long totalPage) {
		if(totalPage!=null){set("totalPage", totalPage);}
	}
	
//	public java.lang.Long getTotalPage() {
//		return getLong("totalPage");
//	}	

	public Model currentTime(){
		this.set("currentTime", DateUtils.date2String(new Date()));
		return this;
	}
	/**
	 * 分页请求
	 * @author wdm  @date 2017年12月25日
	 * @version 1.0
	 */
	public Model request(String serviceName,String transName){
		this.set("strServiceName", serviceName);
		this.set("strTransName", transName);
		if(!this.exists("pageNumber")){
			kv.put("pageNumber", new JObject(DataType._long,0L));
			fields.add("pageNumber");
		}
		if(!this.exists("pageSize")){
			kv.put("pageSize", new JObject(DataType._long,10L));
			fields.add("pageSize");
		}
		kv.put("startIndex", new JObject(DataType._long,this.getLong("pageSize")*this.getLong("pageNumber")));
		fields.add("startIndex");
		return this;
	}
	public static String getFieldId(String strFieldText) {
		if (strFieldText.startsWith("{") == false) {
			return null;
		}
		if (strFieldText.endsWith("}") == false) {
			return null;
		}
		return strFieldText.substring(1, strFieldText.length() - 1);
	}

	@Deprecated
	public void setObject(String field, Object value) {
		fields.add(field);
		kv.put(field, new JObject(DataType._obj, value));
	}
	
	public void set(String field, Byte value) {
		fields.add(field);
		kv.put(field, new JObject(DataType._byte, value));
	}

	public void set(String field, Short value) {
		fields.add(field);
		kv.put(field, new JObject(DataType._short, value));
	}

	public void set(String field, Integer value) {
		fields.add(field);
		kv.put(field, new JObject(DataType._int, value));
	}

	public void set(String field, String value) {
		fields.add(field);
		JObject jobj = new JObject(DataType._string, value);
		kv.put(field, jobj);
	}

	public void set(String field, Date value) {
		fields.add(field);
		JObject jobj = new JObject(DataType._string, DateUtils.date2String(value));
		kv.put(field, jobj);
	}

	public void set(String field, Long value) {
		fields.add(field);
		kv.put(field, new JObject(DataType._long, value));
	}

	public void set(String field, Float value) {
		fields.add(field);
		kv.put(field, new JObject(DataType._float, value));
	}

	public void set(String field, Double value) {
		fields.add(field);
		kv.put(field, new JObject(DataType._double, value));
	}

	public void set(String field, Boolean value) {
		fields.add(field);
		kv.put(field, new JObject(DataType._boolean, value));
	}

	public void set(String field, Model dataModel) {
		fields.add(field);
		kv.put(field, new JObject(DataType._m, dataModel));
	}
	
	public void copy(Model dm){
		Map<String, JObject> kv=dm.kv();
		for (String field : kv.keySet()) {
			this.kv.put(field, kv.get(field));
			fields.add(field);
		}
	}
	//	set field end------------------------------------------------------------------------------------------------------------------------------------
	

	//	set array start------------------------------------------------------------------------------------------------------------------------------------
	public void set(String field, byte[] value) {
		fields.add(field);
		kv.put(field, new JObject(DataType._bytes, value));
		kv.put(field+".length", new JObject(DataType._int,value.length));
	}

	public void set(String field, short[] value) {
		fields.add(field);
		kv.put(field, new JObject(DataType._shorts, value));
		kv.put(field+".length", new JObject(DataType._int,value.length));
	}

	public void set(String field, int[] value) {
		fields.add(field);
		kv.put(field, new JObject(DataType._ints, value));
		kv.put(field+".length", new JObject(DataType._int,value.length));
	}

	public void set(String field, String[] value) {
		fields.add(field);
		JObject jobj = new JObject(DataType._strings, value);
		kv.put(field, jobj);
		kv.put(field+".length", new JObject(DataType._int,value.length));
	}

	public void set(String field, long[] value) {
		fields.add(field);
		kv.put(field, new JObject(DataType._longs, value));
		kv.put(field+".length", new JObject(DataType._int,value.length));
	}

	public void set(String field, float[] value) {
		fields.add(field);
		kv.put(field, new JObject(DataType._floats, value));
		kv.put(field+".length", new JObject(DataType._int,value.length));
	}

	public void set(String field, double[] value) {
		fields.add(field);
		kv.put(field, new JObject(DataType._doubles, value));
		kv.put(field+".length", new JObject(DataType._int,value.length));
	}

	public void set(String field, boolean[] value) {
		fields.add(field);
		kv.put(field, new JObject(DataType._booleans, value));
		kv.put(field+".length", new JObject(DataType._int,value.length));
	}

	public void set(String field, Model[] dataModels) {
		fields.add(field);
		kv.put(field, new JObject(DataType._ms, dataModels));
		kv.put(field+".length", new JObject(DataType._int,dataModels.length));
	}
	//	set array end------------------------------------------------------------------------------------------------------------------------------------

	/**
	 * 判断容器中是否有对象
	 * @return boolean
	 */
	final public boolean empty() {
		return kv.size() == 0;
	}

	/**
	 * 判断容器中指定对象是否存在
	 * @param field
	 * @return
	 */
	final public boolean exists(String field) {
		return kv.get(field) != null;
	}

	final public Object[] fields() {
		return fields.toArray();
	}

	final public Object[] objects() {
		return kv.values().toArray();
	}

	final public int fieldCount() {
		return fields.size();
	}

	public Model clone() {
		return this.clone();
	}


	
	// 序列化方法 start-------------------------------------------------------------------------------------------------
	final public String toJson() {
		return toString();
	}

	public String toString() {
		StringBuilder sb = new StringBuilder("{");
		for (String field : fields) {
			JObject jobj = kv.get(field);
			sb.append("\"" + field + "\":");
			DataType dt = jobj.dataType;
			switch (dt) {
			case _int:
			case _long:
			case _double:
			case _float:
			case _short:	
			case _byte:					
			case _boolean:
				sb.append(String.valueOf(jobj.obj));
				break;
			case _string:
				sb.append("\"");
				sb.append(jobj.obj);
				sb.append("\"");
				break;
			case _m:
				Model dm = (Model) jobj.obj;
				sb.append(dm.toString());
				break;
			case _ints:
				int[] ints = (int[]) jobj.obj;
				sb.append("[");
				for (int i = 0; i < ints.length; i++) {
					sb.append(ints[i]);
					if(i+1<ints.length){
						sb.append(",");
					}
				}
				sb.append("]");
				break;
			case _longs:
				long[] longs = (long[]) jobj.obj;
				sb.append("[");
				for (int i = 0; i < longs.length; i++) {
					sb.append(longs[i]);
					if(i+1<longs.length){
						sb.append(",");
					}
				}
				sb.append("]");
				break;
			case _doubles:
				double[] doubles = (double[]) jobj.obj;
				sb.append("[");
				for (int i = 0; i < doubles.length; i++) {
					sb.append(doubles[i]);
					if(i+1<doubles.length){
						sb.append(",");
					}
				}
				sb.append("]");
				break;
			case _floats:
				float[] floats = (float[]) jobj.obj;
				sb.append("[");
				for (int i = 0; i < floats.length; i++) {
					sb.append(floats[i]);
					if(i+1<floats.length){
						sb.append(",");
					}
				}
				sb.append("]");
				break;
			case _bytes:
				byte[] bytes = (byte[]) jobj.obj;
				sb.append("[");
				for (int i = 0; i < bytes.length; i++) {
					sb.append(bytes[i]);
					if(i+1<bytes.length){
						sb.append(",");
					}
				}
				sb.append("]");
				break;				
			case _shorts:
				short[] shorts = (short[]) jobj.obj;
				sb.append("[");
				for (int i = 0; i < shorts.length; i++) {
					sb.append(shorts[i]);
					if(i+1<shorts.length){
						sb.append(",");
					}
				}
				sb.append("]");
				break;				
			case _booleans:	
				boolean[] booleans = (boolean[]) jobj.obj;
				sb.append("[");
				for (int i = 0; i < booleans.length; i++) {
					sb.append(booleans[i]);
					if(i+1<booleans.length){
						sb.append(",");
					}
				}
				sb.append("]");
				break;			
			case _date:
			case _datetime:
			case _time:				
			case _strings:	
				Object[] strs = (Object[]) jobj.obj;
				sb.append("[");
				for (int i = 0; i < strs.length; i++) {
					sb.append("\"").append(strs[i]).append("\"");
					if(i+1<strs.length){
						sb.append(",");
					}
				}
				sb.append("]");
				break;				
			case _ms:
				Model[] dms = (Model[]) jobj.obj;
				sb.append("[");
				boolean haschild = false;
				for (int i = 0; i < dms.length; i++) {
					sb.append(dms[i].toString()).append(",");
					haschild = true;
				}
				if (haschild) {
					sb.replace(sb.length() - 1, sb.length(), "");
				}
				sb.append("]");
				break;
			case _obj:
//				Object obj = (Object) jobj.obj;
//				String js = JSONObject.toJSONString(obj);
//				sb.append(js);
				sb.append( jobj.obj);
				break;
			default:
				sb.append("{}");
			}
			sb.append(",");
		}
		if(sb.length()>1)sb.replace(sb.length() - 1, sb.length(), "");
		sb.append("}");
		return sb.toString();
	}

	final public String toXML() {
		StringBuilder sb = xml();
		sb.insert(0, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
		return sb.toString();
	}
	
	final public static Model formXML(String modelXml) {
		XMLElement xmlNode=new XMLElement();
		xmlNode.parseString(modelXml);
		Model model=new Model();
		model.fromXML(xmlNode);
		return model;
	}

	private StringBuilder xml() {
		StringBuilder sb = new StringBuilder("<m>");
		for (String field : fields) {
			JObject jobj = kv.get(field);
			DataType dt = jobj.dataType;
			switch (dt) {
			case _int:
				sb.append("<n n=\"").append(field).append("\" v=\"");
				sb.append((int) jobj.obj);
				sb.append("\"/>");
				break;
			case _long:
				sb.append("<l n=\"").append(field).append("\" v=\"");
				sb.append((long) jobj.obj);
				sb.append("\"/>");
				break;
			case _double:
				sb.append("<db n=\"").append(field).append("\" v=\"");
				sb.append((double) jobj.obj);
				sb.append("\"/>");
				break;
			case _float:
				sb.append("<ft n=\"").append(field).append("\" v=\"");
				sb.append((float) jobj.obj);
				sb.append("\"/>");
				break;
			case _boolean:
				sb.append("<bn n=\"").append(field).append("\" v=\"");
				sb.append((boolean) jobj.obj);
				sb.append("\"/>");
				break;
			case _short:
				sb.append("<sh n=\"").append(field).append("\" v=\"");
				sb.append(this.getShort(field));
				sb.append("\"/>");
				break;
			case _byte:
				sb.append("<by n=\"").append(field).append("\" v=\"");
				sb.append(this.getByte(field));
				sb.append("\"/>");
				break;				
			case _string:
				sb.append("<s n=\"").append(field).append("\" v=\"");
				sb.append(jobj.obj);
				sb.append("\"/>");
				break;
			case _strings:
				sb.append("<ss n=\"").append(field).append("\" v=\"");
				String[] strs=this.getStrings(field);
				sb.append(strs[0]);
				for (int i = 1; i < strs.length; i++) {
					sb.append(",").append(strs[i]);
				}
				sb.append("\"/>");
				break;
			case _booleans:
				sb.append("<bns n=\"").append(field).append("\" v=\"");
				boolean[] booleans=this.getBooleans(field);
				sb.append(booleans[0]);
				for (int i = 1; i < booleans.length; i++) {
					sb.append(",").append(booleans[i]);
				}
				sb.append("\"/>");
				break;				
			case _longs:
				sb.append("<ls n=\"").append(field).append("\" v=\"");
				long[] longs=this.getLongs(field);
				sb.append(longs[0]);
				for (int i = 1; i < longs.length; i++) {
					sb.append(",").append(longs[i]);
				}
				sb.append("\"/>");
				break;
			case _ints:
				sb.append("<ns n=\"").append(field).append("\" v=\"");
				int[] ints=this.getIntegers(field);
				sb.append(ints[0]);
				for (int i = 1; i < ints.length; i++) {
					sb.append(",").append(ints[i]);
				}
				sb.append("\"/>");
				break;
			case _shorts:
				sb.append("<shs n=\"").append(field).append("\" v=\"");
				short[] shorts=this.getShorts(field);
				sb.append(shorts[0]);
				for (int i = 1; i < shorts.length; i++) {
					sb.append(",").append(shorts[i]);
				}
				sb.append("\"/>");
				break;
			case _bytes:
				sb.append("<bys n=\"").append(field).append("\" v=\"");
				byte[] bytes=this.getBytes(field);
				sb.append(bytes[0]);
				for (int i = 1; i < bytes.length; i++) {
					sb.append(",").append(bytes[i]);
				}
				sb.append("\"/>");
				break;
			case _doubles:
				sb.append("<dbs n=\"").append(field).append("\" v=\"");
				double[] doubles=this.getDoubles(field);
				sb.append(doubles[0]);
				for (int i = 1; i < doubles.length; i++) {
					sb.append(",").append(doubles[i]);
				}
				sb.append("\"/>");
				break;
			case _floats:
				sb.append("<fts n=\"").append(field).append("\" v=\"");
				float[] floats=this.getFloats(field);
				sb.append(floats[0]);
				for (int i = 1; i < floats.length; i++) {
					sb.append(",").append(floats[i]);
				}
				sb.append("\"/>");
				break;
			case _datetimes:
				sb.append("<dts n=\"").append(field).append("\" v=\"");
				String[] datetimes=this.getStrings(field);
				sb.append(datetimes[0]);
				for (int i = 1; i < datetimes.length; i++) {
					sb.append(",").append(datetimes[i]);
				}
				sb.append("\"/>");
				break;
			case _dates:
				sb.append("<des n=\"").append(field).append("\" v=\"");
				String[] dates=this.getStrings(field);
				sb.append(dates[0]);
				for (int i = 1; i < dates.length; i++) {
					sb.append(",").append(dates[i]);
				}
				sb.append("\"/>");
				break;	
			case _times:
				sb.append("<tes n=\"").append(field).append("\" v=\"");
				String[] times=this.getStrings(field);
				sb.append(times[0]);
				for (int i = 1; i < times.length; i++) {
					sb.append(",").append(times[i]);
				}
				sb.append("\"/>");
				break;	
			case _m:
				sb.append("<m n=\"").append(field).append("\">");
				Model dm = (Model) jobj.obj;
				sb.append(dm.xml());
				sb.append("</m>");
				break;
			case _ms:
				Model[] dms = (Model[]) jobj.obj;
				sb.append("<ms n=\"").append(field).append("\">");
				for (int i = 0; i < dms.length; i++) {
					sb.append(dms[i].xml());
				}
				sb.append("</ms>");
				break;
			case _obj:
				sb.append("<s n=\"").append(field).append("\" v=\"");
				sb.append(jobj.obj);
				sb.append("\"/>");
				break;
			default:
				sb.append("");
			}
		}
		sb.append("</m>");
		return sb;
	}
	// 序列化方法 end-------------------------------------------------------------------------------------------------

	// 反序列化方法 start-------------------------------------------------------------------------------------------------
	private void fromXML(XMLElement nodeCDO){
		for(XMLElement node : nodeCDO.getChildren()){
			String tag=node.getName();
			if(tag.equals("s") || tag.equals("dt") || tag.equals("de") || tag.equals("te")){//String
				String name	=node.getStringAttribute("N");
				String value=node.getStringAttribute("V");
				this.set(name, value);
			} else if(tag.equals("bn")){//BooleanField
				String name	=node.getStringAttribute("N");
				String value=node.getStringAttribute("V");
				boolean bValue=false;
				if(value.equalsIgnoreCase("true")){
					bValue=true;
				}else if(value.equalsIgnoreCase("false")){
				}else{
					throw new RuntimeException("Parse xml error: unexpected boolean value "+value+" under "+tag);
				}
				this.set(name, bValue);
			} else if(tag.equals("by")){//ByteField
				String name	=node.getStringAttribute("N");
				String value=node.getStringAttribute("V");
				this.set(name, Byte.parseByte(value));
			} else if(tag.equals("sh")){//ShortField
				String name	=node.getStringAttribute("N");
				String value=node.getStringAttribute("V");
				this.set(name, Short.parseShort(value));
			} 
//			else if(tag.equals("ch")){//ShortField
//				String name	=node.getStringAttribute("N");
//				String value=node.getStringAttribute("V");
//				this.set(name,(value));
//			}
			else if(tag.equals("n")){//IntegerField
				String name	=node.getStringAttribute("N");
				String value=node.getStringAttribute("V");
				this.set(name, Integer.parseInt(value));
			} else if(tag.equals("l")){//LongField
				String name	=node.getStringAttribute("N");
				String value=node.getStringAttribute("V");
				this.set(name, Long.parseLong(value));
			} else if(tag.equals("ft")){//FloatField
				String name	=node.getStringAttribute("N");
				String value=node.getStringAttribute("V");
				this.set(name, Float.parseFloat(value));
			} else if(tag.equals("db")) {//Double
				String name	=node.getStringAttribute("N");
				String value=node.getStringAttribute("V");
				this.set(name, Double.parseDouble(value));
			} else if(tag.equals("ss") || tag.equals("dts") || tag.equals("des") || tag.equals("tes")){
				String name	=node.getStringAttribute("N");
				String value=node.getStringAttribute("V");
				if(value==null){
					
				}else{
					String[] arr=value.split(",");
					this.set(name, arr);
				}
			} else if(tag.equals("fts")){
				String name	=node.getStringAttribute("N");
				String value=node.getStringAttribute("V");
				if(value==null){
					
				}else{
					String[] arr=value.split(",");
					float[] fts=new float[arr.length];
					for (int i = 0; i < arr.length; i++) {
						try{
							fts[i]=Float.parseFloat(arr[i]);
						}catch(Exception ex){
							throw new RuntimeException("Parse xml error: unexpected floats value "+arr[i]+" under "+tag);
						}
					}
					this.set(name, fts);
				}
			} else if(tag.equals("ns")){
				String name	=node.getStringAttribute("N");
				String value=node.getStringAttribute("V");
				if(value==null){
					
				}else{
					String[] arr=value.split(",");
					int[] fts=new int[arr.length];
					for (int i = 0; i < arr.length; i++) {
						try{
							fts[i]=Integer.parseInt(arr[i]);
						}catch(Exception ex){
							throw new RuntimeException("Parse xml error: unexpected ints value "+arr[i]+" under "+tag);
						}
					}
					this.set(name, fts);
				}
			} else if(tag.equals("ls")) {
				String name	=node.getStringAttribute("N");
				String value=node.getStringAttribute("V");
				if(value==null){
					
				}else{
					String[] arr=value.split(",");
					long[] fts=new long[arr.length];
					for (int i = 0; i < arr.length; i++) {
						try{
							fts[i]=Long.parseLong(arr[i]);
						}catch(Exception ex){
							throw new RuntimeException("Parse xml error: unexpected longs value "+arr[i]+" under "+tag);
						}
					}
					this.set(name, fts);
				}
			} else if(tag.equals("dbs")) {
				String name	=node.getStringAttribute("N");
				String value=node.getStringAttribute("V");
				if(value==null){
					
				}else{
					String[] arr=value.split(",");
					double[] fts=new double[arr.length];
					for (int i = 0; i < arr.length; i++) {
						try{
							fts[i]=Double.parseDouble(arr[i]);
						}catch(Exception ex){
							throw new RuntimeException("Parse xml error: unexpected doubles value "+arr[i]+" under "+tag);
						}
					}
					this.set(name, fts);
				}
				
			} else if(tag.equals("shs")) {
				String name	=node.getStringAttribute("N");
				String value=node.getStringAttribute("V");
				if(value==null){
					
				}else{
					String[] arr=value.split(",");
					short[] fts=new short[arr.length];
					for (int i = 0; i < arr.length; i++) {
						try{
							fts[i]=Short.parseShort(arr[i]);
						}catch(Exception ex){
							throw new RuntimeException("Parse xml error: unexpected shorts value "+arr[i]+" under "+tag);
						}
					}
					this.set(name, fts);
				}
			} else if(tag.equals("bys")) {
				String name	=node.getStringAttribute("N");
				String value=node.getStringAttribute("V");
				if(value==null){
					
				}else{
					String[] arr=value.split(",");
					byte[] fts=new byte[arr.length];
					for (int i = 0; i < arr.length; i++) {
						try{
							fts[i]=Byte.parseByte(arr[i]);
						}catch(Exception ex){
							throw new RuntimeException("Parse xml error: unexpected bytes value "+arr[i]+" under "+tag);
						}
					}
					this.set(name, fts);
				}
			} else if(tag.equals("bns")){
				String name	=node.getStringAttribute("N");
				String value=node.getStringAttribute("V");
				if(value==null){
					
				}else{
					String[] arr=value.split(",");
					boolean[] bns=new boolean[arr.length];
					for (int i = 0; i < arr.length; i++) {
						boolean bValue=false;
						if("true".equalsIgnoreCase(arr[i])){
							bValue=true;
						}else if("false".equalsIgnoreCase(arr[i])){
						}else{
							throw new RuntimeException("Parse xml error: unexpected boolean value "+value+" under "+tag);
						}
						bns[i]=bValue;
					}
					this.set(name, bns);
				}				
			} else if(tag.equals("m")) {
				String name	=node.getStringAttribute("N");
				Model modelValue	=new Model();
				modelValue.fromXML((XMLElement)node.getChildren().get(0));
				this.set(name, modelValue);
			} else if(tag.equals("ms")) {
				String name	=node.getStringAttribute("N");
				ArrayList<XMLElement> alSubNode=node.getChildren();
				Model[] modelsValue=new Model[alSubNode.size()];
				for(int i=0;i<modelsValue.length;i++) {
					XMLElement subNode=alSubNode.get(i);
					String strSubNodeTag=subNode.getName();
					if(strSubNodeTag.equals("m")==false) {
						throw new RuntimeException("Parse xml error: unexpected Tag name "+strSubNodeTag+" under "+tag);
					}
					Model modelValue=new Model();
					modelValue.fromXML(subNode);
					modelsValue[i]=modelValue;
				}
				this.set(name, modelsValue);
			} else{
				throw new RuntimeException("Parse xml error: unexpected Tag name ["+tag+"]");
			}
		}
	}
	
}

package com.gavin.model;


import java.io.Serializable;

/**
 * ------------------------------
 *  java通用数据对象
 * ------------------------------
 * @author wdm（[email protected]）  @date 2018年3月20日
 * @version 1.0
 */
public class JObject implements Serializable {

	private static final long serialVersionUID = -9200135627701400975L;
	DataType dataType;
	Object obj;

	public JObject(DataType dataType, Object obj) {
		this.dataType = dataType;
		this.obj = obj;
	}

	public DataType getType() {
		return dataType;
	}

	public Object getValue() {
		return obj;
	}

}

package com.gavin.model;


/**
 * ------------------------------
 * 数据类型
 * ------------------------------
 * @author wdm（[email protected]）  @date 2018年4月18日
 * @version 1.0
 */
public enum DataType{
	_byte,_short,_int,_long,_float,_double,_boolean,_string,
	
	_date,_time,_datetime,
	
	_bytes,_shorts,_ints,_longs,_floats,_doubles,_booleans,_strings,
	
	_dates,_times,_datetimes,
	
	_obj,_m,_ms;
} 

package com.gavin.test;

import com.gavin.model.Model;

public class TestModel {
	public static void main(String[] args) {
		Model model = new Model();
		model.set("contractNumber", "dsa45dsa11122333");//合同编号
		
		Model user = new Model();//用户信息
		user.set("userName","张三");
		user.set("age",20L);
		user.set("idNumber","430224198805120057");
		model.set("user",user);
		
		Model[] contacts = new Model[2];//联系人信息
		contacts[0]=new Model();
		contacts[0].set("userName","李四");
		contacts[0].set("age",20L);
		contacts[0].set("idNumber","430224198801120052");
		contacts[0].set("phone","18514589896");
		contacts[1]=new Model();
		contacts[1].set("userName","王五");
		contacts[1].set("age",36L);
		contacts[1].set("idNumber","430224198101120012");
		contacts[1].set("phone","18514582336");
		model.set("contacts",contacts);
		
		System.out.println(model.toXML());//序列化
		System.out.println(Model.formXML(model.toXML()));//反序列化
		System.out.println(Model.formXML(model.toXML()).toXML());//反序列化
		
		System.out.println("--------------------------------------------------------------------------------------");
	}
}

json输出结果为：

{
    "contractNumber":"dsa45dsa11122333",
    "user":{
        "userName":"张三",
        "idNumber":"430224198805120057",
        "age":20
    },
    "contacts":[
        {
            "phone":"18514589896",
            "userName":"李四",
            "idNumber":"430224198801120052",
            "age":20
        },
        {
            "phone":"18514582336",
            "userName":"王五",
            "idNumber":"430224198101120012",
            "age":36
        }
    ]
}

xml输出为：

<?xml version="1.0" encoding="UTF-8"?>
<m>
    <s n="contractNumber" v="dsa45dsa11122333"/>
    <m n="user">
        <m>
            <s n="userName" v="张三"/>
            <s n="idNumber" v="430224198805120057"/>
            <l n="age" v="20"/>
        </m>
    </m>
    <ms n="contacts">
        <m>
            <s n="phone" v="18514589896"/>
            <s n="userName" v="李四"/>
            <s n="idNumber" v="430224198801120052"/>
            <l n="age" v="20"/>
        </m>
        <m>
            <s n="phone" v="18514582336"/>
            <s n="userName" v="王五"/>
            <s n="idNumber" v="430224198101120012"/>
            <l n="age" v="36"/>
        </m>
    </ms>
</m>

xml解析

package com.gavin.utils;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

final public class XMLElement {
	static long serialVersionUID = 6685035139346394777L;

	public static int NANOXML_MAJOR_VERSION = 2;

	public static int NANOXML_MINOR_VERSION = 2;

	private HashMap<String, String> attributes;

	private ArrayList<XMLElement> children;

	private String name;

	private String contents;

	private int lineNr;

	private boolean ignoreCase;

	private boolean ignoreWhitespace;

	private char charReadTooMuch;

	char[] chsReader;
	int nIndex = 0;

	public XMLElement() {
		this(false, true, true);
	}

	public XMLElement(HashMap<String, String> entities) {
		this(false, true, true);
	}

	public XMLElement(boolean skipLeadingWhitespace) {
		this(skipLeadingWhitespace, true, true);
	}

	protected XMLElement(boolean skipLeadingWhitespace, boolean fillBasicConversionTable, boolean ignoreCase) {
		this.ignoreWhitespace = skipLeadingWhitespace;
		this.ignoreCase = ignoreCase;
		this.name = null;
		this.contents = "";
		this.attributes = new HashMap<String, String>();
		this.children = new ArrayList<XMLElement>();
		this.lineNr = 0;
	}

	public void addChild(XMLElement child) {
		this.children.add(child);
	}

	public void setAttribute(String name, Object value) {
		if (this.ignoreCase) {
			name = name.toUpperCase();
		}
		this.attributes.put(name, value.toString());
	}

	public int countChildren() {
		return this.children.size();
	}

	public Set enumerateAttributeNames() {
		return this.attributes.keySet();
	}

	public Iterator enumerateChildren() {
		return this.children.iterator();
	}

	public ArrayList<XMLElement> getChildren() {
		return this.children;
	}

	public String getContents() {
		return this.getContent();
	}

	public String getContent() {
		return this.contents;
	}

	public int getLineNr() {
		return this.lineNr;
	}

	public Object getAttribute(String name) {
		return this.getAttribute(name, null);
	}

	public Object getAttribute(String name, Object defaultValue) {
		if (this.ignoreCase) {
			name = name.toUpperCase();
		}
		Object value = this.attributes.get(name);
		if (value == null) {
			value = defaultValue;
		}
		return value;
	}

	public Object getAttribute(String name, HashMap valueSet, String defaultKey, boolean allowLiterals) {
		if (this.ignoreCase) {
			name = name.toUpperCase();
		}
		Object key = this.attributes.get(name);
		Object result;
		if (key == null) {
			key = defaultKey;
		}
		result = valueSet.get(key);
		if (result == null) {
			if (allowLiterals) {
				result = key;
			} else {
				throw this.invalidValue(name, (String) key);
			}
		}
		return result;
	}

	public String getStringAttribute(String name) {
		return this.getStringAttribute(name, null);
	}

	public String getStringAttribute(String name, String defaultValue) {
		return (String) this.getAttribute(name, defaultValue);
	}

	public String getStringAttribute(String name, HashMap valueSet, String defaultKey, boolean allowLiterals) {
		return (String) this.getAttribute(name, valueSet, defaultKey, allowLiterals);
	}

	public int getIntAttribute(String name) {
		return this.getIntAttribute(name, 0);
	}

	public int getIntAttribute(String name, int defaultValue) {
		if (this.ignoreCase) {
			name = name.toUpperCase();
		}
		String value = (String) this.attributes.get(name);
		if (value == null) {
			return defaultValue;
		} else {
			try {
				return Integer.parseInt(value);
			} catch (NumberFormatException e) {
				throw this.invalidValue(name, value);
			}
		}
	}

	public int getIntAttribute(String name, HashMap valueSet, String defaultKey, boolean allowLiteralNumbers) {
		if (this.ignoreCase) {
			name = name.toUpperCase();
		}
		Object key = this.attributes.get(name);
		Integer result;
		if (key == null) {
			key = defaultKey;
		}
		try {
			result = (Integer) valueSet.get(key);
		} catch (ClassCastException e) {
			throw this.invalidValueSet(name);
		}
		if (result == null) {
			if (!allowLiteralNumbers) {
				throw this.invalidValue(name, (String) key);
			}
			try {
				result = Integer.valueOf((String) key);
			} catch (NumberFormatException e) {
				throw this.invalidValue(name, (String) key);
			}
		}
		return result.intValue();
	}

	public double getDoubleAttribute(String name) {
		return this.getDoubleAttribute(name, 0.);
	}

	public double getDoubleAttribute(String name, double defaultValue) {
		if (this.ignoreCase) {
			name = name.toUpperCase();
		}
		String value = (String) this.attributes.get(name);
		if (value == null) {
			return defaultValue;
		} else {
			try {
				return Double.valueOf(value).doubleValue();
			} catch (NumberFormatException e) {
				throw this.invalidValue(name, value);
			}
		}
	}

	public double getDoubleAttribute(String name, HashMap valueSet, String defaultKey, boolean allowLiteralNumbers) {
		if (this.ignoreCase) {
			name = name.toUpperCase();
		}
		Object key = this.attributes.get(name);
		Double result;
		if (key == null) {
			key = defaultKey;
		}
		try {
			result = (Double) valueSet.get(key);
		} catch (ClassCastException e) {
			throw this.invalidValueSet(name);
		}
		if (result == null) {
			if (!allowLiteralNumbers) {
				throw this.invalidValue(name, (String) key);
			}
			try {
				result = Double.valueOf((String) key);
			} catch (NumberFormatException e) {
				throw this.invalidValue(name, (String) key);
			}
		}
		return result.doubleValue();
	}

	public boolean getBooleanAttribute(String name, String trueValue, String falseValue, boolean defaultValue) {
		if (this.ignoreCase) {
			name = name.toUpperCase();
		}
		Object value = this.attributes.get(name);
		if (value == null) {
			return defaultValue;
		} else if (value.equals(trueValue)) {
			return true;
		} else if (value.equals(falseValue)) {
			return false;
		} else {
			throw this.invalidValue(name, (String) value);
		}
	}

	public String getName() {
		return this.name;
	}

	public String getTagName() {
		return this.getName();
	}

	public void parseFromReader() throws IOException, XMLParseException {
		this.parseFromReader(/* startingLineNr */1);
	}

	public void parseFromReader(int startingLineNr) throws XMLParseException {
		this.name = null;
		this.contents = "";
		this.attributes = new HashMap();
		this.children = new ArrayList<XMLElement>();
		this.charReadTooMuch = '\0';

		while (true) {
			char ch = this.scanWhitespace();

			if (ch != '<') {
				throw this.expectedInput("<");
			}

			ch = this.readChar();

			if ((ch == '!') || (ch == '?')) {
				this.skipSpecialTag(0);
			} else {
				this.charReadTooMuch = ch;
				this.scanElement(this);
				return;
			}
		}
	}

	public void parseString(String string) throws XMLParseException {
		this.chsReader = string.toCharArray();
		this.parseFromReader(/* startingLineNr */1);
	}

	public void parseString(String string, int offset) throws XMLParseException {
		this.parseString(string.substring(offset));
	}

	public void parseString(String string, int offset, int end) throws XMLParseException {
		this.parseString(string.substring(offset, end));
	}

	public void parseCharArray(char[] input, int offset, int end) throws XMLParseException {
		this.parseCharArray(input, offset, end, /* startingLineNr */1);
	}

	public void parseCharArray(char[] input, int offset, int end, int startingLineNr) throws XMLParseException {
		this.parseFromReader(startingLineNr);
	}

	public void removeChild(XMLElement child) {
		this.children.remove(child);
	}

	public void removeAttribute(String name) {
		if (this.ignoreCase) {
			name = name.toUpperCase();
		}
		this.attributes.remove(name);
	}

	public void removeChild(String name) {
		this.removeAttribute(name);
	}

	protected XMLElement createAnotherElement() {
		return new XMLElement(this.ignoreWhitespace, false, this.ignoreCase);
	}

	public void setContent(String content) {
		this.contents = content;
	}

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

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

	public String toString() {
		try {
			ByteArrayOutputStream out = new ByteArrayOutputStream();
			OutputStreamWriter writer = new OutputStreamWriter(out);
			this.write(writer);
			writer.flush();
			return new String(out.toByteArray());
		} catch (IOException e) {
			// Java exception handling suxx
			return super.toString();
		}
	}

	public void write(Writer writer) throws IOException {
		if (this.name == null) {
			this.writeEncoded(writer, this.contents);
			return;
		}
		writer.write('<');
		writer.write(this.name);
		if (!this.attributes.isEmpty()) {
			Set enum1 = this.attributes.keySet();
			Iterator iter = enum1.iterator();
			while (iter.hasNext()) {
				writer.write(' ');
				String key = (String) iter.next();
				String value = (String) this.attributes.get(key);
				writer.write(key);
				writer.write('=');
				writer.write('"');
				this.writeEncoded(writer, value);
				writer.write('"');
			}
		}
		if ((this.contents != null) && (this.contents.length() > 0)) {
			writer.write('>');
			this.writeEncoded(writer, this.contents);
			writer.write('<');
			writer.write('/');
			writer.write(this.name);
			writer.write('>');
		} else if (this.children.isEmpty()) {
			writer.write('/');
			writer.write('>');
		} else {
			writer.write('>');
			Iterator enum1 = this.enumerateChildren();
			while (enum1.hasNext()) {
				XMLElement child = (XMLElement) enum1.next();
				child.write(writer);
			}
			writer.write('<');
			writer.write('/');
			writer.write(this.name);
			writer.write('>');
		}
	}

	protected void writeEncoded(Writer writer, String str) throws IOException {
		for (int i = 0; i < str.length(); i += 1) {
			char ch = str.charAt(i);
			switch (ch) {
			case '<':
				writer.write('&');
				writer.write('l');
				writer.write('t');
				writer.write(';');
				break;
			case '>':
				writer.write('&');
				writer.write('g');
				writer.write('t');
				writer.write(';');
				break;
			case '&':
				writer.write('&');
				writer.write('a');
				writer.write('m');
				writer.write('p');
				writer.write(';');
				break;
			case '"':
				writer.write('&');
				writer.write('q');
				writer.write('u');
				writer.write('o');
				writer.write('t');
				writer.write(';');
				break;
			case '\'':
				writer.write('&');
				writer.write('a');
				writer.write('p');
				writer.write('o');
				writer.write('s');
				writer.write(';');
				break;
			default:
				int unicode = (int) ch;
				if ((unicode < 32) || (unicode > 126)) {
					writer.write('&');
					writer.write('#');
					writer.write('x');
					writer.write(Integer.toString(unicode, 16));
					writer.write(';');
				} else {
					writer.write(ch);
				}
			}
		}
	}

	private void scanIdentifier(StringBuilder result) {
		char ch;
		while (true) {
			if (charReadTooMuch != '\0') {
				ch = this.charReadTooMuch;
				this.charReadTooMuch = '\0';
			} else {
				ch = this.chsReader[nIndex++];
			}

			if (((ch < 'A') || (ch > 'Z')) && ((ch < 'a') || (ch > 'z')) && ((ch < '0') || (ch > '9')) && (ch != '_')
					&& (ch != '.') && (ch != ':') && (ch != '-') && (ch <= '\u007E')) {
				this.charReadTooMuch = ch;
				return;
			}
			result.append(ch);
		}
	}

	private char scanWhitespace() {
		char ch;

		if (charReadTooMuch != '\0') {
			ch = this.charReadTooMuch;
			this.charReadTooMuch = '\0';
			switch (ch) {
			case ' ':
			case '\t':
			case '\n':
			case '\r':
				break;
			default:
				return ch;
			}
		}

		while (true) {

			ch = this.chsReader[nIndex++];
			switch (ch) {
			case ' ':
			case '\t':
			case '\n':
			case '\r':
				break;
			default:
				return ch;
			}
		}
	}

	private char scanWhitespace(StringBuilder result) {
		while (true) {
			char ch = this.readChar();
			switch (ch) {
			case ' ':
			case '\t':
			case '\n':
				result.append(ch);
			case '\r':
				break;
			default:
				return ch;
			}
		}
	}

	private char[] chs = new char[100];

	private void scanString(StringBuilder string) {
		char delimiter = this.readChar();
		if ((delimiter != '\'') && (delimiter != '"')) {
			throw this.expectedInput("' or \"");
		}

		int nIndexString = 0;
		while (true) {
			char ch = this.readChar();
			if (ch == delimiter) {
				break;
			} else if (ch == '&') {
				if (nIndexString > 0) {
					string.append(chs, 0, nIndexString);
					nIndexString = 0;
				}
				this.resolveEntity(string);
			} else {
				chs[nIndexString] = ch;
				nIndexString++;
				if (nIndexString >= chs.length) {
					string.append(chs, 0, nIndexString);
					nIndexString = 0;
				}
			}
		}
		if (nIndexString > 0) {
			string.append(chs, 0, nIndexString);
			nIndexString = 0;
		}
	}

	private void scanPCData(StringBuilder data) {
		for (;;) {
			char ch = this.readChar();
			if (ch == '<') {
				ch = this.readChar();
				if (ch == '!') {
					this.checkCDATA(data);
				} else {
					this.charReadTooMuch = ch;
					return;
				}
			} else if (ch == '&') {
				this.resolveEntity(data);
			} else {
				data.append(ch);
			}
		}
	}

	private boolean checkCDATA(StringBuilder buf) {
		char ch = this.readChar();
		if (ch != '[') {
			this.charReadTooMuch = ch;
			this.skipSpecialTag(0);
			return false;
		} else if (!this.checkLiteral("CDATA[")) {
			this.skipSpecialTag(1); // one [ has already been read
			return false;
		} else {
			int delimiterCharsSkipped = 0;
			while (delimiterCharsSkipped < 3) {
				ch = this.readChar();
				switch (ch) {
				case ']':
					if (delimiterCharsSkipped < 2) {
						delimiterCharsSkipped += 1;
					} else {
						buf.append(']');
						buf.append(']');
						delimiterCharsSkipped = 0;
					}
					break;
				case '>':
					if (delimiterCharsSkipped < 2) {
						for (int i = 0; i < delimiterCharsSkipped; i++) {
							buf.append(']');
						}
						delimiterCharsSkipped = 0;
						buf.append('>');
					} else {
						delimiterCharsSkipped = 3;
					}
					break;
				default:
					for (int i = 0; i < delimiterCharsSkipped; i += 1) {
						buf.append(']');
					}
					buf.append(ch);
					delimiterCharsSkipped = 0;
				}
			}
			return true;
		}
	}

	private void skipComment() {
		int dashesToRead = 2;
		while (dashesToRead > 0) {
			char ch = this.readChar();
			if (ch == '-') {
				dashesToRead -= 1;
			} else {
				dashesToRead = 2;
			}
		}
		if (this.readChar() != '>') {
			throw this.expectedInput(">");
		}
	}

	private void skipSpecialTag(int bracketLevel) {
		int tagLevel = 1; // <
		char stringDelimiter = '\0';
		if (bracketLevel == 0) {
			char ch = this.readChar();
			if (ch == '[') {
				bracketLevel += 1;
			} else if (ch == '-') {
				ch = this.readChar();
				if (ch == '[') {
					bracketLevel += 1;
				} else if (ch == ']') {
					bracketLevel -= 1;
				} else if (ch == '-') {
					this.skipComment();
					return;
				}
			}
		}
		while (tagLevel > 0) {
			char ch = this.readChar();
			if (stringDelimiter == '\0') {
				if ((ch == '"') || (ch == '\'')) {
					stringDelimiter = ch;
				} else if (bracketLevel <= 0) {
					if (ch == '<') {
						tagLevel += 1;
					} else if (ch == '>') {
						tagLevel -= 1;
					}
				}
				if (ch == '[') {
					bracketLevel += 1;
				} else if (ch == ']') {
					bracketLevel -= 1;
				}
			} else {
				if (ch == stringDelimiter) {
					stringDelimiter = '\0';
				}
			}
		}
	}

	private boolean checkLiteral(String literal) {
		int length = literal.length();
		for (int i = 0; i < length; i += 1) {
			if (this.readChar() != literal.charAt(i)) {
				return false;
			}
		}
		return true;
	}

	private char readChar() {
		if (charReadTooMuch != '\0') {
			char ch = this.charReadTooMuch;
			this.charReadTooMuch = '\0';
			return ch;
		}

		return this.chsReader[nIndex++];
	}

	private void scanElement(XMLElement elt) {
		StringBuilder buf = new StringBuilder();
		this.scanIdentifier(buf);
		String name = buf.toString();
		elt.setName(name);
		char ch = this.scanWhitespace();
		while ((ch != '>') && (ch != '/')) {
			buf.setLength(0);
			this.charReadTooMuch = ch;
			this.scanIdentifier(buf);
			String key = buf.toString();
			ch = this.scanWhitespace();
			if (ch != '=') {
				throw this.expectedInput("=");
			}
			this.charReadTooMuch = this.scanWhitespace();
			buf.setLength(0);
			this.scanString(buf);
			elt.setAttribute(key, buf);
			ch = this.scanWhitespace();
		}
		if (ch == '/') {
			ch = this.readChar();
			if (ch != '>') {
				throw this.expectedInput(">");
			}
			return;
		}
		buf.setLength(0);
		ch = this.scanWhitespace(buf);
		if (ch != '<') {
			this.charReadTooMuch = ch;
			this.scanPCData(buf);
		} else {
			while (true) {
				ch = this.readChar();
				if (ch == '!') {
					if (this.checkCDATA(buf)) {
						this.scanPCData(buf);
						break;
					} else {
						ch = this.scanWhitespace(buf);
						if (ch != '<') {
							this.charReadTooMuch = ch;
							this.scanPCData(buf);
							break;
						}
					}
				} else {
					if ((ch != '/') || this.ignoreWhitespace) {
						buf.setLength(0);
					}
					if (ch == '/') {
						this.charReadTooMuch = ch;
					}
					break;
				}
			}
		}
		if (buf.length() == 0) {
			while (ch != '/') {
				if (ch == '!') {
					ch = this.readChar();
					if (ch != '-') {
						throw this.expectedInput("Comment or Element");
					}
					ch = this.readChar();
					if (ch != '-') {
						throw this.expectedInput("Comment or Element");
					}
					this.skipComment();
				} else {
					this.charReadTooMuch = ch;
					XMLElement child = this.createAnotherElement();
					this.scanElement(child);
					elt.addChild(child);
				}
				ch = this.scanWhitespace();
				if (ch != '<') {
					throw this.expectedInput("<");
				}
				ch = this.readChar();
			}
			this.charReadTooMuch = ch;
		} else {
			if (this.ignoreWhitespace) {
				elt.setContent(buf.toString().trim());
			} else {
				elt.setContent(buf.toString());
			}
		}
		ch = this.readChar();
		if (ch != '/') {
			throw this.expectedInput("/");
		}
		this.charReadTooMuch = this.scanWhitespace();
		if (!this.checkLiteral(name)) {
			throw this.expectedInput(name);
		}
		if (this.scanWhitespace() != '>') {
			throw this.expectedInput(">");
		}
	}

	private char[] chsKeyBuffer = new char[10];

	private void resolveEntity(StringBuilder buf) {
		char ch = '\0';
		int nIndexKey = 0;
		while (true) {
			ch = this.readChar();
			if (ch == ';') {
				break;
			}
			this.chsKeyBuffer[nIndexKey] = ch;
			nIndexKey++;
			if (nIndexKey >= this.chsKeyBuffer.length) {
				throw this.unknownEntity(new String(this.chsKeyBuffer));
			}
		}
		String key = new String(this.chsKeyBuffer, 0, nIndexKey);
		if (this.chsKeyBuffer[0] == '#') {
			try {
				if (key.charAt(1) == 'x') {
					ch = (char) Integer.parseInt(key.substring(2), 16);
				} else {
					ch = (char) Integer.parseInt(key.substring(1), 10);
				}
			} catch (NumberFormatException e) {
				throw this.unknownEntity(key);
			}
			buf.append(ch);
		} else {
			if (key.equals("amp")) {
				buf.append('&');
			} else if (key.equals("quot")) {
				buf.append('"');
			} else if (key.equals("apos")) {
				buf.append('\'');
			} else if (key.equals("lt")) {
				buf.append('<');
			} else if (key.equals("gt")) {
				buf.append('>');
			} else {
				throw this.unknownEntity(key);
			}
		}
	}

	private XMLParseException invalidValueSet(String name) {
		String msg = "Invalid value set (entity name = \"" + name + "\")";
		return new XMLParseException(this.getName(), msg);
	}

	private XMLParseException invalidValue(String name, String value) {
		String msg = "Attribute \"" + name + "\" does not contain a valid " + "value (\"" + value + "\")";
		return new XMLParseException(this.getName(), msg);
	}

//	private XMLParseException unexpectedEndOfData() {
//		String msg = "Unexpected end of data reached";
//		return new XMLParseException(this.getName(), msg);
//	}

//	private XMLParseException syntaxError(String context) {
//		String msg = "Syntax error while parsing " + context;
//		return new XMLParseException(this.getName(), msg);
//	}

	private XMLParseException expectedInput(String charSet) {
		String msg = "Expected: " + charSet;
		return new XMLParseException(this.getName(), msg);
	}

	private XMLParseException unknownEntity(String name) {
		String msg = "Unknown or invalid entity: &" + name + ";";
		return new XMLParseException(this.getName(), msg);
	}

	public XMLElement getChildAt(int index) {
		return (XMLElement) this.children.get(index);
	}
}

package com.gavin.utils;

public class XMLParseException extends RuntimeException {

	private static final long serialVersionUID = 23620782682752178L;
	public static final int NO_LINE = -1;
	private int lineNr;

	public XMLParseException(String name, String message) {
		super("XML Parse Exception during parsing of "
				+ ((name == null) ? "the XML definition" : ("a " + name + " element")) + ": " + message);
		this.lineNr = XMLParseException.NO_LINE;
	}

	public int getLineNr() {
		return this.lineNr;
	}

}

xml简化标签，对应表

s=String
n=int
l=long
sh=short
bn=boolean
by=byte
ch=char
db=double
ft=float
dt=datetime
de=date
te=time
m=Model
所有的数组加s