[Java Spring + Hibernate] Difficoltà ad usare Hibernate su Spring

[AndreaNobili]

Ciao ragazzi,
sono veramente disperato (anzi molto peggio...)
Devo realizare un progetto universitario in Spring e che si interfacci ad un database MySql tramite Hibernate...ma stò incontrando notevoli difficoltà ad usare Hibernate su Spring...

vi spiego brevemente quello che fà attualmente il mio progetto (è un'applicazione web molto semplice concettualmente parlando): c'è una classe chiamata InsertpoiController che di fatto gestisce un form che permette agli utenti di inserire dei POI (Point Of Interest) in una tabella del DB.
Quando l'utente fà il submit del form i dati inseriti (nome, latitudine, longitudine, altitudine, etcetc) vengono memorizzati nelle variabili di istanza di un oggetto istanza di una certa classe POI e poi devono essere salvati sul DB usando Hibernate

Finchè si tratta di raccogliere i dati inseriti in un oggetto istanza della classe POI non ho problemi...il problema grosso sorge nel riuscire a memorizzarli nel DB usando Hibernate.

Allora...io che ho fatto:

1) Ho eseguito il mapping di Hibernate tra la classe POI e la relativa tabella del DB ed ho eseguito il mapping tra le variabili di istanza di tale classe e le rispettive colonne del DB

2) Ho creato un'interfaccia PoiDao che al momento dichiara un solo metodo astratto insert che permette di persistere nel DB l'oggetto poi che contiene i dati submittati dall'utente

3) Ho implementato tale interfaccia con la classe PoiHibernateDaoSupport che rappresenta un'implementazione del DAO specifica per usare Hibernate

4) Dentro la classe InsertPoiController (la classe controllore del form) ho inserito il riferimento ad un generico oggetto PoiDao ed il relativo metodo setter per permettere l'injection di un oggetto dao nella classe controllore così da poter permettere di usare tale oggetto dentro questa classe e persistere nel DB l'oggetto che contiene i dati inviati tramite forum.

5) Ho configurato il fil XML per eseguire l'injection del dao dentro al controllore del form e le injection usate per configurare JDBC ed Hibernate (per collegarsi al DB)

Il problema è che quando provo ad eseguire il mio progetto (che fino alla parte relativa alla raccolta dei dati inseriti nel form funziona perfettamente) NetBeans mi dà il seguente errore:

In-place deployment at /home/andrea/NetBeansProjects/InsertPOI/build/web
Initializing...
deploy?path=/home/andrea/NetBeansProjects/InsertPOI/build/web&name=InsertPOI&force=true failed on GlassFish v3
/home/andrea/NetBeansProjects/InsertPOI/nbproject/build-impl.xml:588: The module has not been deployed.
ERRORE NELLA COSTRUZIONE (tempo totale: 2 secondi)


In pratica ho le seguenti classi:

1) InsertPoiController: che gestisce il form. In questa classe voglio iniettare un oggetto DAO per poterlo usare all'interno del metodo onSubmit per salvare i dati presenti nel command object:

package controller;

import dao.PoiDao;
import dao.PoiHibernateDaoSupport;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.SimpleFormController;

import service.SavedService;

public class InsertpoiController extends SimpleFormController {

   private SavedService savedService;

   PoiDao dao;

   public void setPoiDao(PoiDao dao){
        this.dao = dao;
    }

    public void setSavedService(SavedService savedService){
    this.savedService = savedService;
}

    public InsertpoiController(){
        setCommandClass(POI.class);
        setCommandName("poi");
        setSuccessView("savedView");
        setFormView("dataInputView");
    }

    @Override
    protected ModelAndView onSubmit(Object command) throws Exception{
        POI poi = (POI) command;

        // HERE THE CODE TO PERSIST MY COMMAND OBJECT poi
        
        ModelAndView mv = new ModelAndView(getSuccessView());
        mv.addObject("savedMessage", savedService.printSaved(poi.getNome(), poi.getLat(), poi.getLon(), poi.getAlt(), poi.getTipologia(), poi.getWikiLink()));
        return mv;
    }
    
}

