001: /*
002: * Copyright 2004-2007 the original author or authors.
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License");
005: * you may not use this file except in compliance with the License.
006: * You may obtain a copy of the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: */
016: package org.springframework.webflow.util;
017:
018: import java.lang.reflect.InvocationTargetException;
019: import java.lang.reflect.Method;
020:
021: /**
022: * Simple utility class for working with the java reflection API. Only intended for
023: * internal use. Will likely disappear in a future release of Spring Web Flow and
024: * simply rely on {@link org.springframework.util.ReflectionUtils} if necessary.
025: *
026: * @author Keith Donald
027: */
028: public class ReflectionUtils {
029:
030: /**
031: * Invoke the specified {@link Method} against the supplied target object
032: * with no arguments. The target object can be <code>null</code> when
033: * invoking a static {@link Method}. All exceptions are treated as fatal and will be
034: * converted to unchecked exceptions.
035: * @see #invokeMethod(java.lang.reflect.Method, Object, Object[])
036: * @throws RuntimeException when something goes wrong invoking the method or
037: * when the method itself throws an exception
038: */
039: public static Object invokeMethod(Method method, Object target)
040: throws RuntimeException {
041: return invokeMethod(method, target, null);
042: }
043:
044: /**
045: * Invoke the specified {@link Method} against the supplied target object
046: * with the supplied arguments. The target object can be null when invoking a
047: * static {@link Method}. All exceptions are treated as fatal and will be
048: * converted to unchecked exceptions.
049: * @see #invokeMethod(java.lang.reflect.Method, Object, Object[])
050: * @throws RuntimeException when something goes wrong invoking the method or
051: * when the method itself throws an exception
052: */
053: public static Object invokeMethod(Method method, Object target,
054: Object[] args) throws RuntimeException {
055: try {
056: return method.invoke(target, args);
057: } catch (IllegalAccessException ex) {
058: handleReflectionException(ex);
059: throw new IllegalStateException(
060: "Unexpected reflection exception - "
061: + ex.getClass().getName() + ": "
062: + ex.getMessage());
063: } catch (InvocationTargetException ex) {
064: handleReflectionException(ex);
065: throw new IllegalStateException(
066: "Unexpected reflection exception - "
067: + ex.getClass().getName() + ": "
068: + ex.getMessage());
069: }
070: }
071:
072: /**
073: * Handle the given reflection exception.
074: * Should only be called if no checked exception is expected to
075: * be thrown by the target method.
076: * <p>
077: * Throws the underlying RuntimeException or Error in case
078: * of an InvocationTargetException with such a root cause. Throws
079: * an IllegalStateException with an appropriate message else.
080: * @param ex the reflection exception to handle
081: */
082: private static void handleReflectionException(Exception ex) {
083: if (ex instanceof NoSuchMethodException) {
084: throw new IllegalStateException("Method not found: "
085: + ex.getMessage());
086: }
087: if (ex instanceof IllegalAccessException) {
088: throw new IllegalStateException("Could not access method: "
089: + ex.getMessage());
090: }
091: if (ex instanceof InvocationTargetException) {
092: handleInvocationTargetException((InvocationTargetException) ex);
093: }
094: throw new IllegalStateException(
095: "Unexpected reflection exception - "
096: + ex.getClass().getName() + ": "
097: + ex.getMessage());
098: }
099:
100: /**
101: * Handle the given invocation target exception.
102: * Should only be called if no checked exception is expected to
103: * be thrown by the target method.
104: * <p>
105: * Throws the underlying RuntimeException or Error in case
106: * of such a root cause. Throws an IllegalStateException else.
107: * @param ex the invocation target exception to handle
108: */
109: private static void handleInvocationTargetException(
110: InvocationTargetException ex) {
111: if (ex.getTargetException() instanceof RuntimeException) {
112: throw (RuntimeException) ex.getTargetException();
113: }
114: if (ex.getTargetException() instanceof Error) {
115: throw (Error) ex.getTargetException();
116: }
117: throw new IllegalStateException(
118: "Unexpected exception thrown by method - "
119: + ex.getTargetException().getClass().getName()
120: + ": " + ex.getTargetException().getMessage());
121: }
122: }
|