[ 登录注册 ]

HTML/CSS

HTTP把指定的内部实体对象转换成xml,把xml转换成指定的内部实体

2016/08/12 15:08 [db:作者] 返回上一页

相信设计到通讯的工程,都会需要用的通讯协议http、soap...,相信也写过很多的接口soap接口、HTTP+XML接口,每次调用我们写的接口的时候传给我们的都是个XML格式的数据信息,我们需要把这些数据解析出来,然后再拼装成一个info发出去,以下写了一个通用的方法,利用JAVA的反射机制来实现:

 

代码如下:

Java代码

/**

 * <p>

 * Copyright (C), 1988-2008, Huawei Tech. Co., Ltd.

 * </p>

 * <p>

 * FileName: Transform.java

 * </p>

 * <p>

 * Author:tangtao Version :1.0 Date:2010-8-31

 * </p>

 * <p>

 * Description:

 * </p>

 * <p>

 * Version: 1.0

 * </p>

 * <p>

 * Function List:

 * </p>

 */ 

package com.huawei.nvs.sys.conn.http; 

 

import java.io.ByteArrayInputStream; 

import java.lang.reflect.AccessibleObject; 

import java.lang.reflect.Field; 

import java.util.ArrayList; 

import java.util.Iterator; 

import java.util.List; 

import java.util.Locale; 

import java.util.Map; 

import java.util.regex.Matcher; 

import java.util.regex.Pattern; 

 

import org.w3c.dom.Element; 

import org.w3c.dom.Node; 

 

import com.huawei.nvs.sys.conn.http.bean.FieldInfo; 

import com.huawei.nvs.sys.conn.http.bean.HttpInfo; 

import com.huawei.nvs.sys.conn.http.bean.MessageInfo; 

import com.huawei.nvs.sys.conn.http.bean.SendFieldInfo; 

import com.huawei.nvs.sys.conn.http.conf.HttpEnv; 

import com.huawei.nvs.sys.conn.http.exception.HttpException; 

import com.huawei.nvs.sys.conn.http.util.ListMap; 

import com.huawei.nvs.sys.conn.http.util.XmlTools; 

 

/**

 * <p>

 * Title: Transform

 * </p>

 * <p>

 * Description: HTTP消息转换类,把指定的内部实体对象转换成xml,把xml转换成指定的内部实体对象

 * </p>

 * <p>

 * Copyright: Copyright (c) 2010-8-31

 * </p>

 * <p>

 * Company: www.huawei.com

 * </p>

 * 

 * @author wanghui

 * @version 1.0

 */ 

