Raible's Wiki: CreateDAO

At line 1 changed 1 line.

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

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

At line 32 changed 1 line.

La prima cosa che devi fare è crare 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à).

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à).

At line 46 changed 1 line.

Generate your getters and setters using your favorite IDE:

Genera i tuoi getter e setter usando il tuoi IDE preferito:

At line 48 changed 1 line.

Right-click -> Source -> Generate Getters and Setters

Pulsante Destro -> Source -> Generate Getters and Setters

At line 53 changed 1 line.

This class should extend [BaseObject|http://raibledesigns.com/downloads/appfuse/api/org/appfuse/model/BaseObject.java.html], which has 3 abstract methods: (equals(), hashCode() and toString()) that you will need to implement in the Person class. The first two are required by Hibernate. The easiest way to do this is using [Commonclipse|http://commonclipse.sf.net]. More information on using this tool can be found on [Lee Grey's site|http://www.leegrey.com/hmm/2004/09/29/1096491256000.html]. Another Eclipse Plugin you can use is [Commons4E|http://commons4e.berlios.de/]. I haven't used it, so I can't comment on its functionality.

Questa classe deve estendere [BaseObject|http://raibledesigns.com/downloads/appfuse/api/org/appfuse/model/BaseObject.java.html], che ha 3 metodi astratti: (equals(), hashCode() e toString()) che dovrai implementare per la classe Person. I primi due sono richiesti da Hibernate.

Se intendi mettere questo oggetto nella sessione dell'utente o esporlo tramite un web service, dovresti implementare anche {{java.io.Serializable}}.

At line 55 changed 1 line.

;:''If you're using [IntelliJ IDEA|http://www.jetbrains.com/idea], you can generate equals() and hashCode(), but not toString(). There is a [ToStringPlugin|http://www.intellij.org/twiki/bin/view/Main/ToStringPlugin] that works reasonably well.''

Il modo più facile per farlo è usare [Commonclipse|http://commonclipse.sf.net]. Ulteriori informazioni sull'uso di questo strumento si possono trovare sul [sito di Lee Grey|http://www.leegrey.com/hmm/2004/09/29/1096491256000.html]. Un altro Plugin di Eclipse che puoi usare è [Commons4E|http://commons4e.berlios.de/]. Non l'ho usato, per cui non posso fare commenti sulle sul suo funzionamento.

At line 57 changed 1 line.

%%note __NOTE:__ If installing these plugins doesn't work for you, you can find all of these methods in the Person.java object that's used to test AppGen. Just look in ''extras/appgen/test/dao/org/appfuse/model/Person.java'' and copy and paste the methods from that class.%%

;:''Se stai usando [IntelliJ IDEA|http://www.jetbrains.com/idea], puoi generare i metodi equals() e hashCode(), ma non il toString(). C'è un [ToStringPlugin|http://www.intellij.org/twiki/bin/view/Main/ToStringPlugin] che funziona ragionevolmente bene.''

At line 59 changed 1 line.

Now that you have this POJO created, you need to add XDoclet tags to generate the Hibernate mapping file. This mapping file is used by Hibernate to map objects → tables and properties (variables) → columns.

%%note __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.%%

At line 61 changed 1 line.

First of all, add a [@hibernate.class|http://xdoclet.sourceforge.net/tags/hibernate-tags.html#@hibernate.class%20(0..1)] tag that tells Hibernate what table this object relates to:

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.

At line 64 added 2 lines.

Prima di tutto, aggiungi un tag [@hibernate.class|http://xdoclet.sourceforge.net/tags/hibernate-tags.html#@hibernate.class%20(0..1)] che dica ad Hibernate a quale tabella si riferisca questo oggetto:

At line 71 changed 1 line.

You also have to add a primary key mapping or XDoclet will puke when generating the mapping file. Note that all @hibernate.* tags should be placed in the __getters'__ Javadocs of your POJOs.

Devi aggiungere anche un mapping per la primary key o XDoclet ti riempirà 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.

At line 85 changed 1 line.

;:%%(color: blue)''I'm using {{generator-class="increment"}} instead of {{generator-class="native"}} because I [found some issues|AppFuseOnDB2] when using "native" on other databases. If you only plan on using MySQL, I __recommend you use the "native" value__. This tutorial uses increment.''%%

;:%%(color: blue)''Io uso {{generator-class="increment"}} invece di {{generator-class="native"}} in quanto ho [riscontrato qualche problema|AppFuseOnDB2] 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.''%%

At line 87 changed 2 lines.

!!Create a new database table from the object using Ant [#2]

At this point, you can create the person table by running __ant setup-db__. This task creates the {{Person.hbm.xml}} file and creates a database table called "person". From the ant console, you can see the table schema the Hibernate creates for you:

!!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:

At line 96 changed 1 line.

If you want to look at the {{Person.hbm.xml}} file that Hibernate generates for you, look in the {{build/dao/gen/**/model}} directory. Here's the contents of {{Person.hbm.xml}} (so far):

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

At line 134 changed 1 line.

Now you'll add additional [@hibernate.property|http://xdoclet.sourceforge.net/tags/hibernate-tags.html#@hibernate.property%20(0..1)] tags for the other columns (first_name, last_name):

Ora mettiamo i tag [@hibernate.property|http://xdoclet.sourceforge.net/tags/hibernate-tags.html#@hibernate.property%20(0..1)] aggiuntivi per le altre colonne (first_name, last_name):

At line 153 changed 1 line.

In this example, the only reason for adding the ''column'' attribute is because the column name is different from the property name. If they're the same, you don't need to specify the ''column'' attribute. See the [@hibernate.property|http://xdoclet.sourceforge.net/tags/hibernate-tags.html#@hibernate.property%20(0..1)] reference for other attributes you can specify for this tag.

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|http://xdoclet.sourceforge.net/tags/hibernate-tags.html#@hibernate.property%20(0..1)] per gli altri attributi che puoi specificare per questo tag.

At line 155 changed 1 line.

Run __ant setup-db__ again to get the additional columns added to your table.

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

At line 164 changed 1 line.

If you want to change the size of your columns, modify the ''length'' attribute in your @hibernate.property tag. If you want to make it a required field (NOT NULL), add not-null="true".

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".

At line 166 changed 1 line.

!!Create a new DaoTest to run JUnit tests on your DAO [#3]

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

At line 168 changed 1 line.

%%note <a name="appgen"></a>__NOTE:__ AppFuse versions 1.6.1+ contain include an [AppGen] tool that can be used to generate all the classes for the rest of these tutorials. However, it's best that you go through these tutorials before using this tool - then you'll know what code it's generating.%%

%%note <a name="appgen"></a>__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.%%

At line 170 changed 1 line.

Now you'll create a DaoTest to test that your DAO works. "Wait a minute," you say, "I haven't created a DAO!" You are correct. However, I've found that [Test-Driven Development|http://www.artima.com/intv/testdriven.html] breeds higher quality software. For years, I thought __write your test before your class__ was hogwash. It just seemed stupid. Then I tried it and I found that it works great. The only reason I do all this test-driven stuff now is because I've found it rapidly speeds up the process of software development.

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|http://www.artima.com/intv/testdriven.html] permette di scrivere codice di miglior qualità. Per anni ho pensato che __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 e riduce i tempi del processo di sviluppo software.

At line 172 changed 1 line.

To start, create a {{PersonDaoTest.java}} class in the {{test/dao/**/dao}} directory. This class should extend [BaseDaoTestCase|http://raibledesigns.com/downloads/appfuse/api/org/appfuse/dao/BaseDaoTestCase.java.html], a subclass of Spring's [AbstractTransactionalDataSourceSpringContextTests|http://www.springframework.org/docs/api/org/springframework/test/AbstractTransactionalDataSourceSpringContextTests.html] which already exists in this package. This parent class is used to load [Spring's|http://www.springframework.org] ApplicationContext (since Spring binds the layers together), and for (optionally) loading a .properties file (ResourceBundle) that has the same name as your {{*Test.class}}. In this example, if you put a {{PersonDaoTest.properties}} file in the same directory as {{PersonDaoTest.java}}, this file's properties will be available via an "rb" variable.

Per iniziare, crea una classe {{PersonDaoTest.java}} nella directory {{test/dao/**/dao}}. Questa classe deve estendere [BaseDaoTestCase|http://raibledesigns.com/downloads/appfuse/api/org/appfuse/dao/BaseDaoTestCase.java.html], una sotto classe del [AbstractTransactionalDataSourceSpringContextTests|http://www.springframework.org/docs/api/org/springframework/test/AbstractTransactionalDataSourceSpringContextTests.html] di Spring che esiste già in questo package. Questa classe parent viene usata per caricare l'ApplicationContext di [Spring|http://www.springframework.org] (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".

At line 192 changed 1 line.

The code you see above is what you need for a basic Spring integration test that initializes and configures an implementation of PersonDao. Spring will use autowiring byType to call the ''setPersonDao()'' method and set the "personDao" bean as a dependency of this class.

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 userà l'autowiring byType per richiamare il metodo ''setPersonDao()'' ed impostare il bean "personDao" come dipendenza di questa classe.

At line 194 changed 1 line.

Now you need test that the CRUD (create, retrieve, update, delete) methods work in your DAO. To do this, create methods that begin with "test" (all lower case). As long as these methods are public, have a {{void}} return type and take no arguments, they will be called by the <junit> task in build.xml. Below are some simple tests for testing CRUD. An important thing to remember is that each method (also known as a test), should be autonomous. Add the following methods to your {{PersonDaoTest.java}} file:

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> del build.xml di Ant. 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}}:

At line 251 changed 1 line.

;:%%(color: blue)''In the testGetPerson method, you're creating a person and then calling a get. I usually enter a record in the database that I can always rely on. Since [DBUnit|http://www.dbunit.org] is used to populate the database with test data before the tests are run, you can simply add the new table/record to the metadata/sql/sample-data.xml file:''%%

;:%%(color: blue)''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|http://www.dbunit.org] 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:''%%

At line 268 changed 1 line.

;:%%(color: blue)''This way, you can eliminate the "create new" functionality in the testGetPerson method. If you'd rather add this record directly into the database (via SQL or a GUI), you can rebuild your {{sample-data.xml}} file using __ant db-export__ and then __cp {{db-export.xml metadata/sql/sample-data.xml}}__.''%%

;:%%(color: blue)''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}}__.''%%

At line 270 changed 2 lines.

In the above example, you can see that person.set*(value) is being called to populate the Person object before saving it. This is easy in this example, but it could get quite cumbersome if you're persisting an object with 10 required fields (not-null="true"). This is why I created the ResourceBundle in the BaseDaoTestCase. Simply create a {{PersonDaoTest.properties}} file in the same directory as {{PersonDaoTest.java}} and define your property values inside it:

;:%%(color: blue)''I tend to just hard-code test values into Java code - but the .properties file is an option that works great for large objects.''%%

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:

;:%%(color: blue)''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.''%%

At line 276 changed 1 line.

Then, rather than calling person.set* to populate your objects, you can use the BaseDaoTestCase.populate(java.lang.Object) method:

Poi, piuttosto che richiamare person.set* per popolare i tuoi oggetti, puoi usare il metodo BaseDaoTestCase.populate(java.lang.Object):

At line 284 changed 3 lines.

At this point, the PersonDaoTest class won't compile yet because there is no PersonDao.class in your classpath, you need to create it. PersonDao.java is an interface, and PersonDaoHibernate.java is the Hibernate implementation of that interface.

!!Create a new DAO to perform CRUD on the object [#4]

First off, create a PersonDao.java interface in the {{src/dao/**/dao}} directory and specify the basic CRUD methods for any implementation classes.

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.

At line 301 changed 1 line.

Notice in the class above there are no exceptions on the method signatures. This is due to the power of [Spring|http://www.springframework.org] and how it wraps Exceptions with RuntimeExceptions. At this point, you should be able to compile all the source in {{src/dao}} and {{test/dao}} using __ant compile-dao__. However, if you try to run __ant test-dao -Dtestcase=PersonDao__, you will get an error: <span style="color: red">No bean named 'personDao' is defined</span>. This is an error message from Spring - indicating that you need to specify a bean named ''personDao'' in {{applicationContext-hibernate.xml}}. Before you do that, you need to create the PersonDao implementation class.

Nota bene che nella classe qui sopra non ci sono eccezioni nelle firme dei metodi. Ciò è dovuto alla potenza di [Spring|http://www.springframework.org] 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: <span style="color: red">No bean named 'personDao' is defined</span>. 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.

At line 303 changed 1 line.

;:''The ant task for running dao tests is called __test-dao__. If you pass in a testcase parameter (using __-Dtestcase=name__), it will look for {{**/*${testcase}*}} - allowing us to pass in Person, PersonDao, or PersonDaoTest - all of which will execute the PersonDaoTest class.''

;:''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.''

At line 305 changed 1 line.

Let's start by creating a PersonDaoHibernate class that implements the methods in PersonDao and uses Hibernate to get/save/delete the Person object. To do this, create a new class in {{src/dao/**/dao/hibernate}} and name it {{PersonDaoHibernate.java}}. It should extend [BaseDaoHibernate|http://raibledesigns.com/downloads/appfuse/api/org/appfuse/dao/BaseDAOHibernate.java.html] and implement PersonDao. ''Javadocs eliminated for brevity.''

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|http://raibledesigns.com/downloads/appfuse/api/org/appfuse/dao/BaseDAOHibernate.java.html] ed implementare PersonDao. ''Javadoc eliminati per brevità.''

At line 338 changed 1 line.

Now, if you try to run __ant test-dao -Dtestcase=PersonDao__, you will get the same error. We need to configure Spring so it knows that PersonDaoHibernate is the implementation of PersonDao, and you also need to tell it about the Person object.

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.

At line 340 changed 1 line.

!!Configure Spring for the Person object and PersonDao [#5]

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

At line 342 changed 1 line.

First, you need to tell Spring where the Hibernate mapping file is located. To do this, open {{src/dao/**/dao/hibernate/applicationContext-hibernate.xml}} and add {{"Person.hbm.xml"}} to the following code block.

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.

At line 355 changed 1 line.

Now you need to add some XML to this file to bind PersonDaoHibernate to PersonDao. To do this, add the following at the bottom of the file:

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:

At line 359 changed 1 line.

At line 365 changed 2 lines.

!!Run the DaoTest [#6]

Save all your edited files and try running __ant test-dao -Dtestcase=PersonDao__ one more time.

%%note __NOTA:__ Non dimenticare di correggere il nome del package nell'attributo "class" qui sopra se hai indicato un package diverso da org.appfuse quando hai creato il tuo progetto.%%

At line 370 added 3 lines.

!!Eseguire il DaoTest [#6]

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

At line 374 changed 1 line.

''Next Up:'' __Part II:__ [Creating new Managers|CreateManager] - A HowTo for creating Business Facades, which are similar to [Session Facades|http://java.sun.com/blueprints/patterns/SessionFacade.html], but don't use EJBs. These facades are used to provide communication from the front-end to the DAO layer.

''Prossima Puntata:'' __Parte II:__ [Creare nuovi Manager|CreateManager_it] - Un HowTo sulla creazione di Business Façade, che sono simili alle [Session Façade|http://java.sun.com/blueprints/patterns/SessionFacade.html], ma non usano gli EJB. Queste façade sono usate per fornire un modalità di comunicazione dal front-end allo strato DAO.

Raible's Wiki

AppFuse

Other Applications

CreateDAO_it