2) Classe POI che rappresenta il command object di Spring (l'oggetto che raccoglie i dati inseriti nel form) e su cui è stato fatto il mapping di Hibernate con la tabella del DB:

package controller;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import org.hibernate.annotations.Entity;

@Entity
@Table(name = "poi")

public class POI {

    @Id
    @Column(name = "nome")
    private String nome;

    @Id
    @Column(name = "lat")
    private float lat;

    @Id
    @Column(name = "lon")
    private float lon;

    @Id
    @Column(name = "alt")
    private float alt;

    @Column(name = "tipologia")
    private int tipologia;

    @Column(name = "wikiLink")
    private String wikiLink;

    public float getAlt() {
        return alt;
    }

    public void setAlt(float alt) {
        this.alt = alt;
    }

    public float getLat() {
        return lat;
    }

    public void setLat(float lat) {
        this.lat = lat;
    }

    public float getLon() {
        return lon;
    }

    public void setLon(float lon) {
        this.lon = lon;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public int getTipologia() {
        return tipologia;
    }

    public void setTipologia(int tipologia) {
        this.tipologia = tipologia;
    }

    public String getWikiLink() {
        return wikiLink;
    }

    public void setWikiLink(String wikiLink) {
        this.wikiLink = wikiLink;
    }

}

3) Interfaccia PoiDao che rappresenta un generico DAO e contiene solo la logica di business: cioè dice solo che un mio dao attualmente deve solo poter inserire nel DB

package dao;

import controller.POI;

public interface PoiDao {

    public void insert(POI poi);    // Inserisce un POI nel DB come nuovo record

}

4) Classe PoiHibernateDaoSupport che implementa PoiDao e fornisce un dao specifico per la tecnologia Hibernate:

/* Classe concreta che implementa l'interfaccia PoiDao implementandone i metodi
 * astratti e che estende la classe HibernateDatoSupport che serve a facilitare
 * l'injection di HibernateTemlate all'interno del DAO*/

package dao;

import controller.POI;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.transaction.annotation.Transactional;

public class PoiHibernateDaoSupport extends HibernateDaoSupport implements PoiDao {


  @Transactional
  public void insert(POI poi){
    getHibernateTemplate().saveOrUpdate(poi);
  }

}

E questo è il file XML: applicationContext.xml che mi serve per configurare i bean, le dipendenze tra di essi e le injection

<?xml version="1.0" encoding="UTF-8"?>
<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:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schem...-beans-2.5.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schem...ng-aop-2.5.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schem...ing-tx-2.5.xsd">

    <bean name="savedService" class="service.SavedService" />

    <bean id="insertpoiController" class="controller.InsertpoiController">
        
        <property name="PoiHibernateDaoSupport"><ref bean="PoiHibernateDaoSupport"/></property>
    </bean>

    <bean id="PoiHibernateDaoSupport" class="dao.PoiHibernateDaoSupport"/>

    

    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/poi;create=true" />
        <property name="username" value="root" />
        <property name="password" value="aprile12" />
    </bean>

    
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="annotatedClasses">
            <list>
                <value>controller.POI</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>


</beans>

Sono veramente disperato e non sò più cosa provare...credo che la logica sia giusta ma qualcosa mi sfugge

Grazie

[Gengi]

Ciao Andrea,

allora prima di tutto io ti consiglierei di utilizzare le annotations, sia per definire i bean (@Component) che per definire i Controller (@Controller), ti faccio un piccolo esempio:

web.xml

ti consiglio di creare un file separato per gestire hibernate tipo context-hibernate.xml, in seguito lo carici all'avvio con l'application-context.xml:

...

 <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
        	/WEB-INF/context.xml, 
        	/WEB-INF/context-hibernate.xml
        </param-value>
    </context-param>

....

context-hibernate.xml (ora qui uso postgres, cambia solo il dialetto), crea un file db.properties sotto WEB-INF con host, porta, nome_db, user e password

<?xml version="1.0" encoding="UTF-8"?>
<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"
	xsi:schemaLocation="
            http://www.springframework.org/schema/aop http://www.springframework.org/schem...ng-aop-2.5.xsd
            http://www.springframework.org/schema/beans http://www.springframework.org/schem...-beans-2.5.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schem...ontext-2.5.xsd
            http://www.springframework.org/schema/jee http://www.springframework.org/schem...ng-jee-2.5.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schem...ing-tx-2.5.xsd">

	<context:annotation-config />

	<bean
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="location" value="WEB-INF/db.properties" />
	</bean>

	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="org.postgresql.Driver"></property>
		<property name="url">
			<value>jdbc:postgresql://${db.host}:${db.port}/${db.name}</value>
		</property>
		<property name="username">
			<value>${db.username}</value>
		</property>
		<property name="password">
			<value>${db.password}</value>
		</property>
		<property name="maxActive" value="20" />
		<property name="maxIdle" value="20" />
		<property name="maxWait" value="10000" />
		<property name="defaultAutoCommit" value="false" />
	</bean>


	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="annotatedClasses">
			<list>
				<value>controller.POI </value>
                                                   <value>alre classi ... </value>

			</list>
		</property>

		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</prop>
				<prop key="hibernate.show_sql">false</prop>
				<prop key="hibernate.format_sql">false</prop>
				<prop key="hibernate.use_sql_comments">false</prop>
				<prop key="hibernate.hbm2ddl.auto">update</prop>
				<prop key="hibernate.cache.use_second_level_cache">false</prop>
				<prop key="hibernate.cache.provider_class">net.sf.ehcache.hibernate.EhCacheProvider</prop>
				<prop key="hibernate.cache.use_query_cache">false</prop>
			</props>
		</property>

	</bean>
	
	
    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager" p:sessionFactory-ref="sessionFactory" />

    
    <tx:annotation-driven transaction-manager="transactionManager" />

