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_de
CreateActions_de
CreateDAO_de




JSPWiki v2.2.33

[RSS]


Hide Menu

CreateManager_de


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


Teil II: Neue Manager erzeugen - Eine Anleitung für die Erzeugung von Business Facades, die mit der Datenbank Schicht (DAOs) kommuniziert und das Transaktionsmanagement verwaltet.
Dieses Tutorial benötigt Teil I: Neue DAOs und Objekte in AppFuse anlegen.

About this Tutorial

Dieses Tutorial erklärt, wie mann eine Business Facade Klaasse (Und den dazugehörigen JUnit Test) erzeugt, um mit der DAO Schicht zu kommunizieren, die wir in Teil I erzeugt haben.

Im Kontext von AppFuse wird diese Klasse Manager Klasse genannt. Die hauptsächliche Aufgabe der Klasse besteht darin, die Verbindung zwischen WebLayer und DAO Schicht zu bilden. Sie unterstützt einen auch dabei, die Präsentationsschicht von der Datenbankschicht zu trennen (z.B. für Swing Anwendungen). Businesslogik der Anwendung sollte in die Manager gelegt werden.

In dieser Textformatierung erläutere ich, wie man Dinge in der echten Welt durchführt.

Beginnen wir mit dem Erstellen eines neuen Manager Tests und der Manager in der Architektur von AppFuse.

Inhaltsverzeichnis

  • [1] Einen neuen Manager Test erstellen, um JUnit Tests auf dem Manager auszuführen
  • [2] Einen neuen Manager erstellen, um mit der DAO Schicht zu kommunizieren
  • [3] Spring für diesen Manager und die Transaktionen konfigurieren
  • [4] Den Manager Test ausführen

