Aop, Spring

[aop] warning no match for this type name Xlint:invalidAbsoluteTypeName

Questo errore molto stupido ma altrettanto noioso è dovuto ad una errata identificazione del pointcut.

un ottimo post che dà un ottimo spunto per la risoluzione è il seguente:

http://forum.springsource.org/showthread.php?36355-arning-no-match-for-this-type-name-Xlint-invalidAbsoluteTypeName

Annunci
Spring

[Spring MVC] Not returning json content – error Http 406

Una delle caratteristiche più fighe di spring mvc 3.x è sicuramente la possibilità di costruire in pochi passi un controller che possa rispondere in JSON, convertendo magare un pojo di dominio, per darlo poi in pasto al nostro client.

Tra le migliori e semplici guide sicuramente c’è http://www.mkyong.com/spring-mvc/spring-3-mvc-and-json-example/, se si vuole un esempio immediato.

Purtroppo può accadere di avere un errore che ci blocca subito ed è il seguente:

HTTP/1.1 406 Not Acceptable

Per risolvere questo problema ci sono validi post come ad esempio:

Nel caso questi post non risolvano il problema, allora il bug può essere più stupido di quello che si pensa, infatti è possibile che il pojo che si vuole parsare sia semplicemente vuoto.

@RequestMapping(value = "/{idAzienda}", method = RequestMethod.GET)
public @ResponseBody Azienda aziendaId(@PathVariable Integer idAzienda) {

Azienda azienda = new Azienda(); // ERROR POJO CAN?T BE EMPTY
// azienda.setId("0001"); this solve the 406 error
 return azienda;
 }

Per risolvere il problema basterà assicurarsi che il pojo che dovrà essere parsato non sia mai vuoto.

JAVA, Maven, Spring

Maven per usare Spring con la JSR-330

Per utilizzare Spring con le annotazioni standard JSR 330 e gestire il tutto tramite Maven è sufficente aggiungere le rispettive dipendenze prese da qui e qui, che, al momento, corrispondono a quanto segue.

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-context</artifactId>
   <version>3.1.3.RELEASE</version>
</dependency>
<dependency>
   <groupId>javax.inject</groupId>
   <artifactId>javax.inject</artifactId>
   <version>1</version>
</dependency>
Spring

[spring] caricare un file di properties dentro l’applicationContext.xml

L’utilizzo del file applicationContext è fondamentale quando si vuole utilizzare spring, purtroppo molte volte quando si lavora in team, è possibile che certe informazioni varino e perciò ogni volta che si commita un file, per cambiare ad esempio la configurazione del db, si avrà il file modificato ed avremmo problemi in fase di deploy.

Per evitare questi problemi è possibile appoggiarsi ad un file di properties, dove andremmo a depositare le stringhe di configurazione, o comunque tutte quelle configurazione che possono variare a seconda dell’utente.

Per prima cosa bisogna inserire all’interno del file applicationContext.xml

<context:property-placeholder
location="classpath:META-INF/spring/application.properties"/>

grazie a Spring è possibile utilizzare la parola chiave classpath: che ci permette di nascondere gran parte del percorso e andare direttamente al sodo.

Infatti il file application.properties è stato creato all’interno del progetto eclipse: ${nomeprogetto}\src\main\resources\META-INF\spring\application.properties e contiene le seguenti voci:

database.url=local:C:/Users/dlagos/Documents/workspace_repo/....

database.user=admin
database.password=admin

Utilizzeremmo ad esempio le informazioni dentro il file application properties per poi  inserire all’interno di un bean.

<bean id="PersistenceManager"
class="it.assetdata.aventinus.persistence.OrientPersistenceManager"
scope="session" lazy-init="true">
<property name="adminUserName" value="${database.user}">
</property>
<property name="adminUserPassword" value="${database.password}">
</property>
<property name="database" value="${database.url}"></property>
</bean>

Per maggiori informazioni: http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/beans.html#beans-classpath-scanning

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.
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, OXM, Spring, Uncategorized

[Mini Guida] Spring 3 OXM e jaxb2

Qui è presente la secondo parte dell’introduzione a Spring OXM

Come spiegato prima Spring OXM grazie alle sue interfacce, offre una facilità di utilizzo che per esempio si trasforma nella possibilità di utilizzare più tecnologie per gestire i file xml. Tra le quali:

  • jaxb2
  • xmlbeans
  • jibx
  • castor

