使用dom4j將bean轉換成xml,將xml轉換成bean,將list轉換成xml

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
 
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

import com.longtop.cls.frm.util.StringUtil;
import com.sun.jmx.snmp.Timestamp;

public class XmlUtil {
    
        private static final String ATTR_ID = "id";// bean的id屬性
        private static final int NULL_ID = -1;
        
        
        
        /**
         * 將bean轉換成xml
         * @param <T>
         * @param bean
         * @param el
         * @return
         */
        public static <T> Element parseBean(T t, Class<?> bean,Element el) {
            
            Field[] fields = bean.getDeclaredFields();// 獲得bean的所有屬性
 
            for (Field field : fields) {// 迭代屬性並且賦值
                int mod = field.getModifiers();
                if (Modifier.isFinal(mod) || Modifier.isStatic(mod)
                        || Modifier.isPublic(mod)) {
                    continue;
                }
                field.setAccessible(true);// 打破封裝性
                String attr_name = GetAttrName(bean, field);// 獲取bean屬性對應的xml文件中的名字
                String attr_value = GetAttrValue(field, t);// 獲取此屬性對應的值
                // System.out.println(attr_name+"="+attr_value);
                el.addElement(attr_name).setText(attr_value);// 創建屬性並賦值
            }
     
            return el;
        }
        
        /**
         * xml字符串轉換成bean對象
         * 
         * @param xmlStr xml字符串
         * @param clazz 待轉換的class
         * @return 轉換後的對象
         */
        public static Object xmlStrToBean(Element xmlStr, Class clazz) {
            Object obj = null;
            try {
                // 將xml格式的數據轉換成Map對象
                Map<String, Object> map = xmlStrToMap(xmlStr);
                //將map對象的數據轉換成Bean對象
                obj = mapToBean(map, clazz);
            } catch(Exception e) {
                e.printStackTrace();
            }
            return obj;
        }
        /**
         * 將List<bean>轉換成xml
         * @param <T>
         * @param list
         * @param bean
         * @return
         */
        public static <T> String parseList(List<T> list, Class<?> bean) {
            Document document = DocumentHelper.createDocument();// 獲取document
            document.setXMLEncoding("UTF-8");// 設置編碼
            Element root = document.addElement(GetRootName(bean));// 創建根元素
     
            Field[] fields = bean.getDeclaredFields();// 獲得bean的所有屬性
            for (T elem : list) {// 開始迭代傳入的list
                Element child = root.addElement(GetElemName(bean));// 創建子元素
     
                for (Field field : fields) {// 迭代屬性並且賦值
                    int mod = field.getModifiers();
                    if (Modifier.isFinal(mod) || Modifier.isStatic(mod)
                            || Modifier.isPublic(mod)) {
                        continue;
                    }
                    field.setAccessible(true);// 打破封裝性
                    String attr_name = GetAttrName(bean, field);// 獲取bean屬性對應的xml文件中的名字
                    String attr_value = GetAttrValue(field, elem);// 獲取此屬性對應的值
                    System.out.println(attr_name+"="+attr_value);
                    child.addElement(attr_name).setText(attr_value);// 創建屬性並賦值
                }
            }
     
            return document.asXML();
        }
        
        
        // 根據bean自動構建xml的root名字
        public static String GetRootName(Class<?> bean) {
            //String root_name = "_" + bean.getSimpleName().toLowerCase() + "s";
            return null;
        }
     
        // 根據bean自動構建xml的child名字
        public static String GetElemName(Class<?> bean) {
            //String elem_name = "_" + bean.getSimpleName().toLowerCase();
            return null;
        }
     
        // 根據bean和field構建xml中child的attribute名字
        public static String GetAttrName(Class<?> bean, Field field) {
            String attr_name =field.getName();
            return attr_name;
        }
     
        // 根據field與element獲取此field對應的value
        @SuppressWarnings("finally")
        public static <T> String GetAttrValue(Field field, T elem) {
            String value = "";
            try {
                Class<?> eType = elem.getClass() ;
                Class<?> type = field.getType();// 獲取此field的類型
                /*
                 * 下面依次處理 八種基本類型 Timestamp類型 其他類型(帶有id屬性的bean類型)
                 */
                if (type.equals(Byte.class) || type.equals(byte.class)) {
                    value = field.getByte(elem) + "";
                } else if (type.equals(Short.class) || type.equals(short.class)) {
                    value = field.getShort(elem) + "";
                } else if (type.equals(Integer.class) || type.equals(int.class)) {
                    value = field.getInt(elem) + "";
                } else if (type.equals(Long.class) || type.equals(long.class)) {
                    value = field.getLong(elem) + "";
                } else if (type.equals(Float.class) || type.equals(float.class)) {
                    value = field.getFloat(elem) + "";
                } else if (type.equals(Double.class) || type.equals(double.class)) {
                    value = field.getDouble(elem) + "";
                } else if (type.equals(Boolean.class) || type.equals(boolean.class)) {
                    value = field.getBoolean(elem) + "";
                } else if (type.equals(String.class)) {
                    value = (String) field.get(elem);
                } else if (type.equals(Timestamp.class)) {
                    value = ((Timestamp) field.get(elem)).getDateTime() + "";
                } else {
                    // 如果這個類型有id這個屬性，說明它是個外鍵
                    Field attr_id = type.getDeclaredField(ATTR_ID);
                    // 並且此屬性不爲null
                    if (attr_id != null && field.get(elem) != null) {
                        attr_id.setAccessible(true);
                        value = attr_id.getInt(field.get(elem)) + "";
                    }
                }
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } finally {
                return value == null ? "" : value;
            }
        }
     
