Java + FLEX Parte 2 -> Spring BlazeDS Integration + Hibernate

By Felipe Saab

Fala pessoal, finalmente a parte 2 do tutorial da nossa integração Java + FLEX!

CONSIDERAÇÕES INICIAIS

Caso você não tenha visto a Parte 1 do tutorial, por favor, veja ou baixe a aplicação pois a refatoração será feita em cima do projeto desenvolvido no tutorial anterior.

INTRODUÇÃO

Até agora o que temos é uma aplicação com o objetivo de ser uma Agenda de Contatos, porém os contatos estão ficando apenas em memória (uma lista estática na classe ContatoService.java), ao parar o servidor e rodá-lo novamente os contatos anteriormente salvos sumiram.. Ok, para evitar isso vamos persistir os contatos em um banco de dados, e para facilitar ainda mais a nossa vida vamos utilizar o Hibernate para nem nos preocuparmos com SQL, mecher apenas com as classes.

OBS: Por favor não me entenda errado, saber SQL é extremamente importante!! Mesmo utilizando o Hibernate as vezes precisamos construir querys utilizando HQL ou mesmo SQL, mas como nossa aplicação é extremamente simples nós podemos deixar isso de lado e utilizar todas as facilidades que o Hibernate provê.

E tem também o Spring! Ele nos será útil por dois fatores:

Injeção de Dependência: vamos utilizar interfaces e anotações para o Spring injetar os beans que precisamos em cada classe. Por consequência melhorar muito o projeto (design) da nossa aplicação pois as classes ficarão desacopladas (pois utilizaremos as interfaces). Conforme formos escrevendo o código isso ficará mais claro.

Integração com o BlazeDS: vamos utilizar um framework que a SpringSource criou para a integração do Spring com o BlazeDS para não precisarmos de muitas configurações e para termos possibilidade de aproveitar todas as funcionalidades do Spring como segurança e mensagens por exemplo. Para entender melhor sobre este projeto recomendo a leitura da referência [1].

Vamos fazer as coisas por partes então: primeiro vamos adicionar o Spring ao nosso projeto e depois adicionaremos o Hibernate pois ele vai ser um bean gerenciado pelo Spring também.

DOWNLOADS

Spring Framework: Iremos precisar do Spring Framework (utilizarei o 3.1.0 M2) em si e de um outro projeto da SpringSource chamado Spring BlazeDS Integration projetado para facilitar a comunicação do Spring com o FLEX.

Hibernate: No momento em que estou escrevendo este post a última versão é a 3.6.5.

MÃO NA MASSA: SPRING

Vamos começar a escrever códigos então!

Hoje o serviço que o FLEX acessa para recuperar/adicionar os contatos é a classe ContatoService que tem todos os métodos já implementados. Vamos criar uma interface para este serviço para tornar a nossa aplicação mais desacoplada (para mais informação sobre interfaces  e suas vantagens leia este post).

Vamos mudar o nome da classe ContatoService.java para ContatoServiceImpl.java e mudar ela de pacote também: vamos criar um novo pacote e movê-la para ele: br.blog.javasimples.agenda.service.impl.

Agora que a classe já está com o novo nome podemos criar a interface com o nome antigo (ContatoService.java) no pacote br.blog.javasimples.agenda.service (apenas por questões de padrão de nomenclatura). Sendo assim temos a seguinte estrutura:

A interface ContatoService apenas vai definir os métodos que um serviço para contatos deve ter:

/**
 * Interface que define os métodos de um serviço para {@link Contato}.
 *
 * @author Felipe Saab
 */
public interface ContatoService {
 
	/**
	 * Salva um contato.
	 *
	 * @param contato - {@link Contato} a ser salvo
	 */
	void salvar(Contato contato);
 
	/**
	 * Recupera todos os contatos.
	 *
	 * @return Todos os contatos
	 */
	List<contato> getAgenda();
}

E a classe ContatoServiceImpl.java agora deve implementar a interface:

/**
 * Serviço para {@link Contato}.
 *
 * @author Felipe Saab
 */
public class ContatoServiceImpl implements ContatoService {
 
	/**
	 * {@link List Lista} que guarda todos os contatos.
	 */
	private static List<contato> agenda = new ArrayList<contato>();
 
	/**
	 * {@inheritDoc}
	 */
	public void salvar(Contato contato) {
		ContatoServiceImpl.agenda.add(contato);
		System.out.println("Contato adicionado: " + contato);
	}
 
	/**
	 * {@inheritDoc}
	 */
	public List<contato> getAgenda() {
		return ContatoServiceImpl.agenda;
	}
}

