HTML5 + Websocket + Demoiselle

O HTML5, mesmo com algumas funcionalidades ainda em processo de definição, vem promovendo mudanças no mundo de desenvolvimento web. Está se tornando (ou já é) o novo padrão para a estruturação e apresentação de conteúdo na web, trazendo melhorias significativas com novas funcionalidades de semântica e acessibilidade, além de melhorar o suporte aos mais recentes conteúdo multimídias.

Acredito que a primeira tecnologia que vem à sua cabeça quando busca criar páginas dinâmicas fazendo acesso assíncrono ao servidor é o famoso AJAX, pois, consciente ou inconscientemente sabemos que os browsers são bons em fazer requisições para o servidor, trocando em miúdos, toda a comunicação HTTP é direcionada pelo cliente, o que exige interação do usuário ou sondagem periódica para carregar novos dados do servidor. Mas, você já pensou o contrário, onde o servidor passa a enviar dados para o browser em momentos aleatórios? Diversas “técnicas” foram usadas para simular esse tipo de comunicação, mas, a especificação WebSocket do HTML5 define uma API que estabelece conexões de “soquete” entre um navegador da web e um servidor. Em outras palavras, há uma conexão persistente entre o cliente e o servidor e ambas as partes podem começar a enviar dados a qualquer momento. WebSockets HTML5 oferecem uma enorme redução no tráfego de rede desnecessário e latência em comparação com soluções long-polling que foram usados ​​para simular uma conexão full-duplex através da manutenção de duas conexões.

Conforme André Campanini, o intuito da criação do WebSocket é permitir, de maneira facilitada, o desenvolvimento de aplicações mais performáticas, que dependam de atualizações em tempo real. Exemplos são aplicações de bate-papo, jogos multiplayer online, mapas interativos, cotações de ações ao vivo, ferramentas de colaboração online, notificações, dashboards etc. Aplicações web como estas já eram possíveis antes, mas o WebSocket oferece uma saída para os problemas de escalabilidade e desempenho presentes no HTTP, e sem a complexidade de soluções anteriores.

Neste post mostraremos como criar duas aplicações (servidor e cliente) mostrando o uso de Websocket. nosso escopo é alterar o projeto Bookmark gerado pelo arquétipo demoiselle-jsf-jpa para cada vez que um registro for inserido ou removido enviar para uma aplicação cliente a quantidade de registros no banco e a aplicação cliente mostrará esse valor sem precisar fazer requisição ao servidor.

Novidades na interface de segurança do framework 2.4.0

Em breve será lançada a versão 2.4.0 final do Demoiselle Framework. Enquanto isso você já pode se antecipar as mudanças e experimentar a versão 2.4.0-RC1.

Dentre as mudanças da versão 2.4.0 em relação à versão 2.3.x está o aprimoramento da interface SecurityContext. As modificações não foram grandes, mas é importante que você as conheça. A nova interface é a seguinte:

public interface SecurityContext extends Serializable {

	void login();

	void logout();

	boolean hasPermission(String resource, String operation);

	boolean hasRole(String role);

	User getUser();

	boolean isLoggedIn();

	void checkLoggedIn();
}

Em relação às versões anteriores, o método login agora pode lançar dois tipos de RuntimeException. Caso o processo de autenticação falhe por credenciais inválidas (nome do usuário ou senha informados incorretamente, por exemplo) será lançada uma InvalidCredentialsException. Caso ocorra alguma falha no processamento do login (servidor fora do ar ou banco de dados inacessível, por exemplo) será lançada uma AuthenticationException. A InvalidCredentialsException herda de AuthenticationException. O método logout por sua vez lança apenas AuthenticationException para as falhas no processo de desautenticação.

Os métodos hasPermission e hasRole continuam lançando NotLoggedInException caso o usuário não esteja autenticado e passa a lançar AuthorizationException para os casos de falha na verificação da permissão de acesso, tal como banco de dados fora do ar, arquivo inacessível, erro no sistema, etc.

Os métodos getUser e isLoggedIn não sofreram modificações. Foi criado um novo método checkLoggedIn que lança uma NotLoggedInException caso o usuário não esteja autenticado.

A interface Authenticator teve um mudança nos métodos authenticate e unAuthenticate que passam aceitar o lançamento de Exception para ser tratada pela implementação padrão do SecurityContext. Além do mais, o unAuthenticate passou a se chamar unauthenticate:

public interface Authenticator extends Serializable {

	void authenticate() throws Exception;

	void unauthenticate() throws Exception;

	...
}

