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

        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

        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

        person.setFirstName("firstName");

        person.setLastName("lastName");



        // set expected behavior on dao

        personDao.expects(once()).method("savePerson")

            .with(same(person)).isVoid();

        personManager.savePerson(person);

        personDao.verify();



        // reset expectations

        personDao.reset();



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

        personManager.removePerson(personId);

        personDao.verify();



        // reset expectations

        personDao.reset();

        // remove

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

    }

This class won't compile at this point because we have not created our PersonManager interface.

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

First off, create a PersonManager.java interface in the src/service/**/service directory and specify the basic CRUD methods for any implementation classes. I've eliminated the JavaDocs in the class below for display purposes. The setPersonDao() method is not used in most cases - its just exists so the PersonManagerTest can set the DAO on the interface.




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

}

Now let's create a PersonManagerImpl class that implements the methods in PersonManager. To do this, create a new class in src/service/**/service/impl and name it PersonManagerImpl.java. It should extend BaseManager and implement PersonManager.




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

    }

}

One thing to note is the setPersonDao() method. This is used by Spring to bind the PersonDao to this Manager. This is configured in the applicationContext-service.xml file. We'll get to configuring that in Step 3[3]. You should be able to compile everything now using "ant compile-service".

Now you need to edit Spring's config file for our services layer so it will know about this new Manager.

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

To notify Spring of this our PersonManager interface and its implementation, open the src/service/**/service/applicationContext-service.xml file. In here, you should see a commented out definition for the "personManager" bean. Uncomment this, or add the following to the bottom of this file.

The "parent" attribute refers to a bean definition for a TransactionProxyFactoryBean

that has all the basic transaction attributes set.

Den Manager Test ausführen [#4]

Save all your edited files and try running ant test-service -Dtestcase=PersonManager.

Next Up: Part III: Creating Actions and JSPs - A HowTo for creating Actions and JSPs in the AppFuse architecture.

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]