Legal, agora que o serviço já virou uma interface e tem sua implementação vamos adicionar as bibliotecas do Spring no nosso projeto.

As bibliotecas que precisamos estão em: {pasta de download do spring}/dist e {pasta de donwload do spring blazeds integration}/dist.

Fiz um pacote com algumas bibliotecas que o Spring utiliza e irão gerar erro caso não estejam no projeto. Adicione essas bibliotecas no classpath também.

Para adicionar as bibliotecas basta colar (CTRL + V) elas na pasta WebContent/WEB-INF/lib do projeto ContatosJ:

Vamos agora começar a mecher em algumas configurações:

WebContent/WEB-INF/web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
	version="2.4">
	<servlet>
		<servlet-name>spring</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>/WEB-INF/applicationContext.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>spring</servlet-name>
		<url-pattern>/messagebroker/*</url-pattern>
	</servlet-mapping>
</web-app>

Antes nós tinhamos o MessageBrokerServlet definido no nosso arquivo, porém com o projeto de integração entre BlazeDS e Spring nós não precisamos mais ter isso tão explícito, o próprio projeto (Spring BlazeDS Integration) se responsabiliza por criar o MessageBroker e fazer todas as configurações internamente.

Porém o pessoal que criou o projeto utilizou o Spring Web MVC internamente (aceitável né… hehehe), sendo assim, tudo o que precisamos fazer é criar um DispatcherServlet (controlador responsável por todas as requisições que chegam para o Spring Web MVC) e mapear todas as requisições que chegarem para o MessageBroker (/messageBroker/*) para ele, ou seja, toda vez que o FLEX enviar uma requisição para a nossa aplicação (a URL vai ser +/- assim: http://localhost:8080/AgendaJ/messageBroker/my-amf/…) ela vai ser encaminhada para o DispatcherServlet e ele por sua vez vai encaminhar para a classe que deve receber e tratar a requisição.

Vamos criar o arquivo de configuração do Spring em WebContent/WEB-INF/applicationContext.xml (pois informamos este caminho no DispatcherServlet definido no web.xml).

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:flex="http://www.springframework.org/schema/flex"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/flex
                           http://www.springframework.org/schema/flex/spring-flex-1.0.xsd">
 
	<!-- Cria o MessageBroker com as configurações padrão -->
	<flex:message-broker />
 
	<!-- Habilita a injeção de dependência através de anotações -->
	<context:annotation-config />
 
	<!-- Faz com que os Services sejam beans gerenciados pelo container do Spring -->
	<context:component-scan base-package="br.blog.javasimples.agenda.service.impl" />
 
</beans>

Neste pequeno arquivo de configuração nós estamos definindo tudo que precisamos para fazer o Spring conversar com FLEX como se fosse por mágica! hehehe

Com a tag <flex:message-broker /> nós estamos pedindo para o Spring BlazeDS Integration criar o MessageBroker (a classe que vai receber as requisições através do DispatcherServlet que configuramos no web.xml).

A tag <context:annotation-config /> habilita a injeção de dependência através de anotações. Para que o Spring BlazeDS Integration consiga fazer com que a comunicação aconteça sem que nós fiquemos configurando muita coisa os Serviços que vão receber as chamadas remotas devem ser gerenciados pelo container do Spring. Para isso nós poderíamos declarar os beans de serviço no applicationContext.xml através da tag <bean id=”contatoService” class=”br.blog.javasimples.service.impl.ContatoServiceImpl” /> porém para cada novo serviço deveríamos fazer o mesmo. Para evitar isso utilizaremos a anotação @Service nas classes para fazer com que o Spring possa gerenciá-las. É equivalente à utilização da tag <bean>. Se você ainda não entendeu continue lendo que já já vai ficar claro.

E a tag <context:component-scan /> fala para o container do Spring procurar no pacote br.blog.javasimples.agenda.service.impl por classes que estejam anotadas com @Service e com outras anotações que ele conhece para gerenciá-las, ou seja, para poder fazer injeção de dependência e para utilizá-las para comunicar com o FLEX.

Para terminarmos a parte de configuração do Spring vamos voltar e mecher na implementação do serviço de Contato adicionando algumas anotações nele:

/**
 * Serviço para {@link Contato}.
 *
 * @author Felipe Saab
 */
@Service
@RemotingDestination(value="contatoService")
public class ContatoServiceImpl implements ContatoService {
 
	/**
	 * {@link List Lista} que guarda todos os contatos.
	 */
	private static List<contato> agenda = new ArrayList<contato>();
 
