java.lang.reflect.Method

package java.lang.reflect;

import sun.reflect.MethodAccessor;
import sun.reflect.Reflection;

/**
 *
 * 描述方法的类
 *
 * 注意使用反射的方式是首先通过
 * Class.getMethod(String name, Class[] parameterTypes)获得一个Method对象
 * String表示方法名,parameterTypes表示参数列表中的每个参数对应的类型,这时先获得
 * Class对象中Method对象,与实际的操作对象无关,然后调用此方法,是通过Method.(Object obj, Object[] args)
 * 这里obj指调用方法的对象,args表示每个参数对应的值
 *
 * 例子,一下两种方式的效果是一样的(当然性能不同)
 * String ost = "lqtest";
 * String nst = ost.substring(2,6);
 *
 * String ost2 = "lqtest";
 * Class[] types = {int.class, int.class};
 * Method med = String.class.getMethod("substring", types);
 * Object[] values ={new Integer(2), new Integer(6)};
 * String nst2 = (String) med.invoke(ost2, values);
 *
 * 使用反射一切都是变化的,类名,方法名,参数列表,都是变量,而不是写死的,他们
 * 在运行时才知道具体值,而不是编译期
 *
 * comment by liqiang
 *
 * @author Kenneth Russell
 * @author Nakul Saraiya
 */
public final
class Method extends AccessibleObject implements Member {
 //定义此方法的类对象
    private Class  clazz;
    private int   slot;
    //方法名,从1.4开始它变成intern的形式
    private String  name;
    //返回类型
    private Class  returnType;
    //参数列表
    private Class[]  parameterTypes;
    //异常列表
    private Class[]  exceptionTypes;
    //方法的描述符
    private int   modifiers;
    //处理方法的实际对象
    private volatile MethodAccessor methodAccessor;
    //如果当前对象是通过拷贝得到的,则root指向拷贝前的对象
    private Method              root;

    //调用对象的安全检查的缓存,保存上一个通过检查的调用对象,如果当前的调用对象
    //不是上一个调用对象则做安全检查
    private volatile Class      securityCheckTargetClassCache;

    //构造函数
    Method(Class declaringClass,
           String name,
           Class[] parameterTypes,
           Class returnType,
           Class[] checkedExceptions,
           int modifiers,
           int slot)
    {
        this.clazz = declaringClass;
        this.name = name;
        this.parameterTypes = parameterTypes;
        this.returnType = returnType;
        this.exceptionTypes = checkedExceptions;
        this.modifiers = modifiers;
        this.slot = slot;
    }

    //通过本对象的数据生成一个新对象
    Method copy() {
     //通过本对象的数据生成一个新对象
        Method res = new Method(clazz, name, parameterTypes, returnType,
                                exceptionTypes, modifiers, slot);
        //新对象的root指向原对象
        res.root = this;
        //新对象与原对象公用一个MethodAccessor
        res.methodAccessor = methodAccessor;
        return res;
    }

    //返回声明此函数的类
    public Class getDeclaringClass() {
 return clazz;
    }

    //返回方法名
    public String getName() {
 return name;
    }

    //返回描述符
    public int getModifiers() {
 return modifiers;
    }

    //取得返回类型
    public Class getReturnType() {
 return returnType;
    }

    //返回参数列表
    public Class[] getParameterTypes() {
 return copy(parameterTypes);
    }

    //返回异常列表
    public Class[] getExceptionTypes() {
 return copy(exceptionTypes);
    }

    //判断obj是否与当前方法对象相等
    public boolean equals(Object obj) {
 if (obj != null && obj instanceof Method) {//如果是方法对象
  //转型
     Method other = (Method)obj;
    
     //定义此方法的类和方法名相等
     if ((getDeclaringClass() == other.getDeclaringClass())
  && (getName() == other.getName())) {
      
  /* Avoid unnecessary cloning */
  Class[] params1 = parameterTypes;
  Class[] params2 = other.parameterTypes;
  
  //比较参数列表
  if (params1.length == params2.length) {
      for (int i = 0; i < params1.length; i++) {
   if (params1[i] != params2[i])
       return false;
      }
      return true;
  }
  
     }
 }
 return false;
    }

