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        public static boolean getProperties(Object target, Map props, String optionPrefix) {
054            boolean rc = false;
055            if (target == null) {
056                throw new IllegalArgumentException("target was null.");
057            }
058            if (props == null) {
059                throw new IllegalArgumentException("props was null.");
060            }
061            if (optionPrefix == null) {
062                optionPrefix = "";
063            }
064    
065            Class clazz = target.getClass();
066            Method[] methods = clazz.getMethods();
067            for (Method method : methods) {
068                String name = method.getName();
069                Class type = method.getReturnType();
070                Class params[] = method.getParameterTypes();
071                if (name.startsWith("get") && params.length == 0 && type != null && isSettableType(type)) {
072                    try {
073                        Object value = method.invoke(target);
074                        if (value == null) {
075                            continue;
076                        }
077    
078                        String strValue = convertToString(value, type);
079                        if (strValue == null) {
080                            continue;
081                        }
082    
083                        name = name.substring(3, 4).toLowerCase() + name.substring(4);
084                        props.put(optionPrefix + name, strValue);
085                        rc = true;
086                    } catch (Throwable ignore) {
087                        // ignore
088                    }
089                }
090            }
091    
092            return rc;
093        }
094    
095        public static Object getProperty(Object target, String prop) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
096            if (target == null) {
097                throw new IllegalArgumentException("target was null.");
098            }
099            if (prop == null) {
100                throw new IllegalArgumentException("prop was null.");
101            }
102            prop = prop.substring(0, 1).toUpperCase() + prop.substring(1);
103    
104            Class clazz = target.getClass();
105            Method method = getPropertyGetter(clazz, prop);
106            return method.invoke(target);
107        }
108    
109        public static Method getPropertyGetter(Class type, String propertyName) throws NoSuchMethodException {
110            Method method = type.getMethod("get" + ObjectHelper.capitalize(propertyName));
111            return method;
112        }
113    
114        public static boolean setProperties(Object target, Map props, String optionPrefix) throws Exception {
115            boolean rc = false;
116            if (target == null) {
117                throw new IllegalArgumentException("target was null.");
118            }
119            if (props == null) {
120                throw new IllegalArgumentException("props was null.");
121            }
122    
123            for (Iterator iter = props.keySet().iterator(); iter.hasNext();) {
124                String name = (String)iter.next();
125                if (name.startsWith(optionPrefix)) {
126                    Object value = props.get(name);
127                    name = name.substring(optionPrefix.length());
128                    if (setProperty(target, name, value)) {
129                        iter.remove();
130                        rc = true;
131                    }
132                }
133            }
134            return rc;
135        }
136    
137        public static Map extractProperties(Map props, String optionPrefix) {
138            if (props == null) {
139                throw new IllegalArgumentException("props was null.");
140            }
141    
142            HashMap rc = new HashMap(props.size());
143    
144            for (Iterator iter = props.keySet().iterator(); iter.hasNext();) {
145                String name = (String)iter.next();
146                if (name.startsWith(optionPrefix)) {
147                    Object value = props.get(name);
148                    name = name.substring(optionPrefix.length());
149                    rc.put(name, value);
150                    iter.remove();
151                }
152            }
153    
154            return rc;
155        }
156    
157        public static boolean setProperties(TypeConverter typeConverter, Object target, Map props) throws Exception {
158            boolean rc = false;
159    
160            if (target == null) {
161                throw new IllegalArgumentException("target was null.");
162            }
163            if (props == null) {
164                throw new IllegalArgumentException("props was null.");
165            }
166    
167            for (Iterator iter = props.entrySet().iterator(); iter.hasNext();) {
168                Map.Entry entry = (Map.Entry)iter.next();
169                if (setProperty(typeConverter, target, (String)entry.getKey(), entry.getValue())) {
170                    iter.remove();
171                    rc = true;
172                }
173            }
174    
175            return rc;
176        }
177    
178        public static boolean setProperties(Object target, Map props) throws Exception {
179            return setProperties(null, target, props);
180        }
181    
182        public static boolean setProperty(TypeConverter typeConverter, Object target, String name, Object value) throws Exception {
183            try {
184                Class clazz = target.getClass();
185                // find candidates of setter methods as there can be overloaded setters
186                Set<Method> setters = findSetterMethods(typeConverter, clazz, name, value);
187                if (setters.isEmpty()) {
188                    return false;
189                }
190    
191                // loop and execute the best setter method
192                Exception typeConvertionFailed = null;
193                for (Method setter : setters) {
194                    // If the type is null or it matches the needed type, just use the value directly
195                    if (value == null || setter.getParameterTypes()[0].isAssignableFrom(value.getClass())) {
196                        setter.invoke(target, value);
197                        return true;
198                    } else {
199                        // We need to convert it
200                        try {
201                            // ignore exceptions as there could be another setter method where we could type convert successfully
202                            Object convertedValue = convert(typeConverter, setter.getParameterTypes()[0], value);
203                            setter.invoke(target, convertedValue);
204                            return true;
205                        } catch (NoTypeConversionAvailableException e) {
206                            typeConvertionFailed = e;
207                        } catch (IllegalArgumentException e) {
208                            typeConvertionFailed = e;
209                        }
210                        LOG.trace("Setter \"" + setter + "\" with parameter type \""
211                                  + setter.getParameterTypes()[0] + "\" could not be used for type conertions of " + value);
212                    }
213                }
214                // we did not find a setter method to use, and if we did try to use a type converter then throw
215                // this kind of exception as the caused by will hint this error
216                if (typeConvertionFailed != null) {
217                    throw new IllegalArgumentException("Could not find a suitable setter for property: " + name
218                            + " as there isn't a setter method with same type: " + value.getClass().getCanonicalName()
219                            + " nor type convertion possbile: " + typeConvertionFailed.getMessage());
220                } else {
221                    return false;
222                }
223            } catch (InvocationTargetException e) {
224                // lets unwrap the exception
225                Throwable throwable = e.getCause();
226                if (throwable instanceof Exception) {
227                    Exception exception = (Exception)throwable;
228                    throw exception;
229                } else {
230                    Error error = (Error)throwable;
231                    throw error;
232                }
233            }
234        }
235    
236        public static boolean setProperty(Object target, String name, Object value) throws Exception {
237            return setProperty(null, target, name, value);
238        }
239    
240        private static Object convert(TypeConverter typeConverter, Class type, Object value) throws URISyntaxException {
241            if (typeConverter != null) {
242                return typeConverter.convertTo(type, value);
243            }
244            PropertyEditor editor = PropertyEditorManager.findEditor(type);
245            if (editor != null) {
246                editor.setAsText(value.toString());
247                return editor.getValue();
248            }
249            if (type == URI.class) {
250                return new URI(value.toString());
251            }
252            return null;
253        }
254    
255        private static String convertToString(Object value, Class type) throws URISyntaxException {
256            PropertyEditor editor = PropertyEditorManager.findEditor(type);
257            if (editor != null) {
258                editor.setValue(value);
259                return editor.getAsText();
260            }
261            if (type == URI.class) {
262                return value.toString();
263            }
264            return null;
265        }
266    
267        private static Set<Method> findSetterMethods(TypeConverter typeConverter, Class clazz, String name, Object value) {
268            Set<Method> candidates = new LinkedHashSet<Method>();
269    
270            // Build the method name.
271            name = "set" + ObjectHelper.capitalize(name);
272            while (clazz != Object.class) {
273                // Since Object.class.isInstance all the objects,
274                // Here we just make sure it will be add to the bottom of the set.
275                Method objectSetMethod = null;
276                Method[] methods = clazz.getMethods();
277                for (Method method : methods) {
278                    Class params[] = method.getParameterTypes();
279                    if (method.getName().equals(name) && params.length == 1) {
280                        Class paramType = params[0];
281                        if (paramType.equals(Object.class)) {                        
282                            objectSetMethod = method;
283                        } else if (typeConverter != null || isSettableType(paramType) || paramType.isInstance(value)) {
284                            candidates.add(method);
285                        }
286                    }
287                }
288                if (objectSetMethod != null) {
289                    candidates.add(objectSetMethod);
290                }
291                clazz = clazz.getSuperclass();
292            }
293    
294            if (candidates.isEmpty()) {
295                return candidates;
296            } else if (candidates.size() == 1) {
297                // only one
298                return candidates;
299            } else {
300                // find the best match if possible
301                if (LOG.isTraceEnabled()) {
302                    LOG.trace("Found " + candidates.size() + " suitable setter methods for setting " + name);
303                }
304                // prefer to use the one with the same instance if any exists
305                for (Method method : candidates) {                               
306                    if (method.getParameterTypes()[0].isInstance(value)) {
307                        if (LOG.isTraceEnabled()) {
308                            LOG.trace("Method " + method + " is the best candidate as it has parameter with same instance type");
309                        }
310                        // retain only this method in the answer
311                        candidates.clear();
312                        candidates.add(method);
313                        return candidates;
314                    }
315                }
316                // fallback to return what we have found as candidates so far
317                return candidates;
318            }
319        }
320    
321        private static boolean isSettableType(Class clazz) {
322            if (PropertyEditorManager.findEditor(clazz) != null) {
323                return true;
324            }
325            if (clazz == URI.class) {
326                return true;
327            }
328            if (clazz == Boolean.class) {
329                return true;
330            }
331            return false;
332        }
333    
334        public static String toString(Object target) {
335            return toString(target, Object.class);
336        }
337    
338        public static String toString(Object target, Class stopClass) {
339            LinkedHashMap map = new LinkedHashMap();
340            addFields(target, target.getClass(), stopClass, map);
341            StringBuffer buffer = new StringBuffer(simpleName(target.getClass()));
342            buffer.append(" {");
343            Set entrySet = map.entrySet();
344            boolean first = true;
345            for (Iterator iter = entrySet.iterator(); iter.hasNext();) {
346                Map.Entry entry = (Map.Entry)iter.next();
347                if (first) {
348                    first = false;
349                } else {
350                    buffer.append(", ");
351                }
352                buffer.append(entry.getKey());
353                buffer.append(" = ");
354                appendToString(buffer, entry.getValue());
355            }
356            buffer.append("}");
357            return buffer.toString();
358        }
359    
360        protected static void appendToString(StringBuffer buffer, Object value) {
361            // if (value instanceof ActiveMQDestination) {
362            // ActiveMQDestination destination = (ActiveMQDestination) value;
363            // buffer.append(destination.getQualifiedName());
364            // }
365            // else {
366            buffer.append(value);
367            // }
368        }
369    
370        public static String simpleName(Class clazz) {
371            String name = clazz.getName();
372            int p = name.lastIndexOf(".");
373            if (p >= 0) {
374                name = name.substring(p + 1);
375            }
376            return name;
377        }
378    
379        private static void addFields(Object target, Class startClass, Class stopClass, LinkedHashMap map) {
380            if (startClass != stopClass) {
381                addFields(target, startClass.getSuperclass(), stopClass, map);
382            }
383    
384            Field[] fields = startClass.getDeclaredFields();
385            for (Field field : fields) {
386                if (Modifier.isStatic(field.getModifiers()) || Modifier.isTransient(field.getModifiers())
387                    || Modifier.isPrivate(field.getModifiers())) {
388                    continue;
389                }
390    
391                try {
392                    field.setAccessible(true);
393                    Object o = field.get(target);
394                    if (o != null && o.getClass().isArray()) {
395                        try {
396                            o = Arrays.asList((Object[])o);
397                        } catch (Throwable e) {
398                            // ignore
399                        }
400                    }
401                    map.put(field.getName(), o);
402                } catch (Throwable e) {
403                    LOG.debug("Error adding fields", e);
404                }
405            }
406        }
407    
408    }