jan 27
Digg
Stumbleupon
Technorati
Delicious
Adobe BlazeDS, Adobe Flex, Hibernate, Java, RIA, Spring Framework

Integrando Adobe Flex + BlazeDS + SpringFramework + Hibernate - Uma Solução OpenSource para Sistemas Web. (Parte 2 - Final)

Add

Olá Pessoal!

Primeiro lugar, quero agradecer a todos pelo feedback do post anterior, isto é motivante e me dá ânimo em concluir este, e outros que virão.

Hoje o foco deste artigo é que você termine ele sabendo:

Configurar os Beans do Spring através de annotations;

Integrar o esquema de Beans do Spring com os services do Flex através de uma Factory;

Configurar o Spring para usar o Hibernate para abstrair nosso banco de dados;

Para isso vamos a uma breve introdução a estes poderosos frameworks

Breve Introdução ao Spring

spring

Como não sou fã de ficar re-escrevendo a roda, vou tentar dar a você leigo em Spring, um caminho para estudar.

Primeiro de tudo, leia este artigo feito pelo Phillip Calçado (Shoes)
apostila-spring.pdf 
Valeu Ebertom pela hospedagem! =)

Uma Introdução ao que o  SpringFramework pode oferecer:
http://blog.fragmental.com.br/2005/08/31/spring-em-acao/
http://www.ime.usp.br/~reverbel/SMA/Slides/seminarios/spring.pdf
http://imasters.uol.com.br/artigo/4497/java/spring_framework_introducao/

Outros Tutoriais
http://www.javafree.org/content/view.jf?idContent=46

http://www.devmedia.com.br/articles/viewcomp.asp?comp=6627
http://www.devmedia.com.br/articles/viewcomp.asp?comp=6628
http://www.devmedia.com.br/articles/viewcomp.asp?comp=6653

Spring Annotations
http://blog.interface21.com/main/2006/11/28/a-java-configuration-option-for-spring/
http://weblogs.java.net/blog/seemarich/archive/2007/11/annotation_base_1.html

Exemplos de códigos
http://paulojeronimo.com/arquivos/tutoriais/tutorial-spring-framework.zip
http://www.java2s.com/Code/Java/Spring/CatalogSpring.htm

Documentação
The Spring Framework - Reference Documentation

Bom acredito que se você que está afim de conhecer o SpringFramewok, com esses Link's já é possível entender quase tudo o que ele pode oferecer a sua arquitetura. Lembrando que não é recomendável seguir com este artigo, sem antes entender como funciona  IoC, AOP, DAO, com o SpringFramework.

*Nota A abordagem aqui é sobre o SpringFramework, (Framework de Negócio) e não sobre o SpringMVC, uma vez que o Flex pode se trocar objetos através do protocolo AMF3, é totalmente dispensável o uso de Frameworks MVC's.

Breve Introdução ao Hibernate

Como eu já disse, uma vez que já existe um bom conteúdo sobre Hibernate na Internet, não há a necessidade de re-escrever, por isso vou lhe dar a você leigo em Hibernate uma sequência de Link que irá te ajudar a entender este poderoso Framework.

Uma Introdução ao que o  Hibernate pode oferecer:
http://www.students.ic.unicamp.br/~ra007271/docs/white-papers/hibernate-uma_introducao_dirigida.pdf
http://www.guj.com.br/java.tutorial.artigo.125.1.guj
http://www.jeebrasil.com.br/mostrar/4
http://www.devmedia.com.br/articles/viewcomp.asp?comp=4149

Outros Tutoriais
http://simundi.blogspot.com/2007/09/criar-uma-aplicao-com-hibernate.html
http://www.hibernate.org/hib_docs/v3/reference/en/html/queryhql.html
http://www.hibernate.org/hib_docs/tools/reference/en/html/plugins.html
http://www.guj.com.br/posts/list/7249.java

Pacotão de PDF's
http://br.groups.yahoo.com/group/java-br/files/Hibernate/

Exemplos de código
http://www.java2s.com/Code/Java/Hibernate/CatalogHibernate.htm

Documentação
http://www.hibernate.org/hib_docs/v3/reference/en/html/

