一般来说，通过反射是很难获得参数名的，只能取到参数类型，因为在编译时，参数名有可能是会改变的，需要在编译时加入参数才不会改变。
使用注解是可以实现取类型名（或者叫注解名）的，但是要写注解，并不方便。
观察Spring mvc框架中的数据绑定，发现是可以直接把http请求中对应参数绑定到对应的参数名上的，他是怎么实现的呢？
先参考一下自动绑定的原理：Spring源码研究：数据绑定
在getMethodArgumentValues方法中，MethodParameter[] parameters = getMethodParameters(); 这一句取到方法的所有参数，MethodParameter类型中有方法名的属性，这个是什么类呢？
是spring核心中的一个类，org.springframework.core.MethodParameter，并不是通过反射实现的。
方法getMethodParameters()是在HandlerMethod的类中

public MethodParameter[] getMethodParameters() {
returnthis.parameters;
}

this.parameters则是在构造方法中初始化的：

public HandlerMethod(Object bean, Method method) {
Assert.notNull(bean, "Bean is required");
Assert.notNull(method, "Method is required");
this.bean = bean;
this.beanFactory = null;
this.method = method;
this.bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
this.parameters = initMethodParameters();
}

initMethodParameters()生成了参数列表。

private MethodParameter[] initMethodParameters() {
int count = this.bridgedMethod.getParameterTypes().length;
MethodParameter[] result = new MethodParameter[count];
for (int i = 0; i < count; i++) {
result[i] = new HandlerMethodParameter(i);
}
return result;
}

HandlerMethodParameter(i)是HandlerMethod的内部类，继承自MethodParameter
构造方法调用：

publicHandlerMethodParameter(int index) {
super(HandlerMethod.this.bridgedMethod, index);
}

再调用MethodParameter类的构造方法：

publicMethodParameter(Method method,intparameterIndex,int nestingLevel) {
Assert.notNull(method, "Method must not be null");
this.method = method;
this.parameterIndex = parameterIndex;
this.nestingLevel = nestingLevel;
this.constructor =null;
}

MethodParameter类中有private String parameterName; 储存的就是参数名，但是构造方法中并没有设置他的值，真正设置值是在：

public String getParameterName() {
if(this.parameterNameDiscoverer !=null) {
String[] parameterNames = (this.method !=null?this.parameterNameDiscoverer.getParameterNames(this.method) :
this.parameterNameDiscoverer.getParameterNames(this.constructor));
if(parameterNames !=null) {
this.parameterName = parameterNames[this.parameterIndex];
}
this.parameterNameDiscoverer =null;
}
returnthis.parameterName;
}

而parameterNameDiscoverer就是用来查找名称的，他在哪里设置的值呢？

public void initParameterNameDiscovery(ParameterNameDiscoverer parameterNameDiscoverer) {
this.parameterNameDiscoverer = parameterNameDiscoverer;
}

这是个public方法，哪里调用了这个方法呢？有六七个地方吧，但是主要明显的是这里：

private Object[] getMethodArgumentValues(NativeWebRequest request, ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
MethodParameter[] parameters = getMethodParameters();
Object[] args =new Object[parameters.length];
for(inti = 0; i < parameters.length; i++) {
MethodParameter parameter = parameters[i];
parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
GenericTypeResolver.resolveParameterType(parameter, getBean().getClass());
args[i] = resolveProvidedArgument(parameter, providedArgs);
if(args[i] !=null) {
continue;
}
if(this.argumentResolvers.supportsParameter(parameter)) {
try {
args[i] =this.argumentResolvers.resolveArgument(
parameter, mavContainer, request, this.dataBinderFactory);
continue;
}
catch (Exception ex) {
if (logger.isTraceEnabled()) {
logger.trace(getArgumentResolutionErrorMessage("Error resolving argument", i), ex);
}
throw ex;
}
}
if(args[i] ==null) {
String msg = getArgumentResolutionErrorMessage("No suitable resolver for argument", i);
thrownew IllegalStateException(msg);
}
}
return args;
}

