Generieke veld validatie systeem

[Standeman]

Ik ben bezig met een klein ontwerpje van een een validation framework en ik ben benieuwd wat de mensen hier ervan denken.

In ons systeem kunnen formulieren aangemaakt worden. Elk veld in een dergelijk formulier staat heeft een definition wat het veld beschrijft zoals de naam en wat voor waarde erin moet. Op het moment is er wel zoiets als validatie aanwezig alleen moet dat flink onder handen genomen worden omdat het eigenlijk niet werkt of uitbreidbaar is.

Nu heb ik een oplossing bedacht: een validator class welke ik subclass in allerlei specifieke validatie classes i.c.m. met het decorator pattern om combinaties mogelijk te maken. (bijv. new NumberValidator(new NotNullValidator()).
Ik denk ook ook wel dat dat aardig gaat werken. Het is uitbreidbaar, redelijk flexibel en bekend terein. Het zou een beetje lijken op de validators die je ziet in bijv. Apache commons-validator, JSF of andere MVC frameworks. Echter moet het wel J2ME geschikt zijn (basicly Java 1.3) en in een DB opgeslagen worden. Ik ben er nog niet helemaal achter of commons-validator in dat plaatje past.

Wat is verstandig en wat is handig?

[ Voor 23% gewijzigd door Standeman op 29-09-2009 12:21 ]

[Standeman]

*kickje*
Iemand?

[beany]

En als velden afhankelijk zijn van andere velden?

[Standeman]

Dat moet inderdaad ook ondersteund gaan worden. Ik zat in gedachte al te spelen met een "DependecyValidator(field)" en deze toetevoegen aan het afhankelijke veld. Deze checked dus de waarde van het het veld waarvan deze afhankelijk is.

[Macros]

Ja, afhankelijkheid is het grootste probleem bij dat soort custom validatie.
Als je even opslag in de database buiten beschouwing laat, dan kan je zoals je zelf al voorstelt een Validator interface definieren. Bijvoorbeeld:

Java:

public void validate(ValidationErrors errors, Context context, Field<T> field, T value);

In errors kan je dan errors toevoegen. In de context kan je de waardes van alle andere velden opvragen en eventueel aanpassen, en value is de waarde die je nu valideerd. Field bevat de meta data van het veld dat je nu valideerd. Alle types behalve value zijn optioneel en hoe meer je er kiest, hoe simpeler maar minder krachtig je validators worden. Behalve deze interface moet je ook implementaties maken voor ValidationErrors, Context en Field, en de Validator zelf natuurlijk.

Als je nu nog wilt dat de validators opslaanbaar zijn in een database, dan wil je dus java code (of andere code) opslaan in de database. Welke deze interface moet implementeren. In een J2ME omgeving zie ik dat niet zo snel gebeuren. Dan moet je van te voren een set van validators implementeren die je kan customizen, waarvan je de configuratie van die validators in de database kan opslaan.

code:

validator {
   number id,
   varchar name --naam van de validator klasse

validator_instance {
   number id,
   number validator_id -- foreign key naar validator
}

validator_param {
   number id,
   number validator_id, -- foreign key naar validator
   varchar name, -- naam van de parameter
   -- optioneel ook het type van de parameter
   number param_type_id -- voorbeeld is een foreign key naar een param_type tabel
}

validator_param_instance {
   number id,
   validator_param_id, -- foreign key naar de parameter
   clob/blob/varchar value -- waarde van de parameter sla je waarschijnlijk in de database op als tekst 
}

Ik denk dat je het meeste wel volgt, de waarde van de parameter zal je moeten 'serializeren' naar de database als tekst en terug, dat zal je met toString en fromString moeten doen. Het decorator pattern kan je dan gebruiken door bijvoorbeeld een composite validator te maken die je kan configureren door te verwijzen naar meerdere validator_instances.

Ik denk dat ik zoiets op zou zetten. Oh ja, dan heb je dus geen mogelijkheid om afhankelijkheden te configureren in je validatie. Bijvoorbeeld: postcode moet pattern 0000AA hebben indien land gelijk is aan Nederland. In normaal Java heb ik dat gedaan door de Java script engine uit Java 6 te gebruiken, maar ja, in J2ME is dat wat lastig...

[SiErRa]

Misschien iets te ver out of the box, maar zou je niet met XSD's kunnen werken, en het ingevulde formulier naar XML omzetten en tegen de XSD toetsen.

Dit gaat natuurlijk alleen op als je genoeg hebt aan de validaties die je in een XSD kan doen.

[BCC]

Er zijn voor java toch genoeg generieke MVC validatie frameworks? Waarom wil je het wiel opnieuw uitvinden?

[Standeman]

BCC schreef op woensdag 30 september 2009 @ 22:20:
Er zijn voor java toch genoeg generieke MVC validatie frameworks? Waarom wil je het wiel opnieuw uitvinden?

Omdat het op J2ME moet werken en de meeste validatieframeworks voldoen niet aan de J2ME specificatie (zeg source level >= 1.4). Tevens kunnen users zelf hun formulieren aanmaken en de validatie voor de velden zelf kiezen. Dit wordt zover ik weet niet echt "out of the box" ondersteund. Ook de aansluiting op ons "formulieren-systeem" is lastig met kant en klare frameworks. Hoewel dat laatste slechts een vermoeden is.