java:axis2环境下获取方法参数名的另一种方法

public String concatString(String param1,String param2){
        return param1+param2;
    }

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.axis2.description.java2wsdl.bytecode;

import java.lang.reflect.Method;
import java.util.HashMap;

public class MethodTable {

    private HashMap nameToMethodMap;
    //关键的实现都在这个类中
    private ChainedParamReader cpr;

    public MethodTable(Class cls) throws Exception {
        cpr = new ChainedParamReader(cls);
        nameToMethodMap = new HashMap();
        loadMethods(cls);
    }

    /**
     * To load all the methods in the given class by Java reflection
     *
     * @param cls
     * @throws Exception
     */
    private void loadMethods(Class cls) throws Exception {
        Method [] methods = cls.getMethods();
        for (int i = 0; i < methods.length; i++) {
            Method method = methods[i];
            if (method.isBridge()) {
                continue;
            }
            nameToMethodMap.put(method.getName(), method);
        }
    }

    public String [] getParameterNames(String methodName) {
        Method method = (Method) nameToMethodMap.get(methodName);
        if (method == null) {
            return null;
        }
        return cpr.getParameterNames(method);
    }


}

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.axis2.description.java2wsdl.bytecode;

import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * Description: In ParamReader class, user cannot get inherited method parameter
 * from the class they passed in for performance reasons This class
 * is walks up the inheritance chain. If the method is not found in
 * the derived class, search in super class. If not found in the immedidate super
 * class, search super class's super class, until the root, which is java.lang.Object,
 * is reached. This is not an eager load since it only start searching the super class
 * when it is asked to.
 */
public class ChainedParamReader {
    private List chain = new ArrayList();
    private List clsChain = new ArrayList();
    private Map methodToParamMap = new HashMap();

    /**
     * Processes a given class's parameter names.
     *
     * @param cls the class which user wants to get parameter info from
     * @throws IOException
     */
    public ChainedParamReader(Class cls) throws IOException {
//具体解析每个class文件是由这个ParamReader实现的    
        ParamReader reader = new ParamReader(cls);
        chain.add(reader);
        clsChain.add(cls);
    }

    //now I need to create deligate methods

    /**
     * Returns the names of the declared parameters for the given constructor.
     * If we cannot determine the names, return null.  The returned array will
     * have one name per parameter.  The length of the array will be the same
     * as the length of the Class[] array returned by Constructor.getParameterTypes().
     *
     * @param ctor
     * @return Returns array of names, one per parameter, or null
     */
    public String[] getParameterNames(Constructor ctor) {
        //there is no need for the constructor chaining.
        return ((ParamReader) chain.get(0)).getParameterNames(ctor);
    }

    /**
     * Returns the names of the declared parameters for the given method.
     * If cannot determine the names in the current class, search its parent 
     * class until we reach java.lang.Object. If still can not find the method,
     * returns null. The returned array has one name per parameter. The length 
     * of the array will be the same as the length of the Class[] array 
     * returned by Method.getParameterTypes().
     *
     * @param method
     * @return String[] Returns array of names, one per parameter, or null
     */
    public String[] getParameterNames(Method method) {
        //go find the one from the cache first
        if (methodToParamMap.containsKey(method)) {
            return (String[]) methodToParamMap.get(method);
        }

        String[] ret = null;
//在当前类中寻找指定的方法，找到就返回        
        for (Iterator it = chain.iterator(); it.hasNext();) {
            ParamReader reader = (ParamReader) it.next();
            ret = reader.getParameterNames(method);
            if (ret != null) {
                methodToParamMap.put(method, ret);
                return ret;
            }
        }
        //if we here, it means we need to create new chain.
        Class cls = (Class) clsChain.get(chain.size() - 1);
//如果在当前类中找不到指定的方法，就到父类中寻找，找不到就返回null
        while (cls != null && cls != java.lang.Object.class && cls.getSuperclass() != null) {
            Class superClass = cls.getSuperclass();
            try {
                ParamReader _reader = new ParamReader(superClass);
                chain.add(_reader);
                clsChain.add(cls);
                ret = _reader.getParameterNames(method);
                if (ret != null) { //we found it so just return it.
                    methodToParamMap.put(method, ret);
                    return ret;
                }
            } catch (IOException e) {
                //can not find the super class in the class path, abort here
                return null;
            }
            cls = superClass;
        }
        methodToParamMap.put(method, ret);
        return null;
    }
}

import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import org.apache.axis2.description.java2wsdl.bytecode.ChainedParamReader;

/**
 * 获取构造函数或方法的参数名
 * @author guyadong
 *
 */
public class ParameterNames {
    private final Map<Class<?>, ChainedParamReader> readers = new HashMap<Class<?>, ChainedParamReader>();
    private final Class<?> clazz;

    /**
     * @param clazz 要构造函数或方法的参数名的类
     */
    public ParameterNames(Class<?> clazz) {
        this.clazz = clazz;
        try {
            Class<?> c = clazz;
            do {
                readers.put(c, new ChainedParamReader(c));
            } while (null != (c = c.getSuperclass()));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取构造函数或方法的参数名
     * @param reader
     * @param member 构造函数或方法对象
     * @return
     */
    private final String[] getParameterNames(ChainedParamReader reader, Member member) {
        if (member instanceof Method)
            return reader.getParameterNames((Method) member);
        else if (member instanceof Constructor)
            return reader.getParameterNames((Constructor<?>) member);
        else
            throw new IllegalArgumentException("member type must be Method or Constructor");
    }

    /**
     * 获取构造函数或方法的参数名
     * @param member 构造函数或方法对象
     * @return
     * @see #getParameterNames(ChainedParamReader, Member)
     */
    public final String[] getParameterNames(Member member) {
        Assert.notNull(member, "member");
        Class<?> declaringClass = member.getDeclaringClass();
        ChainedParamReader reader;
        if (null == (reader = readers.get(declaringClass))) {
            throw new IllegalArgumentException(String.format("%s is not member of %s", member.toString(),
                    declaringClass.getName()));
        }
        return getParameterNames(reader, member);
    }

    /**
     * 获取构造函数或方法的参数名<br>
     * {@code name}为{@code null}时,获取构造函数的参数名
     * @param name 方法名
     * @param parameterTypes 构造函数或方法的参数类型
     * @return
     * @throws NoSuchMethodException
     * @see {@link #getParameterNames(String, Class)}
     */
    public final String[] getParameterNames(String name, Class<?>[] parameterTypes) throws NoSuchMethodException {
        try {
            Member member = null == name ? clazz.getConstructor(parameterTypes) : clazz.getMethod(name, parameterTypes);
            return getParameterNames(member);
        } catch (SecurityException e) {
            throw new IllegalArgumentException(e);
        }
    }

}