Java Method类代码示例

import java.lang.reflect.Method; //导入依赖的package包/类
/**
 * Used to optimize performance by avoiding expensive file access every time
 * a DTMManager is constructed as a result of constructing a Xalan xpath
 * context!
 */
private static void speedUpDtmManager() throws Exception {
    // https://github.com/aws/aws-sdk-java/issues/238
    // http://stackoverflow.com/questions/6340802/java-xpath-apache-jaxp-implementation-performance
    // CHECKSTYLE:OFF - We need to load system properties from third-party libraries.
    if (System.getProperty(DTM_MANAGER_DEFAULT_PROP_NAME) == null) {
        // CHECKSTYLE:ON
        Class<?> xPathContextClass = Class.forName(XPATH_CONTEXT_CLASS_NAME);
        Method getDtmManager = xPathContextClass.getMethod("getDTMManager");
        Object xPathContext = xPathContextClass.newInstance();
        Object dtmManager = getDtmManager.invoke(xPathContext);

        if (DTM_MANAGER_IMPL_CLASS_NAME.equals(dtmManager.getClass().getName())) {
            // This would avoid the file system to be accessed every time
            // the internal XPathContext is instantiated.
            System.setProperty(DTM_MANAGER_DEFAULT_PROP_NAME,
                               DTM_MANAGER_IMPL_CLASS_NAME);
        }
    }
}
 

import java.lang.reflect.Method; //导入依赖的package包/类
private static <I> I newProxy(final Class<I> interfaceType) {
	Object o = new Object();

	Method getOriginal;
	try {
		getOriginal = ProxyContainer.class.getMethod("getOriginal");
	} catch (NoSuchMethodException | SecurityException e) {
		throw new AssertionError(e);
	}

	I proxyInstance = newProxy(interfaceType, new Class<?>[] { ProxyContainer.class }, (proxy, method, args) -> {
		if (getOriginal.equals(method)) {
			return o;
		}

		for (int i = 0; i < args.length; i++) {
			if (args[i] instanceof ProxyContainer) {
				args[i] = ((ProxyContainer) args[i]).getOriginal();
			}
		}
		return method.invoke(o, args);
	});
	return proxyInstance;
}
 

import java.lang.reflect.Method; //导入依赖的package包/类
private AssertionTreeItem getTreeItemForMethod(Object object, Method method) {
    boolean accessible = method.isAccessible();
    try {
        method.setAccessible(true);
        Object value = method.invoke(object, new Object[] {});
        if (value != null) {
            if (value.getClass().isArray())
                value = RFXComponent.unboxPremitiveArray(value);
            return new AssertionTreeItem(value, getPropertyName(method.getName()));
        }
    } catch (Throwable t) {
    } finally {
        method.setAccessible(accessible);
    }
    return null;
}
 

import java.lang.reflect.Method; //导入依赖的package包/类
@Test
public void testStaticInvoke1() throws Throwable {
    Method method = CountClass.class.getMethod("count");
    int x1, x2, x3;
    method.invoke(count);

    x1 = invoke(method, null);
    x2 = invoke(method, null);
    x3 = invoke(method, null);
    Assert.assertEquals(x1, x2);
    Assert.assertEquals(x1, x3);

    method = CountClass.class.getMethod("count", int.class);
    int X1, X2, X3, X4;

    X1 = invoke(method, new Object[]{1000});
    X2 = invoke(method, new Object[]{2000});
    X3 = invoke(method, new Object[]{1000});
    X4 = invoke(method, new Object[]{2000});
    Assert.assertEquals(X1, X3);
    Assert.assertEquals(X2, X4);

}
 