De forma similar, a interface Authorizer teve mudanças nos seus métodos que também passam aceitar o lançamento de Exception para serem tratadas pelo SecurityContext.

public interface Authorizer extends Serializable {

	boolean hasRole(String role) throws Exception;

	boolean hasPermission(String resource, String operation) throws Exception;
}

Tais mudanças são aparentemente simples e talvez não gere nenhum impacto para você, mas com elas foi possível aprimorar um pouco mais o mecanismo interno de controle de acesso do Demoiselle Framework. Atualize o seu projeto com a versão 2.4.0-RC1 e se antecipe às mudanças. A versão final será lançada em breve!

Segurança com demoiselle-servlet

Vamos neste post mostrar como criar um possível mecanismo de autenticação. Usaremos a forma mais conhecida – e comum – para executar essa verificação que é por meio de um formulário de login, solicitando um nome de usuário e sua respectiva senha. Vamos usar o login module imbutido no servidor de aplicações JBoss 7 para isso. O primeiro passo é criar um usuário de aplicação através do utilitário add-user.sh, conforme pode ser visto neste link.

Nosso exemplo toma como base o projeto bookmark criado pelo arquétipo demoiselle-jsf-jpa. Esse arquétipo depende da extensão demoiselle-jsf, que por sua vez depende da extensão demoiselle-servlet, e esta dá suporte ao JAAS (Java Authentication and Authorization Service). O projeto implementado pode ser encontrado no Github oficial do projeto.

Como nossa aplicação usa a extensão demoiselle-jsf, podemos definir uma página de login que o Framework Demoiselle vai automaticamente lhe redirecionar para essa página caso haja a tentativa de acessar um recurso protegido e nenhum usuário esteja autenticado no sistema. Crie em src/main/webapp a página login.xhtml com o seguinte código:

<html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://java.sun.com/jsf/html">

<h:head>
<title>#{messages['main.app.title']}</title>
</h:head>

<h:body style="background-color:#f1f1f1">
     <h:form>

          Mensagem de erro: <h:messages errorStyle="color:red" globalOnly="false" />
          <br/>
          <h:outputLabel value="Login: " style="font-weight:bold" for="login" />
          <h:inputText id="login" value="#{credentials.username}" />
          <br/>
          <h:outputLabel value="Senha: " style="font-weight:bold" for="senha" />
          <h:inputSecret id="senha" value="#{credentials.password}" />
          <br/>
          <h:commandButton value="Login" action="#{securityContext.login}" />
     </h:form>
</h:body>
</html>

Adicione essa página como a página de login que o mecanismo de segurança irá procurar. Para isso adicione a seguinte linha no arquivo demoiselle.properties:

frameworkdemoiselle.security.login.page = /login.xhtml

Para autenticar um usuário presente no servidor de aplicação através do JAAS, a extensão demoiselle-servlet oferece a classe Credentials, que deve ser injetada em seu código. Como a classe Credentials do Demoiselle está com anotada com @Named podemos acessar seus atributos diretamente por Expression Language (EL), conforme podemos ver nas linhas 12 e 15.

O Framework Demoiselle deixa o desenvolvedor livre para definir qual forma de autenticação usar, de acordo com a sua conveniência e necessidade. A peça chave para tornar isso possível é o contexto de segurança, representado pelo SecurityContext que também está anotado com @Named e possui o método login() responsável por realizar a autenticação do usuário e que podemos chamar diretamente pela action do botão conforme podemos ver na linha 17.

Para fazer com que a página de login seja a primeira, altere o código da página index.html para ficar com o conteúdo abaixo:

<meta http-equiv="Refresh" content="0; URL=login.jsf" />

Consulte a documentação da API e teste o recurso em seu aplicativo. Não esqueça de reportar qualquer dúvida ou problema na lista de discussão e no tracker oficial do projeto.

Extratores, validação e outras novidades para configurar sua aplicação

Desde a versão 2.3 muitas mudanças ocorreram na funcionalidade de configuração do Demoiselle Framework. A forma de utilização na versão 2.4 já consta de forma completa na documentação de referência, e nesse post vamos dar ênfase as principais mudanças e destacar os recursos e facilidades que a nova versão promove para o desenvolvedor.

Algo que os utilizadores de versões anteriores devem ter bastante atenção é o fato de que as convenções não são mais reconhecidas. Por exemplo, se em uma classe de configuração fosse declarado um atributo com o nome appTitle, o Demoiselle iria procurar por appTitle, app.title, app_title e apptitle. Na versão 2.4 apenas será buscado pelo exato nome do atributo (como appTitle no exemplo anterior). Para procurar por um nome diferente do atributo no arquivo de configuração (ou no Sistema Operacional), deve-se utilizar a anotação @Name passando como parâmetro o nome que será procurado pelo mecanismo de configuração.

