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

Edit this page


Referenced by
Articles
Articles_de
CreateManager_de
LeftMenu




JSPWiki v2.2.33

[RSS]


Hide Menu

CreateDAO_de


Part I: Neue DAOs und Objekte in AppFuse anlegen - Eine Anleitung zum Erstellen von Java Objekten (welche Tabellen darstellen) und Java Klassen, um diese Objekte persistent in einer Datenbank abzulegen.

Über dieses Tutorial

Dieses Tutorial erläutert, wie man eine neue Tabelle in der Datenbank anlegt und wie man Java Code erzeugt, um auf diese Tabelle zuzugreifen.

Zuerst werden wir ein Objekt erstellen und anschliessend weitere Klassen, um dieses Objekt in eine Datenbank zu speichern, wieder auszulesen und zu löschen. In der Java Sprache nennt sich dieses Objekt ein Plain Old Java Object (auch bekannt als POJO). Dieses Objekt stellt hauptsächlich eine Datenbanktabelle dar. Die anderen Klassen sind folgende:

  • Ein Datenzugriffsobjekt (Data Access Object (auch bekannt als DAO), ein Interface Interface und eine Hibernate Implementierung
  • Eine JUnit Klasse, um zu testen, ob unser DAO-Objekt richtig funktioniert.

Hinweis: Falls man MySQL verwendet und Transaktionen genutzt werden sollen (was normalerweise der Fall ist), muss man InnoDB Tabellen nutzen. Um dies zu tun, muss man folgende Zeilen zur MySQL Konfigurationsdatei hinzufügen: (/etc/my.cnf oder c:\Windows\my.ini). Die 2. Zeile (Für UTF-8 character set) benötigt man für MySQL Versionen ab 4.1.7+.
[mysqld]
default-table-type=innodb
default-character-set=utf8

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.

Man kann auch iBATIS als Persistenz Framework verwenden. Weitere Informationen, um iBATIS in AppFuse zu installieren, findet man in der README.txt in extras/ibatis. Falls man IBatis über Hibernate nutzen will, gehe ich davon aus, dass man gute Gründe dafür hat und sich mit dem Framework auskennt. Ich nehme auch an, dass man sich selbst vorstellen kann, wie man dieses Tutorial in Zusammenhang mit IBatis nutzen sollte. ;-)

Font Konventionen (in Arbeit)

Zeichenketten die über die Kommandozeile ausgeführt werden sollen, sehen folgendermasen aus: ant test-all.
Verweise auf Dateien, Verzeichnisse und Pakete, welche im Sourceverzeichnis existieren: build.xml.
und Vorschläge, wie man Dinge in der "realen Welt" durchführt, sind blau und schräg gestellt.

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

Inhaltsverzeichnis

  • [1] Ein neues Objekt erzeugen und XDoclet tags hinzufügen
  • [2] Aus dem Objekt mit Hilfe von Ant eine neue Datenbanktabelle erzeugen
  • [3] Eine neuen DaoTest erzeugen, um die DAO Klasse mit Hilfe von JUnit zu testen
  • [4] Eine neue DAO Klasse erzuegen, um CRUD Methoden auf dem Objekt auszuführen
  • [5] Spring für das Person Objekt und die PersonDao konfigurieren
  • [6] Den DaoTest ausführen

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.

Hinweis: Der Java Code in diesem Tutorial kann man nicht mit mit dem Firefox Browser kopieren. Als Notlösung führt man CTRL+Click (Command+Click mit OS X) auf dem Code Block aus und kopiert ihn anschliessend.


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.

Wenn man IntelliJ IDEA verwendet, kann man die equals() und hashCode() erzeugen, aber nicht die toString() Methode. Es gibt aber ein ToStringPlugin, das anscheinend ganz gut funktioniert.
Hinweis: Falls die Installation dieser PlugIns nicht funktioniert, findet man alle diese Methoden in dem Person.java Objekct, welches zum Testen von AppGen verwendet wird. Einfach in der Datei extras/appgen/test/dao/org/appfuse/model/Person.java danach suchen, und per "Copy and Paste" in die gerade erstellte Datei kopieren.

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:


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

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

Ich verwende generator-class="increment" anstattgenerate-class="native", weil ich einige Probleme entdeckt habe, wenn man "native" mit anderen Datenbanken nutzt. Falls man plant, nur MySQL zu nutzen, empfehle ich die "native" Einstellung zu nutzen. Dieses Tutorial ntzt "increment".

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

An dieser Stelle kann man die person Tabelle erzeugen, in dem man ant setup-db ausführt. Dieser task generiert die Datei Person.hbm.xml und erzeugt eine Datenbanktabelle mit dem Namen "person". In der ant console kann man das Schema finden, das Hibernate für einen erstellt:
[schemaexport] create table person (
[schemaexport]    id bigint not null,
[schemaexport]    primary key (id)
[schemaexport] );

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.

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

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]

