INSTANCIER DYNAMIQUEMENT UN OBJET "METHOD"

package fr.celphys;
import java.lang.reflect.Method;

/**
 * Classe utilisée pour regrouper plusieurs méthodes
 * utilitaire pour utilisation des elemnts de l'API
 * reflect.
 *
 * @author Celphys
 */
public final class ReflectUtils {

    /**
     *  Pas de constructeur par défaut à la compil.
     */
    private ReflectUtils() {
    }

    /**
     * Permet de charger un objet de type METHOD depuis un expression String (issue de Method.toString()).
     * @param fullName
     *          nom de la méthode
     * @return
     *          methode chargée
     * @throws ClassNotFoundException
     *          nom de classe non valide
     * @throws NoSuchMethodException
     *          pas de méthode avec ce nom pour la classe
     */
    public static Method getMethodFromString(final String fullName)
    throws ClassNotFoundException, NoSuchMethodException {
        // 1) Utilisons les parenthère pour extraire la bonne sous chaine d'un method.toString().
        Method targetmethod    = null;
        String[] elements = fullName.split(" ");
        if (elements == null || elements.length < 2) {
            //--> Tentative d'extraction de la sous chains ave une reg exp ... très long O_O...
            throw new IllegalArgumentException("Cannot be Method expression, please check : "
                    + "^([a-zA-Z0-9.]*)+([(])+([a-zA-Z0-9.]*)+([)])$");
        }
        String str = null;
        boolean found     = false;
        int indexElements = 0;
        int indexBegin    = -1;
        int indexEnd      = -1;
        while (!found && indexElements < elements.length) {
            str = elements[indexElements];
            indexBegin = str.indexOf("(");
            indexEnd   = str.indexOf(")");
            found =  (indexBegin != -1 && indexEnd != -1);
            indexElements++;
        }
        if (!found) {
            throw new IllegalArgumentException("Bad Expression cannot find method expression");
        } else {
            String methodCompleteName = str.substring(0, indexBegin);
            String methodSimpleName = methodCompleteName.substring(methodCompleteName.lastIndexOf(".") + 1);
            String methodClassName  = methodCompleteName.substring(0, methodCompleteName.lastIndexOf("."));
            System.out.println("Retrieving method <" + methodSimpleName + "> from class <" + methodClassName + ">");
            String[] parameterTypes = str.substring(indexBegin + 1, indexEnd).split(",");
            Class[] parametersClasses = new Class[parameterTypes.length];
            for (int indexParam = 0; indexParam < parameterTypes.length; indexParam++) {
                String param = parameterTypes[indexParam];
                if (param == null || param.trim().length() < 1) {
                    // Pas de paramètre
                    parametersClasses = null;
                } else {
                    Class classe = null;
                    // On essaie avec le nom de classe
                    try {
                        classe = Class.forName(param);
                    } catch (ClassNotFoundException e) {
                        // Gestion des types Simples
                        if (Integer.TYPE.getName().equals(param)) {
                            classe = Integer.TYPE;
                        } else if (Long.TYPE.getName().equals(param)) {
                            classe = Long.TYPE;
                        } else if (Double.TYPE.getName().equals(param)) {
                            classe = Double.TYPE;
                        } else if (Float.TYPE.getName().equals(param)) {
                            classe = Float.TYPE;
                        } else if (Boolean.TYPE.getName().equals(param)) {
                            classe = Boolean.TYPE;
                        } else {
                            classe = null;
                        }
                    }
                    parametersClasses[indexParam] = classe;
                }
            }
          // Maintenant nous allons créer la méthode
          Class targetClass = Class.forName(methodClassName);
          targetmethod = targetClass.getMethod(methodSimpleName, parametersClasses);
        }
        return targetmethod;
    }    
   
}