Fazer validação mantém a integridade dos dados e pode ser fator importante na lógica da aplicação. Uma novidade que irá dar a possibilidade da utilização de novos recursos é a opção de anotar os atributos de configuração com as anotações da especificação Bean Validation (JSR 303). Com esse recurso você pode exigir que determinado parâmetro não seja nulo (@NotNull), limitar um valor máximo ou mínimo para ele (@Max e @Min, respectivamente), dentre outras restrições (que podem ser feitas simultaneamente). A lista completa das restrições que podem ser aplicadas nos atributos das classes de configuração pode ser conferida aqui. Para utilizar esse recurso você deve ter como dependência de seu projeto alguma implementação da especificação Bean Validation. A implementação de referência é o Hibernate Validator. Para adicioná-la no seu projeto Maven, basta incluir no seu pom.xml a seguinte dependência:

<dependency>
	<groupId>org.hibernate</groupId>
	<artifactId>hibernate-validator</artifactId>
</dependency>

A maior novidade fica por conta de um recurso que pode ser utilizado de forma a dar mais flexibilidade para as aplicações que utilizam o Demoiselle Framework: são os extratores de configuração. Os extratores são classes responsáveis por extrair os valores das configurações do arquivo de propriedades de forma apropriada para determinado tipo de atributo. O Demoiselle suporta nativamente a extração dos tipos mais comuns (veja lista completa na documentação de referência). Mas, e se eu quiser utilizar na minha aplicação uma configuração de um tipo que não seja suportado nativamente pelo Framework? Não há problemas, seu aplicativo pode criar quantas classes extratoras forem necessárias. Para ser extratora de configuração uma classe deve implementar a interface ConfigurationValueExtractor. Existem dois métodos presentes nessa interface, que servem para: responder de qual tipo a classe é extratora, e para extrair os dados de fato.

Para mais detalhes sobre esse recurso, continue lendo.

Usando JPA e JDBC em um mesmo projeto

Vimos que a extensão de demoiselle-jdbc está entre as novidades da versão 2.4.0 do Framework Demoiselle, mas, será possível usá-la em conjunto com a extensão demoiselle-jpa? Plagiando Barack Obama: – “Yes! We Can!”.

Partiremos do pressuposto que você já está familiarizado com o ambiente de desenvolvimento do Framework Demoiselle. Inicialmente vamos criar um projeto utilizando o arquétipo demoiselle-jsf-jpa, o famoso projeto bookmark. O projeto implementado pode ser encontrado no Github oficial do projeto.

Software necessário

Para criar esse exemplo utilizamos os seguintes aplicativos:

• Eclipse IDE (Kepler, versão 4.3.1)
• JDK da Oracle, versão 6 update 45

Continue lendo para acompanhar nosso exemplo passo-a-passo.

Nosso exemplo

O primeiro passo é abrir o arquivo pom.xml e descomentar a dependência da extensão demoiselle-jta, pois delegaremos o controle de transação para o container JEE, e adicionar a dependência da extensão demoiselle-jdbc, conforme código a seguir:

<dependency>
    <groupId>br.gov.frameworkdemoiselle</groupId>
    <artifactId>demoiselle-jta</artifactId>
    <scope>compile</scope>
</dependency>
<dependency>
    <groupId>br.gov.frameworkdemoiselle</groupId>
    <artifactId>demoiselle-jdbc</artifactId>
    <scope>compile</scope>
</dependency>

O segundo passo é configurar a conexão com o banco de dados. O produtor de conexões possui suporte ao acesso direto utilizando uma URL ou acesso via DataSource (JNDI). No exemplo passado usamos a configuração por URL, agora utilizaremos o acesso via DataSource (JNDI). Edite o arquivo demoiselle.properties adicionando a linha abaixo:

frameworkdemoiselle.persistence.jndi.name=java:jboss/datasources/ExampleDS

Conforme dito, delegaremos o controle de transação para o container JEE, então é preciso ajustar o arquivo persistence.xml conforme código abaixo:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">

	<persistence-unit name="bookmark-ds" transaction-type="JTA">
		<jta-data-source>java:jboss/datasources/ExampleDS</jta-data-source>

		<class>br.gov.serpro.jpa_jdbc_sample.domain.Bookmark</class>

		<properties>
			<property name="hibernate.show_sql" value="true" />
			<property name="hibernate.format_sql" value="false" />
			<property name="hibernate.hbm2ddl.auto" value="create-drop" />
			<property name="hibernate.dialect" value="org.hibernate.dialect.H2Dialect" />
			<property name="hibernate.transaction.jta.platform" value="org.hibernate.service.jta.platform.internal.JBossAppServerJtaPlatform" />
		</properties>
	</persistence-unit>
