Vaadin e Java EE 6 com Demoiselle

Para quem tem afinidade e algum histórico com JFC/Swing, onde toda a interface gráfica de uma aplicação é programada em Java, o desenvolvimento web pode ser meio traumático. Somos praticamente forçados a conhecer uma séria de outras linguagens e tecnologias, uma verdadeira “sopa de letrinhas”: HTML, XHTML, CSS, XPath, JavaScript, JQuery, JSF, JSP, Facelets, JSON, Ajax, e por aí vai. O programador é obrigado a  se tornar poliglota (isso não é de todo ruim, mas já é assunto pra outro post) e muitas vezes fazer o trabalho de vários profissionais. Não é à toa que muitas aplicações web tem uma aparência sofrível. São os designers que tem expertise para projetar interface, não os programadores.

Conheci o Vaadin no JavaOne 2009, no pavilhão do evento, conversando alguns minutos com um dos desenvolvedores. Peguei de brinde o Book of Vaadin e de vez em quando venho folheando ele. Também já fiz algumas brincadeirinhas,  mas nenhum desenvolvimento profissional. Cheguei a comentar com alguns colegas até que Marlon se interessou e escreveu um primeiro post no blog do JavaBahia, apresentando o framework. Na linha do Wicket e do GWT, o Vaadin atrai aqueles que sabem Java e querem programar para a web usando esta linguagem, aproveitando os conceitos que já aprendeu sobre Layout Managers, Componentes Visuais e Listeners. No Vaadin, isso é extremamente fácil de aprender e fazer. A documentação é de boa qualidade (ver Tutorial e Livro) e existem também disponíveis uma série de Add-Ons. Sugiro dar uma navegada pela Demo On-Line para ter uma noção das possibildades.

Tá, mas o que isso tudo tem a ver com o Demoiselle?

Tudo. Na versão 2.0, lançada no final do ano passado com total aderência ao JavaEE 6, temos a premissa de fornecer um framework estensível e independente de camada de apresentação. Embora o JSF seja o padrão adotado na maioria das organizações, inclusive no Serpro, é importante fornecer alternativas. Nesses dias aproveitei a arquitetura flexível da nova versão para criar uma extensão Vaadin para o Demoiselle, começando assim a enxergar como tornar cada vez mais fácil a combinação desses mundos. Vai aqui o resumo de até onde consegui chegar, bem como algumas idéias para evolução desse trabalho.

A primeira coisa que busquei foi como utilizar Vaadin com JavaEE 6, mais especificamente com o CDI. Logo achei esse post que já dava todos os caminhos das pedras. Este é basicamente todo o código que coloquei na extensão Vaadin criada para atender a issue 524 cadastrada no tracker, já disponível no nosso repositório de código-fonte como versão 2.0.1-SNAPSHOT. Também já temos um arquétipo Vaadin-JPA. Ao utilizá-lo, você já tem uma aplicação Maven cujo POM.xml (veja como ele é super simples, já que toda o trabalho é feito pelo demoiselle-vaadin-parent) está preparado para usar Demoiselle Core e as extensões Demoiselle Vaadin e JPA.

Por enquanto o arquétipo produz uma aplicação bem trivial. Apenas um HelloApp que estende de br.gov.frameworkdemoiselle.template.VaadinApplication, injetando (@Inject, do CDI) e acionando o método sayHello() de HelloService, estereotipada com @BusinessController.

public class HelloApp extends VaadinApplication {
	@Inject ResourceBundle bundle;
	@Inject HelloService helloService;
	public void init() {
		final Window window = new Window(bundle.getString("app.title"));
		final TextField name = new TextField(bundle.getString("name.text"));
		window.addComponent(name);
		Button submit = new Button(bundle.getString("ok.text"), new ClickListener() {
			public void buttonClick(ClickEvent event) {
				window.showNotification(helloService.sayHello(name.toString()));
			}
		});
		window.addComponent(submit);
		setMainWindow(window);
	}
}

HelloApp e HelloService injetam br.gov.frameworkdemoiselle.util.ResourceBundle, o que já nos permite internacionalizar a aplicação buscando o Locale do browser (isso é possível por causa da fábrica br.gov.frameworkdemoiselle.internal.factory.LocaleFactory implementada na estensão Vaadin). HelloService também injeta um Logger (no Demoiselle Core tem um LoggerFactory), mostrando como é fácil colocar sua aplicação para registrar log. Para conhecer mais funcionalidades do Demoiselle sugiro dar uma olhada na documentação disponível em http://demoiselle.sf.net/docs.

@BusinessController
public class HelloService {
	@Inject Logger logger;
	@Inject ResourceBundle bundle;
	public String sayHello(String name) {
		logger.info(bundle.getString("log.sayinghello.text") + " " + name);
		return bundle.getString("hello.text") + " " + name + "!!!";
	}
}

