java反射之Method的invoke方法实现教程详解

public class MethodInvoke {
 
	public static void main(String[] args) throws Exception {
		Method animalMethod = Animal.class.getDeclaredMethod("print");
		Method catMethod = Cat.class.getDeclaredMethod("print");
		
		Animal animal = new Animal();
		Cat cat = new Cat();
		animalMethod.invoke(cat);
		animalMethod.invoke(animal);
		
		catMethod.invoke(cat);
		catMethod.invoke(animal);
	}
	
}
 
class Animal {
	
	public void print() {
		System.out.println("Animal.print()");
	}
	
}
 
class Cat extends Animal {
	
	@Override
	public void print() {
		System.out.println("Cat.print()");
	}
	
}

 public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException
 {
 if (!override) {
 if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
 Class<?> caller = Reflection.getCallerClass(1);
 
 checkAccess(caller, clazz, obj, modifiers);
 }
 }
 MethodAccessor ma = methodAccessor; // read volatile
 if (ma == null) {
 ma = acquireMethodAccessor();
 }
 return ma.invoke(obj, args);
 }

 public void setAccessible(boolean flag) throws SecurityException {
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) sm.checkPermission(ACCESS_PERMISSION);
 setAccessible0(this, flag);
 }
 
 private static void setAccessible0(AccessibleObject obj, boolean flag)
 throws SecurityException
 {
 if (obj instanceof Constructor && flag == true) {
 Constructor<?> c = (Constructor<?>)obj;
 if (c.getDeclaringClass() == Class.class) {
 throw new SecurityException("Can not make a java.lang.Class" +
   " constructor accessible");
 }
 }
 obj.override = flag;
 }

 MethodAccessor ma = methodAccessor; // read volatile
 if (ma == null) {
 ma = acquireMethodAccessor();
 }
 return ma.invoke(obj, args);

 private volatile MethodAccessor methodAccessor;
 private Method root;
 
 private MethodAccessor acquireMethodAccessor() {
 // First check to see if one has been created yet, and take it
 // if so
 MethodAccessor tmp = null;
 if (root != null) tmp = root.getMethodAccessor();
 if (tmp != null) {
 methodAccessor = tmp;
 } else {
 // Otherwise fabricate one and propagate it up to the root
 tmp = reflectionFactory.newMethodAccessor(this);
 setMethodAccessor(tmp);
 }
 
 return tmp;
 }
 
 void setMethodAccessor(MethodAccessor accessor) {
 methodAccessor = accessor;
 // Propagate up
 if (root != null) {
 root.setMethodAccessor(accessor);
 }
 }
 
 Method copy() {
 Method res = new Method(clazz, name, parameterTypes, returnType,
  exceptionTypes, modifiers, slot, signature,
  annotations, parameterAnnotations, annotationDefault);
 res.root = this;
 res.methodAccessor = methodAccessor;
 return res;
 }

 public MethodAccessor newMethodAccessor(Method method) {
 checkInitted();
 
 if (noInflation) {
 return new MethodAccessorGenerator().
 generateMethod(method.getDeclaringClass(),
  method.getName(),
  method.getParameterTypes(),
  method.getReturnType(),
  method.getExceptionTypes(),
  method.getModifiers());
 } else {
 NativeMethodAccessorImpl acc =
 new NativeMethodAccessorImpl(method);
 DelegatingMethodAccessorImpl res =
 new DelegatingMethodAccessorImpl(acc);
 acc.setParent(res);
 return res;
 }
 }

 private static void checkInitted() {
 if (initted) return;
 AccessController.doPrivileged(
 new PrivilegedAction<Void>() {
 public Void run() {
 
  if (System.out == null) {
  // java.lang.System not yet fully initialized
  return null;
  }
 
  String val = System.getProperty("sun.reflect.noInflation");
  if (val != null && val.equals("true")) {
  noInflation = true;
  }
 
  val = System.getProperty("sun.reflect.inflationThreshold");
  if (val != null) {
  try {
  inflationThreshold = Integer.parseInt(val);
  } catch (NumberFormatException e) {
  throw (RuntimeException)
  new RuntimeException("Unable to parse property sun.reflect.inflationThreshold").
   initCause(e);
  }
  }
 
  initted = true;
  return null;
 }
 });
 }

 public Object invoke(Object obj, Object[] args) 
 throws IllegalArgumentException, InvocationTargetException
 {
 if (++numInvocations > ReflectionFactory.inflationThreshold()) {
 MethodAccessorImpl acc = (MethodAccessorImpl)
 new MethodAccessorGenerator().
  generateMethod(method.getDeclaringClass(),
   method.getName(),
   method.getParameterTypes(),
   method.getReturnType(),
   method.getExceptionTypes(),
   method.getModifiers());
 parent.setDelegate(acc);
 }
 
 return invoke0(method, obj, args);
 }
 
 private static native Object invoke0(Method m, Object obj, Object[] args);