</persistence>

Feito as configurações, partiremos para o código de demonstração. A proposta do exemplo é criar um log em banco de dados para que toda vez que for feita uma inserção ou atualização de um bookmark gravaremos no banco essa operação. Salientamos que o exemplo apresentado é meramente ilustrativo e que existem melhores opções para fazer auditoria em banco de dados, como o Envers!

Considerando que teríamos um SGBD com o banco de dados criado e as tabelas criadas, teríamos somente que criar a estrutura da tabela conforme SQL abaixo:

CREATE TABLE log (
id identity NOT NULL,
datahora timestamp NOT NULL,
operacao varchar(255) NOT NULL,
registro varchar(255) NOT NULL,
CONSTRAINT log_pk PRIMARY KEY (id));

Mas, como estamos utilizando o HSQLDB, criamos uma classe chamada DDL.java para criar a tabela sempre que você fizer o deploy da aplicação. Fica como mais um exemplo de uso da extensão demoiselle-jdbc.

package br.gov.serpro.jpa_jdbc_sample.persistence;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import javax.inject.Inject;
import br.gov.frameworkdemoiselle.lifecycle.Startup;
import br.gov.frameworkdemoiselle.transaction.Transactional;

public class DDL {

	@Inject
	private Connection connection;

	@Startup
	@Transactional
	public void dropAndCreate() throws Exception {
		dropTableIfExists("log");
		createTableLog();
	}

	private void dropTableIfExists(String tableName) throws Exception {
		PreparedStatement pstmt;
		String sql = "select (count(*) > 0) from information_schema.tables where table_name = ?; ";
		pstmt = connection.prepareStatement(sql.toString());
		pstmt.setString(1, tableName);
		ResultSet rs = pstmt.executeQuery();
		rs.next();
		boolean exists = rs.getBoolean(1);
		rs.close();
		pstmt.close();
		if (exists) {
			pstmt = connection.prepareStatement("DROP TABLE " + tableName  + "; ");
			pstmt.execute();
			pstmt.close();
		}
	}

	private void createTableLog() throws Exception {
		StringBuffer sql = new StringBuffer();
		sql.append("CREATE TABLE log ( ");
		sql.append("	id identity NOT NULL, ");
		sql.append("	datahora timestamp NOT NULL, ");
		sql.append("	operacao varchar(255) NOT NULL, ");
		sql.append("	registro varchar(255) NOT NULL, ");
		sql.append("CONSTRAINT log_pk PRIMARY KEY (id) ");
		sql.append("); ");
		PreparedStatement pstmt = connection.prepareStatement(sql.toString());
		pstmt.execute();
		pstmt.close();
	}
}

Posto esses detalhes, vamos criar a entidade Log que será persistida no banco.

package br.gov.serpro.jpa_jdbc_sample.domain;

import java.io.Serializable;

public class Log implements Serializable {

	private static final long serialVersionUID = 1L;

	private Long id;
	private String datahora;
	private String operacao;
	private String registro;

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public String getDatahora() {
		return datahora;
	}

	public void setDatahora(String datahora) {
		this.datahora = datahora;
	}

	public String getOperacao() {
		return operacao;
	}

	public void setOperacao(String operacao) {
		this.operacao = operacao;
	}

	public String getRegistro() {
		return registro;
	}

	public void setRegistro(String registro) {
		this.registro = registro;
	}
}

O próximo passo é criar a camada de persistência, aqui representada pela classe LogDAO, conforme visto abaixo:

package br.gov.serpro.jpa_jdbc_sample.persistence;

import java.io.Serializable;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import javax.inject.Inject;
import br.gov.frameworkdemoiselle.DemoiselleException;
import br.gov.frameworkdemoiselle.stereotype.PersistenceController;
import br.gov.serpro.jpa_jdbc_sample.domain.Bookmark;
import br.gov.serpro.jpa_jdbc_sample.domain.Log;

@PersistenceController
public class LogDAO implements Serializable {

	private static final long serialVersionUID = 1L;

	@Inject
	private Connection connection;

