java 网页参数转换

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.util.*;

public class UrlParamUtil {
    private static final Log log;

    /**
     * 将map参数转换成网页参数,当map不为空时转换结果为 e.g id=1&username=2,反之为null
     * 支持key值为List集合,默认其值为基本类型,除key的值类型为List外,默认值为基本类型进行生成参数
     *  e.g
     Map<String, Object> stringMap = new LinkedHashMap<String, Object>();
     stringMap.put("value1", new String[]{"1", "2"});
     stringMap.put("value2", new Object[]{"1", "2"});
     stringMap.put("value3", new Object[]{"1"});
     stringMap.put("value4", true);
     stringMap.put("value5", Arrays.asList("1", "2"));
     // result: value1=1&value1=2&value2=1&value2=2&value3=1&value4=true&value5=1&value5=2
     *
     * @param map {id:[1, 2, 3], value: 1};
     * @return null/id=1&username=2
     */
    public static String parseMapToUrlParams(Map<String, ?> map) {
        String result = null;
        if (map != null) {
            StringBuffer sb = new StringBuffer();
            boolean hasValue = false;
            for (Map.Entry<String, ?> entry : map.entrySet()) {
                hasValue = true;
                String key = entry.getKey();
                Object value = entry.getValue();
                if (value == null) {
                    parseMapToUrlParamsAppend(sb, key, null);
                } else {
                    if (ListOrArrayUtil.isArray(value)) {  //是数组或List时
                        int size = ListOrArrayUtil.getArraySize(value);
                        if (size > 0) {
                            for (int i = 0; i < size; i++) {
                                Object currentValue = ListOrArrayUtil.getArrayValue(value, i);
                                if (currentValue == null) {
                                    parseMapToUrlParamsAppend(sb, key, null);
                                } else { //判断是否为支持的数据类型,支持时进行拼接
                                    appendSimpleData(currentValue, sb, key);
                                }
                            }
                        } else {
                            parseMapToUrlParamsAppend(sb, key, null);
                        }
                    } else {  //判断是否为支持的数据类型,支持时进行拼接
                        appendSimpleData(value, sb, key);
                    }
                }
            }
            if (hasValue) {  //移除最后多余的&
                int length = sb.length();
                sb.delete(length - 1, length);
            }
            result = sb.toString();
            if (result.equals("")) {
                result = null;
            }
        }

        return result;
    }

    public static Map<String, List<String>> parseParamsToMap(String url) {
        Map<String, List<String>> resultMap = null;
        if (url != null) {
            int index = url.indexOf("?");
            if (index >= 0) {
                url = url.substring(index + 1);
            }

            String[] array = url.split("&");

            if (array != null && array.length > 0) {
                resultMap = new LinkedHashMap<String, List<String>>();
                for(String value: array) {
                    index = value.indexOf("=");
                    if (index > 0) {
                        String key = value.substring(0, index);
                        if (key != null) {
                            key = key.trim();
                            if (key.length() > 0) {
                                String currentValue = value.substring(index + 1);
                                if (currentValue != null) {
                                    List<String> list = resultMap.get(key);
                                    if (list == null) {
                                        list = new ArrayList<String>();
                                        resultMap.put(key, list);
                                    }
                                    list.add(currentValue);
                                }
                            }
                        }

                    }
                }
            }

        }
        return resultMap;
    }



    /**
     * 用于生成网页参数时的拼接函数
     * @param sb
     * @param key
     * @param value
     */
    private static void parseMapToUrlParamsAppend(StringBuffer sb, String key, Object value) {
        if (sb != null) {
            if (value == null) {
                value = "";
            }
            sb.append(key);
            sb.append("=");
            sb.append(value);
            sb.append("&");
        }
    }

