1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
/*
* Created on 25 janv. 07
*/
import java.lang.reflect.Method;
import java.util.LinkedList;
import java.util.List;
/**
* @author CyberChouan
* @version 2007.01.25
*/
public class MethodUtils {
/**
* Lors de l'invocation d'une {@link Method} via la methode 'invoke',
* si le parametre attendu est une primitive, l'invocation avec en
* parametre l'objet associe fonctionne
* @param expected
* @param given
* @return
*/
public static boolean isInvocableFrom(Class expected, Class given) {
if(expected.isAssignableFrom(given)) {
return true;
} else if (hasWrapper(expected)) {
return given.equals(getWrapper(expected));
} else {
return false;
}
}
public static boolean hasPrimitive(Class javaClass) {
if(javaClass.equals(Integer.class)) { return true; }
if(javaClass.equals(Long.class)) { return true; }
if(javaClass.equals(Float.class)) { return true; }
if(javaClass.equals(Double.class)) { return true; }
if(javaClass.equals(Short.class)) { return true; }
if(javaClass.equals(Void.class)) { return true; }
if(javaClass.equals(Character.class)) { return true; }
if(javaClass.equals(Byte.class)) { return true; }
if(javaClass.equals(Boolean.class)) { return true; }
return false;
}
public static Class getPrimitive(Class javaClass) {
if(javaClass.equals(Integer.class)) { return Integer.TYPE; }
if(javaClass.equals(Long.class)) { return Long.TYPE; }
if(javaClass.equals(Float.class)) { return Float.TYPE; }
if(javaClass.equals(Double.class)) { return Double.TYPE; }
if(javaClass.equals(Short.class)) { return Short.TYPE; }
if(javaClass.equals(Void.class)) { return Void.TYPE; }
if(javaClass.equals(Character.class)) { return Character.TYPE; }
if(javaClass.equals(Byte.class)) { return Byte.TYPE; }
if(javaClass.equals(Boolean.class)) { return Boolean.TYPE; }
return null;
}
public static boolean hasWrapper(Class javaClass) {
if(javaClass.equals(Integer.TYPE)) { return true; }
if(javaClass.equals(Long.TYPE)) { return true; }
if(javaClass.equals(Float.TYPE)) { return true; }
if(javaClass.equals(Double.TYPE)) { return true; }
if(javaClass.equals(Short.TYPE)) { return true; }
if(javaClass.equals(Void.TYPE)) { return true; }
if(javaClass.equals(Character.TYPE)) { return true; }
if(javaClass.equals(Byte.TYPE)) { return true; }
if(javaClass.equals(Boolean.TYPE)) { return true; }
return false;
}
public static Class getWrapper(Class javaClass) {
if(javaClass.equals(Integer.TYPE)) { return Integer.class; }
if(javaClass.equals(Long.TYPE)) { return Long.class; }
if(javaClass.equals(Float.TYPE)) { return Float.class; }
if(javaClass.equals(Double.TYPE)) { return Double.class; }
if(javaClass.equals(Short.TYPE)) { return Short.class; }
if(javaClass.equals(Void.TYPE)) { return Void.class; }
if(javaClass.equals(Character.TYPE)) { return Character.class; }
if(javaClass.equals(Byte.TYPE)) { return Byte.class; }
if(javaClass.equals(Boolean.TYPE)) { return Boolean.class; }
return null;
}
/**
* Recherche une methode nommee 'methodName', invocable a partir d'arguments
* de types parameterTypes. Si plusieurs methodes correcpondantes sont trouvees,
* on en renvoie une au hasard (la premiere de la liste)
* @param methodClass
* @param methodName
* @param parameterTypes
* @return
*/
public static Method findMethod(Class methodClass, String methodName, Class[] parameterTypes) {
try { return findExactMethod(methodClass, methodName, parameterTypes);}
catch (Exception e) {
List methods = getMethods(methodClass, methodName, parameterTypes.length);
List invocableMethods = findInvocableMethods(methods, parameterTypes);
if(invocableMethods.size() > 0) {
return (Method) invocableMethods.get(0);
} else {
return null;
}
}
}
public static List findInvocableMethods(List methods, Class[] parameterTypes) {
Method method;
List invocableMethods = new LinkedList();
for(int i=0; i<methods.size(); i++) {
method = (Method) methods.get(i);
if(isInvocableFrom(method, parameterTypes)) {
invocableMethods.add(method);
}
}
return invocableMethods;
}
/**
* Utilisation directe de la methode 'getMethod' de {@link Class}
* @param methodClass
* @param methodName
* @param parameterTypes
* @return
* @throws SecurityException
* @throws NoSuchMethodException
*/
public static Method findExactMethod(Class methodClass, String methodName, Class[] parameterTypes)
throws SecurityException, NoSuchMethodException {
return methodClass.getMethod(methodName, parameterTypes);
}
public static boolean isInvocableFrom(Method method, Class[] argsTypes) {
Class[] expectedArgsTypes = method.getParameterTypes();
// Si le nombre d'arguments n'est pas le meme, la methode n'est pas
// 'invocable' a partir des arguments proposes
if (argsTypes.length != expectedArgsTypes.length) {
return false;
}
// Si un des types est incompatible, la methode n'est pas
// 'invocable' a partir des arguments propos
for(int i=0; i<argsTypes.length; i++) {
if(!isInvocableFrom(expectedArgsTypes[i], argsTypes[i])) {
return false;
}
}
return true;
}
/**
* Renvoie la liste des methodes de la classe 'methodClass' qui portent le nom
* 'name', et qui prennent 'nbArgs' arguments
* @param methodsClass
* @param name
* @param nbArgs
* @return
*/
public static List getMethods(Class methodsClass, String name, int nbArgs) {
Method[] classMethods = methodsClass.getMethods();
Method temp;
List result = new LinkedList();
for(int i=0; i<classMethods.length; i++) {
temp = classMethods[i];
if(temp.getName().equals(name) && temp.getParameterTypes().length == nbArgs) {
result.add(temp);
}
}
return result;
}
/**
* Renvoie la liste des 'getters' d'une classe, c'est a dire les methodes
* dont le nom commence par 'get' (ou 'is' si l'attribut de la classe est
* booleen) et qui n'ont pas de parametres
* @param javaClass
* @return
*/
public static List getGetters(Class javaClass) {
Method[] classMethods = javaClass.getMethods();
Method temp;
List result = new LinkedList();
for(int i=0; i<classMethods.length; i++) {
temp = classMethods[i];
if((temp.getName().startsWith("get") || temp.getName().startsWith("is"))
&& temp.getParameterTypes().length == 0) {
result.add(temp);
}
}
return result;
}
public static void main(String[] args) {
System.out.println(isInvocableFrom(Integer.TYPE, Integer.class));
}
} |
