大家知道，Spring MVC 有一項非常實用的功能宁炫，叫參數(shù)綁定。其具體能實現(xiàn)的功能異常強大氮凝，這里不再贅述羔巢，網(wǎng)上有非常多的資料可供參考，僅舉一例用以描述問題罩阵。

@RestController
public class FooController {
    
    @GetMapping("/methodOne")
    public Boolean methodOne(Integer filedOne, String fieldTwo) {
        System.out.println(filedOne);
        System.out.println(fieldTwo);
        return Boolean.TRUE;
    }
}

這是一種很常見的使用姿勢 - GET請求竿秆，有兩個參數(shù)，分別為filedOne(Integer)稿壁，fieldTwo(String)幽钢。

先前一直都知道Spring MVC 有參數(shù)綁定功能，也一直心安理得去使用傅是，把結論當成必然去記匪燕，一直未曾探究其原理。其實喧笔，我好奇的并非Spring MVC完成參數(shù)綁定的過程帽驯，而是好奇，Spring如何獲取到方法的形參名书闸，并完成屬性注入尼变？

難道大家沒有這樣的疑問？在Java 8及之后浆劲，編譯的時候可以通過-parameters 為反射生成元信息嫌术，可以獲取到方法的參數(shù)名，但這個行為默認是關閉的牌借，且更靠前的Java 6 Java 7呢度气，甚至沒有這個參數(shù)，因此應該不是通過反射獲取參數(shù)名走哺。既然反射走不通蚯嫌，那Spring又是使用了哪種奇淫技巧來獲取方法的參數(shù)名呢？帶著這個問題一起來看源碼丙躏。

注：下面的源碼分析基于Spring 4.3.17

假設我們請求 GET http://localhost:8080/methodOne?fieldTwo=jack择示，
即請求methodOne，參數(shù)名為fieldTwo晒旅，參數(shù)值為jack栅盲，接下來就看看Spring MVC是怎么處理的。

一個Spring MVC的應用废恋，當有一個Web請求的進來的時候谈秫，我們一般從org.springframework.web.servlet.DispatcherServlet#doDispatch開始分析

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    ...（省略）
    // Determine handler for the current request.
    mappedHandler = getHandler(processedRequest);
    ...（省略）
    // Determine handler adapter for the current request.
    HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    ...（省略）
    // Actually invoke the handler.
    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    ...（省略）
}

我們重點看mv = ha.handle(processedRequest, response, mappedHandler.getHandler());扒寄，調(diào)用HandlerAdapter的handle方法，實際上會進入到org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#handleInternal

@Override
protected ModelAndView handleInternal(HttpServletRequest request,
        HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

    ModelAndView mav;
    checkRequest(request);

    // Execute invokeHandlerMethod in synchronized block if required.
    if (this.synchronizeOnSession) {
        HttpSession session = request.getSession(false);
        if (session != null) {
            Object mutex = WebUtils.getSessionMutex(session);
            synchronized (mutex) {
                mav = invokeHandlerMethod(request, response, handlerMethod);
            }
        }
        else {
            // No HttpSession available -> no mutex necessary
            mav = invokeHandlerMethod(request, response, handlerMethod);
        }
    }
    else {
        // No synchronization on session demanded at all...
        mav = invokeHandlerMethod(request, response, handlerMethod);
    }
    ...（省略）
}

synchronizeOnSession默認為false拟烫，不用管该编，因此會走到else的分支，即mav = invokeHandlerMethod(request, response, handlerMethod);

protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
            HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

ServletWebRequest webRequest = new ServletWebRequest(request, response);
try {
    WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
    ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

    ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
    invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
    invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
    invocableMethod.setDataBinderFactory(binderFactory);
    invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
    ...（省略）

    invocableMethod.invokeAndHandle(webRequest, mavContainer);
    ...（省略）
}

