the first invocation for this profiling session.

@param objectName
@param methodName
@return
6352
public static MethodInvocation start(String objectName, String methodName, int lineNumber) {
        bigMessage("Starting profiling... " + objectName + "#" + methodName + " (" + lineNumber + ")");
        if (profiling()) {
            logger.error("Profiling was already started for '{}'", callstack.getFirst().getCls() + "#"
                    + callstack.getFirst().getMethod());
            throw new IllegalStateException();
        }

        MethodDescriptor methodDescriptor = new MethodDescriptor(objectName, methodName, lineNumber);
        MethodInvocation rootInvocation = new MethodInvocation(methodDescriptor);
        invocations.add(rootInvocation);
        callstack.add(rootInvocation);
        Agent.setRootInvocation(rootInvocation);
        return rootInvocation;
    }
1356546
public static String[] getMethodSigsCache(String serviceName, String methodName) {
        ConcurrentHashMap<String, String[]> methods = NOT_OVERLOAD_METHOD_SIGS_CACHE.get(serviceName);
        return methods == null ? null : methods.get(methodName);
    }
1242639
public Object invoke(String methodName, Object... params){
		return ReflectUtil.invoke(this.bean, methodName, params);
	}
59153
public SofaResponseCallback getMethodOnreturn(String methodName) {
        return (SofaResponseCallback) getMethodConfigValue(methodName, RpcConstants.CONFIG_KEY_ONRETURN,
            getOnReturn());
    }
1242724
public static MethodInvokeProxy proxyByName(Object target,String methodName,Object ...args)
	{
		Method m=findMethodByName(target, methodName);
		if(m!=null)
		{
			return new MethodInvokeProxy(target, m, args);
		}
		return null;
	}
48493
public SMethod findMethod(String methodName) {
		for (SService sService : servicesByName.values()) {
			SMethod method = sService.getSMethod(methodName);
			if (method != null) {
				return method;
			}
		}
		return null;
	}
702702
public static Closure getMethodPointer(Object object, String methodName) {
        return InvokerHelper.getMethodPointer(object, methodName);
    }
1182856
static boolean isJavaPropertyMethod(final String methodName) {
        return (methodName.length() > PROPERTY_METHOD_PREFIX_LEN
                && (methodName.startsWith("get") || methodName.startsWith(("set"))));
    }
210057
protected Object doInvokeMethod(String methodName, Object name, Object args) {
        super.doInvokeMethod(methodName, name, args);


        // return the completed node
        return lastCompletedNode;
    }
1259810
public static Function<Object,String> s(final String methodName, final Object... optionalParameters) {
        return methodForString(methodName, optionalParameters);
    }
941298
public Object invokeMethod(String name, Object args) {
        final Object[] argsArr = args instanceof Object[] ? (Object[]) args : new Object[]{args};
        MetaMethod metaMethod = myMetaClass.getMetaMethod(name, argsArr);
        if (metaMethod != null) {
            // we have to use doMethodInvoke here instead of simply invoke,
            // because getMetaMethod may provide a method that can not be called
            // without further argument transformation, which is done only in 
            // doMethodInvoke
            return metaMethod.doMethodInvoke(this, argsArr);
        }

        if (argsArr.length == 2 && argsArr[0] instanceof Class && argsArr[1] instanceof Closure) {
            if (argsArr[0] == theClass)
                registerInstanceMethod(name, (Closure) argsArr[1]);
            else {
                registerSubclassInstanceMethod(name, (Class) argsArr[0], (Closure) argsArr[1]);
            }
            return null;
        }

        if (argsArr.length == 1 && argsArr[0] instanceof Closure) {
            registerInstanceMethod(name, (Closure) argsArr[0]);
            return null;
        }

        throw new MissingMethodException(name, getClass(), argsArr);
    }
494998
public ObjectName preRegister(MBeanServer server, ObjectName name)
			throws Exception {
		oname=name;
        mserver=server;
        domain=name.getDomain();
        return name;
	}
1056806
public List<Method> listMethods( final Class<?>    classObj,
                                     final String      methodName )
    {
        //
        //    Get the array of methods for my classname.
        //
        Method[] methods = classObj.getMethods();

        List<Method> methodSignatures = new ArrayList<Method>();

        //
        //    Loop round all the methods and print them out.
        //
        for ( int ii = 0; ii < methods.length; ++ii )
        {
            if ( methods[ii].getName().equals( methodName ) )
            {
                methodSignatures.add( methods[ii] );
            }
        }

        return methodSignatures;
    }
752776
@Override
  public MethodAmp methodByName(String methodName)
  {
    StubAmp delegate = delegate();
    
    if (delegate != null) {
      return delegate.methodByName(methodName);
    }
    else {
      System.out.println("EEP:");
      return null;
    }
  }
319953
public static Object invokeMethodIfExists(Object instance, String methodName, Object[] args) {
        MetaClass metaClass = getMetaClass(instance);
        List<MetaMethod> methodList = metaClass.respondsTo(instance, methodName, args);
        if (methodList != null && !methodList.isEmpty()) {
            return metaClass.invokeMethod(instance, methodName, args);
        }
        return null;
    }
574221
public Object invokeStaticMethod(Object object, String methodName, Object[] arguments) {
        if (invokeStaticMethodMethod != null) {
            MetaClassHelper.unwrap(arguments);
            return invokeStaticMethodMethod.invoke(object, new Object[]{methodName, arguments});
        }
        return super.invokeStaticMethod(object, methodName, arguments);
    }
1048720
public static ManagementMethod getInstance(String methodName,
                                               JournalEntry parent) {
        if (METHOD_INGEST.equals(methodName)) {
            return new IngestMethod(parent);
        } else if (METHOD_MODIFY_OBJECT.equals(methodName)) {
            return new ModifyObjectMethod(parent);
        } else if (METHOD_PURGE_OBJECT.equals(methodName)) {
            return new PurgeObjectMethod(parent);
        } else if (METHOD_ADD_DATASTREAM.equals(methodName)) {
            return new AddDatastreamMethod(parent);
        } else if (METHOD_MODIFY_DATASTREAM_BY_REFERENCE.equals(methodName)) {
            return new ModifyDatastreamByReferenceMethod(parent);
        } else if (METHOD_MODIFY_DATASTREAM_BY_VALUE.equals(methodName)) {
            return new ModifyDatastreamByValueMethod(parent);
        } else if (METHOD_SET_DATASTREAM_STATE.equals(methodName)) {
            return new SetDatastreamStateMethod(parent);
        } else if (METHOD_SET_DATASTREAM_VERSIONABLE.equals(methodName)) {
            return new SetDatastreamVersionableMethod(parent);
        } else if (METHOD_PURGE_DATASTREAM.equals(methodName)) {
            return new PurgeDatastreamMethod(parent);
        } else if (METHOD_PURGE_RELATIONSHIP.equals(methodName)) {
            return new PurgeRelationshipMethod(parent);
        } else if (METHOD_PUT_TEMP_STREAM.equals(methodName)) {
            return new PutTempStreamMethod(parent);
        } else if (METHOD_GET_NEXT_PID.equals(methodName)) {
            return new GetNextPidMethod(parent);
        } else if (METHOD_ADD_RELATIONSHIP.equals(methodName)) {
            return new AddRelationshipMethod(parent);
        } else {
            throw new IllegalArgumentException("Unrecognized method name: '"
                    + methodName + "'");
        }
    }