classes.java

非常接近C/S操作方式的Java Ajax框架－ZK 用ZK框架使你的B/S应用程序更漂亮更易操作。 官网：www.zkoss.org

/* Classes.java

{{IS_NOTE

	Purpose: Utilities to handle Class
	Description:
	History:
	 2001/4/19, Tom M. Yeh: Created.

}}IS_NOTE

Copyright (C) 2001 Potix Corporation. All Rights Reserved.

{{IS_RIGHT
	This program is distributed under GPL Version 2.0 in the hope that
	it will be useful, but WITHOUT ANY WARRANTY.
}}IS_RIGHT
*/
package org.zkoss.lang;

import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.LinkedList;
import java.util.Collection;
import java.util.Arrays;
import java.util.Date;
import java.lang.reflect.Constructor;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Method;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Modifier;
import java.math.BigDecimal;
import java.math.BigInteger;

import org.zkoss.mesg.MCommon;
import org.zkoss.mesg.Messages;
import org.zkoss.lang.Strings;
import org.zkoss.lang.Objects;
import org.zkoss.math.BigDecimals;
import org.zkoss.math.BigIntegers;
import org.zkoss.util.CacheMap;
import org.zkoss.util.IllegalSyntaxException;
import org.zkoss.util.logging.Log;

/**
 * Utilities to handle java.lang.Class
 *
 * @author tomyeh
 */
public class Classes {
	private static final Log log = Log.lookup(Classes.class);

	/**
	 * Creates and intializes a new instance of the specified class with
	 * the specified arguments.
	 *
	 * <p>Note only public constructors are searched.
	 *
	 * @param cls the class of the instance to create
	 * @param argTypes the argument types of the constructor to inovke
	 * @param args the arguments to initialize the instance
	 * @return the new instance
	 *
	 * @exception NoSuchMethodException if a matching method is not found
	 * @exception InstantiationException if the class that declares the
	 * underlying constructor represents an abstract class
	 * @exception InvocationTargetException if the underlying constructor
	 * throws an exception
	 * @see #newInstance(String, Class[], Object[])
	 */
	public static final
	Object newInstance(Class cls, Class[] argTypes, Object[] args)
	throws NoSuchMethodException, InstantiationException,
	InvocationTargetException {
	 	Constructor contr = cls.getConstructor(argTypes);
	 	try {
	 		return contr.newInstance(args);
	 	} catch (IllegalAccessException ex) {
	 		throw SystemException.Aide.wrap(ex);
	 	}
	}

	/**
	 * Creates and initializes a new instance of the specified class name
	 * with the specified arguments.
	 *
	 * <p>It uses Class.forName to get the class.
	 *
	 * @param clsName the class name of the instance to create
	 * @param argTypes the argument types of the constructor to inovke
	 * @param args the arguments to initialize the instance
	 * @return the new instance
	 *
	 * @exception NoSuchMethodException if a matching method is not found
	 * @exception InstantiationException if the class that declares the
	 * underlying constructor represents an abstract class
	 * @exception InvocationTargetException if the underlying constructor
	 * throws an exception
	 * @exception ClassNotFoundException if the specified class name is not a class
	 * @see #newInstance(Class, Class[], Object[])
	 */
	public static final Object
	newInstance(String clsName, Class[] argTypes, Object[] args)
	throws NoSuchMethodException, InstantiationException,
	InvocationTargetException, ClassNotFoundException {
	 	return newInstance(Class.forName(clsName), argTypes, args);
	}
	/**
	 * Creates and initializes a new instance of the specified class name
	 * with the specified arguments, by use of {@link #forNameByThread}.
	 *
	 * <p>It uses {@link #forNameByThread} to get the class.
	 *
	 * @param clsName the class name of the instance to create
	 * @param argTypes the argument types of the constructor to inovke
	 * @param args the arguments to initialize the instance
	 * @return the new instance
	 *
	 * @exception NoSuchMethodException if a matching method is not found
	 * @exception InstantiationException if the class that declares the
	 * underlying constructor represents an abstract class
	 * @exception InvocationTargetException if the underlying constructor
	 * throws an exception
	 * @exception ClassNotFoundException if the specified class name is not a class
	 * @see #newInstance(Class, Class[], Object[])
	 */
	public static final Object
	newInstanceByThread(String clsName, Class[] argTypes, Object[] args)
	throws NoSuchMethodException, InstantiationException,
	InvocationTargetException, ClassNotFoundException {
	 	return newInstance(forNameByThread(clsName), argTypes, args);
	}
	/**
	 * Creates and initializes a new instance of the specified class name
	 * with default constructor, by use of {@link #forNameByThread}.
	 */
	public static final Object newInstanceByThread(String clsName)
	throws NoSuchMethodException, InstantiationException,
	InvocationTargetException, ClassNotFoundException {
		return newInstance(forNameByThread(clsName), null, null);
	}
	/**
	 * Returns the Class object of the specified class name, using
	 * the current thread's context class loader.
	 *
	 * <p>In additions, it handles the primitive types, such as int and double.
	 *
	 * @param clsName fully qualified name of the desired class
	 * @return the Class object representing the desired class
	 * @exception ClassNotFoundException if the class cannot be located by the specified class loader
	 */
	public static final Class forNameByThread(String clsName)
	throws ClassNotFoundException {
		clsName = toInternalForm(clsName);
		final Class cls = Primitives.toClass(clsName);
		return cls != null ? cls:
			Class.forName(clsName, true, Thread.currentThread().getContextClassLoader());
	}

