Errore schemaLocation: ... must have even number of URI's

Nei file xml di spring la voce xsi:schemaLocation specifica dove trovare gli xsd per i namespace definiti prima nel file.
Esempio:

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:jdbc="http://www.springframework.org/schema/jdbc"
 xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:batch="http://www.springframework.org/schema/batch"
 xmlns:context="http://www.springframework.org/schema/context"
 
 xsi:schemaLocation="http://www.springframework.org/schema/jdbc 
     http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd
  http://www.springframework.org/schema/beans 
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context
  http://www.springframework.org/schema/context/spring-context-4.0.xsd">

In questo caso su alcuni namespace è definita la locazione dell'xsd (non è obbligatorio che ci siano tutti).
E' però importante che le dichiarazioni seguano questo schema [NAMESPACE] [XSD_NAMESPACE], quindi il numero totale di dichiarazioni dovrà essere pari.

Se proviamo a cancellare una di queste voci allora apparirà l'eccezione

Error schemaLocation:....... must have even number of URI's

Spring esternalizzare configurazioni datasource e cifrare password

Scenario: abbiamo una applicazione Java che si connettead un db utilizzando Spring, vogliamo fare in modo che i dati della connettività siano spostati dal file di contesto di Spring ad un normale file di properties esterno al jar, in modo che l'utente possa personalizzarlo a seconda dell'ambiente di esecuzione senza dover toccare il file specifico del context di Spring.
Nel file di configurazione di Spring è possibile definire la seguente proprietà:

<context:property-override location="file:conf/db.properties"/>

Il file è letto in un percorso esterno rispetto al jar di esecuzione, come specificato appunto dalla direttiva file.

Il file esterno avrà una struttura di questo tipo (quella tipica di un file di properties):

dataSource.url=jdbc:sqlserver://localhost:1433;dataBaseName=hibernatetest
dataSource.username=pippo
dataSource.password=m4dr+75TW7u0nWFUU52IaQ==

Quindi nell'applicationContext.xml avremo la seguente definizione del dataSource:

 <bean id="dataSource"
  class="it.dao.BasicDataSourceCifrato">
  <property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver" />
  <property name="url" value="${dataSource.url}" />
  <property name="username" value="${dataSource.username}" />
  <property name="password" value="${dataSource.password}" />
  <property name="initialSize" value="5"></property>
  <property name="maxActive" value="10"></property>
 </bean>

Il datasource è stato ridefinito estendendo  org.apache.commons.dbcp.BasicDataSource .
In questo modo possiamo effettuare la ridefinizione del metodo setPassword inserendo la decifratura della password:

package it.dao;
import it.oasi.cipher.Cifratura;
import org.apache.commons.dbcp.BasicDataSource;
public class BasicDataSourceCifrato extends BasicDataSource {
 public BasicDataSourceCifrato() {
 }
 public synchronized void setPassword(String password) {     
        super.setPassword(decryptPassword(password));
    }
 private String decryptPassword(String password) { 

          // qui si inserisce la logica di decifratura pwd

          ...... 
 }

}

Spring Jdbc Template

In alcuni casi particolari risulta molto utile utilizzare per l'accesso al DBMS JDBC invece degli ORM (Hibernate,EBatis etc.), soprattutto in ambienti legacy dove il database è già esitente e non ottimizzato per l'utilizzo degli ORM.
Il problema di JDBC è comunque l'eccessiva verbosità del codice che ci costringe a gestire l'apertura delle connessioni, la chiusura, i PreparedStatement etc.
Una soluzione ideale in questo ambito è Spring Jdbc, che con il modello dei template ci esenta dal dover gestire manualmente il "plumbing code" JDBC.

Vediamo i passi da seguire per realizzare una applicazione client che si connette ad un db.

LIBRERIE

Ho utilizzato in questo caso spring 3.0
Le dipendenze maven sono le seguenti:

<properties>
 <org.springframework.version>3.0.0.RELEASE</org.springframework.version>
</properties>
 <dependencies>

  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-core</artifactId>
   <version>${org.springframework.version}</version>
  </dependency>
  <dependency>

   <groupId>org.springframework</groupId>

   <artifactId>spring-jdbc</artifactId>

   <version>${org.springframework.version}</version>

  </dependency>
  <dependency>
   <groupId>commons-dbcp</groupId>
   <artifactId>commons-dbcp</artifactId>
   <version>1.2.2</version>
  </dependency>
  <dependency>
   <groupId>commons-pool</groupId>
   <artifactId>commons-pool</artifactId>
   <version>1.4</version>
  </dependency>

 </dependencies>

