O ambiente compatível para o desenvolvimento baseado no Framework Demoiselle é composto de JVM, IDE e Servidor de aplicação.
O Framework Demoiselle é compatível com servidores JEE com container web 2.5. O Tomcat 6.x e JBoss 4.2.x são compatíveis.
Configure o Eclipse para trabalhar com o servidor escolhido e baixe os pacotes do framework.
Crie uma nova aplicação Web e siga a estrutura de projeto como a mencionada abaixo.
Um fator importante de padronização é a estrutura de pacotes que a aplicação implementa, o framework não impede a utilização de uma outra estrutura, apenas propõe uma estrutura que pode ser seguida pelas aplicações. A estrutura de pacotes descreve como os artefatos de desenvolvimento estarão organizados no projeto. Abaixo um exemplo da estrutura de pacotes que pode ser usado com o framework.
+- project
+- src/
+- main/
| +- java/
| | +- defaultpackage/
| | +- bean/
| | +- business/
| | | +- implementation/
| | |
| | +- constant/
| | +- message/
| | +- persistence/
| | | +- dao/
| | | +- implementation
| | |
| | +- view/
| | +- managedbean/
| |
| +- resources/
| | +- hbm/
| | +- demoiselle.properties
| | +- hibernate.cfg.xml
| | +- log4j.properties
| |
| +- jasperreports/
|
+- test/
| +- java/
| +- resources/
|
+- webapp/
+- META-INF/
| +- MANIFEST.MF
|
+- private/
| +- pages/
| | +- default.jsp
| |
| +- resources/
| | +-images/
| | +-scripts/
| | +-styles/
| |
| +- templates/
|
+- public/
| +- pages/
| | +- error/
| | | +- 404.jsp
| | | +- 500.jsp
| | | +- acess.jsp
| | | +- global.jsp
| | |
| | +- security/
| | +- login.jsp
| |
| +- resources/
| | +-images/
| | +-scripts/
| | +-styles/
| |
| +- templates/
|
+- WEB-INF/
| +- faces-config.xml
| +- web.xml
|
+- index.jsp
Copie as bibliotecas do framework e suas depêndencias para a pasta de bibliotecas de projeto web. Geralmente é a pasta /WEB-INF/lib. Na estrutura de projeto definida acima, esta pasta se encontra em /project/src/webapp/WEB-INF/lib
Para configurar o projeto para utilizar o framework Demoiselle, favor abrir a seção 'Configurando o Ambiente'.
A partir daqui, siga os passos da arquitetura de referência.
O framework fornece uma arquitetura de referência que norteia os seus módulos, essa arquitetura define camadas básicas para os sistema construídos a partir do framework. A arquitetura de referência não é obrigatória e pode ser modificada desde que seja respeitada as especificações do módulo lógico Core.
O framework propõe uma arquitetura de camadas para as aplicações. Cada camada é representada por uma interface no módulo lógico Core. A aplicação pode vincular seus objetos de camada implementando essas interfaces, assim o framework vai conhecer os elementos de cada camada atuando neles quando necessário. O processo é similar para as demais camadas.
package defaultpackage.business;
public interface IUseCaseBusinessController extends IBusinessController {
...
}
package defaultpackage.business.implementation;
public class UseCaseBusinessController implements IUseCaseBusinessController {
...
}
O framework implementa um mecanismo de integração entre camadas utilizando injeção de dependência. O módulo lógico Web utiliza um aspecto para detectar os atributos que receberão a injeção de dependência. Para isso o projeto deve ser compilado através do compilador do AspectJ e o módulo Web deve estar na relação de bibliotecas de aspecto. O módulo Core propõe um mecanismo de integração entre camadas que é implementado no módulo Web. O seu comportamento padrão é realizar a injeção por convenção. O Exemplo abaixo vai instanciar um objeto deafultpackage.persistence.dao.implementation.UseCaseDAO e vai injetá-lo no atributo dao. O processo pode ser repetido em outros artefatos de camada.
package defaultpackage.business.implementation;
public class UseCaseBusinessController implements IUseCaseBusinessController {
@Injection
private IUseCaseDAO dao;
...
}
O framework propõe um contexto transacional no módulo lógico Core que é implementado pelo módulo lógico Web. A implementação realiza um controle transacional transparente para a aplicação. O contexto transacional é acionado a cada requisição do usuario e quando um recurso transacional é utilizado, este fica vinculado ao contexto até que a requisicão finalize. Se nenhuma exceção for adicionada ao contexto o recurso transacional realizará commit, caso contrário será chamado o rollback do recurso. Todo mecanismo do framework que realiza chamadas a recursos externos pode implementar um recurso transacional e utilizar o contexto transacional do framework. O contexto transacional pode ser configurado para usar JTA, sendo que para isso deve existir no ambiente uma implementação disponível e todos as conexões devem ser gerenciadas por JTA.
O módulo Core define um mecanismo de troca de mensagens entre as camadas do sistema, assim o módulo Web implementa o contexto de mensagens para executar a troca de mensagem. Uma mensagem é definida a partir da interface IMessage especificada no Core. Esta contém todas as informações necessárias para utilização e internacionalização. Para facilitar a utilização de mensagens a aplicação pode implementar uma IMessage como um enum conforme o exemplo abaixo:
public enum ErrorMessage implements IMessage {
ERROR_A("Error Message"),
ERROR_B("Another Error Message and args {0} {1} {2}");
private String label;
private ErrorMessage(String label) {
this.label = label;
}
public String getKey() {
return this.toString();
}
public String getLabel() {
return label;
}
public Locale getLocale() {
return Locale.US;
}
public Severity getSeverity() {
return Severity.ERROR;
}
public String getResourceName() {
return "error";
}
}
A implementação da mensagem como um enum na aplicação facilita a utilização pois mantém a rastreabilidade através do compilador. Abaixo alguns exemplos de utilização:
throw new ApplicationRuntimeException(ErrorMessage.ERROR_A);
throw new ApplicationRuntimeException(ErrorMessage.ERROR_B,"arg1","arg2",arg3);
try {
...
} catch (Exception e) {
throw new ApplicationRuntimeException(ErrorMessage.ERROR_A, e);
}
IMessageContext ctx = ContextLocator.getInstance().getMessageContext(); ctx.addMessage(InfoMessage.INFO_A);
A camada de segurança proposta pelo framework é transversal as demais camadas da aplicação e o contexto de segurança é o mecanismo de acesso as informações de segurança. Abaixo o exemplo da recuperação das informações a partir do contexto.
ISecurityContext ctx = ContextLocator.getInstance().getSecurityContext(); Principal principal = ctx.getUserPrincipal();
A partir do contexto de segurança é possível autorizar a execução de alguma funcionalidade baseado nos papéis que o usuário tem.
if (ctx.isUserInRole("roleName")) {
...
} else {
...
}
O framework implementa um mecanismo genérico de DAO, povendo uma estrutura reusável para as aplicações. O HibernateGenericDAO implementa um conjunto de metódos (insert, remove, update, find, findById, etc) que são comuns a grande parte das aplicações que utilizam Hibernate como mecanismo de ORM. Abaixo um exemplo de utilização do DAO genérico.
public class AlunoDAO implements IAlunoDAO extends HibernateGenericDAO<Aluno> {
...
}
O AbstractManagedBean é uma abstração para managed beans do JSF que fornece métodos comuns para as aplicações.
public class UseCaseMB extends AbstractManagedBean {
...
}