Tutorial Mentawai #10 – Gerenciamento de Conexões JDBC

Olá novamente!

Hoje vamos conferir um artifício muito interessante que o framework Mentawai nos fornece. Caso você esteja utilizando o a interface com banco de dados padrão do Java, ou seja, JDBC, o Mentawai fornece um grande facilitador para o problema de gerenciar as conexões com o banco. Por ser um ponto com relativo custo de processamento, caso não seja gerenciado de uma forma sensata, pode diminuir consideravelmente o desempenho da sua aplicação.

O framework fornece nativamente a implementação de três tipos diferentes de pool de conexões: DBCP, C3P0 e BoneCP, sendo sugerido pela documentação oficial o uso do BoneCP.

Para que possamos usufruir disso, é necessário que uma pequena configuração seja realizada no nosso Application Manager.

@Override
public ConnectionHandler createConnectionHandler() {

    // Utilizando como exemplo um banco PostgreSQL local
    return new BoneCPConnectionHandler("org.postgresql.Driver", "jdbc:postgresql://localhost:5432/meubanco", "admin", "123456");
}

No caso das implementações dos outros pools de conexão, basta substituir o retorno por C3P0ConnectionHandler ou DBCPConnectionHandler.

Agora, para obter uma conexão, basta realizar a chamada na action:

Connection conn = (Connection) input.getValue("conn");

E… é isso! Simples, não? 😀

Até o próximo post!

Tutorial Mentawai #8 – Enviando E-mails

Olá pessoal!

O Mentawai nos oferece um recurso para facilitar o envio de e-mails pela nossa aplicação. O primeiro passo é inserirmos as configurações do nosso servidor no método init() do Application Manager.

@Override
public void init() {
    // Endereço do seu servidor SMTP
    Email.setDefaultHostName("smtp.google.com");

    // Porta do servidor
    Email.setDefaultPort(465);

    // Necessita de SSL?
    Email.setDefaultSslConnection(true);

    // Caso o servidor necessite de autenticação para enviar
    Email.setDefaultAuthentication("eu@gmail.com", "minha_senha");

    // Configuração padrão de remetente
    Email.setDefaultFrom("eu@gmail.com", "Rafael Toledo");
}

Pronto. Com essas configurações padrão, já é possível enviar e-mails com os métodos a seguir:

/* Todas os métodos recebem: Nome do destinatário, E-mail do destinatário,
   Título do e-mail, Corpo do e-mail. */

// Envio síncrono. O método só retorna quando o e-mail é enviado
SimpleEmail.sendNow("Rafael Toledo", "rafael@rafaeltoledo.net", "Título do e-mail", "Corpo do e-mail.");

// Envio assíncrono. O método retorna imediatamente, mas não há certeza de que o e-mail foi enviado
SimpleEmail.sendLater("Rafael Toledo", "rafael@rafaeltoledo.net", "Título do e-mail", "Corpo do e-mail");

// Envio síncrono com tags HTML
HtmlEmail.sendNow("Rafael Toledo", "rafael@rafaeltoledo.net", "Título do e-mail", "<p>Corpo com tags <strong>HTML</strong>.</p>");

// Envio assíncrono com tags HTML
HtmlEmail.sendLater("Rafael Toledo", "rafael@rafaeltoledo.net", "Título do e-mail", "<p>Corpo com tags <strong>HTML</strong>.</p>");

O Mentawai também fornece a possibilidade de envio de e-mails baseado em templates, que pode ser visto na documentação oficial.

Até a próxima! 🙂

Tutorial Mentawai #7 – Inversão de Controle

Olá pessoal! No tutorial de hoje, vamos ver como utilizar a inversão de controle implementada pelo Mentawai. Para quem não conhece, Inversão de Controle (ou IoC – Inversion of Control) é uma prática na orientação a objetos onde o acoplamento dos objetos é feito em tempo de execução, não sendo normalmente conhecido pelo compilador em uma análise estática.

No caso do Mentawai, a implementação de IoC é orientada a interfaces. Ou seja, você define a interface com os métodos que determinado objeto necessita, e o Mentawai se encarrega de injetar a dependência em tempo de execução.

O primeiro passo para utilizar é configurá-lo no Application Manager.

@Override
public void loadFilters() {

    filter(new MentaContainerFilter());
}

Em seguida, basta aplicar configurar o IoC, especificando quais dependências devem ser aplicadas.

@Override
public void setupIoC() {

    ioc(UsuarioDAO.class, HibernateUsuarioDAO.class);
}

