Mentawai Recipes - Latest forum topics

Projeto MentaBlank - Ponto de partida para qualquer aplicação utilizando o Mentawai

saoj — GMT

Para agilizar as coisas para quem está começando com o Mentawai, preparamos um projeto completo com as principais funcionalidades do framework. Trata-se de uma aplicação web onde você pode realizar um cadastro, se logar, editar esse cadastro e dar logout.

Essa aplicação pode e deve ser utilizada como ponto de partida para outras aplicações web.

Os seguintes conceitos são utilizados:

:arrow: Validação
:arrow: Autenticação
:arrow: Redirect after Login
:arrow: IoC
:arrow: Auto-Wiring
:arrow: Pool de Conexões
:arrow: Tratamento de Exceções
:arrow: ORM (Mapeamento de Beans no BD)
:arrow: Diversas tags do Mentawai (mtw:requiresAuthentication, mtw:bean, etc.)

Baixe o projeto aqui: http://www.mentaframework.org/files/MentaBlank.zip

Abaixa descreveremos um passo a passo de como colocar esse projeto para rodar dentro do Eclipse, assumindo que você possui o [url=http://tomcat.apache.org]Tomcat[/url] e o [url=http://www.eclipsetotale.com/tomcatPlugin.html]Sysdeo[/url] instalado no seu ambiente de desenvolvimento.

Selecione a opção do menu File -> Import. Escolha a opção "Existing Projects into Workspace". Clique em "Next".

[img]http://www.mentaframework.org/images/MentaBlank/1.JPG[/img]

Selecione a opção "Select archive file", clique em "Browse" e selecione o arquivo MentaBlank.zip que você baixou. Você deverá visualizar o projeto MentaBlank selecionado na caixa de texto logo abaixo.

[img]http://www.mentaframework.org/images/MentaBlank/2.JPG[/img]

Clique em "Finish" e um novo projeto "MentaBlank" será criado no seu eclipse. Antes de colocarmos ele para rodar no Tomcat precisamos criar um database para ele. O MentaBlank utiliza o MySQL, mas é bastante fácil alterá-lo para qualquer BD de sua preferência.

Vá no diretório WEB-INF/db e lá você encontrará dois arquivos:

:arrow: MentaBlank.sql com o script SQL para gerar a base de dados da aplicação
:arrow: grant.txt com o sql para criar o usuário "MentaBlank" no MySQL

Crie um database "MentaBlank", rode os arquivos acima e o seu banco-de-dados estará pronto para receber a nossa aplicação.

Repare que no [i]AppManager.java[/i], a configuração do Pool de Conexões é feita nas seguintes linhas:
[code]
String driver = "com.mysql.jdbc.Driver";
String url = "jdbc:mysql://localhost/MentaBlank?autoReconnect=true";
String user = "MentaBlank";
String pass = "MentaBlank";

this.connHandler = new C3P0ConnectionHandler(driver, url, user, pass);
[/code]

Agora para testar sua aplicação clique em Project -> Properties. Selecione a opção "Tomcat" e faça as seguintes alterações abaixo:

[img]http://www.mentaframework.org/images/MentaBlank/3.JPG[/img]

Clique em "Ok", inicie o seu Tomcat e acesse a URL http://localhost:8080/MentaBlank/ para testar a aplicação.

Obs: Versão para Eclipse WTP pode ser baixada em: http://www.mentaframework.org/files/MentaBlankWTP.zip (por Hélio Frota)

Especificação da Aplicação de Referência

saoj — GMT

[size=18][color=blue][b]Especificação:[/b][/color][/size]

A aplicação de referência é bastante simples:

:arrow: Uma tela de login, uma tela de cadastro, uma página principal de boas-vindas e uma tela para alterar o seu cadastro.

:arrow: No ato do cadastro, o usuário escolherá um grupo (Guest, Admin ou Master). Esse grupo poderá ser alterado na tela de alteração de cadastro.

:arrow: Um usuário do grupo Guest não poderá alterar o seu cadastro.

:arrow: No ato do cadastro, o usuário escolherá um idioma (Inglês ou Português). Esse idioma poderá ser alterado na tela de alteração de cadastro.

:arrow: A aplicação será apresentada no idioma escolhido pelo usuário.

:arrow: Ao se cadastrar, o usuário receberá um email com os dados da sua conta. Esse email deve estar no idioma escolhido pelo usuário.

:arrow: O username deve ser único por usuário, ou seja, dois usuários diferentes não podem possuir o mesmo username.

[size=18][color=blue][b]Aplicação rodando:[/b][/color][/size]

http://menta.seducaotecnologica.com.br/

[size=18][color=blue][b]Telas:[/b][/color][/size]

[color=blue]- Tela inicial para o login:[/color]

[img]http://saoj-la.dyndns.org/downloads/menta/images/login.png[/img]

[color=blue]- Tela de cadastro:[/color]

[img]http://saoj-la.dyndns.org/downloads/menta/images/registration.png[/img]

[color=blue]- Tela de boas-vindas:[/color]

[img]http://saoj-la.dyndns.org/downloads/menta/images/welcome.png[/img]

[color=blue]- Tela de boas-vindas para o Guest:[/color] (sem possibilidade de ir para alteração de cadastro)

[img]http://saoj-la.dyndns.org/downloads/menta/images/welcome-guest.png[/img]

[color=blue]- Tela para alteração de cadastro:[/color]

[img]http://saoj-la.dyndns.org/downloads/menta/images/edit.png[/img]

Show don't tell

saoj — GMT

Ao invés de começar documentando todas as funcionalidades do Mentawai, que são muitas, optamos por disponibilizar uma aplicação completa como referência. Dessa maneira você pode olhar o código, ver exemplos de várias funcionalidades e decidir por si só a respeito da praticidade e simplicidade do Mentawai em relação aos outros frameworks.

As características particulares do Mentawai, que o diferenciam de outros frameworks, são:

:arrow: Full-stack (completo e auto-suficiente, não necessitando de outros frameworks)
:arrow: [url=http://en.wikipedia.org/wiki/Kiss_principle]KISS principle[/url] (se você não sabe ou não consegue fazer algo a culpa é do framework, não sua)
:arrow: Configuração Programática (sem XML ou annotations)

A aplicação de referência pode ser baixada do SVN:

[color=blue][b]svn co svn://saoj-la.dyndns.org/menta/trunk Menta[/b][/color]

Você também pode vê-la rodando aqui: http://menta.seducaotecnologica.com.br/

Clique [url=http://forum.mentaframework.org/posts/list/2405.page]aqui[/url] para as instruções de como importar esse projeto para dentro do seu Eclipse.

Poderíamos utilizar o bom marketing para convence-lo de que o Mentawai é bom, mas ao invés disso estaremos incentivando a política do [color=red][b]SHOW DON'T TELL[/b][/color] ([i]mostre não fale[/i]) com um comparativo de frameworks através da aplicação de referência. Essa política funciona assim:

:arrow: Estarei disponibilizando vários repositórios de SVN, um para cada framework como VRaptor, Struts, Spring MVC, etc.

:arrow: Uma pessoa com experiência no framework X pode solicitar uma senha de committer para o repositório do framework X.

:arrow: Feito isso ela pode implementar a aplicação de referência com o framework X de forma que possamos compará-la às outras implementação com diferentes frameworks.

:arrow: Essaa implementações serão disponibilizadas lado-a-lado com a implementação de referência do Mentawai, ou seja, você poderá decidir por conta própria o framework de sua preferência.

A especificação completa da aplicação de referência pode ser consultada aqui: http://forum.mentaframework.org/posts/list/0/2406.page

Abaixo listamos as funcionalidades do Mentawai exemplificadas na aplicação de referência:

[color=blue][b]1) Autenticação[/b][/color]

:arrow: Filtro de autenticação para bloquear/permitir o acesso às actions
:arrow: Tags de autenticação para bloquear/permitir os acesso às páginas (JSP, Velocity, etc.)
:arrow: [i]Redirect after login[/i], ou seja, quando um usuário acessa uma página sem estar logado, ele é redirecionado para a página de login. Após um login bem sucedido ele é novamente redirecionado para a página que ele inicialmente tentou acessar.

[color=blue][b]2) Autorização[/b][/color]

:arrow: Filtro de autorização para bloquear/permitir o acesso às actions
:arrow: Tags de autorização para bloquear/permitir o acesso às páginas (JSP, Velocity, etc.)
:arrow: Tags de autorização para exibir/remover partes de uma página
:arrow: Setar os grupos que um usuário logado pertence (a autorização ou não é concedida de acordo com os grupos do usuário logado)

[color=blue][b]3) Internacionalização[/b][/color] (i18n)