FILE DI CONFIGURAZIONE

Il file di configurazione del context di Spring:

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
 xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
 xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:task="http://www.springframework.org/schema/task"
 xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd">


 <bean id="adUserDao" class="it.dao.AdUserDaoImpl">
  <property name="dataSource" ref="dataSource" />
 </bean>

 <bean id="dataSource"
  class="org.apache.commons.dbcp.BasicDataSource">

  <property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver" />
  <property name="url" value="jdbc:sqlserver://localhost:1433;dataBaseName=hibernatetest" />
  <property name="username" value="pippo" />
  <property name="password" value="pippo" />
  <property name="initialSize" value="5"></property>
  <property name="maxActive" value="10"></property>
 </bean>
 
</beans>

TABELLA

La tabella su cui si scrive e si legge ha il seguente script di creazione (DBMS Sql server versione 2008):

CREATE TABLE [dbo].[aduser](
 [id] [bigint] IDENTITY(1,1) NOT NULL,
 [name] [varchar](255) NOT NULL,
 [password] [varchar](255) NOT NULL,
 CONSTRAINT [PK_aduser] PRIMARY KEY CLUSTERED 
(
 [id] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]

INTERFACCIA ADUSERDAO

package it.dao;
import java.util.List;
import it.objects.AdUser;
public interface AdUserDao {
 
 public boolean insert(AdUser obj) throws DaoException ;
 
 public AdUser getUserById(int id) throws DaoException;
 
 public List<AdUser> getListaUtenti() throws DaoException;

}

CLASSE ADUSER 

package it.objects;
public class AdUser {
 private static final String A_CAPO = "\r\n";
 private int id;
 private String nome;
 private String password;
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 public String getNome() {
  return nome;
 }
 public void setNome(String nome) {
  this.nome = nome;
 }
 public String getPassword() {
  return password;
 }
 public void setPassword(String password) {
  this.password = password;
 }
 public AdUser(){
  
 }
 public AdUser(String nome,String password){
  this.nome=nome;
  this.password=password;
  
 }
 public String toString(){
  StringBuffer sb=new StringBuffer();
  sb.append("ID: ");
  sb.append(this.id);
  sb.append(A_CAPO);
  sb.append("NOME: ");
  sb.append(this.nome);
  sb.append(A_CAPO);
  sb.append("PWD: ");
  sb.append(this.password);
  sb.append(A_CAPO);
  return sb.toString();
 }
}

IMPLEMENTAZIONE DAO 

package it.dao;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import it.objects.AdUser;
public class AdUserDaoImpl implements AdUserDao {
 private DataSource dataSource;
 private JdbcTemplate jdbcTemplate;
 public DataSource getDataSource() {
  return dataSource;
 }

 public void setDataSource(DataSource dataSource) {
  this.dataSource = dataSource;
 }

 public AdUserDaoImpl() {
  // TODO Auto-generated constructor stub
 }

 @Override
 public boolean insert(AdUser obj) throws DaoException {
  try
  {
   boolean retVal=false;
   jdbcTemplate=new JdbcTemplate(dataSource);
   String insert="insert into aduser(name,password) values (?,?)";
   int esito=jdbcTemplate.update(insert,new Object[]{obj.getNome(),obj.getPassword()});
   if(esito>0) retVal= true;
   return retVal;
  }
  catch(Exception ex){
   throw new DaoException("Errore nell'insert dettaglio "+ex.getMessage());
  }
 }

 @Override
 public AdUser getUserById(int id) throws DaoException {
  try
  {
   jdbcTemplate=new JdbcTemplate(getDataSource());
   String get="select id,name,password from aduser where id=?";
   AdUser retVal=jdbcTemplate.queryForObject(get,new Object[]{id}, new AdUserRowMapper());
   return retVal;
  }
  catch(Exception ex){
   throw new DaoException("Errore nel recupero dettaglio "+ex.getMessage());
  }
 }

 @Override
 public List<AdUser> getListaUtenti() throws DaoException {
  try
  {
   jdbcTemplate=new JdbcTemplate(getDataSource());
   String get="select id,name,password from aduser";
   List<AdUser> listaUtenti=new ArrayList<AdUser>();
   List<Map<String, Object>> rows =jdbcTemplate.queryForList(get);
    for (Map row : rows) {
     AdUser u=new AdUser();
     u.setId(Integer.parseInt(String.valueOf(row.get("ID"))));
     u.setNome((String)row.get("name"));
     u.setPassword((String)row.get("password"));
     listaUtenti.add(u);
    }
   return listaUtenti;
  }
  catch(Exception ex){
   throw new DaoException("Errore nel recupero dettaglio "+ex.getMessage());
  }
 }

}

ROWMAPPER 

Il RowMapper è una classe che implementa l'interfaccia di Spring org.springframework.jdbc.core.RowMapper e che serve a mappare il ResultSet con l'oggetto.

package it.dao;
import java.sql.ResultSet;
import java.sql.SQLException;
import it.objects.AdUser;
import org.springframework.jdbc.core.RowMapper;
public class AdUserRowMapper implements RowMapper<AdUser> {
 public AdUserRowMapper() {
  // TODO Auto-generated constructor stub
 }
 @Override
 public AdUser mapRow(ResultSet rs, int arg1) throws SQLException {
  // TODO Auto-generated method stub
  AdUser a=new AdUser();
  a.setId(rs.getInt("ID"));
  a.setNome(rs.getString("name"));
  a.setPassword(rs.getString("password"));
  return a;
 }

}

ESECUZIONE PROGRAMMA

 ConfigurableApplicationContext context=new ClassPathXmlApplicationContext("conf/applicationContext.xml");
   AdUserDao ad=(AdUserDao)context.getBean("adUserDao");
        AdUser user= ad.getUserById(1);
        System.out.println(user);
        List<AdUser> utenti=ad.getListaUtenti();
        for(AdUser a : utenti){
         System.out.println(a);
        }

        ad.insert(new AdUser("qweqw", "rrrrrrr"));
        context.close(); 

NOTE 

In questo caso abbiamo utilizzato la connessione da un pool gestito dalle librerie :

commons-dbcp-1.4.jar
commons-pool-1.4.jar

Si può anche decidere di utilizzare il DriverManagerDataSource di Spring che ci ritorna una connessione ogni volta che viene richiesta. Oppure il SingleConnectionDataSource che torna ogni volta la stessa connessione già utilizzata, come se si trattase di un pool di connessioni con size pari a 1.
Di seguito la configurazione per l'implementazione del DriverManagerDataSource:

<bean id="dataSource"
  class="org.springframework.jdbc.datasource.DriverManagerDataSource">

  <property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver" />
  <property name="url" value="jdbc:sqlserver://localhost:1433;dataBaseName=hibernatetest" />
  <property name="username" value="pippo" />
  <property name="password" value="pippo" />
 </bean>

Aggiungere repository Maven prime faces

Di seguito la struttura di un file pom utilizzato per utilizzare:

• jsf 2.0;
• primefaces 3.5;
• spring 3.0;
• javamail

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>test</groupId>
  <artifactId>webProva</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>test</name>
 <repositories>
  <repository>
<id>prime-repo</id>
<name>Prime Repo</name>
<url>http://repository.primefaces.org</url>
</repository>
</repositories>
  <dependencies>
  <dependency>
<groupId>org.primefaces</groupId>
<artifactId>primefaces</artifactId>
<version>3.5</version>
</dependency>
<dependency>
   <groupId>com.sun.faces</groupId>
   <artifactId>jsf-api</artifactId>
   <version>2.1.11</version>
  </dependency>
  <dependency>
   <groupId>com.sun.faces</groupId>
   <artifactId>jsf-impl</artifactId>
   <version>2.1.11</version>
  </dependency>
 

   <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>3.0.5.RELEASE</version>
   </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>3.0.5.RELEASE</version>
    </dependency>
     <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>3.0.5.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>3.0.5.RELEASE</version>
    </dependency>
    <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>3.0.5.RELEASE</version>
        </dependency>
        <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-web</artifactId>
 <version>3.0.5.RELEASE</version>
</dependency>
        <dependency> 
        <groupId>org.springframework</groupId> 
        <artifactId>spring-webmvc</artifactId> 
        <version>3.0.5.RELEASE</version>
         </dependency>
        <dependency>
 <groupId>javax.mail</groupId>
 <artifactId>mail</artifactId>
 <version>1.4</version>
</dependency>

  </dependencies>
</project>

Spring 3.0 ed Hibernate 3.2 su un progetto Java Standard

Oggi volevo provare ad utilizzare assieme Spring 3.0 e Hibernate 3.2 per sviluppare un progetto Java ed operare delle CRUD su una semplice tabella di Db.

Devo dire che ho trovato molte difficoltà soprattutto per quanto riguarda la configurazione dell’ambiente e dei jar necessari;  e cercando su internet ho notato che molta gente in rete lamentava i miei stessi problemi.

Trovo quantomeno singolare che nei siti specifici dei progetti non ci sia una paginetta che elenchi tutti i jar necessari per far funzionare Spring, forse sarà perché spesso Spring si utilizza all’interno di container web che al loro interno hanno già le librerie necessarie.

Alla fine dopo diverse “googlate” sono riuscito a configurare il tutto e a farlo funzionare.

Caso d’uso

Il db server utilizzato è MySql 5.5.15.

La tabella creata (Persona) ha la seguente ddl

	CREATE TABLE `persona` (   `idpersona` int(11) NOT NULL AUTO_INCREMENT,   `nome` varchar(45) DEFAULT NULL,   `cognome` varchar(100) DEFAULT NULL,   PRIMARY KEY (`idpersona`) )

Configurazione librerie di progetto

Di seguito riporto un elenco di tutti i jar necessari al progetto , ben 34 di cui 20 sono quelli presenti nella directory dist della distribuzione di Spring 3.0.6, 1 di hibernate 3.2, 1 è il connector J utilizzato per andare su Mysql e i restanti 12 jar servono invece a Spring per vari motivi (logging, transazionalità ecc. ecc.).

Come ide di sviluppo ho utilizzato Eclipse Indigo ed ho messo tutti i jar in una directory lib del progetto che ho quindi aggiunto nel classpath (tasto destro sul progetto,Properties/ java/build path /Libraries/Add Library)

antlr-2.7.5H3.jar

cglib-nodep-2.2.jar

commons-collections-3.1.jar

commons-logging-1.1.1-javadoc.jar

commons-logging-1.1.1-sources.jar

commons-logging-1.1.1.jar

commons-logging-adapters-1.1.1.jar

commons-logging-api-1.1.1.jar

commons-logging-tests.jar

dom4j-1.6.1.jar

ehcache-1.2.3.jar

hibernate-3.2.0.cr2.jar

jta.jar

mysql-connector-java-3.1.14-bin.jar

org.springframework.aop-3.0.6.RELEASE.jar

org.springframework.asm-3.0.6.RELEASE.jar

org.springframework.aspects-3.0.6.RELEASE.jar

org.springframework.beans-3.0.6.RELEASE.jar

org.springframework.context-3.0.6.RELEASE.jar

org.springframework.context.support-3.0.6.RELEASE.jar

org.springframework.core-3.0.6.RELEASE.jar

org.springframework.expression-3.0.6.RELEASE.jar

org.springframework.instrument-3.0.6.RELEASE.jar

org.springframework.instrument.tomcat-3.0.6.RELEASE.jar

org.springframework.jdbc-3.0.6.RELEASE.jar

org.springframework.jms-3.0.6.RELEASE.jar

org.springframework.orm-3.0.6.RELEASE.jar

org.springframework.oxm-3.0.6.RELEASE.jar

org.springframework.test-3.0.6.RELEASE.jar

org.springframework.transaction-3.0.6.RELEASE.jar

org.springframework.web-3.0.6.RELEASE.jar

org.springframework.web.portlet-3.0.6.RELEASE.jar

org.springframework.web.servlet-3.0.6.RELEASE.jar

org.springframework.web.struts-3.0.6.RELEASE.jar

Configurazione xml di Spring e Hibernate

Ho quindi aggiunto una directory xml all’interno del progetto dove sono presenti i seguenti 3 file xml:

·         spring.xml, per definire i bean utilizzati da Spring;

·         hibernate.cfg.xml, per definire la session factory di hibernate e per mappare le risorse;

·         persona.hbm.xml l’hbm che definisce le mappature tra oggetto e tabella.

Spring.xml

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"        xsi:schemaLocation="http://www.springframework.org/schema/beans              http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">        <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">        <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>        </bean>        <bean id="personaDao" class="it.test.daoImpl.SpringHibernatePersonaDaoImpl">        <property name="sessionFactory" ref="sessionFactory"></property>        </bean> </beans>

Qui ho  definito la sessionFactory di Hibernate, specificando che i valori di configurazione devono essere presi dal file hibernate.cfg.xml che si trova sul classpath, e quindi il bean utilizzato per le operazioni di CRUD sulla tabella,  a cui ho iniettato la sessionFactory (come si vedrà dopo è una DI via set della proprietà e non via costruttore).

Hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory>  <!-- Database connection settings -->         <property name="connection.driver_class">com.mysql.jdbc.Driver</property>         <property name="connection.url">jdbc:mysql://localhost:3306/test</property>        <property name="connection.username">root</property>         <property name="connection.password">root</property>         <!-- JDBC connection pool (use the built-in) -->        <property name="connection.pool_size">1</property>        <!-- SQL dialect -->         <property name="dialect">org.hibernate.dialect.MySQLDialect</property>        <!-- Echo all executed SQL to stdout -->        <property name="show_sql">true</property>  <!-- Mapping files --> <mapping resource="persona.hbm.xml"/> </session-factory> </hibernate-configuration>

Persona.hbm.xml

Di seguito l’hbm che mappa la tabella

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="it.test.oggetti"> <class name="Persona" table="persona"> <id name="id" type="long" unsaved-value="null" >     <column name="idpersona" not-null="true"/>     <generator class="identity"/>  </id> <property name="nome" type="string"> <column name="nome" length="45"></column> </property> <property name="cognome" type="string"> <column name="cognome" length="100"></column> </property> </class> </hibernate-mapping>

NB: si noti la mappatura della Primary Key della tabella con generator class IDENTITY,  significa che il valore della chiave può non essere disponibile al momento dell’inserimento, in quanto generato nel commit dello statement SQL.  Questa caratteristica accomuna molti database, tra cui appunto MySql e Microsoft SQL Server, per Oracle si sarebbe dovuto usare SEQUENCE.

La classe Persona è un semplice POJO con le 3 proprietà id di tipo Long e nome e cognome di tipo Stringa.

L’ interfaccia di Business  per realizzare la CRUD sulla tabella è :

public interface PersonaDao {               public void store(Persona p);        public void delete(Long id);        public Persona findById(Long id);        public List<Persona> findAll(); }

Di seguito l’implementazione dell’interfaccia

public class SpringHibernatePersonaDaoImpl implements PersonaDao {

       private SessionFactory sessionFactory;

       public SpringHibernatePersonaDaoImpl(){

             Configuration conf=new Configuration().configure();

             sessionFactory=conf.buildSessionFactory();

       }

    public void setSessionFactory(SessionFactory sessionFactory){

       this.sessionFactory=sessionFactory;

    }

       @Override

       public void store(Persona p) {

             Session session=sessionFactory.openSession();

             Transaction tx=session.getTransaction();

             try

             {

                    tx.begin();

                    session.saveOrUpdate(p);

                    tx.commit();

             }

             catch(RuntimeException ex){

                    tx.rollback();

                    throw ex;

             }

             finally{

                    session.close();

             }

       }

       @Override

       public void delete(Long id) {

             Session session=sessionFactory.openSession();

             Transaction tx=session.getTransaction();

             try

             {

                    tx.begin();

                    Persona p=(Persona)session.get(Persona.class, id);

                    session.delete(p);

                    tx.commit();

             }

             catch(RuntimeException ex){

                    tx.rollback();

                    throw ex;

             }

             finally{

                    session.close();

             }

            

       }

       @Override

       public Persona findById(Long id) {

             Session session=sessionFactory.openSession();

             try

             {

                    Persona p=(Persona)session.get(Persona.class, id);

                    return p;

             }

             finally{

                    session.close();

             }

            

       }

       @Override

       public List<Persona> findAll() {

             Session session=sessionFactory.openSession();

             try

             {

                    Query q=session.createQuery("from Persona");

                    return q.list();

             }

             finally{

                    session.close();

             }

       }

}

A questo punto non resta che richiamare da un main il bean di Spring , in questo modo

ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml"); PersonaDao p=(PersonaDao)context.getBean("personaDao"); Persona p1=new Persona(); p1.setCognome("Bianchi"); p1.setNome("Mario"); p.store(p1); Persona p2=new Persona(); p2.setCognome("Rossi"); p2.setNome("Mario"); p.store(p2); Persona p3=new Persona(); p3.setCognome("Rossi"); p3.setNome("Mario"); p.store(p3); System.out.println(p.findAll());