MentaContainer

Rev

Rev 22 | Rev 139 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 22 Rev 58
1
package org.mentacontainer.util;
1
package org.mentacontainer.util;
2
2
3
import java.lang.reflect.Field;
3
import java.lang.reflect.Field;
4
import java.lang.reflect.InvocationTargetException;
4
import java.lang.reflect.InvocationTargetException;
5
import java.lang.reflect.Method;
5
import java.lang.reflect.Method;
6
import java.util.ArrayList;
6
import java.util.ArrayList;
7
import java.util.HashMap;
7
import java.util.HashMap;
8
import java.util.Iterator;
8
import java.util.Iterator;
9
import java.util.List;
9
import java.util.List;
10
import java.util.Map;
10
import java.util.Map;
11
11
12
public class InjectionUtils {
12
public class InjectionUtils {
13
13
14
        /**
14
        /**
15
         * The character used to separate the prefix from the value name when you are using the getObject method with a prefix. You can change the value of this prefix if you want to
15
         * The character used to separate the prefix from the value name when you are using the getObject method with a prefix. You can change the value of this prefix if you want to
16
         * by changing this static variable.
16
         * by changing this static variable.
17
         *
17
         *
18
         * Ex: getObject(User.class, "user") will get all values that begin with "user.".
18
         * Ex: getObject(User.class, "user") will get all values that begin with "user.".
19
         */
19
         */
20
        public static char PREFIX_SEPARATOR = '.';
20
        public static char PREFIX_SEPARATOR = '.';
21
21
22
        private static Map<Class<? extends Object>, Map<String, Object>> settersMaps = new HashMap<Class<? extends Object>, Map<String, Object>>();
22
        private static Map<Class<? extends Object>, Map<String, Object>> settersMaps = new HashMap<Class<? extends Object>, Map<String, Object>>();
23
23
24
        private static Map<Class<? extends Object>, Map<String, Object>> fieldsMaps = new HashMap<Class<? extends Object>, Map<String, Object>>();
24
        private static Map<Class<? extends Object>, Map<String, Object>> fieldsMaps = new HashMap<Class<? extends Object>, Map<String, Object>>();
25
25
26
        public static void prepareForInjection(Class<? extends Object> klass, Map<String, Object> setters, Map<String, Object> fields) {
26
        public static void prepareForInjection(Class<? extends Object> klass, Map<String, Object> setters, Map<String, Object> fields) {
27
27
28
                StringBuffer sb = new StringBuffer(32);
28
                StringBuffer sb = new StringBuffer(32);
29
29
30
                Method[] methods = klass.getMethods();
30
                Method[] methods = klass.getMethods();
31
31
32
                for (int i = 0; i < methods.length; i++) {
32
                for (int i = 0; i < methods.length; i++) {
33
33
34
                        Method m = methods[i];
34
                        Method m = methods[i];
35
35
36
                        String name = m.getName();
36
                        String name = m.getName();
37
37
38
                        Class<?>[] types = m.getParameterTypes();
38
                        Class<?>[] types = m.getParameterTypes();
39
39
40
                        if (name.startsWith("set") && name.length() > 3 && types.length == 1) {
40
                        if (name.startsWith("set") && name.length() > 3 && types.length == 1) {
41
41
42
                                String var = name.substring(3);
42
                                String var = name.substring(3);
43
43
44
                                if (var.length() > 1) {
44
                                if (var.length() > 1) {
45
45
46
                                        sb.delete(0, sb.length());
46
                                        sb.delete(0, sb.length());
47
47
48
                                        sb.append(var.substring(0, 1).toLowerCase());
48
                                        sb.append(var.substring(0, 1).toLowerCase());
49
49
50
                                        sb.append(var.substring(1));
50
                                        sb.append(var.substring(1));
51
51
52
                                        var = sb.toString();
52
                                        var = sb.toString();
53
53
54
                                } else {
54
                                } else {
55
55
56
                                        var = var.toLowerCase();
56
                                        var = var.toLowerCase();
57
                                }
57
                                }
58
58
59
                                m.setAccessible(true);
59
                                m.setAccessible(true);
60
60
61
                                if (setters.containsKey(var)) {
61
                                if (setters.containsKey(var)) {
62
62
63
                                        Object obj = setters.get(var);
63
                                        Object obj = setters.get(var);
64
64
65
                                        if (obj instanceof List) {
65
                                        if (obj instanceof List) {
66
66
67
                                                List<Method> list = (List<Method>) obj;
67
                                                List<Method> list = (List<Method>) obj;
68
68
69
                                                list.add(m);
69
                                                list.add(m);
70
70
71
                                        } else if (obj instanceof Method) {
71
                                        } else if (obj instanceof Method) {
72
72
73
                                                List<Method> list = new ArrayList<Method>();
73
                                                List<Method> list = new ArrayList<Method>();
74
74
75
                                                list.add((Method) obj);
75
                                                list.add((Method) obj);
76
76
77
                                                list.add(m);
77
                                                list.add(m);
78
78
79
                                                setters.put(var, list);
79
                                                setters.put(var, list);
80
80
81
                                        }
81
                                        }
82
82
83
                                } else {
83
                                } else {
84
84
85
                                        setters.put(var, m);
85
                                        setters.put(var, m);
86
86
87
                                }
87
                                }
88
                        }
88
                        }
89
                }
89
                }
90
90
91
                if (fields == null) return;
91
                if (fields == null) return;
92
92
93
                Field[] f = klass.getDeclaredFields();
93
                Field[] f = klass.getDeclaredFields();
94
94
95
                for (int i = 0; i < f.length; i++) {
95
                for (int i = 0; i < f.length; i++) {
96
96
97
                        Field field = f[i];
97
                        Field field = f[i];
98
98
99
                        field.setAccessible(true);
99
                        field.setAccessible(true);
100
100
101
                        String name = field.getName();
101
                        String name = field.getName();
102
102
103
                        if (setters.containsKey(name)) {
103
                        if (setters.containsKey(name)) {
104
104
105
                                Object obj = setters.get(name);
105
                                Object obj = setters.get(name);
106
106
107
                                if (obj instanceof Method) {
107
                                if (obj instanceof Method) {
108
108
109
                                        Method m = (Method) obj;
109
                                        Method m = (Method) obj;
110
110
111
                                        Class<?>[] types = m.getParameterTypes();
111
                                        Class<?>[] types = m.getParameterTypes();
112
112
113
                                        Class<?> type = field.getType();
113
                                        Class<?> type = field.getType();
114
114
115
                                        if (type.isAssignableFrom(types[0])) continue;
115
                                        if (type.isAssignableFrom(types[0])) continue;
116
116
117
                                } else if (obj instanceof List) {
117
                                } else if (obj instanceof List) {
118
118
119
                                        List<Method> list = (List<Method>) obj;
119
                                        List<Method> list = (List<Method>) obj;
120
120
121
                                        Iterator<Method> iter = list.iterator();
121
                                        Iterator<Method> iter = list.iterator();
122
122
123
                                        boolean found = false;
123
                                        boolean found = false;
124
124
125
                                        while (iter.hasNext()) {
125
                                        while (iter.hasNext()) {
126
126
127
                                                Method m = iter.next();
127
                                                Method m = iter.next();
128
128
129
                                                Class<?>[] types = m.getParameterTypes();
129
                                                Class<?>[] types = m.getParameterTypes();
130
130
131
                                                Class<?> type = field.getType();
131
                                                Class<?> type = field.getType();
132
132
133
                                                if (type.isAssignableFrom(types[0])) {
133
                                                if (type.isAssignableFrom(types[0])) {
134
134
135
                                                        found = true;
135
                                                        found = true;
136
136
137
                                                        break;
137
                                                        break;
138
                                                }
138
                                                }
139
                                        }
139
                                        }
140
140
141
                                        if (found) continue;
141
                                        if (found) continue;
142
                                }
142
                                }
143
                        }
143
                        }
144
144
145
                        fields.put(name, field);
145
                        fields.put(name, field);
146
146
147
                }
147
                }
148
        }
148
        }
149
149
150
        public static boolean checkPrimitives(Class<? extends Object> target, Class<? extends Object> source) {
150
        public static boolean checkPrimitives(Class<? extends Object> target, Class<? extends Object> source) {
151
151
152
                if (target.equals(int.class) && source.equals(Integer.class)) return true;
152
                if (target.equals(int.class) && source.equals(Integer.class)) return true;
153
153
154
                if (target.equals(boolean.class) && source.equals(Boolean.class)) return true;
154
                if (target.equals(boolean.class) && source.equals(Boolean.class)) return true;
155
155
156
                if (target.equals(byte.class) && source.equals(Byte.class)) return true;
156
                if (target.equals(byte.class) && source.equals(Byte.class)) return true;
157
157
158
                if (target.equals(short.class) && source.equals(Short.class)) return true;
158
                if (target.equals(short.class) && source.equals(Short.class)) return true;
159
159
160
                if (target.equals(char.class) && source.equals(Character.class)) return true;
160
                if (target.equals(char.class) && source.equals(Character.class)) return true;
161
161
162
                if (target.equals(long.class) && source.equals(Long.class)) return true;
162
                if (target.equals(long.class) && source.equals(Long.class)) return true;
163
163
164
                if (target.equals(float.class) && source.equals(Float.class)) return true;
164
                if (target.equals(float.class) && source.equals(Float.class)) return true;
165
165
166
                if (target.equals(double.class) && source.equals(Double.class)) return true;
166
                if (target.equals(double.class) && source.equals(Double.class)) return true;
167
167
168
                return false;
168
                return false;
169
169
170
        }
170
        }
171
171
172
        public static Object tryToConvert(Object source, Class<? extends Object> targetType) {
172
        public static Object tryToConvert(Object source, Class<? extends Object> targetType) {
173
173
174
                return tryToConvert(source, targetType, false);
174
                return tryToConvert(source, targetType, false);
175
        }
175
        }
176
176
177
        public static Object tryToConvert(Object source, Class<?> targetType, boolean tryNumber) {
177
        public static Object tryToConvert(Object source, Class<?> targetType, boolean tryNumber) {
178
178
179
                String value = null;
179
                String value = null;
180
180
181
                if (source instanceof String) {
181
                if (source instanceof String) {
182
182
183
                        value = (String) source;
183
                        value = (String) source;
184
184
185
                } else if (tryNumber && source instanceof Number) {
185
                } else if (tryNumber && source instanceof Number) {
186
186
187
                        value = source.toString();
187
                        value = source.toString();
188
188
189
                } else {
189
                } else {
190
190
191
                        return null;
191
                        return null;
192
                }
192
                }
193
193
194
                Object newValue = null;
194
                Object newValue = null;
195
195
196
                String className = targetType.getName();
196
                String className = targetType.getName();
197
197
198
                if (className.equals("int") || className.equals("java.lang.Integer")) {
198
                if (className.equals("int") || className.equals("java.lang.Integer")) {
199
                        int x = -1;
199
                        int x = -1;
200
                        try {
200
                        try {
201
                                x = Integer.parseInt(value);
201
                                x = Integer.parseInt(value);
202
                        } catch (Exception e) {
202
                        } catch (Exception e) {
203
                                return null;
203
                                return null;
204
                        }
204
                        }
205
                        newValue = new Integer(x);
205
                        newValue = new Integer(x);
206
                } else if (className.equals("short") || className.equals("java.lang.Short")) {
206
                } else if (className.equals("short") || className.equals("java.lang.Short")) {
207
                        short x = -1;
207
                        short x = -1;
208
                        try {
208
                        try {
209
                                x = Short.parseShort(value);
209
                                x = Short.parseShort(value);
210
                        } catch (Exception e) {
210
                        } catch (Exception e) {
211
                                return null;
211
                                return null;
212
                        }
212
                        }
213
                        newValue = new Short(x);
213
                        newValue = new Short(x);
214
214
215
                } else if (className.equals("char") || className.equals("java.lang.Character")) {
215
                } else if (className.equals("char") || className.equals("java.lang.Character")) {
216
216
217
                        if (value.length() != 1) {
217
                        if (value.length() != 1) {
218
                                return null;
218
                                return null;
219
                        }
219
                        }
220
220
221
                        newValue = new Character(value.charAt(0));
221
                        newValue = new Character(value.charAt(0));
222
222
223
                } else if (className.equals("long") || className.equals("java.lang.Long")) {
223
                } else if (className.equals("long") || className.equals("java.lang.Long")) {
224
                        long x = -1;
224
                        long x = -1;
225
                        try {
225
                        try {
226
                                x = Long.parseLong(value);
226
                                x = Long.parseLong(value);
227
                        } catch (Exception e) {
227
                        } catch (Exception e) {
228
                                return null;
228
                                return null;
229
                        }
229
                        }
230
                        newValue = new Long(x);
230
                        newValue = new Long(x);
231
                } else if (className.equals("float") || className.equals("java.lang.Float")) {
231
                } else if (className.equals("float") || className.equals("java.lang.Float")) {
232
                        float x = -1;
232
                        float x = -1;
233
                        try {
233
                        try {
234
                                x = Float.parseFloat(value);
234
                                x = Float.parseFloat(value);
235
                        } catch (Exception e) {
235
                        } catch (Exception e) {
236
                                return null;
236
                                return null;
237
                        }
237
                        }
238
                        newValue = new Float(x);
238
                        newValue = new Float(x);
239
                } else if (className.equals("double") || className.equals("java.lang.Double")) {
239
                } else if (className.equals("double") || className.equals("java.lang.Double")) {
240
                        double x = -1;
240
                        double x = -1;
241
                        try {
241
                        try {
242
                                x = Double.parseDouble(value);
242
                                x = Double.parseDouble(value);
243
                        } catch (Exception e) {
243
                        } catch (Exception e) {
244
                                return null;
244
                                return null;
245
                        }
245
                        }
246
                        newValue = new Double(x);
246
                        newValue = new Double(x);
247
                } else if (className.equals("boolean") || className.equals("java.lang.Boolean")) {
247
                } else if (className.equals("boolean") || className.equals("java.lang.Boolean")) {
248
                        try {
248
                        try {
249
                                int x = Integer.parseInt(value);
249
                                int x = Integer.parseInt(value);
250
                                if (x == 1) {
250
                                if (x == 1) {
251
                                        newValue = Boolean.TRUE;
251
                                        newValue = Boolean.TRUE;
252
                                } else if (x == 0) {
252
                                } else if (x == 0) {
253
                                        newValue = Boolean.FALSE;
253
                                        newValue = Boolean.FALSE;
254
                                } else {
254
                                } else {
255
                                        return null;
255
                                        return null;
256
                                }
256
                                }
257
                        } catch (Exception e) {
257
                        } catch (Exception e) {
258
                                if (value.equalsIgnoreCase("true") || value.equals("on")) {
258
                                if (value.equalsIgnoreCase("true") || value.equals("on")) {
259
                                        newValue = Boolean.TRUE;
259
                                        newValue = Boolean.TRUE;
260
                                } else if (value.equalsIgnoreCase("false")) {
260
                                } else if (value.equalsIgnoreCase("false")) {
261
                                        newValue = Boolean.FALSE;
261
                                        newValue = Boolean.FALSE;
262
                                } else {
262
                                } else {
263
                                        return null;
263
                                        return null;
264
                                }
264
                                }
265
                        }
265
                        }
266
                } else if (targetType.isEnum()) {
266
                } else if (targetType.isEnum()) {
267
267
268
                        try {
268
                        try {
269
                               
269
                               
270
                                Class k = (Class) targetType; // not sure how to avoid this raw type!
270
                                Class k = (Class) targetType; // not sure how to avoid this raw type!
271
271
272
                                newValue = Enum.valueOf(k, value);
272
                                newValue = Enum.valueOf(k, value);
273
273
274
                        } catch (Exception e) {
274
                        } catch (Exception e) {
275
275
276
                                return null;
276
                                return null;
277
                        }
277
                        }
278
278
279
                }
279
                }
280
280
281
                return newValue;
281
                return newValue;
282
282
283
        }
283
        }
284
284
285
        public static Object shouldConvertToNull(Object value, Class<? extends Object> targetType) {
285
        public static Object shouldConvertToNull(Object value, Class<? extends Object> targetType) {
286
286
287
                if (targetType.equals(String.class)) {
287
                if (targetType.equals(String.class)) {
288
288
289
                        return value;
289
                        return value;
290
290
291
                } else if (targetType.isPrimitive()) {
291
                } else if (targetType.isPrimitive()) {
292
292
293
                        return value;
293
                        return value;
294
                }
294
                }
295
295
296
                return null;
296
                return null;
297
        }
297
        }
298
298
299
        public static Class<? extends Object> getPrimitiveFrom(Object w) {
299
        public static Class<? extends Object> getPrimitiveFrom(Object w) {
300
                if (w instanceof Boolean) {
300
                if (w instanceof Boolean) {
301
                        return Boolean.TYPE;
301
                        return Boolean.TYPE;
302
                } else if (w instanceof Byte) {
302
                } else if (w instanceof Byte) {
303
                        return Byte.TYPE;
303
                        return Byte.TYPE;
304
                } else if (w instanceof Short) {
304
                } else if (w instanceof Short) {
305
                        return Short.TYPE;
305
                        return Short.TYPE;
306
                } else if (w instanceof Character) {
306
                } else if (w instanceof Character) {
307
                        return Character.TYPE;
307
                        return Character.TYPE;
308
                } else if (w instanceof Integer) {
308
                } else if (w instanceof Integer) {
309
                        return Integer.TYPE;
309
                        return Integer.TYPE;
310
                } else if (w instanceof Long) {
310
                } else if (w instanceof Long) {
311
                        return Long.TYPE;
311
                        return Long.TYPE;
312
                } else if (w instanceof Float) {
312
                } else if (w instanceof Float) {
313
                        return Float.TYPE;
313
                        return Float.TYPE;
314
                } else if (w instanceof Double) {
314
                } else if (w instanceof Double) {
315
                        return Double.TYPE;
315
                        return Double.TYPE;
316
                }
316
                }
317
                return null;
317
                return null;
318
        }
318
        }
319
319
320
        public static Class<? extends Object> getPrimitiveFrom(Class<? extends Object> klass) {
320
        public static Class<? extends Object> getPrimitiveFrom(Class<? extends Object> klass) {
321
321
322
                String s = klass.getName();
322
                String s = klass.getName();
323
323
324
                if (s.equals("java.lang.Boolean")) {
324
                if (s.equals("java.lang.Boolean")) {
325
                        return Boolean.TYPE;
325
                        return Boolean.TYPE;
326
                } else if (s.equals("java.lang.Byte")) {
326
                } else if (s.equals("java.lang.Byte")) {
327
                        return Byte.TYPE;
327
                        return Byte.TYPE;
328
                } else if (s.equals("java.lang.Short")) {
328
                } else if (s.equals("java.lang.Short")) {
329
                        return Short.TYPE;
329
                        return Short.TYPE;
330
                } else if (s.equals("java.lang.Character")) {
330
                } else if (s.equals("java.lang.Character")) {
331
                        return Character.TYPE;
331
                        return Character.TYPE;
332
                } else if (s.equals("java.lang.Integer")) {
332
                } else if (s.equals("java.lang.Integer")) {
333
                        return Integer.TYPE;
333
                        return Integer.TYPE;
334
                } else if (s.equals("java.lang.Long")) {
334
                } else if (s.equals("java.lang.Long")) {
335
                        return Long.TYPE;
335
                        return Long.TYPE;
336
                } else if (s.equals("java.lang.Float")) {
336
                } else if (s.equals("java.lang.Float")) {
337
                        return Float.TYPE;
337
                        return Float.TYPE;
338
                } else if (s.equals("java.lang.Double")) {
338
                } else if (s.equals("java.lang.Double")) {
339
                        return Double.TYPE;
339
                        return Double.TYPE;
340
                }
340
                }
341
                return null;
341
                return null;
342
        }
342
        }
343
343
344
        public static Field getField(Object target, String name) {
344
        public static Field getField(Object target, String name) {
345
                return getField(target.getClass(), name);
345
                return getField(target.getClass(), name);
346
        }
346
        }
347
347
348
        public static Field getField(Class<? extends Object> target, String name) {
348
        public static Field getField(Class<? extends Object> target, String name) {
349
                Field fields[] = target.getDeclaredFields();
349
                Field fields[] = target.getDeclaredFields();
350
                for (int i = 0; i < fields.length; i++) {
350
                for (int i = 0; i < fields.length; i++) {
351
                        if (name.equals(fields[i].getName())) {
351
                        if (name.equals(fields[i].getName())) {
352
                                return fields[i];
352
                                return fields[i];
353
                        }
353
                        }
354
                }
354
                }
355
                return null;
355
                return null;
356
        }
356
        }
357
357
358
        public static Method findMethodToGet(Class<? extends Object> target, String name) {
358
        public static Method findMethodToGet(Class<? extends Object> target, String name) {
359
359
360
                StringBuffer sb = new StringBuffer(128);
360
                StringBuffer sb = new StringBuffer(128);
361
361
362
                sb.append("get").append(name.substring(0, 1).toUpperCase());
362
                sb.append("get").append(name.substring(0, 1).toUpperCase());
363
363
364
                if (name.length() > 1) sb.append(name.substring(1));
364
                if (name.length() > 1) sb.append(name.substring(1));
365
365
366
                try {
366
                try {
367
367
368
                        return target.getMethod(sb.toString(), (Class[]) null);
368
                        return target.getMethod(sb.toString(), (Class[]) null);
369
369
370
                } catch (Exception e) {
370
                } catch (Exception e) {
371
371
372
                }
372
                }
373
373
374
                sb.setLength(0);
374
                sb.setLength(0);
375
375
376
                sb.append("is").append(name.substring(0, 1).toUpperCase());
376
                sb.append("is").append(name.substring(0, 1).toUpperCase());
377
377
378
                if (name.length() > 1) {
378
                if (name.length() > 1) {
379
379
380
                        sb.append(name.substring(1));
380
                        sb.append(name.substring(1));
381
                }
381
                }
382
382
383
                try {
383
                try {
384
384
385
                        return target.getMethod(sb.toString(), (Class[]) null);
385
                        return target.getMethod(sb.toString(), (Class[]) null);
386
386
387
                } catch (Exception e) {
387
                } catch (Exception e) {
388
388
389
                }
389
                }
390
390
391
                return null;
391
                return null;
392
        }
392
        }
393
393
394
        public static Method findMethodToInject(Class<? extends Object> target, String name, Class<? extends Object> source) {
394
        public static Method findMethodToInject(Class<? extends Object> target, String name, Class<? extends Object> source) {
395
395
396
                StringBuffer sb = new StringBuffer(128);
396
                StringBuffer sb = new StringBuffer(128);
397
397
398
                sb.append("set").append(name.substring(0, 1).toUpperCase());
398
                sb.append("set").append(name.substring(0, 1).toUpperCase());
399
399
400
                if (name.length() > 1) sb.append(name.substring(1));
400
                if (name.length() > 1) sb.append(name.substring(1));
401
401
402
                String methodName = sb.toString();
402
                String methodName = sb.toString();
403
403
404
                Method m = null;
404
                Method m = null;
405
405
406
                try {
406
                try {
407
407
408
                        m = FindMethod.getMethod(target, methodName, new Class[] { source });
408
                        m = FindMethod.getMethod(target, methodName, new Class[] { source });
409
409
410
                } catch (Exception e) {
410
                } catch (Exception e) {
411
                }
411
                }
412
412
413
                if (m == null) {
413
                if (m == null) {
414
414
415
                        Class<? extends Object> primitive = getPrimitiveFrom(source);
415
                        Class<? extends Object> primitive = getPrimitiveFrom(source);
416
416
417
                        if (primitive != null) {
417
                        if (primitive != null) {
418
418
419
                                try {
419
                                try {
420
420
421
                                        m = target.getMethod(methodName, new Class[] { primitive });
421
                                        m = target.getMethod(methodName, new Class[] { primitive });
422
422
423
                                } catch (Exception e) {
423
                                } catch (Exception e) {
424
                                }
424
                                }
425
425
426
                        }
426
                        }
427
                }
427
                }
428
428
429
                if (m != null) {
429
                if (m != null) {
430
                        m.setAccessible(true);
430
                        m.setAccessible(true);
431
                }
431
                }
432
432
433
                return m;
433
                return m;
434
434
435
        }
435
        }
436
436
437
        public static Field findFieldToInject(Class<? extends Object> target, String name, Class<? extends Object> source) {
437
        public static Field findFieldToInject(Class<? extends Object> target, String name, Class<? extends Object> source) {
438
438
439
                Field f = getField(target, name);
439
                Field f = getField(target, name);
440
440
441
                if (f != null) {
441
                if (f != null) {
442
442
443
                        Class<?> type = f.getType();
443
                        Class<?> type = f.getType();
444
444
445
                        if (type.isAssignableFrom(source) || checkPrimitives(type, source)) {
445
                        if (type.isAssignableFrom(source) || checkPrimitives(type, source)) {
446
446
447
                                f.setAccessible(true);
447
                                f.setAccessible(true);
448
448
449
                                return f;
449
                                return f;
450
                        }
450
                        }
451
451
452
                }
452
                }
453
453
454
                return null;
454
                return null;
455
        }
455
        }
456
456
457
        private static final boolean isBlank(Object value) {
457
        private static final boolean isBlank(Object value) {
458
458
459
                if (value != null && value instanceof String) {
459
                if (value != null && value instanceof String) {
460
460
461
                        String s = ((String) value).trim();
461
                        String s = ((String) value).trim();
462
462
463
                        if (s.length() == 0) return true;
463
                        if (s.length() == 0) return true;
464
                }
464
                }
465
465
466
                return false;
466
                return false;
467
        }
467
        }
468
468
469
        public static boolean inject(Method m, Object target, Object value, boolean tryToConvert, boolean tryingToConvertBoolean) throws Exception {
469
        public static boolean inject(Method m, Object target, Object value, boolean tryToConvert, boolean tryingToConvertBoolean) throws Exception {
470
470
471
                Class<?> type = m.getParameterTypes()[0];
471
                Class<?> type = m.getParameterTypes()[0];
472
472
473
                if (tryingToConvertBoolean) {
473
                if (tryingToConvertBoolean) {
474
474
475
                        if (value == null && (type.equals(Boolean.class) || type.equals(boolean.class))) {
475
                        if (value == null && (type.equals(Boolean.class) || type.equals(boolean.class))) {
476
476
477
                                value = Boolean.FALSE;
477
                                value = Boolean.FALSE;
478
478
479
                        } else {
479
                        } else {
480
480
481
                                // if trying to convert boolean, convert or don't do anything...
481
                                // if trying to convert boolean, convert or don't do anything...
482
482
483
                                return false;
483
                                return false;
484
484
485
                        }
485
                        }
486
                }
486
                }
487
487
488
                if (value == null
488
                if (value == null
489
                        || (type.isAssignableFrom(value.getClass()) || checkPrimitives(type, value.getClass()) || (tryToConvert && ((isBlank(value) && (value = shouldConvertToNull(value,
489
                        || (type.isAssignableFrom(value.getClass()) || checkPrimitives(type, value.getClass()) || (tryToConvert && ((isBlank(value) && (value = shouldConvertToNull(value,
490
                                type)) == null) || (value = tryToConvert(value, type)) != null)))) {
490
                                type)) == null) || (value = tryToConvert(value, type)) != null)))) {
491
491
492
                        try {
492
                        try {
493
493
494
                                m.invoke(target, new Object[] { value });
494
                                m.invoke(target, new Object[] { value });
495
495
496
                                return true;
496
                                return true;
497
497
498
                        } catch (Exception e) {
498
                        } catch (Exception e) {
499
499
500
                                System.err.println("Error injecting by method: " + value + " in " + target + " thru " + m);
500
                                System.err.println("Error injecting by method: " + value + " in " + target + " thru " + m);
501
501
502
                                e.printStackTrace();
502
                                e.printStackTrace();
503
503
504
                                throw e;
504
                                throw e;
505
505
506
                        }
506
                        }
507
                }
507
                }
508
508
509
                return false;
509
                return false;
510
510
511
        }
511
        }
512
512
513
        public static boolean hasDefaultConstructor(Class<? extends Object> klass) {
513
        public static boolean hasDefaultConstructor(Class<? extends Object> klass) {
514
514
515
                try {
515
                try {
516
516
517
                        return klass.getConstructor((Class[]) null) != null;
517
                        return klass.getConstructor((Class[]) null) != null;
518
518
519
                } catch (Exception e) {
519
                } catch (Exception e) {
520
520
521
                        return false;
521
                        return false;
522
                }
522
                }
523
        }
523
        }
524
524
525
        /**
525
        /**
526
         * Extract the value of a property of a bean!
526
         * Extract the value of a property of a bean!
527
         *
527
         *
528
         * @param bean
528
         * @param bean
529
         *            the target bean
529
         *            the target bean
530
         * @param nameProperty
530
         * @param nameProperty
531
         *            the property name
531
         *            the property name
532
         * @return they value as String. The method toString is always called to every property!
532
         * @return they value as String. The method toString is always called to every property!
533
         * @throws Exception
533
         * @throws Exception
534
         */
534
         */
535
        public static String getProperty(Object bean, String nameProperty) throws Exception {
535
        public static String getProperty(Object bean, String nameProperty) throws Exception {
536
536
537
                if (nameProperty == null || nameProperty.equals("")) return null;
537
                if (nameProperty == null || nameProperty.equals("")) return null;
538
538
539
                String methodName = getter(nameProperty);
539
                String methodName = getter(nameProperty);
540
540
541
                Class<? extends Object> clazz = bean.getClass();
541
                Class<? extends Object> clazz = bean.getClass();
542
                Method[] methods = clazz.getMethods();
542
                Method[] methods = clazz.getMethods();
543
                for (Method method : methods) {
543
                for (Method method : methods) {
544
                        if (method.getName().equals(methodName) && method.getParameterTypes().length == 0) {
544
                        if (method.getName().equals(methodName) && method.getParameterTypes().length == 0) {
545
                                Object value = method.invoke(bean, (Object[]) null);
545
                                Object value = method.invoke(bean, (Object[]) null);
546
                                if (value == null) return null;
546
                                if (value == null) return null;
547
                                return value.toString();
547
                                return value.toString();
548
                        }
548
                        }
549
                }
549
                }
550
550
551
                Field[] fields = clazz.getDeclaredFields();
551
                Field[] fields = clazz.getDeclaredFields();
552
                for (Field field : fields) {
552
                for (Field field : fields) {
553
                        field.setAccessible(true);
553
                        field.setAccessible(true);
554
                        if (field.getName().equals(nameProperty)) {
554
                        if (field.getName().equals(nameProperty)) {
555
                                Object value = field.get(bean);
555
                                Object value = field.get(bean);
556
                                if (value == null) return null;
556
                                if (value == null) return null;
557
                                return value.toString();
557
                                return value.toString();
558
                        }
558
                        }
559
                }
559
                }
560
560
561
                return null;
561
                return null;
562
        }
562
        }
563
563
564
        private static String getter(String name) {
564
        private static String getter(String name) {
565
                StringBuilder sb = new StringBuilder(name.length() + 3);
565
                StringBuilder sb = new StringBuilder(name.length() + 3);
566
566
567
                sb.append("get").append(name.substring(0, 1).toUpperCase());
567
                sb.append("get").append(name.substring(0, 1).toUpperCase());
568
568
569
                if (name.length() > 1) sb.append(name.substring(1));
569
                if (name.length() > 1) sb.append(name.substring(1));
570
                return sb.toString();
570
                return sb.toString();
571
        }
571
        }
572
572
573
        public static void beanToMap(Object bean, Map<String, String> map) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
573
        public static void beanToMap(Object bean, Map<String, String> map) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
574
                if (bean != null) {
574
                if (bean != null) {
575
575
576
                        for (Method method : bean.getClass().getMethods()) {
576
                        for (Method method : bean.getClass().getMethods()) {
577
                                String name = method.getName();
577
                                String name = method.getName();
578
578
579
                                if (name.length() > 3 && name.startsWith("get") && !name.equals("getClass") && method.getParameterTypes().length == 0) {
579
                                if (name.length() > 3 && name.startsWith("get") && !name.equals("getClass") && method.getParameterTypes().length == 0) {
580
580
581
                                        method.setAccessible(true);
581
                                        method.setAccessible(true);
582
                                        Object value = method.invoke(bean, new Object[0]);
582
                                        Object value = method.invoke(bean, new Object[0]);
583
                                        map.put(name, value.toString());
583
                                        map.put(name, value.toString());
584
                                }
584
                                }
585
                        }
585
                        }
586
                }
586
                }
587
        }
587
        }
