Raible's Wiki: CreateManager

Parte II: Creare nuovi Manager - Un HowTo sulla creazione di Business Façade che parlino con il livello del database (DAO) e si occupino della gestione delle transazioni.

Informazioni su questo Tutorial

Nel contesto di AppFuse, questa viene denominata una classe Manager. La sua responsibilità principale è comportarsi da ponte fra il layer di persistenza (DAO) ed il layer web. È anche utile per disaccoppiare lo strato di presentazione dallo strato database (i.e. per applicazioni Swing). I Manager dovrebbero inoltre essere il luogo deputato nel quale mettere la business logic della tua applicazione.

Iniziamo con il creare un nuovo ManagerTest ed un nuovo Manager nell'architettura di AppFuse.

Indice

Crea un nuovo ManagerTest per eseguire test JUnit sul Manager [#1]

Questa classe dovrebbe estendere BaseManagerTestCase

, che è già presente nel package service. La classe base (BaseManagerTestCase) fornisce funzionalità analoghe al BaseDaoTestCase.

Il codice qui sotto è tutto ciò di cui hai bisogno per un test JUnit di base del tuo Manager. Diversamente dal DaoTest, questo test usa jMock

per isolare il Manager dalle sue dipendenze e renderlo un vero "unit" test. Ciò può essere di grande aiuto perché ti permette di verificare la tua business logic senza preoccuparti delle altre dipendenze. Il codice sottostante semplicemente inizializza il Manager e le sue dipendenze (come Mock) per effettuare i test.




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;

    }

}

Ora che lo scheletro della classe è fatto, devi aggiungervi la carne: i metodi di test per far sì che tutto funzioni. Qui c'è un frammento tratto dal Tutorial su DAO che ti aiuterà a caipre cosa stiamo per fare.




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

    }

A questo punto questa classe non compilerà perché non abbiamo ancora creato la nostra interfaccia PersonManager.

Crea un nuovo Manager per parlare con il DAO [#2]

Per primo, crea un'interfaccia PersonManager.java nella directory src/service/**/service e specifica i metodi CRUD di base in tutte le classi che la implementano. Ho rimosso i JavaDoc nella classe sotto per motivi di visualizzazione. Il metodo setPersonDao() nella maggior parte dei casi non è usato - esiste giusto per permettere al PersonManagerTest di poter impostare il DAO sull'interfaccia.




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

}

Ora creiamo una classe PersonManagerImpl che implementi i metodi in PersonManager. Per far questo, crea una nuova classe in src/service/**/service/impl e chiamala PersonManagerImpl.java. Deve estendere BaseManager ed implementare 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));

    }

}

Una cosa da notare è il metodo setPersonDao(). Questo è usato da Spring per legare il PersonDao a questo Manager. Ciò è configurato nel flie applicationContext-service.xml. Arriveremo a configurare quello nel Passo 3[3]. Dovresti riuscire a compilare tutto ora con "ant compile-service".

Ora devi modificare il file di configurazione di Spring per il nostro strato servizi in modo che sappia dell'esistenza di questo nuovo Manager.

Configura Spring per questo Manager e relative Transaction [#3]

Per notificare a Spring l'esistenza della nostra interfaccia PersonManager e della relativa implementazione, apri il file src/service/**/service/applicationContext-service.xml. Aggiungi quanto segue al termine di questo file.

Questo bean deve avere un nome che termina con "Manager". Deve essere così, in quanto esiste un advice AOP che viene applicato su questo file per tutti i bean *Manager.

Esegui il ManagerTest [#4]

Registra tutti i file da te modificati e prova ad eseguire ant test-service -Dtestcase=PersonManager.

I file che sono stati modificati ed aggiunti fino a questo punto sono disponibili in download

Prossima Puntata: Parte III: Creare Action e JSP - Un HowTo per la creazione di Action e JSP nell'architettura di AppFuse.

Raible's Wiki

AppFuse

Other Applications