XmlParser（android 解析xml）

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;

import android.util.Log;


public class XmlParser
{
    private static final String TAG = "XmlParser";

    /**
     * set方法前缀
     */
    private static final String SET_METHOD_PRE = "set";

    /**
     * 列表对象后缀
     */
    private static final String LIST_METHOD_SUFFIX = "List";

    /**
     * whoInfo列表tag
     */
    private static final String LIST_WHO = "whoInfoList";

    /**
     * Xml解析器
     */
    private XmlPullParser xmlParser = null;

    /**
     * 返回对象类
     */
    private Class<?> resultClazz = null;

    /**
     * 返回对象对应xml节点
     */
    private String resultNode = null;

    /**
     * 返回对象
     */
    private Object result = null;

    /**
     * 根元素列表
     */
    @SuppressWarnings("rawtypes")
    private List itemList = new ArrayList();

    /**
     * 根元素
     */
    private Object item = null;

    /**
     * 根元素类
     */
    private Class<?> itemClazz = null;

    /**
     * 根元素节点
     */
    private String itemNode = null;

    /**
     * 子元素列表
     */
    @SuppressWarnings("rawtypes")
    private List subItemList = new ArrayList();

    /**
     * 子元素
     */
    private Object subItem = null;

    /**
     * 子元素类
     */
    private Class<?> subItemClazz = null;

    /**
     * 子元素节点
     */
    private String subItemNode = null;

    /**
     * 子元素列表节点
     */
    private String subItemListNode = null;

    /**
     * 内嵌元素节点
     */
    private String innerItemNode = null;

    /**
     * 内嵌元素
     */
    private Object innerItem = null;

    /**
     * 内嵌元素类
     */
    private Class<?> innerItemClazz = null;

    /**
     * 是否开始解析返回对象
     */
    private boolean isResultStart = false;

    /**
     * 是否开始解析元素
     */
    private boolean isItemStart = false;

    /**
     * 是否开始解析返回子元素
     */
    private boolean isSubStart = false;

    /**
     * 是否开始解析返回内嵌对象元素
     */
    private boolean isInnerItemStart = false;

    public XmlParser(InputStream src, Class<?> relsultClazz, String resultNode)
    {
        if (src == null)
        {
            throw new IllegalArgumentException("InputStream can't be null");
        }
        if (relsultClazz == null)
        {
            throw new IllegalArgumentException("Class Instance can't be null");
        }

        this.resultClazz = relsultClazz;
        this.resultNode = resultNode;

        try
        {
            xmlParser = XmlPullParserFactory.newInstance().newPullParser();
            xmlParser.setInput(src, "UTF-8");
        }
        catch (XmlPullParserException e)
        {
            Log.e(TAG, "XmlPullParserException:" + e.getMessage(), e.getCause());
        }
    }