No exemplo acima, dizemos que para a interface UsuarioDAO, utilizaremos a implementação HibernateUsuarioDAO. Pronto. Agora basta criar alguma forma em sua Action para que essa implementação seja aplicada. Duas opções são através de construtor ou através de um setter.

public class UsuarioAction extends BaseAction {

    private final UsuarioDAO usuarioDAO;

    public UsuarioAction(UsuarioDAO usuarioDAO) {
        this.usuarioDAO = usuarioDAO;
    }

    . . .
}

ou

public class UsuarioAction extends BaseAction {

    private UsuarioDAO usuarioDAO;

    public UsuarioAction() {
    }

    public void setUsuarioDAO(UsuarioDAO usuarioDAO) {
        this.usuarioDAO = usuarioDAO;
    }

    . . .
}

E pronto. Nada mais precisa ser feito, de forma que a implementação escolhida (no caso, HibernateUsuarioDAO) será injetada automaticamente na action.

Para maiores informações, dê uma olhada na documentação oficial.

É isso! Até a próxima! 😀

Tutorial Mentawai #6 – Validação

Olá pessoal! No post de hoje, veremos como funciona a validação no Mentawai.

O framework nos fornece uma ótima maneira de validar formulários. Nesta validação basta adicionar as regras do próprio Mentawai ou definir as suas próprias. O primeiro passo para a utilização é configurar o ValidationFilter no ApplicationManager. Muito simples:

@Override
public void loadFilters() {
     filter(new ValidationFilter());
}

Agora, na sua Action você deve fazê-la implementar a interface Validatable e criar a sua implementação do método prepareValidator(). É nesse método que definimos as restrições que deverão ser validadas. Segue um exemplo.

public class HelloAction extends BaseAction implements Validatable {

	@Override
	public void prepareValidator(Validator val, String method) {
		val.requiredFields("Campo obrigatório!", "nome", "cpf", "email");

		val.add("cpf", MethodRule.getInstance(this, "validaCpf"), "CPF Inválido!");
		val.add("email", EmailRule.getInstance(), "E-mail Inválido!");
	}

	boolean validaCpf(String cpf) {
		... implementação ...

		return true;
	}

	@Override
	public String execute() throws Exception {
		... implementação ...

		return SUCCESS;
	}
}

Neste exemplo utilizamos alguns exemplos de “rules” ou regras que o Mentawai oferece. Na documentação lá no site oficialvocê encontra os outros filtros que ele  oferece, ou mesmo como implementar sua própria regra de validação (ele possui, por exemplo, CPF, tempo, hora, CNPJ). Lá na JSP, basta adicionar as tags onde o erro deve ser exibido:

...
CPF: <mtw:input type="text" name="cpf" />
<mtw:outError field="cpf">
    <font color="red"><mtw:out /></font>
</mtw:outError>
...

E é isso. Só não se esqueça de configurar no ApplicationManager a consequência ERROR, que é retornada caso o formulário não passe pelas regras de validação.

action("/Hello", HelloAction.class).
    on(SUCCESS, fwd("/jsp/hello.jsp")).
    on(ERROR, fwd("/jsp/index.jsp"));

