@Override @Nullable public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name, List<TypeDescriptor> argumentTypes) throws AccessException { if (targetObject instanceof Class) { throw new IllegalArgumentException("DataBindingMethodResolver does not support Class targets"); } return super.resolve(context, targetObject, name, argumentTypes); }
@Override @Nullable public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name, List<TypeDescriptor> argumentTypes) throws AccessException { if (targetObject instanceof Class) { throw new IllegalArgumentException("DataBindingMethodResolver does not support Class targets"); } return super.resolve(context, targetObject, name, argumentTypes); }
MethodExecutor me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "methodToCall", args); me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "foo", args); me.execute(emptyEvalContext, ru, 45); me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "foo", args); me.execute(emptyEvalContext, ru, 45f); me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "foo", args); me.execute(emptyEvalContext, ru, 23d); me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "foo", args); me.execute(emptyEvalContext, ru, (short) 23); me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "foo", args); me.execute(emptyEvalContext, ru, 23L); me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "foo", args); me.execute(emptyEvalContext, ru, (char) 65); me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "foo", args); me.execute(emptyEvalContext, ru, (byte) 23); me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "foo", args); me.execute(emptyEvalContext, ru, true); me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "bar", args); me.execute(emptyEvalContext, ru, 12, 23f);
@Ignore @Test public void repro() throws Exception { AlwaysTrueReleaseStrategy target = new AlwaysTrueReleaseStrategy(); BeanFactoryTypeConverter converter = new BeanFactoryTypeConverter(); StandardEvaluationContext context = new StandardEvaluationContext(); context.setTypeConverter(converter); List<Foo> arguments = new ArrayList<>(); // !!!! With the below line commented you'll get NPE. Uncomment and everything is OK! //arguments.add(new Foo()); List<TypeDescriptor> paramDescriptors = new ArrayList<>(); Method method = AlwaysTrueReleaseStrategy.class.getMethod("checkCompleteness", List.class); paramDescriptors.add(new TypeDescriptor(new MethodParameter(method, 0))); List<TypeDescriptor> argumentTypes = new ArrayList<>(); argumentTypes.add(TypeDescriptor.forObject(arguments)); ReflectiveMethodResolver resolver = new ReflectiveMethodResolver(); MethodExecutor executor = resolver.resolve(context, target, "checkCompleteness", argumentTypes); Object result = executor.execute(context, target, arguments); System.out.println("Result: " + result); }
/** * Test whether {@link ReflectiveMethodResolver} handles Widening Primitive Conversion. That's passing an 'int' to a * method accepting 'long' is ok. */ @Test public void wideningPrimitiveConversion_SPR8224() throws Exception { class WideningPrimitiveConversion { public int getX(long i) { return 10; } } final Integer INTEGER_VALUE = Integer.valueOf(7); WideningPrimitiveConversion target = new WideningPrimitiveConversion(); EvaluationContext emptyEvalContext = new StandardEvaluationContext(); List<TypeDescriptor> args = new ArrayList<>(); args.add(TypeDescriptor.forObject(INTEGER_VALUE)); MethodExecutor me = new ReflectiveMethodResolver(true).resolve(emptyEvalContext, target, "getX", args); final int actual = (Integer) me.execute(emptyEvalContext, target, INTEGER_VALUE).getValue(); final int compiler = target.getX(INTEGER_VALUE); assertEquals(compiler, actual); }
@Override public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name, List<TypeDescriptor> argumentTypes) throws AccessException { this.validateMethod(targetObject, name, (argumentTypes != null ? argumentTypes.size() : 0)); return super.resolve(context, targetObject, name, argumentTypes); }
@Override @Nullable public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name, List<TypeDescriptor> argumentTypes) throws AccessException { if (targetObject instanceof Class) { throw new IllegalArgumentException("DataBindingMethodResolver does not support Class targets"); } return super.resolve(context, targetObject, name, argumentTypes); }
@Override public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name, List<TypeDescriptor> argumentTypes) throws AccessException { this.validateMethod(targetObject, name, (argumentTypes != null ? argumentTypes.size() : 0)); return super.resolve(context, targetObject, name, argumentTypes); }
@Override public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name, List<TypeDescriptor> argumentTypes) throws AccessException { if ("tenantProperty".equals(name)) { return new TenantMethodExecutor(); } return super.resolve(context, targetObject, name, argumentTypes); } }
@Override public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name, List<TypeDescriptor> argumentTypes) throws AccessException { // first check against given targetObject MethodExecutor executor = super.resolve(context, targetObject, name, argumentTypes); if (executor != null) { return executor; } // intercept our own function names and replace target so // that we can match a correct partition functions. if (METHOD_PATH.equals(name)) { targetObject = PathCombiningMethodExecutor.class; } else if (METHOD_DATEFORMAT.equals(name)) { targetObject = DateFormatMethodExecutor.class; } else if (METHOD_HASH.equals(name)) { targetObject = HashMethodExecutor.class; } else if (METHOD_HASHLIST.equals(name)) { targetObject = HashListMethodExecutor.class; } else if (METHOD_HASHRANGE.equals(name)) { targetObject = HashRangeMethodExecutor.class; } // need to go back to super method for whole spel to work return super.resolve(context, targetObject, name, argumentTypes); }
/** * If the target object is a tag library, replace the name and targetObject parameters with the * method name and implementing class, respectively, of the named tag library function before * calling the super method. */ @Override public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name, List<TypeDescriptor> argumentTypes) throws AccessException { if (targetObject instanceof TagLibrary) { TagLibrary lib = (TagLibrary) targetObject; TagLibraryFunction function = lib.getFunction(name); if (function != null) { try { targetObject = Class.forName(function.getClassName()); } catch (ClassNotFoundException e) { throw new AccessException("Error evaluating " + function, e); } name = function.getMethodName(); } else { throw new AccessException("Unknown function \"" + name + "\" in tag library " + lib.getUri()); } } return super.resolve(context, targetObject, name, argumentTypes); } }
/** * If the target object is a tag library, replace the name and targetObject parameters with the * method name and implementing class, respectively, of the named tag library function before * calling the super method. */ @Override public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name, List<TypeDescriptor> argumentTypes) throws AccessException { if (targetObject instanceof TagLibrary) { TagLibrary lib = (TagLibrary) targetObject; TagLibraryFunction function = lib.getFunction(name); if (function != null) { try { targetObject = Class.forName(function.getClassName()); } catch (ClassNotFoundException e) { throw new AccessException("Error evaluating " + function, e); } name = function.getMethodName(); } else { throw new AccessException("Unknown function \"" + name + "\" in tag library " + lib.getUri()); } } return super.resolve(context, targetObject, name, argumentTypes); } }