CreateDAO_it

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

Informazioni su questo tutorial

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.

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.

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:

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.

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]

[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):

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

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]

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 properties in questo file saranno rese disponibili tramite la variabile "rb".

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.

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:

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

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

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.

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:

I tend to just hard-code test values into Java code - but the .properties file is an option that works great for large objects.

firstName=Matt
lastName=Raible

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]

Notice in the class above there are no exceptions on the method signatures. This is due to the power of Spring 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: No bean named 'personDao' is defined. 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.

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.

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 and implement PersonDao. Javadocs eliminated for brevity.

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.

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

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.

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:

Eseguire il DaoTest [#6]

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.