    //返回hashCode
    public int hashCode() {
 return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
    }

    //方法对象的字符串表示
    public String toString() {
 try {
     StringBuffer sb = new StringBuffer();
     int mod = getModifiers();
     if (mod != 0) {
     //标志符
  sb.append(Modifier.toString(mod) + " ");
     }
     //注意它这里用的是Field方法中显示类的名字,这个方法显示数组类型跟Class.getName()不同
     //添加返回类型
     sb.append(Field.getTypeName(getReturnType()) + " ");
     //添加类名
     sb.append(Field.getTypeName(getDeclaringClass()) + ".");
     //添加方法名
     sb.append(getName() + "(");   
    
     //参数列表
     Class[] params = parameterTypes; // avoid clone
     for (int j = 0; j < params.length; j++) {
  sb.append(Field.getTypeName(params[j]));
  if (j < (params.length - 1))
      sb.append(",");
     }
     sb.append(")");
    
     //异常列表
     Class[] exceptions = exceptionTypes; // avoid clone
     if (exceptions.length > 0) {
  sb.append(" throws ");
  for (int k = 0; k < exceptions.length; k++) {
      sb.append(exceptions[k].getName());
      if (k < (exceptions.length - 1))
   sb.append(",");
  }
     }
     return sb.toString();
 } catch (Exception e) {
     return "<" + e + ">";
 }
    }

    /**
     *
     * 注意使用反射的方式是首先通过
     * Class.getMethod(String name, Class[] parameterTypes)获得一个Method对象
     * String表示方法名,parameterTypes表示参数列表中的每个参数对应的类型,这时先获得
     * Class对象中Method对象,与实际的操作对象无关,然后调用此方法,是通过Method.(Object obj, Object[] args)
     * 如果调用的方法是static的则obj对象为null,如果方法没有参数,则args的长度为0或为null
     * 如果返回值是原始类型则返回它的封装类,如果返回值是void则返回null
     */
    public Object invoke(Object obj, Object[] args)
 throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
             //获得调用对象的Class对象
                Class caller = Reflection.getCallerClass(1);
               
                Class targetClass = ((obj == null || !Modifier.isProtected(modifiers))
                                     ? clazz
                                     : obj.getClass());
                //调用此操作的对象或方法调用作用的对象与缓存不同,则做安全检查
                if (securityCheckCache != caller ||
                    targetClass != securityCheckTargetClassCache) {
                    Reflection.ensureMemberAccess(caller, clazz, obj, modifiers);
                    securityCheckCache = caller;
                    //通过安全检查的调用对象,缓存它供下次调用时使用
                    securityCheckTargetClassCache = targetClass;
                }
            }
        }
       
        if (methodAccessor == null) acquireMethodAccessor();
        return methodAccessor.invoke(obj, args);
    }

    //如果此对象是由copy生成的,则对象与生成此对象的对象使用同一个MethodAccessor
    private void acquireMethodAccessor() {
        MethodAccessor tmp = null;
       
        if (root != null) tmp = root.getMethodAccessor();
        if (tmp != null) {
            methodAccessor = tmp;
            return;
        }
       
        //不是由copy得来创建MethodAccessor对象
        tmp = reflectionFactory.newMethodAccessor(this);
        setMethodAccessor(tmp);
    }

    //返回MethodAccessor对象
    MethodAccessor getMethodAccessor() {
        return methodAccessor;
    }

    //设置MethodAccessor对象
    void setMethodAccessor(MethodAccessor accessor) {
        methodAccessor = accessor;
        if (root != null) {//如果此对象是由copy的来
         //递归调用其上级
            root.setMethodAccessor(accessor);
        }
    }

    //生成一个新的Class数组并将原数组内容考到新数组中
    static Class[] copy(Class[] in) {
 int l = in.length;
 
 if (l == 0)
     return in;
 
 Class[] out = new Class[l];
 for (int i = 0; i < l; i++)
     out[i] = in[i];
 
 return out;
    }
}