JAVA, ROO, Spring, Uncategorized

[Tips] Recuperare beans, risorse e altro da spring 3

Questa mini guida illustrerà i vari modi in cui è possibile recuperare risorse varie che sono presenti in spring.

Supponendo che il nostro classpath abbia la seguente gerarchia: src > main > resources >META-INF > spring, come definito all’interno dei progetti creati con ROO 1.0.2.

Recuperare l’applicationContext.xml

private static final String urlApplicationContext = “META-INF//spring//applicationContext.xml”;

oppure

private static final String urlApplicationContext = “classpath:META-INF/spring/applicationContext.xml”;

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(urlApplicationContext);

In questo modo ottengo un oggetto ClassPathXmlApplicationContext che ci permette di gestire gli elementi che sono stati definiti all’interno dell’applicationContext.xml, oltre ad avere la possibilità di gestione del context di spring.

Recuperare un bean dall’applicationContext.xml

Semplicemente si dovrà instanziare il context descritto all’inizio e richiamare il bean tramite il suo ID:

Person p = (Person) context.getBean(“Id del Bean”);

Recuperare un file dal classpath

Per recuperare un file che sappiamo sia presente all’interno del nostro classpath basterà fare.

private static final String urlClasspathSpringOXM = “classpath:META-INF//spring//”;
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(urlApplicationContext);
Resource resource = context.getResource(urlClasspathSpringOXM+filename);
Il metodo getResource, restituisce l’oggetto Resource relativo al file a cui stiamo puntando. Ed effettuare una serie di operazioni su di esso come ad esempio la richiesta di informazioni sul suo nome, o sulla possibilità di poterlo leggere, oppure richiamare il metodo getFile() che restituisce un oggetto di tipo FILE, che ci permette di lavorare sul file.
Annunci
JAVA, ROO, Spring, Uncategorized, Validation

[Guida] Validazione con Spring 3

All’interno di Spring 3 è stato notevolmente potenziato il sistema di validazione, portandolo a recepire la JSR-303 (che si occupa proprio di definire le specifiche del bean validator).

Link di Interesse

Prima di cominciare voglio presentare alcuni link molto utili che possono servire per la consultazione:

Utilizzo Base del Validation

Utilizzando ROO 1.0.2, di default ti permette di creare BEAN che utilizzino la JSR-303 e le specifiche di ejb 3.

Ad esempio è possibile avere il seguente bean:

public class Utente {
// Impone che il campo sia not null
@NotNull
private String nome;
// Il valora del campo deve seguire  il patter della espressione regolare
@Pattern(regexp=”[a-z]+”)
private String gruppo;
// il valore del campo deve seguire la espressione regolare standard per l’email
@email
private String email;
}

Questa impostazione del bean ci permette di utilizzare da subito il validation integrato in spring, in modo da eseguire un controllo immediato sulla consistenza dei campi del bean.
Ad esempio è possibile creare un controller del tipo:

@RequestMapping(value = “/utente”, method = RequestMethod.POST)

public String UtenteController.create(@Valid Utente utente, BindingResult result, ModelMap modelMap) {

if (utente == null) throw new IllegalArgumentException(“A utente is required”);

if (result.hasErrors()) {

modelMap.addAttribute(“utente”, utente);

……

……

return “utente/create”;

}

utente.persist();

return “redirect:/utente/” + utente.getIdUtente();

}

Questo esempio di controller utilizza l’annotation javax.validation.Valid “@Valid” che permette di verificare che l’oggetto relativo (Utente) inviato da un form ipotetico, segua le indicazioni definite all’interno del bean. l’esempio ci mostra come utilizzare da subito la validazione, ma purtroppo ha dei limiti legati al fatto che cosi com’è stato definito il bean può coprire solo una parte delle specifiche di bussiness.

Validatore Personalizzato

Per poter implementare un proprio validation è necessario:

1 – Definire all’interno dell’applicationContext.xml i bean che abilitano il validation personalizzato