將handlerMethod包裝成ServletInvocableHandlerMethod硕淑，并設置argumentResolvers课竣、returnValueHandlers、binderFactory置媳、parameterNameDiscoverer于樟。其中，argumentResolvers需要重點關注拇囊，因為它是用來做參數(shù)解析的迂曲。接下來看invocableMethod.invokeAndHandle(webRequest, mavContainer);

public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
            Object... providedArgs) throws Exception {

    Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
    ...（省略）
}

直接進入invokeForRequest方法

public Object invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer,
            Object... providedArgs) throws Exception {

    Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
    ...（省略）
}

即將進入重要方法getMethodArgumentValues

private Object[] getMethodArgumentValues(NativeWebRequest request, ModelAndViewContainer mavContainer,
            Object... providedArgs) throws Exception {

    MethodParameter[] parameters = getMethodParameters();//獲取方法參數(shù)
    Object[] args = new Object[parameters.length];
    for (int i = 0; i < parameters.length; i++) {
        MethodParameter parameter = parameters[i];
        parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);//設置參數(shù)名發(fā)現(xiàn)者
        args[i] = resolveProvidedArgument(parameter, providedArgs);
        if (args[i] != null) {
            continue;
        }
        if (this.argumentResolvers.supportsParameter(parameter)) {//從參數(shù)解析器列表里找到能夠支持該參數(shù)解析的
            try {
                args[i] = this.argumentResolvers.resolveArgument(
                        parameter, mavContainer, request, this.dataBinderFactory);//進行參數(shù)解析
                continue;
            }
            catch (Exception ex) {
                if (logger.isDebugEnabled()) {
                    logger.debug(getArgumentResolutionErrorMessage("Failed to resolve", i), ex);
                }
                throw ex;
            }
        }
        if (args[i] == null) {
            throw new IllegalStateException("Could not resolve method parameter at index " +
                    parameter.getParameterIndex() + " in " + parameter.getMethod().toGenericString() +
                    ": " + getArgumentResolutionErrorMessage("No suitable resolver for", i));
        }
    }
    return args;
}

1. 獲取方法參數(shù)。

MethodParameter[] parameters = getMethodParameters();

這里的參數(shù)是指我們最上面定義的public Boolean methodOne(Integer filedOne, String fieldTwo)參數(shù)表示寥袭，因為我們定義了兩個參數(shù)路捧，所以這里parameters有兩個元素。
我們看一下MethodParameter類的定義：

public class MethodParameter {

    private static final Annotation[] EMPTY_ANNOTATION_ARRAY = new Annotation[0];

    private static final Class<?> javaUtilOptionalClass;

    private final Method method;

    private final Constructor<?> constructor;

    private final int parameterIndex;

    private int nestingLevel = 1;

    /** Map from Integer level to Integer type index */
    Map<Integer, Integer> typeIndexesPerLevel;

    private volatile Class<?> containingClass;

    private volatile Class<?> parameterType;

    private volatile Type genericParameterType;

    private volatile Annotation[] parameterAnnotations;

    private volatile ParameterNameDiscoverer parameterNameDiscoverer;

    private volatile String parameterName;

    private volatile MethodParameter nestedMethodParameter;
    
    ...（省略）
}

• method 記錄參數(shù)屬于哪個方法（在這里传黄，public java.lang.Boolean com.example.demo.controller.FooController.methodOne(java.lang.Integer,java.lang.String)）
• parameterIndex 記錄參數(shù)在所屬方法的位置索引（在這里鬓长，filedOne的index = 0,fieldTwo的index = 1）
• containingClass記錄了所屬的Class（在這里，com.example.demo.controller.FooController）
• parameterType 記錄參數(shù)的類型(在這里尝江，filedOne的類型是java.lang.Integer，fieldTwo的類型是java.lang.String)
• parameterAnnotations 記錄參數(shù)上有什么注解（在這里英上，無注解炭序，因此為空）
• parameterNameDiscoverer 記錄參數(shù)名解析器，非常重要苍日，它能解答最開始提出的問題
• parameterName 記錄參數(shù)名惭聂。我們就是要找到Spring MVC如何解析參數(shù)名，并給這個屬性賦值相恃。