	/**
	 * Change class name to internal form (e.g. byte[] -> [B). If already in
	 * internal form, then just return it.
	 */
	public static final String toInternalForm(String clsName) {
		final int k = clsName.indexOf('[');
		if (k <= 0) { //not an array, or already in internal form
			return clsName;	//just return
		}

		//component class
		final String elm = clsName.substring(0, k).trim();
		if (elm.length() == 0)
			throw new IllegalArgumentException("Not a legal class name: \""+clsName+'"');

		//array depth
		boolean leftb = false;
		final String stub = clsName.substring(k);
		final StringBuffer sb = new StringBuffer(128);
		for (int j = 0; j < stub.length(); j++) {
			final char ch = stub.charAt(j);
			if (ch == '[') {
				if (leftb)
					throw new IllegalArgumentException("Not a legal class name: \""+clsName+'"');
				leftb = true;
				sb.append('[');
			} else if (ch == ']') {
				if (!leftb)
					throw new IllegalArgumentException("Not a legal class name: \""+clsName+'"');
				leftb = false;
			}
		}
		if (leftb)
			throw new IllegalArgumentException("Not a legal class name: \""+clsName+'"');

		final char code = Primitives.getNotation(elm);
		if (code != (char)0) {//primitive array
			sb.append(code);
		} else {//object array
			sb.append('L').append(elm).append(';');
		}
		return sb.toString();
	}

	/**
	 * Gets the topmost interface of the specified class or interface that
	 * implements or extends the specified interface.
	 * For example, if A extends B, and C implements A,
	 * then getTopInterface(C, B) returns A.
	 *
	 * <p>The interfaces implemented by the specified class is checked first,
	 * and then the subclass.
	 *
	 * @param cls the class or interface
	 * @param subIF the sub-interface
	 * @return the topmost interface extending subIF, or null if subIF
	 * is not implemented by cls
	 */
	public static Class getTopmostInterface(Class cls, Class subIF) {
		if (cls.isInterface())
			return subIF.isAssignableFrom(cls) ? cls: null;

		while (cls != null) {
			final Class[] ifs = cls.getInterfaces();
			for (int j = 0; j < ifs.length; ++j)
				if (subIF.isAssignableFrom(ifs[j]))
					return ifs[j];

			cls = cls.getSuperclass();
		}
		return null;
	}

	/**
	 * Tests whether a class contains the specified method.
	 * Only public methods are tested.
	 *
	 * @param cls the class to test
	 * @param name the method name
	 * @param paramTypes the list of parameter types
	 * @return true if it contains the method
	 */
	public static final boolean containsMethod
	(Class cls, String name, Class[] paramTypes) {
		try {
			cls.getMethod(name, paramTypes);
			return true;
		} catch (NoSuchMethodException ex) {//no found
			return false;
		}
	}

	/** Corrects a string to a valid Java name.
	 * Currently, it only removes '-' and capitalizes the succeeding
	 * character. Example, 'field-name' becomes 'fieldName'.
	 */
	public final static String correctFieldName(String name) {
		int j = name.indexOf('-');
		if (j < 0)
			return name; //nothing to change

		for (final StringBuffer sb = new StringBuffer(name);;) {
			sb.deleteCharAt(j);
			if (sb.length() == j)
				return sb.toString();

			sb.setCharAt(j, Character.toUpperCase(sb.charAt(j)));

			j = sb.indexOf("-", j);
			if (j < 0)
				return sb.toString();
		}
	}