No exemplo no site oficial, é possível obter maiores detalhes sobre o processo. Não há muito o que ser dito, já que o exemplo é bastante completo! (:

Tutorial Mentawai #5 – Mensagens Dinâmicas

Olá pessoal!

No tutorial de hoje, vou mostrar como é fácil a criação de mensagens dinâmicas de aviso ou de erro no Mentawai. Essas mensagens podem ser utilizadas para feedback de uma operação que o usuário tenha executado na aplicação web.

Para utilizar tal recurso, basta fazer uso dos métodos addMessage() e addError() em sua action, passando como argumento a mensagem em questão ou o índice da mensagem no arquivo de internacionalização (que será visto nos próximos tutoriais).

Vamos fazer um exemplo:

public class MinhaAction extends BaseAction {
@Override
public String execute() {
try {
// Uma operação qualquer
} catch (Exception ex) {
addError("Ops! Uma exception!");
return ERROR;
}
addMessage("Operação realizada com sucesso!");
return SUCCESS;
}
}
view raw snippet01.java hosted with ❤ by GitHub

Já na sua JSP, para obter as mensagens, basta utilizar as tags <mtw:outMessage> ou <mtw:outError> que exibem o seu conteúdo caso existam mensagens correspondentes:

<h1>Uma Página Qualquer</h1>
<p>Resultado da operação:</p>
<mtw:outMessage>
<p class="mensagem"><mtw:out /></p>
</mtw:outMessage>
<mtw:outError>
<p class="erro"><mtw:out /></p>
</mtw:outError>
view raw snippet02.jsp hosted with ❤ by GitHub

Simples, não? No próximo tutorial veremos como é a funcionalidade de validação no Mentawai! Até lá! 😀

Mentawai 2.5 – Descomplicando o Desenvolvimento Web

Bom, depois de falhar uma semaninha, voltei aqui. Algumas mudanças na parte profissional acabaram mudando a minha rotina e não consegui produzir conteúdo aqui pro blog. Mas aos poucos vou reajustando as coisas por aqui 😀

Nos últimos posts, estávamos começando uma série de posts sobre programação web utilizando o framework Mentawai. Porém, ainda nos primeiros posts, fui surpreendido (positivamente) por uma nova versão, onde vários pontos-chave foram reestruturados, simplificando consideravelmente o seu uso. Já desde a versão 2.0, o Mentawai vem adotando o princípio do KISS (Keep It Simple, Stupid!)

Em relação ao que vimos nos nossos posts, a principal mudança é o incentivo a prática de uma programação mais “literal”, onde ao ler os métodos, já fica subentendido o que determinada linha faz. Vamos pegar o exemplo de um ApplicationManager da documentação oficial:

public class AppManager extends ApplicationManager {
@Override
public void loadActions() {
action("/Hello", HelloAction.class)
.on(SUCCESS, fwd("/jsp/hello.jsp"));
}
}
view raw snippet01.java hosted with ❤ by GitHub

Percebam que a configuração passa a ser quase “ao pé da letra”. Action Hello, HelloClass.class, on Success, forward to /jsp/hello.jsp. Ou seja, uma action de nome Hello, representada por HelloAction.class, ao resultar em SUCCESS será encaminhada para jsp/hello.jsp.

Além dessa característica, o framework caracteriza-se por ser full-stack, ou seja, é possível implementar uma aplicação web completa utilizando somente o Mentawai. Isso, com a já conhecida abolição ao uso de XMLs.

Nos próximos posts, vamos voltar aos nossos posts, dessa vez utilizando essa nova versão do Mentawai. Aguardem! 😀

Tutorial Mentawai #4 – Autorização

Olá pessoal! Tudo certo?

No último tutorial sobre o Mentawai, vimos como implementar facilmente autenticação em um aplicativo web. No post de hoje, vamos complementar o conceito, mostrando o que o Mentawai pode oferecer em se falando de Autorização.

De fato, Autenticação e Autorização são conceitos complementares. Não faz sentido se falar em Autorização (o que cada usuário tem acesso) se o aplicativo não implementa Autenticação (apenas usuários autênticos podem ter acesso ao aplicativo).

No Mentawai, o conceito de Autorização é implementado através de Grupos e Permissões. Um Usuário possui um ou mais grupos. Um Grupo, por sua vez, possui uma ou mais Permissões.

A criação dos Grupos e consequente definição das permissões deve ocorrer no método init() do ApplicationManager, dessa forma:

@Override
public void init(Context application) {
Group administrador = new Group("administrador");
// Pode adicionar uma permissão de cada vez
administrador.addPermission("criarUsuario");
// Ou adicionar encadeada
administrador.addPermission("configurarSistema").addPermission("visualizarMenu");
AuthorizationManager.addGroup(administrador);
Group usuarioComum = new Group("usuarioComum");
usuarioComum.addPermission("visualizarMenu");
AuthorizationManager.addGroup(usuarioComum);
}
view raw snippet01.java hosted with ❤ by GitHub

Definidos os grupos, ao autenticar o usuário você atribui o(s) grupo(s) ao qual ele pertence.

@Override
public String execute() throws Exception {
String email = input.getString("email");
String senha = input.getString("senha");
. . .
if (email.equals("admin@rafaeltoledo.net")) {
setUserSession(email);
// pode-se fazer assim...
setUserGroup("administrador");
setUserGroup("usuarioComum");
// ... ou assim!
List<String> grupos = new ArrayList<String>();
grupos.add("administrador");
grupos.add("usuarioComum");
setUserGroups(grupos);
}
return SUCCESS;
}
view raw snippet02.java hosted with ❤ by GitHub

Já nas páginas, o Mentawai fornece algumas tags para controlar o que pode ou não ser visto por cada um dos usuários, controlando por grupos ou por permissões.

<!-- Protegendo a página toda, configurando vários grupos -->
<mtw:requiresAuthorization groups="administrador, usuarioComum"/>
<!-- Protegendo a página toda, configurando um grupo apenas -->
<mtw:requiresAuthorization group="administrador"/>
<!-- Ou ainda protegendo a página toda por permissões -->
<mtw:requiresAuthorization permission="configurarSistema"/>
<!-- Ou protegendo trechos da página por grupos... -->
<mtw:hasAuthorization group="administrador"><!-- também pode definir mais de um grupo -->
<p>Só administradores veem isso.</p>
</mtw:hasAuthorization>
<!-- ... ou por permissões -->
<mtw:hasAuthorization permission="configurarSistema"><!-- também pode definir mais de uma permissão -->
<p>Só quem tem a permissão configurarSistema vê isso.</p>
</mtw:hasAuthorization>
view raw snippet03.jsp hosted with ❤ by GitHub

Para concluir, basta adicionar uma consequência global ao ApplicationManager para redirecionar os usuários sem determinada permissão para uma página de erro, por exemplo. Você também pode proteger, em vez da página, a própria chamada à Action.

@Override
public void loadActions() {
addGlobalFilter(new AuthenticationFilter());
addGlobalConsequence(AuthenticationFilter.LOGIN, new Redirect("/login.jsp"));
addGlobalConsequence(AuthorizationFilter.ACCESSDENIED, new Redirect("/erro.jsp"));
ActionConfig ac = new ActionConfig("CriarUsuario", CriarUsuarioAction.class);
ac.addConsequence(CriarUsuarioAction.SUCCESS, new Redirect("/usuarioList.jsp"));
ac.addFilter(new AuthorizationFilter(new Permission("criarUsuario")));
addActionConfig(ac);
. . .
}
view raw snippet04.java hosted with ❤ by GitHub

Simples não? Se você tem os papéis de cada um dos usuários bem definidos dentro de seu aplicativo, é muito fácil criar o seu controle de acesso utilizando o Mentawai. Em 2010 precisei fazer um sistema mais “maleável” e apanhei um pouco… vou procurar o código e em breve faço um post mostrando como resolvi.

Por enquanto é só! Até a próxima! 😀

Tutorial Mentawai #3 – Autenticação

Olá pessoal! Tudo certo?

No último post sobre o Mentawai, tivemos uma visão geral sobre Filtros, que basicamente são ações executadas sobre o conteúdo da input ou output, antes ou depois da execução de uma Action. A partir do uso de filtros giram praticamente todas as funcionalidades do framework.

No tutorial de hoje, vamos ver como funciona o controle de autenticação no Mentawai. A autenticação consiste em evitar o acesso de usuários não autenticados (que não realizaram um login, por exemplo). Vocês verão que este processo de controle é extremamente simples de se fazer com o Mentawai.

Primeiramente, precisamos criar uma action de login. Em vez de estender BaseAction, esta action deve estender BaseLoginAction.

package net.rafaeltoledo.mentawai.controller.action;
import org.mentawai.action.BaseLoginAction;
public class LoginAction extends BaseLoginAction {
@Override
public String execute() throws Exception {
String email = input.getString("email");
String senha = input.getString("senha");
// Aqui você pode realizar a sua consulta ao banco
if (!"admin@rafaeltoledo.net".equals(email) || !"admin".equals(senha)) {
return ERROR;
}
setUserSession(email);
return SUCCESS;
}
}
view raw snippet01.java hosted with ❤ by GitHub

O lance dessa action é o método setUserSession() que deve ser chamado para iniciar a sessão de um usuário. Usuários sem uma sessão criada serão bloqueados pelo AuthenticationFilter que veremos logo a seguir.

Agora, precisamos adicionar um filtro no ApplicationManager que definirá opções de redirecionamento e alguns detalhes a mais:

package net.rafaeltoledo.mentawai.controller;
import net.rafaeltoledo.mentawai.controller.action.LoginAction;
import org.mentawai.core.ActionConfig;
import org.mentawai.core.Forward;
import org.mentawai.core.Redirect;
import org.mentawai.filter.AuthenticationFilter;
public class ApplicationManager extends org.mentawai.core.ApplicationManager {
@Override
public void loadActions() {
addGlobalFilter(new AuthenticationFilter());
addGlobalConsequence(AuthenticationFilter.LOGIN, new Redirect("/login.jsp"));
ActionConfig ac = new ActionConfig("Login", LoginAction.class);
ac.addConsequence(LoginAction.SUCCESS, new Redirect("/home.jsp"));
ac.addConsequence(LoginAction.ERROR, new Forward("/login.jsp"));
addActionConfig(ac);
}
}
view raw snippet02.java hosted with ❤ by GitHub

Perceba que adicionamos um filtro global, o AuthenticationFilter. É ele o responsável por tratar o bloqueio das páginas por usuários não autenticados. Além disso definimos uma consequência global, indicando para onde o usuário será redirecionado caso tente acessar alguma página protegida sem estar autenticado (no caso, redirecionamos para a página de login).

Além disso, configuramos a action de Login, definindo um redirecionamento para a home (login com sucesso) ou pra páginda de login (login sem sucesso). E qual a diferença entre o Redirect e o Forward? Enquanto o Redirect simplesmente redireciona para outra página ou action, o Forward redireciona mantendo os dados na saída, realizando um processamento prévio da página. Ele é útil, por exemplo, para exibirmos mensagens de aviso ao usuário (coisa que veremos em muito breve!).

Continuando nosso tutorial, assim como implementamos o login, precisamos implementar o Logout. Como o logout realiza praticamente a mesma tarefa em todas as aplicações, o Mentawai já fornece uma implementação pronta que pode ser utilizada. Caso você tenha dados específicos que necessitem tratamento, você pode criar a sua implementação, tomando como base o exemplo da documentação oficial. Então, basta configurarmos no ApplicationManager.

ac = new ActionConfig("Logout", LogoutAction.class);
ac.addConsequence(LogoutAction.SUCCESS, new Redirect("/home.jsp"));
addActionConfig(ac);
view raw snippet03.java hosted with ❤ by GitHub

Ok… já vimos como funciona toda essa parte de configuração… mas como eu projeto a minha página? Através de uma única tag!

<%@ taglib uri="http://www.mentaframework.org/tags-mtw/" prefix="mtw" %>
<mtw:requiresAuthentication />
<html>
<body>
<h1>O usuário só verá esta página se estiver autenticado!</h1>
</body>
</html>
view raw snippet04.jsp hosted with ❤ by GitHub

Na configuração atual que temos, caso o usuário tente acessar uma página protegida, ele será redirecionado para a página de login e, caso o login seja realizado com sucesso, ele é redirecionado para a home. Em alguns casos, seria interessante que, após o login, ele fosse redirecionado de volta para a página que estava tentando acessar. Para isso, podemos adicionar um filtro na configuração da action de login para fazer esse trabalho pra gente.

ActionConfig ac = new ActionConfig("Login", LoginAction.class);
ac.addConsequence(LoginAction.SUCCESS, new Redirect("/home.jsp"));
ac.addConsequence(LoginAction.ERROR, new Forward("/login.jsp"));
addActionConfig(ac);
ac.addFilter(new RedirectAfterLoginFilter());
ac.addConsequence(RedirectAfterLoginFilter.REDIR, new Redirect());
view raw snippet05.java hosted with ❤ by GitHub

E depois, basta adicionar  a opção redir=”true” na tag mtw:requiresAuthentication.

<%@ taglib uri="http://www.mentaframework.org/tags-mtw/" prefix="mtw" %>
<mtw:requiresAuthentication redir="true" />
<html>
<body>
<h1>Após a autenticação, o usuário volta pra cá!</h1>
</body>
</html>
view raw snippet06.jsp hosted with ❤ by GitHub

Então… é isso pessoal! No próximo tutorial, veremos como implementar um sistema de autorização com o Mentawai. Até lá! 😀

Tutorial Mentawai #2 – Filtros

Bom, depois de um tempo brincando com Android (o que acabou consumindo quase todo o tempo que eu dedicava ao blog), voltamos com o esquecido tutorial sobre o framework Mentawai.

No primeiro tutorial, vimos como configurar o arquivo de deploy, e realizamos uma operação básica com uma action. No tutorial de hoje, vamos brincar um pouquinho com a funcionalidade de Filtros. Em um framework web, praticamente todas as funcionalidades giram em torno do uso de filtros.

Para este exemplo sobre o uso de filtros, vamos fazer um exemplo simples sobre o uso de um filtro chamado VOFilter. Este filtro serve para transformarmos um conjunto de campos em um objeto, mapeado de acordo com uma classe definida no ApplicationManager. Isso é útil para evitarmos ter que capturar valor por valor de um formulário e setar tudo em um objeto manualmente.

Para início de conversa, vou supor que você já tem um projeto configurado, de acordo com o projeto do primeiro tutorial. Caso tenha dúvidas no processo, não relute em consultá-lo 🙂

Primeiramente, vamos criar uma classe de Pojo para representar uma entidade de nosso aplicativo.

package net.rafaeltoledo.mentawai.pojo;
public class Funcionario {
private String nome;
private String cpf;
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getCpf() {
return cpf;
}
public void setCpf(String cpf) {
this.cpf = cpf;
}
}
view raw snippet01.java hosted with ❤ by GitHub

Prosseguindo, vamos criar uma Action que obterá um objeto diretamente do input da Action, conferindo se os campos foram carregados corretamente.

package net.rafaeltoledo.mentawai.filters.action;
import net.rafaeltoledo.mentawai.filters.pojo.Funcionario;
import org.mentawai.core.BaseAction;
public class ExemploVOFilterAction extends BaseAction {
@Override
public String execute() throws Exception {
Funcionario funcionario = (Funcionario) input.getValue("funcionario");
if (funcionario == null) {
return ERROR;
}
if (funcionario.getNome() == null) {
return ERROR;
}
if (funcionario.getCpf() == null) {
return ERROR;
}
funcionario.setNome(funcionario.getNome().toUpperCase());
output.setValue("funcionario", funcionario);
return SUCCESS;
}
}
view raw snippet02.java hosted with ❤ by GitHub

Como pode ser visto, ao contrário do primeiro tutorial, neste fazemos um cast do conteúdo do input chamado funcionario como um objeto completo. Conferimos os campos se estão presentes e, ao final, recolocamos o objeto na saída com o nome todo em letras maiúsculas.

Agora, vamos realizar a configuração desta Action no ApplicationManager. É lá que reside toda a magia da coisa 😀

package net.rafaeltoledo.mentawai.filters;
import net.rafaeltoledo.mentawai.filters.action.ExemploVOFilterAction;
import net.rafaeltoledo.mentawai.filters.pojo.Funcionario;
import org.mentawai.core.ActionConfig;
import org.mentawai.core.Forward;
import org.mentawai.filter.VOFilter;
public class ApplicationManager extends org.mentawai.core.ApplicationManager {
@Override
public void loadActions() {
ActionConfig ac = new ActionConfig("/ExemploVOFilter", ExemploVOFilterAction.class);
ac.addConsequence(ExemploVOFilterAction.SUCCESS, new Forward("/exibir.jsp"));
ac.addConsequence(ExemploVOFilterAction.ERROR, new Forward("/index.jsp"));
addActionConfig(ac);
// É aqui que toda magia acontece!
ac.addFilter(new VOFilter(Funcionario.class, "funcionario"));
}
}
view raw snippet03.java hosted with ❤ by GitHub

A configuração ocorre da maneira convencional, porém com a adição do VOFilter, onde passamos a classe que representa a entidade (Funcionario.class) e o nome com que queremos que ele seja colocado no input da Action (funcionario).

Bom, para completar, basta codificarmos as JSPs.

index.jsp

<%@ page language="java"
contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd&quot;>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Entrada de Dados</title>
</head>
<body>
<form action="ExemploVOFilter.mtw" method="post">
Nome: <input name="nome" size="25" /><br />
CPF: <input name="cpf" size="25" /><br />
<input type="submit" value="Enviar" />
</form>
</body>
</html>
view raw snippet04.jsp hosted with ❤ by GitHub

exibir.jsp

<%@ taglib uri="http://www.mentaframework.org/tags-mtw/" prefix="mtw" %>
<%@ page language="java"
contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd&quot;>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Saída</title>
</head>
<body>
<h3>Saída do Value Object Filter</h3>
<mtw:bean value="funcionario">
<h4>Nome: <mtw:out value="nome" /></h4>
<h4>CPF: <mtw:out value="cpf" /></h4>
</mtw:bean>
</body>
</html>
view raw snippet05.jsp hosted with ❤ by GitHub

Ah, antes de executar, se certifique que, no arquivo web.xml, esteja configurado para apontar para o arquivo index.jsp.

<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
view raw snippet06.jsp hosted with ❤ by GitHub

Se executarmos o aplicativo, veremos o poder do Mentawai!

Bom, por hoje é isso! Até a próxima! 😀