Um pouco sobre a arquitetura do ScrumToys

O ScrumToys é um projeto que nasceu com o propósito de demonstrar o maior número possível de funcionalidades do JSF 2.0. Contudo, o ScrumToys vai alem e realiza alguns desafios que foram encontrados durante o seu refactoring para ser incorporado à versão final do NetBeans 6.8.

A primeira versão!

A primeira versão do ScrumToys foi desenvolvida aplicando efetivamente o padrão de projeto MVC. Através deste padrão, a camada view foi implementada com os componentes visuais do JSF, a camada controller foi implementada através de Managed Beans configurados via anotações e a camada model se distribuía em classes JavaBeans para realizar alguns componentes de negócios, entidades persistentes (JPA) e persistência através de Data Access Objects (DAOs). Estas várias camadas realizavam o ScrumToys para rodar no JBossAS 4.2.3 com banco de dados baseado no MySQL Database Server 5.0. Além disso, o projeto foi criado inicialmente através do Eclipse.

O refactoring!

Para simplificar ao máximo esta aplicação de demonstração, esta passou por um refactoring completo na camada model, além de uma revisão detalhada da camada de apresentação (view e controller). Neste refactoring, foi necessário tomar algumas decisões em prol da simplicidade que deixariam qualquer desenvolvedor purista de cabelos em pé. Algumas destas decisões envolveram:

