默認情況下，我們是無法獲取方法中參數名稱的。通過反射機制，也只能得到參數的順序以及一些沒有意義的變量：arg0、arg1等等。

但我們又確實需要這部分信息。比如IDE的自動提示，文檔化服務接口的詳細信息等。

這是因為，這些變量的名字，根本就沒有編譯進class文件中，它不可能憑空產生。

[[333160]]

在JDK 8之后，可以通過在編譯時指定-parameters選項，將方法的參數名記入class文件，并在運行時通過反射機制獲取相關信息。

如果你的項目是實用maven構建，那么就可以加入幾行配置，追加參數。

<plugin>   
    <artifactId>maven-compiler-plugin</artifactId>   
    <version>3.8.0</version>   
    <configuration>   
        <source>1.8</source>   
        <target>1.8</target>   
        <encoding>utf8</encoding>   
        <compilerArgs>   
            <arg>-parameters</arg>   
        </compilerArgs>   
    </configuration>   
</plugin>   

如果是用的IDEA等編輯器，也可以通過設置界面進行配置。不過不推薦這樣，因為你的這些配置不好進行共享。

在普通Java項目里，就可以通過下面的方式來獲取反射數據。Method.getParameters這個方法是新加的。

public class Test { 
   
    public static void main(String[] args) throws Exception{ 
        Class clazz = Class.forName("com.test.MethodParameterTest"); 
        Method[] methods = clazz.getMethods(); 
        Constructor[] constructors = clazz.getConstructors(); 
        for (Constructor constructor : constructors) { 
            System.out.println("+++" + constructor.getName()); 
            Parameter[] parameters = constructor.getParameters(); 
            for (Parameter parameter : parameters) { 
                printParameter(parameter); 
            } 
        } 
   
        System.out.println("------------------"); 
        for (Method method : methods) { 
            System.out.println(method.getName()); 
            Parameter[] parameters = method.getParameters(); 
            for (Parameter parameter : parameters) { 
                printParameter(parameter); 
            } 
        } 
    } 
   
    private static void printParameter(Parameter parameter) { 
        //參數名 
        System.out.println("\t\t" + parameter.getName()); 
        //是否在源碼中隱式聲明的參數名 
        System.out.println("\t\t\t implicit:" + parameter.isImplicit()); 
        //類文件中，是否存在參數名 
        System.out.println("\t\t\t namePresent:" + parameter.isNamePresent()); 
        //是否為虛構參數 
        System.out.println("\t\t\t synthetic:" + parameter.isSynthetic()); 
        System.out.println("\t\t\t VarArgs:" + parameter.isVarArgs()); 
    } 
} 

下面介紹幾個方法的意義：

isImplicit()

參數是否為隱式聲明在源文件中，比如內部類，默認構造函數(無參)其實在編譯成class時將會把包含它的主類引用作為首個參數，此參數即為隱式聲明。

如果為true，即表示有JDK編譯器隱式生成在class文件中的方法參數，而source文件中并不可見。常規的普通方法，此值為false。

isNamePresent()

此參數在class文件中是否有此參數名;受制于在編譯時是否指定了“-parameter”，對于指定此參數的編譯文件，通常為true;對于JDK 內部類、默認編譯的類，通常為false;此時你會發現，它們的參數名通常為表意名稱：arg0、arg1等等，此時為false。

isSynthetic()

是否為“虛構”參數，如果為true，表示既不是“顯式”聲明、也不是隱式聲明在源文件中的參數，比如enum類的“values()”、“valueOf(String)”這是編譯器“虛構”的系統方法。

在Spring環境中，由于有工具類的支持，會更加方便一些。

public class SpringTest { 
   
    private static final ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer(); 
   
   
    public static void main(String[] args) throws Exception{ 
        Class clazz = Class.forName("com.test.MethodParameterTest"); 
        Method[] methods = clazz.getMethods(); 
        for (Method method : methods) { 
            System.out.println(method.getName()); 
            //JDK 1.8 + is better. 
            String[] parameterNames = parameterNameDiscoverer.getParameterNames(method); 
            if (parameterNames == null) { 
                continue; 
            } 
            for (String pn : parameterNames) { 
                System.out.println("\t\t" + pn); 
            } 
        } 
    } 
} 

那Java版本低于1.8的時候，又是怎么獲取的呢?我們可以參考Spring的LocalVariableTableParameterNameDiscoverer類。

public String[] getParameterNames(Method method) { 
        Method originalMethod = BridgeMethodResolver.findBridgedMethod(method); 
        return doGetParameterNames(originalMethod); 
} 
@Nullable 
private String[] doGetParameterNames(Executable executable) { 
        Class<?> declaringClass = executable.getDeclaringClass(); 
        Map<Executable, String[]> map = this.parameterNamesCache.computeIfAbsent(declaringClass, this::inspectClass); 
        return (map != NO_DEBUG_INFO_MAP ? map.get(executable) : null); 
} 

最后就走到了inspectClass方法中。

private Map<Executable, String[]> 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 constructor/method parameter names"); 
            } 
            return NO_DEBUG_INFO_MAP; 
        } 
        try { 
            ClassReader classReader = new ClassReader(is); 
            Map<Executable, String[]> map = new ConcurrentHashMap<>(32); 
            classReader.accept(new ParameterNameDiscoveringVisitor(clazz, map), 0); 
            return map; 
        } 
        ... 

可以看到，這種情況下，Spring是通過直接讀取class文件進行解析的。實際上是通過讀取LocalVariableTable中的數據進行獲取的。如果你編譯的時候沒有加入這些debug選項，同樣也拿不到方法參數的具體名稱。

總結一下

• Java8以前，讀取Class中的LocalVariableTable屬性表，需要編譯時加入參數-g或者-g:vars 獲取方法局部變量調試信息；
• Java8及其以后，通過java.lang.reflect.Parameter#getName即可獲取，但需要編譯時加入參數-parameters參數。