O web.xml é também bastante simples. Utiliza o VaadinApplicationServlet da extensão Demoiselle para instanciar a aplicação web HelloApp através do CDI. O listener org.jboss.weld.environment.servlet.Listener só é necessário quando não estamos usando um container Java EE 6 completo, como é o caso do Tomcat. Se você resolver testar com JBoss 6 ou Glassfish, remova a tag <listener>.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
	<display-name>vaadinhello</display-name>
	<listener>
		<listener-class>org.jboss.weld.environment.servlet.Listener</listener-class>
	</listener>
	<!-- ApplicationServlet from Vaadin jar will respond to requests. -->
	<servlet>
		<servlet-name>HelloApp</servlet-name>
		<servlet-class>br.gov.frameworkdemoiselle.servlet.VaadinApplicationServlet</servlet-class>
		<init-param>
			<!-- Define our application class for servlet. -->
			<param-name>application</param-name>
	    	<param-value>br.gov.frameworkdemoiselle.sample.vaadinhello.HelloApp</param-value>
		</init-param>
	</servlet>
	<!-- Make the servlet respond to all requests. -->
	<servlet-mapping>
		<servlet-name>HelloApp</servlet-name>
		<url-pattern>/*</url-pattern>
	</servlet-mapping>
</web-app>

Resolvi criar um pequeno vídeo mostrando a criação de um aplicação. O código do vaadin-hello está disponível no Incubator do Demoiselle.

Para assistir, baixe os dois arquivos baixo na mesma pasta e abra vaadinhello.htm no browser local:

https://demoiselle.svn.sourceforge.net/svnroot/demoiselle/incubator/vaadinhello/vaadinhello.htm
https://demoiselle.svn.sourceforge.net/svnroot/demoiselle/incubator/vaadinhello/vaadinhello.swf

(Obrigado WordPress.com por não me deixar incorporar o video Flash nesse post!)

Se desejar um exemplo mais completo, veja o código adaptado do tutorial Adding JPA to the AddressBook Demo. Transformei ele num projeto Maven e coloquei a dependencia da extensão demoiselle-vaadin. Com pequenas alterações temos uma aplicação Vaadin completa usando Demoiselle, JavaEE 6 e JPA. O código também está no Incubator do Demoiselle.

Trabalhos futuros, temos vários em mente. Algumas idéias:

• Adaptar o arquétipo para criar uma aplicação BookMarks, semelhante ao que é feito hoje no arquétipo JSF-JPA. Aí poderemos ter um QuickStart também para o Vaadin!
• Na extensão vaadin, criar abstrações que facilitem a criação de CRUDs. Ainda se escreve muito código, como podemos ver no tutorial Adding JPA to the AddressBook Demo
• Incorporar na extensão Vaadin (e mostrar exemplos) Vaadin Bean Validation Add-on, que nos permite usar a JSR-303 para validação em formulários.

Por enquanto, é isso. Foi criada uma entrada no fórum do Demoiselle para discutir publicamente ideias para essa nova extensão. Toda contribuição é bem-vinda. Até a próxima!

Por uma indisponibilidade temporária no ambiente do sourceforge, ainda não conseguimos fazer deploy do parent demoiselle-vaadin-parent-2.0.1-SNAPSHOT, do arquétipo demoiselle-vaadin-jpa-2.0.1-SNAPSHOT nem da extensão demoiselle-vaadin-2.0.1-SNAPSHOT no repositório do Demoiselle http://demoiselle.sf.net/repository/snapshot. Assim que o sourceforge estiver normalizado, faremos isso.

CDI + JUnit = demoiselle-junit

Demoiselle + CDI + JUnit

Dedico este post a todos que precisam de um mero @Inject nos seus casos de teste e não acham nenhuma solução simples pela Web. Faz tempo que passamos por este aperto no projeto Demoiselle 2.0. Esperamos durante meses por uma versão estável do Arquillian, que ainda não saiu e nem é tão fácil de usar. Queríamos algo simples, sem recursos super-avançados, que se aplicasse na maioria dos casos. Então criamos a extensão demoiselle-junit.

O projeto Arquillian sem sombra de dúvidas é um grande projeto, talvez muito grande para quem quer resolver problemas simples de injeção de beans nos seus casos de teste. Criamos a demoiselle-junit, uma extensão do Framework Demoiselle 2.0, que não pretende competir com o Arquillian. Na realidade trata-se de uma alternativa simples para casos do dia-a-dia, algo prático do tipo plugar-e-usar.

Esta extensão estará disponível à partir da versão 2.0.1 do framework, mas, caso você tenha interesse em experimentar ou propor melhorias, segue o passo-a-passo da configuração da versão 2.0.1-SNAPSHOT usando o Maven. Adicione o seguinte repositório:

<repositories>
	<repository>
		<id>demoiselle.sourceforge.net</id>
		<name>Demoiselle Maven Repository</name>
		<url>http://demoiselle.sourceforge.net/repository/snapshot</url>
	</repository>
</repositories>

Adicione a seguinte dependência:

<dependency>
	<groupId>br.gov.frameworkdemoiselle</groupId>
	<artifactId>demoiselle-junit</artifactId>
	<version>2.0.1-SNAPSHOT</version>
	<scope>test</scope>
</dependency>

Agora faça sua classe de teste conforme o seguinte exemplo:

@RunWith(DemoiselleRunner.class)
public class MeuTest {

	@Inject
	private MeuBean bean;

	@Test
	public void algumTeste() {
		Assert.assertNotNull(bean);
	}
}

Agora a injeção vai funcionar perfeitamente. Basicamente, levantamos um ambiente CDI com ajuda do Weld-SE. Boa diversão!

Fonte: http://cleversonsacramento.wordpress.com/2011/01/12/cdi-junit-demoiselle-junit/