Ok, partindo do princípio que você já entendeu como funciona o Hibernate, e o Spring, vamos ao código! +)


Requerimentos:

SpringFramework 2.5 ou superior;
*Vamos baixar o Spring com as dependências, isto é neste arquivo conterá todas as libs que nós podemos por ventura usar com o Spring, como por exemplo as libs do hibernate.

MySql 5.x Instalado;
*Eu estarei usando o pacote apache friends - xampp

MySql JConnector 5.x.x;

Conhecimentos básicos sobre MySql;

Plugin Eclipse SpringIDE;
*Opcional

Plugin Eclipse Hibernate Tools 3.2.x;
*Opcional

Instale os plugin's estes opcionais na verdade este artigo não fará uso deles, mas pensando no futuro seria interessante fazer uso deles.

Após isso, abra seu projeto no Eclipse que nós tinhamos criado anteriormente, O JavaFlex.

Vamos adicionar as seguintes libs ao projeto na pasta JavaFlex\WebContent\WEB-INF\lib:

Library

*A maioria das libs podem ser encontrada no arquivo compactado que você baixou do Spring. Lembrando também que o modelo de estilo de projeto criado no Eclipse, Dynamic Web Project, já adiciona automaticamente ao Classpath do projeto ao você colar as libs nesta pasta.

Como nós já tinhamos modelado um caso de uso chamado Cargo, vamos agora criar um banco de dados para o nosso pequeno sistema.

Abra seu MySql, e execute este script sql que criará a base de dados chamada JavaFlex, e também a tabela JAVAFLEX_CARGO;

