001 /* 002 * Created on Oct 31, 2006 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with 005 * the License. You may obtain a copy of the License at 006 * 007 * http://www.apache.org/licenses/LICENSE-2.0 008 * 009 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on 010 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the 011 * specific language governing permissions and limitations under the License. 012 * 013 * Copyright @2006-2009 the original author or authors. 014 */ 015 package org.fest.reflect.method; 016 017 import static org.fest.reflect.util.Accessibles.makeAccessible; 018 import static org.fest.reflect.util.Accessibles.setAccessibleIgnoringExceptions; 019 import static org.fest.reflect.util.Throwables.targetOf; 020 import static org.fest.util.Arrays.format; 021 import static org.fest.util.Strings.concat; 022 import static org.fest.util.Strings.quote; 023 024 import java.lang.reflect.Method; 025 026 import org.fest.reflect.exception.ReflectionError; 027 028 /** 029 * Understands the use of reflection to access a method from an object. 030 * <p> 031 * <pre> 032 * // Equivalent to call 'person.setName("Luke")' 033 * {@link org.fest.reflect.core.Reflection#method(String) method}("setName").{@link MethodName#withParameterTypes(Class...) withParameterTypes}(String.class) 034 * .{@link MethodParameterTypes#in(Object) in}(person) 035 * .{@link Invoker#invoke(Object...) invoke}("Luke"); 036 * 037 * // Equivalent to call 'person.concentrate()' 038 * {@link org.fest.reflect.core.Reflection#method(String) method}("concentrate").{@link MethodName#in(Object) in}(person).{@link Invoker#invoke(Object...) invoke}(); 039 * 040 * // Equivalent to call 'person.getName()' 041 * String name = {@link org.fest.reflect.core.Reflection#method(String) method}("getName").{@link MethodName#withReturnType(Class) withReturnType}(String.class) 042 * .{@link MethodReturnType#in(Object) in}(person) 043 * .{@link Invoker#invoke(Object...) invoke}(); 044 * </pre> 045 * </p> 046 * 047 * @param <T> the return type of the method invocation. 048 * 049 * @author Yvonne Wang 050 */ 051 public final class Invoker<T> { 052 053 static <T> Invoker<T> newInvoker(String methodName, Object target, Class<?>... parameterTypes) { 054 return createInvoker(methodName, target, parameterTypes); 055 } 056 057 private static <T> Invoker<T> createInvoker(String methodName, Object target, Class<?>... parameterTypes) { 058 if (target == null) throw new NullPointerException("Target should not be null"); 059 Method method = lookupInClassHierarchy(methodName, typeOf(target), parameterTypes); 060 return new Invoker<T>(target, method); 061 } 062 063 private static Class<?> typeOf(Object target) { 064 if (target instanceof Class<?>) return (Class<?>)target; 065 return target.getClass(); 066 } 067 068 private static Method lookupInClassHierarchy(String methodName, Class<?> targetType, Class<?>[] parameterTypes) { 069 Method method = null; 070 Class<?> type = targetType; 071 while (type != null) { 072 method = method(methodName, type, parameterTypes); 073 if (method != null) break; 074 type = type.getSuperclass(); 075 } 076 if (method == null) 077 throw new ReflectionError(concat("Unable to find method ", quote(methodName), " in ", 078 targetType.getName(), " with parameter type(s) ", format(parameterTypes))); 079 return method; 080 } 081 082 private static Method method(String methodName, Class<?> type, Class<?>[] parameterTypes) { 083 try { 084 return type.getDeclaredMethod(methodName, parameterTypes); 085 } catch (SecurityException e) { 086 return null; 087 } catch (NoSuchMethodException e) { 088 return null; 089 } 090 } 091 092 private final Object target; 093 private final Method method; 094 095 private Invoker(Object target, Method method) { 096 this.target = target; 097 this.method = method; 098 } 099 100 /** 101 * Invokes the method managed by this class using the given arguments. 102 * @param args the arguments to use to call the method managed by this class. 103 * @return the result of the method call. 104 * @throws ReflectionError if the method cannot be invoked. 105 */ 106 @SuppressWarnings("unchecked") public T invoke(Object... args) { 107 boolean accessible = method.isAccessible(); 108 try { 109 makeAccessible(method); 110 return (T) method.invoke(target, args); 111 } catch (Throwable t) { 112 Throwable cause = targetOf(t); 113 if (cause instanceof RuntimeException) throw (RuntimeException)cause; 114 throw cannotInvokeMethod(cause, args); 115 } finally { 116 setAccessibleIgnoringExceptions(method, accessible); 117 } 118 } 119 120 private ReflectionError cannotInvokeMethod(Throwable cause, Object... args) { 121 String message = concat("Unable to invoke method ", quote(method.getName()), " with arguments ", format(args)); 122 throw new ReflectionError(message, cause); 123 } 124 125 /** 126 * Returns the "real" method managed by this class. 127 * @return the "real" method managed by this class. 128 */ 129 public java.lang.reflect.Method info() { 130 return method; 131 } 132 }