public class GeneratedMethodAccessor1 extends MethodAccessorImpl {
 
	public GeneratedMethodAccessor1 () {
	 super();
	}
	
	public Object invoke(Object obj, Object[] args)
	 throws IllegalArgumentException, InvocationTargetException 
	{
		if (!(obj instanceof Cat)) {
			throw new ClassCastException();
		}
		if (args != null && args.length != 0) {
			throw new IllegalArgumentException();
		}
		
		try {
			Cat cat = (Cat) obj;
			cat.print();
			return null;
		} catch (Throwable e) {
			throw new InvocationTargetException(e, "invoke error");
		}
	}
	
}

JNIEXPORT jobject JNICALL Java_sun_reflect_NativeMethodAccessorImpl_invoke0
(JNIEnv *env, jclass unused, jobject m, jobject obj, jobjectArray args)
{
 return JVM_InvokeMethod(env, m, obj, args);
}

JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
 JVMWrapper("JVM_InvokeMethod");
 Handle method_handle;
 if (thread->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
 method_handle = Handle(THREAD, JNIHandles::resolve(method));
 Handle receiver(THREAD, JNIHandles::resolve(obj));
 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
 jobject res = JNIHandles::make_local(env, result);
 if (JvmtiExport::should_post_vm_object_alloc()) {
 oop ret_type = java_lang_reflect_Method::return_type(method_handle());
 assert(ret_type != NULL, "sanity check: ret_type oop must not be NULL!");
 if (java_lang_Class::is_primitive(ret_type)) {
 // Only for primitive type vm allocates memory for java object.
 // See box() method.
 JvmtiExport::post_vm_object_alloc(JavaThread::current(), result);
 }
 }
 return res;
 } else {
 THROW_0(vmSymbols::java_lang_StackOverflowError());
 }
JVM_END

oop Reflection::invoke_method(oop method_mirror, Handle receiver, objArrayHandle args, TRAPS) {
 oop mirror = java_lang_reflect_Method::clazz(method_mirror);
 int slot = java_lang_reflect_Method::slot(method_mirror);
 bool override = java_lang_reflect_Method::override(method_mirror) != 0;
 objArrayHandle ptypes(THREAD, objArrayOop(java_lang_reflect_Method::parameter_types(method_mirror)));
 
 oop return_type_mirror = java_lang_reflect_Method::return_type(method_mirror);
 BasicType rtype;
 if (java_lang_Class::is_primitive(return_type_mirror)) {
 rtype = basic_type_mirror_to_basic_type(return_type_mirror, CHECK_NULL);
 } else {
 rtype = T_OBJECT;
 }
 
 instanceKlassHandle klass(THREAD, java_lang_Class::as_Klass(mirror));
 Method* m = klass->method_with_idnum(slot);
 if (m == NULL) {
 THROW_MSG_0(vmSymbols::java_lang_InternalError(), "invoke");
 }
 methodHandle method(THREAD, m);
 
 return invoke(klass, method, receiver, override, ptypes, rtype, args, true, THREAD);
}
 