    /**
     *
     * 解析xml
     *
     * @return 对象列表
     */
    @SuppressWarnings(
    {"unchecked", "rawtypes"})
    public Object parseXml()
    {

        try
        {
            int evtType = xmlParser.getEventType();
            Field[] resultFields = resultClazz.getDeclaredFields();
            Field[] itemFields = null;
            Field[] innerItemFields = null;
            Field[] subItemFields = null;
            Field[] curFields = resultFields;
            while (evtType != XmlPullParser.END_DOCUMENT)
            {
                switch (evtType)
                {
                    case XmlPullParser.START_TAG:
                    {
                        String startTag = xmlParser.getName();

                        // 开始遍历返回对象
                        if (startTag.equalsIgnoreCase(resultNode))
                        {
                            result = newInstance(resultClazz);
                            evtType = xmlParser.next();
                            isResultStart = true;
                            continue;
                        }

                        // 开始遍历元素
                        if (itemNode != null
                                && startTag.equalsIgnoreCase(itemNode))
                        {
                            isItemStart = true;
                            if (itemClazz == null)
                            {
                                throw new IllegalArgumentException(
                                        "itemClazz can't be null");
                            }
                            else
                            {
                                item = newInstance(itemClazz);
                            }
                            itemFields = itemClazz.getDeclaredFields();
                            curFields = itemFields;
                            evtType = xmlParser.next();
                            continue;
                        }

                        // 开始遍历内嵌对象元素
                        if (innerItemNode != null
                                && startTag.equalsIgnoreCase(innerItemNode))
                        {
                            isInnerItemStart = true;
                            isItemStart = false;
                            innerItemClazz = getClass(innerItemNode);
                            innerItem = newInstance(innerItemClazz);
                            innerItemFields = innerItemClazz
                                    .getDeclaredFields();
                            curFields = innerItemFields;
                            evtType = xmlParser.next();
                            continue;
                        }

                        // 如果遍历至子对象列表处，初始化子对象
                        if (startTag.toLowerCase().endsWith(
                                LIST_METHOD_SUFFIX.toLowerCase())
                                && !startTag.trim().equals(LIST_WHO))
                        {
                            isSubStart = true;
                            String className = startTag.substring(
                                    0,
                                    startTag.toLowerCase().indexOf(
                                            LIST_METHOD_SUFFIX.toLowerCase()));

                            subItemNode = className;
                            subItemListNode = startTag;
                            subItemList = new ArrayList();

                            subItemClazz = getClass(className);
                            subItem = newInstance(subItemClazz);
                            subItemFields = subItemClazz.getDeclaredFields();
                            curFields = subItemFields;

                            evtType = xmlParser.next();
                            continue;

                        }

                        // 如果该节点和子对象相同则创建子对象实例
                        if (startTag.equals(subItemNode) && isSubStart)
                        {
                            subItem = newInstance(subItemClazz);
                            evtType = xmlParser.next();
                            continue;
                        }

                        // 开始遍历返回对象属性
                        for (Field field : curFields)
                        {
                            String fieldname = field.getName();
                            if (fieldname.equals(startTag))
                            {
                                try
                                {

                                    String methodName = SET_METHOD_PRE
                                            + fieldname.substring(0, 1)
                                                    .toUpperCase()
                                            + fieldname.substring(1);
                                    String nextText = xmlParser.nextText();

                                    if (isResultStart && !isItemStart && !isInnerItemStart)
                                    {
                                        invokeMethod(result, methodName,
                                                String.class, resultClazz,
                                                nextText);

                                    }
                                    else if (isItemStart && !isSubStart)
                                    {
                                        invokeMethod(item, methodName,
                                                String.class, itemClazz,
                                                nextText);
                                    }
                                    else if (isInnerItemStart && !isSubStart)
                                    {
                                        invokeMethod(innerItem, methodName,
                                                String.class, innerItemClazz,
                                                nextText);
                                    }
                                    else if (isSubStart)
                                    {
                                        invokeMethod(subItem, methodName,
                                                String.class, subItemClazz,
                                                nextText);
                                    }

                                    break;
                                }
                                catch (IllegalArgumentException e)
                                {
                                    Log.e(TAG,
                                            "IllegalArgumentException:"
                                                    + e.getMessage(),
                                            e.getCause());
                                }

                            }

                        }

                        break;
                    }
                    case XmlPullParser.END_TAG:
                    {
                        String endTag = xmlParser.getName();

                        // 一个根元素遍历结束加入根元素列表
                        if (endTag.equalsIgnoreCase(itemNode))
                        {
                            // 将返回对象元素加进列表
                            itemList.add(item);
                        }

                        // 一个子元素遍历结束加入子元素列表
                        else if (endTag.equalsIgnoreCase(subItemNode))
                        {
                            // 将子元素加进子列表
                            subItemList.add(subItem);
                        }

                        // 所有子元素遍历结束
                        else if (endTag.equalsIgnoreCase(subItemListNode))
                        {
                            String methodName = SET_METHOD_PRE
                                    + subItemListNode.substring(0, 1)
                                            .toUpperCase()
                                    + subItemListNode.substring(1);

                            // 内嵌对象内列表元素，调用内嵌对象的添加列表方法
                            // 否则调用根对象添加列表方法
                            if (!isInnerItemStart)
                            {
                                invokeMethod(item, methodName, ArrayList.class,
                                        itemClazz, subItemList);
                                isSubStart = false;
                                curFields = itemFields;
                            }
                            else
                            {
                                invokeMethod(innerItem, methodName,
                                        ArrayList.class, innerItemClazz,
                                        subItemList);
                                isSubStart = false;
                                isInnerItemStart = false;
                                curFields = innerItemFields;
                            }

                        }

                        // 内嵌对象遍历结束
                        else if (endTag.equalsIgnoreCase(innerItemNode))
                        {
                            String methodName = SET_METHOD_PRE
                                    + innerItemNode.substring(0, 1)
                                            .toUpperCase()
                                    + innerItemNode.substring(1);
                            invokeMethod(item, methodName, innerItemClazz,
                                    itemClazz, innerItem);
                            curFields = itemFields;
                            isInnerItemStart = false;
                            isItemStart = true;
                        }

                        // 所有节点遍历结束
                        else if (endTag.equalsIgnoreCase(resultNode)
                                && itemNode != null)
                        {
                            String itemName = itemClazz.getSimpleName();
                            String itemListMethodName = SET_METHOD_PRE
                                    + itemName.substring(0, 1).toUpperCase()
                                    + itemName.substring(1)
                                    + LIST_METHOD_SUFFIX;
                            invokeMethod(result, itemListMethodName,
                                    List.class, resultClazz, itemList);
                        }

                        break;
                    }
                    default:
                    {
                        break;
                    }
                }

                evtType = xmlParser.next();

            }
            return result;

        }
        catch (XmlPullParserException e)
        {
            Log.e(TAG, "InstantiationException:" + e.getMessage(), e.getCause());
        }
        catch (IOException e)
        {
            Log.e(TAG, "IOException:" + e.getMessage(), e.getCause());
        }
        catch (SecurityException e)
        {
            Log.e(TAG, "SecurityException:" + e.getMessage(), e.getCause());
        }

        return null;
    }