	public void insert(Bookmark bookmark, String operacao) {

		StringBuffer sql = new StringBuffer();
		sql.append("insert into log (datahora, operacao, registro) ");
		sql.append("values (now(), ?, ?)");

		try {
			PreparedStatement pstmt;
			pstmt = connection.prepareStatement(sql.toString());
			pstmt.setString(1, operacao);
			pstmt.setString(2, bookmark.getId() + " # " + bookmark.getDescription() + " # " + bookmark.getLink());
			pstmt.execute();
			pstmt.close();
		} catch (SQLException e) {
			throw new DemoiselleException("Não foi possível gravar o log de operação");
		}

	}

	public List findAll() throws Exception {
		StringBuffer sql = new StringBuffer();
		sql.append("select * from log");

		PreparedStatement pstmt = connection.prepareStatement(sql.toString());

		ResultSet rs = pstmt.executeQuery();
		List result = new ArrayList();

		while (rs.next()) {
			Log log = new Log();
			log.setId(rs.getLong("id"));
			log.setDatahora(rs.getString("datahora"));
			log.setOperacao(rs.getString("operacao"));
			log.setRegistro(rs.getString("registro"));
			result.add(log);
		}

		rs.close();
		pstmt.close();
		return result;
	}

}

Criamos a classe LogBC só para seguir o padrão do projeto, veja código abaixo:

package br.gov.serpro.jpa_jdbc_sample.business;

import java.io.Serializable;
import java.util.List;
import javax.inject.Inject;
import br.gov.frameworkdemoiselle.stereotype.BusinessController;
import br.gov.serpro.jpa_jdbc_sample.domain.Bookmark;
import br.gov.serpro.jpa_jdbc_sample.domain.Log;
import br.gov.serpro.jpa_jdbc_sample.persistence.LogDAO;

@BusinessController
public class LogBC implements Serializable{

	private static final long serialVersionUID = 1L;

	@Inject
	private LogDAO logDAO;

	public List findAll() throws Exception {
		return logDAO.findAll();
	}

	public void insert(Bookmark bookmark, String operacao){
		logDAO.insert(bookmark, operacao);
	}

}

Como nossa proposta é registrar a cada inserção e atualização um log dessa operação, adaptamos a classe BookmarkBC. Reparem que sobrescrevemos os métodos insert e update e que dentro deles chamamos os métodos de LogBC (linhas 22 e 29) cuja conexão é JDBC e o BookmarkDAO (linhas 21 e 28) cuja conexão é JPA.

package br.gov.serpro.jpa_jdbc_sample.business;

import javax.inject.Inject;
import br.gov.frameworkdemoiselle.stereotype.BusinessController;
import br.gov.frameworkdemoiselle.template.DelegateCrud;
import br.gov.frameworkdemoiselle.transaction.Transactional;
import br.gov.serpro.jpa_jdbc_sample.domain.Bookmark;
import br.gov.serpro.jpa_jdbc_sample.persistence.BookmarkDAO;
import br.gov.serpro.jpa_jdbc_sample.persistence.LogDAO;

@BusinessController
public class BookmarkBC extends DelegateCrud<Bookmark, Long, BookmarkDAO> {

	private static final long serialVersionUID = 1L;

	@Inject
	private LogBC logBC;

	@Transactional
	public Bookmark insert(final Bookmark bookmark) {
		Bookmark bookmarkResult = getDelegate().insert(bookmark);
		logBC.insert(bookmarkResult, "insert");
		return bookmarkResult;
	}

	@Transactional
	public Bookmark update(final Bookmark bookmark) {
		Bookmark bookmarkResult = getDelegate().update(bookmark);
		logBC.insert(bookmarkResult, "update");
		return bookmarkResult;
	}
}

Pronto! Vimos que é plenamente possível usar as duas extensões de persistência, aproveite e tire o máximo de proveito de cada uma! Não esqueça de reportar qualquer dúvida ou problema na lista de discussão e no tracker oficial do projeto.

Determinando o escopo do EntityManager injetado pelo Demoiselle

Um dos recursos da extensão demoiselle-jpa é fornecer um produtor de instâncias de EntityManager e cuidar do ciclo de vida dessas instâncias, providenciando que permaneçam consistentes durante uma chamada de método de negócio e que sejam devidamente fechadas ao final dessa chamada. Até o momento qualquer injeção de EntityManager ficava armazenada no escopo Request, o que significa que durante uma requisição web qualquer ponto de injeção receberá a mesma instância de EntityManager.

Isso é interessante para a maior parte dos casos, mas não permite flexibilidade para contornar situações onde esse comportamento não é desejável. Exemplos de tais situações incluem:

• Sistemas não web
• Chamadas onde o escopo de requisição não está ativo
• Situações que requerem controlar o tempo de vida do EntityManager, para evitar a famosa exceção LazyInitializationException

