Java Reflection - 谁影响了我？

1
2
3
4
5
6

ParameterNameDiscoverer discoverer = new StandardReflectionParameterNameDiscoverer();
Method method = ((MethodSignature) point.getSignature()).getMethod();
String[] params = paramDiscover.getParameterNames(method);
for (int len = 0; len < params.length; len++) {
    // do something
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public class StandardReflectionParameterNameDiscoverer implements ParameterNameDiscoverer {

	@Override
	@Nullable
	public String[] getParameterNames(Method method) {
		return getParameterNames(method.getParameters());
	}

	@Override
	@Nullable
	public String[] getParameterNames(Constructor<?> ctor) {
		return getParameterNames(ctor.getParameters());
	}

	@Nullable
	private String[] getParameterNames(Parameter[] parameters) {
		String[] parameterNames = new String[parameters.length];
		for (int i = 0; i < parameters.length; i++) {
			Parameter param = parameters[i];
			if (!param.isNamePresent()) {
				return null;
			}
			parameterNames[i] = param.getName();
		}
		return parameterNames;
	}
}

1
2
3
4

public boolean isNamePresent() {
    // 当没有真实参数数据，或name为null，则会返回false
    return executable.hasRealParameterData() && name != null;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

private Parameter[] privateGetParameters() {
    // Use tmp to avoid multiple writes to a volatile.
    Parameter[] tmp = parameters;
    if (tmp == null) {
        // Otherwise, go to the JVM to get them
        try {
            tmp = getParameters0();
        } catch(IllegalArgumentException e) {
            // Rethrow ClassFormatErrors
            throw new MalformedParametersException("Invalid constant pool index");
        }
        // If we get back nothing, then synthesize parameters
        if (tmp == null) {
            hasRealParameterData = false;
            tmp = synthesizeAllParams();
        } else {
            hasRealParameterData = true;
            verifyParameters(tmp);
        }
        parameters = tmp;
    }
    return tmp;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

[arthas@40916]$ ognl '@com.xxx.XxxController@class.getMethods()[0].getParameters()'
@Parameter[][
    @Parameter[com.xxx.ParamVO request],
]
[arthas@40916]$ stack com.xxx.XxxController index -n 5
Press Q or Ctrl+C to abort.
Affect(class count: 2 , method count: 2) cost in 167 ms, listenerId: 1
[arthas@40916]$ ognl '@com.xxx.XxxController@class.getMethods()[0].getParameters()'
@Parameter[][
    @Parameter[com.xxx.ParamVO arg0],
]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

/**
 * {@return an array of {@code Parameter} objects representing
 * all the parameters to the underlying executable represented by
 * this object} An array of length 0 is returned if the executable
 * has no parameters.
 *
 * <p>The parameters of the underlying executable do not necessarily
 * have unique names, or names that are legal identifiers in the
 * Java programming language (JLS {@jls 3.8}).
 *
 * @throws MalformedParametersException if the class file contains
 * a MethodParameters attribute that is improperly formatted.
 */
public Parameter[] getParameters() {
    // TODO: This may eventually need to be guarded by security
    // mechanisms similar to those in Field, Method, etc.
    //
    // Need to copy the cached array to prevent users from messing
    // with it.  Since parameters are immutable, we can
    // shallow-copy.
    return privateGetParameters().clone();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

private transient volatile Parameter[] parameters;
private native Parameter[] getParameters0();
// ...
private Parameter[] synthesizeAllParams() {
    final int realparams = getParameterCount();
    final Parameter[] out = new Parameter[realparams];
    for (int i = 0; i < realparams; i++)
        // TODO: is there a way to synthetically derive the
        // modifiers?  Probably not in the general case, since
        // we'd have no way of knowing about them, but there
        // may be specific cases.
        out[i] = new Parameter("arg" + i, 0, this, i);
    return out;
}
private Parameter[] privateGetParameters() {
    // Use tmp to avoid multiple writes to a volatile.
    Parameter[] tmp = parameters;
    if (tmp == null) {
        // Otherwise, go to the JVM to get them
        try {
            tmp = getParameters0();
        } catch(IllegalArgumentException e) {
            // Rethrow ClassFormatErrors
            throw new MalformedParametersException("Invalid constant pool index");
        }
        // If we get back nothing, then synthesize parameters
        if (tmp == null) {
            hasRealParameterData = false;
            tmp = synthesizeAllParams();
        } else {
            hasRealParameterData = true;
            verifyParameters(tmp);
        }
        parameters = tmp;
    }
    return tmp;
}