<!–     Invokes Spring MVC @Controller methods –>

<bean class=”org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter”>

<property name=”webBindingInitializer”>

<!– Configures Spring MVC DataBinder instances –>

<bean class=”org.springframework.web.bind.support.ConfigurableWebBindingInitializer”>

<property name=”validator” ref=”validator” />

</bean>

</property>

</bean>

<!– Creates the JSR-303 Validator –>

<bean id=”validator” class=”com.springsource.roo.pizzashop.validation.UtenteValidator” />

2 – Creare la classe “UtenteValidator” (definita all’interno dell’applicationContext) che permette di sviluppare la nostra validazione personalizzata.

public class UtenteValidator implements Validator{

@Override

public boolean supports(Class clazz) {

return Utente.class.isAssignableFrom(clazz);

}

@Override

public void validate(Object target, Errors errors) {

System.out.println(“Sono dentro il validator”);

// Validazione del campo Utente.nome tramite le Utils di Validation

ValidationUtils.rejectIfEmptyOrWhitespace(errors, “nome”, “error.utente.vuoto”, “Il campo utente e’ richiesto”);

// Validazione personalizzata per l’oggetto utente ed le sue proprietà in

// questo modo posso implementare le logiche di bussiness come Utente utente = (Utente)target;

if( (utente.getNome().equals(“”)) && utente.getGruppo().equals(“”) ){

errors.rejectValue(“gruppo”, “error.utente.gruppo”);

}

}

}

All’interno della classe abbiamo fatto l’override di due metodi:

  • supports: dove posso specificare a quale classe associare il mi validator;
  • validate: dove implemento i vari controlli che devo eseguire sui campi, e le relative logiche.

Il nostro controller visto precedentemente deve cambiare nel seguente modo:

@RequestMapping(value = “/utente”, method = RequestMethod.POST)

public String UtenteController.create(@ModelAttribute(“utente”) Utente utente, BindingResult result, ModelMap modelMap) {

if (utente == null) throw new IllegalArgumentException(“A utente is required”);

// Chiamo il validatore per l’oggetto utente

validator.validate(utente, result);

if (result.hasErrors()) {

modelMap.addAttribute(“utente”, utente);

return “utente/create”;

}

utente.persist();

return “redirect:/utente/” + utente.get_id();

}

I cambiamenti più vistosi (segnati in grassetto) sono:

  • la presenza del @ModelAttribute al posto del @Valid, che permette di catturare l’oggetto inviato da un form senza però eseguire il validator integrato;
  • validator.validate: che permette di chiamare il validator personalizzato che abbiamo creato inviando l’oggetto da verificare

3 – La pagina con la quale comunicherà il nostro controller sarà composta nel seguente modo:

<spring:url value=”/utente” var=”form_url”/>

<form:form action=”${form_url}” method=”POST” modelAttribute=”utente”>

<form:errors cssClass=”errors” delimiter=”&lt;p/&gt;”/>

<div id=”roo_utente_nome”>

<label for=”_nome_id”>Nome:</label>

<form:input cssStyle=”width:250px” id=”_nome_id” maxlength=”30″ path=”nome” size=”0″/>

<br/>

<form:errors cssClass=”errors” id=”_nome_error_id” path=”nome”/>

</div>

<br/>

<div id=”roo_utente_gruppo”>

<label for=”_gruppo_id”>Gruppo:</label>

<form:input cssStyle=”width:250px” id=”_gruppo_id” maxlength=”30″ path=”gruppo” size=”0″/>

<br/>

<form:errors cssClass=”errors” id=”_gruppo_error_id” path=”gruppo”/>

</div>

<br/>

<div id=”roo_utente_email”>

<label for=”_id_email”>email:</label>

<form:input cssStyle=”width:250px” id=”_id_email” maxlength=”30″ path=”email” size=”0″/>

<br/>