:arrow: Arquivos de i18n ficam dentro do diretório i18n. Os nomes são master_pt_BR.i18n, master_en_US.i18n, etc. Um arquivo (com possibilidade de prefixos para as chaves) para tudo, ao invés de vários arquivos espalhados pela aplicação, como um por action por exemplo.
:arrow: Para mensagens que vieram de dentro das actions (mensagens dinâmicas de successo ou erro por exemplo, validação, etc.)
:arrow: Para textos dentro do JSP, com tags aceitando prefixos e valores dinâmicos como por exemplo Hello $1.
:arrow: Reload automático quando os arquivos de propriedades (i18n) são alterados. Você não quer ter que re-iniciar a sua aplicação porque mudou "Olá" para "Oi".
:arrow: Tradução padrão quando uma chave não é encontrada (para Produção).
:arrow: Exibição de texto com erro (! en_US.hello !) quando uma chave não é encontrada (para QA).
:arrow: Localização para imagens através de uma tag para imprimir o sub-diretório do locale.

[color=blue][b]4) IoC[/b][/color]

:arrow: IoC completo, integrado com o framework, sem a necessidade de Spring. Mas quem quiser usar Spring também pode.
:arrow: Configuração programática para IoC ao invés de usar um milhão de XMLs. Perguntem para o Google porque eles resolveram lançar o Guice.

[color=blue][b]5) Mensagens dinâmicas vindo das actions[/b][/color]

:arrow: "Sua conta foi atualizada com sucess"
:arrow: Integração limpa e fácil com o sistema de i18n, ou seja, essas mensagens virão do arquivo master i18n.

[color=blue][b]6) Lista de dados estáticos[/b][/color]

:arrow: É bastante recorrente a necessidade de ter combos com listas estáticas, como grupos, idiomas, países, etc.
:arrow: Eles precisam ser igualmente internacionalizados
:arrow: Tags para facilmente exibir esses combos em um formulário HTML
:arrow: Tags para facilmente exibir um valor (localizado) para um determinado id.

[color=blue][b]7) Filtros[/b][/color]

:arrow: Não estamos falando aqui de filtros de Servlet, mas de filtros do framework, como os interceptors do Struts.
:arrow: Filtros precisam ser simples para que você possa fazer os seus e fáceis de usar, para que você possa utilizar os que o framework oferece.

[color=blue][b]8 ) Validação[/b][/color]

:arrow: Integrada com o i18n
:arrow: Tags fáceis para mostrar os erros nas páginas
:arrow: Jeito fácil de validar uma action (implementando uma interface ou filtro por exemplo)

[color=blue][b]9) Jeito fácil de testar as actions[/b][/color]

:arrow: JUnit para as actions sem complexidades, mocks, etc.

[color=blue][b]10) Tags pra a view[/b][/color]

:arrow: Diversas tags para facilitar a sua vida na view, muito melhores do que as genéricas da JSTL.
:arrow: Facilidade para criar suas próprias tags, sem qualquer complexidade ou enrolação (abstraindo a bagunça inicial da api de JSP)
:arrow: Tags para paginação e muitas outras. Ou você faz a paginação na mão com código no JSP?

[color=blue][b]11) Enviando email[/b][/color]

:arrow: Tem que ser integrado com o i18n, ou seja, cada usuário recebe um email no seu idioma. Os emails ficam separados dentro do diretório /letters, com um sub-diretório para cada locale.
:arrow: Tem que suportar algum tipo de template, porque você precisa carregar um email e fazer algumas substituições no corpo da mensagem, como username, password, etc.
:arrow: Tem que corretamente suportar charsets, caso contrário o usuário receberá lixo para os caracteres acentuados.
:arrow: Tem que suportar emails em plain/text e também em HTML.
:arrow: Precisa suportar defaults para hostname, from, authentication, etc. para que você só precise configurar isso uma vez de acordo com o ambiente (produção, QA, dev, etc.)
:arrow: Precisa suportar o desativamento dos envios de email para quando você está rodando os unit tests. De maneira fácil e na configuração! (Não vai sair colocando IF em tudo)
:arrow: Tem que suportar envio assíncrono, ou seja, na maioria das vezes você não quer bloquear a action enquanto o email está sendo enviado.
:arrow: Tem que suportar SSL se você quiser utilizar o SMTP do GMAIL.
:arrow: E não se esqueça do título do email, que precisa também ser internacionalizado e suportar templates.

[color=blue][b]12) Configurações por ambiente[/b][/color]

:arrow: As configurações estáticas e textuais, como dados de conexão com o banco, smtp, hibernate, logging, etc. precisam ser carregadas de um arquivo properties. A aplicação deve suportar um arquivo properties por ambiente, além de um default que pode ser sobrescrito pelo mais específico do ambiente.

[color=blue][b]13) Suporte a dois tipos de persistência[/b][/color] (opcional)

:arrow: a aplicação pode suportar JDBC ou Hibernate, ou seja, ela implementa uma versão dos DAOs com JDBC e outra com HIBERNATE. De acordo com uma variável de ambiente ("persistency") ela decide quais implementações do DAO ela vai utilizar. A flexibilidade de IoC demonstrada na prática.

Instruções para instalar a aplicação de referência

saoj — GMT

[color=blue][b]1) Importando para o Eclipse:[/b][/color]

A aplicação de referência utiliza o Maven2. Com o maven é bastante fácil importar um projeto Java qualquer para dentro do Eclipse. Siga os passos abaixo:

:arrow: Caso ainda não tenha, instale o SVN na sua máquina: http://subversion.tigris.org/

:arrow: Caso ainda não tenha, instale o Maven 2.x.x na sua máquina: http://maven.apache.org

:arrow: Utilize o comando abaixo para fazer o checkout da aplicação de referência. O diretório 'Menta' será criado com a aplicação.