	/**
	 * {@inheritDoc}
	 */
	public void salvar(Contato contato) {
		ContatoServiceImpl.agenda.add(contato);
		System.out.println("Contato adicionado: " + contato);
	}
 
	/**
	 * {@inheritDoc}
	 */
	public List<contato> getAgenda() {
		return ContatoServiceImpl.agenda;
	}
}

A anotação @Service diz que a classe ContatoServiceImpl vai ser gerenciada pelo Spring, ou seja, ela vai estar presente no container do Spring, consequentemente ela vai conseguir ser acessada por injeção de dependência, e pelo Spring BlazeDS Integration (e qualquer outro lugar que precise dessa classe através do Spring).

E a anotação @RemotingDestination informa qual o id devemos utilizar no RemoteObject do FLEX para chamar os métodos desta classe. Simples assim!!!

Lembra que criamos uma tag <destination> no arquivo WebContent/WEB-INF/flex/remoting-config.xml informando o id e a classe? Agora não precisa mais, só essa anotação já resolve todos os problemas, faz com que o Spring BlazeDS Integration faça tudo sozinho por trás.

Com o Spring BrazeDS Integration tomando conta de criar e gerenciar todas as configurações que vamos precisar para a comunicação Java <-> FLEX podemos “fazer um limpa” nos arquivos de configuração do BlazeDS que nós não vamos utilizar ou que o Spring irá criar sozinho. Podemos apagar os arquivos WebContent/WEB-INF/flex/remoting-config.xml, WebContent/WEB-INF/flex/messaging-config.xml e WebContent/WEB-INF/flex/proxy-config.xml:

Agora vamos ajeitar o arquivo WebContent/WEB-INF/flex/services-config.xml para não referenciar mais os arquivos excluídos:

<?xml version="1.0" encoding="UTF-8"?>
<services-config>
	<services>
		<default-channels>
			<channel ref="my-amf" />
		</default-channels>
	</services>
 
	<security>
		<login-command class="flex.messaging.security.TomcatLoginCommand"
			server="Tomcat" />
	</security>
 
	<channels>
		<channel-definition id="my-amf"
			class="mx.messaging.channels.AMFChannel">
			<endpoint
				url="http://{server.name}:{server.port}/{context.root}/messagebroker/amf"
				class="flex.messaging.endpoints.AMFEndpoint" />
		</channel-definition>
	</channels>
 
	<logging>
		<target class="flex.messaging.log.ConsoleTarget" level="Error">
			<properties>
				<prefix>[BlazeDS] </prefix>
				<includeDate>true</includeDate>
				<includeTime>true</includeTime>
				<includeLevel>true</includeLevel>
				<includeCategory>true</includeCategory>
			</properties>
			<filters>
				<pattern>Endpoint.*</pattern>
				<pattern>Service.*</pattern>
				<pattern>Configuration</pattern>
			</filters>
		</target>
	</logging>
 
	<system>
		<redeploy>
			<enabled>true</enabled>
			<watch-interval>20</watch-interval>
			<watch-file>{context.root}/WEB-INF/flex/services-config.xml</watch-file>
			<touch-file>{context.root}/WEB-INF/web.xml</touch-file>
		</redeploy>
	</system>
</services-config>

A grande alteração nesse arquivo foi na tag <services> onde removemos as referências aos arquivos que acabamos de excluir e indicamos para o BlazeDS que o canal padrão para a comunicação é o canal my-amf, ou seja, todas as requisições que chegarem para o message-broker e não tiverem um canal em específico irão ser enviados para o canal my-amf.

OBS: também foram removidas as referências dos arquivos removidos da tag <redeploy>.

E com isso terminamos a configuração do Spring! Que maravilha não?!?! Valeu SpringSource por fazer esse projetinho show de bola!

ADICIONANDO O HIBERNATE

Uma vez que o Spring está configurado vamos para a persistência dos dados com o Hibernate.

Primeiro de tudo vamos criar um banco de dados para a nossa aplicação:

CREATE TABLE contato (
	id INT( 11 ) NOT NULL AUTO_INCREMENT,
	nome VARCHAR( 50 ) NOT NULL ,
	telefone VARCHAR( 14 ) NOT NULL ,
	email VARCHAR( 50 ) NULL ,
	PRIMARY KEY ( id )
) ENGINE = innodb CHARACTER SET utf8 COLLATE utf8_unicode_ci;

Ok, agora precisamos das bibliotecas do Hibernate no classpath da nossa aplicação. Vamos adicionar as bibliotecas:
{pasta download hibernate}/hibernate3.jar
{pasta download hibernate}/lib/jpa
{pasta download hibernate}/lib/required
{pasta download hibernate}/lib/bytecode/javassist