public class Transform 

    /**

     * 把实体bean转换成xml字符串

     * 

     * @param bean 实体对象

     * @throws HttpException HttpException

     * @return 转换成功的xml字符串

     */ 

    public static String beanToXml(HttpInfo bean) 

        throws HttpException 

    { 

        if (null == bean) 

        { 

            throw new HttpException("Parameter bean is null."); 

        } 

        StringBuffer sbf = new StringBuffer("<?xml version='1.0' encoding='UTF-8'?>"); 

         

        ListMap headFieldMap = new ListMap(); 

        ListMap bodyFieldMap = new ListMap(); 

         

        Class<?> c = bean.getClass(); 

         

        try 

        { 

            // 获取消息类型和实体对象类路径

            Field f = c.getDeclaredField("msgType"); 

            Field v = c.getDeclaredField("version"); 

             

            // 修改checkstyle 问题by wangzheng at 20101015 begin 

            // f.setAccessible(true); 

            AccessibleObject.setAccessible(new Field[] {f}, true); 

            AccessibleObject.setAccessible(new Field[] {v}, true); 

            // 修改checkstyle 问题by wangzheng at 20101015 end 

             

            String msgType = f.get(bean).toString(); 

            String version = (String)v.get(bean); 

             

            //因为这个是发到SMC的消息,不存在多版本,所以这里默认赋值为1.0版本

            version = null == version ? "smc" : version; 

             

            String path = c.getName(); 

            Field[] fields = c.getDeclaredFields(); 

            AccessibleObject.setAccessible(fields, true); 

            // 找出bean中的消息头和消息体

            for (Field field : fields) 

            { 

                String fieldName = field.getName(); 

                if (isUseField(msgType, path, fieldName, version)) 

                { 

                    if ("MsgType".equalsIgnoreCase(fieldName) || "Expires".equalsIgnoreCase(fieldName) 

                        || "callID".equalsIgnoreCase(fieldName)) 

                    { 

                        headFieldMap.put(fieldName, field); 

                    } 

                    else 

                    { 

                        bodyFieldMap.put(fieldName, field); 

                    } 

                } 

            } 

            sbf.append("<NVS_SMS_REQ>"); 

            // 拼装消息头xml字符串

            String headStr = buildHead(version, msgType, headFieldMap, bean); 

            // 拼装消息体xml字符串

            String bodyStr = buildBody(version, msgType, bodyFieldMap, bean); 

             

            // 拼装整个xml消息字符串

            sbf.append(headStr).append(bodyStr); 

            sbf.append("</NVS_SMS_REQ>"); 

        } 

        catch (Exception e) 

        { 

            e.printStackTrace(); 

            throw new HttpException("The xml conversion bean fail.", e); 

        } 

        return sbf.toString(); 

    } 

     

    /**

     * 把实体bean转换成xml字符串

     * 

     * @param msgType 消息类型

     * @param bean 实体对象

     * @throws HttpException HttpException

     * @return 转换成功的xml字符串

     */ 

    public static String beanToXml(String msgType, Object bean) 

        throws HttpException 

    { 

        if (null == bean) 

        { 

            throw new HttpException("Parameter bean is null."); 

        } 

        StringBuffer sbf = new StringBuffer(""); 

         

        ListMap headFieldMap = new ListMap(); 

        ListMap bodyFieldMap = new ListMap(); 

         

        Class<?> c = bean.getClass(); 

         

        try 

        { 

            String path = c.getName(); 

            String version = (String)(c.getDeclaredMethod("getVersion").invoke(bean, new Object[] {})); 

             

            Field[] fields = c.getDeclaredFields(); 

            AccessibleObject.setAccessible(fields, true); 

             

            // 找出bean中的消息头和消息体

            for (Field field : fields) 

            { 

                String fieldName = field.getName(); 

                if (isUseField(msgType, path, fieldName, version)) 

                { 

                    if ("MsgType".equalsIgnoreCase(fieldName) || "Expires".equalsIgnoreCase(fieldName) 

                        || "callID".equalsIgnoreCase(fieldName)) 

                    { 

                        headFieldMap.put(fieldName, field);  

                    } 

                    else 

                    { 

                        bodyFieldMap.put(fieldName, field); 

                    } 

                } 

            } 

            sbf.append("<Msg_Body>"); 

            // 拼装消息头xml字符串

            String headStr = buildHead(version, msgType, headFieldMap, bean); 

            // 拼装消息体xml字符串

            String bodyStr = buildBody(version, msgType, bodyFieldMap, bean); 

             

            // 拼装整个xml消息字符串

            sbf.append(headStr).append(bodyStr); 

            sbf.append("</Msg_Body>"); 

        } 

        catch (Exception e) 

        { 

            e.printStackTrace(); 

            throw new HttpException("The bean conversion xml fail.", e); 

        }  

        return sbf.toString(); 

    } 

     

    /**

     * 根据传入的消息头字段拼装成xml格式字符串

     * 

     * @param headListMap 消息头Field

     * @param c 实体对象

     * @return 拼装后的xml消息头字符串

     * @throws IllegalAccessException 反射失败

     */ 

    private static String buildHead(String version, String msgType, ListMap headListMap, Object c) 

        throws IllegalAccessException 

    { 

        // mod by wangzheng at 20100920 begin 

        // StringBuffer sbf = new StringBuffer("<head>"); 

        StringBuffer sbf = new StringBuffer(); 

         

        List<?> keyList = headListMap.getKeyList(); 

        for (int i = 0; i < keyList.size(); i++) 

        { 

            String key = keyList.get(i).toString(); 

            // 获取属性节点对应的消息节点名称

            String msgFieldName = getMsgField(version, msgType, c.getClass().getName(), key); 

            msgFieldName = null == msgFieldName ? key : msgFieldName; 

            Field field = (Field)headListMap.get(key); 

            Object obj = field.get(c); 

            sbf.append("<").append(msgFieldName).append(">"); 

            sbf.append(changeStrToXml(obj)); 

            sbf.append("</").append(msgFieldName).append(">"); 

        } 

        // sbf.append("</head>"); 

        // mod by wangzheng at 20100920 begin 

        return sbf.toString(); 

    } 

     

    /**

     * 根据传入的消息体字段拼装成xml格式字符串

     * 

     * @param bodyListMap 消息头Field

     * @param c 实体对象

     * @return 拼装后的xml消息体字符串

     * @throws IllegalAccessException

     */ 

    private static String buildBody(String version, String msgType, ListMap bodyListMap, Object c) 

        throws IllegalAccessException 

    { 

        // mod by wangzheng at 20100920 begin 

        // StringBuffer sbf = new StringBuffer("<body>"); 

        StringBuffer sbf = new StringBuffer(); 

         

        List<?> keyList = bodyListMap.getKeyList(); 

        for (int i = 0; i < keyList.size(); i++) 

        { 

            String key = keyList.get(i).toString(); 

             

            // 获取属性节点对应的消息节点名称

            String msgFieldName = getMsgField(version, msgType, c.getClass().getName(), key); 

            msgFieldName = null == msgFieldName ? key : msgFieldName; 

             

            Field field = (Field)bodyListMap.get(key); 

            Object obj = field.get(c); 

            if (obj instanceof List) 

            { 

                String buildResult = Transform.buildList(version, msgType, (List<Object>)obj, msgFieldName); 

                sbf.append(buildResult); 

            } 

            else if (obj instanceof String[]) 

            { 

                String buildResult = buildArray((String[])obj, msgFieldName); 

                sbf.append(buildResult); 

            } 

            else if (obj instanceof HttpInfo) 

            { 

                String buildResult = Transform.buildBean(version, msgType, obj); 

                sbf.append(buildResult); 

            } 

            else 

            { 

                sbf.append("<").append(msgFieldName).append(">"); 

                sbf.append(changeStrToXml(obj)); 

                sbf.append("</").append(msgFieldName).append(">"); 

            } 

        } 

         

        // sbf.append("</body>"); 

        // mod by wangzheng at 20100920 begin 

        return sbf.toString(); 

    } 

     

    /**

     * 根据传入的List消息体字段拼装成xml格式字符串

     * 

     * @param list 消息实体对象列表

     * @param listName 列表名称

     * @return 拼装后的xml消息体字符串

     * @throws IllegalAccessException

     */ 

    private static String buildArray(String[] value, String listName) 

        throws IllegalAccessException 

    { 

        StringBuffer sbf = new StringBuffer(); 

         

        for (int i = 0; i < value.length; i++) 

        { 

            sbf.append("<").append(listName).append(">"); 

            sbf.append(value[i]); 

            sbf.append("</").append(listName).append(">"); 

        } 

         

        return sbf.toString(); 

    } 

     

    /**

     * 根据传入的List消息体字段拼装成xml格式字符串

     * 

     * @param list 消息实体对象列表

     * @param listName 列表名称

     * @return 拼装后的xml消息体字符串

     * @throws IllegalAccessException

     */ 

    private static String buildList(String version, String msgType, List<Object> list, String listName) 

        throws IllegalAccessException 

    { 

        StringBuffer sbf = new StringBuffer(); 

        sbf.append("<").append(listName).append(">"); 

        for (int i = 0; i < list.size(); i++) 

        { 

            sbf.append(buildBean(version, msgType, list.get(i))); 

        } 

        sbf.append("</").append(listName).append(">"); 

        return sbf.toString(); 

    } 

     

    /**

     * 把简单的实体对象中的属性转换成xml格式的字符串

     * 

     * @param bean 简单的实体对象

     * @return 转换后的字符串

     * @throws IllegalAccessException

     */ 

    private static String buildBean(String version, String msgType, Object bean) 

        throws IllegalAccessException 

    { 

        StringBuffer sbf = new StringBuffer(); 

         

        Class<?> c = bean.getClass(); 

        String path = c.getName(); 

        //String className = path.substring(path.lastIndexOf(".") + 1, path.length()); 

        //className = className.substring(0, className.indexOf("Info")); 

        String infoName = getMsgField(version, msgType, path); 

        infoName = null == infoName ? "" : infoName; 

        sbf.append("<").append(infoName).append(">"); 

          

        Field[] fields = c.getDeclaredFields(); 

        AccessibleObject.setAccessible(fields, true); 

        for (Field f : fields) 

        { 

            String fieldName = f.getName(); 

            // 只封装在配置文件中配置过的字段

            if (isUseField(msgType, path, fieldName, version)) 

            { 

                // 获取属性节点对应的消息节点名称

                String msgFieldName = getMsgField(version, msgType, path, fieldName); 

                msgFieldName = null == msgFieldName ? fieldName : msgFieldName; 

                 

                Object obj = f.get(bean); 

                if (obj instanceof List) 

                { 

                    String buildResult = Transform.buildList(version, msgType, (List)obj, msgFieldName); 

                    sbf.append(buildResult); 

                } 

                else 

                { 

                    sbf.append("<").append(msgFieldName).append(">"); 

                    Object value = f.get(bean); 

                    sbf.append(changeStrToXml(value)); 

                    sbf.append("</").append(msgFieldName).append(">"); 

                } 

            } 

        } 

        sbf.append("</").append(infoName).append(">"); 

         

        return sbf.toString(); 

    } 

     

    private static boolean isUseField(String msgID, String infoName, String fieldName, String version) 

    { 

        // 根据消息ID从内存中取出发送消息配置Map 

        SendFieldInfo sendMsgInfo = HttpEnv.getSendMsgMap().get(version).get(msgID); 

        if (null != sendMsgInfo) 

        { 

            // 根据info的详细类名称取出发送消息字段

            Map<String, MessageInfo> messageMap = sendMsgInfo.getMessageMap(); 

            if (null != messageMap) 

            { 

                // 根据info路径获取配置的info 

                MessageInfo msgInfo = messageMap.get(infoName); 

                if (null != msgInfo) 

                { 

                    Map<String, FieldInfo> fieldMap = msgInfo.getFieldMap(); 

                    // 根据消息字段获取匹配的属性字段

                    fieldName = fieldName.toLowerCase(Locale.getDefault()); 

                    FieldInfo fieldInfo = fieldMap.get(fieldName); 

                    if (null != fieldInfo) 

                    { 

                        return true; 

                    } 

                } 

            } 

        } 

        else 

        { 

            // 如果infoMap为空说明在http_data.xml的发送节点没有配置要发送的info属性,所以默认发送info中全部属性

            return true; 

        } 

         

        return false; 

    } 

     

    /**

     * 根据消息ID,info类名称,消息字段获取到对应的消息字段名称

     * 

     * @param msgID 消息ID

     * @param infoName info类完整名称

     * @param fieldName info属性名称

     * @return info属性所对应的消息字段

     */ 

    private static String getMsgField(String version, String msgID, String infoName, String fieldName) 

    { 

        // 根据消息ID从内存中取出发送消息配置Map 

        Map<String, SendFieldInfo> sendMsgInfoMap = HttpEnv.getSendMsgMap().get(version); 

        if (null != sendMsgInfoMap) 

        { 

            SendFieldInfo sendMsgInfo = sendMsgInfoMap.get(msgID); 

            if (null != sendMsgInfo) 

            { 

                // 根据info的详细类名称取出发送消息字段

                Map<String, MessageInfo> messageMap = sendMsgInfo.getMessageMap(); 

                if (null != messageMap) 

                { 

                    // 根据info路径获取配置的info 

                    MessageInfo msgInfo = messageMap.get(infoName); 

                    if (null != msgInfo) 

                    { 

                        Map<String, FieldInfo> fieldMap = msgInfo.getFieldMap(); 

                        Iterator<Map.Entry<String, FieldInfo>> it = fieldMap.entrySet().iterator(); 

                        while (it.hasNext()) 

                        { 

                            Map.Entry<String, FieldInfo> entry = it.next(); 

                            String key = entry.getKey(); 

                            FieldInfo field = entry.getValue(); 

                             

                            if (fieldName.equalsIgnoreCase(key)) 

                            { 

                                return field.getName(); 

                            } 

                        } 

                    } 

                } 

            } 

        } 

         

        return null; 

    } 

     

    /**

     * 根据消息ID,info类名称,获取到对应的info别名字段名称

     * 

     * @param msgID 消息ID

     * @param infoName info类完整名称

     * @param fieldName info属性名称

     * @return info属性所对应的消息字段

     */ 

    private static String getMsgField(String version, String msgID, String infoName) 

    { 

        // 根据消息ID从内存中取出发送消息配置Map 

        Map<String, SendFieldInfo> sendMsgInfoMap = HttpEnv.getSendMsgMap().get(version); 

        if (null != sendMsgInfoMap) 

        { 

            SendFieldInfo sendMsgInfo = sendMsgInfoMap.get(msgID); 

            if (null != sendMsgInfo) 

            { 

                // 根据info的详细类名称取出发送消息字段

                Map<String, MessageInfo> messageMap = sendMsgInfo.getMessageMap(); 

                if (null != messageMap) 

                { 

                    // 根据info路径获取配置的info 

                    MessageInfo msgInfo = messageMap.get(infoName); 

                    if (null != msgInfo) 

                    { 

                        return msgInfo.getMsgField(); 

                    } 

                } 

            } 

        } 

         

        return null; 

    } 

     

    /**

     * 把字符串中的特殊字符用xml指定的字符代替

     * 

     * @param str 需要转换的字符串

     * @return 转换后的字符串

     */ 

    private static String changeStrToXml(Object str) 

    { 

        String tempStr = null == str ? "" : str.toString(); 

        // 转换所有&为&amp; 

        tempStr = tempStr.replaceAll("[&]", "&amp;"); 

        // 转换所有<为&lt; 

        tempStr = tempStr.replaceAll("[<]", "&lt;"); 

        // 转换所有>为&gt; 

        tempStr = tempStr.replaceAll("[>]", "&gt;"); 

        // 转换所有‘为&apos; 

        tempStr = tempStr.replaceAll("[']", "&apos;"); 

        // 转换所有"为&quot; 

        tempStr = tempStr.replaceAll("[\"]", "&quot;"); 

         

        return tempStr; 

    } 

     

    /**

     * 把xml中的的特殊字符用转换回原始数据

     * 

     * @param str 需要转换的字符串

     * @return 转换后的字符串

     */ 

    private static String changeXmlToStr(Object xmlStr) 

    { 

        String tempStr = null == xmlStr ? "" : xmlStr.toString(); 

        // 转换所有&amp;为& 

        tempStr = tempStr.replaceAll("&amp;", "&"); 

        // 转换所有&lt;为< 

        tempStr = tempStr.replaceAll("&lt;", "<"); 

        // 转换所有&gt;为> 

        tempStr = tempStr.replaceAll("&gt;", ">"); 

        // 转换所有&apos;为‘

        tempStr = tempStr.replaceAll("&apos;", "'"); 

        // 转换所有&quot;为" 

        tempStr = tempStr.replaceAll("&quot;", "\""); 

         

        return tempStr; 

    } 

     

    /**

     * 把xml格式的字符串信息转换成实体对象

     * 

     * @param xml xml字符串

     * @return 消息实体Bean

     * @throws HttpException HttpException

     */ 

    public static HttpInfo xmlToBean(String xml) 

        throws HttpException 

    { 

        return xmlToBean("smc", xml); 

    } 

     

    /**

     * 把xml格式的字符串信息转换成实体对象

     * 

     * @param version 消息版本

     * @param xml xml字符串

     * @return 消息实体Bean

     * @throws HttpException HttpException

     */ 

    public static HttpInfo xmlToBean(String version, String xml) 

        throws HttpException 

    { 

        if (null == xml || "".equals(xml)) 

        { 

            throw new HttpException("Parameter xml is null."); 

        } 

        HttpInfo info = null; 

        // 删除xml声明行(第一行) 

        xml = deleteXmlHead(xml); 

         

        Element messageNode = null; 

        try 

        { 

            // 将xml字符串转化为ByteArrayInputStream 

            ByteArrayInputStream bis = new ByteArrayInputStream(xml.getBytes("UTF-8")); 

             

            // 获取head和body节点

            messageNode = XmlTools.createRootElement(bis); 

            // Node headNode = XmlTools.getChildNode(messageNode, "head"); 

            // Node bodyNode = XmlTools.getChildNode(messageNode, "body"); 

             

            // 获取head节点和body节点的所有子节点

            // List<Node> headChildList = XmlTools.getChildNodes(headNode); 

            List<Node> bodyChildLists = XmlTools.getChildNodes(messageNode); 

             

            // 合并headChildList和bodyChildLists 

            // headChildList.addAll(bodyChildLists); 

             

            // mod by wangzheng at 20100905 begin 

            // 获取消息类型

            // Node msgTypeNode = headChildList.get(0); 

             

            // 获取消息类型

            // Node msgTypeNode = XmlTools.getChildNode(headNode, "msgType"); 

            Node msgTypeNode = XmlTools.getChildNode(messageNode, "MSG_TYPE"); 

            String msgType = XmlTools.getNodeValue(msgTypeNode); 

            // mod by wangzheng at 20100905 end 

             

            // 根据消息类型取出配置的相应info并生成对象

            MessageInfo msgInfo = HttpEnv.getMsgMap().get(version).get(msgType); 

             

            // 根据配置信息生成Info 

            info = (HttpInfo)createInfo(msgInfo, bodyChildLists); 

        } 

        catch (HttpException e) 

        { 

            e.printStackTrace(); 

            throw e; 

        } 

        catch (Exception e) 

        { 

            e.printStackTrace(); 

            throw new HttpException("The bean conversion xml fail.", e); 

        } 

        finally 

        { 

            messageNode = null; 

        } 

        return info; 

    } 

     

    // add by wangzheng at 20100920 begin 

    /**

     * 把xml格式的字符串信息转换成实体对象--没有head及body

     * 

     * @param xml xml字符串

     * @return 消息实体Bean

     * @throws HttpException HttpException

     */ 

    public static HttpInfo xmlToBeanNoHead(String xml) 

        throws HttpException 

    { 

        if (null == xml || "".equals(xml)) 

        { 

            throw new HttpException("Parameter xml is null."); 

        } 

        HttpInfo info = null; 

        // 删除xml声明行(第一行) 

        xml = deleteXmlHead(xml); 

         

        Element messageNode = null; 

        try 

        { 

            // 将xml字符串转化为ByteArrayInputStream 

            ByteArrayInputStream bis = new ByteArrayInputStream(xml.getBytes("UTF-8")); 

             

            // 获取head和body节点

            messageNode = XmlTools.createRootElement(bis); 

             

            // 获取head节点和body节点的所有子节点

            List<Node> headChildList = XmlTools.getChildNodes(messageNode); 

             

            // 获取消息类型

            Node msgTypeNode = XmlTools.getChildNode(messageNode, "MSG_TYPE"); 

            String msgType = XmlTools.getNodeValue(msgTypeNode); 

             

            // 根据消息类型取出配置的相应info并生成对象

            MessageInfo msgInfo = HttpEnv.getMsgMap().get("").get(msgType); 

             

            // 根据配置信息生成Info 

            info = (HttpInfo)createInfo(msgInfo, headChildList); 

        } 

        catch (HttpException e) 

        { 

            e.printStackTrace(); 

            throw e; 

        } 

        catch (Exception e) 

        { 

            e.printStackTrace(); 

            throw new HttpException("The bean conversion xml fail.", e); 

        } 

        finally 

        { 

            messageNode = null; 

        } 

        return info; 

    } 

     

    /**

     * 把xml格式的字符串信息转换成实体对象--没有head及body

     * 

     * @param xml xml字符串

     * @param msgType 消息类型

     * @param version 消息版本

     * @return 消息实体Bean

     * @throws HttpException HttpException

     */ 

    public static Object xmlToBeanNoHead(String msgType, String version, String xml) 

        throws HttpException 

    { 

        if (null == xml || "".equals(xml)) 

        { 

            throw new HttpException("Parameter xml is null."); 

        } 

        Object info = null; 

        // 删除xml声明行(第一行) 

        xml = deleteXmlHead(xml); 

         

        Element messageNode = null; 

        try 

        { 

            // 将xml字符串转化为ByteArrayInputStream 

            ByteArrayInputStream bis = new ByteArrayInputStream(xml.getBytes("UTF-8")); 

             

            // 获取head和body节点

            messageNode = XmlTools.createRootElement(bis); 

             

            // 获取head节点和body节点的所有子节点

            List<Node> headChildList = XmlTools.getChildNodes(messageNode); 

             

            // 根据消息类型取出配置的相应info并生成对象

            MessageInfo msgInfo = HttpEnv.getMsgMap().get(version).get(msgType); 

             

            // 根据配置信息生成Info 

            info = createInfo(msgInfo, headChildList); 

        } 

        catch (HttpException e) 

        { 

            e.printStackTrace(); 

            throw e; 

        } 

        catch (Exception e) 

        { 

            e.printStackTrace(); 

            throw new HttpException("The bean conversion xml fail.", e); 

        } 

        finally 

        { 

            messageNode = null; 

        } 

        return info; 

    } 

     

    // add by wangzheng at 20100920 end 

     

    /**

     * 根据xml节点创建指定的实体Bean

     * 

     * @param msgInfo 实体bean

     * @param nodeList xml节点列表

     * @throws HttpException

     */ 

    private static Object createInfo(MessageInfo msgInfo, List<Node> nodeList) 

        throws HttpException 

    { 

        // 获取出messageInfo的属性

        String path = msgInfo.getPath(); 

        Map<String, FieldInfo> fieldMap = msgInfo.getFieldMap(); 

        Object obj = null; 

        try 

        { 

            // 根据类路径生成对象

            obj = Class.forName(path).newInstance(); 

            for (Node node : nodeList) 

            { 

                // 获取消息节点名称及节点值

                String nodeName = node.getNodeName().toLowerCase(Locale.getDefault()); 

                Object nodeValue = XmlTools.getValue(node); 

                 

                // 根据节点名称找到Field 

                FieldInfo field = fieldMap.get(nodeName); 

                if (null != field) 

                { 

                    String type = field.getType(); 

                    if ("java.util.List".equalsIgnoreCase(type)) 

                    { 

                        List<Object> list = new ArrayList<Object>(); 

                        MessageInfo subInfo = field.getChildInfo(); 

                         

                        // 获取节点下所有子节点

                        List<Node> subInfoList = XmlTools.getChildNodes(node); 

                        for (Node subInfoNode : subInfoList) 

                        { 

                            List<Node> subNodeList = XmlTools.getChildNodes(subInfoNode); 

                            Object info = createInfo(subInfo, subNodeList); 

                            list.add(info); 

                        } 

                        // Node subInfoNode = XmlTools.getChildNodes(node).get(0); 

                        nodeValue = list; 

                    } 

                    //mod by wangzheng at 20110329 begin 

                    //若类型为HTTPInfo的子类,则进行取info操作,达不到预期效果,估计需要修改加载内存中结构信息

                    else if (Class.forName("com.huawei.nvs.sys.conn.http.bean.HttpInfo") 

                        .isAssignableFrom(Class.forName(type))) 

                    { 

                        Object info = null; 

                        //MessageInfo subInfo = field.getChildInfo(); 

                        MessageInfo subInfo = msgInfo; 

                        // 获取节点下所有子节点

                        List<Node> subInfoList = XmlTools.getChildNodes(node); 

                        if (subInfoList.size() > 0) 

                        { 

                            List<Node> subNodeList = XmlTools.getChildNodes(subInfoList.get(0)); 

                            if (null == subNodeList || 0 == subNodeList.size()) 

                            { 

                                subNodeList = subInfoList; 

                            } 

                            info = createInfo(subInfo, subNodeList); 

                        } 

                        nodeValue = info; 

                    } 

                    //                  else if ("com.huawei.nvs.sys.conn.http.bean.HttpInfo".equalsIgnoreCase(type)) 

                    //                  { 

                    //                      Object info = null; 

                    //                      MessageInfo subInfo = field.getChildInfo(); 

                    //                      // 获取节点下所有子节点

                    //                      List<Node> subInfoList = XmlTools.getChildNodes(node); 

                    //                      if (subInfoList.size() > 0) 

                    //                      { 

                    //                          List<Node> subNodeList = XmlTools.getChildNodes(subInfoList.get(0)); 

                    //                          info = createInfo(subInfo, subNodeList); 

                    //                      } 

                    //                      nodeValue = info; 

                    //                  } 

                    //mod by wangzheng at 20110329 end 

                    String name = field.getName(); 

                    Object defaultValue = field.getDefaultValue(); 

                    String checkRegular = field.getCheckRegular(); 

                     

                    // 如果默认值为null那么根据数据类型获取默认值

                    if (null == defaultValue || "".equals(defaultValue)) 

                    { 

                        defaultValue = getDefaultValue(type); 

                    } 

                    // 如果节点值为null的话就给节点赋默认值

                    nodeValue = null == nodeValue ? defaultValue : nodeValue; 

                    nodeValue = nodeValue instanceof java.util.List ? nodeValue : changeXmlToStr(nodeValue); 

                    // 正则表达式校验

                    if (null != checkRegular && !"".equals(checkRegular)) 

                    { 

                        if (!check(nodeValue, checkRegular)) 

                        { 

                            StringBuffer sbf = new StringBuffer("The field value is illegal."); 

                            sbf.append(nodeName).append("=[").append(nodeValue).append("]."); 

                            sbf.append("regex=[").append(checkRegular).append("]"); 

                            throw new HttpException(sbf.toString()); 

                        } 

                    } 

                    // 设置info属性值

                    setInfoAttValue(obj, name, type, nodeValue); 

                } 

            } 

        } 

        catch (HttpException e) 

        { 

            throw e; 

        } 

        catch (Exception e) 

        { 

            e.printStackTrace(); 

            throw new HttpException("The bean conversion xml fail.", e); 

        } 

        return obj; 

    } 

     

    private static String deleteXmlHead(String msg) 

    { 

        int startIndex = msg.indexOf("<Message>"); 

        if (startIndex > -1) 

        { 

            msg = msg.substring(startIndex, msg.length()); 

        } 

        return msg; 

    } 

     

    /**

     * 根据传入的正则表达式验证传入的字符串是否合法

     * 

     * @param str 需要校验的字符串

     * @param regex 正则表达式

     * @return booean true:合法false:不合法

     */ 

    private static boolean check(Object str, String regex) 

    { 

        Pattern pattern = Pattern.compile(regex); 

        Matcher matcher = pattern.matcher(str.toString()); 

        return matcher.matches(); 

    } 

     

    /**

     * 设置指定info中的指定属性值

     * 

     * @param obj 实体bean

     * @param name 属性名称

     * @param type 属性取值类型

     * @param value 要设置的属性值

     * @throws IllegalAccessException

     */ 

    private static void setInfoAttValue(Object obj, String name, String type, Object value) 

        throws IllegalAccessException 

    { 

        Class<?> cls = obj.getClass(); 

        // 获取info中所有属性

        Field[] fields = cls.getDeclaredFields(); 

        AccessibleObject.setAccessible(fields, true); 

         

        // 找到匹配的属性并赋值

        for (Field field : fields) 

        { 

            if (field.getName().equalsIgnoreCase(name)) 

            { 

                if (type.equalsIgnoreCase("java.lang.String") || type.equalsIgnoreCase("String")) 

                { 

                    field.set(obj, value); 

                } 

                else if (type.equalsIgnoreCase("java.util.List")) 

                { 

                    field.set(obj, value); 

                } 

                else if (type.equalsIgnoreCase("java.lang.Integer") || type.equalsIgnoreCase("int")) 

                { 

                    field.setInt(obj, Integer.parseInt((String)value)); 

                } 

                else if (type.equalsIgnoreCase("java.lang.Double") || type.equalsIgnoreCase("double")) 

                { 

                    field.setDouble(obj, Double.parseDouble((String)value)); 

                } 

                else if (type.equalsIgnoreCase("java.lang.Long") || type.equalsIgnoreCase("long")) 

                { 

                    field.setLong(obj, Long.parseLong((String)value)); 

                } 

                else if (type.equalsIgnoreCase("java.lang.Float") || type.equalsIgnoreCase("float")) 

                { 

                    field.setFloat(obj, Float.parseFloat((String)value)); 

                } 

                else if (type.equalsIgnoreCase("java.lang.Boolean") || type.equalsIgnoreCase("boolean")) 

                { 

                    field.setBoolean(obj, Boolean.parseBoolean((String)value)); 

                } 

                else if (type.equalsIgnoreCase("java.lang.Character") || type.equalsIgnoreCase("char")) 

                { 

                    char c = null == value ? ' ' : ((String)value).toCharArray()[0]; 

                    field.setChar(obj, c); 

                } 

                else if (type.equalsIgnoreCase("java.lang.Short") || type.equalsIgnoreCase("Short")) 

                { 

                    field.setShort(obj, Short.parseShort((String)value)); 

                } 

                else if (type.equalsIgnoreCase("com.huawei.nvs.sys.conn.http.bean.HttpInfo") 

                    || type.equalsIgnoreCase("HttpInfo")) 

                { 

                    field.set(obj, value); 

                } 

                 

                break; 

            } 

        } 

    } 

     

    private static Object getDefaultValue(String type) 

    { 

        Object obj = null; 

        if (type.equalsIgnoreCase("java.lang.Integer") || type.equalsIgnoreCase("int")) 

        { 

            obj = Integer.valueOf(0); 

        } 

        else if (type.equalsIgnoreCase("java.lang.Double") || type.equalsIgnoreCase("double")) 

        { 

            obj = Double.valueOf(0.0); 

        } 

        else if (type.equalsIgnoreCase("java.lang.Long") || type.equalsIgnoreCase("long")) 

        { 

            obj = Long.valueOf(0L); 

        } 

        else if (type.equalsIgnoreCase("java.lang.Float") || type.equalsIgnoreCase("float")) 

        { 

            obj = Float.valueOf(0F); 

        } 

        else if (type.equalsIgnoreCase("java.lang.Boolean") || type.equalsIgnoreCase("boolean")) 

        { 

            obj = Boolean.valueOf(false); 

        } 

        else if (type.equalsIgnoreCase("java.lang.Character") || type.equalsIgnoreCase("char")) 

        { 

            obj = null; 

        } 

        else if (type.equalsIgnoreCase("java.lang.Short") || type.equalsIgnoreCase("Short")) 

        { 

            obj = Short.valueOf("0"); 

        } 

        else if (type.equalsIgnoreCase("java.lang.String") || type.equalsIgnoreCase("String")) 

        { 

            obj = null; 

        } 

        return obj; 

    } 

}   

点击复制链接 与好友分享!回本站首页

文章来源:http://www.bozhiyue.com/html_css/2016/0812/368002.html
评论
发表评论