import java.lang.reflect.Method; //导入依赖的package包/类
private static WebException verifyPureArguments(
        final Validator verifier,
        final Depot depot,
        final Object[] args) {
    final Event event = depot.getEvent();
    final Object proxy = event.getProxy();
    final Method method = event.getAction();
    WebException error = null;
    try {
        if (Virtual.is(proxy)) {
            // TODO: Wait for proxy generation
            // Validation for dynamic proxy
            // final Object delegate = Instance.getProxy(method);
            // verifier.verifyMethod(delegate, method, args);
        } else {
            // Validation for proxy
            verifier.verifyMethod(proxy, method, args);
        }
    } catch (final WebException ex) {
        // Basic validation failure
        error = ex;
    }
    return error;
}
 

import java.lang.reflect.Method; //导入依赖的package包/类
@Override
public AnimatorUpdateListener onLoadingFinish(int footerHeight, Interpolator interpolator, int duration) {
    if (mScrollableView != null) {
        if (mScrollableView instanceof RecyclerView) ((RecyclerView) mScrollableView).smoothScrollBy(0, footerHeight, interpolator);
        else if (mScrollableView instanceof ScrollView) ((ScrollView) mScrollableView).smoothScrollBy(0, footerHeight);
        else if (mScrollableView instanceof AbsListView) ((AbsListView) mScrollableView).smoothScrollBy(footerHeight, duration);
        else {
            try {
                Method method = mScrollableView.getClass().getDeclaredMethod("smoothScrollBy", Integer.class, Integer.class);
                method.invoke(mScrollableView, 0, footerHeight);
            } catch (Exception e) {
                int scrollX = mScrollableView.getScrollX();
                int scrollY = mScrollableView.getScrollY();
                return animation -> mScrollableView.scrollTo(scrollX, scrollY + (int) animation.getAnimatedValue());
            }
        }
        return null;
    }
    return null;
}
 

import java.lang.reflect.Method; //导入依赖的package包/类
public static Object invokeMethod(Method method, Object methodReceiver, Object... methodParamValues) throws
        InvocationTargetException, IllegalAccessException {

    if (method != null) {
        boolean acc = method.isAccessible();

        if (!acc) {
            method.setAccessible(true);
        }

        Object ret = method.invoke(methodReceiver, methodParamValues);

        if (!acc) {
            method.setAccessible(false);
        }

        return ret;
    }

    return null;
}
 

import java.lang.reflect.Method; //导入依赖的package包/类
@Override
protected boolean beforeInvoke(Object receiver, Method method, Object[] args) throws Throwable {
    //2.3,15,16,17,18,19,21
/* public void grantUriPermissionFromOwner(IBinder owner, int fromUid, String targetPkg,
    Uri uri, int mode) throws RemoteException;*/
    //这个函数是用来给某个包授予访问某个URI的权限。
    //插件调用这个函数会传插件自己的包名，而此插件并未被安装。就这样调用原来函数传给系统，是会出问题的。所以改成宿主程序的包名。
    final int index = 2;
    if (args != null && args.length > index) {
        if (args[index] != null && args[index] instanceof String) {
            String targetPkg = (String) args[index];
            if (isPackagePlugin(targetPkg)) {
                args[index] = mHostContext.getPackageName();
            }
        }
    }

    return super.beforeInvoke(receiver, method, args);
}
 

import java.lang.reflect.Method; //导入依赖的package包/类
/**
 * Executes the method of the specified <code>ApplicationContext</code>
 * @param method The method object to be invoked.
 * @param context The AppliationContext object on which the method
 *                   will be invoked
 * @param params The arguments passed to the called method.
 */
private Object executeMethod(final Method method, 
                             final ApplicationContext context,
                             final Object[] params) 
        throws PrivilegedActionException, 
               IllegalAccessException,
               InvocationTargetException {
                                 
    if (SecurityUtil.isPackageProtectionEnabled()){
       return AccessController.doPrivileged(new PrivilegedExceptionAction<Object>(){
            @Override
            public Object run() throws IllegalAccessException, InvocationTargetException{
                return method.invoke(context,  params);
            }
        });
    } else {
        return method.invoke(context, params);
    }        
}
 