oop Reflection::invoke(instanceKlassHandle klass, methodHandle reflected_method,
  Handle receiver, bool override, objArrayHandle ptypes,
  BasicType rtype, objArrayHandle args, bool is_method_invoke, TRAPS) {
 ResourceMark rm(THREAD);
 
 methodHandle method; // actual method to invoke
 KlassHandle target_klass; // target klass, receiver's klass for non-static
 
 // Ensure klass is initialized
 klass->initialize(CHECK_NULL);
 
 bool is_static = reflected_method->is_static();
 if (is_static) {
 // ignore receiver argument
 method = reflected_method;
 target_klass = klass;
 } else {
 // check for null receiver
 if (receiver.is_null()) {
 THROW_0(vmSymbols::java_lang_NullPointerException());
 }
 // Check class of receiver against class declaring method
 if (!receiver->is_a(klass())) {
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "object is not an instance of declaring class");
 }
 // target klass is receiver's klass
 target_klass = KlassHandle(THREAD, receiver->klass());
 // no need to resolve if method is private or <init>
 if (reflected_method->is_private() || reflected_method->name() == vmSymbols::object_initializer_name()) {
 method = reflected_method;
 } else {
 // resolve based on the receiver
 if (reflected_method->method_holder()->is_interface()) {
 // resolve interface call
 if (ReflectionWrapResolutionErrors) {
 // new default: 6531596
 // Match resolution errors with those thrown due to reflection inlining
 // Linktime resolution & IllegalAccessCheck already done by Class.getMethod()
 method = resolve_interface_call(klass, reflected_method, target_klass, receiver, THREAD);
 if (HAS_PENDING_EXCEPTION) {
 // Method resolution threw an exception; wrap it in an InvocationTargetException
 oop resolution_exception = PENDING_EXCEPTION;
 CLEAR_PENDING_EXCEPTION;
 JavaCallArguments args(Handle(THREAD, resolution_exception));
 THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),
 vmSymbols::throwable_void_signature(),
 &args);
 }
 } else {
 method = resolve_interface_call(klass, reflected_method, target_klass, receiver, CHECK_(NULL));
 }
 } else {
 // if the method can be overridden, we resolve using the vtable index.
 assert(!reflected_method->has_itable_index(), "");
 int index = reflected_method->vtable_index();
 method = reflected_method;
 if (index != Method::nonvirtual_vtable_index) {
 // target_klass might be an arrayKlassOop but all vtables start at
 // the same place. The cast is to avoid virtual call and assertion.
 InstanceKlass* inst = (InstanceKlass*)target_klass();
 method = methodHandle(THREAD, inst->method_at_vtable(index));
 }
 if (!method.is_null()) {
 // Check for abstract methods as well
 if (method->is_abstract()) {
 // new default: 6531596
 if (ReflectionWrapResolutionErrors) {
 ResourceMark rm(THREAD);
 Handle h_origexception = Exceptions::new_exception(THREAD,
  vmSymbols::java_lang_AbstractMethodError(),
  Method::name_and_sig_as_C_string(target_klass(),
  method->name(),
  method->signature()));
 JavaCallArguments args(h_origexception);
 THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),
 vmSymbols::throwable_void_signature(),
 &args);
 } else {
 ResourceMark rm(THREAD);
 THROW_MSG_0(vmSymbols::java_lang_AbstractMethodError(),
  Method::name_and_sig_as_C_string(target_klass(),
    method->name(),
    method->signature()));
 }
 }
 }
 }
 }
 }
 
 // I believe this is a ShouldNotGetHere case which requires
 // an internal vtable bug. If you ever get this please let Karen know.
 if (method.is_null()) {
 ResourceMark rm(THREAD);
 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(),
 Method::name_and_sig_as_C_string(klass(),
    reflected_method->name(),
    reflected_method->signature()));
 }
 
 // In the JDK 1.4 reflection implementation, the security check is
 // done at the Java level
 if (!(JDK_Version::is_gte_jdk14x_version() && UseNewReflection)) {
 
 // Access checking (unless overridden by Method)
 if (!override) {
 if (!(klass->is_public() && reflected_method->is_public())) {
 bool access = Reflection::reflect_check_access(klass(), reflected_method->access_flags(), target_klass(), is_method_invoke, CHECK_NULL);
 if (!access) {
 return NULL; // exception
 }
 }
 }
 
 } // !(Universe::is_gte_jdk14x_version() && UseNewReflection)
 
 assert(ptypes->is_objArray(), "just checking");
 int args_len = args.is_null() ? 0 : args->length();
 // Check number of arguments
 if (ptypes->length() != args_len) {
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "wrong number of arguments");
 }
 
 // Create object to contain parameters for the JavaCall
 JavaCallArguments java_args(method->size_of_parameters());
 
 if (!is_static) {
 java_args.push_oop(receiver);
 }
 
 for (int i = 0; i < args_len; i++) {
 oop type_mirror = ptypes->obj_at(i);
 oop arg = args->obj_at(i);
 if (java_lang_Class::is_primitive(type_mirror)) {
 jvalue value;
 BasicType ptype = basic_type_mirror_to_basic_type(type_mirror, CHECK_NULL);
 BasicType atype = unbox_for_primitive(arg, &value, CHECK_NULL);
 if (ptype != atype) {
 widen(&value, atype, ptype, CHECK_NULL);
 }
 switch (ptype) {
 case T_BOOLEAN: java_args.push_int(value.z); break;
 case T_CHAR: java_args.push_int(value.c); break;
 case T_BYTE: java_args.push_int(value.b); break;
 case T_SHORT: java_args.push_int(value.s); break;
 case T_INT: java_args.push_int(value.i); break;
 case T_LONG: java_args.push_long(value.j); break;
 case T_FLOAT: java_args.push_float(value.f); break;
 case T_DOUBLE: java_args.push_double(value.d); break;
 default:
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "argument type mismatch");
 }
 } else {
 if (arg != NULL) {
 Klass* k = java_lang_Class::as_Klass(type_mirror);
 if (!arg->is_a(k)) {
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "argument type mismatch");
 }
 }
 Handle arg_handle(THREAD, arg); // Create handle for argument
 java_args.push_oop(arg_handle); // Push handle
 }
 }
 
 assert(java_args.size_of_parameters() == method->size_of_parameters(), "just checking");
 
 // All oops (including receiver) is passed in as Handles. An potential oop is returned as an
 // oop (i.e., NOT as an handle)
 JavaValue result(rtype);
 JavaCalls::call(&result, method, &java_args, THREAD);
 
 if (HAS_PENDING_EXCEPTION) {
 // Method threw an exception; wrap it in an InvocationTargetException
 oop target_exception = PENDING_EXCEPTION;
 CLEAR_PENDING_EXCEPTION;
 JavaCallArguments args(Handle(THREAD, target_exception));
 THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),
 vmSymbols::throwable_void_signature(),
 &args);
 } else {
 if (rtype == T_BOOLEAN || rtype == T_BYTE || rtype == T_CHAR || rtype == T_SHORT)
 narrow((jvalue*) result.get_value_addr(), rtype, CHECK_NULL);
 return box((jvalue*) result.get_value_addr(), rtype, CHECK_NULL);
 }
}

method = resolve_interface_call(klass, reflected_method, target_klass, receiver, CHECK_(NULL));

methodHandle Reflection::resolve_interface_call(instanceKlassHandle klass, methodHandle method,
      KlassHandle recv_klass, Handle receiver, TRAPS) {
 assert(!method.is_null() , "method should not be null");
 
 CallInfo info;
 Symbol* signature = method->signature();
 Symbol* name = method->name();
 LinkResolver::resolve_interface_call(info, receiver, recv_klass, klass,
     name, signature,
     KlassHandle(), false, true,
     CHECK_(methodHandle()));
 return info.selected_method();
}

 // if the method can be overridden, we resolve using the vtable index.
 assert(!reflected_method->has_itable_index(), "");
 int index = reflected_method->vtable_index();
 method = reflected_method;
 if (index != Method::nonvirtual_vtable_index) {
  // target_klass might be an arrayKlassOop but all vtables start at
  // the same place. The cast is to avoid virtual call and assertion.
  InstanceKlass* inst = (InstanceKlass*)target_klass();
  method = methodHandle(THREAD, inst->method_at_vtable(index));
 }