À l'aide de la réflexion pour obtenir une méthode, la méthode des paramètres de types d'interface ne sont pas trouvés

Peut-être que je suis absent quelque chose de simple ici, mais comment puis-je obtenir une méthode dont le paramètre est une interface à l'aide de la réflexion.

Dans le cas suivant newValue serait un List<String> appelé foo. Je voudrais donc appeler addModelProperty("Bar", foo); Mais cela ne fonctionne que pour moi si je n'utilise pas l'interface et utiliser uniquement LinkedList<String> foo. Comment puis-je utiliser une interface pour newValue et obtenir la méthode de model qui dispose d'une interface en tant que paramètre addBar(List<String> a0)?

Voici un exemple plus détaillé. (basé sur: Cet exemple)

public class AbstractController {
  public setModel(AbstractModel model) {
    this.model = model;
  }
  protected void addModelProperty(String propertyName, Object newValue) {
    try {
      Method method = getMethod(model.getClass(), "add" + propertyName, newValue);
      method.invoke(model, newValue);
    } catch (NoSuchMethodException e) {
    } catch (InvocationTargetException e) {
    } catch (Exception e) {}
    }
}

public class AbstractModel {
  protected PropertyChangeSupport propertyChangeSupport;
  protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
    propertyChangeSupport.firePropertyChange(propertyName, oldValue, newValue);
  }
}

public class Model extends AbstractModel {
  public void addList(List<String> list) {
    this.list.addAll(list);
  }
}

public class Controller extends AbstractController {
  public void addList(List<String> list) {
    addModelProperty(list);
  }
}

public void example() {
  Model model = new Model();
  Controller controller = new Controller();
  List<String> list = new LinkedList<String>();
  list.add("example");
//addList in the model is only found if LinkedList is used everywhere instead of List
  controller.addList(list);
}
pourquoi ne pas vous poster le code que vous avez essayé et cela ne fonctionne pas ainsi, nous pouvons voir comment vous souhaitez que cela fonctionne?

OriginalL'auteur initialZero | 2010-08-30

  1. 11

    Que vous avez à la recherche par le biais de toutes les méthodes de votre modèle et de trouver celles qui sont compatibles avec les arguments que vous avez. C'est un peu brouillon, car, en général, il peut y avoir plus qu'un.

    Si vous êtes simplement intéressé par les méthodes publiques, la getMethods() méthode est la plus simple à utiliser, car il vous donne toutes les méthodes accessibles sans marcher la hiérarchie de classe.

    Collection<Method> candidates = new ArrayList<Method>();
String target = "add" + propertyName;
for (Method m : model.getClass().getMethods()) {
  if (target.equals(m.getName())) {
    Class<?>[] params = m.getParameterTypes();
    if (params.length == 1) {
      if (params[0].isInstance(newValue))
        candidates.add(m);
    }
  }
}
/* Now see how many matches you have... if there's exactly one, use it. */

    OriginalL'auteur erickson

  2. 6

    Si vous n'avez pas l'esprit en ajoutant une dépendance à Apache Commons, vous pouvez utiliser MethodUtils.getMatchingAccessibleMethod(Classe clazz, Chaîne methodName, la Classe[] parameterTypes).

    Si vous l'esprit de l'ajout de cette dépendance, vous pouvez au moins savoir qu'il est utile de prendre un coup d'oeil à comment cette méthode est mise en œuvre.

    OriginalL'auteur Lodovik