PLAIN TEXT
CODE:
  1. --
  2. -- Banco de Dados: `javaflex`
  3. --
  4. CREATE DATABASE `javaflex` DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci;
  5. USE `javaflex`;
  6.  
  7. --
  8. -- Estrutura da tabela `javaflex_cargo`
  9. --
  10.  
  11. CREATE TABLE `javaflex_cargo` (
  12.   `ID_CARGO` int(10) unsigned NOT NULL auto_increment,
  13.   `DS_CARGO` varchar(50) collate utf8_unicode_ci NOT NULL,
  14.   PRIMARY KEY  (`ID_CARGO`)
  15. ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=1 ;

Entendendo os Pacotes, e configurando a persistência

Com o banco de dados criado, vamos mapear a tabela no banco, com o nosso Entity Cargo, para isso, crie um package chamado:

com.digows.artigos.JavaFlex.model.repository.hibernate.hbm

Neste package irá conter todos os nossos mapeamentos em xml, alguns preferem fazer uso de annotations, só que pessoalmente não gosto de acoplar códigos de annotations em meus beans de negócio, prefiro delegar a função Mapeamento a arquivos xml's.

Neste mesmo package crie um arquivo chamado Cargo.hbm.xml, e adicione o seguinte conteúdo:

Cargo.hbm.xml

PLAIN TEXT
XML:
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping>
  6.     <class name="com.digows.artigos.JavaFlex.model.entity.Cargo"
  7.         table="javaflex_cargo">
  8.  
  9.         <id name="idCargo" column="ID_CARGO" type="long">
  10.             <generator class="native" />
  11.         </id>
  12.  
  13.         <property name="dsCargo" column="DS_CARGO" type="string"
  14.             not-null="true" length="50" />
  15.     </class>
  16. </hibernate-mapping>

Perceba que estamos mapeando nosso entity Cargo que foi criado no post anterior com a tabela  JAVAFLEX_CARGO criada recém.

com.digows.artigos.JavaFlex.model.repository.hibernate

Este package irá conter classes que implementam o Pattern DAO usando o Hibernate. Métodos de CRUD e querys em geral usando o Hibernate deverão estar neste pacote estes separados por casos de uso.

Neste mesmo package, vamos criar um DAO usando o hibernate para o nosso entity cargo, para isso, crie uma classe java chamada CargoHibernateDao,  e adicione o seguinte conteúdo:

CargoHibernateDao.java

PLAIN TEXT
JAVA:
  1. package com.digows.artigos.JavaFlex.model.repository.hibernate;
  2.  
  3. import java.util.List;
  4.  
  5. import org.hibernate.SessionFactory;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.beans.factory.annotation.Qualifier;
  8. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
  9. import org.springframework.stereotype.Repository;
  10.  
  11. import com.digows.artigos.JavaFlex.model.entity.Cargo;
  12. import com.digows.artigos.JavaFlex.model.repository.CargoRepository;
  13.  
  14. @Repository(value="cargoRepository")
  15. public class CargoHibernateDao extends HibernateDaoSupport
  16.                         implements CargoRepository {
  17.  
  18.     @Autowired
  19.     public CargoHibernateDao(@Qualifier("sessionFactory")SessionFactory factory) {
  20.         super.setSessionFactory(factory);
  21.     }
  22.  
  23.     public Cargo save(Cargo p_cargo) {
  24.         getHibernateTemplate().saveOrUpdate(p_cargo);
  25.         return p_cargo;// ID POPULADA
  26.     }
  27.  
  28.     public void remove(Cargo p_cargo) {
  29.         getHibernateTemplate().delete(p_cargo);
  30.     }
  31.  
  32.     public Cargo findById(Cargo p_cargo) throws Exception {
  33.         long id = p_cargo.getIdCargo();
  34.         p_cargo = (Cargo) getHibernateTemplate().get(Cargo.class, p_cargo.getIdCargo());
  35.  
  36.         if (p_cargo == null)
  37.             throw new Exception("O Cargo com a ID: "+id+" do(a) "+Cargo.class.getSimpleName()+" não foi encontrada.");
  38.         return p_cargo;
  39.     }
  40.  
  41.     @SuppressWarnings("unchecked")
  42.     public List<cargo> getList() {
  43.         return (List<cargo>) getHibernateTemplate().loadAll(Cargo.class);
  44.     }
  45. }

Perceba que esta implementa apenas métodos de acesso ao banco de dados usando o hibernate. Nesta classe faço uso de annotations para que o container Spring faça o wire dos beans.

@Repository

A anotação @Repository é mais um estereótipo que foi introduzido no Spring 2.0. Esta anotação é usada para indicar que uma classe funciona como um repositório (Veremos mais adiante o que é este pattern), esta anotação faz com que o Spring envie Exceptions da persistência a camada de serviço, vindas de DataAccessException, isto é deixa tranparênte a camada de serviço o tipo de repository que foi implementado.

@Autowired

A anotação @Autowired é usada para a injeção de depêndencia da sessionFactory do hibernate.

@SuppressWarnings

Faço uso da anotação @SuppressWarnings, apenas para o compilador não gerar um Warning no cast da List, uma vez que o Hibernate foi projetado sem o uso de Generics, ao usar Generics o compilador devolve um Warning.

Perceba que esta classe implementa uma interface, está interface implementa o pattern Repository, este padrão já causou muita polêmica em forums Java como o GUJ por exemplo, recomendo a leitura deste post para entender o padrão:
http://blog.caelum.com.br/2007/06/09/repository-seu-modelo-mais-orientado-a-objeto/

com.digows.artigos.JavaFlex.model.repository

Este package irá conter interfaces do tipo repository que dará comportamentos a DAO's sejam elas implementadas por DAO's Hibernate, DAO's JDBC, DAO's iBatis e etc...

Neste mesmo pacote, crie uma interface chamada CargoRepository com o seguinte conteúdo:

CargoRepository.java

PLAIN TEXT
JAVA:
  1. package com.digows.artigos.JavaFlex.model.repository;
  2.  
  3. import java.util.List;
  4. import com.digows.artigos.JavaFlex.model.entity.Cargo;
  5.  
  6. public interface CargoRepository {
  7.  
  8.     void remove(Cargo p_cargo);
  9.     Cargo save(Cargo p_cargo);
  10.     Cargo findById(Cargo p_cargo) throws Exception;
  11.     List<cargo> getList();
  12. }

Ok! nossa persistência já foi programada, vamos agora alterar a classe CargoService que foi criado no post anterior, para que se comporte como uma classe de serviço gerenciada pelo container Spring.

Para isso, altere o nome da classe CargoService que está no package com.digows.artigos.JavaFlex.model.service para CargoServiceImpl e adicione este conteúdo:

CargoServiceImpl.java

PLAIN TEXT
JAVA:
  1. package com.digows.artigos.JavaFlex.model.service;
  2.  
  3. import java.util.List;
  4.  
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Service;
  7. import org.springframework.transaction.annotation.Propagation;
  8. import org.springframework.transaction.annotation.Transactional;
  9.  
  10. import com.digows.artigos.JavaFlex.model.entity.Cargo;
  11. import com.digows.artigos.JavaFlex.model.repository.CargoRepository;
  12.  
  13. @Service(value="cargoService")
  14. @Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class)
  15. public class CargoServiceImpl implements CargoService {
  16.  
  17.     private CargoRepository cargoRepository;
  18.  
  19.     @Autowired
  20.     public void setCargoRepository(CargoRepository cargoRepository) {
  21.         this.cargoRepository = cargoRepository;
  22.     }
  23.  
  24.     public Cargo save(Cargo p_cargo) throws Exception {
  25.         try {
  26.             this.cargoRepository.save(p_cargo);
  27.             return p_cargo;
  28.         } catch (Exception e) {
  29.             throw new Exception("Não foi possível salvar." +e.getCause());
  30.         }
  31.     }
  32.  
  33.     public void remove(Cargo p_cargo) throws Exception {
  34.         try {
  35.             this.cargoRepository.remove(p_cargo);
  36.         } catch (Exception e) {
  37.             throw new Exception("Não foi possível excluir." +e.getMessage());
  38.         }
  39.     }
  40.  
  41.     public Cargo findById(Cargo p_cargo) throws Exception {
  42.         try {
  43.             return this.cargoRepository.findById(p_cargo);
  44.         } catch (Exception e) {
  45.             throw new Exception("Não foi possível procurar pela ID."+e.getMessage());
  46.         }
  47.     }
  48.  
  49.     public List<cargo> getList() throws Exception {
  50.         try {
  51.             return this.cargoRepository.getList();
  52.         } catch (Exception e) {
  53.             throw new Exception("Não foi possível listar."+e.getMessage());
  54.         }
  55.     }
  56. }

