Raible's Wiki

Raible Designs
Wiki Home
News
Recent Changes

AppFuse

Homepage
  - Korean
  - Chinese
  - Italian
  - Japanese

QuickStart Guide
  - Chinese
  - French
  - German
  - Italian
  - Korean
  - Portuguese
  - Spanish
  - Japanese

User Guide
  - Korean
  - Chinese

Tutorials
  - Chinese
  - German
  - Italian
  - Korean
  - Portuguese
  - Spanish

FAQ
  - Korean

Latest Downloads

Other Applications

Struts Resume
Security Example
Struts Menu

Set your name in
UserPreferences

Referenced by
Articles
CreateManager_it
LeftMenu




JSPWiki v2.2.33

[RSS]


Hide Menu

CreateDAO_it
Search Wiki:
Your trail:

This is version 7. It is not the current version, and thus it cannot be edited.
[Back to current version]   [Restore this version]

Parte I: Creare nuovi DAO ed Object in AppFuse - Un HowTo su come creare Java Object (che rappresentino tabelle) e creare classi Java per rendere persistenti tali oggetti nel database.

Informazioni su questo tutorial

Questo tutorial mostrerà come creare un nuova tabella nel database, e come creare il codice Java per accedere a questa tabella.

Verrà creato un oggetto e poi delle altre classi per rendere persistente (registrare/recuperare/eliminare) quell'oggetto dal database. Parlando in Java, questo oggetto viene chiamato Plain Old Java Object (a.k.a. POJO). Questo oggetto in sostanza rappresenta una tabella su database. Le altre classi saranno:

  • Un Data Access Object (a.k.a. DAO), un'Interfaccia ed un'Implementazione su Hibernate
  • Una classe JUnit per verificare che il DAO funziona

AppFuse usa Hibernate come layer di persistenza di default. Hibernate è un Object/Relational (O/R) Framework che permette di correlare i tuoi Java Object alle tabelle del database. Ti permette di effettuare molto facilmente operazioni CRUD (Create, Retrieve, Update, Delete) sui tuoi oggetti.

Puoi usare anche iBATIS come scelta di persistence framework. Per installare iBATIS in AppFuse, vedere il file README.txt in extras/ibatis. Poi completa la versione iBATIS di questo tutorial.

Convenzioni Tipografiche (work in progress)

Le stringhe di testo da intendersi eseguite al prompt dei comandi si presentano così: ant test-all.
Riferimenti a file, directory e package all'interno dell'alberatura del tuo sorgente: build.xml.
E suggerimenti su come fare le cose nel "Mondo Reale" sono in corsivo blu.

Iniziamo a creare un nuovo Object, DAO e Test nella struttura di progetto di AppFuse.

Indice

  • [1] Creare un nuovo Object ed aggiungere i tag XDoclet
  • [2] Creare un nuova tabella nel database a partire dall'oggetto usando Ant
  • [3] Creare un nuovo DaoTest per eseguire i test JUnit sul DAO
  • [4] Creare un nuovo DAO per effettuare operazioni CRUD sull'oggetto
  • [5] Configurare Spring per l'oggetto Person e il PersonDao
  • [6] Eseguire il DaoTest