<form:errors cssClass=”errors” id=”_email_error_id” path=”email”/>

</div>

<br/>

<div class=”submit” id=”roo_utente_submit”>

<input id=”proceed” type=”submit” value=”Salva”/>

</div>

</form:form>

La nostra pagina utilizza i tag di spring, quali:

  • form =  dove si definisce il bean che deve essere associato al form stesso;
  • form:input = il campo input che rappresenta una della proprietà del mio bean;
  • form:error = Questo tag è molto importante per la validazione, in quanto mostra a video la label di errore che viene viene generata dalla nostra classe di validazione.

JAVA, ROO, Spring, Uncategorized

Prendere un bean in global session da spring mvc 3

In spring è possibile salvare oggetti o come nel mio caso dei bean all’interno della sessione o della global session di spring.

In questo caso definiamo il bean all’interno del file application-context.xml

<!– Create a proxy to generate session-scoped infoUtente –>
<bean name=”infoUtenteSession” id=”infoUtente” scope=”globalSession”>
<!– This requires CGLIB –>
<aop:scoped-proxy/>
</bean>

Adesso dobiamo controllare che all’interno del file web.xml sia presente il seguente listener

<!– RequestContextListener serve per permettere di richiamare un sessionBean all’interno di springSecurity –>

<listener>
<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
</listener>

E all’interno del file pom.xml sia presente la chiamata alla libreria cglib

<dependency>
<groupId>cglib</groupId>
<artifactId>cglib-nodep</artifactId>
<version>2.2</version>
</dependency>

Per reperire queste informazioni all’interno dell’applicazione sarà sufficiente fare:

infoUtente=(InfoUtente) ContextLoader.getCurrentWebApplicationContext().getBean(“infoUtente”);

Qui potete trovare un link per maggiori informazioni:

http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/htmlsingle/spring-framework-reference.html#beans-factory-scopes-other

JAVA, ROO, Spring, Spring Security, Uncategorized

[spring security 3] FORM_LOGIN_FILTER personalizzato

In Spring Security è possibile personalizzare la procedura utilizzata per la fase di login.

Ridefinendo il filtro FORM_LOGIN_FILTER è possibile ridefinire il comportamento che terrà spring security per esempio nel caso in cui il login sia stato eseguito con successo oppure sia fallito.

All’interno del file applicationContext-security.xml

<!– HTTP security configurations –>
<http auto-config=”false” use-expressions=”true” entry-point-ref=”loginUrlAuthenticationEntryPoint”>