588
       
588
       
589
        public static interface Provider {
589
        public static interface Provider {
590
               
590
               
591
                public Object get(String key);
591
                public Object get(String key);
592
               
592
               
593
                public boolean contains(String key);
-
 
-
 
593
                public boolean hasValue(String key);
594
        }
594
        }
595
595
596
        public static void getObject(Object target, Provider provider, boolean tryField, String prefix, boolean tryToConvert, boolean convertBoolean, boolean allowRecursion)
596
        public static void getObject(Object target, Provider provider, boolean tryField, String prefix, boolean tryToConvert, boolean convertBoolean, boolean allowRecursion)
597
                throws Exception {
597
                throws Exception {
598
598
599
                Class<? extends Object> targetClass = target.getClass();
599
                Class<? extends Object> targetClass = target.getClass();
600
600
601
                Map<String, Object> setters, fields;
601
                Map<String, Object> setters, fields;
602
602
603
                // see if we have these in cache...
603
                // see if we have these in cache...
604
604
605
                synchronized (settersMaps) {
605
                synchronized (settersMaps) {
606
606
607
                        setters = settersMaps.get(targetClass);
607
                        setters = settersMaps.get(targetClass);
608
608
609
                        fields = fieldsMaps.get(targetClass);
609
                        fields = fieldsMaps.get(targetClass);
610
610
611
                }
611
                }
612
612
613
                // if not in cache, prepare maps for injection...
613
                // if not in cache, prepare maps for injection...
614
614
615
                if (setters == null) {
615
                if (setters == null) {
616
616
617
                        setters = new HashMap<String, Object>();
617
                        setters = new HashMap<String, Object>();
618
618
619
                        fields = null;
619
                        fields = null;
620
620
621
                        if (tryField) {
621
                        if (tryField) {
622
622
623
                                fields = new HashMap<String, Object>();
623
                                fields = new HashMap<String, Object>();
624
624
625
                        }
625
                        }
626
626
627
                        prepareForInjection(targetClass, setters, fields);
627
                        prepareForInjection(targetClass, setters, fields);
628
628
629
                        synchronized (settersMaps) {
629
                        synchronized (settersMaps) {
630
630
631
                                settersMaps.put(targetClass, setters);
631
                                settersMaps.put(targetClass, setters);
632
632
633
                                fieldsMaps.put(targetClass, fields);
633
                                fieldsMaps.put(targetClass, fields);
634
634
635
                        }
635
                        }
636
                }
636
                }
637
637
638
                Iterator<String> iter = setters.keySet().iterator();
638
                Iterator<String> iter = setters.keySet().iterator();
639
639
640
                while (iter.hasNext()) {
640
                while (iter.hasNext()) {
641
641
642
                        String var = iter.next();
642
                        String var = iter.next();
643
643
644
                        boolean hasValue = provider.contains(var);
-
 
-
 
644
                        boolean hasValue = provider.hasValue(var);
645
645
646
                        Object value = provider.get(var);
646
                        Object value = provider.get(var);
647
647
648
                        boolean tryingToConvertBoolean = false;
648
                        boolean tryingToConvertBoolean = false;
649
649
650
                        if (value == null && !hasValue) {
650
                        if (value == null && !hasValue) {
651
651
652
                                if (!convertBoolean) {
652
                                if (!convertBoolean) {
653
653
654
                                        continue;
654
                                        continue;
655
655
656
                                } else {
656
                                } else {
657
657
658
                                        tryingToConvertBoolean = true;
658
                                        tryingToConvertBoolean = true;
659
                                }
659
                                }
660
660
661
                        }
661
                        }
662
662
663
                        // if (value == null) continue;
663
                        // if (value == null) continue;
664
664
665
                        Object obj = setters.get(var);
665
                        Object obj = setters.get(var);
666
666
667
                        // we may have a list of overloaded methods...
667
                        // we may have a list of overloaded methods...
668
668
669
                        List<Method> list = null;
669
                        List<Method> list = null;
670
670
671
                        Method m = null;
671
                        Method m = null;
672
672
673
                        if (obj instanceof List) {
673
                        if (obj instanceof List) {
674
674
675
                                list = (List<Method>) obj;
675
                                list = (List<Method>) obj;
676
676
677
                        } else {
677
                        } else {
678
678
679
                                m = (Method) setters.get(var);
679
                                m = (Method) setters.get(var);
680
680
681
                        }
681
                        }
682
682
683
                        if (m != null) {
683
                        if (m != null) {
684
684
685
                                if (!inject(m, target, value, tryToConvert, tryingToConvertBoolean) && allowRecursion) {
685
                                if (!inject(m, target, value, tryToConvert, tryingToConvertBoolean) && allowRecursion) {
686
686
687
                                        // i did not inject... how about a VO object for this
687
                                        // i did not inject... how about a VO object for this
688
                                        // setter?
688
                                        // setter?
689
689
690
                                        Class<?> type = m.getParameterTypes()[0];
690
                                        Class<?> type = m.getParameterTypes()[0];
691
691
692
                                        if (!type.getName().startsWith("java.") && !type.isPrimitive() && hasDefaultConstructor(type)) {
692
                                        if (!type.getName().startsWith("java.") && !type.isPrimitive() && hasDefaultConstructor(type)) {
693
693
694
                                                Object param = type.newInstance();
694
                                                Object param = type.newInstance();
695
695
696
                                                InjectionUtils.getObject(param, provider, true, prefix, true, true, false); // no
696
                                                InjectionUtils.getObject(param, provider, true, prefix, true, true, false); // no
697
                                                // recursion...
697
                                                // recursion...
698
698
699
                                                inject(m, target, param, false, false);
699
                                                inject(m, target, param, false, false);
700
                                        }
700
                                        }
701
                                }
701
                                }
702
702
703
                        } else {
703
                        } else {
704
704
705
                                Iterator<Method> it = list.iterator();
705
                                Iterator<Method> it = list.iterator();
706
706
707
                                boolean injected = false;
707
                                boolean injected = false;
708
708
709
                                while (it.hasNext()) {
709
                                while (it.hasNext()) {
710
710
711
                                        m = it.next();
711
                                        m = it.next();
712
712
713
                                        if (inject(m, target, value, tryToConvert, tryingToConvertBoolean)) {
713
                                        if (inject(m, target, value, tryToConvert, tryingToConvertBoolean)) {
714
714
715
                                                injected = true;
715
                                                injected = true;
716
716
717
                                                break;
717
                                                break;
718
                                        }
718
                                        }
719
                                }
719
                                }
720
720
721
                                if (!injected && allowRecursion) {
721
                                if (!injected && allowRecursion) {
722
722
723
                                        // i could not inject anything... how about a VO object for
723
                                        // i could not inject anything... how about a VO object for
724
                                        // this setter...
724
                                        // this setter...
725
725
726
                                        it = list.iterator();
726
                                        it = list.iterator();
727
727
728
                                        while (it.hasNext()) {
728
                                        while (it.hasNext()) {
729
729
730
                                                m = (Method) it.next();
730
                                                m = (Method) it.next();
731
731
732
                                                Class<?> type = m.getParameterTypes()[0];
732
                                                Class<?> type = m.getParameterTypes()[0];
733
733
734
                                                if (!type.getName().startsWith("java.") && !type.isPrimitive() && hasDefaultConstructor(type)) {
734
                                                if (!type.getName().startsWith("java.") && !type.isPrimitive() && hasDefaultConstructor(type)) {
735
735
736
                                                        Object param = type.newInstance();
736
                                                        Object param = type.newInstance();
737
737
738
                                                        InjectionUtils.getObject(param, provider, true, prefix, true, true, false); // no
738
                                                        InjectionUtils.getObject(param, provider, true, prefix, true, true, false); // no
739
                                                        // recursion...
739
                                                        // recursion...
740
740
741
                                                        if (inject(m, target, param, false, false)) {
741
                                                        if (inject(m, target, param, false, false)) {
742
742
743
                                                                break; // done...
743
                                                                break; // done...
744
                                                        }
744
                                                        }
745
                                                }
745
                                                }
746
                                        }
746
                                        }
747
                                }
747
                                }
748
                        }
748
                        }
749
                }
749
                }
750
750
751
                if (fields != null) {
751
                if (fields != null) {
752
752
753
                        iter = fields.keySet().iterator();
753
                        iter = fields.keySet().iterator();
754
754
755
                        while (iter.hasNext()) {
755
                        while (iter.hasNext()) {
756
756
757
                                String var = iter.next();
757
                                String var = iter.next();
758
758
759
                                boolean hasValue = provider.contains(var);
-
 
-
 
759
                                boolean hasValue = provider.hasValue(var);
760
760
761
                                Object value = provider.get(var);
761
                                Object value = provider.get(var);
762
762
763
                                Field f = (Field) fields.get(var);
763
                                Field f = (Field) fields.get(var);
764
764
765
                                Class<?> type = f.getType();
765
                                Class<?> type = f.getType();
766
766
767
                                // If there is no value in the action input, assume false for
767
                                // If there is no value in the action input, assume false for
768
                                // booleans...
768
                                // booleans...
769
                                // (checkboxes and radio buttons are not send when not
769
                                // (checkboxes and radio buttons are not send when not
770
                                // marked...)
770
                                // marked...)
771
771
772
                                if (convertBoolean && value == null && !hasValue) {
772
                                if (convertBoolean && value == null && !hasValue) {
773
773
774
                                        if (type.equals(Boolean.class) || type.equals(boolean.class)) {
774
                                        if (type.equals(Boolean.class) || type.equals(boolean.class)) {
775
775
776
                                                value = Boolean.FALSE;
776
                                                value = Boolean.FALSE;
777
                                        }
777
                                        }
778
778
779
                                }
779
                                }
780
780
781
                                if (value == null && !hasValue) continue;
781
                                if (value == null && !hasValue) continue;
782
782
783
                                // if (value == null) continue;
783
                                // if (value == null) continue;
784
784
785
                                if (value == null
785
                                if (value == null
786
                                        || (type.isAssignableFrom(value.getClass()) || checkPrimitives(type, value.getClass()) || (tryToConvert && ((isBlank(value) && (value = shouldConvertToNull(
786
                                        || (type.isAssignableFrom(value.getClass()) || checkPrimitives(type, value.getClass()) || (tryToConvert && ((isBlank(value) && (value = shouldConvertToNull(
787
                                                value, type)) == null) || (value = tryToConvert(value, type)) != null)))) {
787
                                                value, type)) == null) || (value = tryToConvert(value, type)) != null)))) {
788
788
789
                                        try {
789
                                        try {
790
790
791
                                                f.set(target, value);
791
                                                f.set(target, value);
792
792
793
                                        } catch (Exception e) {
793
                                        } catch (Exception e) {
794
794
795
                                                System.err.println("Error injecting by field: " + value + " in " + target);
795
                                                System.err.println("Error injecting by field: " + value + " in " + target);
796
796
797
                                                e.printStackTrace();
797
                                                e.printStackTrace();
798
798
799
                                                throw e;
799
                                                throw e;
800
800
801
                                        }
801
                                        }
802
                                }
802
                                }
803
                        }
803
                        }
804
                }
804
                }
805
        }
805
        }
806
}
806
}
807
 
807