Raible's Wiki: CreateDAO

Wenn man PostgreSQL nutzt und komische Fehlermeldungen über batch processing erhält, kann man versuchen dies abzustellen indem man die Zeile <prop key="hibernate.jdbc.batch_size">0</prop> zur Datei src/dao/**/hibernate/applicationContext-hibernate.xml hinzufügt.

AppFuse nutzt Hibernate

als Standard Persistenz Schicht. Hibernate ist ein Object/Relational (O/R) Framework, welches es einem ermöglicht, Java Objekte und Datenbanktabellen zu verknüpfen. Das Framework erlaubt es einem, sehr einfach CRUD (Create, Retrieve, Update, Delete) Methoden auf seine Objekte anzuwenden.

Font Konventionen (in Arbeit)

Beginnen wir mit dem Erstellen eines neuen Objekts, der DAO Klasse und der Tests in Appfuse Projekt Struktur.

Inhaltsverzeichnis

Ein neues Objekt erzeugen und XDoclet tags hinzufügen [#1]

Als Erstes benötigen wir ein Objekt. welches wir persistent speichern wollen. Dafür erzeugen wir ein einfaches "Person" Objekt (im src/dao/**/model Verzeichnis), welches eine ID, einen Vornamen und einen Nachnamen (als Properties) besitzt.




package org.appfuse.model;



public class Person extends BaseObject {

    private Long id;

    private String firstName;

    private String lastName;



    /*

     Getters und Setters mit Hilfe der IDE erzeugen: 

     In Eclipse:

     Rechts-Click -> Source -> Generate Getters and Setters

    */

}

Diese Klasse sollte vom BaseObject

abgeleitet sein, welches folgende 3 abstrakten methoden enthält: (equals(), hashCode() und toString()). Diese benötigt man, um die Person Klasse zu implementieren. Die ersten beiden benötigt Hibernate. Diese Methoden können sehr einfach mit Commonclipse

erzeugt werden. Mehr Informationen über dieses Tool findet man auf Lee Grey's Seite

. Ein anderes Eclipse PligIn, das man nutzen könnte, ist Commons4E

. Ich habe es noch nicht verwendet, deshalb kann ich nichts zur genauen Funktionalität sagen.

Nachdem wir jetzt das POJO erzeugt haben, müssen wir die XDoclet Tags hinzufügen, mit deren Hilfe das Hibernate Mapping Datei erzeugt wird. Diese Mapping Datei wird von Hibernate verwendet, um Objekte → Tabellen und Properties (Variablen) → Spalten zu verbinden.

Zuerst fügen wir einen @hibernate.class

Tag ein, der Hibernate erklärt, welche Tabelle mit diesem Objekt verbunden ist:

Desweiteren müssen wir einen Primär Schlüssel Mapping angeben, da dies zwingend zur Erzeugung der Mapping Datei von XDoclet benötigt wird. Man beachte, dass alle @hibernate.* tags in den JavaDoc Bereich der Getter des POJOs gehören.




    /**

     * @return Returns the id.

     * @hibernate.id column="id"

     *  generator-class="increment" unsaved-value="null"

     */



    public Long getId() {

        return this.id;

    }

Aus dem Objekt mit Hilfe von Ant eine neue Datenbanktabelle erzeugen [#2]

Falls man sich die Person.hbm.xml Datei, die Hibernate für einen erzeugt hat, ansehen will, findet man diese im Verzeichnis build/dao/gen/**/model. Hier der (bisherige) Inhalt der Datei Person.hbm.xml:




<?xml version="1.0"?>



<!DOCTYPE hibernate-mapping PUBLIC

    "-//Hibernate/Hibernate Mapping DTD 2.0//EN" 

    "http://hibernate.sourceforge.net/hibernate-mapping-2.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>

Jetzt fügen wir zusätzliche @hibernate.property

tags für die anderen Spalten (first_name, last_name) hinzu:




    /**

     * @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;

    }

Der einzige Grund, warum in diesem Beispiel das column Attribut hinzugefügt wird, ist, dass der Spaltenname sich vom Attributnamen unterscheidet. Falls die beiden gleich sein sollten, muss man kein column Attribut angeben. Für weitere Informationen kann man einen Blick in die @hibernate.property

Referenz dieses Tags werfen.

Jetzt führt man wieder ant setup-db aus, um die neuen Spalten der Tabelle hinzuzufügen.

Falls man die Größe der Spalten verändern will, kann man das length Attribut im @hibernate.property tag ändern. Falls man dieses Feld als 'benötigt' (NOT NULL) markieren will, fügt man not-null="true" hinzu.

Eine neuen DaoTest erzeugen, um die DAO Klasse mit Hilfe von JUnit zu testen [#3]

Jetzt erzeugen wir einen DaoTest, um zu überprüfen, ob unsere DAO Klasse funktioniert. "Halt, halst," werden sie sagen, "wir haben noch gar keine DAO Klasse erzeugt!" Da haben sie natürlich Recht. Wie auch immer, ich bin der Meinung, dass Test-Driven Eintwicklung

qualitataiv hochwertigere Software hervorbringt. Lange Zeit dachte ich, schreib erst die Tests bevor die Klasse schreibst ist Unsinn. Es kam mir einfach dumm vor. Dann versuchte ich es, und fand heraus, dass es wunderbar funktioniert. Der einzige Grund, warum ich jetzt all diese test-driven Dinge verwende, ist, weil ich herausgefunden habe, dass es immens den Prozesses der Software Entwicklung beschleunigt.

Für den Anfang erzeugt man eine PersonDaoTest.java Klasse im test/dao/**/dao Verzeichnis. Diese Klasse sollte von der Klasse BaseDaoTestCase

abgeleitet werden (die bereits in diesem Package vorhanden ist), einer Unterklasse von Spring's AbstractDependencyInjectionSpringContextTests

Klasse. Diese Superklasse wird zum Laden von Spring's

ApplicationContext (da Spring doe Schichten miteinander verbindet) genutzt, und (optional) zum Laden einer .properties Datei (ResourceBundle), welche den selben Namen wie ihre *Test.class besitzt. Falls sie in diesem BEispiel eine Datei namens PersonDaoTest.properties in dem gleichen Verzeichnis wie das der Datei erzeugen, ist der Inhalt dieser Datei in einer "rb" Variable verfügbar.




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;

    }

}