    /**
     * 判断是否为支持的数据类型,支持时进行拼接,不支持时输出提示信息
     * @param value
     * @param sb
     * @param key
     */
    private static void appendSimpleData(Object value, StringBuffer sb, String key) {
        if (value != null) {
            Class<?> currentValueClass = value.getClass();
            if (SimpleDataUtil.support(currentValueClass)) {  //如果支持此类型时
                if (currentValueClass.equals(String.class)) {
                    value = ResponseEncodeUtil.encode((String) value);
                }
                parseMapToUrlParamsAppend(sb, key, value);
            } else {
                if (log.isInfoEnabled()) {
                    log.info(" not support " + currentValueClass.getName() + ",\n continue append the key: " + key + ", value: " + value);
                }
            }
        }

    }

    public static void main(String[] args) {
        Map<String, Object> stringMap = new LinkedHashMap<String, Object>();
        stringMap.put("value1", new String[]{"1", "2"});
        stringMap.put("value2", new Object[]{"1", "2"});
        stringMap.put("value3", new Object[]{"1", Arrays.asList("1"), true});
        stringMap.put("value4", true);
        stringMap.put("value5", Arrays.asList("1", 1, 1l, 1.0f, 1.0d, true, new Date(), (short)1));
        System.out.println(parseMapToUrlParams(stringMap));  //   value1=1&value1=2&value2=1&value2=2&value3=1&value3=true&value4=true&value5=1&value5=1&value5=1&value5=1.0&value5=1.0&value5=true&value5=1
        System.out.println(parseParamsToMap("?value1=1&value1=2&value2=1&value2=2&value3=1&value3=true&value4=true&value5=1&value5=1&value5=1&value5=1.0&value5=1.0&value5=true&value5=1"));  //{value1=[1, 2], value2=[1, 2], value3=[1, true], value4=[true], value5=[1, 1, 1, 1.0, 1.0, true, 1]}
    }


    static {
        log = LogFactory.getLog(UrlParamUtil.class);
    }

}

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.lang.reflect.Array;
import java.util.List;

/**
 * List对象或数组[]工具类
 */
public class ListOrArrayUtil {

    private final static Log log;

    /**
     * 判断该对象是否为数组
     * @param object
     * @return
     */
    public static boolean isArray(Object object) {
        if (object != null) {
            if (object instanceof List) {
                return true;
            } else if (object.getClass().isArray()) {
                return true;
            }
        }
        return false;
    }

    /**
     * 获取该数组的大小
     * @param object
     * @return
     */
    public static int getArraySize(Object object) {
        int size = 0;
        if (object != null) {
            if (object instanceof List) {
                size = ((List) object).size();
            } else if (object.getClass().isArray()) {
                size = Array.getLength(object);
            } else {
                if (log.isWarnEnabled()) {
                    log.warn(object + "is not array");
                }
            }
        } else {
            if (log.isWarnEnabled()) {
                log.warn("the value is null");
            }
        }
        return size;
    }

    /**
     * 获取该数组对象对应索引的值
     * @param object --- List对象或[]数组
     * @param index
     * @return
     */
    public static Object getArrayValue(Object object, int index) {
        if (object instanceof List) {
            return ((List) object).get(index);
        } else {
            if (object.getClass().isArray()) {
                return Array.get(object, index);
            }
        }
        return null;
    }

    static {
        log = LogFactory.getLog(ListOrArrayUtil.class);
    }

}

import java.util.HashMap;
import java.util.Map;

/**
 * 判断是否对以下数据类型的支持
 * Long/long Short/short String Boolean/boolean Float/float Integer/int Double/double
 */
public class SimpleDataUtil {

    private static final Map<Class, Class> SUPPORT_MAP = new HashMap<Class, Class>();;