Começando na versão 2.4 a extensão demoiselle-jpa permitirá determinar o escopo do EntityManager. Além disso ela permitirá desligar o controle de escopo, entregando ao desenvolvedor a tarefa de controlar o ciclo de vida manualmente.

Para demonstrar essa nova funcionalidade, elaboramos um pequeno exemplo do recurso em ação. O aplicativo de exemplo está disponível no repositório do projeto no Github.

Software necessário

Para criar esse exemplo utilizamos os seguintes aplicativos:

• Eclipse IDE (Kepler, versão 4.3.1) + Plugin Jboss Tools
• Servidor de Aplicação JBoss AS 7.1
• JDK da Oracle, versão 6 update 45

Continue lendo nosso passo-a-passo desse novo recurso.

Nova extensão de persistência usando JDBC

A extensão de persistência usando JDBC (demoiselle-jdbc) está entre as novidades da versão 2.4.0 do Framework Demoiselle, o qual passou a fornecer um produtor padrão para conexões JDBC puras. Neste post mostraremos como criar uma camada de persistência com as operações CRUD usando essa nova extensão.

Partiremos do pressuposto que você já está familiarizado com o ambiente de desenvolvimento do Framework Demoiselle. Inicialmente vamos criar um projeto utilizando o arquétipo demoiselle-minimal, no nosso caso, o projeto chamar-se-á book. O projeto implementado com testes JUnit pode ser encontrado no Github oficial do projeto.

Software necessário

Para criar esse exemplo utilizamos os seguintes aplicativos:

• Eclipse IDE (Kepler, versão 4.3.1)
• JDK da Oracle, versão 6 update 45

Continue lendo para acompanhar nosso exemplo passo-a-passo.

Nova API para monitoração e gerenciamento de aplicações

Um dos novos recursos do Demoiselle 2.4.0 é a criação de uma nova API para monitorar aplicações. Com este recurso é possível adicionar pontos de entrada em seu sistema que permitem monitorar remotamente qualquer recurso desejado, além de configurar o comportamento da aplicação sem a necessidade de parar o servidor.

Existem várias tecnologias de monitoração no mercado. O Java possui uma especificação própria para monitoração de aplicações – a tecnologia JMX especificada originalmente na JSR-3 e estendida em outras JSR’s como a JSR-160 (JMX Remoting). O JMX permite a monitoração e gerenciamento remoto de aplicações Java e é a base do sistema de administração de diversos servidores de aplicação como o JBoss e o Glassfish. Além do JMX, existem outras tecnologias de monitoração como a SNMP e o Zabbix. A API do Demoiselle visa tornar transparente ao desenvolvedor a diferença entre essas tecnologias e fornecer uma interface única de monitoração que permite dar acesso ao seu sistema através das várias tecnologias de monitoração existentes.

Para demonstrar o poder desse novo recurso e dar uma breve introdução do uso de monitoração em sua aplicação, vamos criar um novo projeto usando o arquétipo demoiselle-jsf-jpa (o sistema Bookmark) e acrescentar a ele algumas métricas de monitoração.

O aplicativo de exemplo está disponível no repositório do projeto no Github.

Software necessário

Para criar esse exemplo utilizamos os seguintes aplicativos:

• Eclipse IDE (Kepler, versão 4.3.1) + Plugin Jboss Tools
• Servidor de Aplicação JBoss AS 7.1
• JDK da Oracle, versão 6 update 45

Continue lendo nosso passo-a-passo desse novo recurso.

Compatibilidade entre as versões 2.3 e 2.4

Em relação à compatibilidade, a recém-lançada versão 2.4.0-RC1 traz poucos impactos em comparação com a família 2.3. Para termos um exemplo, basta criarmos um arquétipo demoiselle- jsf-jpa da versão 2.3.4, e modificarmos sua versão do parent para  2.4.0-RC1. Para fazer essa mudança, basta uma pequena modificação no pom.xml da aplicação, como mostra o código abaixo.

	<parent>
		<groupId>br.gov.frameworkdemoiselle</groupId>
		<artifactId>demoiselle-jsf-parent</artifactId>
		<version>2.4.0-RC1</version>
	</parent>

Depois dessa modificação aparecerá um erro no projeto, que é no método handleLoad() da classe BookmarkEditMB. Isso se dá por conta da mudança em sua interface; na nova versão esse método recebe o id do bean e retorna o bean carregado. Logo a solução para essa quebra é bastante simples, basta modificar o método para receber um Long e retornar um Bookmark. O código abaixo mostra como deve ficar esse método.

@Override
protected Bookmark handleLoad(Long id) {
return this.bookmarkBC.load(id);}

