Tutorial Mentawai #1 – Criando uma Aplicação

Padrão

Olá pessoal! Como foi pedido em nossa enquete um pouco sobre programação web, hoje vou começar uma série de posts (mais uma!) sobre desenvolvimento web Java utilizando o framework Mentawai. Mais à frente, assim que concluir a série sobre a biblioteca Allegro 5, pretendo escrever alguns posts sobre o Struts2. Portanto, aguardem pois vem coisa boa por aí!

Pra quem não conhece o Mentawai, é um framework web MVC em Java que prega religiosamente que toda configuração (actions, filtros, validação, listas, etc.) deve ser realizada através de forma programática, ou seja, através de código Java, e não através do uso de XMLs, como ocorre na grande maioria dos frameworks. Particularmente, acho uma proposta bastante interessante.

Para o desenvolvimento de nossos exemplos, você pode utilizar a IDE que desejar, e como servidor de páginas, sugiro a utilização do Apache Tomcat. A versão atual do Mentawai é a 2.3.2 e o jar da do framework pode ser baixado aqui.

O primeiro passo é criarmos a aplicação em si. Se estiver usando o Eclipse, é um projeto Dynamic Web Project e se estiver utilizando o Netbeans, é um projeto Java Web -> Aplicação Web. Com o projeto criado, vamos colocar adicionar o jar do Mentawai ao projeto (a própria IDE tem métodos de adicioná-lo, ou então coloque dentro de WEB-INF/lib. Agora, devemos configurar o arquivo web.xml, que fica dentro da pasta WEB-INF. Se ele não existe, crie-o.

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
	<servlet>
		<servlet-name>Controller</servlet-name>
		<servlet-class>org.mentawai.core.Controller</servlet-class>
		<init-param>
			<param-name>applicationManager</param-name>
			<param-value>net.rafaeltoledo.helloworld.ApplicationManager</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>Controller</servlet-name>
		<url-pattern>*.mtw</url-pattern>
	</servlet-mapping>
	<welcome-file-list>
		<welcome-file>username.jsp</welcome-file>
	</welcome-file-list>
</web-app>

No arquivo, definimos o Controller do Mentawai com o parâmeto servlet, inicializando com o nosso applicationManager. No Mentawai, é ele quem realizará as configurações das Actions – classes que realizam a lógica do aplicativo. No nosso caso, ela estará no pacote net.rafaeltoledo.helloworld. Em seguida, definimos em servlet-mapping qual será a extensão das nossas Actions – .mtw. Assim, uma Action de cadastrar usuário terá um nome como CadastrarUsuario.mtw. Por fim, definimos o arquivo de “boas-vindas”, que será o primeiro a ser chamado ao executar o endereço: username.jsp.

Bom, vamos começar criando uma Action que simplesmente pegará o nome do usuário e o devolverá em letras maiúsculas. Crie o arquivo HelloAction no pacote net.rafaeltoledo.helloworld. O arquivo conterá o seguinte:

package examples.helloworld;

import org.mentawai.core.BaseAction;

public class HelloAction extends BaseAction {

	@Override
	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;
	}
}

A classe estende a classe BaseAction, definida pelo framework. Essa classe já possui métodos para processamento, filtros, e uma série de funcionalidades que podem ser realizadas, como validação. No nosso exemplo, vamos sobrescrever somente o método execute() que é responsável pelo processamento propriamente dito. A action possui os elementos input e output que correspondem aos dados vindos da JSP e o local onde os dados processados serão colocados, respectivamente. Ao terminar a execução, a Action retorna um valor SUCCESS ou ERROR (ou outro valor definido pelo usuário, se for o caso) que indicará se o resultado do processamento teve êxito. No nosso exemplo, obtemos um valor String do formulário, sob o nome de username, sendo obtido através do método getString(). Se o valor não for nulo ou vazio, a String é retornada com seus caracteres em maiúsculo com o método setValue.

O próximo passo, é criarmos o nosso Application Manager. Crie a classe ApplicationManager dentro do pacote net.rafaeltoledo.helloworld. A classe terá esse conteúdo:

package examples.helloworld;

import org.mentawai.core.ActionConfig;
import org.mentawai.core.Forward;

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

	@Override
	public void loadActions() {
		ActionConfig ac = new ActionConfig("/HelloWorld", HelloAction.class);
		ac.addConsequence(SUCCESS, new Forward("/hello.jsp"));
		ac.addConsequence(ERROR, new Forward("/username.jsp"));
		addActionConfig(ac);
	}
}

O nosso ApplicationManager estenderá o ApplicationManager do framework Mentawai. Com isso, sobrescreveremos o método loadActions() que realiza as configurações sobre o comportamento das Actions. Em nosso exemplo, definimos o nome da Action como HelloWorld no construtor da classe ActionConfig (responsável pela configuração propriamente dita) e que essa Action será representada pela classe definida em HelloAction.class (a nossa Action). Em seguida, definimos as consequências, ou seja, o que a Action fará a cada possível saída. Se caso o retorno for SUCCESS, direcionaremos a navegação para hello.jsp (a classe Forward faz o redirecionamento) e, caso for ERROR, voltamos para username.jsp. Por fim, adicionamos a configuração com o método addActionConfig().

O próximo e último passo é criar as duas JSPs. Se você não tem familiaridade com elas, fique tranquilo, pois sua sintaxe compartilha de muitas tags do HTML padrão. No nosso caso, ainda usaremos algumas tags extras do Mentawai. Vamos criar primeiro o arquivo username.jsp na raiz do diretório de páginas web.

<%@ taglib uri="http://www.mentaframework.org/tags-mtw/" prefix="mtw" %>
<body>
	<h1>Olá Mentawai!</h1>
	<mtw:form>
		Digite seu nome: <mtw:input name="username" size="25"/>
		<mtw:submit value="Enviar" action="/HelloWorld.mtw" method="post"/>
	</mtw:form>
</body>

É um formulário bastante simples, com um campo chamado username e um botão com a identificação Enviar. O que temos de “diferente” é a inclusão da taglib, para que possamos utilizar as tags do Mentawai, e que os elementos específicos do Mentawai, tem o prefixo de mtw:. Definimos que ao clicarmos no botão, será chamada a Action HelloWorld.mtw.

Vamos agora criar o arquivo hello.jsp:

<%@ taglib uri="http://www.mentaframework.org/tags-mtw/" prefix="mtw" %>
<html>
	<body>
		<h3>Olá, <mtw:out value="username" />!</h3>
	</body>
</html>

Nesta página, exibimos com a tag mtw:out o valor username. Pronto! É só isso! Agora basta jogar no servidor (geralmente a IDE fará isso automaticamente quando você mandar executar) e acessar em seu navegador localhost:8080/<nome-do-aplicativo> (obs: o valor da porta pode mudar, de acordo com a sua configuração).

Bom pessoal, é isso! Aguardem os próximos posts, pois vamos explorar algumas das várias funcionalidades do framework Mentawai. Até lá!

3 comentários sobre “Tutorial Mentawai #1 – Criando uma Aplicação

  1. Rafael

    Tem como vc disponibilizar esse projeto?? não consegui fazer rodar, estou utilizando o eclipse, tomcat e mentawai 2.5.4?? muito obrigado!!

Deixe uma resposta