        public static <T> void SetAttrValue(Field field, T elem, String value) {
            try {
                Class<?> type = field.getType();
                if (type.equals(Byte.class) || type.equals(byte.class)) {
                    try {
                        field.setByte(elem, Byte.parseByte(value));
                    } catch (NumberFormatException e) {
                        // 數字格式化異常，未做任何處理
                    }
                } else if (type.equals(Short.class) || type.equals(short.class)) {
                    try {
                        field.setShort(elem, Short.parseShort(value));
                    } catch (NumberFormatException e) {
                        // 數字格式化異常，未做任何處理
                    }
                } else if (type.equals(Integer.class) || type.equals(int.class)) {
                    try {
                        field.setInt(elem, Integer.parseInt(value));
                    } catch (NumberFormatException e) {
                        field.setInt(elem, NULL_ID);
                    }
                } else if (type.equals(Long.class) || type.equals(long.class)) {
                    try {
                        field.setLong(elem, Long.parseLong(value));
                    } catch (NumberFormatException e) {
                        // 數字格式化異常，未做任何處理
                    }
                } else if (type.equals(Float.class) || type.equals(float.class)) {
                    try {
                        field.setFloat(elem, Float.parseFloat(value));
                    } catch (NumberFormatException e) {
                        // 數字格式化異常，未做任何處理
                    }
                } else if (type.equals(Double.class) || type.equals(double.class)) {
                    try {
                        field.setDouble(elem, Double.parseDouble(value));
                    } catch (NumberFormatException e) {
                        // 數字格式化異常，未做任何處理
                    }
                } else if (type.equals(Boolean.class) || type.equals(boolean.class)) {
                    try {
                        field.setBoolean(elem, Boolean.parseBoolean(value));
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                } else if (type.equals(String.class)) {
                    field.set(elem, value);
                } else if (type.equals(Timestamp.class)) {
                    try {
                        field.set(elem, new Timestamp(Long.parseLong(value)));
                    } catch (NumberFormatException e) {
                        // 如果格式化異常，說明這個Timestamp是個null字串，當麼它的值也爲null
                        field.set(elem, null);
                    }
                } else {
                    Field attr_id = type.getDeclaredField(ATTR_ID);
                    if (attr_id != null) {
                        attr_id.setAccessible(true);
                        Object external = type.newInstance();
                        try {
                            attr_id.setInt(external, Integer.parseInt(value));
                            field.set(elem, external);
                        } catch (NumberFormatException e) {
                            // 如果格式化出現異常，那麼這個外鍵爲null
                            field.set(elem, null);
                        }
                    }
                }
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (SecurityException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            }
        }
        
        /**
         * 將xml格式的字符串轉換成Map對象
         * 
         * @param xmlStr xml格式的字符串
         * @return Map對象
         * @throws Exception 異常
         */
        public static Map<String, Object> xmlStrToMap(Element xmlStr) throws Exception {
            if(StringUtil.isEmpty(xmlStr)) {
                return null;
            }
            Map<String, Object> map = new HashMap<String, Object>();
            //獲取ReqParam數據
            List children  = xmlStr.elements();
            //循環所有子元素
            if(children != null && children.size() > 0) {
                for(int i = 0; i < children.size(); i++) {
                    Element child = (Element)children.get(i);
                    map.put(child.getName(), child.getTextTrim());
                }
            }
            return map;
        }
        
        /**
         * 將Map對象通過反射機制轉換成Bean對象
         * 
         * @param map 存放數據的map對象
         * @param clazz 待轉換的class
         * @return 轉換後的Bean對象
         * @throws Exception 異常
         */
        public static Object mapToBean(Map<String, Object> map, Class clazz) throws Exception {
            Object obj = clazz.newInstance();
            if(map != null && map.size() > 0) {
                for(Map.Entry<String, Object> entry : map.entrySet()) {
                    String propertyName = entry.getKey();
                    Object value = entry.getValue();
                    String setMethodName = "set"
                            + propertyName.substring(0, 1).toUpperCase()
                            + propertyName.substring(1);
                    Field field = getClassField(clazz, propertyName);
                    if(field!=null){
                        Class fieldTypeClass = field.getType();
                        value = convertValType(value, fieldTypeClass);
                        clazz.getMethod(setMethodName, field.getType()).invoke(obj, value);
                    }
                }
            }
            return obj;
        }
        
        
        /**
         * 將Object類型的值，轉換成bean對象屬性裏對應的類型值
         * 
         * @param value Object對象值
         * @param fieldTypeClass 屬性的類型
         * @return 轉換後的值
         */
        private static Object convertValType(Object value, Class fieldTypeClass) {
            Object retVal = null;
            if(Long.class.getName().equals(fieldTypeClass.getName())
                    || long.class.getName().equals(fieldTypeClass.getName())) {
                retVal = Long.parseLong(value.toString());
            } else if(Integer.class.getName().equals(fieldTypeClass.getName())
                    || int.class.getName().equals(fieldTypeClass.getName())) {
                retVal = Integer.parseInt(value.toString());
            } else if(Float.class.getName().equals(fieldTypeClass.getName())
                    || float.class.getName().equals(fieldTypeClass.getName())) {
                retVal = Float.parseFloat(value.toString());
            } else if(Double.class.getName().equals(fieldTypeClass.getName())
                    || double.class.getName().equals(fieldTypeClass.getName())) {
                retVal = Double.parseDouble(value.toString());
            } else {
                retVal = value;
            }
            return retVal;
        }
     
        /**
         * 獲取指定字段名稱查找在class中的對應的Field對象(包括查找父類)
         * 
         * @param clazz 指定的class
         * @param fieldName 字段名稱
         * @return Field對象
         */
        private static Field getClassField(Class clazz, String fieldName) {
            if( Object.class.getName().equals(clazz.getName())) {
                return null;
            }
            Field []declaredFields = clazz.getDeclaredFields();
            for (Field field : declaredFields) {
                if (field.getName().equals(fieldName)) {
                    return field;
                }
            }
     
            Class superClass = clazz.getSuperclass();
            if(superClass != null) {// 簡單的遞歸一下
                return getClassField(superClass, fieldName);
            }
            return null;
        } 

     
        public static <T> List<T> ParseXML(String content, Class<?> bean) {
            List<T> elements = new ArrayList<T>();// 構建一個空的list
            try {
                Document document = DocumentHelper.parseText(content);// 根據傳入的content獲取document
                Element rootElement = document.getRootElement();// 獲取根元素
     
                Field[] fields = bean.getDeclaredFields();// 獲取此bean的所有屬性
                // 迭代根元素下所有的子元素
                for (Iterator<Element> childs = rootElement.elements().iterator(); childs
                        .hasNext();) {
                    T element = (T) bean.newInstance();// 根據bean創建一個對象
                    Element child = childs.next();// 依次獲取子元素
                    for (Field field : fields) {
                        int mod = field.getModifiers();
                        if (Modifier.isFinal(mod) || Modifier.isStatic(mod)
                                || Modifier.isPublic(mod)) {
                            continue;
                        }
                        field.setAccessible(true);
                        String attr_name = GetAttrName(bean, field);// 獲取屬性名
                        Element param = child.element(attr_name);
                        // 根據屬性名獲取屬性
                        String attr_value = param.getText();// 獲取屬性值
                        SetAttrValue(field, element, attr_value);// 設置屬性值
                        // System.out.println("->"+attr_name+"="+attr_value);
                    }
     
                    // 判斷該element是否==null？
                    Field field_id = bean.getDeclaredField(ATTR_ID);
                    if (field_id != null) {
                        field_id.setAccessible(true);
                        if (field_id.getInt(element) == NULL_ID) {
                            elements.add(null);
                            continue;
                        }
                    }
     
                    elements.add(element);// 把初始化好的element添加到elements中
                }
            } catch (SecurityException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (DocumentException e) {
                e.printStackTrace();
            } finally {
                return elements;
            }
        }
     
        /*
         * 將一個文件讀取出來解析成列表
         */
        @SuppressWarnings("finally")
        public static <T> List<T> ReadListByFile(String path, Class<?> bean) {
            List<T> elements = new ArrayList<T>();// 構建一個空的list
            try {
                SAXReader saxReader = new SAXReader();
                Document document = saxReader.read(new File(path));
                Element rootElement = document.getRootElement();// 獲取根元素
     
                Field[] fields = bean.getDeclaredFields();// 獲取此bean的所有屬性
                // 迭代根元素下所有的子元素
                for (Iterator<Element> childs = rootElement.elements().iterator(); childs
                        .hasNext();) {
                    T element = (T) bean.newInstance();// 根據bean創建一個對象
                    Element child = childs.next();// 依次獲取子元素
                    for (Field field : fields) {
                        int mod = field.getModifiers();
                        if (Modifier.isFinal(mod) || Modifier.isStatic(mod)
                                || Modifier.isPublic(mod)) {
                            continue;
                        }
                        field.setAccessible(true);
                        String attr_name = GetAttrName(bean, field);// 獲取屬性名
                        Element param = child.element(attr_name);
                        ;// 根據屬性名獲取屬性
                        String attr_value = param.getText();// 獲取屬性值
                        SetAttrValue(field, element, attr_value);// 設置屬性值
                        // System.out.println("->"+attr_name+"="+attr_value);
                    }
     
                    // 判斷該element是否==null？
                    Field field_id = bean.getDeclaredField(ATTR_ID);
                    if (field_id != null) {
                        field_id.setAccessible(true);
                        if (field_id.getInt(element) == NULL_ID) {
                            elements.add(null);
                            continue;
                        }
                    }
     
                    elements.add(element);// 把初始化好的element添加到elements中
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                return elements;
            }
        }
     
        /*
         * 將一個列表寫入文件
         */
        public static <T> void WriteFileByList(String path, List<T> list,
                Class<?> bean) {
            /*
             * 從這裏開始與ParseList是一樣的
             */
            Document document = DocumentHelper.createDocument();// 獲取document
            document.setXMLEncoding("UTF-8");// 設置編碼
            Element root = document.addElement(GetRootName(bean));// 創建根元素
     
            Field[] fields = bean.getDeclaredFields();// 獲得bean的所有屬性
            for (T elem : list) {// 開始迭代傳入的list
                Element child = root.addElement(GetElemName(bean));// 創建子元素
     
                for (Field field : fields) {// 迭代屬性並且賦值
                    int mod = field.getModifiers();
                    if (Modifier.isFinal(mod) || Modifier.isStatic(mod)
                            || Modifier.isPublic(mod)) {
                        continue;
                    }
                    field.setAccessible(true);// 打破封裝性
                    String attr_name = GetAttrName(bean, field);// 獲取bean屬性對應的xml文件中的名字
                    String attr_value = GetAttrValue(field, elem);// 獲取此屬性對應的值
                    // System.out.println(attr_name+"="+attr_value);
                    child.addElement(attr_name).setText(attr_value);// 創建屬性並賦值
                }
            }
     
            /*
             * 這裏就是把Parse的返回字串轉化爲了保存爲文件而已
             */
            FileOutputStream fos = null;
            XMLWriter writer = null;
            try {
                fos = new FileOutputStream(path);
                OutputFormat format = OutputFormat.createPrettyPrint();
                format.setEncoding("UTF-8");
                writer = new XMLWriter(fos, format);
                writer.write(document);
                writer.flush();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (writer != null) {
                    try {
                        writer.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
     
        public static <T> void AddElementsByList(String path, List<T> list,
                Class<?> bean) {
            SAXReader saxReader = new SAXReader();
            Document document = null;
            try {
                document = saxReader.read(new File(path));
            } catch (Exception e) {
                e.printStackTrace();
                return;
            }
     
            Element root = document.getRootElement();
            Field[] fields = bean.getDeclaredFields();// 獲得bean的所有屬性
            for (T elem : list) {// 開始迭代傳入的list
                Element child = root.addElement(GetElemName(bean));// 創建子元素
     
                for (Field field : fields) {// 迭代屬性並且賦值
                    int mod = field.getModifiers();
                    if (Modifier.isFinal(mod) || Modifier.isStatic(mod)
                            || Modifier.isPublic(mod)) {
                        continue;
                    }
                    field.setAccessible(true);// 打破封裝性
                    String attr_name = GetAttrName(bean, field);// 獲取bean屬性對應的xml文件中的名字
                    String attr_value = GetAttrValue(field, elem);// 獲取此屬性對應的值
                    // System.out.println(attr_name+"="+attr_value);
                    child.addElement(attr_name).setText(attr_value);// 創建屬性並賦值
                }
            }
     
            /*
             * 這裏就是把Parse的返回字串轉化爲了保存爲文件而已
             */
            FileOutputStream fos = null;
            XMLWriter writer = null;
            try {
                fos = new FileOutputStream(path);
                OutputFormat format = OutputFormat.createPrettyPrint();
                format.setEncoding("UTF-8");
                writer = new XMLWriter(fos, format);
                writer.write(document);
                writer.flush();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (writer != null) {
                    try {
                        writer.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

    
}