Pronto, o arquétipo com a versão do parent já está atualizada e a aplicação pronta para ser executada, e com os novos recursos da versão 2.4.0-RC1 à disposição. Esses novos recursos serão temas de outros posts.

Uma outra modificação é sugerida (mas ainda não obrigatória) nas classes BookmarkListMB e BookmarkEditMB. Trata-se da retirada do ponto antes do nome da página que passamos como parâmetro nas anotações @NextView e @PreviousView. Esse ponto não é necessário, e pode causar problemas. O código abaixo mostra como devem ficar os parâmetros passados para essas anotações.

@NextView("/bookmark_edit.xhtml")
@PreviousView("/bookmark_list.xhtml")

No caso do arquétipo demoiselle-minimal, após fazer a atualização da versão do parent (de forma similar ao mostrado no primeiro parágrafo) nenhuma outra modificação é necessária.

Essas pequenas modificações são as necessárias para manter o arquétipo Bookmark rodando sem problemas. Outras modificação necessárias para aplicações específicas estarão disponíveis através de outros posts neste blog, da documentação de referência, e do release notes das versões. Fiquem ligados, e até breve!

Configuração do Framework Java Demoiselle 2.3.1 com Eclipse Indigo sr2 3.7, edição Java Developers (64bits para Mac), JBoss 7.1.1.Final e Postgres 9.2 no Mac OS X Mountain Lion 10.8.2

O projeto Demoiselle-Infra não está disponível para Mac e, por isso, usuários dessa plataforma precisam configurar o ambiente manualmente.

Referências:

Wilson Elias Guimarães Neto –
http://pensandoalgo.wordpress.com/2011/10/19/preparando-o-eclipse-indigo-para-o-demoiselle-2/

Emerson Saito –
http://www.frameworkdemoiselle.gov.br/documentacaodoprojeto/manuais-e-tutoriais/tutorial-da-versao-2-2-3-0/

Emerson Saito –
https://frameworkdemoiselle.wordpress.com/2012/11/13/usando-datasources-conexao-com-base-de-dados-no-jboss-as-7-1-2/

Cleverson Sacramento – http://cleversonsacramento.com/2011/09/10/tela-cheia-no-eclipse-com-lion/

1) Download do Eclipse

URL: http://www.eclipse.org/downloads/packages/release/indigo/sr2

2) Instalação de software e updates do Eclipse

2.1) Clique em “Help” → “Eclipse Marketplace”.

2.2) No Marketplace, pesquise pelas palavras chaves “jboss tools” e instale o plugin para a versão Indigo

.

2.3) Instalação do Maven:

Seguindo as dicas do Wilson Elias Guimarães Neto, o jeito mais prático é acessar
“File” → “Import”. Pesquise pelo termo “maven” e selecione a opção “Checkout Maven Projects from SCM”. A tela abaixo será exibida. Clique no link “m2e Marketplace”.

Ao clicar no link “m2e Marketplace”, será exibida a tela com as opções disponíveis para instalação. Marque as opções, conforme imagem abaixo, e prossiga.

3) Criação do projeto:

Acesse “File” →”New” → “Project” e selecione a opção “Maven” → “Maven Project”.

Ou, ainda melhor, use os atalhos para evitar “cliques”. Pressione  <⌘> + N, digite “maven”, navegue com a seta para baixo até a opção “Maven Project” e pressione a tecla <Enter>.

Avance até chegar na tela abaixo, na qual você deverá clicar no botão “Configure…” para adicionar o repositório de arquétipos maven do demoiselle.

Na tela de configuração de repositórios, adiciona o repositório remoto http://demoiselle.sourceforge.net/repository/archetype-catalog.xml. Pode nomear o repositório como “Demoiselle”, por exemplo.

Uma vez configurado o repositório, selecione o recém incluído catálogo “Demoiselle”, marque a opção “demoiselle-minimal”, conforme figura abaixo, e prossiga.

Informe os dados do projeto. Daqui em diante, pode usar o projeto “Inscrição”, seguindo o tutorial da versão 2.3.1.

A figura abaixo mostra o projeto recém criado. Rode os testes do Hello World e certifique-se de que está tudo certo (o resultado será verde).

4) Instalação do Jboss

Em determinado ponto do tutorial citado acima, você precisará rodar a aplicação no servidor de aplicações JBoss. Se tivéssemos usado o Demoiselle-Infra, já estaria tudo pronto. Porém, teremos que instalar manualmente. Baixe a versão 7.1.1.Final aqui (eu extraí o pacote em /usr/bin/).

