Comment valider de nombreux champs JSON sans encombrer le code avec des chèques if-chèques sur chaque champ?

Question

J'ai une classe qui contient divers champs et on peut accéder à l'aide de getters et de setters comme ce qui suit

public class Student {

    private String name;
    private int age;
    private int sibblingsCount;
    private String elderSibblingName;
    private String youngerSibblingName;

    public String getName() {
        return this.name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return this.name;
    }
    public void setAge(int age) {
        this.age = age;
    }

    public void setSibblingsCount(int count) {
        this.sibblingsCount = count;
    }
    public int getSibblingsCount() {
        return this.sibblingsCount;
    }

    public void setElderSibblingName(String name) {
        this.elderSibblingName = name;
    }
    public String getElderSibblingName() {
        return this.elderSibblingName;
    }

    public void setYoungerSibblingName(String name) {
        this.youngerSibblingName = name;
    }
    public void getYoungerSibblingName() {
        return this.youngerSibblingName;
    }

    public String getStudentDetails() {    
        JSONObject json = new JSONObject();
        if(name != null && !name.isEmpty()) {
            json.put("name", this.name);
        }

        if(this.age != 0) {
            json.put("age", this.age);
        }

        if(this.sibblingsCount != 0) {
            json.put("sibblingsCount", this.sibblingsCount);
        }

        if(this.elderSibblingName != null && !this.elderSibblingName.isEmpty()) {
            json.put("elderSibblingName", this.elderSibblingName);
        }

        if(this.youngerSibblingName != null && !this.youngerSibblingName.isEmpty() {
            json.put("youngerSibblingName", this.youngerSibblingName);
        }
        return json.toString();
    }
}

Tout ce dont j'ai besoin, c'est d'emballer les champs valides de la classe Student. Le champ est dit être valide lorsqu'il contient une certaine valeur. Dire age ne devrait pas être 0 Et ce doit être un nombre valide. Dites elderSibblingName il ne doit pas être nul ou vide. Comment vérifier les champs valides tout en emballant le JSON résultant?

Il est vraiment douloureux de vérifier la validité de chaque classement de la classe qui rend le code maladroit lorsqu'il y a trop de champs dans la classe.

Answer 1

Dans mon expérience personnelle, le type d'encombrement particulier qui se déroule pendant la validation est que le code est généralement couplé temporellement. C'est difficile à lire et à maintenir. Être fan de code déclaratif, je mettez également en œuvre la validation de manière aussi.

Voici un exemple. Supposons que nous ayons le schéma suivant:

{
    "payment":{
        "card_number":12345612341234,
        "expires_at":"12/29"
    }
}

J'aimerais avoir une seule expression validant celui-ci. Et en fait, j'en ai un, ici il va dans result() Méthode:

public class ValidatedRegistrationRequest implements Validatable<RegistrationRequest>
{
    private String jsonRequestString;
    private Connection dbConnection;

    public ValidatedRegistrationRequest(String jsonRequestString, Connection dbConnection)
    {
        this.jsonRequestString = jsonRequestString;
        this.dbConnection = dbConnection;
    }

    @Override
    public Result<RegistrationRequest> result() throws Exception
    {
        return
            new FastFail<>(
                new WellFormedJson(
                    new Unnamed<>(Either.right(new Present<>(this.jsonRequestString)))
                ),
                requestJsonObject ->
                    new UnnamedBlocOfNameds<>(
                        List.of(
                            new FastFail<>(
                                new IsJsonObject(
                                    new Required(
                                        new IndexedValue("payment", requestJsonObject)
                                    )
                                ),
                                paymentJsonObject ->
                                    new NamedBlocOfNameds<>(
                                        "payment",
                                        List.of(
                                            new ValidThrueIsNotExpired(
                                                new AsString(
                                                    new Required(
                                                        new IndexedValue("valid_thru", paymentJsonObject)
                                                    )
                                                )
                                            ),
                                            new CardNumberIsNotBlacklisted(
                                                new CardNumberSatisfiesLuhnAlgorithm(
                                                    new Required(
                                                        new IndexedValue("card_number", paymentJsonObject)
                                                    )
                                                ),
                                                this.dbConnection
                                            )
                                        ),
                                        Payment.class
                                    )
                            )
                        ),
                        RegistrationRequest.class
                    )
            )
                .result()
            ;
    }
}

Malheureusement, le logiciel ne peut pas formater le code avec les numéros de ligne. ICI Vous pouvez trouver une analyse de ligne par ligne de ce qui se passe ici.

En outre, il n'y a pas de mutation ici. Pas un ensemble unique, nulle part. Cela ajoute à la maintenabilité globale.

Cette approche pourrait sembler trompeusement comme une overkill dans ce cas relativement simple. Mais n'oubliez pas de multiples chèques nuls et de toutes les trucs de Nitty-Gritty qui vont avec validation. Quoi qu'il en soit, il brille vraiment lorsqu'il est utilisé avec des schémas json complexes avec des règles de validation complexes.