[Parancoe] Validazione tramite DWR

Continuo la serie dei post che riguardano i miei cotributi allo sviluppo di Parancoe.

Come ho già ricordato, Parancoe è una libreria pensata per lo sviluppo di applicazioni web che permetta allo sviluppatore di concentrarsi sul codice e lasciar stare la configurazione.

Se volete partecipare, andate a visitare il sito.

Quello di cui mi sto occupando in questo periodo è l'integrazione nel meccanismo DWR (Direct web remoting) nel processo di validazione dei dati.

DWR è un framework che rende semplice l'integrazione della tecnologia AJAX all'interno di applicazioni Java. In particolare propone un'ottima integrazione con Spring, sul quale Parancoe si basa.

L'idea che è venuta al team di Parancoe è di usare DWR per richiamare la validazione via javascript.

Supponiamo di avere una form di inserimento dati. Attualmente la validazione di questa form avviene solo lato server.

Utilizzando DWR si potrebbe validare il campo appena questo è stato editato, risparmiando all'utente l'invio di una form sintatticamente non corretta.

Le operazioni da fare per l'integrazione di DWR con la libreria di validazione di Parancoe sono:

1. Definire un entry point unico richiamabile via Ajax
2. Integrare la configurazione di DWR all'interno di Parancoe in modo che lo sviluppatore trovi DWR già attivo di default
3. Definire un custom tag da usare all'interno della JSP che integri la chiamata a DWR senza che lo sviluppatore debba scrivere codice javascript

In questo post mi concentrerò sul primo punto.

DWRValidator

Il meccanismo di validazione di Parancoe si basa sulla libreria springmodules-validator. Per chi fosse interessato ad una descrizione di tale libreria, rimando al post Validazione in Parancoe.

La classe che compie la validazione è la classe BeanValidator. Tale classe eredita da Validator che mette a disposizione un metodo di validazione la cui firma è:

/**
* Applies all validation rules as defined in the
* {@link org.springmodules.validation.bean.conf.
* BeanValidationConfiguration}
* retrieved for the given bean from the configured
* {@link org.springmodules.validation.bean.conf.loader.
* BeanValidationConfigurationLoader}.
*
* @see Validator#validate(Object, org.springframework.validation.Errors)
*/
public void validate(Object obj, Errors errors) { ... }

Questo metodo si aspetta un'istanza dell'oggetto da validare (obj), istanza creata da Spring a partire dai dati inseriti nella form. La firma di questo metodo non lo rende facilmente integrabile con DWR.

Per poter integrare DWR è necessario creare una classe che esponga un metodo la cui firma preveda come attributi degli oggetti di tipo stringa. Una sorta di:

public String validateDWR(String beanId,
String propertyName,
String propertyValue)

L'idea è quindi quella di ricondursi alla validazione di springmodules passando per il metodo validateDWR. A questo scopo, un metodo interessante di BeanValidator è il seguente:

/**
* Applying the given validation rules on the given property of
* the given object.
* The validation stops as soon as one of the validation rules
* produces validation errors.
* This errors are then registered with the given {@link Errors)
* instance.
*/
protected void validateAndShortCircuitRules(ValidationRule[] rules,
String propertyName, Object obj, Errors errors)

Questo metodo si aspetta sempre un'istanza dell'oggetto in esame, ma si limita a validarne una singola property. Si potrebbe quindi creare un'istanza dell'oggetto in esame e settarne la singola property (propertyName) con il valore passato in ingresso (propertyValue).

Il problema adesso si sposta nella inizializzazione dell'oggetto sotto esame. L'obbiettivo è di non dover creare un metodo per ogni oggetto che dovrà essere validato. A questo scopo ci viene in aiuto il terzo parametro del metodo prototipato inizialmente, ovvero beanId.

Il valore che assume beanId, come ci si può aspettare è il nome dell'oggetto come viene definito nel file di configurazione di Parancoe. Tutti i bean registrati in quel file sono consultabili andando ad interrogare l'application context di Spring.

La classe che esporrà il metodo validateDWR dunque estenderà da BeanValidator per avere il metodo validateAndShortCircuitRules e implementerà l'interfaccia ApplicationContextAware che le permette di avere il contesto di Spring da analizzare.

I passi per una possibile implementazione della classe di validazione con dwr saranno dunque:

Recupero del tipo del bean dal contesto di Spring

// recupero la classe del bean da validare
Class clazz = applicationContext.getBean(beanId).getClass();

// carico le regole di validazione per la classe in esame
BeanValidationConfiguration configuration =
configurationLoader.loadConfiguration(clazz);

// recupero le regole di validazione per la property in input
ValidationRule[] rules = configuration.getPropertyRules(propertyName);

Asseganzione del valore in input alla property

// mi creo un'instanza dell'oggetto in esame a cui assegno
// propertyValue
Object obj = clazz.newInstance();
BeanWrapper wrapper = new BeanWrapperImpl(obj);
PropertyValue val = new PropertyValue(propertyName, propertyValue);
wrapper.setPropertyValue(val);

//Mi creo un oggetto dove mettere gli eventuali errori
Errors errors = new BeanPropertyBindingResult(obj, beanId);

Validazione

//compio la validazione
validateAndShortCircuitRules(rules, propertyName, obj, errors);

return getValidationMessage(errors, propertyName);

La classe va un po' sgrezzata, però è già funzionante (almeno per i tipi String, per altri tipi di oggetti, come le date non è ancora pronta).

Allegato al post trovate uno zip contenente un progetto maven con il sorgente della classe e un piccolo testcase.