import java.lang.reflect.Method; //导入依赖的package包/类
public Object getItem() {
    Object newValue = editor.getText();

    if (oldValue != null && !(oldValue instanceof String))  {
        // The original value is not a string. Should return the value in it's
        // original type.
        if (newValue.equals(oldValue.toString()))  {
            return oldValue;
        } else {
            // Must take the value from the editor and get the value and cast it to the new type.
            Class<?> cls = oldValue.getClass();
            try {
                Method method = MethodUtil.getMethod(cls, "valueOf", new Class[]{String.class});
                newValue = MethodUtil.invoke(method, oldValue, new Object[] { editor.getText()});
            } catch (Exception ex) {
                // Fail silently and return the newValue (a String object)
            }
        }
    }
    return newValue;
}
 

import java.lang.reflect.Method; //导入依赖的package包/类
@Override
public void registerSimpleCommands(Object object) {
    for (Method method : object.getClass().getDeclaredMethods()) {
        cn.nukkit.command.simple.Command def = method.getAnnotation(cn.nukkit.command.simple.Command.class);
        if (def != null) {
            SimpleCommand sc = new SimpleCommand(object, method, def.name(), def.description(), def.usageMessage(), def.aliases());

            Arguments args = method.getAnnotation(Arguments.class);
            if (args != null) {
                sc.setMaxArgs(args.max());
                sc.setMinArgs(args.min());
            }

            CommandPermission perm = method.getAnnotation(CommandPermission.class);
            if (perm != null) {
                sc.setPermission(perm.value());
            }

            if (method.isAnnotationPresent(ForbidConsole.class)) {
                sc.setForbidConsole(true);
            }

            this.register(def.name(), sc);
        }
    }
}
 

import java.lang.reflect.Method; //导入依赖的package包/类
private static Method maybeGetMethod(Class<?> clazz, String name, Class<?>... argClasses)
{
	try
	{
		return clazz.getMethod(name, argClasses);
	}
	catch (NoSuchMethodException nsme)
	{
		// OK
		return null;
	}
	catch (RuntimeException re)
	{
		Log.w(TAG, "Unexpected error while finding method " + name, re);
		return null;
	}
}
 

import java.lang.reflect.Method; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static Method getIDmethod(Class<? extends BaseDomain> clazz) {
	if (clazz.getAnnotation(IdClass.class) != null) {
		try {
			return clazz.getDeclaredMethod("getDomainID");
		} catch (NoSuchMethodException e) {
			throw new RuntimeException("含有"+IdClass.class.getName()+
					"的domain必须实现"+UnionKeyDomain.class.getName()+"接口!!!",e);
		}
	}
	
	Method[] methods = clazz.getDeclaredMethods();
	for (Method m:methods) {
		Annotation aa = m.getAnnotation(Id.class);
		if (aa == null) {
			continue;
		}
		return m;
	}
	if (clazz == BaseDomain.class) {
		return null;
	}
	return getIDmethod((Class<? extends BaseDomain>)clazz.getSuperclass());
}
 

import java.lang.reflect.Method; //导入依赖的package包/类
@Override
public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
    Sql sql = this.sql;

    if (method.getDeclaringClass() == SqlStreamHolder.class) {
        return sql;
    }

    TransactionStatus transactionStatus = null;
    try {
        transactionStatus = TransactionAspectSupport.currentTransactionStatus();
    } catch (NoTransactionException e) {
        if (FAIL_WITHOUT_TRANSACTION) {
            throw e;
        }
    }
    if (transactionStatus instanceof SqlStreamTransactionStatus) {
        sql = ((SqlStreamTransactionStatus) transactionStatus).transaction;
    }

    return method.invoke(sql, objects);
}
 

import java.lang.reflect.Method; //导入依赖的package包/类
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    if (method.getName().equals("getStatement")) {
        return this.st;
    } else {
        try {
            return method.invoke(this.delegate, args);
        } catch (Throwable t) {
            if (t instanceof InvocationTargetException
                    && t.getCause() != null) {
                throw t.getCause();
            } else {
                throw t;
            }
        }
    }
}