# Paramo

Java compiler doesn't store method parameter names in the class file and we can't retrieve them using reflection. Actually, the names are stored in the `LocalVariableTable` attribute of the method, if a class is compiled with debug symbols on (i.e., javac -g). The `LocalVariableTable` attribute is not accessible using reflection, but it can be read using the bytecode parsing library like ASM.

**Paramo** is a little tool that extracts method or constructor parameter names from bytecode debug information in runtime.

**Paramo** works only if debug information is available in class files (compile with: `javac -g` ).

### Usage

Using **Paramo** is very simple: just pass `Method` or `Constructor` to the static method `Paramo#resolveParameters`. It returns `MethodParameter[]` array with method parameter information, or an empty array if the method/constructor does not have any parameter.

`MethodParameter` is a simple POJO that holds two information about the method parameter:

* parameter name
* bytecode signature, including the generic information!

Method`resolveParameters` does not cache anything; every time invoked it will examine the bytecode again. For efficient usage, wrap it and cache results. {: .attn}

In contrast to the rest of **Jodd**, **Paramo** is written to be 'raw', without many helper methods. This is done by purpose, since getting parameter names is usually part of some higher-level logic, that should wrap it in the way that serves the best to that logic.

### Examples

Let's say we have the following class:

```java
public static class Foo {
    public Foo(String something) {}

    public void hello() {}

    public void two(String username, String password) {}
}
```

We will assume that we got references to `Method`s and `Constructor` using reflection (and with tool such `ReflectUtil#findMethod`). Now, let's read parameter names:

```java
MethodParameter[] s = Paramo.resolveParameters(constructor);
System.out.println(s.length);           // 1
System.out.println(s[0].getName());     // something
```

```java
MethodParameter[] s = Paramo.resolveParameters(helloMethod);
System.out.println(s.length);           // 0
```

```java
MethodParameter[] s = Paramo.resolveParameters(twoMethod);
System.out.println(s.length);           // 2
System.out.println(s[0].getName());     // username
System.out.println(s[1].getName());     // password
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://proxetta.jodd.org/paramo/paramo.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.