Perceba que é uma classe de serviço simples, esta apenas tem a funcão de coodernar os Entities de domínio e fazer a persistência atráves de um repository.

@Service

A anotação @Service é uma forma especializada da anotação @Component. É conveniente anotar as classes da camada de serviço com @Service para facilitar o processamento por ferramentas ou antecipar qualquer futuro serviço de capacidades específicas que podem ser adicionados a esta anotação.

@Transactional

Como o próprio nome diz, é um estereótipo que delega ao container que esta classe de serviço deve ser transicional.

@Autowired

A anotação @Autowired é usada para a injeção de depêndencia que será feita pelo container de uma implementação da interface CargoService.

Nessa camada de serviço faço uso também do Pattern DIP (Dependency Inversion Principle), por isso esta classe é uma implementação (CasoDeUsoServiceImpl) de uma interface de serviço, no caso a CargoService.

Para isso no pacote com.digows.artigos.JavaFlex.model.service, crie uma interface com o nome de CargoService, com este conteúdo:

CargoService.java

PLAIN TEXT
JAVA:
  1. package com.digows.artigos.JavaFlex.model.service;
  2.  
  3. import java.util.List;
  4.  
  5. import com.digows.artigos.JavaFlex.model.entity.Cargo;
  6.  
  7. public interface CargoService {
  8.  
  9.     void remove(Cargo p_cargo) throws Exception;
  10.     Cargo save(Cargo p_cargo) throws Exception;
  11.     Cargo findById(Cargo p_cargo) throws Exception;
  12.     List<cargo> getList() throws Exception;
  13. }

Ok, com estes passos realizados, já concluímos a implementação do nosso model. A estrutura final deverá ser esta:

image

Configurando o SpringFramework com o Hibernate e o Blaze.

No post anterior, configuramos o Tomcat para utilizar apenas o BlazeDS, agora precisamos adicionar mais as configurações  do SpringFramework.

Para isso abra o arquivo JavaFlex\WebContent\WEB-INF\web.xml e altere deixando com este conteúdo:

web.xml