第一次進入到getMethodArgumentValues方法的時候辜纲，調(diào)用getMethodParameters方法可以直接獲取到parameters，因為應用啟動的時候就解析好了拦耐，但是啟動的時候并沒有解析參數(shù)名耕腾，因此parameterName為空。

2. 設置參數(shù)名解析器：

parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);

其中杀糯，this.parameterNameDiscoverer是InvocableHandlerMethod類的一個成員變量扫俺，直接new了一個 DefaultParameterNameDiscoverer，是ParameterNameDiscoverer的默認實現(xiàn)固翰。

public class InvocableHandlerMethod extends HandlerMethod {

    private WebDataBinderFactory dataBinderFactory;

    private HandlerMethodArgumentResolverComposite argumentResolvers = new HandlerMethodArgumentResolverComposite();

    private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
    ...（省略）
}



public class DefaultParameterNameDiscoverer extends PrioritizedParameterNameDiscoverer {

    private static final boolean standardReflectionAvailable = ClassUtils.isPresent(
            "java.lang.reflect.Executable", DefaultParameterNameDiscoverer.class.getClassLoader());


    public DefaultParameterNameDiscoverer() {
        if (standardReflectionAvailable) {
            addDiscoverer(new StandardReflectionParameterNameDiscoverer());
        }
        addDiscoverer(new LocalVariableTableParameterNameDiscoverer());
    }

}

我們看到狼纬，DefaultParameterNameDiscoverer繼承自PrioritizedParameterNameDiscoverer（一個ParameterNameDiscoverer代理羹呵，里面維護了帶優(yōu)先級的參數(shù)名解析器集合，先添加的優(yōu)先解析疗琉，如果某個解析器解析后返回null冈欢，則會使用下一個解析器進行解析，默認情況下使用Java 8的反射機制進行解析盈简，解析失敗就fall back到使用基于ASM的參數(shù)解析器去獲取class文件里的debug信息）凑耻，在構造DefaultParameterNameDiscoverer時就維護了解析器集合，如果類路徑下存在java.lang.reflect.Executable送火，就添加一個StandardReflectionParameterNameDiscoverer(使用Java 8的反射機制)拳话，再添加基于ASM的參數(shù)解析器LocalVariableTableParameterNameDiscoverer，用于fall back時的解析

3. 從參數(shù)解析器列表里找到能夠支持該參數(shù)解析的

if (this.argumentResolvers.supportsParameter(parameter))

private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
    HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
    if (result == null) {
        for (HandlerMethodArgumentResolver methodArgumentResolver : this.argumentResolvers) {
            if (logger.isTraceEnabled()) {
                logger.trace("Testing if argument resolver [" + methodArgumentResolver + "] supports [" +
                        parameter.getGenericParameterType() + "]");
            }
            if (methodArgumentResolver.supportsParameter(parameter)) {
                result = methodArgumentResolver;
                this.argumentResolverCache.put(parameter, result);
                break;
            }
        }
    }
    return result;
}

這里种吸，能夠支持我們代碼中參數(shù)解析的解析器為RequestParamMethodArgumentResolver弃衍，何以見得？我們看org.springframework.web.method.annotation.RequestParamMethodArgumentResolver#supportsParameter

public boolean supportsParameter(MethodParameter parameter) {
    if (parameter.hasParameterAnnotation(RequestParam.class)) {//我們的兩個參數(shù)都沒有用RequestParam注解進行修飾坚俗，因此代碼會走到else
        if (Map.class.isAssignableFrom(parameter.nestedIfOptional().getNestedParameterType())) {
            String paramName = parameter.getParameterAnnotation(RequestParam.class).name();
            return StringUtils.hasText(paramName);
        }
        else {
            return true;
        }
    }
    else {
        if (parameter.hasParameterAnnotation(RequestPart.class)) {
            return false;
        }
        parameter = parameter.nestedIfOptional();
        if (MultipartResolutionDelegate.isMultipartArgument(parameter)) {
            return true;
        }
        else if (this.useDefaultResolution) {/true
            return BeanUtils.isSimpleProperty(parameter.getNestedParameterType());//代碼會走到這里
        }
        else {
            return false;
        }
    }
}