E também precisamos da biblioteca que contém o driver do banco de dados que estamos utilizando (no meu caso a do MySQL).

Agora já podemos realizar o mapeamento objeto relacional da nossa classe Contato.java para a tabela Contato do banco de dados (eu gosto de mapear utilizando anotações, mas não tem problema nenhum utilizar xml):

/**
 * Classe que representa um Contato da agenda.
 *
 * @author Felipe Saab
 */
@Entity
@Table(name = "CONTATO")
public class Contato implements Serializable {
 
	private static final long serialVersionUID = -1549466344815889020L;
 
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	@Column(name="ID", length=11, nullable=false)
	private Long id;
 
	@Column(name="NOME", length=50, nullable=false)
	private String nome;
 
	@Column(name="TELEFONE", length=14, nullable=false)
	private String telefone;
 
	@Column(name="EMAIL", length=50)
	private String email;
 
	public Long getId() {
		return id;
	}
 
	public void setId(Long id) {
		this.id = id;
	}
 
	public String getNome() {
		return nome;
	}
 
	public void setNome(String nome) {
		this.nome = nome;
	}
 
	public String getTelefone() {
		return telefone;
	}
 
	public void setTelefone(String telefone) {
		this.telefone = telefone;
	}
 
	public String getEmail() {
		return email;
	}
 
	public void setEmail(String email) {
		this.email = email;
	}
 
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("[");
		sb.append(this.getNome() + ",");
		sb.append(this.getTelefone() + ",");
		sb.append(this.getEmail());
		sb.append("]");
		return sb.toString();
	}
}

Foi adicionado o atributo id para representar a chave primária do contato.

Como também existe uma classe Contato no FLEX precisamos atualizá-la:

package br.blog.javasimples.agenda.model
{
	[Bindable]
	[RemoteClass(alias="br.blog.javasimples.agenda.model.Contato")]
	public class Contato
	{
		public var id:Number;
		public var nome:String;
		public var telefone:String;
		public var email:String;
 
		public function Contato()
		{
		}
	}
}

Vamos utilizar agora um padrão de projeto (design pattern) chamado DAO (Data Access Object): tal padrão visa centralizar o acesso aos dados em um único objeto, ou seja, sempre que precisarmos gravar/recuperar algo do banco de dados vamos utilizar os métodos desse objeto.

Do mesmo jeito que fizemos a interface ContatoService é interessante fazer a ContatoDao. Seguindo o padrão de nomenclarura dos pacotes vamos criá-la no pacote br.blog.javasimples.agenda.dao:

/**
 * Interface que define os métodos de um DAO para {@link Contato}.
 *
 * @author Felipe Saab
 */
public interface ContatoDao {
	/**
	 * Salva um contato.
	 *
	 * @param contato - {@link Contato} a ser salvo
	 */
	void salvar(Contato contato);
 
	/**
	 * Recupera todos os contatos.
	 *
	 * @return Todos os contatos
	 */
	List<contato> getAgenda();
}

Foram definidos os métodos que já estamos utilizando em ContatoService para acessar os dados para depois que o DAO estiver pronto nós apenas delegarmos a chamada do Service para DAO.

Vamos para a implementação então – sempre seguindo o padrão de nomenclatura dos pacotes: br.blog.javasimples.agenda.dao.impl.

/**
 * DAO para {@link Contato}.
 *
 * @author Felipe Saab
 */
@Repository
public class ContatoDaoImpl extends HibernateDaoSupport implements ContatoDao {
 
	@Autowired
	public void init(SessionFactory sessionFactory) {
		super.setSessionFactory(sessionFactory);
	}
 
	/**
	 * {@inheritDoc}
	 */
	@Override
	public void salvar(Contato contato) {
		this.getHibernateTemplate().save(contato);
	}
 
	/**
	 * {@inheritDoc}
	 */
	@Override
	public List<contato> getAgenda() {
		return this.getHibernateTemplate().loadAll(Contato.class);
	}
 
}

A anotação @Repository funciona como a anotação @Service, ou seja, o container do Spring vai conseguir gerenciá-la dinamicamente por causa dessa anotação. Essa anotação também é utilizada para alguns tratamentos específicos para a camada de persistência de dados, mas não vem ao caso agora. heheh