<custom-filter position=”FORM_LOGIN_FILTER” ref=”customUsernamePasswordAuthenticationFilter”  />
<!– Configure these elements to secure URIs in your application –>
<intercept-url pattern=”/choice/**” access=”hasRole(‘Admin’)”/>
<intercept-url pattern=”/member/**” access=”isAuthenticated()” />
<intercept-url pattern=”/resources/**” access=”permitAll” />
<intercept-url pattern=”/static/**” access=”permitAll” />
<intercept-url pattern=”/login/**” access=”permitAll” />
<intercept-url pattern=”/**” access=”isAuthenticated()” />
<logout logout-url=”/static/j_spring_security_logout” invalidate-session=”true” logout-success-url=”/index” />
</http>

<beans:bean id=”customUsernamePasswordAuthenticationFilter” class=”com.gruppomcr.xxx.service.CustomAuthenticationProcessingFilter” >
<beans:property name=”authenticationManager” ref=”authenticationManager” />
<beans:property name=”authenticationFailureHandler” ref=”failureHandler” />
<beans:property name=”authenticationSuccessHandler” ref=”successHandler” />
<beans:property name=”filterProcessesUrl” value=”/static/j_spring_security_check” />
<beans:property name=”allowSessionCreation” value=”true” />
</beans:bean>

La relativa classe CustomAuthenticationProcessingFilter permette di redefinire ad esempio:

  • Il comportamento nel caso in cui l’autenticazione sia andata a buon fine
  • Il comportamento nel caso in cui l’autenticazione sia fallita
  • il contenuto restituito dal metodo getDetails() all’interno del SecurityContext

public class CustomAuthenticationProcessingFilter extends UsernamePasswordAuthenticationFilter{

private UtenteSessionService utenteSessionService;

@Autowired

public void setUtenteService(UtenteSessionService utenteSessionService){

this.utenteSessionService = utenteSessionService;

}

@Override
// successfulAuthentication: E’ possibile definire le operazioni da effettuare subito dopo che l’autenticazione ha avuto successo
protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, Authentication authResult)

throws IOException, ServletException {

super.successfulAuthentication(request, response, authResult);

String password = request.getParameter(“j_password”);

String utenza = request.getParameter(“j_username”);

System.out.println(“==successful login== pass=== “+password+” utenza=== “+utenza);

SecurityContext securityContext = SecurityContextHolder.getContext();

System.out.println(“securityContext.getAuthentication().getAuthorities():     “+securityContext.getAuthentication().getAuthorities().toString());

System.out.println(“securityContext.getAuthentication().getPrincipal():     “+securityContext.getAuthentication().getPrincipal().toString());

System.out.println(“securityContext.getAuthentication().getDetails():     “+securityContext.getAuthentication().getDetails().toString());

System.out.println(“successfulAuthentication — STO PER CHIAMARE L’INIZIALIZZAZIONE”);

}

@Override

protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException {

super.unsuccessfulAuthentication(request, response, failed);

System.out.println(“==failed login==”);

}

@Override

protected void setDetails(HttpServletRequest request, UsernamePasswordAuthenticationToken authRequest) {

System.out.println(“Sto chiamando set details”);

super.setDetails(request, authRequest);

Map<String, String > m = new HashMap<String, String>();

m.add(“info1″,”valore1”);

m.add(“info2″,”valore2”);

authRequest.setDetails(m);

}

}

All’interno del metodo successfulAuthentication è presente la stringa SecurityContext securityContext = SecurityContextHolder.getContext(); e la successiva stringa  securityContext.getAuthentication() che permette di reperire il corrente l’oggetto principal autenticato. Grazie a questa classe statica è possibile richiamare:

  • getAuthorities() : che restituisce la lista dei ruoli associati all’user di spring security;
  • getPrincipal() : restituisce l’oggetto UserDetails presente in sessione;
  • getDetails() : restituisce l’oggetto Details che di default ha le info sull’ip e il webservice.

La classe statica SecurityContextHolder è possibile richiamarla nel seguente modo ad esempio:
SecurityContextHolder.getContext().getAuthentication().getPrincipal(), tranquillamente all’interno dell’ambiente spring.

Sempre all’interno della classe è stato ridefinito il metodo setDetails() che permette di ridefinire le informazioni che vengono reperite da getDetails() detto precedentemente, nel nostro esempio è stato salvato una mappa con dei valori personali.

Qui è presente un link per maggiori chiarimenti:

http://static.springsource.org/spring-security/site/docs/3.0.x/reference/ns-config.html

Hibernate, JAVA, ROO, Spring, Spring Security, Uncategorized

Come creare un authentication-provider personalizzato con spring security 3 e Hibernate

All’interno di Spring Security è possibile definire il modo in cui quest’ultimo deve interagire con le informazioni utente per il loro reperimento e i successivi controlli per il login, in poche parole configurare il meccanismo di autenticazione.

La parte dedicata a ciò è l’authentication-manager che si trova dentro il file applicationContext-security.xml.

<!– Configure Authentication mechanism –>
<authentication-manager alias=”authenticationManager”>
<authentication-provider user-service-ref=”CustomUserServiceDetails”/>
</authentication-manager>
All’interno possiamo trovare il tag authentication-provider che ci permette la definizione di quale tecnologia dobbiamo utilizzare per gestire l’autenticazione, ad esempio tramite jdbc o ldap.

Nel nostro caso invece vogliamo ridefinire tutto il processo di autenticazione o meglio personalizzarlo in modo che reperisca le informazioni direttamente da Hibernate e creando nuovi ruoli legati all’utente che ci permettano di rendere la navigazione di quest’ultimo più semplice utilizzando direttamente gli strumenti nativi.

Nel tag authentication-provider è presente l’attributo user-service-ref che permette di refenziare un classe definita all’interno di spring security, nel nostro caso ad esempio:

<beans:bean id=”CustomUserServiceDetails” class=”com.gruppomcr.xxx.security.CustomUserServiceDetailsImpl” />

La classe CustomUserServiceDetailsImpl implementa l’interfaccia UserDetailsService che permette di redifinire il metodo loadUserByUsername, questo metodo ci permette di:
  • reperire le informazioni sulla username dell’utente che si stà loggando
  • personalizzare le informazioni che verranno salvate nell’oggetto UserDetails all’interno della sessione di spring security
  • utilizzare le informazioni personalizzate per meglio utilizzare gli strumenti nativi che ci offre spring

Continua a leggere

JAVA, ROO, Spring

@DateTimeFormat – Formattare la data con le Spring Annotation

All’interno del progetto stò utilizzando spring 3 mvc e hibernate 3.

Una delle maggiori noie e proprio legato alla formattazione della data, per ovviare a ciò è possibile utilizzare una annotations nativa di spring 3 che si chiama @DateTimeFormat.

Il suo utilizzo è molto semplice e qui riporto una parte di codice per esempio

@Temporal(TemporalType.DATE)
@Column(name = “DATA_NASCITA”, nullable = false, length = 10)
@DateTimeFormat(pattern=”dd/MM/yyyy”)
public Date getDataNascita() {
return this.dataNascita;
}
public void setDataNascita(Date dataNascita) {
this.dataNascita = dataNascita;
}

Trai i parametri che è possibile passare a @DateTimeFormat è presente “pattern” che permette di definire un pattern che dovrà seguire la data quando sarà ottenuta dal db, nel caso di esempio e proprio quello legato alla data europea.

Questa annotation è derivata dal progetto joda time, le cui api sono presenti al seguente sito: http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html

Dojo, ROO, Spring

[roo dijit] RegExp e Trim su dijit.form.ValidationTextBox

Il progetto su cui sto lavorando e derivato da spring Roo 2.3.2, il quale permette di generare automaticamente dei controlli Js con DOJO, per validare i dati inserite all’interno di un form.

Ed è stato proprio dojo e nella fattispecie dijit che mi ha dato non poche grane.

Per effettuare un controllo su di un campo email, grazie ad una espressione regolare è sufficente utilizzare la seguente sintassi:

<script type=”text/javascript”>
dojo.require(“dojox.validate.regexp”);
Spring.addDecoration(new Spring.ElementDecoration({elementId : ‘_email_id’, widgetType : ‘dijit.form.ValidationTextBox’, widgetAttrs : {promptMessage: ‘${field_validation}’, invalidMessage: ‘${field_invalid}’, regExp: “[a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}” ,required : false}}));
</script>

Le parti più importanti sono quelle in grassetto dove nella prima parte di richiama la componente di dojo che permette di utilizzare le regular expression, mentre nella seconda parte di utilizza direttamente la regular espression desiderata (nella fattispecie un controllo banale sull’email).

Mentre se si vuole inserire un controllo che permette di eliminare gli spazi vuoti è sufficiente utilizzare il trim: true

<script type=”text/javascript”>

Spring.addDecoration(new Spring.ElementDecoration({elementId : ‘_nome_id’, widgetType : ‘dijit.form.ValidationTextBox’, widgetAttrs : {promptMessage:’${field_validation}’, invalidMessage: ‘${field_invalid}’, required : false, trim:true}}));

</script>