又回到了初始方法，这里面对ParameterNameDiscovery初始化，用来查找参数名：
methodParam.initParameterNameDiscovery(this.parameterNameDiscoverer);
this.parameterNameDiscoverer又是什么呢？
private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
通过DefaultParameterNameDiscoverer类的实例来查找参数名。

/**
* Default implementation of the {@link ParameterNameDiscoverer} strategy interface,
* using the Java 8 standard reflection mechanism (if available), and falling back
* to the ASM-based {@link LocalVariableTableParameterNameDiscoverer} for checking
* debug information in the class file.
*
* Further discoverers may be added through {@link #addDiscoverer(ParameterNameDiscoverer)}.
*
* @author Juergen Hoeller
* @since 4.0
* @see StandardReflectionParameterNameDiscoverer
* @see LocalVariableTableParameterNameDiscoverer
*/
public class DefaultParameterNameDiscoverer extends PrioritizedParameterNameDiscoverer {
private static final boolean standardReflectionAvailable =
(JdkVersion.getMajorJavaVersion() >= JdkVersion.JAVA_18);
public DefaultParameterNameDiscoverer() {
if (standardReflectionAvailable) {
addDiscoverer(new StandardReflectionParameterNameDiscoverer());
}
addDiscoverer(new LocalVariableTableParameterNameDiscoverer());
}
}

低于1.8时使用new LocalVariableTableParameterNameDiscoverer()来解析参数名。
其中有方法：

public String[] getParameterNames(Method method) {
Method originalMethod = BridgeMethodResolver.findBridgedMethod(method);
Class declaringClass = originalMethod.getDeclaringClass();
Map map = this.parameterNamesCache.get(declaringClass);
if (map == null) {
map = inspectClass(declaringClass);
this.parameterNamesCache.put(declaringClass, map);
}
if (map != NO_DEBUG_INFO_MAP) {
return map.get(originalMethod);
}
return null;
}

通过map = inspectClass(declaringClass); 获取名称map。

private Map inspectClass(Class clazz) {
InputStream is = clazz.getResourceAsStream(ClassUtils.getClassFileName(clazz));
if (is == null) {
// We couldn't load the class file, which is not fatal as it
// simply means this method of discovering parameter names won't work.
if (logger.isDebugEnabled()) {
logger.debug("Cannot find '.class' file for class [" + clazz
+ "] - unable to determine constructors/methods parameter names");
}
return NO_DEBUG_INFO_MAP;
}
try {
ClassReader classReader = new ClassReader(is);
Map map = new ConcurrentHashMap(32);
classReader.accept(new ParameterNameDiscoveringVisitor(clazz, map), 0);
return map;
}
catch (IOException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Exception thrown while reading '.class' file for class [" + clazz +
"] - unable to determine constructors/methods parameter names", ex);
}
}
catch (IllegalArgumentException ex) {
if (logger.isDebugEnabled()) {
logger.debug("ASM ClassReader failed to parse class file [" + clazz +
"], probably due to a new Java class file version that isn't supported yet " +
"- unable to determine constructors/methods parameter names", ex);
}
}
finally {
try {
is.close();
}
catch (IOException ex) {
// ignore
}
}
return NO_DEBUG_INFO_MAP;
}

这是方法。。。由此可见，spring是直接读取class文件来读取参数名的。。。。。。。。。。。。真累
反射的method类型为public java.lang.String com.guangshan.data.DataPoolController.addData(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse,java.lang.String,org.springframework.ui.Model)
所以需要通过类型查找参数名。
调试过程：反向调用过程：
1、

文章图片
classReader.accept(new ParameterNameDiscoveringVisitor(clazz, map), 0);
classReader位于org.springframework.asm包中，是spring用于反编译的包，读取class信息，class信息中是包含参数名的（可以用文本编辑器打开一个class文件查看，虽然有乱码，但是方法的参数名还在）
通过accept填充map对象，map的键为成员名（方法名或者参数名），值为参数列表（字符串数组）。
2、