DAO generico per l'oggetto POI:

public interface PoiDao{
   
   public void insert(POI poi);
}

@Component(value = "poiDao");
public class PoiDaoImpl implements PoiDao {

   @Autowired
   @Qualifier("sessionFactory")
   private SessionFactory sessionFactory;

   @Override
   public void insert(POI poi){
       this.sessionFactory.getCurrentSession().saveOrUpdate(poi);
   }
}

Crei un servizio (ad esempio PoiService) creando prima l'interfaccia del servizio poi l'implementazione:

PoiService

public interface PoiService{

   public void insertPOI(POI poi);

}

La sua implementazione:

PoiServiceImpl

@Service(value = "poiService")
@Transactional(readOnly = true)
public class PoiService implements PoiService{
	
    @Autowired
    @Qualifier("poiDao")
    private PoiDao poiDao;

    @Override
    public void insertPOI(POI poi){
        this.poiDao.insert(poi);
    }

}

Alla fine nel tuo controller (creato con @Controller) farai cosi:

PoiController:

@Controller
public class PoiController extends SimpleFormController{

   @Autowired 
   @Qualifier("poiService")
   private PoiService poiService

    @Override
    protected ModelAndView onSubmit(Object command) throws Exception{
        
        POI poi = (POI) command;
        // grazie al servizio PoiService inserisci l'oggetto nel db
        this.poiService.insertPOI(poi);

        // ... ritorni poi la vista

    }
}

Ricorda però che per poter utilizzare le annotations devi configurare dei component-scan:

- per @Controller nel file della tua servlet (soltamente nomeApp-servlet.xml) devi mettere <context:component-scan base-package="package.dei.tuoi.controllers" />

- per @Service e @Component devi mettere nell'application context le due seguenti istruzioni:


<context:component-scan base-package="package.delle.implementazioni.dei.servizi " />


<context:component-scan base-package="package.delle.implementazioni.dei.dao" />


Facile no?


Comunque ti consiglio di utilizzare eclipse per sviluppare con Spring, anche per via del fatto che con un Jetty (ed annesso plug-in per eclipse run-jetty) pui far eseguire la tua applicazione anche senza fare il build, e se usi anche JRebel non devi neanche fare il restart del server Jetty quando modifichi qualcosa, visto che questo viene preso in carico da JRebel)



se hai bisogno altre spiegazioni contatta pure

Saluti Gengi

[AndreaNobili]

Ti ho mandato un pvt ma posto anche quà...magari la cosa potrebbe far comodo anche a qualcun altro...

Ciao,
scusa se ti disturbo in privato ma sono veramente disperato (purtroppo devo consegnare un mega progetto universitario solo che...non mi hanno spiegato NULLA )

Non ho ben capito un bel po' delle cose che mi hai scritto nella tua risposta...ti espongo i miei dubbi.

Intanto se vuoi dare un'occhiata al mio progetto per capire meglio (sicuramente meglio che guardando gli snippet pubblicati) puoi scaricare quà (dentro la subdir src trovi i miei sorgenti): http://www.andreanobiliphoto.com/storage/InsertPOI.zip

DUBBI:

1) Da quello che vedo dentro web.xml tu gli dici di caricare all'avvio dell'applicazione anche il file context-hibernate.xml che da quello che ho capito dovrebbe contenere le informazioni necessarie per la configurazione di Hibernate...quindi cosa di preciso? Le informazioni riguardanti il data source e le specifiche di Hibernate per usare il DB?

Poi però fai riferimento alla creazione di un file chiamato db.properties dentro WEB-INF e dici che deve contentere: host, porta, nome_db, user e password......scusa la domanda forse banale...ma che struttura deve avere questo file? e poi questi dati non sono da mettere nel famoso context-hibernate.xml ?