Hinweis: AppFuse Versionen 1.6.1+ besitzen ein AppGen Tool, das man vwerwenden kann, um alle restlichen Klassen dieses Tutorials zu erzeugen. Wie auch immer, am besten ist es, wenn man dieses Tutorial durcharbeitet, bevor man das Tool nutzt - Dann weiß man, welchen Code das Tool erzeugt.

Jetzt erzeugen wir einen DaoTest, um zu überprüfen, ob unsere DAO Klasse funktioniert. "Halt, halt," 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 qualitativ hochwertigere Software hervorbringt. Lange Zeit dachte ich, schreib erst die Tests bevor du 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 Prozess 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.

Ich kopiere (open → save as) normalerweise einen bereits vorhandenen Test (z.B. UserDaoTest.java) und suche/ersetze [Uu]ser mit [Pp]erson, oder wie auch immer der Name meines Objektes lautet.


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

In der Methode testGetPerson erzeugen wir eine Person und rufen dann ein get auf. Ich füge normalerweise einen Datensatz in die Datenbank ein, den ich jederzeit nutzen kann. Seitdem DBUnit genutzt wird, um die Datenbank mit Testwerten zu befüllen bevor die Tests ausgeführt werden, kann man einfach eine neue Tabelle / Datensatz in der Datei metadata/sql/sample-data.xml hibzufügen:

<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>
Auf diesem Weg kann man die "create new" Funktionalität in der testGetPerson Methode elimieren. Falls man den Datensatz lieber direkt (mit Hilfe von SQL oder einer GUI) in die Datenbank einfügen will, kann man die sample-data.xml Datei mit Hilfe des ant db-export Befehls und anschliessend cp db-export.xml metadata/sql/sample-data.xml erzeugen.

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:

Ich tendiere dazu, Testwerte hart in den JavaCode einzubinden - aber die properties Datei ist eine andere Möglichkeit, die wunderbar für große Objekte funktioniert.
firstName=Matt
lastName=Raible

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


person = new Person();
person = (Personpopulate(person);

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]

Zuallererst erzeugt man ein PersonDao.java Interface im Verzeichnis src/dao/**/dao und spezifiziert die einfachen CRUD Methoden für beliebige implementierende Klassen. Ich habe die JavaDocs in der unten stehenden Klasse entfernt, um die Anzeige übersichtlicher zu halten.


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.

Der ant taskfür die Ausführung der dao Tests lautet test-dao. Falls man einen Testcase Parameter mitangibt (in dem man -Dtestcase=name verwendet), sucht ant nach der Datei **/*${testcase}* - Dies erlaubt es uns als Parameter Person, PersonDao, oder PersonDaoTest zu verwenden - alle werden veranlassen, dass die PersonDaoTest class ausgeführt wird.

Beginnen wir mit der Erstellung einer PersonDaoHibernate Klasse, die die Methoden von PersonDao implementiert und Hibernate nutzt, um das Person Objekt zu laden / zu speichern / und zu löschen. Um dies zu tun, erzeugt man eine neue Klasse im Verzeichnis src/dao/**/dao/hibernate und nennt diese PersonDaoHibernate.java. Sie sollte von der Klasse BaseDaoHibernate abgeleitet sein und das Interface PersonDao implementieren. Zur Kürzung wurden die Javadocs entfernt.


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 = (PersongetHibernateTemplate().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));
    }
}

Wenn man jetzt versucht ant test-dao -Dtestcase=PersonDao auszuführen, erhält man den selben Fehler. Wir müssen noch Spring so konfigurieren, dass es weiß, dass PersonDaoHibernate die implementierende Klasse zum Interface PersonDao ist. Desweiteren müssen wir Spring mehr über das Objekt Person erzählen.

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

Zuerst müssen wir Spring erklären, wo die Hibernate Mapping Datei zu finden ist. Um dies zu tun, öffnet man src/dao/**/dao/hibernate/applicationContext-hibernate.xml und fügt "Person.hbm.xml" zum folgenden Codeblock hinzu.


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

Jetzt müssen wir dieser Datei noch ein wenig XML hinzufügen, um PersonDaoHibernate an PersonDao zu binden. Um dies zu tun, fügt man folgende Zeilen am Ende der Datei ein:


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

Man könnte auch autowire="byName" zu <bean> hinzufügen, und würde so um die "sessionFactory" property herumkommen. Persönlich mag ich es aber, wenn die Abhängligkeiten meiner Objekte dokumentiert ist (in XML).

Den DaoTest ausführen [#6]

Jetzt speichert man alle editierten Dateien und versucht ant test-dao -Dtestcase=PersonDao noch einmal auszuführen.

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


Next Up: Teil II: Neue Manager erzeugen - Eine Anleitung, wie man A Business Facades erzeugt, welche den Session Facades ähneln, aber keine EJBs nutzen. Diese facades werden genutzt, um die Kommunikation zwischen dem Front End und der DAO Schicht zu ermöglichen.



Go to top   Edit this page   More info...   Attach file...
This page last changed on 06-Nov-2006 13:53:00 MST by MattRaible.