O método init(SessionFactory) que é executado internamente após a classe ser instanciada  serve para configurar a classe pai (HibernateDaoSupport) setando a SessionFactory nele. Esse método possui a anotação @Autowired pois antes dele ser executado o Spring vai injetar o atributo sessionFactory para nós (a classe estando anotada com @Repository demonstra que ela pode estar no container e o Spring vai conseguir injetar as dependências).

Porém essa nova classe precisa de mais algumas configurações no arquivo de configuração do Spring (applicationContext.xml) para poder funcionar:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:flex="http://www.springframework.org/schema/flex"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/flex
                           http://www.springframework.org/schema/flex/spring-flex-1.0.xsd">
 
	<!-- Cria o MessageBroker com as configurações padrão -->
	<flex:message-broker />
 
	<!-- Habilita a injeção de dependência através de anotações -->
	<context:annotation-config />
 
	<!-- Faz com que os Services sejam beans gerenciados pelo container do Spring -->
	<context:component-scan base-package="br.blog.javasimples.agenda.service.impl" />
 
	<!-- Faz com que os DAOs sejam beans gerenciados pelo container do Spring -->
	<context:component-scan base-package="br.blog.javasimples.agenda.dao.impl" />
 
	<!-- DataSource -->
	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName">
			<value>com.mysql.jdbc.Driver</value>
		</property>
 
		<property name="url">
			<value>jdbc:mysql://localhost:3306/javasimples_agenda</value>
		</property>
 
		<property name="username">
			<value>usuario</value>
		</property>
 
		<property name="password">
			<value>senha</value>
		</property>
	</bean>
 
	<!-- Hibernate SessionFactory -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
 
		<property name="dataSource">
			<ref local="dataSource" />
		</property>
 
		<!-- Carrega todos os Beans -->
		<property name="packagesToScan">
			<list>
				<value>br.blog.javasimples.agenda.model</value>
			</list>
		</property>
 
		<!-- Propriedades do Hibernate -->
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.format_sql">true</prop>
			</props>
		</property>
	</bean>
 
</beans>

Adicionamos uma nova tag <context:component-scan> informando que o pacote onde vão estar os DAOs também deve ser gerenciado pelo Spring, definimos um DataSource (para saber mais leia este post) e definimos a SessionFactory (para saber mais leia este post) que vai ser injetada no método init(SessionFactory) da classe ContatoDaoImpl.

Uma vez que o DAO está criado e configurado corretamente precisamos mudar o ContatoServiceImpl para utilizá-lo ao invés da lista estática que utilizava antes:

/**
 * Serviço para {@link Contato}.
 *
 * @author Felipe Saab
 */
@Service
@RemotingDestination(value="contatoService")
public class ContatoServiceImpl implements ContatoService {
 
	/**
	 * DAO
	 */
	@Autowired
	private ContatoDao contatoDao;
 
	/**
	 * {@inheritDoc}
	 */
	public void salvar(Contato contato) {
		this.contatoDao.salvar(contato);
		System.out.println("Contato adicionado: " + contato);
	}
 
	/**
	 * {@inheritDoc}
	 */
	public List<contato> getAgenda() {
		return this.contatoDao.getAgenda();
	}
}

Mais uma vez aproveitamos da facilidade da injeção de dependência através de anotações para não nos preocuparmos em instanciar/recuperar o objeto contatoDao, o Spring se encarrega disso para nós.

Prontinho, com isso nós acabamos de incrementar a nossa pequena agenda com Spring e Hibernate!

CONCLUSÃO

Se testarmos a aplicação com essas alterações veremos que ela continua funcionando exatamente da mesma maneira que estava funcionando antes porém agora com o Spring tomando conta da comunicação entre o Java e o FLEX e o Hibernate persistindo os contatos no banco, quando formos adicionar novas funcionalidades temos que pensar apenas na funcionalidade, não precisamos ficar nos preocupando com os detalhes mais baixo nível (como a comunicação Java + FLEX). Tenho uma palavra para isso: produtividade! hehehe

Todo esse processo que realizamos é mais conhecido como refatoração: não mudamos nada do ponto de vista do usuário, apenas melhoramos a estrutura interna do aplicativo.

O código fonte pode ser pego aqui (sem as bibliotecas).

[]s e até a próxima,

Saab.

REFERÊNCIAS

[1] An introduction to Spring BlazeDS Integration

[2] Simple Flex Webapp

[3] Página do projeto Spring BlazeDS Integration

[4] Using Spring BlazeDS Integration 1.0

PS: Gostou? Não gostou? Ajudou? Não ajudou? Quebrou um galho? Perdeu 10 minutos da tua vida lendo? Comente! Divulgue! Fale mal! Compartilhe sua opinião com toda a comunidade!