001 /**
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017 package org.apache.camel.util;
018
019 import java.beans.PropertyEditor;
020 import java.beans.PropertyEditorManager;
021 import java.lang.reflect.Field;
022 import java.lang.reflect.InvocationTargetException;
023 import java.lang.reflect.Method;
024 import java.lang.reflect.Modifier;
025 import java.net.URI;
026 import java.net.URISyntaxException;
027 import java.util.Arrays;
028 import java.util.HashMap;
029 import java.util.Iterator;
030 import java.util.LinkedHashMap;
031 import java.util.LinkedHashSet;
032 import java.util.Map;
033 import java.util.Set;
034
035 import org.apache.camel.NoTypeConversionAvailableException;
036 import org.apache.camel.TypeConverter;
037 import org.apache.commons.logging.Log;
038 import org.apache.commons.logging.LogFactory;
039
040 /**
041 * Helper for introspections of beans.
042 */
043 public final class IntrospectionSupport {
044
045 private static final transient Log LOG = LogFactory.getLog(IntrospectionSupport.class);
046
047 /**
048 * Utility classes should not have a public constructor.
049 */
050 private IntrospectionSupport() {
051 }
052
053 /**
054 * Copies the properties from the source to the target
055 * @param source source object
056 * @param target target object
057 * @param optionPrefix optional option preifx (can be null)
058 * @return true if properties is copied, false if something went wrong
059 */
060 public static boolean copyProperties(Object source, Object target, String optionPrefix) {
061 Map properties = new LinkedHashMap();
062 if (!getProperties(source, properties, optionPrefix)) {
063 return false;
064 }
065 try {
066 return setProperties(target, properties, optionPrefix);
067 } catch (Exception e) {
068 LOG.debug("Can not copy properties to target: " + target, e);
069 return false;
070 }
071 }
072
073 @SuppressWarnings("unchecked")
074 public static boolean getProperties(Object target, Map properties, String optionPrefix) {
075 ObjectHelper.notNull(target, "target");
076 ObjectHelper.notNull(properties, "properties");
077 boolean rc = false;
078 if (optionPrefix == null) {
079 optionPrefix = "";
080 }
081
082 Class clazz = target.getClass();
083 Method[] methods = clazz.getMethods();
084 for (Method method : methods) {
085 String name = method.getName();
086 Class type = method.getReturnType();
087 Class params[] = method.getParameterTypes();
088 if (name.startsWith("get") && params.length == 0 && type != null && isSettableType(type)) {
089 try {
090 Object value = method.invoke(target);
091 if (value == null) {
092 continue;
093 }
094
095 String strValue = convertToString(value, type);
096 if (strValue == null) {
097 continue;
098 }
099
100 name = name.substring(3, 4).toLowerCase() + name.substring(4);
101 properties.put(optionPrefix + name, strValue);
102 rc = true;
103 } catch (Exception ignore) {
104 // ignore
105 }
106 }
107 }
108
109 return rc;
110 }
111
112 public static boolean hasProperties(Map properties, String optionPrefix) {
113 ObjectHelper.notNull(properties, "properties");
114
115 if (ObjectHelper.isNotEmpty(optionPrefix)) {
116 for (Object o : properties.keySet()) {
117 String name = (String) o;
118 if (name.startsWith(optionPrefix)) {
119 return true;
120 }
121 }
122 // no parameters with this prefix
123 return false;
124 } else {
125 return !properties.isEmpty();
126 }
127 }
128
129 public static Object getProperty(Object target, String property) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
130 ObjectHelper.notNull(target, "target");
131 ObjectHelper.notNull(property, "property");
132
133 property = property.substring(0, 1).toUpperCase() + property.substring(1);
134
135 Class clazz = target.getClass();
136 Method method = getPropertyGetter(clazz, property);
137 return method.invoke(target);
138 }
139
140 public static Method getPropertyGetter(Class type, String propertyName) throws NoSuchMethodException {
141 return type.getMethod("get" + ObjectHelper.capitalize(propertyName));
142 }
143
144 @SuppressWarnings("unchecked")
145 public static boolean setProperties(Object target, Map properties, String optionPrefix) throws Exception {
146 ObjectHelper.notNull(target, "target");
147 ObjectHelper.notNull(properties, "properties");
148 boolean rc = false;
149
150 for (Iterator<Map.Entry> it = properties.entrySet().iterator(); it.hasNext();) {
151 Map.Entry entry = it.next();
152 String name = entry.getKey().toString();
153 if (name.startsWith(optionPrefix)) {
154 Object value = properties.get(name);
155 name = name.substring(optionPrefix.length());
156 if (setProperty(target, name, value)) {
157 it.remove();
158 rc = true;
159 }
160 }
161 }
162
163 return rc;
164 }
165
166 @SuppressWarnings("unchecked")
167 public static Map extractProperties(Map properties, String optionPrefix) {
168 ObjectHelper.notNull(properties, "properties");
169
170 HashMap rc = new LinkedHashMap(properties.size());
171
172 for (Iterator<Map.Entry> it = properties.entrySet().iterator(); it.hasNext();) {
173 Map.Entry entry = it.next();
174 String name = entry.getKey().toString();
175 if (name.startsWith(optionPrefix)) {
176 Object value = properties.get(name);
177 name = name.substring(optionPrefix.length());
178 rc.put(name, value);
179 it.remove();
180 }
181 }
182
183 return rc;
184 }
185
186 public static boolean setProperties(TypeConverter typeConverter, Object target, Map properties) throws Exception {
187 ObjectHelper.notNull(target, "target");
188 ObjectHelper.notNull(properties, "properties");
189 boolean rc = false;
190
191 for (Iterator iter = properties.entrySet().iterator(); iter.hasNext();) {
192 Map.Entry entry = (Map.Entry)iter.next();
193 if (setProperty(typeConverter, target, (String)entry.getKey(), entry.getValue())) {
194 iter.remove();
195 rc = true;
196 }
197 }
198
199 return rc;
200 }
201
202 public static boolean setProperties(Object target, Map props) throws Exception {
203 return setProperties(null, target, props);
204 }
205
206 public static boolean setProperty(TypeConverter typeConverter, Object target, String name, Object value) throws Exception {
207 try {
208 Class clazz = target.getClass();
209 // find candidates of setter methods as there can be overloaded setters
210 Set<Method> setters = findSetterMethods(typeConverter, clazz, name, value);
211 if (setters.isEmpty()) {
212 return false;
213 }
214
215 // loop and execute the best setter method
216 Exception typeConvertionFailed = null;
217 for (Method setter : setters) {
218 // If the type is null or it matches the needed type, just use the value directly
219 if (value == null || setter.getParameterTypes()[0].isAssignableFrom(value.getClass())) {
220 setter.invoke(target, value);
221 return true;
222 } else {
223 // We need to convert it
224 try {
225 // ignore exceptions as there could be another setter method where we could type convert successfully
226 Object convertedValue = convert(typeConverter, setter.getParameterTypes()[0], value);
227 setter.invoke(target, convertedValue);
228 return true;
229 } catch (NoTypeConversionAvailableException e) {
230 typeConvertionFailed = e;
231 } catch (IllegalArgumentException e) {
232 typeConvertionFailed = e;
233 }
234 if (LOG.isTraceEnabled()) {
235 LOG.trace("Setter \"" + setter + "\" with parameter type \""
236 + setter.getParameterTypes()[0] + "\" could not be used for type conversions of " + value);
237 }
238 }
239 }
240 // we did not find a setter method to use, and if we did try to use a type converter then throw
241 // this kind of exception as the caused by will hint this error
242 if (typeConvertionFailed != null) {
243 throw new IllegalArgumentException("Could not find a suitable setter for property: " + name
244 + " as there isn't a setter method with same type: " + value.getClass().getCanonicalName()
245 + " nor type conversion possible: " + typeConvertionFailed.getMessage());
246 } else {
247 return false;
248 }
249 } catch (InvocationTargetException e) {
250 // lets unwrap the exception
251 Throwable throwable = e.getCause();
252 if (throwable instanceof Exception) {
253 Exception exception = (Exception)throwable;
254 throw exception;
255 } else {
256 Error error = (Error)throwable;
257 throw error;
258 }
259 }
260 }
261
262 public static boolean setProperty(Object target, String name, Object value) throws Exception {
263 return setProperty(null, target, name, value);
264 }
265
266 @SuppressWarnings("unchecked")
267 private static Object convert(TypeConverter typeConverter, Class type, Object value)
268 throws URISyntaxException, NoTypeConversionAvailableException {
269 if (typeConverter != null) {
270 return typeConverter.mandatoryConvertTo(type, value);
271 }
272 PropertyEditor editor = PropertyEditorManager.findEditor(type);
273 if (editor != null) {
274 editor.setAsText(value.toString());
275 return editor.getValue();
276 }
277 if (type == URI.class) {
278 return new URI(value.toString());
279 }
280 return null;
281 }
282
283 private static String convertToString(Object value, Class type) throws URISyntaxException {
284 PropertyEditor editor = PropertyEditorManager.findEditor(type);
285 if (editor != null) {
286 editor.setValue(value);
287 return editor.getAsText();
288 }
289 if (type == URI.class) {
290 return value.toString();
291 }
292 return null;
293 }
294
295 private static Set<Method> findSetterMethods(TypeConverter typeConverter, Class clazz, String name, Object value) {
296 Set<Method> candidates = new LinkedHashSet<Method>();
297
298 // Build the method name.
299 name = "set" + ObjectHelper.capitalize(name);
300 while (clazz != Object.class) {
301 // Since Object.class.isInstance all the objects,
302 // here we just make sure it will be add to the bottom of the set.
303 Method objectSetMethod = null;
304 Method[] methods = clazz.getMethods();
305 for (Method method : methods) {
306 Class params[] = method.getParameterTypes();
307 if (method.getName().equals(name) && params.length == 1) {
308 Class paramType = params[0];
309 if (paramType.equals(Object.class)) {
310 objectSetMethod = method;
311 } else if (typeConverter != null || isSettableType(paramType) || paramType.isInstance(value)) {
312 candidates.add(method);
313 }
314 }
315 }
316 if (objectSetMethod != null) {
317 candidates.add(objectSetMethod);
318 }
319 clazz = clazz.getSuperclass();
320 }
321
322 if (candidates.isEmpty()) {
323 return candidates;
324 } else if (candidates.size() == 1) {
325 // only one
326 return candidates;
327 } else {
328 // find the best match if possible
329 if (LOG.isTraceEnabled()) {
330 LOG.trace("Found " + candidates.size() + " suitable setter methods for setting " + name);
331 }
332 // prefer to use the one with the same instance if any exists
333 for (Method method : candidates) {
334 if (method.getParameterTypes()[0].isInstance(value)) {
335 if (LOG.isTraceEnabled()) {
336 LOG.trace("Method " + method + " is the best candidate as it has parameter with same instance type");
337 }
338 // retain only this method in the answer
339 candidates.clear();
340 candidates.add(method);
341 return candidates;
342 }
343 }
344 // fallback to return what we have found as candidates so far
345 return candidates;
346 }
347 }
348
349 private static boolean isSettableType(Class clazz) {
350 if (PropertyEditorManager.findEditor(clazz) != null) {
351 return true;
352 }
353 if (clazz == URI.class) {
354 return true;
355 }
356 if (clazz == Boolean.class) {
357 return true;
358 }
359 return false;
360 }
361
362 public static String toString(Object target) {
363 return toString(target, Object.class);
364 }
365
366 public static String toString(Object target, Class stopClass) {
367 LinkedHashMap map = new LinkedHashMap();
368 addFields(target, target.getClass(), stopClass, map);
369 StringBuffer buffer = new StringBuffer(simpleName(target.getClass()));
370 buffer.append(" {");
371 Set entrySet = map.entrySet();
372 boolean first = true;
373 for (Iterator iter = entrySet.iterator(); iter.hasNext();) {
374 Map.Entry entry = (Map.Entry)iter.next();
375 if (first) {
376 first = false;
377 } else {
378 buffer.append(", ");
379 }
380 buffer.append(entry.getKey());
381 buffer.append(" = ");
382 appendToString(buffer, entry.getValue());
383 }
384 buffer.append("}");
385 return buffer.toString();
386 }
387
388 protected static void appendToString(StringBuffer buffer, Object value) {
389 buffer.append(value);
390 }
391
392 public static String simpleName(Class clazz) {
393 String name = clazz.getName();
394 int p = name.lastIndexOf('.');
395 if (p >= 0) {
396 name = name.substring(p + 1);
397 }
398 return name;
399 }
400
401 @SuppressWarnings("unchecked")
402 private static void addFields(Object target, Class startClass, Class stopClass, LinkedHashMap map) {
403 if (startClass != stopClass) {
404 addFields(target, startClass.getSuperclass(), stopClass, map);
405 }
406
407 Field[] fields = startClass.getDeclaredFields();
408 for (Field field : fields) {
409 if (Modifier.isStatic(field.getModifiers()) || Modifier.isTransient(field.getModifiers())
410 || Modifier.isPrivate(field.getModifiers())) {
411 continue;
412 }
413
414 try {
415 field.setAccessible(true);
416 Object o = field.get(target);
417 if (o != null && o.getClass().isArray()) {
418 try {
419 o = Arrays.asList((Object[])o);
420 } catch (Throwable e) {
421 // ignore
422 }
423 }
424 map.put(field.getName(), o);
425 } catch (Throwable e) {
426 throw ObjectHelper.wrapRuntimeCamelException(e);
427 }
428 }
429 }
430
431 }