[color=darkblue][b]svn co svn://saoj-la.dyndns.org/menta/trunk Menta[/b][/color]

:arrow: Vá para dentro do diretório Menta e execute 'mvn clean install'. Os testes deverão ser executados e o WAR da aplicação gerado.

:arrow: Ainda dentro do diretório Menta, execute 'mvn eclipse:eclipse -Dwtpversion=2.0'. Feito isso o seu projeto está pronto para ser importado para dentro do Eclipse.

:arrow: Utilize a função [i]Import...[/i] do Eclipse para importar o diretório Menta. Um novo projeto será criado no Eclipse.

OBS: Para os testes unitários o banco H2 é utilizado, logo não é necessário instalar ou configurar nenhum banco de dados.

[b][color=blue]2) Configurando o banco de dados:[/color][/b] (para rodar a aplicação no TOMCAT)

:arrow: Caso ainda não tenha, instale o MYSQL na sua máquina: http://www.mysql.org

:arrow: Crie um database com o nome 'Menta'

:arrow: Conceda permissões para o usuário 'menta' acessá-lo do localhost:

[b][color=darkblue]grant all privileges on Menta.* to 'menta'@'localhost' identified by 'menta';[/color][/b]

[b][color=blue]3) Inicializando o banco de dados:[/color][/b]

Execute o script 'WEB-INF/db/menta.sql' para a inicialização do banco de dados, tomando cuidado com o charset que deve ser UTF-8:

:arrow: Vá para o diretório 'WEB-INF/db' onde está o script menta.sql

:arrow: Acesse o seu banco de dados utilizando o mysql client:

[b][color=darkblue]mysql -u menta -p Menta[/color][/b]

:arrow: Ative o charset UTF-8:

[b][color=darkblue]SET NAMES utf8;[/color][/b]

:arrow: Execute o script menta.sql:

[b][color=darkblue]source menta.sql;[/color][/b]

[color=blue][b]4) Rodando no Tomcat:[/b][/color]

Para executar a aplicação você pode utilizar o SYSDEO (plugin do Tomcat para Eclipse) ou o WTP (integração do Eclipse com o Tomcat). Caso utilize o SYSDEO você precisará configurá-lo para reconhecer um projeto Maven. Siga os passos abaixo:

:arrow: Vá em propriedades do seu projeto e selecione Tomcat

:arrow: Coloque 'src/main/webapp' como "Subdirectory to set as web application root (optional)"

:arrow: Ative o DevLoader e selecione os jars que deverão ser utilizados pelo Tomcat. Veja imagem no final desse post.

[color=blue][b]5) Deployando o WAR em um Tomcat standalone:[/b][/color]

:arrow: Copie o menta.war para dentro do webapps do seu Tomcat.

:arrow: Restarte o seu tomcat

:arrow: Um diretório menta deverá ser criado no webapps com sua aplicação.

[color=blue][b]6) Problemas de permissão com o Tomcat:[/b][/color]

A aplicação utiliza o método System.getenv() para acessar uma variável de ambiente. É possível que o Tomcat não permita essa operação devido ao seu SecurityManager. Isso ocorreu comigo no tomcat6 rodando em um Ubuntu Server, mas não no meu tomcat6 rodando no Mac. Para resolver isso você pode desativar o SecurityManager assim:

:arrow: Abra o arquivo /etc/default/tomcat6

:arrow: Adicione a seguinte linha:

[color=darkblue][b]TOMCAT6_SECURITY=no[/b][/color]

:arrow: Reinicie o seu Tomcat

OBS: Você também pode tentar fazer um ajuste fino no SecurityManager do Tomcat dentro do diretório 'policy-d'.

[i] Ativando o DevLoader para o Sysdeo: [/i]
[img]http://saoj-la.dyndns.org/downloads/menta/images/devloader.png[/img]

Comparativo entre diversos frameworks

saoj — GMT

Simon Brown postou no seu blog uma aplicação simples com o objetivo de comparar vários frameworks web, ou seja, de avaliar como cada um se comportaria na hora de implementar essa aplicação simples.

Link do blog:

http://weblogs.java.net/blog/simongbrown/archive/2005/11/comparing_webap.html

Implementação com o [b]Mentawai[/b]:

http://www.mentaframework.org/wp/index.php

Implementação com o [b]Rife[/b]:

http://rifers.org/blogs/gbevin/2006/3/16/comparing_web_frameworks_rife

Implementação com o [b]Struts1[/b]:

http://weblogs.java.net/blog/simongbrown/archive/2006/01/comparing_webap_7.html

Implementação com o [b]Wicket[/b]:

http://weblogs.java.net/blog/simongbrown/archive/2006/03/comparing_webap_8.html

Implementação com o [b]Stripes[/b]:

http://weblogs.java.net/blog/simongbrown/archive/2006/03/comparing_webap_9.html

Implementação com o [b]WebWork[/b]:

http://weblogs.java.net/blog/simongbrown/archive/2006/03/comparing_webap_10.html

Mentawai x Seam

saoj — GMT

Esse artigo tem como intuito analisar a mesma aplicação web implementada por dois frameworks bastante diferentes: Mentawai e Seam.

A implementação com o Seam pode ser analisada e baixada aqui:
http://www.infoq.com/articles/jboss-seam

A implementação com o Mentawai pode ser baixada aqui: (Utilizamos o [url="http://www.h2database.com/html/frame.html"]banco de dados embarcado H2[/url] de forma que vc não precisa se preocupar em criar/configurar o seu próprio banco de dados para esse exemplo)
http://www.mentaframework.org/files/Menta_versus_Seam.zip

Alguns pontos que vc deve observar em relação a implementação com o Mentawai:

:arrow: Foi difícil configurar um pool de conexões? Duas linhas de código e temos um pool de conexões configurado sem qualquer enrolação.

:arrow: Repare como a arquitetura da aplicação com o Mentawai fica bem dividida e organizada. Temos nossas actions, entities, repositórios (ou DAOs), implementações para os nossos repositórios (ou DAOs) e nossos serviços onde as regras do negócio serão utilizadas.

:arrow: Repare que vc utilizou Inversão de Controle de uma maneira bem simples e fácil, sem precisar de Spring ou outro framework. No ApplicationManager estamos dizendo que o nosso UserRepository será do tipo H2UserRepository. Se amanhã quizermos utilizar um OracleUserRepository, tudo que temos que fazer é mudar a configuração de IoC (1 linha).

:arrow: Repare que vc utilizou Auto-Wiring de uma maneira bem simples e fácil, sem precisar de Spring ou outro framework. No ApplicationManager estamos dizendo que tudo que precisar de uma Connection irá receber automaticamente uma Connection. No nosso exemplo o H2UserRepository vai receber essa connection via auto-wiring.

:arrow: Repare que as configurações da sua aplicação ficam centralizadas em um único lugar e que a linguagem utilizada na configuração é o Java ([url="http://www.mentaframework.org/configuration.jsp"]poderia ser outras linguagens também[/url]).

:arrow: Repare que para algumas configurações bem burras e estáticas podemos utilizar também o arquivo properties default chamado AppManager.properties que deve estar no diretório WEB-INF. ([url="http://forum.mentaframework.org/posts/list/1497.page"]mais info sobre isso aqui[/url])