PLAIN TEXT
XML:
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xmlns="http://java.sun.com/xml/ns/javaee"
  4.     xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  5.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  6.     id="WebApp_ID" version="2.5">
  7.  
  8.     <display-name>JavaFlex</display-name>
  9.  
  10.     <!--
  11.         ///////////////////////////////
  12.             Configuracao Spring 2.5
  13.         ///////////////////////////////
  14.     -->
  15.     <context-param>
  16.         <param-name>contextConfigLocation</param-name>
  17.         <param-value>
  18.             /WEB-INF/applicationContext.xml
  19.         </param-value>
  20.     </context-param>
  21.  
  22.     <listener>
  23.         <listener-class>
  24.             org.springframework.web.context.ContextLoaderListener
  25.         </listener-class>
  26.     </listener>
  27.     <listener>
  28.         <listener-class>
  29.             org.springframework.web.context.request.RequestContextListener
  30.         </listener-class>
  31.     </listener>
  32.  
  33.     <!--
  34.         ///////////////////////////////
  35.             Configuracao do BlazeDS
  36.         ///////////////////////////////
  37.     -->
  38.     <context-param>
  39.         <param-name>flex.class.path</param-name>
  40.         <param-value>/WEB-INF/flex/hotfixes</param-value>
  41.     </context-param>
  42.  
  43.     <!-- MessageBroker Servlet -->
  44.     <servlet>
  45.         <servlet-name>MessageBrokerServlet</servlet-name>
  46.         <display-name>MessageBrokerServlet</display-name>
  47.         <servlet-class>
  48.             flex.messaging.MessageBrokerServlet
  49.         </servlet-class>
  50.         <init-param>
  51.             <param-name>services.configuration.file</param-name>
  52.             <param-value>/WEB-INF/flex/services-config.xml</param-value>
  53.         </init-param>
  54.         <init-param>
  55.             <param-name>flex.write.path</param-name>
  56.             <param-value>/WEB-INF/flex</param-value>
  57.         </init-param>
  58.         <load-on-startup>1</load-on-startup>
  59.     </servlet>
  60.     <servlet-mapping>
  61.         <servlet-name>MessageBrokerServlet</servlet-name>
  62.         <url-pattern>/messagebroker/*</url-pattern>
  63.     </servlet-mapping>
  64.  
  65.  
  66.     <welcome-file-list>
  67.         <welcome-file>index.html</welcome-file>
  68.         <welcome-file>index.htm</welcome-file>
  69.         <welcome-file>index.jsp</welcome-file>
  70.     </welcome-file-list>
  71.  
  72. </web-app>

Perceba na configuração do Spring, ele faz referência a um arquivo chamado applicationContext.xml, este arquivo é o que contém as configurações do Spring em si, então no mesmo diretório que se econtra o web.xml, crie um arquivo com o nome de applicationContext.xml e coloque este conteúdo:

applicationContext.xml

PLAIN TEXT
XML:
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.     xmlns:p="http://www.springframework.org/schema/p"
  5.     xmlns:context="http://www.springframework.org/schema/context"
  6.     xmlns:jee="http://www.springframework.org/schema/jee"
  7.     xmlns:tx="http://www.springframework.org/schema/tx"
  8.     xsi:schemaLocation="
  9.             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
  10.             http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
  11.             http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd
  12.             http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
  13.     <!--
  14.         //////////////////////////////////////
  15.         Integração do Spring com o Hibernate
  16.         //////////////////////////////////////
  17.     -->
  18.  
  19.     <!--
  20.         Carregamento do Arquivo de Configuracoes do JDBC
  21.     -->
  22.     <context:property-placeholder location="classpath:jdbc.properties" />
  23.  
  24.     <!--
  25.         Configuracao do DataSource
  26.     -->
  27.     <bean id="dataSource"
  28.         class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  29.         <property name="driverClassName">
  30.             <value>${jdbc.driverClassName}</value>
  31.         </property>
  32.         <property name="url">
  33.             <value>${jdbc.url}</value>
  34.         </property>
  35.         <property name="username">
  36.             <value>${jdbc.username}</value>
  37.         </property>
  38.         <property name="password">
  39.             <value>${jdbc.password}</value>
  40.         </property>
  41.     </bean>
  42.  
  43.     <!--
  44.         Hibernate SessionFactory
  45.     -->