Creare un nuovo Object ed aggiungere i tag XDoclet [#1]

La prima cosa che devi fare è creare un oggetto da rendere persistente. Crea un semplice oggetto "Person" (nella directory src/dao/**/model) che abbia un id, un firstName ed un lastName (come proprietà).

NOTA: La copia del codice Java in questi tutorial non funziona in Firefox. Un workaround è usare CTRL+Clic (Comando+Clic su OS X) sul blocco di codice e poi copiarlo.


package org.appfuse.model;

public class Person extends BaseObject {
    private Long id;
    private String firstName;
    private String lastName;

    /*
     Genera i tuoi getter e setter usando il tuoi IDE preferito: 
     In Eclipse:
     Pulsante Destro -> Source -> Generate Getters and Setters
    */
}

Questa classe deve estendere BaseObject, che ha 3 metodi astratti: (equals(), hashCode() e toString()) che dovrai implementarre per la classe Person. I primi due sono richiesti da Hibernate. Il modo più facile per farlo è usare Commonclipse. Ulteriori informazioni sull'uso di questo strumento si possono trovare sul sito di Lee Grey. Un altro Plugin di Eclipse che puoi usare è Commons4E. Non l'ho usato, per cui non posso fare commenti sulle sul suo funzionamento.

Se stai usando IntelliJ IDEA, puoi generare i metodi equals() e hashCode(), ma non il toString(). C'è un ToStringPlugin che funziona ragionevolmente bene.
NOTA: Se l'installazione di questi plugin non ti funziona, puoi trovare tutti questi metodi nell'oggetto Person.java che viene utilizzato per il test di AppGen. Basta che guardi in extras/appgen/test/dao/org/appfuse/model/Person.java e fai copia e incolla dei metodi da quella classe.

Dopo aver creato questo POJO, devi aggiungere i tag XDoclet per generare il file di mapping di Hibernate. Questo file di mapping viene utilizzato da Hibernate per mappare oggetti → tabelle e proprietà (variabili) → colonne.

Prima di tutto, aggiungi un tag @hibernate.class che dica ad Hibernate a quale tabella si riferisca questo oggetto:


/**
 * @hibernate.class table="person"
 */
public class Person extends BaseObject {

Devi aggiungere anche un mapping per la primary key o XDoclet ti vomiterà addosso una serie di errori durante la generazione del file di mapping. Nota che tutti quei tag @hibernate.* devono essere posti all'interno del Javadoc dei getter dei tuoi POJO.


    /**
     * @return Returns the id.
     * @hibernate.id column="id" generator-class="increment" unsaved-value="null"
     */

    public Long getId() {
        return this.id;
    }

Io uso generator-class="increment" invece di generator-class="native" in quanto ho riscontrato qualche problema nell'uso di "native" con altri database. Se hai in programma di usare solo MySQL, ti raccomando di usare il valore "native". Questo tutorial usa increment.

Creare una nuova tabella nel database a partire dall'oggetto usando Ant [#2]

A questo punto, puoi creare la tabella person eseguendo un ant setup-db. Questo task crea il file Person.hbm.xml e poi una tabella nel database con nome "person". Dalla console di ant, puoi vedere lo schema della tabella che ti crea Hibernate: 
[schemaexport] create table person (
[schemaexport]    id bigint not null,
[schemaexport]    primary key (id)
[schemaexport] );

Se vuoi dare un'occhio al file Person.hbm.xml che ti genera Hibernate, guarda nella directory build/dao/gen/**/model. Ecco il contenuto di Person.hbm.xml (finora):


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
    <class
        name="org.appfuse.model.Person"
        table="person"
        dynamic-update="false"
        dynamic-insert="false"
    >

        <id
            name="id"
            column="id"
            type="java.lang.Long"
            unsaved-value="null"
        >
            <generator class="increment">
            </generator>
        </id>

        <!--
            To add non XDoclet property mappings, create a file named
                hibernate-properties-Person.xml
            containing the additional properties and place it in your merge dir.
        -->

    </class>

</hibernate-mapping>

Ora mettiamo i tag @hibernate.property aggiuntivi per le altre colonne (first_name, last_name):


    /**
     * @hibernate.property column="first_name" length="50"
     */
    public String getFirstName() {
        return this.firstName;
    }

    /**
     * @hibernate.property column="last_name" length="50"
     */
    public String getLastName() {
        return this.lastName;
    }

In questo esempio, l'unico motivo per aggiungere l'attributo column è perché il nome della colonna è diverso dal nome della proprietà. Se sono uguali, non devi specificare l'attributo column. Vedi la documentazione @hibernate.property per gli altri attributi che puoi specificare per questo tag.

Esegui di nuovo ant setup-db per fare in modo che le nuove colonne vengano aggiunte alla tua tabella. 

[schemaexport] create table person (
[schemaexport]    id bigint not null,
[schemaexport]    first_name varchar(50),
[schemaexport]    last_name varchar(50),
[schemaexport]    primary key (id)
[schemaexport] );

Se vuoi modificare le dimensioni delle tue colonne, cambia il valore dell'attributo length nel tuo tag @hibernate.property. Se vuoi rendere il campo obbligatorio (NOT NULL), aggiungi not-null="true".

Creare un nuovo DaoTest per eseguire test JUnit sul tuo DAO [#3]

NOTA: Le versioni di AppFuse dalla 1.6.1 in su contengono lo strumento AppGen che può essere usato per generare tutte le classi per il resto di questi tutorial. Tuttavia, è meglio che tu prosegua questi tutorial prima di utilizzare questo strumento - così poi saprai che codice ti sta generando.

Ora c'è da creare un DaoTest per verificare che il tuo DAO funzioni. "Aspetta un momento," mi dirai, "Io non ho creato un DAO!" Ed hai ragione. Tuttavia, ho scoperto che il Test-Driven Development permette di tirar su codice di miglior qualità. Per anni ho pensato che lo scrivere i test prima delle classi fosse una sonora boiata. É che mi sembrava stupido e basta. Poi ho provato a farlo ed ho scoperto che invece funziona alla grande. L'unico motivo per cui ora faccio tutto questa roba test-driven è perché ho scoperto che accelera in tempi brevi il processo di sviluppo software.

Per iniziare, crea una classe PersonDaoTest.java nella directory test/dao/**/dao. Questa classe deve estendere BaseDaoTestCase, una sotto classe del AbstractTransactionalDataSourceSpringContextTests di Spring che esiste già in questo package. Questa classe parent viene usata per caricare l'ApplicationContext di Spring (in quanto Spring collega i vari layer insieme), e per (opzionalmente) caricare un file .properties (ResourceBundle) con lo stesso nome della tua *Test.class. In questo esempio, se metti un file PersonDaoTest.properties nella stessa directory di PersonDaoTest.java, le proprietà all'interno di questo file saranno rese disponibili tramite la variabile "rb".


package org.appfuse.dao;

import org.appfuse.model.Person;
import org.springframework.dao.DataAccessException;

public class PersonDaoTest extends BaseDaoTestCase {
    
    private Person person = null;
    private PersonDao dao = null;

    public void setPersonDao(PersonDao dao) {
        this.dao = dao;
    }
}

Il codice che vedi qui sopra è tutto quello che ti server per un test di integrazione di base con Spring che inizializzi e configuri un'implementazione di PersonDao. Spring useraà l'autowiring byType per richiamare il metodo setPersonDao() ed impostare il bean "personDao" come dipendenza di questa classe.

Ora devi verificare che i metodi CRUD (create, retrieve, update, delete) funzionino nel tuo DAO. Per farlo crea dei metodi che inizino con "test" (tutto minuscolo). Se questi metodi sono pubblici, hanno un valore di ritorno void e non prendono argomenti, verranno richiamati dal task <junit> task nel build.xml. Qui sotto ci sono alcuni semplici test per verificare il CRUD. Una cosa importante da ricordare è che ogni metodo (noto anche come test), deve essere autonomo. Aggiungi i seguenti metodi al tuo file PersonDaoTest.java:


    public void testGetPerson() throws Exception {
        person = new Person();
        person.setFirstName("Matt");
        person.setLastName("Raible");

        dao.savePerson(person);
        assertNotNull(person.getId());

        person = dao.getPerson(person.getId());
        assertEquals(person.getFirstName(), "Matt");
    }

    public void testSavePerson() throws Exception {
        person = dao.getPerson(new Long(1));
        person.setFirstName("Matt");

        person.setLastName("Last Name Updated");

        dao.savePerson(person);

        if (log.isDebugEnabled()) {
            log.debug("updated Person: " + person);
        }

        assertEquals(person.getLastName(), "Last Name Updated");
    }

    public void testAddAndRemovePerson() throws Exception {
        person = new Person();
        person.setFirstName("Bill");
        person.setLastName("Joy");

        dao.savePerson(person);

        assertEquals(person.getFirstName(), "Bill");
        assertNotNull(person.getId());

        if (log.isDebugEnabled()) {
            log.debug("removing person...");
        }

        dao.removePerson(person.getId());

        try {
            person = dao.getPerson(person.getId());
            fail("Person found in database");
        } catch (DataAccessException dae) {
            log.debug("Expected exception: " + dae.getMessage());
            assertNotNull(dae);
        }
    }

Nel metodo testGetPerson, stai creando una persona, poi stai richiamando una get. Di solito io inserisco un record nel database sul quale posso sempre contare. Poiché viene usato DBUnit per popolare il database con i dati di test prima che questi vengano eseguiti, puoi semplicemente aggiungere la nuova tabella/record al file metadata/sql/sample-data.xml:

<table name='person'>
    <column>id</column>
    <column>first_name</column>
    <column>last_name</column>
    <row>
      <value>1</value>
      <value>Matt</value>
      <value>Raible</value>
    </row>
</table>
In questo modo, puoi eliminara la funzione "crea nuovo" nel metodo testGetPerson. Se preferisci piuttosto aggiungere questo record direttamente nel database (via SQL o una GUI), puoi ricostruire il tuo file sample-data.xml usando ant db-export e poi cp db-export.xml metadata/sql/sample-data.xml.

Nell'esempio qui sopra, puoi vedere che person.set*(value) viene chiamato per popolare l'oggetto Person prima di registrarlo. Questa cosa è semplice in questo esempio, ma può diventare parecchio complessa se stai rendendo persistente un oggetto con 10 campi obbligatori (not-null="true"). Questo è il motivo per cui ho creato il ResourceBundle nel BaseDaoTestCase. Crea semplicemente un file PersonDaoTest.properties nella stessa directory come PersonDaoTest.java e definisci i valori delle tue proprietà al suo interno:

Io tendo a cablare i valori di test direttamente nel codice Java - ma il file .properties è un'opzione che funziona molto bene per oggetti grandi.
firstName=Matt
lastName=Raible
Poi, piuttosto che richiamare person.set* per popolare i tuoi oggetti, puoi usare il metodo BaseDaoTestCase.populate(java.lang.Object):


person = new Person();
person = (Person) populate(person);

A questo punto, la classe PersonDaoTest non compila ancora perché non c'è nessuna PersonDao.class nel tuo classpath, devi crearla. PersonDao.java è un'interfaccia, e PersonDaoHibernate.java è l'implementazione Hibernate di tale interfaccia.

Crea un nuovo DAO per effettuare operazioni CRUD sull'oggetto[#4]

Prima di tutto, crea un'interfaccia PersonDao.java nella directory src/dao/**/dao e specifica i metodi CRUD principali per tutte le classi di implementazione.


package org.appfuse.dao;

import org.appfuse.model.Person;

public interface PersonDao extends Dao {
    public Person getPerson(Long personId);
    public void savePerson(Person person);
    public void removePerson(Long personId);
}

Nota bene che nella classe qui sopra non ci sono eccezioni nelle firme dei metodi. Ciò è dovuto alla potenza di Spring e a come maschera le Exception con RuntimeException. A questo punto, dovresti essere in grado di compilare tutto il sorgente in src/dao e test/dao usando ant compile-dao. Tuttavia, se provi ad eseguire ant test-dao -Dtestcase=PersonDao, otterrai un errore: No bean named 'personDao' is defined. Questo è un messaggio di errore provenienta da Spring - il quale indica che devi specificare un bean denominato personDao in applicationContext-hibernate.xml. Prima di farlo però, devi creare la classe di implementazione di PersonDao.

Il task ant per eseguire i test sui dao si chiama test-dao. Se passi un parametro testcase (using -Dtestcase=name), cercherà **/*${testcase}* - permettendoci di passare su Person, PersonDao, o PersonDaoTest - i quali eseguiranno tutti la classe PersonDaoTest.

Iniziamo con il creare una classe PersonDaoHibernate che implementi i metodi in PersonDao e usi Hibernate per ottenere/registrare/eliminare l'oggetto Person. Per far questo, crea una nuova classe in src/dao/**/dao/hibernate e chiamala PersonDaoHibernate.java. Dovrebbe estendere BaseDaoHibernate ed implementare PersonDao. Javadoc eliminati per brevità.


package org.appfuse.dao.hibernate;

import org.appfuse.model.Person;
import org.appfuse.dao.PersonDao;
import org.springframework.orm.ObjectRetrievalFailureException;

public class PersonDaoHibernate extends BaseDaoHibernate implements PersonDao {

    public Person getPerson(Long id) {
        Person person = (Person) getHibernateTemplate().get(Person.class, id);

        if (person == null) {
            throw new ObjectRetrievalFailureException(Person.class, id);
        }

        return person;
    }

    public void savePerson(Person person) {
        getHibernateTemplate().saveOrUpdate(person);
    }

    public void removePerson(Long id) {
        // object must be loaded before it can be deleted
        getHibernateTemplate().delete(getPerson(id));
    }
}

Ora, se provi ad eseguire ant test-dao -Dtestcase=PersonDao, otterrai lo stesso errore. Dobbiamo configurare Spring in modo che sappia che PersonDaoHibernate è l'implementazione di PersonDao, e dobbiamo dirgli anche qualcosa sull'oggetto Person.

Configurare Spring per l'oggetto Person e il PersonDao [#5]

Innanzitutto, devi dire a Springdove si trova il file di mapping di Hibernate. Per farlo, apri src/dao/**/dao/hibernate/applicationContext-hibernate.xml ed aggiungi "Person.hbm.xml" al blocco di codice seguente.


<property name="mappingResources"> 
    <list> 
        <value>org/appfuse/model/Person.hbm.xml</value> 
        <value>org/appfuse/model/Role.hbm.xml</value> 
        <value>org/appfuse/model/User.hbm.xml</value>
    </list> 
</property> 

Ora devi aggiungere un po' di XML a questo file per collegare PersonDaoHibernate a PersonDao. Per far questo, aggiungi quanto segue alla fine del file:


<!-- PersonDao: implementazione Hibernate --> 
<bean id="personDao" class="org.appfuse.dao.hibernate.PersonDaoHibernate"> 
    <property name="sessionFactory" ref="sessionFactory"/>
</bean> 

Eseguire il DaoTest [#6]

Registra tutti i tuoi file modificati e prova ad eseguire ant test-dao -Dtestcase=PersonDao un'altra volta.

Yeah Baby, Yeah: BUILD SUCCESSFUL
Total time: 9 seconds

Next Up: Part II: Creating new Managers - A HowTo for creating Business Facades, which are similar to Session Facades, but don't use EJBs. These facades are used to provide communication from the front-end to the DAO layer.


Go to top   More info...   Attach file...
This particular version was published on 06-Nov-2006 13:52:56 MST by MarcelloTeodori.