Offrendo perciò ampia libertà allo sviluppatore di scegliere la tecnologia che ritiene più adatta, oppure di cambiare in corso d’opera tecnologia, con un semplicissimo cambiamento nei file di configurazione.

La scelta all’interno del mio progetto è caduta su jaxb2, sia perchè meglio documentato per la fase di start-up sia perchè è abbastanza affidabile.

1 – Per cominciare è necessario configurare il pom.xml aggiungendo le seguenti dipendenze

<!– Parte Dedicata alle dipendenze per la parte di OXM–>
<!– Con spring version pari a 3.0.0 –>
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.2</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-oxm</artifactId>
<version>${spring.version}</version>
</dependency>

2 – Configurare l’applicationContext.xml (nel mio progetto è presente all’interno di classpath:META-INF/spring/)

In grassetto appaiono le parti aggiunte alla definizione del tag BEANS

<beans xmlns=”http://www.springframework.org/schema/beans&#8221;

…….

xmlns:oxm=”http://www.springframework.org/schema/oxm&#8221;

xsi:schemaLocation=”http://www.springframework.org/schema/oxm

http://www.springframework.org/schema/oxm/spring-oxm-3.0.xsd“>

3 – Dichiarare sempre nell’applicationContext nuovi bean che ci permetteranno di utilizzare Spring OXM

<!– Parte Legata all’OXM –>

<bean id=”oxMapper” class=”it.mcr.gestionefir.util.oxm.service.OxMapperImpl”>

<property name=”marshaller” ref=”jaxbMarshaller” />

<property name=”unmarshaller” ref=”jaxbMarshaller” />

</bean>

<oxm:jaxb2-marshaller id=”jaxbMarshaller”>

<oxm:class-to-be-bound name=”it.mcr.gestionefir.util.oxm.beans.DipendenzaQualificaOxm” />

<oxm:class-to-be-bound name=”it.mcr.gestionefir.util.oxm.beans.QualificaOxm” />

</oxm:jaxb2-marshaller>

<bean id=”gestoreDipendenzaQualificaOxm” class=”it.mcr.gestionefir.util.oxm.service.GestoreDipendenzaQualifica” />

  • Il bean “oxMapper” mi permette di definire una classe che implementa l’interfaccia “OxMapper” contenente i due metodi per eseguire il marshaller e unmarshaller di spring oxm, queste due proprietà sono state innestate da un secondo bean “jaxbMarshaller”;
  • jaxbMarshaller” implementa la chiamata alla libreria jaxb ed inoltre permette di definire i bean (POJO) che devono essere utilizzati per effettuare la trasformazione/lettura in xml;
  • Il terzo bean “gestoreDipendenzaQualificaOxm” definize una classe di servizio che mi permette di definire un gestore per gli oggetti OXM creati in modo che siano creati e gestiti come singleton, per evitare di rubare troppe risorse nel caso di più chiamate all’oggetto.

4 – La classe OxMapperImpl, presente qui sotto presenta le parti fondamentali della classe, in grassetto sono presenti le parti più interessanti che permettono di scrivere e leggere un xml.

@Service(“oxMapper”)

public class OxMapperImpl implements OxMapper {

private static final Log LOG = LogFactory.getLog(OxMapperImpl.class);

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

private static final String urlFolderSpring = “src//main//resources//META-INF//spring//”;

private static final String urlClasspathSpringOXM = “classpath:META-INF//spring//”;

private Marshaller marshaller;

private Unmarshaller unmarshaller;

protected ClassPathXmlApplicationContext getClassPathXmlApplicationContext() {

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(urlApplicationContext);

System.out.println(context.CLASSPATH_URL_PREFIX);

return context;

}

public void writeObjectToXml(Object object, String filename) throws IOException {

FileOutputStream fos = null;

File file =  new File(urlFolderSpring+filename);

try {

fos = new FileOutputStream(file);

marshaller.marshal(object, new StreamResult(fos));

} catch (XmlMappingException e) {

System.err.println(“Xml-Serialization failed due to an XmlMappingException.”+ e);

} catch (IOException e) {

System.err.println(“Xml-Serialization failed due to an IOException.”+ e);

} finally {

if (fos != null) { fos.close(); }

}

}

public Object readObjectFromXml(String filename) throws IOException {

System.out.println(“sono dentro readObjectFromXml: “+filename);

FileInputStream fis = null;

ClassPathXmlApplicationContext context = getClassPathXmlApplicationContext();

Resource resource = context.getResource(urlClasspathSpringOXM+filename);

try {

fis = new FileInputStream(resource.getFile());

return unmarshaller.unmarshal(new StreamSource(fis));

} catch (IOException e) {

System.err.println(“Xml-Deserialization failed due to an IOException.”+e);

} finally {

if (fis != null) { fis.close();  }

}

return null;

}

}

