private final Method findMatchingMethod(final Class<?> classType, final Method matchingMethod) {
for (final Method method : classType.getMethods()) {
if (method.getName().equals(matchingMethod.getName())
&& method.getReturnType().equals(matchingMethod.getReturnType())
&& matchParameters(method.getParameters(), matchingMethod.getParameters())) {
return method;
}
}
return null;
}
PrivilegeNG addController(Class<?> controller_class, Method method) {
StringBuilder sb = new StringBuilder();
sb.append(controller_class.getName());
sb.append(": ");
if (method.getReturnType().getSimpleName().equalsIgnoreCase("void") == false) {
sb.append(method.getReturnType().getSimpleName());
sb.append(" ");
}
sb.append(method.getName());
sb.append("(");
if (method.getParameterCount() > 0) {
Parameter[] params = method.getParameters();
for (int pos = 0; pos < params.length; pos++) {
sb.append(params[pos].getType().getSimpleName());
if (pos + 1 < params.length) {
sb.append(", ");
}
}
}
sb.append(")");
associated_controllers.add(sb.toString());
return this;
}
private List<Method> GetMethods(java.lang.reflect.Method[] methods) {
List<Method> list = new ArrayList<>();
for (java.lang.reflect.Method mthd : methods) {
String visibility = this.GetVisibility(mthd.getModifiers());
boolean isStatic = this.GetIsStatic(mthd.getModifiers());
boolean isfinal = this.GetIsFinal(mthd.getModifiers());
String outputType = mthd.getGenericReturnType().toString();
List<InputParameter> inputParameters = this.GetInputParameters(mthd.getParameters());
List<String> annotations = this.GetAnnotations(mthd.getAnnotations());
String name = mthd.getName();
if (name.contains("_")) continue;
boolean isThrowExceptions = false;
if (mthd.getExceptionTypes().length > 0) {
isThrowExceptions = true;
}
Method method =
ModelFactory.GetMethodWithValue(
outputType,
name,
visibility,
isfinal,
isStatic,
isThrowExceptions,
inputParameters,
annotations,
new ArrayList<>());
list.add(method);
}
return list;
}
private UriComponents applyContributers(
UriComponentsBuilder builder,
Method method,
Object[] argumentValues,
Map<String, Object> uriVars) {
if (this.contributors.isEmpty()) {
return builder.buildAndExpand(uriVars);
}
int paramCount = method.getParameters().length;
int argCount = argumentValues.length;
Assert.isTrue(
paramCount == argCount,
"Number of method parameters "
+ paramCount
+ " does not match number of argument values "
+ argCount);
for (int i = 0; i < paramCount; i++) {
MethodParameter param = new MethodParameter(method, i);
param.initParameterNameDiscovery(parameterNameDiscoverer);
for (UriComponentsContributor c : this.contributors) {
if (c.supportsParameter(param)) {
c.contributeMethodArgument(
param, argumentValues[i], builder, uriVars, this.conversionService);
break;
}
}
}
return builder.buildAndExpand(uriVars);
}
public static void main(String[] args)
throws ExecutionException, InterruptedException, InvocationTargetException,
IllegalAccessException {
for (String arg : args) {
if (arg.startsWith("fan=")) System.setProperty("cassandra.btree.fanfactor", arg.substring(4));
else if (arg.startsWith("min=")) minTreeSize = Integer.parseInt(arg.substring(4));
else if (arg.startsWith("max=")) maxTreeSize = Integer.parseInt(arg.substring(4));
else if (arg.startsWith("count=")) perThreadTrees = Integer.parseInt(arg.substring(6));
else exit();
}
List<Method> methods = new ArrayList<>();
for (Method m : LongBTreeTest.class.getDeclaredMethods()) {
if (m.getParameters().length > 0) continue;
for (Annotation annotation : m.getAnnotations())
if (annotation.annotationType() == Test.class) methods.add(m);
}
LongBTreeTest test = new LongBTreeTest();
Collections.sort(methods, (a, b) -> a.getName().compareTo(b.getName()));
log(Lists.transform(methods, (m) -> m.getName()).toString());
for (Method m : methods) {
log(m.getName());
m.invoke(test);
}
log("success");
}
/**
* Extracts parameters from a method call and attaches these with the comments extracted from the
* javadoc
*
* @param apiAction The Verb of the action containing these parametes
* @param method The method to inspect
* @param parameterComments The parameter comments associated with these parameters
* @return A collection of parameters keyed by name
*/
protected Map<String, RamlQueryParameter> extractQueryParameters(
RamlActionType apiAction, Method method, Map<String, String> parameterComments) {
// Since POST requests have a body we choose to keep all request data in one place as much as
// possible
if (apiAction.equals(RamlActionType.POST) || method.getParameterCount() == 0) {
return Collections.emptyMap();
}
Map<String, RamlQueryParameter> queryParams = new LinkedHashMap<>();
for (Parameter param : method.getParameters()) {
if (isQueryParameter(
param)) { // Lets skip resourceIds since these are going to be going in the URL
RamlParamType simpleType = SchemaHelper.mapSimpleType(param.getType());
if (simpleType == null) {
queryParams.putAll(
SchemaHelper.convertClassToQueryParameters(
param, javaDocs.getJavaDoc(param.getType())));
} else {
// Check if we have comments
String paramComment = parameterComments.get(param.getName());
queryParams.putAll(SchemaHelper.convertParameterToQueryParameter(param, paramComment));
}
}
}
return queryParams;
}
@RuntimeType
public static Object intercept(
@Origin Method method, @AllArguments Object[] arguments, @SuperCall Callable superCall) {
val declaringClass = method.getDeclaringClass();
val parameters = method.getParameters();
val keyArguments =
IntStream.range(0, parameters.length)
.boxed()
.map(i -> Argument.builder().type(parameters[i].getType()).value(arguments[i]).build())
.collect(Collectors.toList());
val cacheKey =
CacheKey.builder().bucketName(declaringClass.getName()).arguments(keyArguments).build();
return cache.computeIfAbsent(
cacheKey,
k -> {
try {
return superCall.call();
} catch (Exception e) {
return null;
}
});
}
public static int parseUid(Method m, Object[] args) {
Parameter[] pas = m.getParameters();
for (int i = 0; i < pas.length; i++) {
if (pas[i].isAnnotationPresent(Uid.class)) {
return (int) args[i];
}
}
return -1;
}
private static JInvocation generateInvocation(Method method) {
JInvocation generatedInvocation = JExpr.invoke(JExpr.invoke("getWrapped"), method.getName());
for (Parameter parameter : method.getParameters()) {
generatedInvocation.arg(JExpr.ref(parameter.getName()));
}
return generatedInvocation;
}
public static boolean hasFormTypes(Method method) {
final List<java.lang.reflect.Parameter> params = Arrays.asList(method.getParameters());
for (java.lang.reflect.Parameter param : params) {
Class<?> type = param.getType();
if (!formTypes.containsKey(type)) {
return false;
}
}
return true;
}
/**
* @param method the method associated to the element
* @param index the method parameter index
* @param type the method parameter type
* @return the associated {@link FilterElementParameterDescriptor}
*/
private FilterElementParameterDescriptor<?> createFilterElementParameter(
Method method, int index, Type type) {
// @Name
List<Name> nameAnnotations =
ReflectionMethodUtils.getMethodParameterAnnotations(method, index, Name.class, true);
String name;
if (!nameAnnotations.isEmpty()) {
name = nameAnnotations.get(0).value();
} else {
// Fallback on reflection to get the parameter name
Parameter parameter = method.getParameters()[index];
name = parameter.isNamePresent() ? method.getParameters()[index].getName() : null;
}
// @Default
List<Default> defaultAnnotations =
ReflectionMethodUtils.getMethodParameterAnnotations(method, index, Default.class, true);
Object defaultValue;
if (!defaultAnnotations.isEmpty()) {
defaultValue = defaultAnnotations.get(0).value();
if (defaultValue != null) {
try {
defaultValue = this.converter.convert(type, defaultValue);
} catch (ConversionException e) {
// TODO: remove that hack when String -> Map support is added to xwiki-properties
if (ReflectionUtils.getTypeClass(type) == Map.class
&& ((String) defaultValue).isEmpty()) {
defaultValue = Collections.EMPTY_MAP;
} else {
throw e;
}
}
}
} else {
defaultValue = null;
}
return new FilterElementParameterDescriptor<Object>(index, name, type, defaultValue);
}
@Test
public void findingAnnotationsRecursively() {
Method method = findMethod(this.getClass(), "withMarker", String.class);
List<Annotation> annotations = allAnnotations(method.getParameters()[0]);
assertEquals(4, annotations.size());
assertEquals(X.class, annotations.get(0).annotationType());
assertEquals(Y.class, annotations.get(1).annotationType());
assertEquals(Z.class, annotations.get(2).annotationType());
assertEquals(W.class, annotations.get(3).annotationType());
}
@Override
public String[] getParameterNames(Method method) {
Parameter[] parameters = method.getParameters();
String[] parameterNames = new String[parameters.length];
for (int i = 0; i < parameters.length; i++) {
Parameter param = parameters[i];
if (!param.isNamePresent()) {
return null;
}
parameterNames[i] = param.getName();
}
return parameterNames;
}
@Override
public <E> DynamicType.Builder<E> processMethod(
final DynamicType.Builder<E> builder, final Method method, final Annotation annotation) {
final java.lang.reflect.Parameter[] arguments = method.getParameters();
if (ReflectionUtility.isGetMethod(method))
if (arguments == null || arguments.length == 0)
return this.getNode(builder, method, annotation);
else
throw new IllegalStateException(
method.getName() + " was annotated with @OutVertex but had arguments.");
else
throw new IllegalStateException(
method.getName() + " was annotated with @OutVertex but did not begin with: get");
}
public static void main(String[] args) throws JClassAlreadyExistsException, IOException {
JCodeModel codeModel = new JCodeModel();
Class template = AbstractBaseWrapper.class;
String packageName = template.getPackage().getName();
String className = template.getSimpleName().replace("Abstract", "") + "Impl";
JPackage generatedPackage = codeModel._package(packageName);
JDefinedClass generatedClass = generatedPackage._class(JMod.FINAL, className); // Creates
// a
// new
// class
generatedClass._extends(template);
for (Method method : template.getMethods()) {
if (Modifier.isAbstract(method.getModifiers())) {
System.out.println(
"Found abstract method "
+ Modifier.toString(method.getModifiers())
+ " "
+ method.getName());
JMethod generatedMethod =
generatedClass.method(JMod.PUBLIC, method.getReturnType(), method.getName());
for (Parameter parameter : method.getParameters()) {
generatedMethod.param(parameter.getModifiers(), parameter.getType(), parameter.getName());
}
if (method.getReturnType().equals(Void.TYPE)) {
generatedMethod.body().add(generateInvocation(method));
} else {
generatedMethod.body()._return(generateInvocation(method));
}
}
}
ByteArrayOutputStream out = new ByteArrayOutputStream();
codeModel.build(new SingleStreamCodeWriter(out));
System.out.println(out);
}
public static void main(String[] args) throws ClassNotFoundException {
// Получение объекта типа Class
People people = new People();
Class myClass = people.getClass();
System.out.println("myClass = " + myClass);
// Если у нас есть класс, для которого в момент компиляции известен тип, то получить экземпляр
// класса ещё проще.
Class myClass1 = People.class;
System.out.println("myClass1 = " + myClass1);
// Если имя класса не известно в момент компиляции, но становится известным во время выполнения
// программы,
// можно использовать метод forName(), чтобы получить объект Class.
Class c = Class.forName("DZ_14.reflection_Test.Razbor.People");
System.out.println("c = " + c);
// Получение пакета
Package p = People.class.getPackage();
System.out.println("package " + p.getName() + ";");
// Выводим интерфейсы, которые реализует класс
Class[] interfaces = myClass.getInterfaces();
for (int i = 0, size = interfaces.length; i < size; i++) {
System.out.print(i == 0 ? "implements " : ", ");
System.out.print(interfaces[i].getSimpleName());
}
System.out.println(" {");
// Выводим поля класса
Field[] fields = People.class.getDeclaredFields();
for (Field field : fields) {
System.out.println(
"\t" + field.getModifiers() + field.getType() + " " + field.getName() + ";");
}
// Выводим методы, аннотации класса
Method[] methods = People.class.getDeclaredMethods();
for (Method m : methods) {
Annotation[] annotations = m.getAnnotations();
System.out.print("\t");
for (Annotation a : annotations)
System.out.print("@" + a.annotationType().getSimpleName() + " ");
System.out.println();
System.out.print(
"\t" + m.getModifiers() + getType(m.getReturnType()) + " " + m.getName() + "(");
System.out.print(m.getParameters());
System.out.println(") { }");
}
}
private void addMethodParameters(JaxrsResourceMethodDescription jaxrsRes, Method method) {
for (Parameter param : method.getParameters()) {
ParamInfo paramInfo = new ParamInfo();
paramInfo.cls = param.getType();
paramInfo.defaultValue = null;
paramInfo.name = null;
paramInfo.type = null;
Annotation annotation;
if ((annotation = param.getAnnotation(PathParam.class)) != null) {
PathParam pathParam = (PathParam) annotation;
paramInfo.name = pathParam.value();
paramInfo.type = "@" + PathParam.class.getSimpleName();
} else if ((annotation = param.getAnnotation(QueryParam.class)) != null) {
QueryParam queryParam = (QueryParam) annotation;
paramInfo.name = queryParam.value();
paramInfo.type = "@" + QueryParam.class.getSimpleName();
} else if ((annotation = param.getAnnotation(HeaderParam.class)) != null) {
HeaderParam headerParam = (HeaderParam) annotation;
paramInfo.name = headerParam.value();
paramInfo.type = "@" + HeaderParam.class.getSimpleName();
} else if ((annotation = param.getAnnotation(CookieParam.class)) != null) {
CookieParam cookieParam = (CookieParam) annotation;
paramInfo.name = cookieParam.value();
paramInfo.type = "@" + CookieParam.class.getSimpleName();
} else if ((annotation = param.getAnnotation(MatrixParam.class)) != null) {
MatrixParam matrixParam = (MatrixParam) annotation;
paramInfo.name = matrixParam.value();
paramInfo.type = "@" + MatrixParam.class.getSimpleName();
} else if ((annotation = param.getAnnotation(FormParam.class)) != null) {
FormParam formParam = (FormParam) annotation;
paramInfo.name = formParam.value();
paramInfo.type = "@" + FormParam.class.getSimpleName();
}
if (paramInfo.name == null) {
paramInfo.name = param.getName();
}
if ((annotation = param.getAnnotation(DefaultValue.class)) != null) {
DefaultValue defaultValue = (DefaultValue) annotation;
paramInfo.defaultValue = defaultValue.value();
}
jaxrsRes.parameters.add(paramInfo);
}
}
/** Execute the action */
@Override
public void run() {
try {
// get the second parameter
Class<?> parameterType = actionMethod.getParameters()[1].getClass();
ObjectMapper mapper = new ObjectMapper();
Object parameterData = mapper.treeToValue(parameter, parameterType);
// Class<?> returnType = actionMethod.getReturnType();
// Object returnData = null;
// returnData =
actionMethod.invoke(targetObject, identity, parameterData);
} catch (Exception exception) {
exception.printStackTrace();
}
}
@Before("ClassInfoCheck()")
public Object ClassInfoCheckAround(JoinPoint joinPoint) throws Throwable {
System.out.println("ClassInfoCheckAround");
Object obj = joinPoint.getTarget();
System.out.println(obj.getClass().toString());
// Todo : 리플렉션을 이용해서 어노테이션의 값을 체크
Class[] args = new Class[1];
args[0] = SearchVO.class;
// System.out.println(obj.getClass().getMethod("selectPlayerList",
// args).getAnnotation(ClassInfo.class).created() + " No For");
// 어노테이션을 사용한 객체와 메소드
for (Method method : obj.getClass().getMethods()) {
Parameter[] parameters = method.getParameters();
method.getDefaultValue();
for (Parameter parameter : parameters) {
// if(!parameter.isNamePresent()) {
// throw new IllegalArgumentException("Parameter names are not present!");
// }
// System.out.println(method.getName() + " : " + parameter.getParameterizedType());
}
Type[] types = method.getGenericParameterTypes();
for (Type type : types) {
// System.out.println(method.getName() + " " + type.getClass());
}
ClassInfo classInfo = (ClassInfo) method.getAnnotation(ClassInfo.class);
if (classInfo != null && classInfo.created() != null) {
// System.out.println(classInfo.created() + " For");
}
}
// 사용된 어노테이션
Class<?> object = joinPoint.getTarget().getClass();
for (Method method : object.getDeclaredMethods()) {
if (method.isAnnotationPresent(RequestMapping.class)) {
Annotation annotation = method.getAnnotation(RequestMapping.class);
System.out.println(annotation);
}
}
return obj;
}
/**
* Invokes the specified method on the specified object with the specified parameter.
*
* @param object the object to invoke the method on
* @param setter the method to invoke
* @param parameter the parameter to pass to the method
* @throws ReflectiveOperationException if there is any reflection error
* @throws IllegalArgumentException if the specified parameter is not valid
*/
@SuppressWarnings("unchecked")
private static <E extends Enum<E>> void invoke(Object object, Method setter, Object parameter)
throws ReflectiveOperationException, IllegalArgumentException {
Class<?> paramType = setter.getParameters()[0].getType();
if (String.class.equals(paramType)) {
setter.invoke(object, parameter.toString());
} else if (boolean.class.equals(paramType)) {
setter.invoke(object, Boolean.valueOf(parameter.toString()));
} else if (int.class.equals(paramType)) {
setter.invoke(object, Integer.parseInt(parameter.toString()));
} else if (double.class.equals(paramType)) {
setter.invoke(object, Double.parseDouble(parameter.toString()));
} else if (Character.class.equals(paramType)) {
setter.invoke(object, parameter.toString().charAt(0));
} else if (paramType.isEnum()) {
Class<E> e = (Class<E>) paramType;
setter.invoke(object, Enum.valueOf(e, parameter.toString()));
} else {
throw new RuntimeException("Unknown setter type: " + paramType);
}
}
public Object routeRequest(String http_method, String url, Map<String, String> args)
throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
/* find matching method */
final String entry = http_method + ":" + url;
Method method = routing.get(entry);
if (method == null) {
throw new IllegalAccessException("No such route exposed");
}
/* map named arguments to positional */
Parameter parameters[] = method.getParameters();
Object mapped_args[] = new Object[parameters.length];
for (int i = 0; i < parameters.length; ++i) {
final String argname = parameters[i].getName();
if (!args.containsKey(argname)) {
throw new IllegalArgumentException("Missing argument " + argname);
}
mapped_args[i] = args.get(argname);
}
/* invoke method with arguments */
return method.invoke(this, mapped_args);
}
private Parameter findParameterOfMethod(String methodName, Class<?>... parameterTypes) {
Method method = ReflectionUtils.findMethod(Sample.class, methodName, parameterTypes).get();
return method.getParameters()[0];
}
