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
CreateActions
CreateDAO
CreateDAO_sp
CreateDAOiBATIS
CreateDAOiBATIS_ko
CreateManager_es
JSFBeans
SpringControllers
...and 3 more




JSPWiki v2.2.33

[RSS]


Hide Menu

CreateManager
Search Wiki:
Your trail:

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

Part II: Creating new Managers - A HowTo for creating Business Facades that talk to the database tier (DAOs) and handle transaction management.
This tutorial depends on Part I: Creating new DAOs and Objects in AppFuse.

About this Tutorial

This tutorial will show you how to create a Business Facade class (and a JUnit Test) to talk to the DAO we created in Part I.

In the context of AppFuse, this is called a Manager class. It's main responsibility to act as a bridge between the persistence (DAO) layer and the web layer. It's also useful for de-coupling your presentation layer from your database layer (i.e. for Swing apps). Managers should also be where you put any business logic for your application.

I will tell you how I do stuff in the Real World in text like this.

Let's get started by creating a new ManagerTest and Manager in AppFuse's architecture.

Table of Contents

  • [1] Create a new ManagerTest to run JUnit tests on the Manager
  • [2] Create a new Manager to talk to the DAO
  • [3] Configure Spring for this Manager and Transactions
  • [4] Run the ManagerTest

Create a new ManagerTest to run JUnit tests on the Manager [#1]

In Part I, we created a Person object and PersonDao - so let's continue developing this entity. First, let's create a JUnit test for the PersonManager. Create PersonManagerTest in the test/service/**/service directory. We'll want to test the same basic methods (get, save, remove) that our DAO has.
This may seem redundant (why all the tests!), but these tests are GREAT to have 6 months down the road.

This class should extend BaseManagerTestCase, which already exists in the service package. The parent class (BaseManagerTestCase) serves the same functionality as the BaseDaoTestCase - to load a properties file that has the same name as your *Test.class, as well as to initialize Spring's ApplicationContext.

I usually copy (open → save as) an existing test (i.e. UserManagerTest.java) and find/replace [Uu]ser with [Pp]erson, or whatever the name of my object is.

The code below is what we need for a basic JUnit test of our Managers. The code below simply creates and destroys the PersonManager. The "ctx" object is initialized in the BaseManagerTestCase class.


package org.appfuse.service;

import org.appfuse.model.Person;
import org.springframework.dao.DataAccessException;

public class PersonManagerTest extends BaseManagerTestCase {

    private Person person = null;
    private PersonManager mgr = null;

    protected void setUp() throws Exception {
        super.setUp();
        mgr = (PersonManager) ctx.getBean("personManager");
    }

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

Now that we have the JUnit framework down for this class, let's add the meat: the test methods to make sure everything works in our Manager. Here's a snippet from the DAO Tutorial tutorial to help you understand what we're about to do.

...we create methods that begin with "test" (all lower case). As long as these methods are public, have a void return type and take no arguments, they will be called by our <junit> task in our Ant build.xml file. Here's some simple tests for testing CRUD. An important thing to remember is that each method (also known as a test), should be autonomous.

Add the following methods to your PersonManagerTest.java file:


    public void testGetPerson() throws Exception {
        person = mgr.getPerson("1");

        assertNotNull(person.getFirstName());
    }

    public void testSavePerson() throws Exception {
        person = mgr.getPerson("1");
        person.setFirstName("test");

        mgr.savePerson(person);
        assertEquals(person.getFirstName(), "test");
    }

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

        mgr.savePerson(person);
        assertEquals(person.getFirstName(), "Bill");
        assertNotNull(person.getId());

        log.debug("removing person, personId: " + person.getId());

        mgr.removePerson(person.getId().toString());

        try {
            person = mgr.getPerson(person.getId().toString());
            fail("Person found in database");
        } catch (DataAccessException dae) {
            log.debug("Expected exception: " + dae.getMessage());
            assertNotNull(dae);
        }
    }

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

I think it's funny how I've followed so many patterns to allow extendibility in AppFuse. In reality, on most projects I've been on - I learn so much in a year that I don't want to extend the architecture - I want to rewrite it. Hopefully by keeping AppFuse up to date with my perceived best practices, this won't happen as much. Each year will just be an upgrade to the latest AppFuse, rather than a re-write. ;-)

Create a new Manager to talk to the DAO [#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.

As usual, I usually duplicate (open → save as) an existing file (i.e. UserManager.java).


package org.appfuse.service;

import org.appfuse.model.Person;

public interface PersonManager {
    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 Person 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"...

Finally, we need to create the PersonManagerTest.properties file in test/service/**/service so that person = (Person) populate(person); will work in our test.

If you created a PersonDaoTest.properties file in the last tutorial, duplicating (and renaming) it is the easy route. Alternatively, you could set the properties manually.
firstName=Bill
lastName=Joy

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

Configure Spring for this Manager and Transactions [#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.


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

The "parent" attribute refers to a bean definition for a TransactionProxyFactoryBean that has all the basic transaction attributes set.

Run the ManagerTest [#4]

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

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

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


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