/* * Copyright 2005 Joe Walker * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *     http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.directwebremoting.util;import java.io.IOException;import java.io.InputStream;import java.io.RandomAccessFile;import java.io.Reader;import java.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.net.URLDecoder;import java.util.ArrayList;import java.util.Arrays;import java.util.HashSet;import java.util.Iterator;import java.util.List;import java.util.Locale;import java.util.Map;import java.util.Set;import javax.servlet.ServletConfig;import javax.servlet.ServletContext;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import javax.servlet.http.HttpSession;import javax.xml.transform.TransformerFactoryConfigurationError;/** * 一些通用的方法 * Various utilities, mostly to make up for JDK 1.4 functionallity that is not * in JDK 1.3 * @author Joe Walker [joe at getahead dot ltd dot uk] */public final class LocalUtil{    /**     * splitInbound() returns the type info in this parameter     */    public static final int INBOUND_INDEX_TYPE = 0;    /**     * splitInbound() returns the value info in this parameter     */    public static final int INBOUND_INDEX_VALUE = http://www.mamicode.com/1;    /**     * Prevent instansiation     */    private LocalUtil()    {    }    /**     * Replacement for String#replaceAll(String, String) in JDK 1.4+     * @param text source text     * @param repl the stuff to get rid of     * @param with the stuff to replace it with     * @return replaced text or null if any args are null     */    public static String replace(String text, String repl, String with)    {        if (text == null || repl == null || with == null || repl.length() == 0)        {            return text;        }        StringBuffer buf = new StringBuffer(text.length());        int searchFrom = 0;        while (true)        {            int foundAt = text.indexOf(repl, searchFrom);            if (foundAt == -1)            {                break;            }            buf.append(text.substring(searchFrom, foundAt)).append(with);            searchFrom = foundAt + repl.length();        }        buf.append(text.substring(searchFrom));        return buf.toString();    }    /**     * 判断给定的字符串是否符合 Java 标识符的规范     *      * Determines if the specified string is permissible as a Java identifier.     * Returns true if the string is non-null, non-zero length with a Java     * identifier start as the first character and Java identifier parts in all     * remaining characters.     * @param test the string to be tested.     * @return true if the string is a Java identifier, false otherwise.     * @see java.lang.Character#isJavaIdentifierPart(char)     * @see java.lang.Character#isJavaIdentifierStart(char)     */    public static boolean isJavaIdentifier(String test)    {        if (test == null || test.length() == 0)        {            return false;        }        if (!Character.isJavaIdentifierStart(test.charAt(0)) && test.charAt(0) != ‘_‘)        {            return false;        }        for (int i = 1; i < test.length(); i++)        {            if (!Character.isJavaIdentifierPart(test.charAt(i)) && test.charAt(i) != ‘_‘)            {                return false;            }        }        return true;    }    /**     * Determines if the specified string contains only Unicode letters or     * digits as defined by {@link Character#isLetterOrDigit(char)}     * @param test The string to test     * @return true if the string is non-null, non-empty and contains only     * characters that are unicode letters or digits     * @see Character#isLetterOrDigit(char)     */    public static boolean isLetterOrDigitOrUnderline(String test)    {        if (test == null || test.length() == 0)        {            return false;        }        for (int i = 0; i < test.length(); i++)        {            if (!Character.isLetterOrDigit(test.charAt(i)) && test.charAt(i) != ‘_‘)            {                return false;            }        }        return true;    }    /**     * True if c1 is java.lang.Boolean and c2 is boolean, etc.     * @param c1 the first class to test     * @param c2 the second class to test     * @return true if the classes are equivalent     */    public static boolean isEquivalent(Class c1, Class c2)    {        if (c1 == Boolean.class || c1 == Boolean.TYPE)        {            return c2 == Boolean.class || c2 == Boolean.TYPE;        }        else if (c1 == Byte.class || c1 == Byte.TYPE)        {            return c2 == Byte.class || c2 == Byte.TYPE;        }        else if (c1 == Character.class || c1 == Character.TYPE)        {            return c2 == Character.class || c2 == Character.TYPE;        }        else if (c1 == Short.class || c1 == Short.TYPE)        {            return c2 == Short.class || c2 == Short.TYPE;        }        else if (c1 == Integer.class || c1 == Integer.TYPE)        {            return c2 == Integer.class || c2 == Integer.TYPE;        }        else if (c1 == Long.class || c1 == Long.TYPE)        {            return c2 == Long.class || c2 == Long.TYPE;        }        else if (c1 == Float.class || c1 == Float.TYPE)        {            return c2 == Float.class || c2 == Float.TYPE;        }        else if (c1 == Double.class || c1 == Double.TYPE)        {            return c2 == Double.class || c2 == Double.TYPE;        }        else if (c1 == Void.class || c1 == Void.TYPE)        {            return c2 == Void.class || c2 == Void.TYPE;        }        return false;    }    /**     * @param type The class to de-primitivize     * @return The non-privitive version of the class     */    public static Class getNonPrimitiveType(Class type)    {        if (!type.isPrimitive())        {            return type;        }        else if (type == Boolean.TYPE)        {            return Boolean.class;        }        else if (type == Byte.TYPE)        {            return Byte.class;        }        else if (type == Character.TYPE)        {            return Character.class;        }        else if (type == Short.TYPE)        {            return Short.class;        }        else if (type == Integer.TYPE)        {            return Integer.class;        }        else if (type == Long.TYPE)        {            return Long.class;        }        else if (type == Float.TYPE)        {            return Float.class;        }        else if (type == Double.TYPE)        {            return Double.class;        }        else if (type == Void.TYPE)        {            return Void.class;        }        return null;    }    /**     * Add headers to prevent browers and proxies from caching this reply.     * @param resp The response to add headers to     */    public static void addNoCacheHeaders(HttpServletResponse resp)    {        // Set standard HTTP/1.1 no-cache headers.        resp.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");        // Set IE extended HTTP/1.1 no-cache headers (use addHeader).        resp.addHeader("Cache-Control", "post-check=0, pre-check=0");        // Set standard HTTP/1.0 no-cache header.        resp.setHeader("Pragma", "no-cache");        // Set to expire far in the past. Prevents caching at the proxy server        resp.setHeader("Expires", "Sat, 6 May 1995 12:00:00 GMT");    }    /**     * Is this class one that we auto fill, so the user can ignore?     * @param paramType The type to test     * @return true if the type is a Servlet type     */    public static boolean isServletClass(Class paramType)    {        return paramType == HttpServletRequest.class ||               paramType == HttpServletResponse.class ||               paramType == ServletConfig.class ||               paramType == ServletContext.class ||               paramType == HttpSession.class;    }    /**     * URL decode a value. This method gets around the lack of a     * decode(String, String) method in JDK 1.3.     * @param value The string to decode     * @return The decoded string     */    public static String decode(String value)    {        if (!testedDecoder)        {            try            {                decode14 = URLDecoder.class.getMethod("decode", new Class[] { String.class, String.class });            }            catch (Exception ex)            {                if (!warn13)                {                    log.warn("URLDecoder.decode(String, String) is not available. Falling back to 1.3 variant.");                    warn13 = true;                }            }            testedDecoder = true;        }        if (decode14 != null)        {            try            {                return (String) decode14.invoke(null, new Object[] { value, "UTF-8" });            }            catch (Exception ex)            {                log.warn("Failed to use JDK 1.4 decoder", ex);            }        }        return URLDecoder.decode(value);    }    /**     * 用反射给对象设置属性集     *      * Set use reflection to set the setters on the object called by the keys     * in the params map with the corresponding values     * @param object The object to setup     * @param params The settings to use     * @param ignore List of keys to not warn about if they are not properties     *               Note only the warning is skipped, we still try the setter     */    public static void setParams(Object object, Map params, List ignore)    {        for (Iterator it = params.entrySet().iterator(); it.hasNext();)        {            Map.Entry entry = (Map.Entry) it.next();            String key = (String) entry.getKey();            Object value = entry.getValue();            try            {                setProperty(object, key, value);            }            catch (NoSuchMethodException ex)            {                if (ignore != null && !ignore.contains(key))                {                    log.warn("No property ‘" + key + "‘ on " + object.getClass().getName());                }            }            catch (InvocationTargetException ex)            {                log.warn("Error setting " + key + "=" + value + " on " + object.getClass().getName(), ex.getTargetException());            }            catch (Exception ex)            {                log.warn("Error setting " + key + "=" + value + " on " + object.getClass().getName(), ex);            }        }    }    /**     * 用反射给对象设置属性，通过给定的属性名。     *      * Set a property on an object using reflection     * @param object The object to call the setter on     * @param key The name of the property to set.     * @param value The new value to use for the property     * @throws NoSuchMethodException Passed on from reflection code     * @throws SecurityException Passed on from reflection code     * @throws IllegalAccessException Passed on from reflection code     * @throws IllegalArgumentException Passed on from reflection code     * @throws InvocationTargetException Passed on from reflection code     */    public static void setProperty(Object object, String key, Object value) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException    {        Class real = object.getClass();        String setterName = "set" + key.substring(0, 1).toUpperCase(Locale.ENGLISH) + key.substring(1);        try        {            // Can we work with whatever type we were given?            Method method = real.getMethod(setterName, new Class[] { value.getClass() });            method.invoke(object, new Object[] { value });            return;        }        catch (NoSuchMethodException ex)        {            // If it is a string then next we try to coerce it to the right type            // otherwise we give up.            if (!(value instanceof String))            {                throw ex;            }        }        Method[] methods = real.getMethods();        for (int i = 0; i < methods.length; i++)        {            Method setter = methods[i];            if (setter.getName().equals(setterName) && setter.getParameterTypes().length == 1)            {                Class propertyType = setter.getParameterTypes()[0];                try                {                    Object param = LocalUtil.simpleConvert((String) value, propertyType);                    setter.invoke(object, new Object[] { param });                    return;                }                catch (IllegalArgumentException ex)                {                    // The conversion failed - it was speculative anyway so we                    // don‘t worry now                }            }        }        throw new NoSuchMethodException("Failed to find a property called: " + key + " on " + object.getClass().getName());    }    /**     * Can the type be used in a call to {@link #simpleConvert(String, Class)}?     * @param paramType The type to test     * @return true if the type is acceptable to simpleConvert()     */    public static boolean isTypeSimplyConvertable(Class paramType)    {        return paramType == String.class ||            paramType == Integer.class ||            paramType == Integer.TYPE ||            paramType == Short.class ||            paramType == Short.TYPE ||            paramType == Byte.class ||            paramType == Byte.TYPE ||            paramType == Long.class ||            paramType == Long.TYPE ||            paramType == Float.class ||            paramType == Float.TYPE ||            paramType == Double.class ||            paramType == Double.TYPE ||            paramType == Character.class ||            paramType == Character.TYPE ||            paramType == Boolean.class ||            paramType == Boolean.TYPE;    }    /**     * A very simple conversion function for all the IoC style setup and     * reflection that we are doing.     * @param value The value to convert     * @param paramType The type to convert to. Currently ony primitive types and     * String are supported.     * @return The converted object.     */    public static Object simpleConvert(String value, Class paramType)    {        if (paramType == String.class)        {            return value;        }        if (paramType == Character.class || paramType == Character.TYPE)        {            if (value.length() == 1)            {                return new Character(value.charAt(0));            }            else            {                throw new IllegalArgumentException("Can‘t more than one character in string - can‘t convert to char: ‘" + value + "‘");            }        }        String trimValue = value.trim();        if (paramType == Boolean.class)        {            if (trimValue.length() == 0)            {                return null;            }            return Boolean.valueOf(trimValue);        }        if (paramType == Boolean.TYPE)        {            return Boolean.valueOf(trimValue);        }        if (paramType == Integer.class)        {            if (trimValue.length() == 0)            {                return null;            }            return Integer.valueOf(trimValue);        }        if (paramType == Integer.TYPE)        {            if (trimValue.length() == 0)            {                return new Integer(0);            }            return Integer.valueOf(trimValue);        }        if (paramType == Short.class)        {            if (trimValue.length() == 0)            {                return null;            }            return Short.valueOf(trimValue);        }        if (paramType == Short.TYPE)        {            if (trimValue.length() == 0)            {                return new Short((short) 0);            }            return Short.valueOf(trimValue);        }        if (paramType == Byte.class)        {            if (trimValue.length() == 0)            {                return null;            }            return Byte.valueOf(trimValue);        }        if (paramType == Byte.TYPE)        {            if (trimValue.length() == 0)            {                return new Byte((byte) 0);            }            return Byte.valueOf(trimValue);        }        if (paramType == Long.class)        {            if (trimValue.length() == 0)            {                return null;            }            return Long.valueOf(trimValue);        }        if (paramType == Long.TYPE)        {            if (trimValue.length() == 0)            {                return new Long(0);            }            return Long.valueOf(trimValue);        }        if (paramType == Float.class)        {            if (trimValue.length() == 0)            {                return null;            }            return Float.valueOf(trimValue);        }        if (paramType == Float.TYPE)        {            if (trimValue.length() == 0)            {                return new Float(0);            }            return Float.valueOf(trimValue);        }        if (paramType == Double.class)        {            if (trimValue.length() == 0)            {                return null;            }            return Double.valueOf(trimValue);        }        if (paramType == Double.TYPE)        {            if (trimValue.length() == 0)            {                return new Double(0);            }            return Double.valueOf(trimValue);        }        throw new IllegalArgumentException("Unsupported conversion type: " + paramType.getName());    }    /**     * 得到除去包名的类名。     *      * Get the short class name (i.e. without the package part)     * @param clazz the class to get the short name of     * @return the class name of the class without the package name     */    public static String getShortClassName(Class clazz)    {        String className = clazz.getName();        char[] chars = className.toCharArray();        int lastDot = 0;        for (int i = 0; i < chars.length; i++)        {            if (chars[i] == ‘.‘)            {                lastDot = i + 1;            }            else if (chars[i] == ‘$‘)            {                chars[i] = ‘.‘;            }        }        // This might come up in scans for locale/charset issues. It‘s not an        // issue since we are talking about chars.        return new String(chars, lastDot, chars.length - lastDot);    }    /**     * Is this object property one that we can use in a JSON style or do we need     * to get fancy. i.e does it contain only letters and numbers with an     * initial letter.     * @param name The name to test for JSON compatibility     * @return true if the name is simple     */    public static boolean isSimpleName(String name)    {        if (name.length() == 0)        {            return false;        }        if (JavascriptUtil.isReservedWord(name))        {            return false;        }        boolean isSimple = Character.isLetter(name.charAt(0));        for (int i = 1; isSimple && i < name.length(); i++)        {            if (!Character.isLetterOrDigit(name.charAt(i)))            {                isSimple = false;            }        }        return isSimple;    }    /**     * Utility to essentially do Class forName and allow configurable     * Classloaders.     * <p>The initial implementation makes use of the context classloader for     * the current thread.     * @param className The class to create     * @return The class if it is safe or null otherwise.     * @throws ClassNotFoundException If <code>className</code> is not valid     */    public static Class classForName(String className) throws ClassNotFoundException    {        // Class.forName(className);        return Thread.currentThread().getContextClassLoader().loadClass(className);    }    /**     * Calling methods using reflection is useful for graceful fallback - this     * is a helper method to make this easy     * @param object The object to use as ‘this‘     * @param method The method to call, can be null in which case null is returned     * @param params The parameters to pass to the reflection call     * @return The results of calling method.invoke() or null     * @throws IllegalStateException If anything goes wrong     */    public static Object invoke(Object object, Method method, Object[] params) throws IllegalStateException    {        Object reply = null;        if (method != null)        {            try            {                reply = method.invoke(object, params);            }            catch (InvocationTargetException ex)            {                throw new IllegalStateException("InvocationTargetException calling " + method.getName() + ": " + ex.getTargetException().toString());            }            catch (Exception ex)            {                throw new IllegalStateException("Reflection error calling " + method.getName() + ": " + ex.toString());            }        }        return reply;    }    /**     * Utility to essentially do Class forName with the assumption that the     * environment expects failures for missing jar files and can carry on if     * this process fails.     * @param name The name for debugging purposes     * @param className The class to create     * @param impl The implementation class - what should className do?     * @return The class if it is safe or null otherwise.     */    public static Class classForName(String name, String className, Class impl)    {        Class clazz;        try        {            clazz = classForName(className);        }        catch (ClassNotFoundException ex)        {            // We expect this sometimes, hence debug            log.debug("Skipping ‘" + name + "‘ due to ClassNotFoundException on " + className + ". Cause: " + ex.getMessage());            return null;        }        catch (NoClassDefFoundError ex)        {            // We expect this sometimes, hence debug            log.debug("Skipping ‘" + name + "‘ due to NoClassDefFoundError on " + className + ". Cause: " + ex.getMessage());            return null;        }        catch (TransformerFactoryConfigurationError ex)        {            // We expect this sometimes, hence debug            log.debug("Skipping ‘" + name + "‘ due to TransformerFactoryConfigurationError on " + className + ". Cause: " + ex.getMessage());            log.debug("Maybe you need to add xalan.jar to your webserver?");            return null;        }        // Check it is of the right type        if (!impl.isAssignableFrom(clazz))        {            log.error("Class ‘" + clazz.getName() + "‘ does not implement ‘" + impl.getName() + "‘.");            return null;        }        // Check we can create it        try        {            clazz.newInstance();        }        catch (InstantiationException ex)        {            log.error("InstantiationException for ‘" + name + "‘ failed:", ex);            return null;        }        catch (IllegalAccessException ex)        {            log.error("IllegalAccessException for ‘" + name + "‘ failed:", ex);            return null;        }        catch (NoClassDefFoundError ex)        {            // We expect this sometimes, hence debug            log.debug("Skipping ‘" + name + "‘ due to NoClassDefFoundError on " + className + ". Cause: " + ex.getMessage());            return null;        }        catch (TransformerFactoryConfigurationError ex)        {            // We expect this sometimes, hence debug            log.debug("Skipping ‘" + name + "‘ due to TransformerFactoryConfigurationError on " + className + ". Cause: " + ex.getMessage());            log.debug("Maybe you need to add xalan.jar to your webserver?");            return null;        }        catch (Exception ex)        {            // For some reason we can‘t catch this?            if (ex instanceof ClassNotFoundException)            {                // We expect this sometimes, hence debug                log.debug("Skipping ‘" + name + "‘ due to ClassNotFoundException on " + className + ". Cause: " + ex.getMessage());                return null;            }            else            {                log.error("Failed to load ‘" + name + "‘ (" + className + ")", ex);                return null;            }        }        return clazz;    }    /**     * Utility to essentially do Class forName and newInstance with the     * assumption that the environment expects failures for missing jar files     * and can carry on if this process fails.     * @param name The name for debugging purposes     * @param className The class to create     * @param impl The implementation class - what should className do?     * @return The new instance if it is safe or null otherwise.     */    public static Object classNewInstance(String name, String className, Class impl)    {        Class clazz;        try        {            clazz = LocalUtil.classForName(className);        }        catch (ClassNotFoundException ex)        {            // We expect this sometimes, hence debug            log.debug("Skipping ‘" + name + "‘ due to ClassNotFoundException on " + className + ". Cause: " + ex.getMessage());            return null;        }        catch (NoClassDefFoundError ex)        {            // We expect this sometimes, hence debug            log.debug("Skipping ‘" + name + "‘ due to NoClassDefFoundError on " + className + ". Cause: " + ex.getMessage());            return null;        }        catch (TransformerFactoryConfigurationError ex)        {            // We expect this sometimes, hence debug            log.debug("Skipping ‘" + name + "‘ due to TransformerFactoryConfigurationError on " + className + ". Cause: " + ex.getMessage());            return null;        }        // Check it is of the right type        if (!impl.isAssignableFrom(clazz))        {            log.error("Class ‘" + clazz.getName() + "‘ does not implement ‘" + impl.getName() + "‘.");            return null;        }        // Check we can create it        try        {            return clazz.newInstance();        }        catch (InstantiationException ex)        {            log.error("InstantiationException for ‘" + name + "‘ failed:", ex);            return null;        }        catch (IllegalAccessException ex)        {            log.error("IllegalAccessException for ‘" + name + "‘ failed:", ex);            return null;        }        catch (TransformerFactoryConfigurationError ex)        {            log.error("TransformerFactoryConfigurationError for ‘" + name + "‘ failed:", ex);            return null;        }        catch (Exception ex)        {            log.error("Failed to load creator ‘" + name + "‘, classname=" + className + ": ", ex);            return null;        }    }    /**     * InputStream closer that can cope if the input stream is null.     * If anything goes wrong, the errors are logged and ignored.     * @param in The resource to close     */    public static void close(InputStream in)    {        if (in == null)        {            return;        }        try        {            in.close();        }        catch (IOException ex)        {            log.warn(ex.getMessage(), ex);        }    }    /**     * InputStream closer that can cope if the input stream is null.     * If anything goes wrong, the errors are logged and ignored.     * @param in The resource to close     */    public static void close(Reader in)    {        if (in == null)        {            return;        }        try        {            in.close();        }        catch (IOException ex)        {            log.warn(ex.getMessage(), ex);        }    }    /**     * InputStream closer that can cope if the input stream is null.     * If anything goes wrong, the errors are logged and ignored.     * @param in The resource to close     */    public static void close(RandomAccessFile in)    {        if (in == null)        {            return;        }        try        {            in.close();        }        catch (IOException ex)        {            log.warn(ex.getMessage(), ex);        }    }    /**     * Return a List of superclasses for the given class.     * @param clazz the class to look up     * @return the List of superclasses in order going up from this one     */    public static List getAllSuperclasses(Class clazz)    {        List classes = new ArrayList();        Class superclass = clazz.getSuperclass();        while (superclass != null)        {            classes.add(superclass);            superclass = superclass.getSuperclass();        }        return classes;    }    /**     * Return a list of all fields (whatever access status, and on whatever     * superclass they were defined) that can be found on this class.     * <p>This is like a union of {@link Class#getDeclaredFields()} which     * ignores and superclasses, and {@link Class#getFields()} which ignored     * non-pubic fields     * @param clazz The class to introspect     * @return The complete list of fields     */    public static Field[] getAllFields(Class clazz)    {        List classes = getAllSuperclasses(clazz);        classes.add(clazz);        return getAllFields(classes);    }    /**     * As {@link #getAllFields(Class)} but acts on a list of {@link Class}s and     * uses only {@link Class#getDeclaredFields()}.     * @param classes The list of classes to reflect on     * @return The complete list of fields     */    private static Field[] getAllFields(List classes)    {        Set fields = new HashSet();        for (Iterator it = classes.iterator(); it.hasNext();)        {            Class clazz = (Class) it.next();            fields.addAll(Arrays.asList(clazz.getDeclaredFields()));        }        return (Field[]) fields.toArray(new Field[fields.size()]);    }    /**     * The log stream     */    private static final Logger log = Logger.getLogger(LocalUtil.class);    /**     * Have we given a warning about URLDecoder.decode() in jdk 1.3     */    private static boolean warn13 = false;    /**     * Have we tested for the correct URLDecoder.decode()     */    private static boolean testedDecoder = false;    /**     * Are we using the jdk 1.4 version of URLDecoder.decode()     */    private static Method decode14 = null;}