L'esempio di codice che mi fai sotto mi pare riferirsi proprio a context-hibernate.xml...l'unica cosa che mi viene da pensare è che forse lui si reperisca i dati necessari dal file db.properties alle righe di codice come:
codice:

<value>jdbc:postgresql://${db.host}:${db.port}/${db.name}</value>

Giusto? però vabbè...essendo molto principiante per ora potrei mettere anche i dati direttamente là senza complicarmi ulteriormente la vita...

Sempre in questo famoso file di configurazione di Hibernate: context-hibernate.xml da quello che riesco a capire definisco i seguenti bean:

DATASOURCE: definisce la sorgente dati...quindi il driver JDBC appropriato al mio tipo di DB e gli inietto dentro le varie configurazioni

Poi c'è questo bean che non riesco a capire bene cosa faccia...mi viene da pensare che serva ad iniettare il famoso file di configurazione contenente i dati di configurazione al DB (se mettessi i dati direttamente nel codice potrei evitarmelo giusto?):

<bean>
    class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location" value="WEB-INF/db.properties" />
</bean>

Poi dichiari il bean SessionFactory che serve a creare l'oggetto che gestisce la sessione di comunicazionde col DB e setti le varie proprietà come datasource da usare (che viene iniettato con una setter injection), dialetto sql per le query, etcetc...ok...la cosa che però non capisco bene è questo pezzo di codice del bean SessioFactory:

<property name="annotatedClasses">
    <list>
        <value>controller.POI </value>
        <value>alre classi ... </value>
    </list>
</property>

Che significa esattamente? cos'è un annotatedClasses (penso che capire questa cosa mi possa aiutare a capire altri tuoi ragionamenti che hai fatto dopo)

2) Poi vabbè anche tu crei l'interfaccia PoiDao come me...la cosa che mi sfugge invece è che mi dai il seguente codice ma non capisco bene a cosa si riferisca (all'implementazione concreta dell'interfaccia PoiDao?):

@Component(value = "poiDao");
public class PoiDaoImpl implements PoiDao {

   @Autowired
   @Qualifier("sessionFactory")
   private SessionFactory sessionFactory;

   @Override
   public void insert(POI poi){
       this.sessionFactory.getCurrentSession().saveOrUpdate(poi);
   }
}

Se è come penso io praticamente sarebbe il codice da mettere dentro la classe PoiHibernateDaoSupport...solo che...il mio codice è un po' diverso (se vedi nei miei sorgenti capisci...perchè usa l'HibernateTemplate)....potresti darmi qualche invo in più in merito? anche riguardo ai tag che iniziano con la @ che da quello che ho capito hanno qualcosa a che fare con le annotated classes ma non sò proprio di cosa si tratti e cercando sulla documentazione non sono riuscito a trovare molto...

[AndreaNobili]

3) Ecco quì invece proprio non capisco che fai...mi riferisco alla storia del servizio....se vedi sul mio codice PoiService è semplicemente un servizio che una volta che l'utente ha effettuato il submit del form computa una stringa di hello che stampa anche i valori presenti nel command object poi

Perchè tu crei l'interfaccia per il PoiService (che contiene la definizione del metodo insert quando nel mio esempio deve solo computare una stringa...), poi la implementi con il codice:

@Service(value = "poiService")
@Transactional(readOnly = true)
public class PoiService implements PoiService{
	
    @Autowired
    @Qualifier("poiDao")
    private PoiDao poiDao;

    @Override
    public void insertPOI(POI poi){
        this.poiDao.insert(poi);
    }

}

che non capisco bene cosa faccia...praticamente fai sta cosa per fare l'inject del DAO? ma non posso iniettare il mio DAO direttamente nella mia classe controller del form...mmm...questo è proprio un punto oscuro di ciò che hai fatto...se si potesse iniettare direttamente nel dao preferirei per semplicità (anche a scapito di un po' di eleganza...ma sono talmente newbye che ora come ora W la banalità)

Se intanto mi puoi chiarire queste cosette te ne sarei estremamente grato (oddio lo sò che ti ho scritto un papiro...scusami tantissimo...)

Please...help me :-(
Andrea

[Gengi]

Ti ho risposto con un pvt, se ho tempo vedo di farti anche un piccolo esempio di codice...

Gengi..

[AndreaNobili]

Ti ringrazio tantissimo,
stò dando una letta alle tue spiegazioni...e qualcosa credo di iniziare a capire...casomai ti rompo ulteriormente le scatole se mi impallo...grazie, sei veramente gentilissimo

Andrea