:arrow: Repare como foi fácil persistir o objeto User no banco de dados utilizando o MentaBean. Repare que a sua entidade e o seu modelo de negócios não receberam qualquer tipo de anotação, em outras palavras, estão totalmente desacopladas do framework web.

:arrow: Repare que vc não precisou escrever uma linha de SQL para persistir o seu objeto User no banco de dados e que se amanhã vc quiser mudar o seu mecanismo de persistencia para Hibernate, IBatis, JPA, Arquivos Texto, Lista em Memória, etc. tudo que vc tem que fazer é implementar uma nova versão do UserRepository e reconfigurar o seu IoC.

:arrow: Repare como a sua action [i]UserAction[/i] é bem simples e como vc pode validar campos, obter objetos (Pojos) populados com os dados do seu formulário, retornar facilmente vários resultados, criar várias inner actions, etc.

:arrow: Repare que na camada de apresentação o Mentawai te oferece diversas tags simples e poderosas como mtw:outError, mtw:list, mtw:loop, mtw:isEmpty, etc. Nada te impede de usar JSTL ou EL, mas as tags do Mentawai são bem mais simples, poderosas e com menos verbosidade pois se encaixam perfeitamente ao framework, enquanto as JSTL são genéricas para todos os frameworks. (Migre o hello.jsp para JSTL e analise por si mesmo!)

:arrow: Se amanhã eu quiser colocar a minha aplicação num ambiente distribuído (pouco provável), tudo que eu tenho que fazer é transformar os meus [i]services[/i] em web services. ([url="http://xfire.codehaus.org/"]recomendamos xFire para isso[/url]) Partir do pressuposto que toda aplicação web vai ser integrada com EJB como o Seam faz não é legal. Dá para entender porque ele faz isso: JBoss

Estrutura da Aplicação e Classes:

[img]http://www.mentaframework.org/images/helloworld.PNG[/img]

User.java
[code]
package org.helloworld.entity;

import java.io.Serializable;

public class User implements Serializable {

private int id;

private String name;

public User() { }

public User(int id, String name) {
this.id = id;
this.name = name;
}

public User(int id) {
this.id = id;
}

public int getId() { return id; }

public String getName() { return name; }

public void setId(int id) { this.id = id; }

public void setName(String name) { this.name = name; }
}
[/code]

UserRepository.java
[code]
package org.helloworld.repository;

import java.util.Collection;

import org.helloworld.entity.User;

public interface UserRepository {

public User getById(int id);

public Collection getUsers();

public void add(User user);

}
[/code]

H2UserRepository.java
[code]
package org.helloworld.repository.h2;

import java.sql.Connection;
import java.util.Collection;

import org.helloworld.entity.User;
import org.helloworld.repository.UserRepository;
import org.mentawai.bean.BeanSession;
import org.mentawai.bean.jdbc.H2BeanSession;

public class H2UserRepository implements UserRepository {

private BeanSession session; // mentabean...

// Injeção vai acontecer aqui... (Auto-Wiring)
public void setConn(Connection conn) {

this.session = new H2BeanSession(conn);
}

public User getById(int id) {

User u = new User(id);

try {

if (session.load(u)) {

return u;
}

return null;

} catch(Exception e) {

throw new RuntimeException(e);
}
}

public void add(User user) {

try {

session.insert(user);

} catch(Exception e) {

throw new RuntimeException(e);
}
}

public Collection getUsers() {

User u = new User(); // no arguments for WHERE clause... (empty user)

try {

return session.loadList(u);

} catch(Exception e) {

throw new RuntimeException(e);
}
}
}
[/code]

UserService.java
[code]
package org.helloworld.service;

import java.util.Collection;

import org.helloworld.entity.User;
import org.helloworld.repository.UserRepository;

public class UserService {

// Injeção vai acontecer aqui (IoC)
private UserRepository userRepo;

public UserService() { }

public void add(User user) {

userRepo.add(user);
}

public Collection getUsers() {

return userRepo.getUsers();
}
}
[/code]

UserAction.java
[code]
package org.helloworld.action;

import java.util.Collection;

import org.helloworld.entity.User;
import org.helloworld.service.UserService;
import org.mentawai.core.BaseAction;
import org.mentawai.filter.ModelDriven;

public class UserAction extends BaseAction implements ModelDriven {

private UserService userService = new UserService();

public Object getModel() {

return userService;
}

public String add() {

if (isPost()) { // POST

String name = input.getStringValue("name");

if (name == null || name.trim().equals("")) {

addError("Por favor digite um nome!");

return ERROR;
}

User u = input.getObject(User.class);

userService.add(u);

return SUCCESS;

} else { // GET

return JSP;
}
}

public String list() {

Collection users = userService.getUsers();

output.setValue("users", users);

return SUCCESS;
}
}
[/code]

ApplicationManager.java
[code]
package org.helloworld;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.Properties;

import org.helloworld.action.UserAction;
import org.helloworld.entity.User;
import org.helloworld.repository.h2.H2UserRepository;
import org.mentawai.bean.DBTypes;
import org.mentawai.core.ActionConfig;
import org.mentawai.core.Context;
import org.mentawai.db.C3P0ConnectionHandler;
import org.mentawai.db.ConnectionHandler;
import org.mentawai.filter.ConnectionFilter;
import org.mentawai.filter.DIFilter;
import org.mentawai.filter.InjectionFilter;
import org.mentawai.filter.IoCFilter;

public class ApplicationManager extends org.mentawai.core.ApplicationManager {

private ConnectionHandler connHandler;

@Override
public void init(Context application) {

Properties prop = getProperties();

String driver = prop.getProperty("driver");
String url = prop.getProperty("url");
String user = prop.getProperty("user");
String pass = prop.getProperty("pass");

// Configuração do pool de conexões (C3P0)
connHandler = new C3P0ConnectionHandler(driver, url, user, pass);

// Cria a tabela, se ela não existe...
createTable(connHandler);

// Satck de filtros
filter(new ConnectionFilter(connHandler)); // pool de conexões...
filter(new IoCFilter()); // ioc container...
filter(new DIFilter()); // auto-wiring...
filter(new InjectionFilter()); // action/model injection...

// IoC
ioc("userRepo", H2UserRepository.class);

// Auto-wiring
di("conn", Connection.class);

}

@Override
public void loadBeans() {

// ORM mapping...
bean(User.class, "Users")
.pk("id", DBTypes.AUTOINCREMENT)
.field("name", DBTypes.STRING);
}

@Override
public void loadActions() {

// configure list inner action...
ActionConfig listAction = action(UserAction.class, "list")
.on(SUCCESS, fwd("/hello.jsp"));

// configure add inner action...
// (depois de adicionar queremos ir para listar)
action(UserAction.class, "add")
.on(JSP, chain(listAction))
.on(SUCCESS, chain(listAction))
.on(ERROR, chain(listAction));

}

protected void createTable(ConnectionHandler connHandler) {

Connection conn = null;

PreparedStatement stmt = null;

try {

conn = connHandler.getConnection();

stmt = conn.prepareStatement("create table if not exists Users(id " +
"INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100))");

stmt.executeUpdate();

} catch(Exception e) {

System.err.println("Cannot create table: " + e.getMessage());

throw new RuntimeException(e);

} finally {

if (stmt != null) try { stmt.close(); } catch(Exception e) { }

connHandler.release(conn);
}
}

}
[/code]

