A tricky way to twick ValueBinding language to bind a method call

Question

Here is the scenario:
I'd like component can bind value to method call(with parameters) to a java instance, of course including backingBean.
I wish this solution would be useful, especially when you are working in iteration component such as ForEach, TreeView or DataTable, EL ValueBinging language might be too restricted to complex expression. This way, you can pass iteration items as parameters into a method can and return a value to you page by valuebinding language
In JSP:
    <h:outputText value="#{Page1.callHelper[Page1]['targetMethod']['James'][Page1.callEnd]}"/>In PageBean:
     public String targetMethod(String name){
         return "Hello, " + name +"!";
    private CallHelper callHelper = new CallHelper();
     public CallHelper getCallHelper() {
          return callHelper;
     public void setCallHelper(CallHelper callHelper) {
          this.callHelper = callHelper;
     private CallEnd callEnd = new CallEnd();
     public CallEnd getCallEnd() {
          return callEnd;
     public void setCallEnd(CallEnd callEnd) {
          this.callEnd = callEnd;
     }Util classes:
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
public class CallHelper extends LinkedHashMap {
     private CallHelper parent;
     public Object get(Object key){
          if(key instanceof CallEnd)return getRoot().methodCall();
          else{
               Object value = super.get(key);          
               if(value == null){
                    value = new CallHelper();
                    put(key, value);
                    ((CallHelper)value).parent = this;
               return value;
     public boolean containsKey(Object key){
          return true;
     public boolean realContainsKey(Object key){
          return super.containsKey(key);
    protected CallHelper getRoot(){
         CallHelper root = this;
         if(root.parent==null)return root;
         else return root.parent.getRoot();
     protected Object methodCall(){
          Object result = null;
         List callParameters = new ArrayList(2);
         listCallParameters(callParameters, this);
         if(callParameters.size()>1){
              Object instance = callParameters.get(0);
              String methodName = callParameters.get(1).toString();
              List methodParameters = new ArrayList();
              for(int i=2; i<callParameters.size(); i++){
                   methodParameters.add(callParameters.get(i));
              Method method = findMethod(instance, methodName, methodParameters);
              if(method != null){
                   try {
                         result = method.invoke(instance, methodParameters.toArray());
                    } catch (IllegalArgumentException e) {
                    } catch (IllegalAccessException e) {
                    } catch (InvocationTargetException e) {
          this.clear();
          return result;
     private void listCallParameters(List list, Map map){
          if(map==null || !map.keySet().iterator().hasNext())return;
          Object key = map.keySet().iterator().next();
          if(key instanceof CallEnd)return;
          list.add(key);
          listCallParameters(list, (Map)map.get(key));
     private Method findMethod(Object instance, String methodName, List parameters){
          Method result = null;
          Method[] methods = instance.getClass().getMethods();
          for(int i=0; i<methods.length; i++){
               if(methods.getName().equals(methodName)){
                    System.out.println(methodName);
                    Class[] paraClasses = methods[i].getParameterTypes();
                    if(paraClasses.length==parameters.size()){
                         boolean match = true;
                         for(int j=0; j<paraClasses.length; j++){
                              if(parameters.get(j)!=null && !paraClasses[j].isInstance(parameters.get(j))){
                                   match = false;
                                   break;
                         if(match){
                              result = methods[i];
                              break;
          return result;
public class CallEnd {
Improvement:
Anyone can make it thread safety and bind callhelper and callend directly to FacesContext properties rather than each backingBean.
Have fun!
And feel free to contect me at:
[email protected]
[email protected]

Answer 1

You must seperate your parameter preparing and action method calling for sure.
It depends on what kind of parameters you need to pass in:
1. If action method is bound to several buttons, and it just wants to know which button was clicked, you can set actionListener to prepare it for you. Because the event includes the information you need.
2. For other kinds of parameters, you can use ValueBinding Language to bind parameter values to backingBean, then the action method(without parameters) can pick parameters up from backingBean.