• Migrar o projeto do Eclipse para o NetBeans (inicialmente o NetBeans 6.7.1);
• Alterar e eliminar possíveis configurações da aplicação Web para rodar no Glassfish sem a necessidade de configurações extras (tornando-o plug'n play);
• Usar o banco de dados JavaDB (antigo Derby) que já vem integrado numa instalação padrão do NetBeans e do Glassfish. Isso eliminaria a necessidade de instalar um MySQL, criar um usuário e um esquema no banco;
• Simplificar a configuração do JPA para usar o TopLink ou Eclipse Essentials, além de criar o banco de dados automaticamente no esquema padrão que já existe no JavaDB do NetBeans. Notamos que o Glassfish v2 (ainda Java EE 5) usa o TopLink como implementação de JPA 1.0 e o Glassfish v3 (que já é Java EE 6 e está embutido no NetBeans 6.8) usa o Eclipse Essentials, como implementação de JPA 2.0 (código aberto e doado do TopLink pela Oracle para o Eclipse.org, considerada a implementação de referência do JPA).
• E agora a decisão de projeto mais radical e ofensiva para alguns desenvolvedores: simplificar a camada model ao eliminar componentes de negócios e todos os Data Access Object. Assim, a lógica necessária para persistência e manipulação das entidades de negócios seriam implementadas na camada controller (dentro dos Managed Beans).

A última decisão de projeto, levou a uma arquitetura muito mais simples em detrimento da organização comumente recomendada para as camadas de uma aplicação web robusta e escalonável. Mas, esta arquitetura permitiu evitar o uso de Enterprise JavaBeans para o gerenciamento do contexto de persistência e demarcação de transação com recursos do EJB Container. Aspecto que fugiria do escopo do projeto e do propósito inicial da demonstração implementada. Contudo, mesmo ao eliminar os DAOs, a aplicação ainda precisaria ter acesso ao contexto de persistência (JPA) e realizar a demarcação da transação (neste caso, demarcação programática) dentro dos Managed Beans.

Uma nova arquitetura!

A segunda versão da aplicação, após o refactoring, passou a oferecer uma arquitetura simples através de classes que realizam simplesmente o propósito de demonstrar o maior número possível de funcionalidades do JSF 2.0, sem desviar a atenção para outras tecnologias que constituem o Java EE 6.

Como parte do processo de simplificação da arquitetura e para atender a necessidade de gerenciar um contexto de persistência e demarcação dentro dos Managed Beans da camada controller, a seguinte classe abstrata foi implementada para servir de base para todos os Managed Beans implemenatados.

package jsf2.demo.scrum.web.controller;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.PersistenceUnit;
import javax.persistence.EntityManagerFactory;
import javax.transaction.UserTransaction;
// Outros imports foram omitidos ...

/**
  * @author Dr. Spock (spock at dev.java.net)
  */
public abstract class AbstractManager {

  @PersistenceUnit
  private EntityManagerFactory emf;
  @Resource
  private UserTransaction userTransaction;

  protected final <T> T doInTransaction(PersistenceAction<T> action)
            throws ManagerException {
    EntityManager em = emf.createEntityManager();
    try {
      userTransaction.begin();
      T result = action.execute(em);
      userTransaction.commit();
      return result;
    } catch (Exception e) {
      try {
        userTransaction.rollback();
      } catch (Exception ex) {
        Logger.getLogger(AbstractManager.class.getName()).log(Level.SEVERE,
                     null, ex);
      }
      throw new ManagerException(e);
    } finally {
      em.close();
    }
  }

  protected final void doInTransaction(PersistenceActionWithoutResult action)
          throws ManagerException {
    EntityManager em = emf.createEntityManager();
    try {
      userTransaction.begin();
      action.execute(em);
      userTransaction.commit();
    } catch (Exception e) {
      try {
        userTransaction.rollback();
      } catch (Exception ex) {
        Logger.getLogger(AbstractManager.class.getName()).log(Level.SEVERE,
                     null, ex);
      }
      throw new ManagerException(e);
    } finally {
      em.close();
    }
  }

  protected static interface PersistenceAction<T> {
    T execute(EntityManager em);
  }

  protected static interface PersistenceActionWithoutResult {
    void execute(EntityManager em);
  }

  // Alguns outros métodos foram omitidos

}

Esta classe aplica os padrões de projeto Template Method e Strategy ao disponibilizar o método doInTransaction() que demarca a transação via JTA e permite receber o algoritmo de persistência através de uma implementação de callback ao realizar a "inner" interface PersistenceAction ou PersistenceActionWithoutResult. Esta implementação foi inspirada em classes presentes na arquitetura do Spring Framework chamadas de Template que encapsulam códigos padrões.

Como os Managed Beans são componentes gerenciados e deverão herdar o código base apresentado acima, o Web Container Java EE 6 realizará a injeção de dependência ao fornecer referências válidas de objetos aos atributos dos tipos EntityManagerFactory e UserTransaction.

O diagrama a seguir ilustra a estrutura básica dos Managed Beans implementados no ScrumToys usando a classe abstrata acima como base.


O Managed Bean ProjectManager herdará a capacidade de persistência e já terá uma demarcação simples de transação através dos métodos Template doInTransaction(). A seguir está um fragmento de código deste controller.

package jsf2.demo.scrum.web.controller;

import jsf2.demo.scrum.model.entities.Project;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
// Outros imports foram omitidos

/**
  * @author Dr. Spock (spock at dev.java.net)
  */
@ManagedBean(name = "projectManager")
@SessionScoped
public class ProjectManager extends AbstractManager
           implements Serializable {

  private static final long serialVersionUID = 1L;
  private Project currentProject;
  private DataModel<Project> projects;
  private List<SelectItem> projectItems;
  private List<Project> projectList;

  @PostConstruct
  public void construct() {
    this.currentProject = new Project();
    init();
  }

  // ...

  public void init() {
    try {
      setProjectList(doInTransaction(new PersistenceAction<List<Project>>() {
        public List<Project> execute(EntityManager em) {
          Query query = em.createNamedQuery("project.getAll");
          return (List<Project>) query.getResultList();
        }
      }));
    } catch (ManagerException ex) {
      Logger.getLogger(ProjectManager.class.getName()).log(Level.SEVERE,null,ex);
    }
    projectItems = new LinkedList<SelectItem>();
    projectItems.add(new SelectItem(new Project(), "-- Select one project --"));
    if (getProjectList() != null) {
      projects = new ListDataModel<Project>(getProjectList());
      for (Project p : getProjectList()) {
        projectItems.add(new SelectItem(p, p.getName()));
      }
    }
  }

  // ...

  public String remove() {
    final Project project = projects.getRowData();
    if (project != null) {
      try {
        doInTransaction(new PersistenceActionWithoutResult() {
          public void execute(EntityManager em) {
            if (em.contains(project)) {
              em.remove(project);
            } else {
              em.remove(em.merge(project));
            }
          }
        });
        getProjectList().remove(project);
      } catch (Exception e) {
        Logger.getLogger(getClass()).log(Level.SEVERE, 
           "Error on try to remove Project: " + getCurrentProject(), e);
        addMessage("Error on try to remove Project", FacesMessage.SEVERITY_ERROR);
        return null;
      }
    }
    init();
    // Using implicity navigation, this request come from /projects/show.xhtml
    // and directs to /project/show.xhtml could be null instead
    return "show";
  }
  
  // Alguns métodos foram omitidos.
  
}

Veja, no código acima, as linhas 33 a 38 que aplica o uso do Template Method doInTransaction() e do callback do tipo PersistenceAction para recuperar da base de dados todas as instancias persistidas de projetos. Este trecho de código herda o gerenciamento do EntityManager (abri e fechar) e a demarcação de transação (begin/commit/rollback). Outro exemplo se encontra entre as linhas 58 e 66, ao usar o callback do tipo PersistenceActionWithoutResult.

A simplicidade tornando-se referência!

A arquitetura proposta no ScrumToys influenciou a implementação de alguns códigos dos exemplos contidos no livro JavaServer Faces 2.0, The Complete Reference escrito pelo Ed Burns, líder da especificação do JSF 2.0 no JCP, e pelo Chris Schalk, Developer Advocate no Google. Algumas páginas deste livro estão disponívels no Google Books:

JavaServer Faces 2.0, The Complete Reference

Segue abaixo uma página deste livro citando a arquitetura de persistência e gerenciamento de transação implementada na aplicação Virtual Trainer.

Luz, câmera, AÇÃO!

O vídeo a seguir ilustra a criação de um projeto no NetBeans 6.8 para ter acesso aos códigos do ScrumToys e avaliar a implementação da arquitetura proposta em ação.


Para mais informações sobre este projeto:

• JSF 2.0 Demo
• JSF 2.0 e ScrumToys
• JSF 2 Scrum Whiteboard, por Eder Magalhães
• Experimente online: ScrumToys
• Vídeo demo do ScrumToys no LinguÁgil 2009

By Spock
http://blog.spock.com.br/
http://twitter.spock.com.br/
http://www.springbrasil.com.br/
Outros posts: http://blog.globalcode.com.br/search/label/Spock