反射获得springmvc的所有方法，入参出参

@RequestMapping("/test")
public void test(HttpSession session) throws Exception {
	//获取所有被RestController注解的类
	WebApplicationContext wc = WebApplicationContextUtils.getRequiredWebApplicationContext(session.getServletContext());
	Map<String, Object> beansWithAnnotation = wc.getBeansWithAnnotation(RestController.class);
	Set<Map.Entry<String, Object>> entries = beansWithAnnotation.entrySet();

	//遍历集合
	for (Map.Entry<String, Object> entry : entries) {
		Object value = entry.getValue();
		Class<?> clazz = value.getClass();
		Method[] methods = clazz.getMethods();
		//获取类上的RequestMapping的值
		RequestMapping controllerMapping = clazz.getAnnotation(RequestMapping.class);
		String controllerUrl = springPath+ controllerMapping.value()[0];
		for (Method method : methods) {
			boolean present = method.isAnnotationPresent(RequestMapping.class);
			if (present) {
				RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);
				ApiOperation annotation = method.getAnnotation(ApiOperation.class);
				String annotationValue = annotation.value();
				LocalVariableTableParameterNameDiscoverer discoverer = new LocalVariableTableParameterNameDiscoverer();
				//获得方法上的所有所有入参名
				String[] parameterNames = discoverer.getParameterNames(method);
				Class<?>[] parameterTypes = method.getParameterTypes();
				String param = "";
				for (int i =0; i < parameterTypes.length;i++) {
					ClassLoader classLoader = parameterTypes[i].getClassLoader();
					if (classLoader == null) {
						//如果参数是基本类
						param += parameterTypes[i].getSimpleName() + " " + parameterNames[i] +",";

					} else {
						//如果参数是封装类
						Field[] fields = parameterTypes[i].getDeclaredFields();
						for (Field field : fields) {
							param += field.getType().getSimpleName() + " " + field.getName() +",";
						}
					}
				}

				//获取方法的返回参数类型
				String returnCallback = "";
				Type genericReturnType = method.getGenericReturnType();
				if (genericReturnType instanceof ParameterizedType) { // 判断获取的类型是否是参数类型
					Type[] typesto = ((ParameterizedType) genericReturnType).getActualTypeArguments();// 强制转型为带参数的泛型类型，
					Type type = typesto[0];
					String typeName = type.getTypeName();
					if (type instanceof ParameterizedType) {
						typeName = typeName.substring(0,typeName.indexOf("<"));
						typeName = typeName.substring(typeName.lastIndexOf(".")+1);
						returnCallback += "<"+typeName+"<";
						Type[] typesto2 = ((ParameterizedType) type).getActualTypeArguments();
						for (int i =0; i < typesto2.length; i++) {
							Type type1 = typesto2[i];
							String typeName1 = type1.getTypeName();
							if (typeName1.indexOf("<") >= 0) {
								typeName1 = typeName1.substring(0,typeName1.indexOf("<"));
								typeName1 = typeName1.substring(typeName1.lastIndexOf(".")+1);
							} else {
								typeName1 = typeName1.substring(typeName1.lastIndexOf(".")+1);
							}
							if (i == typesto2.length -1) returnCallback += typeName1;
							else returnCallback += typeName1+",";
						}
						returnCallback += ">>";

					} else {
						returnCallback += "<"+typeName.substring(typeName.lastIndexOf(".")+1)+">";
					}

				}

			}
		}

	}
}