AppManager.properties
[code]

driver = org.h2.Driver
url = jdbc:h2:~/helloworld
user = helloworld
pass = helloworld

[/code]

hello.jsp
[code]
<%@page contentType="text/html;charset=UTF-8" %>
<%@taglib uri="/WEB-INF/lib/mentawai.jar" prefix="mtw" %>

Mentawai Hello World

Please enter you name:

Mentawai x Struts2

saoj — GMT

- [color="blue"][b]Validação:[/color][/b]

O Struts2 oferece validação via XML ou Annotations.

A documentação do Struts2 continua sendo, na minha opinião, pouco objetiva e pouco clara. Clique aqui para acessar a [url="http://struts.apache.org/2.x/docs/validation.html"]documentação oficial sobre validação[/url], e tire suas próprias conclusões. Repare que não há nenhum código Java, apenas XML.

Validação via XML: (repare que existe código Java dentro do XML !!!! :roll: )

[code]

"-//OpenSymphony Group//XWork Validator 1.0.2//EN"
"http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd">

You must enter a value for email.

Not a valid e-mail.

You must enter a value for email2.

Not a valid e-mail2.

email.equals(email2)
Email not the same as email2

email.startsWith('mark')
Email does not start with mark

[/code]

Validação via Annotations: (como deturpar o uso de annotations assim como foi feito com o uso de XML)

[url="http://struts.apache.org/2.x/docs/validation-annotation.html"]Clique aqui para ver que isso está na documentação oficial do Struts2[/url]

[code]

@Validation()
public class SimpleAnnotationAction extends ActionSupport {

@RequiredFieldValidator(type = ValidatorType.FIELD, message = "You must enter a value for bar.")
@IntRangeFieldValidator(type = ValidatorType.FIELD, min = "6",
max = "10", message = "bar must be between ${min} and ${max}, current value is ${bar}.")
public void setBar(int bar) {
this.bar = bar;
}

public int getBar() {
return bar;
}

@Validations(
requiredFields =
{@RequiredFieldValidator(type = ValidatorType.SIMPLE,
fieldName = "customfield", message = "You must enter a value for field.")},
requiredStrings =
{@RequiredStringValidator(type = ValidatorType.SIMPLE,
fieldName = "stringisrequired", message = "You must enter a value for string.")},
emails =
{ @EmailValidator(type = ValidatorType.SIMPLE,
fieldName = "emailaddress", message = "You must enter a value for email.")},
urls =
{ @UrlValidator(type = ValidatorType.SIMPLE,
fieldName = "hreflocation", message = "You must enter a value for email.")},
stringLengthFields =
{@StringLengthFieldValidator(type = ValidatorType.SIMPLE, trim = true, minLength="10" ,
maxLength = "12", fieldName = "needstringlength", message = "You must enter a stringlength.")},
intRangeFields =
{ @IntRangeFieldValidator(type = ValidatorType.SIMPLE,
fieldName = "intfield", min = "6", max = "10", message = "bar must be between ${min} and ${max}, current value is ${bar}.")},
dateRangeFields =
{@DateRangeFieldValidator(type = ValidatorType.SIMPLE,
fieldName = "datefield", min = "-1", max = "99", message = "bar must be between ${min} and ${max}, current value is ${bar}.")},
expressions = {
@ExpressionValidator(expression = "foo > 1",
message = "Foo must be greater than Bar 1. Foo = ${foo}, Bar = ${bar}."),
@ExpressionValidator(expression = "foo > 2",
message = "Foo must be greater than Bar 2. Foo = ${foo}, Bar = ${bar}."),
@ExpressionValidator(expression = "foo > 3",
message = "Foo must be greater than Bar 3. Foo = ${foo}, Bar = ${bar}."),
@ExpressionValidator(expression = "foo > 4",
message = "Foo must be greater than Bar 4. Foo = ${foo}, Bar = ${bar}."),
@ExpressionValidator(expression = "foo > 5",
message = "Foo must be greater than Bar 5. Foo = ${foo}, Bar = ${bar}.")
}
)
public String execute() throws Exception {
return SUCCESS;
}
}
[/code]

Mais uma vez a [b]configuração programática do Mentawai[/b] mostra todo o seu poder facilitando a implementação dessa funcionalidade tão essencial e importante:

Filtro de Validação do Mentawai: (pode ser aplicado em mais de uma action)

Ou vc pode também fazer a validação diretamente na action através da interface Validatable: http://recipes.mentaframework.org/posts/list/4.page

[code]