public static boolean isSimpleProperty(Class<?> clazz) {
    Assert.notNull(clazz, "Class must not be null");
    return isSimpleValueType(clazz) || (clazz.isArray() && isSimpleValueType(clazz.getComponentType()));
}

public static boolean isSimpleValueType(Class<?> clazz) {
    return (ClassUtils.isPrimitiveOrWrapper(clazz) ||
            Enum.class.isAssignableFrom(clazz) ||
            CharSequence.class.isAssignableFrom(clazz) ||
            Number.class.isAssignableFrom(clazz) ||
            Date.class.isAssignableFrom(clazz) ||
            URI.class == clazz || URL.class == clazz ||
            Locale.class == clazz || Class.class == clazz);
}

其實镜盯，Spring MVC在RequestMappingHandlerAdapter的afterPropertiesSet方法中初始化了參數(shù)解析器列表argumentResolvers，注冊了四類一系列參數(shù)解析器：

• 基于注解的參數(shù)解析器
  • RequestParamMethodArgumentResolver(@RequestParam猖败，useDefaultResolution = false)
  • RequestParamMapMethodArgumentResolver(@RequestParam)
  • PathVariableMethodArgumentResolver(@PathVariable)速缆、
  • RequestHeaderMethodArgumentResolver(@RequestHeader)
  • RequestResponseBodyMethodProcesso(r@RequestBody)
  • ServletModelAttributeMethodProcessor(@ModelAttribute， annotationNotRequired = false)
  • ...
• 基于類型的參數(shù)注解器
  • ServletRequestMethodArgumentResolver(ServletRequest恩闻、InputStream)
  • ServletResponseMethodArgumentResolver(ServletResponse艺糜、OutputStream)
  • ModelMethodProcessor(Model)
  • ...
• 自定義參數(shù)解析器
• 兜底參數(shù)解析器
  • RequestParamMethodArgumentResolver(useDefaultResolution = true)
  • ServletModelAttributeMethodProcessor(annotationNotRequired = true)

其中RequestParamMethodArgumentResolver被注冊了兩次，第一次useDefaultResolution = false幢尚，第二次useDefaultResolution = true破停。

useDefaultResolution的含義是：一個簡單類型的方法參數(shù)，如果沒有被諸如@RequestParam等注解修飾尉剩，要不要被當成一個請求參數(shù)去解析真慢。
我們的兩個請求參數(shù)filedOne、filedTwo理茎，都沒有被@RequestParam進行注解黑界，且類型都是簡單類型(Integer、String)皂林。因此朗鸠，我們的兩個請求參數(shù)都將會被RequestParamMethodArgumentResolver進行解析

4. 進行參數(shù)解析

args[i] = this.argumentResolvers.resolveArgument(
                        parameter, mavContainer, request, this.dataBinderFactory);



public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
            NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

    HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
    if (resolver == null) {
        throw new IllegalArgumentException("Unknown parameter type [" + parameter.getParameterType().getName() + "]");
    }
    return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
}

經(jīng)過上面的分析，知道我們的resolver就是RequestParamMethodArgumentResolver础倍，它并沒有重寫resolveArgument方法童社，因此這里調(diào)用的是父類AbstractNamedValueMethodArgumentResolver里的方法，我們接著看

