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
Articles_de
CreateManager_de
LeftMenu




JSPWiki v2.2.33

[RSS]


Hide Menu

CreateDAO_de


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


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.

Now we'll create a DaoTest to test that our DAO works. "Wait a minute," you say, "we haven't created a DAO!" You are correct. However, I've found that Test-Driven Development 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.

To start, create a PersonDaoTest.java class in the test/dao/**/dao directory. This class should extend BaseDaoTestCase, a subclass of Spring's AbstractDependencyInjectionSpringContextTests which already exists in this package. This parent class is used to load Spring's 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.

I usually copy (open → save as) an existing test (i.e. UserDaoTest.java) and find/replace [Uu]ser with [Pp]erson, or whatever the name of my object is.


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

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

Now we need to actually test that the CRUD (create, retrieve, update, delete) methods work in our DAO. To do this we created 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 our <junit> task in our Ant build.xml file. Here's 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:



    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 the testGetPerson method, we'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 our 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 we're calling person.set*(value) to populate our object before saving it. This is easy in this example, but it could get quite cumbersome if we'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
Then, rather than calling person.set* to populate your objects, you can use the BaseDaoTestCase.populate(java.lang.Object) method:


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

At this point, the PersonDaoTest class won't compile yet because there is no PersonDao.class in our classpath, we need to create it. PersonDAO.java is an interface, and PersonDAOHibernate.java is the Hibernate implementation of that interface. Let's go ahead and create those.

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

First off, create a PersonDao.java interface in the src/dao/**/dao directory and specify the basic CRUD methods for any implementation classes. I've eliminated the JavaDocs in the class below for display purposes.


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

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 we need to specify a bean named personDAO in applicationContext-hibernate.xml. Before we do that, we 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.


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

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> 

You could also use autowire="byName" to the <bean> and get rid of the "sessionFactory" property. Personally, I like having the dependencies of my objects documented (in XML).

Den DaoTest ausführen [#6]

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

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:49 MST by PeterSchneider-Manzell.