public class HelloWorldValidator extends ValidationFilter {

private static final String FIELD_REQUIRED_ERROR = "Field required!";
private static final String INVALID_USERNAME_LENGTH = "Username length invalid!";
private static final String INVALID_AGE = "Invalid age!";
private static final String INVALID_PASSWORD_LENGTH = "Invalide password length!";
private static final String PASSWORD_DOES_NOT_MATCH = "Passwords do not match!";

public void initValidator() {

add("username", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
add("username", new StringRule(6, 30), INVALID_USERNAME_LENGTH);

add("age", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
add("age", new IntegerRule(18, 50), INVALID_AGE);

add("password", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
add("password", new StringRule(4, 20), INVALID_PASSWORD_LENGTH);
add("password", new EqualRule("password", "passconf"), PASSWORD_DOES_NOT_MATCH);

add("passconf", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
}

}
[/code]

E para internacionalizar essas mensagens, tudo que vc precisa fazer é criar um arquivo HelloWorldValidator_en_US.i18n dentro do diretório /validation:

[code]

###############################################
# Messages for the filter HelloWorldValidator #
###############################################

required = Required field cannot be left blank
2 = Your username must be between %min% and %max% characters long.
3 = You must be %min% years old or older.
4 = Your password must be between %min% and %max% characters long.
5 = Passwords do not match.

[/code]

E o filtro de validação ficaria assim:

[code]
public class HelloWorldValidator extends ValidationFilter {

private static final String FIELD_REQUIRED_ERROR = "required"; // to illustrate that this can be a string too
private static final int INVALID_USERNAME_LENGTH = 2;
private static final int INVALID_AGE = 3;
private static final int INVALID_PASSWORD_LENGTH = 4;
private static final int PASSWORD_DOES_NOT_MATCH = 5;

public void initValidator() {

add("username", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
add("username", new StringRule(6, 30), INVALID_USERNAME_LENGTH);

add("age", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
add("age", new IntegerRule(18, 50), INVALID_AGE);

add("password", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
add("password", new StringRule(4, 20), INVALID_PASSWORD_LENGTH);
add("password", new EqualRule("password", "passconf"), PASSWORD_DOES_NOT_MATCH);

add("passconf", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
}

}
[/code]

- [color="blue"][b]Internacionalização:[/color][/b]

A documentação oficial do Struts para internacionalização está aqui: http://struts.apache.org/2.x/docs/localization.html

Mais uma vez a documentação deixa em aberto as seguintes questões:

- Struts2 utiliza ResourceBundle, o que provavelmente vai forçar um restart da aplicação a cada mudança nos arquivos properties do resourcebundle.

- Se o locale do meu usuário está salvo no banco, como forço para que o locale da aplicação seja esse locale para esse usuário?

- Tenho a opção de criar apenas um único arquivo onde todo o meu conteúdo internacionalizado estará presente (arquivo master) ?

- O Struts2 permite internacionalizar actions colocando arquivos properites dentro do pacote da action. É boa prática colocar os arquivos de internacionalização separados do seu código e num lugar que possa ser acessível pelo designer e/ou tradutor. (Ou vc programador vai fazer essa tarefa?)

Compare o approach do Struts2 com o approach do Mentawai e tire suas próprias conclusões: http://www.mentaframework.org/i18n.jsp?loc=pt

- [color="blue"][b]Conversão:[/color][/b]

Assim como [url="http://struts.apache.org/2.x/docs/type-conversion.html"]sua documentação[/url], os conversores do Struts não são nem simples, nem claros, nem pragmáticos:

[code]
/**
* Observação bem grande na documentação, para te ajudar:
*
* To allow Struts to recognize that a conversion error has occurred,
* the converter class need to throw XWorkException or preferably
* TypeConversionException.
*/
public class MyConverter extends StrutsTypeConverter {

public Object convertFromString(Map context, String[] values, Class toClass) {
.....
}

public String convertToString(Map context, Object o) {
.....
}
}
[/code]

É difícil entender e/ou justficar algo tão bizarro acima para algo tão simples como uma conversão, principalmente quando olhamos a versão do Mentawai abaixo:

[code]

public class MyConverter extends BasicConverter {

public Object convert(Object value) throws ConversionException {

// ...
}
}

// ou ainda para converter baseado no locale

public class MyConverter extends LocaleConverter {

public Object convert(Object value, Locale loc) throws ConversionException {

// ...
}
}
[/code]

- [color="blue"][b]Filtros:[/color][/b]

A configuração dos filtros é feita via XML, como sempre. Se tivermos que por exemplo aplicar o mesmo filtro em 100 actions diferentes, teremos que usar copy/paste e transformar a nossa configuração num arquivo XML gigantesco. Em contrapartida, se utilizarmos configuração programática, podemos fazer um for/loop, métodos, if, etc.

Veja o exemplo de um interceptor do Struts:

[code]
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;

public class SimpleInterceptor extends AbstractInterceptor {

public String intercept(ActionInvocation invocation) throws Exception {
MyAction action = (MyAction)invocation.getAction();
action.setDate(new Date());
return invocation.invoke();
}
}
[/code]

Reparem que, talvez pela falta de um INPUT/OUTPUT para as actions, o interceptor acima está fortemente acoplado a action MyAction, ou seja, só pode ser aplicado a ela.

Na versão do Mentawai ficaria assim:

(reparem que o filtro abaixo poderá ser aplicado em qualquer action, e não apenas MyAction)

[code]
public class SimpleFilter implements Filter {

public String filter(InvocationChain chain) throws Exception {
Action action = chain.getAction();
Input input = action.getInput();

input.setValue("someDate", new Date());

return chain.invoke();
}

public void destroy() { }
}
[/code]

[i]Aguardem mais comparativos !!![/i]

Martin Fowler sobre configurações

saoj — GMT

Fonte: http://www.javafree.org/content/view.jf?idContent=1

[quote]
Código ou arquivos de configuração

Um assunto separado, mas freqüentemente adicionado, é quando usar arquivos de configuração ou código sobre uma API para amarrar os serviços. Para a maioria das aplicações que tem de ser instaladas em vários lugares, um arquivo de configuração separado normalmente faz mais sentido. Quase sempre será um arquivo XML, e isto faz sentido. Entretanto, há casos onde é mais fácil usar código de programação para fazer a montagem. Um caso é onde se tem uma aplicação simples, que não tem muitas variações de instalação. Neste caso, um pouco de código pode ser mais claro que um arquivo XML separado.

Um caso constrastante é onde a montagem é muito complexa, envolvendo passos condicionais. Uma vez que se chega mais próximo de uma linguagem de programação, o XML começa a entrar em colapso, e é melhor usar uma linguagem real que tem toda a sintaxe para se escrever um programa claro. É feita então uma classe construtora que faz a montagem. Se há diferentes cenários de montagem, pode-se prover várias classes construtoras e usar um arquivo de configuração simples que faz a seleção entre eles.

Muitas vezes penso que as pessoas estão ansiosas demais por definir arquivos de configuração. Muitas vezes, uma linguagem de programação serve como um mecanismo de configuração direto e poderoso. Linguagens modernas podem facilmente compilar pequenos montadores que podem ser usados para juntar plugins em sistemas maiores. Se a compilação é trabalhosa demais, existem também linguagens script que podem funcionar muito bem.

É freqüentemente falado que arquivos de configuração não deveriam usar uma linguagem de programação, porque eles precisam ser editados por não-programadores. Mas quão freqüente este é o caso? As pessoas realmente esperam que não-programadores alterem os níveis de isolamento de transações de aplicações servidoras complexas? Arquivos de configuração que não usam uma linguagem de programação funcionam bem apenas enquanto simples. Se eles se tornaram complexos, então é hora de pensar sobre usar uma linguagem de programação apropriada.

Uma coisa que vemos no mundo Java no momento é uma dissonância de arquivos de configuração, onde cada componente tem seus próprios arquivos de configuração, que são diferentes de quaisquer outros. Se uma dúzia destes componentes forem usados, pode-se facilmente acabar com uma dúzia de arquivos de configuração que devem ser atualizados.

Meu conselho aqui é sempre prover uma maneira de fazer toda a configuração facilmente com uma interface programática, e então tratar o arquivo de configuração separado como uma característica opcional. Pode-se facilmente construir a manipulação de um arquivo de configuração usando uma interface programática. Quando se cria um componente, deve-se deixar a cargo do usuário quando utilizar a interface programática, o formato padrão do arquivo de configuração, ou criar seu próprio formato de arquivo, amarrando-o à interface programática.
Separando Configuração do Uso

A coisa mais importante nisto tudo é assegurar-se de que a configuração dos serviços seja separada de seu uso. Isto é um princípio fundamental do design próximo à separação entre interfaces e implementação. É algo que vemos dentro de um programa orientado-a-objetos quando lógica condicional decide que classe instanciar, e então, futuras avaliações desta condição é feita por polimorfismo ao invés de ter código condicional duplicado.

Se esta separação é útil dentro de uma única base de código, é especialmente vital quando se usa elementos externos, como componentes e serviços. A primeira questão é se é desejável deferir a escolha da classe de implementação para instalações particulares. Se sim, é necessário o uso de alguma implementação de plugin. Uma vez que plugins estejam sendo utilizados, é essencial que a montagem dos plugins seja feita separadamente do resto da aplicação, para que seja possível substituir diferentes configurações facilmente para diferentes instalações. Como se consegue isto é secundário. Este mecanismo de configuração pode tanto configurar um service locator quanto usar injeção para configurar os objetos diretamente.
[/quote]

Choosing consequences for handling different outputs (JSP, Ajax, Binary, etc.)

saoj — GMT

Mentawai has the concept of Consequence, also known as Resolver in other frameworks like Spring MVC.

Basically, depending on the RESULT of an Action you can trigger the appropriate CONSEQUENCE.

The most common consequences are FORWARD to a JSP or REDIRECT to an URL:
[code]

action("/Users", UserAction.class, "add")
.on(ERROR, fwd("/jsp/users/add.jsp"))
.on(SUCCESS, redir("/Users.list.mtw"));

// if you have an action configured, you can also redir to an action
// the code below is identical to the code above

ActionConfig listAC = action("/Users", UserAction.class, "list")
.on(SUCCESS, fwd("/jsp/users/list.jsp"));

action("/Users", UserAction.class, "add")
.on(ERROR, fwd("/jsp/users/add.jsp"))
.on(SUCCESS, redir(listAC));
[/code]
Now we talk about consequences for other types of output:

[b]1) AJAX consequence generating JSON:[/b]

Action:
[code]
public String list() {

List users = getUsersSomehow();

output.setValue("users", users);

return AJAX; // or any result you want...
}
[/code]
Configuration:
[code]

action("/User", UserAction.class, "list")
.on(AJAX, ajax(new JsonRenderer());
[/code]
[b]2) Streaming binary (images, pdf or anything):[/b]

Action:
[code]
public String get() {

// you can add a byte array or an InputStream to the action output:

byte[] image = getImageDataSomehow();

output.add(image); // you can also do output.setValue(StreamConsequence.STREAM, image);

// or

InputStream is = getInputStreamSomehow();

output.add(is); // you can also do output.setValue(StreamConsequence.STREAM, is);

return STREAM; // or any result you want
}
[/code]
Configuration:
[code]
action("/Images", ImageAction.class, "get")
.on(STREAM, stream("image/jpeg"));

action("/Docs", PdfAction.class, "get")
.on(STREAM, stream("application/pdf"));
[/code]

Easy internationalization (i18n)

saoj — GMT

[b]OBS:[/b] Mentawai i18n files are auto-reloadable, in other words, from time to time the file is checked for modifications. If it was modified it is reloaded. That means you do NOT have to restart your web container each time you change some text inside your i18n file.

When the user is authenticated, you set his locale:
[code]
setSessionObj(user);

setSessionLocale("es_ES");
[/code]
Then all you have to do is create a directory i18n and place one file per language in there. Example:

/i18n/master_en_US.i18n
[code]
# a comment
hello = Hi there. You can even jump \
a line here. Enjoy!
[/code]
/i18n/master_es_ES.i18n
[code]
# comentário
hello = Hola. Incluso puede saltar una línea \
aquí. Disfrute!
[/code]
Then in the JSP you can do:
[code]

Your message:

[/code]
To better organize your text file you can use prefixes. Example:

/i18n/master_en_US.i18n
[code]
# a comment
index.hello = Hi there. You can even jump \
a line here. Enjoy!
[/code]
/i18n/master_es_ES.i18n
[code]
# comentário
index.hello = Hola. Incluso puede saltar una línea \
aquí. Disfrute!
[/code]
Then in the JSP you do:
[code]

Your message:

[/code]
If you have a text that is global, for example, the title of all pages, you can skip the prefix by doing:

/i18n/master_en_US.i18n
[code]
# a comment

title = Your title here

index.hello = Hi there. You can even jump \
a line here. Enjoy!
[/code]
/i18n/master_es_ES.i18n
[code]
# comentário

title = Su titulo aqui

index.hello = Hola. Incluso puede saltar una línea \
aquí. Disfrute!
[/code]
An in the JSP:
[code]

<mtw:i18n key="title" noPrefix="true" />

Your message:

[/code]
And there is much more:

:arrow: You can have localized texts inside your actions.

:arrow: If the user is not logged, you can pick a locale based on browser request, cookie, etc.

:arrow: You can use placeholders to help the designer:
[code]
This is a simple message just for the designer to see something!
[/code]
:arrow: You can configure what to do if the key is not found: show the default locale translation or show the key with exclamation marks around it so someone can spot the problem and fix it. (good for QA)

Easy Authorization with groups

saoj — GMT

An authenticated user can belong to one or more groups. All you have to do is:
[code]
setSessionObj(user); // user is authenticated

setSessionGroup("admin"); // and belongs to the admin groups

// or

setSessionGroups("admin", "moderator"); // user can belong to more than one group
[/code]
Now to protect access to an action you can do:
[code]
on(ACCESSDENIED, redir("/denied.jsp")); // a global consequence for ACCESSDENIED

action("/DeleteRecord", DeleteRecordAction.class)
.on(SUCCESS, redir("/deleted.jsp"))
.filter(new AuthorizationFilter("admin"));
[/code]
The AuthorizationFilter returns the result [i]ACCESSDENIED[/i] if the current authenticated user does not belong to the [i]admin[/i] group. Then a global consequence can redirect to a page or throw an exception.

And how to protect access to an JSP page

1) Blocking access to a page:
[code]

[/code]
2) Block access to a portion of the page:
[code]

Admins can see this!

Admins and moderators can see this!

[/code]
Mentawai also supports authorization by permissions. For more info see here: http://www.mentaframework.org/authorization.jsp

Easy Authentication

saoj — GMT

After checking username and password, in any way you want, you decide that your user is authenticated. So you do:
[code]

setSessionObj(user);

[/code]
Now if you use the [i]AuthenticationFilter[/i] as a global filter, all access to your actions will only be allowed if the user is authenticated, in other words, if you called the method above for the current session. If not the [i]LOGIN[/i] result is returned and you can redirect for the login page.
[code]
filter(new AuthenticationFilter());
on(LOGIN, redir("/login.jsp"));
[/code]
Now, some actions need to bypass authentication. Example: the action for registration. All you have to do is implement te [i]AuthenticationFree[/i] interface.
[code]
public class UserAction extends BaseAction implements AuthenticationFree {

// You don't need to log to register...
public boolean bypassAuthentication(String method) {

if (method != null && method.equals("register")) return true;

return false;
}
}
[/code]
The [i]LoginAction[/i] is another one that should not be authenticated. The org.mentawai.action.LoginAction implements [i]AuthenticationFree[/i] as you might expect.

You blocked access to actions. Now it is time to block access to JSPs. You can use the simple tag:
[code]

[/code]
That's it. Mentawai also supports redirect after login in a very simple way. See here: http://www.mentaframework.org/authentication.jsp

How to use internationalization in DisplayTags

rodrigo.avila — GMT

If you don't have any i18n file, follow this link:
http://www.mentaframework.org/i18n.jsp

if you want create your own DisplayTags, follow this link:
http://recipes.mentaframework.org/posts/list/34.page

To use internationalization in DisplayTags, do the following:

1) Create your taglib. For example:

[code]public class NumberOfFriendsTag extends PrintTag {

public String getStringToPrint() throws JspException {

Output output = action.getOutput();

User user = (User) output.getValue("user");

int nFriends = user.getNumberOfFriends();

if (nFriends == 1) {

return "You have 1 friend!";

} else if (nFriends == 0) {

return "You do not have any friend!";

} else {

return "You have " + nFriends + " friends!";

}
}
}
[/code]

2) Flaunt your taglib where are the i18n files. To do that, use

[code]I18N i18n = I18NMap.getI18N("/WEB-INF/i18n/master", loc);[/code]

inside your [i]getStringToPrint()[/i] method. After that, use

[code]i18n.get( "chave_no_arquivo_i18n" );[/code]

to get the internationalized text.

The first string is the path to your master file, from the application root. [i]loc[/i] is the user localeé o locale do usuário, available [i]automagically[/i] inside the class.

See the code:

[code]public class NumberOfFriendsTag extends PrintTag {

public String getStringToPrint() throws JspException {

// Método para pegar os arquivos i18n.
I18N i18n = I18NMap.getI18N("/i18n/master", loc);

Output output = action.getOutput();

User user = (User) output.getValue("user");

int nFriends = user.getNumberOfFriends();

if (nFriends == 1) {

return i18n.get( "apenas_um_amigo" );

} else if (nFriends == 0) {

return i18n.get( "nenhum_amigo" );

} else {

//return "Você tem " + nFriends + " amigos!";
return i18n.get( "voce_tem" ) + " " + nFriends + " " + i18n.get( "amigo_plural" );

}
}
}
[/code]

Master file:

/i18n/master_pt_BR.i18n
[code]apenas_um_amigo = Você tem 1 amigo!
nenhum_amigo = Você não tem amigos!
voce_tem = Você tem
amigo_plural = amigos[/code]

/i18n/master_en_US.i18n
[code]apenas_um_amigo = You have 1 friend.
nenhum_amigo = You don't have any friend.
voce_tem = You have
amigo_plural = friends[/code]

Logging: how to enable and use in 3 easy steps

rodrigo.avila — GMT

The Mentawai logging system is very simple and non-intrusive. To use it, follow these steps:

1) Activate the logging system in ApplicationManager:
[code]public void init(Context application){

Debug.enable(true);

[...]

} [/code]

2) Use:
[code]Debug.log("logged text: bla bla bla...");[/code]

3) See the logged text in
[code]/WEB-INF/logs[/code]