	/**
	 * Convert an attribute name, returned by toAttributeName, to
	 * a method name.
	 *
	 * <p>toMethodName("true", "is") => "isTrue"<br>
	 * toMethodName("true", "") => "true"
	 *
	 * @param attrName the attribute name
	 * @param prefix the prefix; one of is, get and set
	 * @return the method name
	 * @see #toAttributeName
	 */
	public static final String toMethodName(String attrName, String prefix) {
		if (prefix.length() == 0)
			return attrName;

		StringBuffer sb = new StringBuffer(prefix);
		char[] buf = attrName.toCharArray();
		buf[0] = Character.toUpperCase(buf[0]);
		return sb.append(buf).toString();
	}

	/**
	 * Tests if a method name is an attribute, i.e., prefixing with is,
	 * get or set. Caller could then test if it is a setter or getter
	 * by charAt(0)=='s'.
	 *
	 * <p>Note 'set' is considered as an attribute, whose name is an
	 * empty string.
	 *
	 * @param methodName the method name to test
	 * @return true if it is setter or getter
	 */
	public static final boolean isAttribute(String methodName) {
		int len = methodName.length();
		if (len < 2)
			return false;

		int j;
		switch (methodName.charAt(0)) {
		case 's':
		case 'g':
			if (len<3 || methodName.charAt(1)!='e' || methodName.charAt(2)!='t')
				return false;
			j = 3;
			break;
		case 'i':
			if (methodName.charAt(1)!='s')
				return false;
			j = 2;
			break;
		default:
			return false;
		}
		return j==len || Character.isUpperCase(methodName.charAt(j));
	}

	/**
	 * Converts a method name to an attribute name by removing the prefix
	 * is, get or set, or null if it doesn't start with is, get or set.
	 *
	 * <p>The code is optimized for better performance.
	 *
	 * @param methodName the method name
	 * @return the attribute name; null if it is not an attribute name
	 * @see #toMethodName
	 */
	public static final String toAttributeName(String methodName) {
		int len = methodName.length();
		if (len < 2)
			return null;

		int j;
		switch (methodName.charAt(0)) {
		case 's':
		case 'g':
			if (len<3 || methodName.charAt(1)!='e' || methodName.charAt(2)!='t')
				return null;
			j = 3;
			break;
		case 'i':
			if (methodName.charAt(1)!='s')
				return null;
			j = 2;
			break;
		default:
			return null;
		}
		if (j==len || Character.isUpperCase(methodName.charAt(j))) {
			char[] buf = new char[len - j];
			if (buf.length>0) {
				methodName.getChars(j, len, buf, 0);
				buf[0] = Character.toLowerCase(buf[0]);
			}
			return new String(buf);
		}
		return null;
	}

	//--Support Class--
	/**The method info class used for {@link #parseMethod(String signature)}.
	 * This info describe the method return type, method name and two collections for
	 * arguments type and arguments name;
	 */
	public static class MethodInfo {
		/** The return type (class name), or null if no specified. */
		public String returnType;
		public String method;
		public String[] argTypes;
		public String[] argNames;
		public String throwsEx;
		
		//constructor
		protected MethodInfo(String r, String m, String[] argTs, String[] argNs, String tEx) {
			returnType = r;
			method = m;
			argTypes = argTs;
			argNames = argNs;
			throwsEx = tEx;
		}
	}
	/**
	 * Gets the method information from a signature. 
	 * It returns a method info with the return type, method name and two collections 
	 * of arguments type and arguments name.
	 *
	 * @param signature the method signature.
	 * @return MethodInfo The method information including return type, method name
	 *			and two collections for argument type annd arguments name.
	 */
	public static final MethodInfo parseMethod(String signature) 
	throws IllegalSyntaxException {
		int len = signature.length();
		int j = Strings.skipWhitespaces(signature, 0);
		int k = Strings.anyOf(signature, "( \t\n\r", j);
		k = Strings.skipWhitespaces(signature, k);
		if (k >= len)
			throw new IllegalSyntaxException(signature);
		
		String returnType = null;
		char cc = signature.charAt(k);
		if (cc != '(') {	
			//skip the return type
			returnType = signature.substring(j, k).trim();
			//
			j = k;
			k = signature.indexOf('(', j + 1);
			if (k < 0)
				throw new IllegalSyntaxException(signature);	
		}
		String method = signature.substring(j, k).trim();
		
		Collection argTypes = new LinkedList();
		Collection argNames = new LinkedList();
		do {