Tutorial Mentawai #10 – Gerenciamento de Conexões JDBC

Padrão

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

Padrão

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

Padrão

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

Padrã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

Padrão

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

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>

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

Padrão

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"));
    }
}

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! 😀