Dynamic/Ajax Combos with mtw:select tag

saoj — GMT

One recurrent problem is when you want to display a dynamic list, in other words, a list that depends on other field. One standard example is State and City where each State has its own list of Cities.

One possible approach to this problem is to add all 50 lists to [i]ListManager[/i], but that would not be a good solution because you would have to have a bunch of IFs in your JSP, like below:
[code]

Cities

Cities

Cities

[/code]
This is awkward and will introduce other problems. For example when we first show the page and no state is selected, we must show an empty list.

Luckily there is a much better solution by using a Mentawai filter to create a dynamic list [i]on the fly[/i] and place it in the action output. Remember that the [i]mtw:select tag[/i] is smart enough to pick up lists straight from the action output, if it finds one.

Let's define the problem before we dive into the code. Below are the situations where we need to take action:

1) Empty form is being displayed to insert a new bean => List should be empty

2) Form is being redisplayed probably because of a validation error => List should be the same one when the used submitted the form, in other words, it should not lose its state when a validation error occurs.

3) Form is being used to EDIT a bean, in other words, a bean object was placed in the action output and a forward was performed to the JSP with the form => List should display the appropriate list corresponding to the bean State.

4) The user selected another State => List should be changed through Ajax (out of the scope of this recipe)

Here are the conditions for 1), 2) and 3):