Caso ainda não esteja aberta a visualização de servidores, acesse “Window” → “Show View” → “Other”, digite “server” e selecione a opção “servers”, conforme abaixo.

Na visualização de servidores, clique no link “new server wizard”.

Em seguida, deixe selecionada a opção JBoss 7.1, avance à próxima tela e você verá a tela abaixo. Já que o Jboss foi extraído em /usr/bin, então o caminho será /usr/bin/jboss-as-7.1.1.Final. Se você fez tudo certo, basta clicar no botão “Finish”, e seu JBoss 7 estará configurado.

Para usar o console de administração do JBoss 7.1, basta criar usuários com o script add_user.sh. Para isso, digite os seguintes comandos no Terminal:

cd /usr/bin/jboss-as-7.1.1.Final/bin

./add_user.sh

Siga as instruções no prompt de comando.

A figura abaixo ilustra todo o procedimento de criação do usuário.

5) Instalação e configuração do Postgres 9.2

Se você configurou tudo até agora e seguiu o tutorial do Demoiselle, percebeu que os dados não persistem de fato (o banco de dados é recriado a cada execução da aplicação).

O JBoss 7.1 já vem com um DataSource configurado (ExampleDS). E esse DS é referenciado no arquétipo demoiselle-jsf-jpa, por exemplo.

Se você ainda não tem o PostgreSQL instalado, baixe aqui. Recomendo o “One Click Installer”.

Depois, siga o tutorial do Saito, que está bem completo. Apesar de ser referente ao PostgreSQL 9.1, não vi nenhuma diferença com relação à configuração do meu ambiente, com o 9.2. Ele também explica como criar usuário no JBoss, citado no tópico (4) acima.

Segue um resumo do tutorial:

• Baixe o driver;

• Copie o arquivo para o diretório de deploys do JBoss. No meu caso executei o comando

sudo mv ~/Downloads/postgresql-9.2-1002.jdbc4.jar /usr/bin/jboss-as-7.1.1.Final/standalone/deployments/

• Inicie seu servidor JBoss pelo Eclipse

Procure as linhas abaixo no console:

INFO  [org.jboss.as.server.deployment] (MSC service thread 1-5) JBAS015876: Starting deployment of “postgresql-9.2-1002.jdbc4.jar”

…

INFO  [org.jboss.as.connector.deployers.jdbc] (MSC service thread 1-1) JBAS010404: Deploying non-JDBC-compliant driver class org.postgresql.Driver (version 9.2)

Significa que o driver do PostgreSQL foi registrado.

• Crie o DataSource java:jboss/datasources/PostgreSqlDS no console de administração web do JBoss, configurando a URL de conexão, que será algo como jdbc:postgresql://localhost:5432/<nome_do_banco_de_dados>. Também será necessário informar um nome de usuário do banco e senha.

• Alterar as configurações da aplicação no persistence.xml para usar o novo DataSource criado. Não esqueça também de alterar a propriedade hibernate.hbm2ddl.auto para update.

6) Aplicação de exemplo usando arquétipo demoiselle-vaadin-jpa

Para arrematar, criei uma aplicação de exemplo usando o vaadin. Criei uma validação adicional em CategoryBC antes de salvar novas categorias, criei uma nova Entity chamada Author e adicionei o atributo Author, com o tipoi @ManyToOne, na entitade Bookmark. Super simples e muito legal.

Imagens abaixo:

7) Conclusões

Considerando:

• Tudo o que foi descrito acima (pode-se dizer que foi bastante fácil fazer esse aplicativo simples, mesmo no ambiente OS X, bastante distinto do utilizado no Serpro);
• A quantidade de material disponível na web sobre o assunto (apesar de ter encontrado bastante material on-line, considero que isso ainda pode melhorar um bocadinho em relação a outros framework, como Django e Rails, principalmente no quesito documentaçao de API contendo exemplos de uso dos métodos das classes do framework);
• O fato de que a estrutura de banco é gerada e/ou atualizadas automaticamente de acordo com as entidades da aplicação e conforme são alteradas;
• A alta estabilidade observada durante a construção da aplicação de exemplo e execução dos testes, sendo que não foi identificado nenhum erro ou travamento;
• A possibilidade de escolher dentre as diferentes implementações disponíveis para as especificações utilizadas pelo framework;

Podemos afirmar, sem medo, que o Demoiselle 2.3.1 é um dos melhores frameworks para construção de aplicativos Web disponíveis no mercado (e estou falando de comparação com Rails e Django que, na minha opinião, são dois dos melhores).

Detalhe: nem cheguei a usar Nimble.

Portanto, framework recomendadíssimo e parabéns à equipe!!! 🙂