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_pt
CreateDAO_es
SandBox




JSPWiki v2.2.33

[RSS]


Hide Menu

CreateManager_es
Search Wiki:
Your trail:

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

Parte II: Creating new Managers - Instrucciones para crear Fachadas de Logica de Negocios (Business Facades) que interaccionan con la capa de acceso a datos (DAO) y manejan todo lo relacionado con la gestion de transacciones.
Este tutorial depende de Part I: Creating new DAOs and Objects in AppFuse.

Sobre este tutorial

Este tutorial te mostrara como crear clases del tipo Business Facada (asi como test unitario ) para interactuar ,con la capa DAO creada in Part I.

En el contexto de AppFuse, crearemos lo que se llama una clase Manager. Su principal objetivo es la de servir de puente entre la capa de persistencia DAO y la capa de presentacion. Tambien permite aislar la capa de presentacion de la capa de persistencia(i.e. para aplicaciones Swing ). Ademas, contienen toda la logica de la aplicacion.

Te voy a decir como yo hago las cosas en la practica.

Vamos a empezar creando una clase ManagerTest y otra clase Manager en la arquitectura de AppFuse.

Tabla de Contenidos

  • [1] Crear una nueva clase ManagerTest para ejecutar tests JUnit con relacion a la clase Manager.
  • [2] Crear una nueva clase Manager que interaccionara con la capa DAO.
  • [3] Configurar Spring para la clase Manager y gestion de transacciones.
  • [4] Ejecutar la clase ManagerTest

Crear una nueva clase ManagerTest para ejecutar tests JUnit con relacion a la clase Manager. [#1]

En Part I,creamos una clase Person y PersonDao - por lo que vamos a seguir desarrollando esta entidad. Primero, crearemos una nueva clase de prueba JUnit para probar la clase PersonManager. Crea la clase PersonManagerTest en el directorio test/service/**/service. Vamos a probar los metodos basicos (leer, anadir, eliminar) que contiene nuestra clase.
El hecho de tener tantas clases de prueba puede parecer redundante, sin embargo, veras como dentro de 6 meses nos seran de mucha ayuda.

Esta clase debe heredar la clase BaseManagerTestCase|http://raibledesigns.com/downloads/appfuse/api/org/appfuse/service/BaseManagerTestCase.java.html], la cual ya existe en el paquete service . La clase padre (BaseManagerTestCase) tiene un proposito similar a la clase BaseDaoTestCase.

Normalmente copio (open → save as) una clase prueba existente(i.e. UserManagerTest.java) y encuentro/reemplazo [Uu]ser por [Pp]erson, o cualquiera que sea el nombre del objeto a probar.

El siguiente codigo es lo que necesitas para una prueba basica de tu clase Manager. A diferencia de la clase DaoTest, esta prueba usa jMock para aislar la clase Manager de sus dependencias , permitiendo asi una verdadera prueba unitaria. Esto puede ser muy util ya que permite probar la logica sin tener que preocuparnos de las clases dependientes. El codigo simplemente asigna la clase Manager y sus dependencias (como Mocks) para la prueba.


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

Ahora que tienes la estructura basica necesitamos hacerlo mas detallado. Vamos a anadir los metodos de prueba para asegurarnos que todo funcionoa como debe ser. A continuacion te muestro un extracto del tutorial DAO Tutorial que te ayudara a entender lo que vamos a implementar.

...Creamos metodos que empiecen con "test" (en minusculas). Siempre que los metodos sean publicos, devuelvan void y no acepten parametros de entrada, seran ejecutados a partir de la tarea <junit> task que se encuentra en el fichero Ant build.xml. Aca puedes encontrar sencillas pruebas para operaciones de Anadir/Lectura/Actualizacion/Supresion (ALAS). Es importante notar que cada metodo (tambien cada test), debe ser autonomo.

Anade los metodos siguientes a la clase PersonManagerTest.java:


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

Esta clase no compilara todavia porque no hemos creado la interface PersonManager.

Es gracioso ver como he aplicado varios patrones de diseno para permitir la _extensibilidad_ en AppFuse. En realidad,en la mayoria de los proyectos en los que he tomado parte, no quiero extender la arquitectura sino reescribirlo todo. Ojala que con AppFuse todo solo un mejoramiento de la arquitectura y no una reescritura de codigo ;-)

Crear una nueva clase Manager que interaccione con la capa DAO [#2]

Primeramente, crearemos la interface PersonManager.java en el directorio src/service/**/service directory y anadiremos las cuatro operaciones basicas (ALAS) que son necesarias para cualquier clase que implemente esta interface. He eliminado las JavaDocs en la clase para mostrarlo mejor. El metodo setPersonDao() no es usado en la mayoria de los casos- solo existe para que la clase PersonManagerTest asigne el DAO en la interface.

Como de costumbre, normalment duplico (open → save as) una clase existente (i.e. 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);
}

Ahora crearemos la clase PersonManagerImpl que implementa los metodos de la interface PersonManager. Para ello, creamos una nueva clase PersonManagerImpl.java en el subdirectorio src/service/**/service/impl. Debe heredar de la clase BaseManager e implementar 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));
    }
}

Un aspecto a notar es el metodo setPersonDao() el cual es usado para "enganchar" la clase PersonDao a este Manager. Esto es configurado en el fichero applicationContext-service.xml. Configuraremos este aspecto en el paso 3[3]. Ahora todo debe compilar sin problemas usando la linea de comandos "ant compile-service".

Ahora necesita editar el fichero de configuracion de Spring para que la capa de servicios se actualice con la recien creada clase Manager.

Configurar Spring para este Manager y gestion de transacciones [#3]

Para notificar a Spring de la presencia de la interface PersonManager y su implementacion, editemos el fichero src/service/**/service/applicationContext-service.xml file. Alli debe ver la definicion del bean "personManager" comentada. Elimine el comentario o anada lo siguiente al final del fichero.


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

El atributo "parent" se refiere a la definicion de bean para TransactionProxyFactoryBeanque contiene todos los atributos basicos para la gestion de transacciones.

Ejecute la clase ManagerTest [#4]

Guarde los ficheros editados y ejecute ant test-service -Dtestcase=PersonManager.

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

Los ficheros que fueron modificados y anadidos en este tutorial se encuentran en available for download.

Siguiente etapa: Parte III: Creacion de Actions y JSPs - Como crear Actions y JSPs en la arquitectura de AppFuse.


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