Einen neuen Manager Test erstellen, um JUnit Tests auf dem Manager auszuführen [#1]

Im Teil I haben wir ein Person Objekt und eine PersonDao erzeugt - also entwickeln wir weiter an dieser Einheit. Zuerst sollten wir einen JUnit Test für den PersonManager erzeugen. Man erzeugt den PersonManagerTest in dem Verzeichnis test/service/**/service. Wir wollen die selben grundlegenden Methoden (get, save, remove) testen, die auch in unserer DAO vorkommen.

Das mag einem redundant vorkommen (Warum diese ganzen Tests!), aber diese Test sind fantastisch, wenn man nur noch 6 Monate bis zum Ende des Projekts vor sich hat.

Diese Klasse sollte von der Klasse BaseManagerTestCase abgeleitet werden, die bereits im service Package vorliegt. Diese Klasse (BaseManagerTestCase) stellt ähnliche Funktionen bereit wie die Klasse BaseDaoTestCase.

Normalerweise öffne (open → save as) ich einen bereits existierenden Test (z.B. UserManagerTest.java) und suche/ersetze [Uu]ser mit [Pp]erson, oder wie auch immer der Name des Objekts lautet.

Der untenstehende Code ist das einzige, was man für einen einfachen JUnit Test für den Manager benötigt. Anders als der DaoTest nutzt dieser Test jMock, um den Manager von seinen Abhängigkeiten zu befreien und ihn so zu einem echten "Unit" Test zu machen. Dies kann sehr hilfreich sein, da es einem erlaubt, Business Logik zu testen, ohne sich Sorgen um andere Abhängigkeiten zu machen. Der untenstehende Code erzeugt für die Tests einfach den Manager und seine Abhängigkeiten (als Mocks).


package org.appfuse.service;

import java.util.List;
import java.util.ArrayList;

import org.appfuse.dao.PersonDao;
import org.appfuse.model.Person;
import org.appfuse.service.impl.PersonManagerImpl;

import org.jmock.Mock;
import org.springframework.orm.ObjectRetrievalFailureException;

public class PersonManagerTest extends BaseManagerTestCase {
    private final String personId = "1";
    private PersonManager personManager = new PersonManagerImpl();
    private Mock personDao = null;
    private Person person = null;

    protected void setUp() throws Exception {
        super.setUp();
        personDao = new Mock(PersonDao.class);
        personManager.setPersonDao((PersonDaopersonDao.proxy());
    }

    protected void tearDown() throws Exception {
        super.tearDown();
        personManager = null;
    }
}

Nachdem wir jetzt das Gerüst für diese Klasse erzeugt haben, müssen wir ihn noch mit Inhalt befüllen: Die Testmethoden, die sicherstellen, dass alles funktioniert. Hier ist ein Ausschnitt aus dem DAO Tutorial, um einfacher zu verstehen, was wir gleich machen werden.

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

Jetzt fügt man folgende Methoden zur Datei PersonManagerTest.java hinzu:


    public void testGetPerson() throws Exception {
        // set expected behavior on dao 
        //Das erwartete Verhalten fuer die DAO definieren
        personDao.expects(once()).method("getPerson")
            .will(returnValue(new Person()));
        person = personManager.getPerson(personId);
        assertTrue(person != null);
        personDao.verify();
    }

    public void testSavePerson() throws Exception {
        // set expected behavior on dao
        //Das erwartete Verhalten fuer die DAO definieren
        personDao.expects(once()).method("savePerson")
            .with(same(person)).isVoid();

        personManager.savePerson(person);
        personDao.verify();
    }    

    public void testAddAndRemovePerson() throws Exception {
        person = new Person();

        // set required fields
        //Benoetigte Felder stetzen
        person.setFirstName("firstName");
        person.setLastName("lastName");

        // set expected behavior on dao
        //Das erwartete Verhalten fuer die DAO definieren
        personDao.expects(once()).method("savePerson")
            .with(same(person)).isVoid();
        personManager.savePerson(person);
        personDao.verify();

        // reset expectations
        //Erwartungen zurücksetzen
        personDao.reset();

        personDao.expects(once()).method("removePerson").with(eq(new Long(personId)));
        personManager.removePerson(personId);
        personDao.verify();

        // reset expectations
        //Erwartungen zurücksetzen
        personDao.reset();
        // remove
        //Entfernen
        Exception ex = new ObjectRetrievalFailureException(Person.class, person.getId());
        personDao.expects(once()).method("removePerson").isVoid();            
        personDao.expects(once()).method("getPerson").will(throwException(ex));
        personManager.removePerson(personId);
        try {
            personManager.getPerson(personId);
            fail("Person with identifier '" + personId + "' found in database");
        catch (ObjectRetrievalFailureException e) {


            assertNotNull(e.getMessage());
        }
        personDao.verify();
    }

Zur Zeit wird diese Klasse noch nicht komilieren, weil wir das Interface PersonManager noch nicht erzeugt haben.

Ich glaube, dass es sehr witzig ist, wie ich verschiedene Patterns angewendet habe, um Erweiterbarkeit in AppFuse zu ermöglichen. In Wirklichkeit habe ich in den meisten meiner Projekte so viel in einem Jahr gelernt, dass ich die Architektur nicht erweitern will, ich will sie umschreiben. Ich hoffe dass das nicht zu oft passieren wird, indem ich AppFuse mit den meiner Meinung nach besten Lösungen auf dem neuesten Stand halte. Jedes Jahr wird es nur ein Upgrade für AppFuse geben, anstatt Appfuse umzuschreiben. ;-)

Einen neuen Manager erstellen, um mit der DAO Schicht zu kommunizieren [#2]

Zu aller erst erzeugt amn ein Interface mit dem Namen PersonManager.java im Verzeichnis src/service/**/service und definiert die grundlegenden CRUD Methoden für alle implementierenden Klassen. Ich habe die JavaDocs in den Klassen entfernt, um die Darstellung zu verbessern. Die setPersonDao() Methode wird in den meisten Fäällen nicht genutzt. - Sie existiert nur, damit der PersonManagerTest die DAO über das Interface setzen kann..

Wie üblich, dupliziere (open → save as) ich eine bereits existierende Datei (z.B. UserManager.java).


package org.appfuse.service;

import org.appfuse.model.Person;
import org.appfuse.dao.PersonDao;

public interface PersonManager {
    public void setPersonDao(PersonDao dao);
    public Person getPerson(String id);
    public void savePerson(Person person);
    public void removePerson(String id);
}

Jetzt erzeugt wir eine PersonManagerImpl Klasse, die die Methoden des PersonManager Interfaces implementiert. Um dies zu tun, erzeugt man eine neue Klasse im Verzeichnis src/service/**/service/impl und nennt diese PersonManagerImpl.java. Diese sollte von der Klasse BaseManager abgeleitet sein und das Interface PersonManager implementieren.


package org.appfuse.service.impl;

import org.appfuse.model.Person;
import org.appfuse.dao.PersonDao;
import org.appfuse.service.PersonManager;

public class PersonManagerImpl extends BaseManager implements PersonManager {
    private PersonDao dao;

    public void setPersonDao(PersonDao dao) {
        this.dao = dao;
    }

    public Person getPerson(String id) {
        return dao.getPerson(Long.valueOf(id));
    }

    public void savePerson(Person person) {
        dao.savePerson(person);
    }

    public void removePerson(String id) {
        dao.removePerson(Long.valueOf(id));
    }
}

Eine Sache, auf die hingewiesen werden muss, ist die setPersonDao() Methode. Diese Methode wird von Spring genutzt, um die PersonDao an diesen Manager zu binden. Dies wird in der Datei applicationContext-service.xml konfiguriert. Zu diesem Punkt werden wir in Schritt 3[3] kommen. Jetzt sollte es möglich sein, alles mit der Hilfe von "ant compile-service" zu kompilieren.

Jetzt muss man die Konfigurationsdatei von Spring editieren, damit unsere Service Schicht diesen neuen Manager kennt.

Spring für diesen Manager und die Transaktionen konfigurieren [#3]

Um unser PersonManager Interface und die dazugehörige Implementierung in Spring bekanntzumachen, öffnet man die Datei src/service/**/service/applicationContext-service.xml. In dieser Datei kann man eine auskommentierte Definition für die "personManager" Bean finden. Man entfernt diesen Kommentar, oder fügt folgende Zeilen am Ende der Datei ein.


    <bean id="personManager" parent="txProxyTemplate">
        <property name="target">
            <bean class="org.appfuse.service.impl.PersonManagerImpl" autowire="byName"/>
        </property>
    </bean>

Das "parent" Attribut bezieht sich auf eine Beandefinition für eine TransactionProxyFactoryBean , die alle grundlegenden Transaktionsattribute bereits gesetzt hat.

Den Manager Test ausführen [#4]

Jetzt speichert man alle Tests und versucht, ant test-service -Dtestcase=PersonManager auszuführen.

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


Die Dateien, die bis zu diesem Punkt geändert oder erstellt wurden, sind zum Download verfügbar.

Next Up: Teil III: Actions und JSPs erstellen - Eine Anleitung zur Erstellung von Actions und JSPs in der Architektur von AppFuse.



Go to top   More info...   Attach file...
This particular version was published on 06-Nov-2006 13:52:49 MST by PeterSchneider-Manzell.