关于xml文件转换成java对象以及java对象转换成xml的工具类
来源：互联网 发布：献给虚无的供物 知乎 编辑：程序博客网 时间：2024/05/21 14:51
首先说一下jdk自带的JAXB方式，它已经对xml转换成java对象以及java对象转换成xml做了很好的支持，在这里我们不谈他，朋友们可以通过其它方式去做了解。
这个工具类的编写也是偶然一个机会，项目中有比较多的报文需要处理，而且都是比较繁琐的，为了更高效的完成项目，我决定写这个工具类，当时可以说是时间仓促也可以说本人孤陋寡闻吧，竟然没有想到jdk已经有了对应处理类，呵呵，不多说了，下面我贴出源码，源码里面有test案例，后面会有个简单的解释，写的不是很好，大家一起学习进步，勿喷。
对目录结构先做个截图：
大家看到了，我用的是dom4j，版本是dom4j-1.6.1.jar，另外一个xml-apis-1.0.b2.jar是dom4j依赖包，jdk环境是1.5，当然1.5以上都是可以的
jar包 maven下载我贴一下
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
下面是源码：
package com.ymt.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE) //作用在属性上
@Retention(RetentionPolicy.RUNTIME) //在运行时有效
@Documented
@Inherited
/**
* @Desc dto转换注解
* @author xiaozhiqiang
* @Date 2015-11-7
*/
public @interface ClassConvert {
public String name() default "";
}
package com.ymt.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import com.ymt.menu.DataFormatType;
@Target(ElementType.FIELD) //作用在属性上
@Retention(RetentionPolicy.RUNTIME) //在运行时有效
@Documented
@Inherited
/**
* @Desc dto转换注解
* @author xiaozhiqiang
* @Date 2015-11-7
*/
public @interface FiledConvert {
public String name() default "";
public String defaultValue() default "";
public boolean isNotNull() default false;
public DataFormatType dataFormatType() default DataFormatType.FULL_DATE_STR;
public int roundNum() default 2;
public String listClassName() default "";
public String className() default "";
}
package com.ymt.core;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import com.ymt.annotation.ClassConvert;
import com.ymt.annotation.FiledConvert;
import com.ymt.menu.DataFormatType;
import com.ymt.exception.BusinessException;
import com.ymt.exception.ServerProcessException;
import com.ymt.util.BigDecimalUtils;
import com.ymt.util.DateUtils;
import com.ymt.util.StringUtils;
/**
* @Desc XML报文工具类
* @author xiaozhiqiang
* @Date 2015-11-12
*/
public class XMLUtil {
private static Map<String,Object> map = new HashMap<String,Object>();
private static Map<String,Object> parserXmlMap = new HashMap<String,Object>();
/**
* @Desc 每解析一个Dto缓存其属性，下次不再解析
* @param objClazz
* @throws Exception
* @author xiaozhiqiang
* @Date 2015-11-10
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
private static void invoke(Class objClazz) throws Exception{
//这里只能判断为null，不能加""的判断
if(map.get(objClazz.getName())==null){
String className = objClazz.getName();
List<Class> list = new ArrayList<Class>();
list = getClassList(objClazz,list);
if(list!=null&&list.size()>0){
for(Class clazz:list){
Field[] fields = clazz.getDeclaredFields();
for(Field field:fields){
Class fieldType = field.getType();
//如果没有配置标签，将不拼接该属性
String name = "";
String defaultValue = "";
boolean isNotNull = false;
DataFormatType dataFormatType = DataFormatType.FULL_DATE_STR;
int roundNum = 2;
if(field.isAnnotationPresent(FiledConvert.class)){
FiledConvert fieldConvert = (FiledConvert)field.getAnnotation(FiledConvert.class);
if(StringUtils.isNotEmpty(fieldConvert.name())){
name = fieldConvert.name();
}else{
//如果没有配置name 基本类型默认取属性名称
//if(isBaseType(field.getType())){
name = field.getName();
//}
}
defaultValue = fieldConvert.defaultValue();
isNotNull = fieldConvert.isNotNull();
dataFormatType = fieldConvert.dataFormatType();
roundNum = fieldConvert.roundNum();
}else{
//如果没有配置name 默认取属性名称
name = field.getName();
}
map.put(className+"."+field.getName()+".name", name);
map.put(className+"."+field.getName()+".defaultValue", defaultValue);
map.put(className+"."+field.getName()+".isNotNull", isNotNull);
if((java.util.Date.class).isAssignableFrom(fieldType)){
map.put(className+"."+field.getName()+".dataFormatType", dataFormatType);
}
if((java.lang.Double.class).isAssignableFrom(fieldType)
||(java.lang.Float.class).isAssignableFrom(fieldType)
||(java.math.BigDecimal.class).isAssignableFrom(fieldType)){
map.put(className+"."+field.getName()+".roundNum", roundNum);
}
}
}
}
//没配置标签默认为空
String annotationName = "";
if(objClazz.isAnnotationPresent(ClassConvert.class)){
ClassConvert classConvert = (ClassConvert)objClazz.getAnnotation(ClassConvert.class);
if(StringUtils.isNotEmpty(classConvert.name())){
annotationName = classConvert.name();
}else{
//配置了标签没赋值默认取类名
annotationName = objClazz.getSimpleName();
}
}else{
annotationName = objClazz.getSimpleName();
}
map.put(objClazz.getName(), annotationName);
}
}
@SuppressWarnings("rawtypes")
private static List<Class> getClassList(Class clazz, List<Class> list) {
if(clazz != Object.class ){
list.add(clazz);
getClassList (clazz.getSuperclass(),list);
}
return list;
}
/**
* @Desc 拼接报文方法
* @param obj
* @return
* @throws Exception
* @author xiaozhiqiang
* @Date 2015-11-10
*/
public static StringBuffer objectParserXml(Object obj) throws Exception {
return objectParserXml(obj,new StringBuffer(),new HashMap<String,Object>(),true);
}
/**
* @Desc 拼接报文方法
* @param obj
* @param isCheck
* @return
* @throws Exception
* @author xiaozhiqiang
* @Date 2015-11-10
*/
public static StringBuffer objectParserXml(Object obj,boolean isCheck) throws Exception {
return objectParserXml(obj,new StringBuffer(),new HashMap<String,Object>(),isCheck);
}
/**
* @Desc 拼接报文方法
* @param obj
* @param sBuffer
* @param subMap
* @param isCheck
* @return
* @throws Exception
* @author xiaozhiqiang
* @Date 2015-11-10
*/
@SuppressWarnings("rawtypes")
public static StringBuffer objectParserXml(Object obj,StringBuffer sBuffer,Map<String,Object> subMap,boolean isCheck) throws Exception {
if(obj!=null){
if (obj instanceof java.util.Collection) {
Collection collection = (Collection) obj;
Iterator iterator = collection.iterator();
//取名字
String name = (String)subMap.get("propertyName");
subMap.put("propertyName", "");
if(StringUtils.isNotEmpty(name)){
sBuffer.append("<" + name + ">"
+ "\n");
}
while(iterator.hasNext()){
Object itObj = iterator.next();
objectParserXml(itObj,sBuffer,subMap,isCheck);
}
if(StringUtils.isNotEmpty(name)){
sBuffer.append("</" + name + ">"
+ "\n");
}
} else {
Class objClazz = obj.getClass();
invoke(objClazz);
String className=obj.getClass().getName();
//优先取属性注解名称
String name = (String)subMap.get("propertyName");
subMap.put("propertyName", "");
if(StringUtils.isEmptyStr(name)){
//如果属性注解没有配置name则取类注解名称
name = (String)map.get(className);
}
if(name!=null&&name.length()>0){
sBuffer.append("<" + name + ">"
+ "\n");
}
List<Class> list = new ArrayList<Class>();
list = getClassList(objClazz,list);
if(list!=null&&list.size()>0){
for(Class clazz:list){
Field[] fields = clazz.getDeclaredFields();
for(Field field:fields){
PropertyDescriptor propertyDescriptor = null;
Method readMethod = null;
Method writeMethod = null;
try {
propertyDescriptor =new PropertyDescriptor(field.getName(),objClazz);
readMethod = propertyDescriptor.getReadMethod();
writeMethod = propertyDescriptor.getWriteMethod();
} catch (Exception e) {
// TODO Auto-generated catch block
}
if (writeMethod != null && readMethod != null) {
Object bean = readMethod.invoke(obj);
Class fieldClazz = field.getType();
String propertyName = (String)map.get(className+"."+field.getName()+".name");
String defaultValue = (String)map.get(className+"."+field.getName()+".defaultValue");
boolean isNotNull = false;
Object isNotNullObj = map.get(className+"."+field.getName()+".isNotNull");
if(isNotNullObj!=null){
isNotNull = (Boolean)isNotNullObj;
}
DataFormatType dataFormatType = DataFormatType.FULL_DATE_STR;
if((java.util.Date.class).isAssignableFrom(fieldClazz)){
Object dataFormatObj = map.get(className+"."+field.getName()+".dataFormatType");
if(dataFormatObj!=null){
dataFormatType = (DataFormatType)dataFormatObj;
}
}
int roundNum = 0;
if((java.lang.Double.class).isAssignableFrom(fieldClazz)
||(java.lang.Float.class).isAssignableFrom(fieldClazz)
||(java.math.BigDecimal.class).isAssignableFrom(fieldClazz)){
Object roundNumObj = map.get(className+"."+field.getName()+".roundNum");
if(roundNumObj!=null){
roundNum = (Integer)roundNumObj;
}
}
String value = getString(bean,getType(dataFormatType),roundNum);
if (!isBaseType(field.getType())) {
subMap.put("propertyName", propertyName);
if(isCheck&&isNotNull&&bean==null){
//抛异常
throw new BusinessException(" className:"+className+" fieldName:"+field.getName()+"要求必传,请检查数据!");
}else{
objectParserXml(bean,sBuffer,subMap,isCheck);
}
}else {
if(StringUtils.isNotEmpty(propertyName)){
if(isCheck&&isNotNull&&StringUtils.isEmptyStr(defaultValue)&&StringUtils.isEmptyStr(value)){
//抛异常
throw new BusinessException(" className:"+className+" fieldName:"+field.getName()+"要求必传,拼接时未取到值并且注解没有默认值!");
}else{
if(StringUtils.isEmptyStr(value)){
value = defaultValue;
}
sBuffer.append("<" + propertyName + ">"
+ value + "</" + propertyName
+ ">" + "\n");
}
}
}
}
}
}
}
if(name!=null&&name.length()>0){
sBuffer.append("</" + name + ">"
+ "\n");
}
}
}
return sBuffer;
}
/**
* @Desc
* @param clazz
* @return
* @author xiaozhiqiang
* @Date 2015-11-12
*/
@SuppressWarnings("rawtypes")
private static boolean isBaseType(Class clazz) {
if (clazz == String.class) {
return true;
} else if (clazz == Byte.class) {
return true;
} else if (clazz == Integer.class) {
return true;
} else if (clazz == Long.class) {
return true;
} else if (clazz == Short.class) {
return true;
} else if (clazz == Character.class) {
return true;
} else if (clazz == Date.class) {
return true;
} else if (clazz == Timestamp.class) {
return true;
} else if (clazz == Double.class) {
return true;
} else if (clazz == Float.class) {
return true;
} else if (clazz == Boolean.class) {
return true;
} else if (clazz == BigDecimal.class) {
return true;
}else if (clazz == BigInteger.class) {
return true;
}else {
return false;
}
}
/**
* @Desc
* @param obj
* @param formatType
* @param roundNum
* @return
* @author xiaozhiqiang
* @Date 2015-11-12
*/
@SuppressWarnings("rawtypes")
private static String getString(Object obj,String formatType,int roundNum) {
if (obj == null) {
return "";
} else {
Class clazz = obj.getClass();
if (clazz == Boolean.class) {
return String.valueOf(obj);
} else if (clazz == Byte.class) {
return String.valueOf(obj);
} else if (clazz == Short.class) {
return String.valueOf(obj);
} else if (clazz == Integer.class) {
return String.valueOf(obj);
} else if (clazz == Long.class) {
return String.valueOf(obj);
} else if (clazz == Float.class) {
return String.valueOf(obj);
} else if (clazz == Double.class) {
return String.valueOf(BigDecimalUtils.roundDouble((Double) obj, roundNum));
} else if (clazz == Date.class) {
return new SimpleDateFormat(formatType).format(obj);
} else if (clazz == Timestamp.class) {
return new SimpleDateFormat(formatType).format(obj);
} else if (clazz == Character.class) {
return obj.toString();
} else if (clazz == String.class) {
return obj.toString();
} else if (clazz == BigDecimal.class) {
return String.valueOf(((BigDecimal)obj).setScale(roundNum, BigDecimal.ROUND_HALF_UP));
} else if (clazz == BigInteger.class) {
return String.valueOf((BigInteger)obj);
}else {
return obj.toString();
}
}
}
/**
* @Desc 返回日期格式化的类型
* @param type
* @return
* @author xiaozhiqiang
* @Date 2015-11-9
*/
private static String getType(DataFormatType type){
String dataType = "";
switch(type){
case SIMPLE_DATE_STR:
dataType = DateUtils.SIMPLE_DATE_STR;
break;
case FULL_DATE_STR:
dataType = DateUtils.FULL_DATE_STR;
break;
case PART_DATE_STR:
dataType = DateUtils.PART_DATE_STR;
break;
case SIMPLE_RULE_DATE_STR:
dataType = DateUtils.SIMPLE_RULE_DATE_STR;
break;
case FULL_RULE_DATE_STR:
dataType = DateUtils.FULL_RULE_DATE_STR;
break;
case PART_RULE_DATE_STR:
dataType = DateUtils.PART_RULE_DATE_STR;
break;
case SMALL_PART_RULE_DATE_STR:
dataType = DateUtils.SMALL_PART_RULE_DATE_STR;
break;
case DATE_FORMAT_YYYYMMDD:
dataType = DateUtils.DATE_FORMAT_YYYYMMDD;
break;
case DATE_FORMAT_YYYYMMDDHHMM:
dataType = DateUtils.DATE_FORMAT_YYYYMMDDHHMM;
break;
case DATE_FORMAT_YYYYMMDDHHMMSS:
dataType = DateUtils.DATE_FORMAT_YYYYMMDDHHMMSS;
break;
default:
dataType = DateUtils.FULL_DATE_STR;
break;
}
return dataType;
}
/**
* @Desc 拼接报文头文件
* @param encoding
* @param append
* @return
* @author xiaozhiqiang
* @Date 2015-11-10
*/
public static String getHead(String encoding,String append){
if(StringUtils.isEmptyStr(append)){
append = "";
}
if(StringUtils.isEmptyStr(encoding)){
encoding = "GBK";
}
String head = "<?xml version=\"1.0\" encoding=\""+encoding+"\" "+append+" ?>";
return head;
}
/**
* @Desc
* @param objClazz
* @throws Exception
* @author xiaozhiqiang
* @Date 2015-11-12
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
private static void ParserXmlMap(Class objClazz) throws Exception{
//这里只能判断为null，不能加""的判断
if(parserXmlMap.get(objClazz.getName())==null){
String className = objClazz.getName();
//类名称
List<Class> list = new ArrayList<Class>();
list = getClassList(objClazz,list);
if(list!=null&&list.size()>0){
for(Class clazz:list){
Field[] fields = clazz.getDeclaredFields();
for(Field field:fields){
String fieldReName = "";
String listClassName = "";
String fieldClassName = "";
Class fieldType = field.getType();
int roundNum = 0;
DataFormatType dataFormatType = DataFormatType.FULL_DATE_STR;
if(field.isAnnotationPresent(FiledConvert.class)){
FiledConvert fieldConvert = (FiledConvert)field.getAnnotation(FiledConvert.class);
if(StringUtils.isNotEmpty(fieldConvert.name())){
fieldReName = fieldConvert.name();
}
if(StringUtils.isNotEmpty(fieldConvert.listClassName())){
listClassName = fieldConvert.listClassName();
}
if(StringUtils.isNotEmpty(fieldConvert.className())){
fieldClassName = fieldConvert.className();
}
dataFormatType = fieldConvert.dataFormatType();
roundNum = fieldConvert.roundNum();
}
if(StringUtils.isEmptyStr(fieldReName)){
fieldReName = field.getName();
}
if(StringUtils.isEmptyStr(fieldClassName)){
if((java.util.Collection.class).isAssignableFrom(fieldType)){
if((java.util.List.class).isAssignableFrom(fieldType)||
(java.util.ArrayList.class).isAssignableFrom(fieldType)){
fieldClassName = "java.util.ArrayList";
}
if((java.util.Set.class).isAssignableFrom(fieldType)||
(java.util.HashSet.class).isAssignableFrom(fieldType)){
fieldClassName = "java.util.HashSet";
}
}else{
fieldClassName = field.getType().getName();
}
}
if(StringUtils.isEmptyStr(listClassName)){
//获取泛型类型
if((java.util.Collection.class).isAssignableFrom(fieldType)){
Type genericFieldType = field.getGenericType();
if(genericFieldType instanceof ParameterizedType){
ParameterizedType tType = (ParameterizedType) genericFieldType;
Type[] fieldArgTypes = tType.getActualTypeArguments();
if(fieldArgTypes!=null){
for(Type fieldArgType : fieldArgTypes){
Class fieldArgClass = (Class) fieldArgType;
listClassName = fieldArgClass.getName();
if(StringUtils.isNotEmpty(listClassName)){
break;
}
}
}
}
}
}
parserXmlMap.put(className+"."+fieldReName+".field", field);
if((java.util.Collection.class).isAssignableFrom(fieldType)){
parserXmlMap.put(className+"."+fieldReName+".listClassName", listClassName);
}
if((java.util.Date.class).isAssignableFrom(fieldType)){
parserXmlMap.put(className+"."+fieldReName+".dataFormatType", dataFormatType);
}
if((java.lang.Double.class).isAssignableFrom(fieldType)
||(java.lang.Float.class).isAssignableFrom(fieldType)
||(java.math.BigDecimal.class).isAssignableFrom(fieldType)){
parserXmlMap.put(className+"."+fieldReName+".roundNum", roundNum);
}
if(!isBaseType(fieldType)){
parserXmlMap.put(className+"."+fieldReName+".fieldClassName", fieldClassName);
}
}
}
}
//没配置标签默认为类简单名称
String annotationName = objClazz.getSimpleName();
if(objClazz.isAnnotationPresent(ClassConvert.class)){
ClassConvert classConvert = (ClassConvert)objClazz.getAnnotation(ClassConvert.class);
if(StringUtils.isNotEmpty(classConvert.name())){
annotationName = classConvert.name();
}
}
parserXmlMap.put(objClazz.getName(), annotationName);
}
}
/**
* @Desc 将xml报文转换成对象
* @param xml 报文
* @param clazz 对象类型
* @return
* @throws Exception
* @author xiaozhiqiang
* @Date 2015-11-12
*/
@SuppressWarnings("rawtypes")
public static Object xmlParserObject(String xml,Class clazz) throws Exception {
Object obj = clazz.newInstance();
if(xml!=null && !"".equals(xml)){
Document document = DocumentHelper.parseText(xml);
Element element = document.getRootElement();
ParserXmlMap(obj.getClass());
putChirdElement(element,obj,obj);
}else{
throw new ServerProcessException("空报文，无法解析数据");
}
return obj;
}
/**
* @Desc
* @param value
* @param clazz
* @param dataFormatType
* @param roundNum
* @return
* @author xiaozhiqiang
* @Date 2015-11-12
*/
@SuppressWarnings("rawtypes")
private static Object transForObject(String value,Class clazz,DataFormatType dataFormatType,int roundNum){
try{
if (StringUtils.isEmptyStr(value)) {
return null;
} else {
if (clazz == Boolean.class) {
return new Boolean(value);
} else if (clazz == Byte.class) {
return new Byte(value);
} else if (clazz == Short.class) {
return new Short(value);
} else if (clazz == Integer.class) {
return new Integer(value);
} else if (clazz == Long.class) {
return new Long(value);
} else if (clazz == Float.class) {
return new Float(value);
} else if (clazz == Double.class) {
if(roundNum==0){
return new Double(value);
}else{
return BigDecimalUtils.roundDouble(new Double(value), roundNum);
}
} else if (clazz == Date.class) {
return DateUtils.parseToFormatDate(value,getType(dataFormatType));
} else if (clazz == Timestamp.class) {
Timestamp t = new Timestamp(System.currentTimeMillis());
t = Timestamp.valueOf(value);
return t;
} else if (clazz == Character.class) {
return value.charAt(0);
} else if (clazz == String.class) {
return value;
} else if (clazz == BigDecimal.class) {
if(roundNum==0){
return new BigDecimal(value);
}else{
return (new BigDecimal(value)).setScale(roundNum, BigDecimal.ROUND_HALF_UP);
}
}else if (clazz == BigInteger.class) {
return new BigInteger(value.substring(0, value.lastIndexOf(".")));
}else {
return value;
}
}
}catch(Exception e){
e.printStackTrace();
return null;
}
}
/**
* @Desc
* @param element
* @param subObj
* @param bean
* @throws Exception
* @author xiaozhiqiang
* @Date 2015-11-12
*/
@SuppressWarnings("rawtypes")
private static void putChirdElement(Element element,Object subObj,Object bean) throws Exception{
if(subObj!=null){
Class subClazz = subObj.getClass();
String className = subClazz.getName();
if (element.isTextOnly()) {
Field field = (Field)parserXmlMap.get(className+"."+element.getName()+".field");
DataFormatType dataFormatType = (DataFormatType)parserXmlMap.get(className+"."+element.getName()+".dataFormatType");
Integer roundNum = (Integer)parserXmlMap.get(className+"."+element.getName()+".roundNum");
String value = element.getText();
Object valueObj =null;
if(field!=null){
valueObj = transForObject(value,field.getType(),dataFormatType,roundNum==null?0:roundNum);
}
setValue(valueObj,field,subObj);
} else {
if(subObj instanceof java.util.Collection){
Collection.class.getMethod("add", Object.class).invoke(subObj,bean);
}else{
if(subClazz!=bean.getClass()){
Field field = (Field)parserXmlMap.get(className+"."+element.getName()+".field");
setValue(bean,field,subObj);
}
}
//初始化
ParserXmlMap(bean.getClass());
Iterator chird = element.elementIterator();
while (chird.hasNext()) {
Element chirdElement = (Element) chird.next();
Object chirdBean = null;
if(!chirdElement.isTextOnly()){
if(bean instanceof java.util.Collection){
//Collection 必须加上注解定义泛型类
String listClassName = (String)parserXmlMap.get(className+"."+element.getName()+".listClassName");
if(StringUtils.isEmptyStr(listClassName)){
throw new BusinessException(className+"."+element.getName()+"没有定义泛型类名");
}
chirdBean = Class.forName(listClassName).newInstance();
}else{
String fieldClassName = (String)parserXmlMap.get(bean.getClass().getName()+"."+chirdElement.getName()+".fieldClassName");
if(StringUtils.isEmptyStr(fieldClassName)){
throw new BusinessException(bean.getClass().getName()+"."+chirdElement.getName()+"没有取到反射类");
}
chirdBean = Class.forName(fieldClassName).newInstance();
}
}
putChirdElement(chirdElement,bean,chirdBean);
}
}
}
}
/**
* @Desc
* @param value
* @param field
* @param obj
* @throws Exception
* @author xiaozhiqiang
* @Date 2015-11-12
*/
private static void setValue(Object value,Field field,Object obj) throws Exception{
if(field!=null&&obj!=null){
PropertyDescriptor propertyDescriptor = null;
Method setter = null;
try {
propertyDescriptor =new PropertyDescriptor(field.getName(),obj.getClass());
setter = propertyDescriptor.getWriteMethod();
} catch (Exception e) {
// TODO Auto-generated catch block
}
if(setter!=null){
setter.setAccessible(true);//可能为私有的则不能访问，为了能访问设置为TRUE
setter.invoke(obj,value);//把引用对象注入到属性
}
}
}
}
package com.ymt.exception;
public class BusinessException extends Exception {
private static final long serialVersionUID = 521006280506457924L;
public BusinessException(String msg){
super(msg);
}
}
package com.ymt.exception;
/**
* 自定义异常，服务执行过程中出现异常，统一抛出该异常
* @author
*
*/
public class ServerProcessException extends Exception {
/**
*
*/
private static final long serialVersionUID = 865342417138850272L;
public ServerProcessException(String msg){
super(msg);
}
}
package com.ymt.menu;
/**
* @Desc
* @author xiaozhiqiang
* @Date 2015-11-9
*/
public enum DataFormatType {
/**yyyy-MM-dd*/
SIMPLE_DATE_STR,
/**yyyy-MM-dd HH:mm:ss*/
FULL_DATE_STR,
/**yyyy-MM-dd HH:mm*/
PART_DATE_STR,
/**yyyy/MM/dd*/
SIMPLE_RULE_DATE_STR,
/**yyyy/MM/dd HH:mm:ss*/
FULL_RULE_DATE_STR,
/**yyyy/MM/dd HH:mm*/
PART_RULE_DATE_STR,
/**HH:mm*/
SMALL_PART_RULE_DATE_STR,
/**yyyyMMdd*/
DATE_FORMAT_YYYYMMDD,
/**yyyyMMddHHmm*/
DATE_FORMAT_YYYYMMDDHHMM,
/**yyyyMMddHHmmss*/
DATE_FORMAT_YYYYMMDDHHMMSS
}
package com.ymt.util.consts;
/**
*
* 功能描述:常用的正则表达式，用于匹配字符串等
*
* @author xiaozhiqiang
* @date 2015-11-18
*/
public class RegexStrings {
/** 完整日期，支持“/”格式，年月日时分秒，匹配例如2013-06-18 20:50:00,带连字符“-”和“:” */
public final static String REG_RULE_FULL_DATE = "^(19|20)\\d{2}[/]([0]{0,1}[1-9]|[1][0-2])[/]([0]{0,1}[1-9]|[1-2][0-9]|[3][0-1])[ ](([0]{0,1}[0-9]|[1][0-9]|[2][0-3])([:](([0]{0,1}[0-9])|([1-5][0-9]))){2})";
/** 日期，年月日，支持“/”格式，匹配例如2013-06-18或20130618的格式，带或者不带连字符“-” */
public final static String REG_RULE_DATE = "^(19|20)\\d{2}[/]{0,1}([0]{0,1}[1-9]|[1][0-2])[/]{0,1}([0]{0,1}[1-9]|[1-2][0-9]|[3][0-1])$";
/** 年月日时分，支持“/”格式，匹配例如2013-06-18 20:50,带连字符“-”和“:” */
public final static String REG_RULE_PART_DATE = "^(19|20)\\d{2}[/]([0]{0,1}[1-9]|[1][0-2])[/]([0]{0,1}[1-9]|[1-2][0-9]|[3][0-1])[ ](([0]{0,1}[0-9]|[1][0-9]|[2][0-3])([:](([0]{0,1}[0-9])|([1-5][0-9]))))";
/** 日期，年月日，匹配例如2013-06-18的格式，带连字符“-” */
public final static String REG_DATE_WITH_CONNECTOR = "^(19|20)\\d{2}[-]([0]{0,1}[1-9]|[1][0-2])[-]([0]{0,1}[1-9]|[1-2][0-9]|[3][0-1])$";
/** 日期，年月日，匹配例如2013-06-18或20130618的格式，带或者不带连字符“-” */
public final static String REG_DATE = "^(19|20)\\d{2}[-]{0,1}([0]{0,1}[1-9]|[1][0-2])[-]{0,1}([0]{0,1}[1-9]|[1-2][0-9]|[3][0-1])$";
/** 时间，时分秒，匹配例如20:50:00 */
public final static String REG_TIME = "^[0]{0,1}[0-9]|[1][0-9]|[2][0-3]([:](([0]{0,1}[0-9])|([1-5][0-9]))){2}$";
/** 完整日期，年月日时分秒，匹配例如2013-06-18 20:50:00,带连字符“-”和“:” */
public final static String REG_FULL_DATE = "^(19|20)\\d{2}[-]([0]{0,1}[1-9]|[1][0-2])[-]([0]{0,1}[1-9]|[1-2][0-9]|[3][0-1])[ ](([0]{0,1}[0-9]|[1][0-9]|[2][0-3])([:](([0]{0,1}[0-9])|([1-5][0-9]))){2})";
/** 年月日时分，匹配例如2013-06-18 20:50,带连字符“-”和“:” */
public final static String REG_PART_DATE = "^(19|20)\\d{2}[-]([0]{0,1}[1-9]|[1][0-2])[-]([0]{0,1}[1-9]|[1-2][0-9]|[3][0-1])[ ](([0]{0,1}[0-9]|[1][0-9]|[2][0-3])([:](([0]{0,1}[0-9])|([1-5][0-9]))))";
}
package com.ymt.util;
import java.math.BigDecimal;
public class BigDecimalUtils {
public static BigDecimal min(Object a, Object b) {
BigDecimal i = new BigDecimal(String.valueOf(a));
BigDecimal j = new BigDecimal(String.valueOf(b));
return i.compareTo(j) < 0 ? i : j;
}
public static BigDecimal min(BigDecimal a, BigDecimal b) {
return a.compareTo(b) < 0 ? a : b;
}
public static BigDecimal max(BigDecimal a, BigDecimal b) {
return a.compareTo(b) > 0 ? a : b;
}
public static void executeAll(Object... obj) {
}
public static BigDecimal toPercent(BigDecimal a) {
return a.divide(new BigDecimal("100"));
}
public static BigDecimal transNullToZERO(BigDecimal a) {
return a == null ? BigDecimal.ZERO : a;
}
public static BigDecimal transNullStringToZERO(String a) {
if(StringUtils.isEmptyStr(a)){
return BigDecimal.ZERO;
}
return new BigDecimal(a.trim());
}
/**
*
* 功能描述：负数转0
*@author xiaozhiqiang
*@date 2014-3-10
*@param a
*@return
*/
public static BigDecimal transMinusToZERO(BigDecimal a) {
return a.compareTo(BigDecimal.ZERO)<0?BigDecimal.ZERO: a;
}
public static BigDecimal getScaleRoundHalfUp(BigDecimal dutyPayAmount, int num) {
return dutyPayAmount.setScale(num, BigDecimal.ROUND_HALF_UP);
}
/**
* 由于java语言中对浮点数的二进制转换会产生问题，因此在将浮点数转换为BigDecimal类型时需要先将浮点数转换为String型
* @author xiaozhiqiang
* @date 2013-12-20
* @param num
* @return BigDecimal
*/
public static BigDecimal getExactBigDicimal(double num) {
String numStr = num + "";
return new BigDecimal(numStr);
}
/**
* 校验是否为小于等于零的数字
* @author xiaozhiqiang
* @date 2014-01-13
* @param num
* @return boolean
*/
public static boolean isNotPlus(BigDecimal number) {
if (number == null) {
return true;
}
if (number.compareTo(new BigDecimal(0)) <= 0) {
return true;
}
return false;
}
/**
*
* 功能描述：校验是否大于零的数字
*@author xiaozhiqiang
*@date 2014-10-10
*@param number
*@return
*/
public static boolean isGreaterZero(BigDecimal number) {
if (number == null) {
return false;
}
if (number.compareTo(new BigDecimal(0)) <= 0) {
return false;
}
return true;
}
/**
* 功能描述：将可能为空的BigDecimal转为BigDecimal
* @date 2014年1月23日
* @return BigDecimal
*/
public static BigDecimal convertBigDecimal(BigDecimal num) {
if (num == null) {
num = new BigDecimal(0);
}
return num;
}
/**
* 功能描述:将可能为空的Integer转为0
* @param integer
* @return
*/
public static Integer convertInteger(Integer integer){
if(integer == null){
integer = new Integer(0);
}
return integer;
}
/**
* 功能描述：将BigDecimal转为BigDecimal,允许自己定义异常时的返回值
* @date 2014年1月23日
* @return BigDecimal
*/
public static BigDecimal convertBigDecimal(BigDecimal num, BigDecimal bd) {
if (num == null) {
return bd;
}
return num;
}
/**
* 功能描述：将BigDecimal转为String
* @date 2014年1月24日
* @return String
*/
public static String covertBigDecimalToString(BigDecimal num) {
if (num == null) {
return "";
}
return num.toString();
}
/**
* 功能描述：将BigDecimal转为double
*
* @date 2014年2月14日
* @return String
*/
public static double toDouble(BigDecimal num){
if(num == null){
return 0;
}
return num.doubleValue();
}
/**
* 判断bd1是否小于bd2
* @author xiaozhiqiang
* @date 2013-12-18
* @param bd1
* @param bd2
* @return boolean
*
*/
public static boolean compareBigDecimalMinus(BigDecimal bd1, BigDecimal bd2) {
boolean returnFlag = false;
int i1 = bd1.compareTo(bd2);
if (i1 < 0) {
returnFlag = true;
}
return returnFlag;
}
/**
* 判断bd1是否小于等于bd2
* @author xiaozhiqiang
* @date 2013-12-18
* @param bd1
* @param bd2
* @return boolean
*
*/
public static boolean compareBigDecimalMinusEq(BigDecimal bd1, BigDecimal bd2) {
boolean returnFlag = false;
int i1 = bd1.compareTo(bd2);
if (i1 < 0 || i1==0) {
returnFlag = true;
}
return returnFlag;
}
/**
* 功能描述：判断bd1是否大于bd2
* @author xiaozhiqiang
* @date 2014-5-15
* @param bd1
* @param bd2
* @return
*/
public static boolean compareBigDecimalPlus(BigDecimal bd1,BigDecimal bd2){
boolean returnFlag = false;
int i1 = bd1.compareTo(bd2);
if (i1 > 0) {
returnFlag = true;
}
return returnFlag;
}
/**
*
* 功能描述：三目运算
*@author xiaozhiqiang
*@date 2014-3-2
*@param flag
*@param amount
*@return
*/
public static BigDecimal ternaryConditionalCalc (boolean flag,BigDecimal amount) {
return flag?amount:BigDecimal.ZERO;
}
/**
* 功能描述：判断BigDecimal是否为null
* @author xiaozhiqiang
* @date 2014-3-13
* @param bigDecimal
* @return
*/
public static boolean isNullBigDecimal(BigDecimal bigDecimal){
boolean result = false;
if(bigDecimal == null){
result = true;
}
return result;
}
/**
* 功能描述：判断BigDecimal是否大于或等于零，为null时返回false
* @author xiaozhiqiang
* @date 2014-3-13
* @param bigDecimal
* @return
*/
public static boolean isGreaterOrEqualToZero(BigDecimal bigDecimal){
boolean result = false;
if(BigDecimalUtils.isNullBigDecimal(bigDecimal)){
return result;
}
if(bigDecimal.compareTo(BigDecimal.ZERO) >= 0) {
result = true;
}
return result;
}
/**
*
* 功能描述：将String类型转换为BigDecimal类型
* 如果String为空或null则返回BigDecimal.ZERO
* @author xiaozhiqiang
* @date 2013-10-26
* @param bigDecimalStr
* @return
*/
public static BigDecimal getBigDecimal(String bigDecimalStr){
BigDecimal result = BigDecimal.ZERO;
if(!StringUtils.isEmptyStr(bigDecimalStr)){
result = new BigDecimal(bigDecimalStr);
}
return result;
}
/**
*
* 功能描述：如果bigDecimal等于0则返回1
* 否则返回bigDecimal
* @author xiaozhiqiang
* @date 2014-04-15
* @param bigDecimal
* @return
*/
public static BigDecimal transZEROToONE(BigDecimal bigDecimal) {
if(BigDecimal.ZERO.compareTo(bigDecimal) == 0){
return BigDecimal.ONE;
}else{
return bigDecimal;
}
}
/**
*
* 功能描述：判断两个BigDecimal 是否相等
* @author xiaozhiqiang
* @date 2014-07-09
* @param BigDecimal one, BigDecimal two
* @return
*/
public static boolean isEqual(BigDecimal one, BigDecimal two){
return one.compareTo(two) == 0 ? true : false;
}
/**
*
* 功能描述：对Double类型进行四舍五入
* @author xiaozhiqiang
* @date 2015-8-31
* @param one
* @param size 精确大小
* @return
*/
public static double roundDouble(double one, int size){
BigDecimal num = new BigDecimal(one).setScale(size, BigDecimal.ROUND_HALF_UP);
return toDouble(num);
}
/**
* @Desc 对BigDecimal类型进行四舍五入并返回BigDecimal
* @param one
* @param size
* @return
* @author xiaozhiqiang
* @Date 2015-11-27
*/
public static BigDecimal roundBigDecimal(BigDecimal one, int size){
return one.setScale(size, BigDecimal.ROUND_HALF_UP);
}
}
package com.ymt.util;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import com.ymt.util.consts.RegexStrings;
public class DateUtils {
public static final String SIMPLE_DATE_STR = "yyyy-MM-dd";
public static final String FULL_DATE_STR = "yyyy-MM-dd HH:mm:ss";
public static final String PART_DATE_STR = "yyyy-MM-dd HH:mm";
public static final String SIMPLE_RULE_DATE_STR = "yyyy/MM/dd";
public static final String FULL_RULE_DATE_STR = "yyyy/MM/dd HH:mm:ss";
public static final String PART_RULE_DATE_STR = "yyyy/MM/dd HH:mm";
public static final String SMALL_PART_RULE_DATE_STR = "HH:mm";
public static final String DATE_FORMAT_YYYYMMDD = "yyyyMMdd";
public static final String DATE_FORMAT_YYYYMMDDHHMM = "yyyyMMddHHmm";
public static final String DATE_FORMAT_YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
/**
*
* 功能描述：根据指定格式解析日期格式
*@author xiaozhiqiang
*@date 2014-3-19
*@param dateStr
*@param formatStr
*@return
*@throws ParseException
*/
public static Date parseToFormatDate(String dateStr,String formatStr) throws ParseException{
if(StringUtils.isEmptyStr(dateStr)||StringUtils.isEmptyStr(formatStr)){
return null;
}
DateFormat dateFormat = new SimpleDateFormat(formatStr);
return dateFormat.parse(dateStr);
}
/**
*
* 功能描述:将String类型的字符串转换成为Date类型，可转换yyyy-MM-dd和yyyy-MM-dd HH:mm:ss两种格式
*
* @author xiaozhiqiang
* @date 2013-6-19
* @param dateString
* 待转换的字符串
* @return Date类型
* @throws ParseException
*/
public static Date parseToDate(String dateString) throws ParseException {
if (dateString == null)
throw new IllegalArgumentException("dateString should not be null");
DateFormat dateFormat = new SimpleDateFormat(SIMPLE_DATE_STR);
DateFormat fullDateFormat = new SimpleDateFormat(FULL_DATE_STR);
DateFormat partDateFormat = new SimpleDateFormat(PART_DATE_STR);
DateFormat dateRullFormat = new SimpleDateFormat(SIMPLE_RULE_DATE_STR);
DateFormat fullRullDateFormat = new SimpleDateFormat(FULL_RULE_DATE_STR);
DateFormat partRullDateFormat = new SimpleDateFormat(PART_RULE_DATE_STR);
if (dateString.matches(RegexStrings.REG_FULL_DATE)) {
return fullDateFormat.parse(dateString);
} else if (dateString.matches(RegexStrings.REG_DATE)) {
return dateFormat.parse(dateString);
} else if (dateString.matches(RegexStrings.REG_PART_DATE)) {
return partDateFormat.parse(dateString);
} else if (dateString.matches(RegexStrings.REG_RULE_FULL_DATE)) {
return fullRullDateFormat.parse(dateString);
} else if (dateString.matches(RegexStrings.REG_RULE_DATE)) {
return dateRullFormat.parse(dateString);
} else if (dateString.matches(RegexStrings.REG_RULE_PART_DATE)) {
return partRullDateFormat.parse(dateString);
} else {
return null;
}
}
}
package com.ymt.util;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
/**
* @Desc
* @author xiaozhiqiang
* @Date 2015-11-10
*/
public class StreamUtils {
/**
* @Desc
* @param is
* @param encoding
* @param lineAppend
* @return
* @throws Exception
* @author xiaozhiqiang
* @Date 2015-11-10
*/
public static String convertStreamToString(InputStream is,String encoding,String lineAppend) throws Exception{
BufferedReader reader = null;
if(encoding!=null&&!"".equals(encoding)){
reader = new BufferedReader(new InputStreamReader(is,encoding));
}else{
reader = new BufferedReader(new InputStreamReader(is));
}
StringBuffer sBuffer = new StringBuffer();
String line = null;
try {
while ((line = reader.readLine()) != null) {
sBuffer.append(line);
if(lineAppend!=null&&!"".equals(lineAppend)){
sBuffer.append(lineAppend);
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return sBuffer.toString();
}
/**
* @Desc
* @param is
* @return
* @throws Exception
* @author xiaozhiqiang
* @Date 2015-11-10
*/
public static String convertStreamToString(InputStream is) throws Exception{
return convertStreamToString(is,null,null);
}
}
package com.ymt.util;
/**
* 字符串相关方法
*
*/
public class StringUtils {
/**
* 功能描述:判断字符串是否为空或者为空白串
* @author xiaozhiqiang
* @date 2013-6-17
* @param str 待判断字符串
* @return 判断结果
*/
public static boolean isEmptyStr(Object obj) {
if (null == obj || "".equals(obj.toString()) || "".equals(obj.toString().trim())) {
return true;
} else
return false;
}
/**
* 功能描述:判断字符串是否非空
* @author xiaozhiqiang
* @date 2013-6-17
* @param str 待判断字符串
* @return 判断结果
*/
public static boolean isNotEmpty(String str) {
return !isEmptyStr(str);
}
/**
* 功能描述:判断字符串是否为空或者为空白串
* @author xiaozhiqiang
* @date 2013-6-17
* @param str 待判断字符串
* @return 判断结果
*/
public static boolean isEmptyStr(String str) {
if (null == str || "".equals(str.trim())) {
return true;
} else
return false;
}
}
===========以下是测试部分=============
package test.bean;
import com.ymt.annotation.ClassConvert;
import com.ymt.annotation.FiledConvert;
//@ClassConvert
public class Classroom {
//@FiledConvert
private Integer id;
//@FiledConvert
private String name;
//@FiledConvert
private Integer grade;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getGrade() {
return grade;
}
public void setGrade(Integer grade) {
this.grade = grade;
}
public Classroom(Integer id, String name, Integer grade) {
super();
this.id = id;
this.name = name;
this.grade = grade;
}
public Classroom() {
super();
}
}
package test.bean;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.Set;
import com.ymt.annotation.ClassConvert;
import com.ymt.annotation.FiledConvert;
import com.ymt.menu.DataFormatType;
@ClassConvert
public class Student {
//@FiledConvert
private Integer id;
//@FiledConvert(name="NAME")
private String name;
@FiledConvert(roundNum=4)
private BigDecimal height;
//@FiledConvert
private Integer age;
@FiledConvert(dataFormatType=DataFormatType.SIMPLE_DATE_STR ,isNotNull=true)
private Date birthday;
//@FiledConvert
private Classroom classroom;
//@FiledConvert(name="teachers")
private List<Teacher> teachers;
//@FiledConvert
private Set<Classroom> classrooms;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Classroom getClassroom() {
return classroom;
}
public void setClassroom(Classroom classroom) {
this.classroom = classroom;
}
public List<Teacher> getTeachers() {
return teachers;
}
public void setTeachers(List<Teacher> teachers) {
this.teachers = teachers;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public Set<Classroom> getClassrooms() {
return classrooms;
}
public void setClassrooms(Set<Classroom> classrooms) {
this.classrooms = classrooms;
}
public BigDecimal getHeight() {
return height;
}
public void setHeight(BigDecimal height) {
this.height = height;
}
public Student() {
super();
}
public Student(Integer id, String name,Integer age, Classroom classroom) {
super();
this.id = id;
this.name = name;
this.age = age;
this.classroom = classroom;
}
}
package test.bean;
import java.util.Date;
import com.ymt.annotation.ClassConvert;
import com.ymt.annotation.FiledConvert;
@ClassConvert
public class Teacher {
@FiledConvert
private String id;
@FiledConvert
private String name;
@FiledConvert
private Date birthday;
@FiledConvert
private String course;
public Teacher() {
super();
}
public Teacher(String id, String name, Date birthday, String course) {
super();
this.id = id;
this.name = name;
this.birthday = birthday;
this.course = course;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getCourse() {
return course;
}
public void setCourse(String course) {
this.course = course;
}
}
package test.main;
import java.io.InputStream;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.junit.Test;
import test.bean.Classroom;
import test.bean.Student;
import test.bean.Teacher;
import com.ymt.core.XMLUtil;
import com.ymt.util.StreamUtils;
public class XmlTest {
@Test
public void ObjectParserXmlTest() throws Exception{
Classroom classroom = new Classroom(1, "软件工程", 4);
Student student = new Student(101, "张三", 22,classroom);
student.setBirthday(new Date());
student.setHeight(new BigDecimal("1.7512"));
List<Teacher> teachers = new ArrayList<Teacher>();
Teacher teacher1 = new Teacher("1", "王老师", new Date(), "语文");
Teacher teacher2 = new Teacher("2", "李老师", new Date(), "数学");
teachers.add(teacher1);
teachers.add(teacher2);
student.setTeachers(teachers);
Set<Classroom> classrooms = new HashSet<Classroom>();
Classroom classroom1 = new Classroom(3, "软件工程3", 5);
Classroom classroom2 = new Classroom(4, "软件工程4", 6);
classrooms.add(classroom1);
classrooms.add(classroom2);
student.setClassrooms(classrooms);
StringBuffer sBuffer = XMLUtil.objectParserXml(student,false);
System.out.println(XMLUtil.getHead("utf-8","standalone=\"yes\"")+"\n"+sBuffer.toString());
}
@Test
public void XmlParserObjectTest() throws Exception{
InputStream is = this.getClass().getResourceAsStream("test.xml");
String content = StreamUtils.convertStreamToString(is,"utf-8","");
Student student = (Student)XMLUtil.xmlParserObject(content, Student.class);
System.out.println(student.toString());
}
}
最后是一个测试的xml
将下面内容复制到test.xml中，将test.xml放在test.main包下
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Student>
<id>101</id>
<name>张三</name>
<height>1.7512</height>
<age>22</age>
<birthday>2016-08-19</birthday>
<classroom>
<id>1</id>
<name>软件工程</name>
<grade>4</grade>
</classroom>
<teachers>
<Teacher>
<id>1</id>
<name>王老师</name>
<birthday>2016-08-19 14:43:46</birthday>
<course>语文</course>
</Teacher>
<Teacher>
<id>2</id>
<name>李老师</name>
<birthday>2016-08-19 14:43:46</birthday>
<course>数学</course>
</Teacher>
</teachers>
<classrooms>
<Classroom>
<id>3</id>
<name>软件工程3</name>
<grade>5</grade>
</Classroom>
<Classroom>
<id>4</id>
<name>软件工程4</name>
<grade>6</grade>
</Classroom>
</classrooms>
</Student>
简单说下com.ymt.annotation包下面两个注解的作用
ClassConvert注解在类名上面，可以自定义对象转换成xml时节点名称，当然也可以在xml转换成对象时起作用，注解的name名称和xml节点的名称一致即可
FiledConvert注解
name 可自定义解析时的名称
defaultValue默认值，只对对象转换xml时有效
isNotNull 是否不为空，当调用XMLUtil.objectParserXml(student,true);后一个参数传值为true时，对象转换成xml会对该属性校验，如果为空或空字符并且没有给默认值，系统将会给出一个异常
DataFormatType 日期类型格式化，只对对象转换xml时有效
roundNum 小数点后四舍五入的位数
listClassName 当对象属性中包含List或Set时，应该对其使用泛型，如果没有使用泛型，应该使用此属性来标注list或set对象中泛型对象位置
className 这个可以不用，目前默认支持ArrayList和HashSet两种集合，这个可以做扩展，比如你先用LinkedList，那className必须配置等于java.util.LinkedList，当然集合类必须是实现了java.util.Collection接口的。
- 关于xml文件转换成java对象以及java对象转换成xml的工具类
- Java对象转换成XML
- Java对象转换成XML
- Java 对象和xml转换工具类
- SAX 解析XML文件:将XML转换成Java对象
- JAVA对象转换XML
- java xml 转换对象
- 96 Android 将XML文件转换成Java对象
- 使用XmlPullParser把xml文件转换成java bean对象
- Java对象转换XML文件：XStream+XPP
- java对象与xml文件转换
- 关于Java对象和XML之间的相互转换
- java关于对象(javabean)与xml之间的相互转换
- 使用XStream java对象转换成XML遇到的问题
- java 反射的应用（将一个java对象转换成一个xml文件）
- Java对象和XML转换
- java对象转换成xml,javascript对象字符串， xml转换成java对象，支持任意类型，支持深层转换
- 用jaxb通过XSD生成Java类，java对象转换成xml文件
- 利用spring aop 处理异常
- ActiveMQ -- 消息持久化
- 安卓开发之你该知道的Linux命令
- 数据结构实验之查找六：顺序查找
- c3p0异常，exception is java.lang.NoClassDefFoundError: com/mchange/v2/log/jdk14logging/ForwardingLogger
- 关于xml文件转换成java对象以及java对象转换成xml的工具类
- sftp
- Android中home键监听一个好用的方法。（按home键后播放器停止播放）
- 回家吃饭Android客户端整理后总结
- iOS 调用系统铃声及震动
- ListView常用扩展之一-具有弹性的ListView
- 微信订阅号，先运营，再技术
- 从B 树、B+ 树、B* 树谈到R 树
- python __call__ 函数
