Mentawai Web Framework

Quick Start

  • Clique aqui para baixar o mais recente binário do Mentawai.


  • Descompacte o conteúdo desse arquivo zip dentro de um diretório vazio.


  • Pegue o arquivo mentawai.jar e coloque-o dentro do diretório /WEB-INF/lib de sua aplicação web. Você pode criar esse diretório se ele não existir.


  • Pegue o arquivo mentacontainer-X.X.X.jar e coloque-o dentro do diretório /WEB-INF/lib de sua aplicação web.


  • Crie o arquivo /WEB-INF/web.xml de sua aplicação web para tratar as actions do mentawai: (inclua as linhas abaixo)
    (OBS: Não há escapatória desse arquivo, mas será o último XML que você verá!)
  • <!-- The Mentawai controller -->
    <web-app>
    <servlet>
    	<servlet-name>Controller</servlet-name>
    	<servlet-class>org.mentawai.core.Controller</servlet-class>
    	<load-on-startup>1</load-on-startup>		
    </servlet>
    
    <!-- You must choose an extension to indicate a mentawai action -->
    <servlet-mapping>
    	<servlet-name>Controller</servlet-name>
    	<url-pattern>*.mtw</url-pattern>
    </servlet-mapping>
    </web-app>
    	

  • Tudo o que estamos fazendo é mapear as requisições que terminam com *.mtw para o controller (gerenciador) do Mentawai.


  • É isso. Você já está pronto para usar o framework Mentawai !

O ciclo de vida da action

O ciclo de vida da action é:

  • O controller recebe a requisição (javax.servlet.http.HttpServletRequest).

  • O controller procura pela action correspondente.

  • O controller prepara o Input, Output, Contexts (Session, Application, Cookies, etc.) e injeta na action.

  • O controller executa a action junto com seus possíveis filtros.

  • O retorno da action é um resultado (java.lang.String), normalmente SUCCESS ou ERROR.

  • Para cada resultado existe uma consequência (org.mentawai.core.Consequence), normalmente um FORWARD ou REDIRECT.

  • O controller executa a consequência.

Isso é só pra você entender o que acontece internamente, mas você não precisa se preocupar com isso. Tudo o que precisa fazer é escrever suas actions e seus filtros.

Meu primeiro projeto: Hello World

Se você quiser fazer o deploy dessa aplicação web simples no seu container web , clique aqui para fazer o download do HelloMentawai.war. Para fazer o deploy de um arquivo war, tudo que você precisa é copia-lo pra dentro do diretório webapps . (Nota: algums browsers, como o meu, mudam a extensão para .zip quando você tenta salvar o arquivo. Renomeie o arquivo para .war se necessário.)


package examples.helloworld;

import java.util.*;

import org.mentawai.core.*;

public class HelloMentawai extends BaseAction {
	
	public String execute() throws Exception {
		String username = input.getString("username");
		if (username == null || username.trim().equals("")) {
			return ERROR;
		}
		output.setValue("username", username.toUpperCase());
		return SUCCESS;
	}
	
}
		

Quando você estende org.mentawai.core.BaseAction, a sua classe tem acesso a alguns dados úteis de membros protected. Na action HelloMentawai nós estamos usando dois deles:
  • input: O input (org.mentawai.core.Input) que possui os headers e os valores dos parâmetros da requisição http. Os parâmetros podem ser qualquer objeto Java, e não somente Strings.


  • output: O output (org.mentawai.core.Output) com o resultado da execução da action. Por exemplo, sua action pode buscar no banco de dados uma lista de usuários e colocá-la no output da action. Depois, se a consequência da action for FORWARD, você pode acessar o output da action na camada view.


Nessa simples action, nós vamos voltar a versão do username em maiúsculas. O resultado é SUCCESS se o parâmetro estiver presente ou ERROR se o usuário não digitar nada no campo do formulário.

Uma action deve possuir um nome (ou endereço) através do qual ela será chamada pelo browser. Ela deve tb definir conseqüências para os resultados que ela gerar. Ao invés de um arquivo de XML pentelho, o Mentawai faz toda a configuração através de código Java, dentro do arquivo ApplicationManager.java.