Der oben stehende Code stellt dar, was wir für einen einfachen Spring Integrationstest benötigen, um unsere PersonDao zu initialisieren und zu zerstören. Spring verwendet dazu "autowiring byType", um die Methode setPersonDao() aufzurufen und damit die Bean "personDao" als eine Abhängigkeit dieser Klasse setzt.

Nun müssen wir überprüfen, ob die CRUD (create, retrieve, update, delete) in unserer DAO Klasse funktionieren. Um dies zu tun erzeugen wir Methoden, die mit "test" (alles klein geschrieben) beginnen. Solange diese Methoden öffentlich sind, müssen sie als Rückgabewert "void" besitzten und keine Argumente besitzen. Sie werden von unserem <junit> task in unserer Ant build.xml Datei aufgerufen. Hier sind ein paar einfache Test um die CRUD Methoden zu überprüfen. Wichtig dabei ist es im Hinterkopf zu behalten, dass jede einzelne dieser Methoden (auch als "Test" bekannt) autonom sein sollte. Folgende Methoden fügt man seiner PersonDaoTest.java Datei hinzu:






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

        }

    }

<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 dem oben beschriebenen Beispiel kann man erkennen, daß wir person.set*(value) aufrufen, um unser Objekt zu befüllen befor wir es speichern. Dies ist in diesem Beispiel einfach, könnte aber sehr aufwendig werden, falls wir z.B. ein Objekt mit 10 benötigten (not-null="true") Attributen speichern wollten. Deshalb habe ich das ResourceBundle im BaseDaoTestCase erstellt. Man erzeugt einfach eine Datei namens PersonDaoTest.properties im sleben Verzeichnis wie die Datei PersonDaoTest.java und definiert die Attributwerte in dieser Datei:

Nun kann man, anstatt person.set* aufzurufen um das Objekt zu befüllen, die Methode BaseDaoTestCase.populate(java.lang.Object) nutzen:

Zurzeit wird der PersonDaoTest noch nicht comilieren, da noch keine PersonDaoHibernate.class im classpath existiert. Diese müssen wir erzeugen. PersonDAO.java ist ein Interface, und PersonDAOHibernate.java ist die Hibernate Implementierung dieses Interfaces. Dann wollen wir diese beiden mal erzeugen.

Eine neue DAO Klasse erzuegen, um CRUD Methoden auf dem Objekt auszuführen [#4]




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

}

Es sei darauf hingewiesen, dass in der obigen Klasse keine Exceptions in den Methoden Signaturen zu finden sind. Dies wird durch die Power von Spring

möglich und wie es Exceptions mit RuntimeExceptions kapselt. Jetzt sollte es möglich sein, den Source Code in src/dao und test/dao zu comilieren, indem man ant compile-dao aufruft. Wie auch immer, wenn man versucht ant test-dao -Dtestcase=PersonDao laufen zu lassen, erhält man den Fehler: No bean named 'personDao' is defined. Dies ist eine Fehlermeldung von Spring - Sie gibt an, dass wir eine Bean mit dem Namen personDAO in der Datei applicationContext-hibernate.xml angeben müssen. Bevor wir dies tun, müssen wir die die Klasse erzeugen, welche das Interface PersonDao implementiert.

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.




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

    }

}

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 we also need to tell it about the Person object.

Spring für das Person Objekt und die PersonDao konfigurieren [#5]

First, we 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.




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

        <value>org/appfuse/model/UserCookie.hbm.xml</value>  

    </list> 

</property>

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




<!-- PersonDao: Hibernate implementation --> 

<bean id="personDao" class="org.appfuse.dao.hibernate.PersonDaoHibernate"> 

    <property name="sessionFactory" ref="sessionFactory"/>

</bean>

Den DaoTest ausführen [#6]

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.

Raible's Wiki

AppFuse

Other Applications

CreateDAO_de

Über dieses Tutorial