Raible's Wiki: CreateManager

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.

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

Inhaltsverzeichnis

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.

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.

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((PersonDao) personDao.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.




    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.

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




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.

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.

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.

Raible's Wiki

AppFuse

Other Applications

CreateManager_de

About this Tutorial

Inhaltsverzeichnis

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

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

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

Den Manager Test ausführen [#4]