5 – I bean pojo utilizzati sono “DipendenzaQualifica” che a sua volta contiene una lista di pojo “Qualifica”

NOTA: nei vari esempi che trovate in giro le annotation vengono messe direttamente sulla dichiarazione dei campi, purtroppo per vari motivi che non sono riuscito a risolvere, questo non mi è stato permesso ed ho dovuto ripiegare inserendoli direttamente nei getters del pojo. Comunque il loro funzionamento è lo stesso

// l’annotation @XmlRootElement permette di definire il nome del tag root, all’interno dell’xml in questo caso sarò lo stesso della classe

@XmlRootElement

public class DipendenzaQualificaOxm {

public DipendenzaQualificaOxm() {}

private String descrizione;

private List<QualificaOxm> listQualificaOxm;

public String toString(){

return “Descrizione file XML: “+descrizione+”Listato degli oggetti: “+listQualificaOxm;

}

// l’annotation @XmlElement(name=”qualifica”) permette di personalizzare il nome del tag corrispondente all’interno dell’xml, infatti senza questo annotation in automatico il tag prende la label del relativo campo pojo.

@XmlElement(name=”qualifica”)

public List<QualificaOxm> getListQualificaOxm() {

return listQualificaOxm;

}

// Getter and Setters

}

6 – Il bean Pojo qualifica

//

//l’annotation @XmlType(propOrder = {“appartenenza”,”formazioneGiocatore”}) permette di organizzare i campi, seguendo un’ordine prestabilito da noi.
@XmlType(propOrder = {“appartenenza”,”formazioneGiocatore”})
@XmlRootElement

public class QualificaOxm {

private int id;

private String name, table, appartenenza;

private Boolean formazioneGiocatore = false;

// l’annotation @XmlAttribute permette di definire una proprieta del pojo come attributo del tag root element,
// senza quest’ultimo la proprietà sarebbe stata trasformata in un elemento dell’xml

@XmlAttribute

public int getId() { return id; }

@XmlAttribute

public String getName() { return name; }

@XmlAttribute public String getTable() { return table; }

@XmlElement(name=”formazioneGiocatorePresente”)
public Boolean getFormazioneGiocatore() {return formazioneGiocatore; }

}

7 – La classe “GestoreDipendenzaQualifica” permette di gestire l’inizializzazione e il caricamento del bean DipendenzaQualifica, in modo che diventi un bean singleton.

@Service(“gestoreDipendenzaQualifica”)

public class GestoreDipendenzaQualifica {

private static String filename = “dipendenzaQualifica-oxm.xml”;

private DipendenzaQualificaOxm dipendenzaQualificaOxmRead;

public void initIstance() throws IOException {

dipendenzaQualificaOxmRead = (DipendenzaQualificaOxm) oxMapper.readObjectFromXml(filename);

}

public DipendenzaQualificaOxm getInstance() throws IOException{

if(dipendenzaQualificaOxmRead == null){

this.initIstance();

}

return dipendenzaQualificaOxmRead;

}

private OxMapper oxMapper;

@Autowired

private void setOxMapper(OxMapper oxMapper){

this.oxMapper = oxMapper;

}

}

8 – Simulazione di una chiamata

Per effettuare una chiamata dovremmo semplicemente effettuare un injection della classe “GestoreDipendenzaQualifica

all’interno della nostra classe obiettivo. Richiamandola nel seguente modo:

DipendenzaQualificaOxm dipendenzaQualificaOxm = null;

try {

dipendenzaQualificaOxm = (DipendenzaQualificaOxm) gestoreDipendenzaQualificaOxm.getInstance();

} catch (Exception e) {

e.printStackTrace();

}