    static {
        SUPPORT_MAP.put(String.class, String.class);
        SUPPORT_MAP.put(Integer.class, Integer.class);
        SUPPORT_MAP.put(int.class, Integer.class);
        SUPPORT_MAP.put(Long.class, Long.class);
        SUPPORT_MAP.put(long.class, Long.class);
        SUPPORT_MAP.put(Short.class, Short.class);
        SUPPORT_MAP.put(short.class, Short.class);
        SUPPORT_MAP.put(Boolean.class, Boolean.class);
        SUPPORT_MAP.put(boolean.class, Boolean.class);
        SUPPORT_MAP.put(Float.class, Float.class);
        SUPPORT_MAP.put(float.class, Float.class);
        SUPPORT_MAP.put(Double.class, Double.class);
        SUPPORT_MAP.put(double.class, Double.class);
    }


    /**
     * 判断是否支持该类型
     * @param type
     * @return
     */
    public static boolean support(Class<?> type) {
        if (type != null && SUPPORT_MAP.containsKey(type)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 获取该类型对应的包装类
     * @param type
     * @return
     */
    public static Class<?> getWrapperClass(Class<?> type) {
        return SUPPORT_MAP.get(type);
    }
}

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URLEncoder;

public class ResponseEncodeUtil {
    private static final Log log;
    private static Method encode;

    /**
     * Filter the specified string for characters that are senstive to HTML
     * interpreters, returning the string with these characters replaced by
     * the corresponding character entities.
     *
     * @param value The string to be filtered and returned
     */
    public static String filter(String value) {
        if ((value == null) || (value.length() == 0)) {
            return value;
        }

        StringBuffer result = null;
        String filtered = null;

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

            switch (value.charAt(i)) {
                case '<':
                    filtered = "&lt;";

                    break;

                case '>':
                    filtered = "&gt;";

                    break;

                case '&':
                    filtered = "&amp;";

                    break;

                case '"':
                    filtered = "&quot;";

                    break;

                case '\'':
                    filtered = "&#39;";

                    break;
            }

            if (result == null) {
                if (filtered != null) {
                    result = new StringBuffer(value.length() + 50);

                    if (i > 0) {
                        result.append(value.substring(0, i));
                    }

                    result.append(filtered);
                }
            } else {
                if (filtered == null) {
                    result.append(value.charAt(i));
                } else {
                    result.append(filtered);
                }
            }
        }

        return (result == null) ? value : result.toString();
    }

    /**
     * URLencodes a string assuming the character encoding is UTF-8.
     *
     * @param value
     * @return String The encoded value in UTF-8
     */
    public static String encode(String value) {
        return encode(value, "UTF-8");
    }

    /**
     * Use the new URLEncoder.encode() method from Java 1.4 if available, else
     * use the old deprecated version.  This method uses reflection to find
     * the appropriate method; if the reflection operations throw exceptions,
     * this will return the url encoded with the old URLEncoder.encode()
     * method.
     * @param value
     * @param enc The character encoding the urlencode is performed on.
     * @return String The encoded value.
     */
    public static String encode(String value, String enc) {
        try {
            if ((enc == null) || (enc.length() == 0)) {
                enc = "UTF-8";
            }

            // encode url with new 1.4 method and UTF-8 encoding
            if (encode != null) {
                return (String) encode.invoke(null, new Object[] { value, enc });
            }
        } catch (IllegalAccessException e) {
            log.debug("Could not find Java 1.4 encode method.  Using deprecated version.",
                    e);
        } catch (InvocationTargetException e) {
            log.debug("Could not find Java 1.4 encode method. Using deprecated version.",
                    e);
        }

        return URLEncoder.encode(value);
    }

    public static void main(String[] args) {
        System.out.println(filter("<script>alert(2333);</script>"));
        System.out.println(encode("张三"));
    }

    static {
        log = LogFactory.getLog(ResponseEncodeUtil.class);
        try {
            Class[] args = new Class[]{String.class, String.class};
            encode = URLEncoder.class.getMethod("encode", args);
        } catch (NoSuchMethodException var1) {
            log.debug("Could not find Java 1.4 encode method.  Using deprecated version.", var1);
        }
    }


}