public final Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
            NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

    NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);//獲取參數(shù)信息著隆，包含參數(shù)名扰楼，是否required呀癣，以及參數(shù)默認值
    MethodParameter nestedParameter = parameter.nestedIfOptional();

    Object resolvedName = resolveStringValue(namedValueInfo.name);//獲取解析后的參數(shù)名
    ...（省略）
    Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);//獲取參數(shù)值
    ...（省略）
    arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);//轉型成實際的參數(shù)類型
    ...（省略）
    handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);//勾子方法，處理解析之后的值

    return arg;
}

進入getNamedValueInfo方法

private NamedValueInfo getNamedValueInfo(MethodParameter parameter) {
    NamedValueInfo namedValueInfo = this.namedValueInfoCache.get(parameter);
    if (namedValueInfo == null) {
        namedValueInfo = createNamedValueInfo(parameter);
        namedValueInfo = updateNamedValueInfo(parameter, namedValueInfo);
        this.namedValueInfoCache.put(parameter, namedValueInfo);
    }
    return namedValueInfo;
}

第一次進來弦赖，無法從cache獲取到NamedValueInfo信息项栏，需要經(jīng)過create、update步驟之后蹬竖，再放回緩存沼沈。

createNamedValueInfo方法主要是根據(jù)@RequestParam獲取name、required币厕、defaultValue信息列另，但我們這里并沒有用該注解修飾，所以會分別給給默認值""旦装、false页衙、ValueConstants.DEFAULT_NONE。

接下來是updateNamedValueInfo方法