1) Nothing is in the action input and nothing is in the action output => Form is being used to insert a bean and an empty list should be displayed.

2) The current State id is in the action input => A validation error occurred and you should use the State id to show the appropriate City list.

3) There is an object in the action output with a State id property => The object (bean) is being edited, so show the appropriate City list corresponding to this bean State id.

Below is a simple filter that I coded to address all these scenarios:
[code]
public class CityListFilter implements Filter {

private Map getMap(int state_id) {

Map list = new LinkedHashMap();

List cities = State.getCities(state_id);

if (cities != null) {

list.put(0, "-- Select a City --");

for(City c : cities) {

list.put(c.getId(), c.getName());
}

} else {

list.put(0, "-- Select a State --");
}

return list;
}

public String filter(InvocationChain chain) throws Exception {

Action action = chain.getAction();

Input input = action.getInput();

Output output = action.getOutput();

int state_id = input.getIntValue("state");

if (state_id > 0) {

// 2) VALIDATION ERROR

output.setValue("cities", getMap(state_id));

return chain.invoke();

} else {

// 3) EDITING A BEAN

// execute action first, so bean is placed in
// action output for editing
String res = chain.invoke();

Object obj = output.getValue("user");

if (obj instanceof User) {

User user = (User) obj;

state_id = user.getState();

output.setValue("cities", getMap(state_id));

} else {

// 1) EMPTY FORM FOR INSERTING BEAN

// just show an empty list...
output.setValue("cities", getMap(-1));
}

return res;
}
}

public void destroy() { }
}
[/code]
So now you can use a single [i]mtw:select[/i] tag and your list will be filled appropriately according to the situation and the State id.
[code]

[/code]

One last catch when setting the filter in the application manager: This filter should be executed *before* the [i]ValidatorFilter[/i] which is a [i]global filter[/i] that performs validation. That's because the [i]ValidatorFilter[/i] aborts the execution chain if it finds an error and as we know global filters are executed before any [i]action specific[/i] filter.

Luckily there is an easy way to place an action specific filter before all global filters. Just use the [i]addFilterFirst()[/i] or [i]filterFirst()[/i] method from [i]ActionConfig[/i].
[code]

filter(new ValidatorFilter()); // global filter for validation

action("/User", UserAction.class)
.filterFirst(new CityListFilter())
.on(SUCCESS, fwd("/show.jsp"))
.on(ERROR, fwd("/error.jsp"));
[/code]
In a web application project, you will probably have to code a filter like that for every dynamic list. To make this job easier, Mentawai 1.14 includes the [i]org.mentawai.filter.DynamicListFilter[/i] that you can use to fast code these filters. See how we could have coded the filter above with this new abstract class:
[code]
public class CityListFilter extends DynamicListFilter {

protected Map getMap(int state_id) {

Map list = new LinkedHashMap();

List cities = State.getCities(state_id);

if (cities != null) {

list.put(0, "-- Select a City --");

for(City c : cities) {

list.put(c.getId(), c.getName());
}

} else {

list.put(0, "-- Select a State --");
}

return list;
}

protected String getParamName() {
return "state";
}

protected String getListName() {
return "cities";
}

protected String getBeanName() {
return "user";
}

// not needed if == getParamName()
protected String getBeanProperty() {
return "state";
}
}
[/code]

Mentawai Recipes - Latest forum topics

Projeto MentaBlank - Ponto de partida para qualquer aplicação utilizando o Mentawai

Especificação da Aplicação de Referência

Show don't tell

Instruções para instalar a aplicação de referência

Comparativo entre diversos frameworks

Mentawai x Seam

Mentawai Hello World

Please enter you name:

The following persons have said "hello" to Mentawai:

Nobody has said so yet!

Mentawai x Struts2

Martin Fowler sobre configurações

Choosing consequences for handling different outputs (JSP, Ajax, Binary, etc.)

Easy internationalization (i18n)

Your message:

Your message:

Your message:

Easy Authorization with groups

Admins can see this!

Admins and moderators can see this!

Easy Authentication

How to use internationalization in DisplayTags

Logging: how to enable and use in 3 easy steps

Dynamic/Ajax Combos with mtw:select tag