    public void setInnerItemNode(String innerItemNode)
    {
        this.innerItemNode = innerItemNode;
    }

    public void setItemNode(String itemNode)
    {
        this.itemNode = itemNode;
    }

    public void setItemClazz(Class<?> itemClazz)
    {
        this.itemClazz = itemClazz;
    }

    /**
     *
     * 根据类名创建类
     *
     * @param className
     *            类名
     */
    private Class<?> getClass(String className)
    {
        try
        {
            // 和返回对象在同一个包下
            String wholeClassName = resultClazz.getPackage().getName()
                    .replace(".result", "")
                    + "."
                    + className.substring(0, 1).toUpperCase()
                    + className.substring(1);

            return Class.forName(wholeClassName);

        }
        catch (ClassNotFoundException e)
        {
            Log.e(TAG, "ClassNotFoundException:" + e.getMessage(), e.getCause());
        }
        return null;
    }

    /**
     *
     * 调用类内方法
     *
     * @param o
     *            类对象
     * @param methodName
     *            方法名
     * @param parameterTypes
     *            参数类型
     * @param receiver
     *            类
     * @param value
     *            参数值
     */
    private void invokeMethod(Object o, String methodName,
            Class<?> parameterTypes, Class<?> receiver, Object value)
    {
        try
        {
            Method method = receiver.getMethod(methodName, parameterTypes);
            method.invoke(o, value);
        }
        catch (SecurityException e)
        {
            Log.e(TAG, "SecurityException:" + e.getMessage(), e.getCause());
        }
        catch (NoSuchMethodException e)
        {
            Log.e(TAG, "NoSuchMethodException:" + e.getMessage(), e.getCause());
        }
        catch (IllegalArgumentException e)
        {
            Log.e(TAG, "IllegalArgumentException:" + e.getMessage(),
                    e.getCause());
        }
        catch (IllegalAccessException e)
        {
            Log.e(TAG, "IllegalAccessException:" + e.getMessage(), e.getCause());
        }
        catch (InvocationTargetException e)
        {
            Log.e(TAG, "InvocationTargetException:" + e.getMessage(),
                    e.getCause());
        }
    }

    /**
     * 根据类创建对象实例
     *
     * @param cls
     *            对象类
     * @return
     */
    private Object newInstance(Class<?> cls)
    {
        try
        {
            return cls.newInstance();
        }
        catch (IllegalAccessException e)
        {
            Log.e(TAG, "IllegalAccessException:" + e.getMessage(), e.getCause());
        }
        catch (InstantiationException e)
        {
            Log.e(TAG, "InstantiationException:" + e.getMessage(), e.getCause());
        }
        return null;
    }

}