private NamedValueInfo updateNamedValueInfo(MethodParameter parameter, NamedValueInfo info) {
    String name = info.name;
    if (info.name.isEmpty()) {
        name = parameter.getParameterName();
        ...（省略）
}

我們知道在createNamedValueInfo中阴绢， info.name被賦值為""店乐，因此直接進入name = parameter.getParameterName()

public String getParameterName() {
    ParameterNameDiscoverer discoverer = this.parameterNameDiscoverer; // 這里是上面提到的DefaultParameterNameDiscoverer
    if (discoverer != null) {
        String[] parameterNames = (this.method != null ?
                discoverer.getParameterNames(this.method) : discoverer.getParameterNames(this.constructor));
        if (parameterNames != null) {
            this.parameterName = parameterNames[this.parameterIndex];
        }
        this.parameterNameDiscoverer = null;
    }
    return this.parameterName;
}

discoverer為上文中提到的DefaultParameterNameDiscoverer，因此我們直接進入其getParameterNames方法呻袭，又因未重寫該方法眨八，因此實際上調(diào)用的是其父類PrioritizedParameterNameDiscoverer的相應方法。

@Override
public String[] getParameterNames(Method method) {
    for (ParameterNameDiscoverer pnd : this.parameterNameDiscoverers) {
        String[] result = pnd.getParameterNames(method);
        if (result != null) {
            return result;
        }
    }
    return null;
}

正如我們上文提到的左电，PrioritizedParameterNameDiscoverer是一個解析器代理廉侧，其維護多個解析器卵渴。在解析的時候姓惑，使用其維護的解析器集合一一進行解析，如果解析成功恨统，直接返回纷纫；如果解析失敗，則使用集合中下一個解析器進行解析陪腌。
第一個解析器是StandardReflectionParameterNameDiscoverer辱魁，因為我們并未使用 -parameters進行編譯，因此解析失敗诗鸭，返回null染簇。
第二個解析器是LocalVariableTableParameterNameDiscoverer，其實現(xiàn)如下：

public String[] getParameterNames(Method method) {
    Method originalMethod = BridgeMethodResolver.findBridgedMethod(method); //根據(jù)橋接方法尋找原始方法强岸，在這里橋接方法跟原始方法是同一個
    Class<?> declaringClass = originalMethod.getDeclaringClass();
    Map<Member, String[]> map = this.parameterNamesCache.get(declaringClass);
    if (map == null) {
        map = inspectClass(declaringClass); //使用ASM獲取類信息
        this.parameterNamesCache.put(declaringClass, map);
    }
    if (map != NO_DEBUG_INFO_MAP) {
        return map.get(originalMethod);
    }
    return null;
}

進入inspectClass方法

private Map<Member, String[]> inspectClass(Class<?> clazz) {
    InputStream is = clazz.getResourceAsStream(ClassUtils.getClassFileName(clazz));
    ...（省略）
    ClassReader classReader = new ClassReader(is);
    Map<Member, String[]> map = new ConcurrentHashMap<Member, String[]>(32);
    classReader.accept(new ParameterNameDiscoveringVisitor(clazz, map), 0);
    return map;
    ...（省略）
}

先是讀取class文件進流里锻弓，然后借助ClassVisitor，調(diào)用ClassReader的accept方法去解析Java類文件蝌箍。而accept方法呈現(xiàn)的細節(jié)青灼，正是對class文件解析暴心。

class結構如下：

ClassFile {
    u4             magic;
    u2             minor_version;
    u2             major_version;
    u2             constant_pool_count;
    cp_info        constant_pool[constant_pool_count-1];
    u2             access_flags;
    u2             this_class;
    u2             super_class;
    u2             interfaces_count;
    u2             interfaces[interfaces_count];
    u2             fields_count;
    field_info     fields[fields_count];
    u2             methods_count;
    method_info    methods[methods_count];
    u2             attributes_count;
    attribute_info attributes[attributes_count];
}

從上述結構中看到，class文件中存儲有一項類型為method_info的methods屬性杂拨，我們稱之為方法表专普。再來看看method_info的結構：

method_info {
    u2             access_flags;
    u2             name_index;
    u2             descriptor_index;
    u2             attributes_count;
    attribute_info attributes[attributes_count];
}

method_info中存儲有一項類型為attribute_info的attributes屬性，我們稱之為屬性表弹沽。再來看看attribute_info的結構：

attribute_info {
    u2 attribute_name_index;
    u4 attribute_length;
    u1 info[attribute_length];
}

這是attribute_info的通用結構檀夹，它可以用在ClassFile、field_info策橘、method_info炸渡、Code_attribute中。正是由于這個原因丽已，上面的method_info才能包含attribute_info類型的屬性attributes蚌堵。而其中有一項屬性叫Code，其結構為：

Code_attribute {
    u2 attribute_name_index;
    u4 attribute_length;
    u2 max_stack;
    u2 max_locals;
    u4 code_length;
    u1 code[code_length];
    u2 exception_table_length;
    {   u2 start_pc;
        u2 end_pc;
        u2 handler_pc;
        u2 catch_type;
    } exception_table[exception_table_length];
    u2 attributes_count;
    attribute_info attributes[attributes_count];
}

剛才我們說過促脉，attribute_info還能用在Code_attribute中辰斋，所以上面的結構中，又包含了attribute_info類型的屬性attributes瘸味。其中有一項屬性叫LocalVariableTypeTable宫仗，我們看看其結構：

LocalVariableTable_attribute {
    u2 attribute_name_index;
    u4 attribute_length;
    u2 local_variable_table_length;
    {   u2 start_pc;
        u2 length;
        u2 name_index;
        u2 descriptor_index;
        u2 index;
    } local_variable_table[local_variable_table_length];
}

里面有一個內(nèi)嵌屬性local_variable_table，其中的name_index指向了常量池中的某項CONSTANT_Utf8_info旁仿，其值就是我們所要找的參數(shù)名藕夫。

關于class文件的結構，更詳細的內(nèi)容可以查閱官方文檔

至此枯冈，總算弄明白Spring MVC對于無注解的參數(shù)是如何獲取參數(shù)名的：通過LocalVariableTableParameterNameDiscoverer進行解析毅贮，該解析器借助了ASM工具，讀取class文件尘奏，根據(jù)class文件的結構滩褥，讀取method_info->Code_attribute->LocalVariableTable_attribute->local_variable_table->name_index->CONSTANT_Utf8_info，最終找到方法的參數(shù)名