文章图片
生成map之后，添加至参数名缓存，parameterNamesCache是以所在类的class为键，第一步的map为值的map。
3、

文章图片
通过第一步的map获取方法中的参数名数组。
4、

文章图片
通过调用本类parameterNameDiscoverer，再获取参数名的列表。
5、

文章图片
6、

文章图片
7、

文章图片
最终回到数据绑定的方法
2016年6月6日11:45:59补充：
@Aspect的注解里面，参数有一个叫做JoinPoint的，这个JoinPoint里面也可以获取参数名：
Signature signature = joinPoint.getSignature();
MethodSignature methodSignature = (MethodSignature) signature;
MethodSignature有方法：public String[] getParameterNames()
实现在：MethodInvocationProceedingJoinPoint类的MethodSignatureImpl类中：
this.parameterNames = parameterNameDiscoverer.getParameterNames(getMethod());
parameterNameDiscoverer是：DefaultParameterNameDiscoverer：

public class DefaultParameterNameDiscoverer extends PrioritizedParameterNameDiscoverer {
private static final boolean standardReflectionAvailable =
(JdkVersion.getMajorJavaVersion() >= JdkVersion.JAVA_18);
public DefaultParameterNameDiscoverer() {
if (standardReflectionAvailable) {
addDiscoverer(new StandardReflectionParameterNameDiscoverer());
}
addDiscoverer(new LocalVariableTableParameterNameDiscoverer());
}
}

判断版本，因为java8可以通过反射获取参数名，但是需要使用-parameters参数开启这个功能
可以看到有两个StandardReflectionParameterNameDiscoverer、LocalVariableTableParameterNameDiscoverer
对于外部使用，spring又提供了DefaultParameterNameDiscoverer来兼容调用
一个是通过标准反射来获取，一个是通过解析字节码文件的本地变量表来获取的。
【java反射获取Method的参数名称（不是类型）】Parameter对象是新的反射对象，param.isNamePresent()表示是否编译了参数名。

推荐阅读

• 

  乡镇电商如何加盟，乡镇电商怎么做
• 

  金铲铲之战1.23b北地拉面熊怎么玩 金铲铲之战时空裂痕1.23b阵容推荐
• 

  太阳的表面温度是多少 太阳的表面温度
• 

  dropbox搭建 Dropbox作为Git服务器的操作步骤
• 

  常见的AirPods问题有哪些,该如何解决？
• 

  Doinb比赛独创卡萨丁100%胜率玩法,前期稳定优势,战绩39-1-14,怎么评价？
• 

  生蚝怎样存放
• 

  win10系统之家官网最新推荐
• 

  python程序设置执行密码，python设置用户名和密码
• 

  冰箱|都说隔夜茶无害，为何夏天不能喝隔夜茶呢？听听老茶客的经验之谈
• 

  LeetCode|LeetCode 剑指 Offer 22. 链表中倒数第k个节点
• 

  如果现在你65岁,怎么过好每一天？
• 

  秋天到了大地回发生什么变化
• 

  爱思助手进行截图的具体使用教程视频 爱思助手进行截图的具体使用教程
• 

  安卓 开机自启热点,s10热点开机自启步骤如图
• 

  土豆炖肉做法 土豆炖肉做法大全家常
• 

  可以制作图片的软件免费的 免费图片转文字app
• 

  新诗《隐痛》（中英双语）
• 

  空调是否漏氟怎么查 空调如何自己检测是否漏氟
• 

  卧室如何摆放家具好看 卧室如何摆放家具，卧室如何摆放家具风水好

• JAVA（抽象类与接口的区别&重载与重写&内存泄漏）
• 事件代理
• Java|Java OpenCV图像处理之SIFT角点检测详解
• java中如何实现重建二叉树
• 数组常用方法一
• 【Hadoop踩雷】Mac下安装Hadoop3以及Java版本问题
• Java|Java基础——数组
• RxJava|RxJava 在Android项目中的使用（一）
• java之static、static|java之static、static final、final的区别与应用
• EditText默认不获取焦点弹出键盘