Comment puis-je place la validation des contraintes sur ma méthode de paramètres d'entrée?

J'ai vu une technique par Eric Burke c'est à peu près comme suit. C'est une façon élégante de l'utilisation de la statique des importations. Le code se lit très bien.

Pour se faire une idée, voici la Contract classe. C'est minime, mais peut facilement être complété en tant que de besoin.

package net.codetojoy;

public class Contract {
    public static void isNotNull(Object obj) {
        if (obj == null) throw new IllegalArgumentException("illegal null");
    }
    public static void isNotEmpty(String s) {
        if (s.isEmpty()) throw new IllegalArgumentException("illegal empty string");
    }
}

Et voici un exemple d'utilisation. Le foo() méthode illustre la statique des importations:

package net.codetojoy;

import static net.codetojoy.Contract.*;

public class Example {
    public void foo(String str) {
        isNotNull(str);
        isNotEmpty(str);
        System.out.println("this is the string: " + str);
    }

    public static void main(String[] args) {
        Example ex = new Example();
        ex.foo("");
    }
}

Remarque: lors de l'expérimentation, notez que il y a peut être un bug autour de le faire dans le package par défaut. J'ai certainement perdu les cellules du cerveau de l'essayer.

OriginalL'auteur Michael Easter

Cela ne veut pas répondre directement à votre question, mais je pense qu'une partie de votre problème est que vous êtes trop la validation. Par exemple, vous pouvez remplacer le premier test avec:

if (x.isEmpty()) {
    throw new IllegalArgumentException("x cannot be empty");
}

et de s'appuyer sur l'île de Java pour lancer une NullPointerException si x est null. Vous avez juste besoin de modifier votre "contrat" pour dire que les NPE est levée pour certains types de "vous m'avez appelé illégal" paramètres de situations.

OriginalL'auteur Stephen C

Je voudrais utiliser le Paramètre d'Annotations, de Réflexion et d'un générique classe de validation pour créer une application à l'échelle de l'établissement. par exemple, vous pouvez code d'une méthode de classe comme:

.. myMethod( @notNull Chaîne x, @notNullorZero Chaîne y){

if (Validator.ifNotContractual(getParamDetails()) {
    raiseException..
    or 
    return ..
}

}

Les méthodes de la classe sont "marqués" pour annoter leurs conditions de contrat. Utiliser la réflexion pour détecter automatiquement les paramètres, leurs valeurs et leurs annotations. Envoyer le tout à une classe statique pour valider et vous permettent de connaître le résultat.

OriginalL'auteur srini.venigalla

Si vous êtes à l'aide de Java 8, lambdas peuvent être utilisés pour créer un très élégant et lisible de la solution pour la validation:

public class Assert {

    public interface CheckArgument<O> {
        boolean test(O object);
    }

    public static final <O> O that(O argument, CheckArgument<O> check) {
        if (!check.test(argument))
            throw new IllegalArgumentException("Illegal argument: " + argument);
        return argument;
    }
}

Vous l'utilisez comme:

public void setValue(int value) {
    this.value = Assert.that(value, arg -> arg >= 0);
}

L'exception ressemblera:

Exception in thread "main" java.lang.IllegalArgumentException: Illegal argument: -7
    at com.xyz.util.Assert.that(Assert.java:13)
    at com.xyz.Main.main(Main.java:16)

La première est sympa, c'est que la classe Assert est tout ce qu'il faut vraiment:

public void setValue(String value) {
    this.value = Assert.that(value, arg -> arg != null && !arg.trim().isEmpty());
}

public void setValue(SomeObject value) {
    this.value = Assert.that(value, arg -> arg != null && arg.someTest());
}

Bien sûr that() peut être mis en œuvre dans un certain nombre de façons: avec une chaîne de format et d'arguments, de lancer d'autres types d'exceptions, etc.

Il n'est pas, cependant, doivent être mises en œuvre afin d'effectuer différents tests.

Pas que vous ne pouvez pas pré paquet de tests si vous aimez:

public static CheckArgument<Object> isNotNull = arg -> arg != null;

Assert.that(x, Assert.isNotNull);

//with a static import:

Assert.that(x, isNotNull);

Je n'ai aucune idée si c'est mauvais pour la performance ou non une bonne idée pour une autre raison. (Juste commencé à regarder les lambdas moi-même, mais le code semble fonctionner comme il se doit...) Mais j'aime que Assert peut être court (pas besoin de dépendances qui peuvent ne pas être cruciale pour le projet) et que les tests sont très visibles.

Voici une méthode pour une meilleure message d'erreur:

public static final <O> O that(O argument, CheckArgument<O> check,
    String format, Object... objects) 
{
    if (!check.test(argument))
        throw new IllegalArgumentException(
            String.format(format, objects));
    return argument;
}

Vous l'appeler comme:

public void setValue(String value) {
    this.value = Assert.that(value, 
        arg -> arg != null && arg.trim().isEmpty(), 
        "String value is empty or null: %s", value);
}

Et il en sort:

Exception in thread "main" java.lang.IllegalArgumentException: String value is empty or null: null
    at com.xyz.util.Assert.that(Assert.java:21)
    at com.xyz.Main.main(Main.java:16)

Mise à jour: Si vous souhaitez utiliser le x = Assert... de construction avec un produit de test, le résultat sera jeté du type utilisé dans la préemballés test. Il doit donc être rejetés sur le type de la variable... SomeClass x = (SomeClass) Assert.that(x, isNotNull)

OriginalL'auteur Erk