Méthode de type de type réflexion en Java

inspiré des cadres moqueurs, nous pourrions rêver de la syntaxe suivante: xxx

L'astuce est la déclaration générique: xxx p> maintenant Le type de retour de la méthode est identique à celui de votre objet de données et que vous pouvez utiliser l'achèvement du code (et la vérification statique) pour accéder à toutes les méthodes, y compris les méthodes de getter.

comme un inconvénient, le code ISN 'T assez intuitif de lire, puisque l'appel à la getter n'obtient rien, mais instruise au contraire le validateur de valider le champ.

Une autre option possible serait d'annoter les champs de votre classe de données : xxx

puis appelez simplement: xxx

pour valider tous les champs en fonction des options annotées.

Java manque le sucre de la syntaxe pour faire quelque chose de aussi agréable que personne.Phonenumber.geter code>. Mais si la personne est une interface, vous pouvez enregistrer la méthode Getter à l'aide d'un proxy dynamique. Vous pouvez enregistrer des méthodes sur des classes non finales à l'aide de CGLib, de la même manière Makiito le fait.

MethodSelector<Person> selector = new MethodSelector<Person>(Person.class);
selector.select().getPhoneNumber();
validateField(data, selector.getMethod(), options);

Le framework piclock vous permet de procéder aux éléments suivants:

 assertThat(Data.class, providesFeaturesOf(OpenData.class));

Check out https://jodd.org/ref/methref.html . Il utilise la bibliothèque de proxy Jodd (Proxetta) pour proxy votre type. Pas sûr de ses caractéristiques de performance, mais il fournit une sécurité de type.

Un exemple: Supposons que str.class code> a la méthode .BOO () code> et vous souhaitez obtenir son nom comme la chaîne "boo" code " >: P>

Methref<Str> m = Methref.on(Str.class);

// `.to()` returns a proxied instance of `Str` upon which you
// can call `.boo()` Methods on this proxy are empty except when
// you call them, the proxy stores the method's name. So doing this
// gets the proxy to store the name `"boo"`.

m.to().boo();

// You can get the name of the method you called by using `.ref()`:

m.ref();   // returns "boo"                                 

Utilisez le @jailbreak de Manifold CODE> pour la compilation-Time Type-Safe-Safe Strong> Accès aux champs privés, aux méthodes, etc.

public class Foo {
  private final int _privateField;

  public Foo(int value) {
    _privateField = value;
  }

  private String privateMethod() {
    return "hi";
  }

  private String privateMethod(String param) {
    return param;
  }
}

J'ai trouvé un moyen d'obtenir la méthode méthode code> à l'aide de Lambdas. Cela ne fonctionne que sur les méthodes d'interface cependant actuellement.

Ça fonctionne en utilisant Net.Jodah: TypeTools code> une bibliothèque très légère. https://github.com/jhalterman/typetools p> xxx pré >

Utilisation: p>

Method method = MethodResolver.toMethod2(SomeIFace::foobar);
System.out.println(method); // public abstract example.Result example.SomeIFace.foobar(java.lang.String,boolean)

Method get = MethodResolver.<Supplier, Object>toMethod0(Supplier::get);
System.out.println(get); // public abstract java.lang.Object java.util.function.Supplier.get()

Method accept = MethodResolver.<IntFunction, Integer, Object>toMethod1(IntFunction::apply);
System.out.println(accept); // public abstract java.lang.Object java.util.function.IntFunction.apply(int)

Method apply = MethodResolver.<BiFunction, Object, Object, Object>toMethod2(BiFunction::apply);
System.out.println(apply); // public abstract java.lang.Object java.util.function.BiFunction.apply(java.lang.Object,java.lang.Object)