Can I obtain method parameter name using Java reflection?
To summarize:
- getting parameter names is possible if debug information is included during compilation. See this answer for more details
- otherwise getting parameter names is not possible
- getting parameter type is possible, using
method.getParameterTypes()
For the sake of writing autocomplete functionality for an editor (as you stated in one of the comments) there are a few options:
- use
arg0
,arg1
,arg2
etc. - use
intParam
,stringParam
,objectTypeParam
, etc. - use a combination of the above - the former for non-primitive types, and the latter for primitive types.
- don't show argument names at all - just the types.
Getting the name of a method parameter
Parameter names are available if you have told the compiler to include them (compile with debug information). Spring has ParameterNameDiscoverer
which can help you obtain the names. The default implementation uses asm ClassReader
to do so.
With javac
you should include the -g
argument to include debug information. With Eclipse I think it is there by default; it can be configured using the preferences: Java -> Compiler and then enable "Store information about method parameters (usable via reflection)" (see also this answer).
Some frameworks use this. For example spring-mvc has @RequestParam
which defaults to the param name, if resolvable. It also supports explicit naming - @RequestParam("foo")
in case no debug information is provided.
How to get method parameter names?
Take a look at the inspect
module - this will do the inspection of the various code object properties for you.
>>> inspect.getfullargspec(a_method)
(['arg1', 'arg2'], None, None, None)
The other results are the name of the *args and **kwargs variables, and the defaults provided. ie.
>>> def foo(a, b, c=4, *arglist, **keywords): pass
>>> inspect.getfullargspec(foo)
(['a', 'b', 'c'], 'arglist', 'keywords', (4,))
Note that some callables may not be introspectable in certain implementations of Python. For Example, in CPython, some built-in functions defined in C provide no metadata about their arguments. As a result, you will get a ValueError
if you use inspect.getfullargspec()
on a built-in function.
Since Python 3.3, you can use inspect.signature()
to see the call signature of a callable object:
>>> inspect.signature(foo)
<Signature (a, b, c=4, *arglist, **keywords)>
How can I get the parameter name in java at run time
Starting from Java 8, you can use Reflection API to retrieve parameters names:
Method someMethod = Main.class.getDeclaredMethod("someMethod");
Parameter[] parameters = someMethod.getParameters();
for(Parameter parameter : parameters)
{
System.out.println(parameter.getName());
}
Also, see JavaDoc of Parameter#getName()
:
Returns the name of the parameter. If the parameter's name is present, then this method returns the name provided by the class file. Otherwise, this method synthesizes a name of the form argN, where N is the index of the parameter in the descriptor of the method which declares the parameter.
Getting method parameter names
There is no way to get the names of the parameters of a method or a function.
The reason for this is because the names are not really important for someone calling a method or a function. What matters is the types of the parameters and their order.
A Function type denotes the set of all functions with the same parameter and result types. The type of 2 functions having the same parameter and result types is identical regardless of the names of the parameters. The following code prints true
:
func f1(a int) {}
func f2(b int) {}
fmt.Println(reflect.TypeOf(f1) == reflect.TypeOf(f2))
It is even possible to create a function or method where you don't even give names to the parameters (within a list of parameters or results, the names must either all be present or all be absent). This is valid code:
func NamelessParams(int, string) {
fmt.Println("NamelessParams called")
}
For details and examples, see Is unnamed arguments a thing in Go?
If you want to create some kind of framework where you call functions passing values to "named" parameters (e.g. mapping incoming API params to Go function/method params), you may use a struct
because using the reflect
package you can get the named fields (e.g. Value.FieldByName()
and Type.FieldByName()
), or you may use a map
. See this related question: Initialize function fields
Here is a relevant discussion on the golang-nuts mailing list.
How can you get the names of method parameters?
public static string GetParamName(System.Reflection.MethodInfo method, int index)
{
string retVal = string.Empty;
if (method != null && method.GetParameters().Length > index)
retVal = method.GetParameters()[index].Name;
return retVal;
}
The above sample should do what you need.
Related Topics
Disable Webcam's Autofocus in Linux
Gdb Pretty Printing with Python a Recursive Structure
How to Capture Mouseevents and Keyevents Using Python in Background on Linux
Scheduling a Regular Event: Cron/Cron Alternatives (Including Celery)
Pytest Running with Another Version of Python
Add Custom Method to String Object
Distributing Ruby/Python Desktop Apps
How to Deploy a Perl/Python/Ruby Script Without Installing an Interpreter
Unicodedecodeerror, Invalid Continuation Byte
How Is Python's List Implemented
Convert Binary to Ascii and Vice Versa
Check If a Word Is in a String in Python
Permutations Between Two Lists of Unequal Length
How to Keep a Python Script Output Window Open
Find the Column Name Which Has the Maximum Value for Each Row
Why Do I Get "Typeerror: 'Str' Object Is Not Callable" with This Code