// no package (root package)

import org.mentawai.core.*;

public class ApplicationManager extends org.mentawai.core.ApplicationManager {
	
    public void loadActions() {
        
        // Ruby style: less verbose and less clear
        
        action("/HelloWorld", HelloMentawai.class)
            
            .on(SUCCESS, fwd("/hello.jsp"))
            .on(ERROR, fwd("/username.jsp"));
            
        // Java style: more verbose and more clear
        
        ActionConfig ac = new ActionConfig("/HelloWorld", HelloMentawai.class);
        ac.addConsequence(SUCCESS, new Forward("/hello.jsp"));
        ac.addConsequence(ERROR, new Forward("/username.jsp"));
        addActionConfig(ac); // add this action to the application manager
            
    }
}
O nome da action define como você pode chamar a action do browser ou da página HTML. Por exemplo, a action acima pode ser chamada através do link http://www.suaaplicacao.com/HelloWorld.mtw ou, se você utilizando um contexto de aplicação diferente de ROOT, http://www.suaaplicacao.com/SEU_CONTEXTO/HelloWorld.mtw.

Nossa action /HelloWorld usará a classe HelloMentawai e sua implementação.

A consequência do resultado SUCCESS é um forward para /hello.jsp. A consequência do resultado ERROR é um forward para /username.jsp.

Você deve colocar a classe acima (ApplicationManager.class) no diretório /WEB-INF/classes de sua aplicação web. Note que isso faz sentido pois não definimos nenhum pacote para essa classe. Por default o Mentawai procura por essa classe no package root quando o container inicia, mas você pode especificar um outro nome e/ou pacote para essa classe com as seguintes linhas no seu arquivo web.xml:

<web-app>
<!-- The Mentawai controller -->
<servlet>
    <servlet-name>Controller</servlet-name>
    <servlet-class>org.mentawai.core.Controller</servlet-class>
    <init-param>
        <param-name>applicationManager</param-name>
        <param-value>examples.helloworld.ApplicationManager</param-value>
    </init-param>        
    <load-on-startup>1</load-on-startup>		
</servlet>

<!-- You must choose an extension to indicate a mentawai action -->
<servlet-mapping>
    <servlet-name>Controller</servlet-name>
    <url-pattern>*.mtw</url-pattern>
</servlet-mapping>
</web-app>
	

Estamos especificando que a classe ApplicationManager é examples.helloworld.ApplicationManager, sobrescrevendo o default do Mentawai que é procurar no root.

O conteúdo do arquivo username.jsp está abaixo.É somente um formulário HTML que faz o submit do username para a action HelloMentawai.

<html>
<body>
<h1>Hello Metawai!</h1>
<mtw:form>
Type your username: <mtw:input name="username" size="25" />
<mtw:submit value="Send" action="/HelloWorld.mtw" method="post" />
</mtw:form>
</body>
</html>
	

O conteúdo do arquivo hello.jsp está abaixo. Note o uso da tag Mentawai para exibir o output.
<%@ taglib uri="/WEB-INF/lib/mentawai.jar" prefix="mtw" %>
<html>
<body>
<h3>Hello <mtw:out value="username" /> from Mentawai!</h3><!-- Menta Tag -->
<!-- or, if you prefer... -->
<%--
<h3>Hello <c:out value="${username}" /> from Mentawai!</h3><!-- JSTL -->
<h3>Hello ${username} from Mentawai!</h3><!-- EL -->
<h3>Hello $username from Mentawai!</h3><!-- Velocity -->
--%>
</body>
</html>
	
Como a consequência do success é FORWARD, todas as informações da action estão disponíveis na camada view e podemos usar a tag <mtw:out> para exibir o valor do output da action. Essa tag funciona bem parecido com a EL (Expression Language) do JSP , procurando por valores nos escopos: page, output (requisição), session e application. Você pode também usar o operador ponto (.) para acessar propriedades como user.name.firstName.