logo
  • Home
  • Acerca
  • Autores
  • Faq
  • Rede
  Twitter   Feed-me! RSS!
Jan 27

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

Escrito por Rodrigo Pereira Fraga em Adobe BlazeDS, Adobe Flex, Hibernate, Java, RIA, Spring Framework @ 01 27th, 2008 | via http://blog.digows.com | Sem comentários
Rodrigo Pereira Fraga
? X
  • Bookmarks

Blinkbits BlinkLists BlogLines Blogmarks Buddymarks CiteULike Co.mments Del.icio.us Digg Diigo

Fark Feed Me Links Furl Google Linkagogo ma.gnolia Mister Wong Newsvine Propeller Rawsugar

Reddit Rojo Simpy Sphinn Spurl Squidoo StumbleUpon Tailrank Technorati Yahoo

More »

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.     –>
  46.     <bean id=“sessionFactory”
  47.         class=“org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
  48.  
  49.         <property name=“dataSource”>
  50.             <ref local=“dataSource” />
  51.         </property>
  52.  
  53.         <!– Carrega todos os HBM’s –>
  54.         <property name=“mappingDirectoryLocations”>
  55.             <list>
  56.                 <value>
  57.                     classpath:com/digows/artigos/JavaFlex/model/repository/hibernate/hbm/
  58.                 </value>
  59.             </list>
  60.         </property>
  61.  
  62.         <!– Configuracoes do Hibernate –>
  63.         <property name=“hibernateProperties”>
  64.             <props>
  65.                 <prop key=“hibernate.dialect”>
  66.                     org.hibernate.dialect.MySQLInnoDBDialect
  67.                 </prop>
  68.                 <prop key=“hibernate.show_sql”>true</prop>
  69.                 <!–
  70.                     Atualizar o Banco de dados de acordo com os arquivos de mapeamentos.
  71.                     <prop key="hibernate.hbm2ddl.auto">update</prop>
  72.                 –>
  73.             </props>
  74.         </property>
  75.  
  76.         <property name=“eventListeners”>
  77.             <map>
  78.                 <entry key=“merge”>
  79.                     <bean
  80.                         class=“org.springframework.orm.hibernate3.support.IdTransferringMergeEventListener” />
  81.                 </entry>
  82.             </map>
  83.         </property>
  84.     </bean>
  85.  
  86.     <!–
  87.         Transaction Manager
  88.     –>
  89.     <bean id=“transactionManager”
  90.         class=“org.springframework.orm.hibernate3.HibernateTransactionManager”>
  91.         <property name=“sessionFactory”>
  92.             <ref local=“sessionFactory” />
  93.         </property>
  94.     </bean>
  95.  
  96.     <!– Habilita os Services para serem transicionais via a Annotation @Transactional –>
  97.     <tx:annotation-driven transaction-manager=“transactionManager” />
  98.  
  99.     <!– ============================== AOP DEFINITIONS ================================ –>
  100.  
  101.  
  102.     <!– ========================= BUSINESS OBJECT DEFINITIONS ========================= –>
  103.     <!–
  104.         Activates various annotations to be detected in bean classes:
  105.         Spring’s @Required and @Autowired, as well as JSR 250′s @Resource.
  106.     –>
  107.     <context:annotation-config />
  108.  
  109.     <!– Carrega os Beans de Servico –>
  110.     <context:component-scan
  111.         base-package=“com.digows.artigos.JavaFlex.model.service” />
  112.  
  113.     <!– Carrega os Beans DAO Hibernate –>
  114.     <context:component-scan
  115.         base-package=“com.digows.artigos.JavaFlex.model.repository.hibernate” />
  116. </beans>

Perceba que as configurações do banco de dados usado, delego a um arquivo .properties, também vou precisar configurar o log4j para a impressão de log’s. Por estética o bacana seria gerar um novo source-path que contenha tais arquivos properties.

Crie um pasta na raiz do projeto com o nome de resources,

De um botão direito sobre o projeto e clique em properties;

Em Java Build Path, clique no botão AddFolder;

Selecione a pasta resources, clique em ok, e marque a opção Allow output folders for source folders, e ok.

Dentro do package resources, crie um arquivo chamado jdbc.properties, e adicione o seguinte conteúdo:

jdbc.properties

PLAIN TEXT
CODE:

  1. # Properties file com as configuracoes do JDBC.
  2. # Aplicado pelo PropertyPlaceholderConfigurer do Spring
  3.  
  4. jdbc.driverClassName=com.mysql.jdbc.Driver
  5. jdbc.url=jdbc:mysql://localhost:3306/javaflex
  6. jdbc.username=root
  7. jdbc.password=
  8.  
  9. #Properties que determina o dialeto do Banco de Dados.
  10. hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect

e outro arquivo chamado log4j.properties com este conteúdo:

log4j.properties

PLAIN TEXT
CODE:

  1. ### direct log messages to stdout ###
  2. log4j.appender.stdout=org.apache.log4j.ConsoleAppender
  3. log4j.appender.stdout.Target=System.out
  4. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
  5. log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L – %m%n
  6.  
  7. # set root logger level to debug and its only appender to mtf
  8. log4j.rootLogger=INFO,development
  9.  
  10. # only for development purposes
  11. log4j.appender.development=org.apache.log4j.ConsoleAppender
  12. log4j.appender.development.layout=org.apache.log4j.PatternLayout
  13. log4j.appender.development.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %5p [%t] (%F:%L) – %m%n
  14.  
  15. log4j.logger.noModule=FATAL
  16. log4j.logger.org.springframework=WARN
  17.  
  18. # Log JDBC bind parameter runtime arguments
  19. log4j.logger.org.hibernate.type=DEBUG

Uma outra modificação é necessária, está a mais importante, pois delega ao Blaze, que existe uma factory de beans criada pelo Spring.

Essa factory deve ser implementada, porém já existe pronto na internet para uso, esta pode ser encontrada aqui:

Spring and Flex Integration Factory Class

Baixe ela, e coloque por exemplo neste pacote:

com.digows.artigos.JavaFlex.controller

*O  nome controller ficou sugestivo aqui, uma vez que está factory não tem comportamentos de um controller, porém como o Flex não faz uso do controller para controlar as actions que também não existe, achei bacana preservar o package colocando a factory de beans do Spring que será usada pelo Blaze neste pacote. Se alguém tiver uma idéia melhor de onde colocar a classe, estou aceitando opniões.

Vamos então configurar o Blaze. Abra o arquivo JavaFlex\WebContent\WEB-INF\flex\services-config.xml e altere deixando com este conteúdo:

services-config.xml

PLAIN TEXT
XML:

  1. <?xml version=“1.0″ encoding=“UTF-8″?>
  2. <services-config>
  3.     <services>
  4.         <service-include file-path=“remoting-config.xml” />
  5.     </services>
  6.  
  7.     <!– Spring factory registration –>
  8.     <factories>
  9.         <factory id=“spring”
  10.             class=“com.digows.artigos.JavaFlex.controller.SpringFactory”/>
  11.     </factories>
  12.  
  13.     <channels>
  14.         <channel-definition id=“channel-amf”
  15.             class=“mx.messaging.channels.AMFChannel”>
  16.             <endpoint
  17.                 url=“http://{server.name}:{server.port}/{context.root}/messagebroker/amf”
  18.                 class=“flex.messaging.endpoints.AMFEndpoint” />
  19.             <properties>
  20.                 <polling-enabled>false</polling-enabled>
  21.             </properties>
  22.         </channel-definition>
  23.     </channels>
  24.  
  25.     <logging>
  26.         <target class=“flex.messaging.log.ConsoleTarget”
  27.             level=“Error”>
  28.             <properties>
  29.                 <prefix>[BlazeDS]</prefix>
  30.                 <includeDate>true</includeDate>
  31.                 <includeTime>false</includeTime>
  32.                 <includeLevel>true</includeLevel>
  33.                 <includeCategory>true</includeCategory>
  34.             </properties>
  35.             <filters>
  36.                 <pattern>Endpoint.*</pattern>
  37.                 <pattern>Service.*</pattern>
  38.                 <pattern>Message.*</pattern>
  39.                 <pattern>DataService.*</pattern>
  40.                 <pattern>Configuration</pattern>
  41.             </filters>
  42.         </target>
  43.     </logging>
  44.  
  45.     <system>
  46.         <redeploy>
  47.             <enabled>true</enabled>
  48.             <watch-interval>20</watch-interval>
  49.             <watch-file>
  50.                 {context.root}/WEB-INF/flex/services-config.xml
  51.             </watch-file>
  52.             <watch-file>
  53.                 {context.root}/WEB-INF/flex/remoting-config.xml
  54.             </watch-file>
  55.             <touch-file>{context.root}/WEB-INF/web.xml</touch-file>
  56.         </redeploy>
  57.     </system>
  58. </services-config>

Perceba que mapeio o local da Factory. Agora é preciso atualizar nosso servico cargoService dentro do arquivo JavaFlex\WebContent\WEB-INF\flex\remoting-config.xml. Então abra e edite deixando com este conteúdo:

remoting-config.xml

PLAIN TEXT
XML:

  1. <?xml version=“1.0″ encoding=“UTF-8″?>
  2. <service id=“remoting-service”
  3.     class=“flex.messaging.services.RemotingService”>
  4.  
  5.     <adapters>
  6.         <adapter-definition id=“java-object”
  7.             class=“flex.messaging.services.remoting.adapters.JavaAdapter”
  8.             default=“true” />
  9.     </adapters>
  10.  
  11.     <default-channels>
  12.         <channel ref=“channel-amf” />
  13.     </default-channels>
  14.  
  15.     <destination id=“cargoService”>
  16.         <properties>
  17.             <factory>spring</factory>
  18.             <source>cargoService</source>
  19.         </properties>
  20.     </destination>
  21. </service>

Aqui só é importante observar que a tag <source /> mapeia o nome do bean do tipo serviço que foi delegado na annotation, no nosso caso na classe CargoServiceImpl perceba a annotation @Service(value=”cargoService”) e também a tag <factory /> que faz referência a configuração no arquivo services-config.xml

Se tudo foi efetuado corretamente, ao você dar um botão direito no projeto e ir em Run As -> Run On Server, ao clicar em salvar no fomulário de cadastro criado no post anterior, o seu objeto cargo vindo do Flex já será persistido! observe o console para isso.

Eu alterei o arquivo com\digows\artigos\JavaFlex\view\screen\CargoForm.mxml para que possa usar todos os métodos do CRUD Cargo. Segue como ficou:

CargoForm.mxml

PLAIN TEXT
XML:

  1. <?xml version=“1.0″ encoding=“utf-8″?>
  2. <mx:TitleWindow xmlns:mx=“http://www.adobe.com/2006/mxml”
  3.     layout=“vertical” width=“488″ height=“384″ creationComplete=“getList()”>
  4.  
  5.     <mx:Form width=“100%” height=“100%” defaultButton=“{btSalvar}”>
  6.         <mx:FormHeading label=“Gerenciamento de Cargos” width=“100%”/>
  7.         <mx:FormItem label=“ID:” width=“127″>
  8.             <mx:TextInput width=“100%” id=“txtIdCargo”
  9.                 text=“{Cargo(dgCargo.selectedItem).idCargo}” editable=“false” enabled=“false”/>
  10.         </mx:FormItem>
  11.         <mx:FormItem label=“Cargo:” width=“345″>
  12.             <mx:TextInput width=“100%” id=“txtDsCargo”
  13.                 text=“{Cargo(dgCargo.selectedItem).dsCargo}”/>
  14.         </mx:FormItem>
  15.         <mx :D ataGrid id=“dgCargo” width=“100%” height=“100%” dataProvider=“{listCargos}”>
  16.             <mx:columns>
  17.                 <mx :D ataGridColumn headerText=“ID” dataField=“idCargo” width=“30″/>
  18.                 <mx :D ataGridColumn headerText=“Cargo” dataField=“dsCargo”/>
  19.             </mx:columns>
  20.         </mx :D ataGrid>
  21.     </mx:Form>
  22.  
  23.     <mx:ControlBar horizontalAlign=“center”>
  24.         <mx:Button label=“Novo” click=“setDefault()”/>
  25.         <mx:Button label=“Salvar” id=“btSalvar” click=“save()”
  26.             textAlign=“center”/>
  27.         <mx:Button label=“Excluir” click=“remove()”/>
  28.     </mx:ControlBar>
  29.  
  30.     <mx:RemoteObject id=“cargoService” showBusyCursor=“true”
  31.         fault=“onFault(event)” destination=“cargoService”>
  32.         <mx:method name=“save” result=“onResultSave(event)” fault=“onFault(event)”/>
  33.         <mx:method name=“remove” result=“onResultRemove(event)” fault=“onFault(event)”/>
  34.         <mx:method name=“getList” result=“onResultGetList(event)” fault=“onFault(event)”/>
  35.     </mx:RemoteObject>
  36.  
  37.     <mx:Script>
  38.         <![CDATA[
  39.             import mx.collections.ArrayCollection;
  40.             import com.digows.artigos.JavaFlex.view.entity.Cargo;
  41.             import mx.rpc.events.ResultEvent;
  42.             import mx.rpc.events.FaultEvent;
  43.             import mx.controls.Alert;
  44.  
  45.             [Bindable]
  46.             private var listCargos:ArrayCollection;
  47.  
  48.             private var cargo:Cargo;
  49.  
  50.             public function save():void
  51.             {
  52.                 this.cargo = new Cargo();
  53.                 this.cargo.idCargo   = new Number(txtIdCargo.text);
  54.                 this.cargo.dsCargo   = txtDsCargo.text;
  55.  
  56.                 //Chama o metodo Save do servico "cargoService"
  57.                 cargoService.save(cargo);
  58.             }
  59.  
  60.             //Função que será executada após a conclusão do método save
  61.             public function onResultSave(event:ResultEvent):void
  62.             {
  63.                 status = "Salvo com Sucesso! Ultima ID: "+Cargo(event.result).idCargo;
  64.                 getList();
  65.             }
  66.  
  67.             public function remove():void
  68.             {
  69.                 if (dgCargo.selectedItem != null) {
  70.                     cargo = dgCargo.selectedItem as Cargo;
  71.                     cargoService.remove(cargo);
  72.                 } else {
  73.                     Alert.show("Selecione um Item na DataGrid");
  74.                 }
  75.             }
  76.  
  77.             //Função que será executada após a conclusão do método remove
  78.             public function onResultRemove(event:ResultEvent):void
  79.             {
  80.                 status = "Excluido com Sucesso!";
  81.                 getList();
  82.             }
  83.  
  84.             public function getList():void
  85.             {
  86.                 cargoService.getList();
  87.             }
  88.  
  89.             //Função que será executada após a conclusão do método getList
  90.             public function onResultGetList(event:ResultEvent):void
  91.             {
  92.                 listCargos = event.result as ArrayCollection;
  93.             }
  94.  
  95.             public function setDefault():void
  96.             {
  97.                 txtIdCargo.text = "";
  98.                 txtDsCargo.text = "";
  99.             }
  100.  
  101.             //Ocorreu uma falha ao chamar algum servico servico.
  102.             public function onFault(event:FaultEvent):void
  103.             {
  104.                 Alert.show(event.fault.message);
  105.             }
  106.         ]]>
  107.     </mx:Script>
  108. </mx:TitleWindow>

image

Bom pessoal, acredito que com estes 2 artigos consegui atingir o objetivo de dar a comunidade Java uma proposta de interface produtiva e poderosa, e também a comunidade Flex uma proposta de uma arquitetura com Flex e Java, utilizando o Blaze Data Services.

Faça mais testes, veja que o desenvolvimento é muito rápido! muito melhor do que se matar com tags html e funções em JavaScript.

Fora que você pode desenvolver com o Flex aplicando os conceitos de Orientação a Objetos, a começar pela tranferência de dados, no Flex chega Objetos! e não textos (XML, WebServices, Request/Response e afins).

Neste artigo não fiz uso de patterns para o desenvolvimento das telas em Flex, porém nos próximos artigos irei abordar detalhadamente como você pode arquiteturar seu código Flex visando ganhar manutenabilidade, escalabilidade, e reusabilidade.

Tópico no Forum que contém detalhes sobre o download. Flex 2.0 e Flex 3.0
[Link]

Obrigado a todos e um Beijão especial para minha querida Liz!

=*****

Abraços

\o/

Jan 21

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

Escrito por Rodrigo Pereira Fraga em Adobe BlazeDS, Adobe Flex, Blazeds, Flex Builder, Hibernate, Java, RIA, Spring Framework, SpringFramework @ 01 21st, 2008 | via http://blog.digows.com | Sem comentários
Rodrigo Pereira Fraga
? X
  • Bookmarks

Blinkbits BlinkLists BlogLines Blogmarks Buddymarks CiteULike Co.mments Del.icio.us Digg Diigo

Fark Feed Me Links Furl Google Linkagogo ma.gnolia Mister Wong Newsvine Propeller Rawsugar

Reddit Rojo Simpy Sphinn Spurl Squidoo StumbleUpon Tailrank Technorati Yahoo

More »

Olá Pessoal,

Hoje vou começar algo que estou prometendo há um bom tempo! A integração dos seguintes frameworks:

Adobe Flex;

Adobe BlazeDS;

Spring Framework;

Hibernate;

Introdução

No mundo de desenvolvimento WEB principalmente com Java, temos problemas quanto ao desenvolvimento de interfaces, como incompatibilidade entre browsers, desenvolviemento lento, e outros detalhes que muitos vivenciam diariamente.

Existem soluções que prometem como o JSF por exemplo, mas como dizem “A primeira experiência em Flex o programador Java nunca esquece.” logo quero convidar você que vem do mundo do Java, para conhecer uma solução de desenvolvimento de interfaces com o AdobeFlex.

Apresentando Adobe Flex e Adobe BlazeDS

Adobe Flex

Do Flex não vou falar muito, também por que neste blog você pode encontrar muito conteúdo explicativo como por exemplo este link: http://blog.digows.com/?p=32 algumas abordagens ali já estão desatualizadas, porém a essência é a mesma como por exemplo algumas vantagens de se usar Flex:

O Flex é executado a partir de uma máquina virtual, logo o programador apenas se preocupa em desenvolver a interface não em programar compatibilidade entre browsers.

Você programa sua interface totalmente orientada a objetos, isso visa reuso de componentes, desenvolvimento de módulos e afins.

Há várias maneiras de comunicar o Java com o Flex, mas em destaque é que você pode trocar objetos Java/Flex por um protocolo que provê compactação e tranferência binária, este é o AMF.

Adobe BlazeDS

O BlazeDS é um produto OpenSource (Licença LGPL v3) que corresponde à tecnologia JAVA server-side que dá suporte tanto para o Remoting assim como ao Messaging de objetos trocados entre o Java e o Flex/Flash.

Com o BlazeDS você pode gerar vários tipos de canais de conexão, um destaque muito importante para toda a comunidade Flex/Flash mundial, é que o serviço de data-push também foi disponibilizado de graça!, para quem não conhece, é algo semelhante ao Pattern Observer.

Integrando o Adobe Flex com o BlazeDS

Requerimentos:

Eclipse 3.3;

Adobe Flex Builder 3 Plugin;
*No título apresento como solução OpenSource, e o FlexBuilder 3 é pago, mas irei fazer uso apenas para facilitar o entendimento, caso seja estudante, baixe o FlexBuilder 2 é de graça para estudantes ou afins, caso não, baixe o Flex SDK e compile com Ant ou com o FlashDeveloper que é de graça.

Adobe BlazeDS;
*É recomendável que baixe a documentação do BlazeDS, para futuros estudos.

Tomcat 6.0;

Ok, Vamos começar!

Extraia o Eclipse 3.3 em algum lugar, por exemplo C:/Desenvolvimento/Eclipse 3.3/

Instale o Plugin do Flex no Eclipse, quando pedir o local aonde instalar o flex sdk, você pode selecionar em C:/Desenvolvimento/Frameworks/Adobe/

Após baixado o BlazeDS, perceba que ele vem vários arquivos, o que importa agora são os seguintes:

blazeds-samples.war

blazeds.war

No blazeds-samples.war como o próprio nome diz, contém aplicações de exemplo, como implementação do data-push, um chat, e etc…

O blazeds.war contém tudo o que é necessário para podermos configurar nossa aplicação.

Você deve ter percebido que no arquivo que você baixou o BlazeDS, contém um Tomcat já com todas as libs necessárias e etc.. Algumas libs ali tem reelevância como a flex-tomcat-common.jar e flex-tomcat-server.jar mas vamos deixar isso para outro artigo =)

Apesar do BlazeDS já vir com um Tomcat, eu estarei usando meu próprio Tomcat 6.0.

Abra seu Eclipse, e faça como no screencast abaixo que mostra como criar seu projeto no Eclipse 3.3:

Link Externo

*Se na aba “Problems” estiver com o erro “Cannot create HTML wrapper. Right-click here to recreate folder html-template.” clique com o botão direito, e clique em Recreate HTML Templates. Considero isso um bug do FlexBuilder.


Com o projeto criado, vamos adicionar as libs necessárias para a execução do BlazeDS, para isso abra o blazeds.war (Com um Winrar da vida) e copie todos os Jars contidos na pasta WEB-INF\lib para o nosso projeto na pasta WebContent\WEB-INF\lib.

Com as Libs adicionadas, vamos criar um serviço no java que servirá como exemplo de como o Flex pode acessar uma classe java através do BlazeDS.

Para isso na pasta src_java, crie uma estrutura de pacotes, por exemplo:

com/digows/artigos/JavaFlex/model/service/
com/digows/artigos/JavaFlex/model/entity/

Dentro do package entity crie uma classe java com o nome de Cargo com o seguinte conteúdo:

Cargo.java

PLAIN TEXT
JAVA:

  1. package com.digows.artigos.JavaFlex.model.entity;
  2.  
  3. public class Cargo {
  4.  
  5.     private long idCargo;
  6.     private String dsCargo;
  7.  
  8.     public long getIdCargo() {
  9.         return idCargo;
  10.     }
  11.     public void setIdCargo(long idCargo) {
  12.         this.idCargo = idCargo;
  13.     }
  14.     public String getDsCargo() {
  15.         return dsCargo;
  16.     }
  17.     public void setDsCargo(String dsCargo) {
  18.         this.dsCargo = dsCargo;
  19.     }
  20. }

Entities (ou Entidades, nenhuma relação com Entity Beans) são objetos que possuem uma identidade única.

Um carrinho de compras numa loja virtual web não é igual a outro, não importa que possuam os mesmos produtos, o carrinho A é o carrinho do usuário A, o carrinho B é do usuário B. Mesmo que contenham os mesmos produtos você não pode exibir o carrinho B ao usuário A, eles são diferentes! O carrinho neste exemplo segue o Padrão Entity, ele é uma entidade de negócios única.

Dentro do package services crie uma classe java com o nome de CargoService com o seguinte conteúdo:

CargoService.java

PLAIN TEXT
JAVA:

  1. package com.digows.artigos.JavaFlex.model.service;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5.  
  6. import com.digows.artigos.JavaFlex.model.entity.Cargo;
  7.  
  8. public class CargoService {
  9.  
  10.     public Cargo save(Cargo p_cargo) {
  11.         System.out.println(“Salvou o Cargo: “+p_cargo.getDsCargo());
  12.         return p_cargo;
  13.     }
  14.  
  15.     public void remove(Cargo p_cargo) {
  16.         System.out.println(“Excluiu o Cargo: “+p_cargo.getDsCargo());
  17.     }
  18.  
  19.     public List<cargo> getList() {
  20.         return new ArrayList<cargo>();
  21.     }
  22.  
  23.     public Cargo findByPrimaryKey() {
  24.         return new Cargo();
  25.     }
  26. }

Services são classes que não implementam diretamente as regras de negócio da aplicação, apenas coordenam a interação entre os componentes, elas são quase sempre beans gerenciados pelo Spring. É muito importante que as classes do tipo Services não implementem as regras de negócio, elas apenas atuam como Façades coordenando as interações.

O CargoService claro não proverá persistência a um banco de dados, os sysouts ali são apenas para abstração da intragração.

Com as classes javas feitas, vamos a configuração dos channels do BlazeDS, para isso no web.xml contido dentro da pasta WebContent\WEB-INF\web.xml, deixe como mostrado abaixo:

web.xml

PLAIN TEXT
XML:

  1. <?xml version=“1.0″ encoding=“UTF-8″?>
  2. <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
  3.     "http://java.sun.com/dtd/web-app_2_3.dtd">
  4. <web-app>
  5.     <display-name>ArquiteturaJavaFlex</display-name>
  6.  
  7.     <!– MessageBroker Servlet –>
  8.     <servlet>
  9.         <servlet-name>MessageBrokerServlet</servlet-name>
  10.         <display-name>MessageBrokerServlet</display-name>
  11.         <servlet-class>
  12.             flex.messaging.MessageBrokerServlet
  13.         </servlet-class>
  14.         <init-param>
  15.             <param-name>services.configuration.file</param-name>
  16.             <param-value>/WEB-INF/flex/services-config.xml</param-value>
  17.         </init-param>
  18.         <init-param>
  19.             <param-name>flex.write.path</param-name>
  20.             <param-value>/WEB-INF/flex</param-value>
  21.         </init-param>
  22.         <load-on-startup>1</load-on-startup>
  23.     </servlet>
  24.     <servlet-mapping>
  25.         <servlet-name>MessageBrokerServlet</servlet-name>
  26.         <url-pattern>/messagebroker/*</url-pattern>
  27.     </servlet-mapping>
  28.  
  29.     <welcome-file-list>
  30.         <welcome-file>index.html</welcome-file>
  31.         <welcome-file>index.htm</welcome-file>
  32.         <welcome-file>index.jsp</welcome-file>
  33.     </welcome-file-list>
  34. </web-app>

Perceba que ao gerar a Servlet Java, é passado por parâmetro um arquivo dentro da pasta WebContent\WEB-INF\flex, crie um arquivo chamado services-config.xml como referênciado, este arquivo é o que contém Factorys, Channels, LogConfigs. Nós vamos usar apenas um tipo de serviço que o BlazeDS implementa, que o canal de AMF3 simples, para isso adicione o seguinte conteúdo:

services-config.xml

PLAIN TEXT
XML:

  1. <?xml version=“1.0″ encoding=“UTF-8″?>
  2. <services-config>
  3.     <services>
  4.         <service-include file-path=“remoting-config.xml” />
  5.  
  6.         <default-channels>
  7.            <channel ref=“my-amf”/>
  8.         </default-channels>
  9.  
  10.     </services>
  11.  
  12.     <channels>
  13.         <channel-definition id=“my-amf” class=“mx.messaging.channels.AMFChannel”>
  14.             <endpoint url=“http://{server.name}:{server.port}/{context.root}/messagebroker/amf” class=“flex.messaging.endpoints.AMFEndpoint”/>
  15.             <properties>
  16.                 <polling-enabled>false</polling-enabled>
  17.             </properties>
  18.         </channel-definition>
  19.     </channels>
  20.  
  21.     <logging>
  22.         <!– You may also use flex.messaging.log.ServletLogTarget –>
  23.         <target class=“flex.messaging.log.ConsoleTarget” level=“Error”>
  24.             <properties>
  25.                 <prefix>[BlazeDS] </prefix>
  26.                 <includeDate>false</includeDate>
  27.                 <includeTime>false</includeTime>
  28.                 <includeLevel>true</includeLevel>
  29.                 <includeCategory>false</includeCategory>
  30.             </properties>
  31.             <filters>
  32.                 <!–<pattern>Endpoint.*</pattern>–>
  33.                 <!–<pattern>Service.*</pattern>–>
  34.                 <pattern>Message.*</pattern>
  35.                 <pattern>DataService.*</pattern>
  36.                 <pattern>Configuration</pattern>
  37.             </filters>
  38.         </target>
  39.     </logging>
  40.  
  41.     <system>
  42.         <redeploy>
  43.             <enabled>true</enabled>
  44.             <watch-interval>20</watch-interval>
  45.             <watch-file>{context.root}/WEB-INF/flex/services-config.xml</watch-file>
  46.             <watch-file>{context.root}/WEB-INF/flex/remoting-config.xml</watch-file>
  47.             <touch-file>{context.root}/WEB-INF/web.xml</touch-file>
  48.         </redeploy>
  49.     </system>
  50. </services-config>

Perceba que é feito um include em um arquivo chamado: remoting-config.xml, então crie um arquivo com este nome na pasta WebContent\WEB-INF\flex\. Este arquivo contém alguns adapters, e nossos destinations, que nada mais é que o mapeamento das nossas classes de serviços no java. Para isso adicione o seguinte conteúdo:

remoting-config.xml

PLAIN TEXT
XML:

  1. <?xml version=“1.0″ encoding=“UTF-8″?>
  2. <service id=“remoting-service”
  3.     class=“flex.messaging.services.RemotingService”>
  4.  
  5.     <adapters>
  6.         <adapter-definition id=“java-object”
  7.             class=“flex.messaging.services.remoting.adapters.JavaAdapter”
  8.             default=“true” />
  9.     </adapters>
  10.  
  11.     <default-channels>
  12.         <channel ref=“my-amf” />
  13.     </default-channels>
  14.  
  15.     <destination id=“cargoService”>
  16.         <properties>
  17.             <source>
  18.                 com.digows.artigos.JavaFlex.model.service.CargoService
  19.             </source>
  20.         </properties>
  21.     </destination>
  22.  
  23. </service>

A estrutura deverá ficar igual apresentado abaixo:

image

Para testar se tudo está ok, de um botão direito sobre o Projeto JavaFlex, e clique em Run As -> Run on Server. Na proxima janela aberta, em server runtime deixe seleciona o “Apache Tomcat v6.0“ e clique em finish, o Servidor irá iniciar, observer a aba Console para verificar possíveis erros. Se alguma Exception tiver ocorrida, verifique os passos e faça novamente.

Acessando o serviço Java através do remoting do BlazeDS

Como nosso serviço já foi levantado, basta gerarmos um form simples para testar nosso serviço, para isso na pasta src_flex, crie a seguinte estrutura de pastas:

com/digows/artigos/JavaFlex/view/entity/
com/digows/artigos/JavaFlex/view/screen/

Dentro do package Entity crie uma Classe ActionScript com o nome de Cargo com o seguinte conteúdo:

Cargo.as

PLAIN TEXT
Actionscript:

  1. package com.digows.artigos.JavaFlex.view.entity
  2. {
  3.     [RemoteClass(alias=“com.digows.artigos.JavaFlex.model.entity.Cargo”)]
  4.     [Bindable]
  5.     public class Cargo
  6.     {
  7.         public var idCargo:Number;
  8.         public var dsCargo:String;
  9.     }
  10. }

A Classe Cargo do Flex, é nada mais nada menos do que o espelho do Entity do java, nesta classe não realizei get’s set’s. Para fazer o espelho dos objetos usei a metatag [RemoteClass] mapeando a localização exata (Com package e nome da Classe) da mesma classe no java. A metatag Bindable é uma annotation muito importante, mais agora vamos apenas abstrair ela.

E dentro do package Screen, crie um arquivo MXML com o nome de CargoForm com o seguinte conteúdo:

CargoForm.mxml

PLAIN TEXT
XML:

  1. <?xml version=“1.0″ encoding=“utf-8″?>
  2. <mx:TitleWindow xmlns:mx=“http://www.adobe.com/2006/mxml”
  3.     layout=“vertical” width=“424″ height=“234″>
  4.  
  5.     <mx:Form width=“100%” height=“100%” defaultButton=“{btSalvar}”>
  6.         <mx:FormHeading label=“Gerenciamento de Cargos” width=“100%”/>
  7.         <mx:FormItem label=“ID:” width=“127″>
  8.             <mx:TextInput width=“100%” id=“txtIdCargo”/>
  9.         </mx:FormItem>
  10.         <mx:FormItem label=“Cargo:” width=“345″>
  11.             <mx:TextInput width=“100%” id=“txtDsCargo”/>
  12.         </mx:FormItem>
  13.     </mx:Form>
  14.  
  15.     <mx:ControlBar horizontalAlign=“center”>
  16.         <mx:Button label=“Salvar” id=“btSalvar” click=“save()” textAlign=“center”/>
  17.     </mx:ControlBar>
  18.  
  19.     <mx:RemoteObject id=“cargoService”
  20.         fault=“onFault(event)” destination=“cargoService”/>
  21.  
  22.     <mx:Script>
  23.         <![CDATA[
  24.             import com.digows.artigos.JavaFlex.view.entity.Cargo;
  25.             import mx.rpc.events.ResultEvent;
  26.             import mx.rpc.events.FaultEvent;
  27.             import mx.controls.Alert;
  28.  
  29.             private var cargo:Cargo;
  30.  
  31.             public function save():void
  32.             {
  33.                 this.cargo = new Cargo();
  34.                 this.cargo.idCargo   = new Number(txtIdCargo.text);
  35.                 this.cargo.dsCargo   = txtDsCargo.text;
  36.  
  37.                 cargoService.addEventListener(ResultEvent.RESULT,
  38.                     //No flex toda requisicao é assincrona,
  39.                     //Entao devo programar um funcao quando
  40.                     //a requisicao terminar de executar
  41.                     function(event:ResultEvent):void
  42.                     {
  43.                         status = "Salvo com Sucesso!"; //Status do TitleWindow
  44.                     }
  45.                 );
  46.                 //Chama o metodo Save do servico "cargoService"
  47.                 cargoService.save(cargo);
  48.             }
  49.  
  50.             public function remove():void{}
  51.  
  52.             public function getList():void{}
  53.  
  54.             public function findByPrimaryKey():void{}
  55.  
  56.             public function onFault(event:FaultEvent):void
  57.             {
  58.                 //Ocorreu uma falha ao chamar o servico.
  59.                 Alert.show(event.fault.message);
  60.             }
  61.         ]]>
  62.     </mx:Script>
  63. </mx:TitleWindow>

Perceba que acoplei muito código neste arquivo, isto não é uma boa prática, nos próximos artigos irei desaclopar as responsabilidades em camadas.

Para testar se tudo está ok, no arquivo JavaFlex.mxml que está na raiz da pasta src_flex renomeie para index.mxml, de um botão direito e clique em Set as Default Application, e deixe ele com o seguinte conteúdo:

index.mxml

PLAIN TEXT
XML:

  1. <?xml version=“1.0″ encoding=“utf-8″?>
  2. <mx:Application xmlns:mx=“http://www.adobe.com/2006/mxml”
  3.     layout=“vertical” verticalAlign=“middle” horizontalAlign=“center”
  4.     xmlns:screen=“com.digows.artigos.JavaFlex.view.screen.*”>
  5.  
  6.     <screen:CargoForm/>
  7.  
  8. </mx:Application>

E para finalizar vamos dizer ao compilador do Flex que existe um servidor de AMF levantado, para isso de um botão direito no projeto JavaFlex -> Properties -> Selecione Flex Compiler -> em Additional compiler arguments adicione a linha e ok:

-services “../WebContent/WEB-INF/flex/services-config.xml”

Para Executar, de um botão direito sobre o projeto JavaFlex, e clique em Run As -> Run on Server e Finish.

Se tudo correr bem, você verá a descrição que você digitou no flex aparecerá no console do Tomcat.

Bom finalizo aqui a primeira parte desta poderosa integração, logo logo posto o resto.

Link do Source do Projeto:
Download

Abraço Pessoal!!

\o/

Te Amuh Liz!! =******

Jan 16

Forum sobre AdobeFlex!

Escrito por Rodrigo Pereira Fraga em Adobe Air, Adobe Flex @ 01 16th, 2008 | via http://blog.digows.com | Sem comentários
Rodrigo Pereira Fraga
? X
  • Bookmarks

Blinkbits BlinkLists BlogLines Blogmarks Buddymarks CiteULike Co.mments Del.icio.us Digg Diigo

Fark Feed Me Links Furl Google Linkagogo ma.gnolia Mister Wong Newsvine Propeller Rawsugar

Reddit Rojo Simpy Sphinn Spurl Squidoo StumbleUpon Tailrank Technorati Yahoo

More »

Olá Pessoal!!

=)

É com muito prazer que divulgo a todos que o forum sobre AdobeFlex ficou pronto! Está bem bacana, utilizamos o PhpBB3 que veio com um layout muito mais atrativo.

http://forum.flexbrasil.com.br/

O forum tem a intenção de unir mais a comunidade, e está voltado para aqueles:

  1. Que não conhece a tecnlogia;
  2. Que estão começando a aprender;
  3. Que já estão em um nível avançado;

 

Acredito que ficou muito bom, pesso que entre e confira!! e também divulguem para que a comunidade cresça  o mais rápido o possível!

Abraços e até mais!

\o/

Jan 11

Crítica em Forma de Comédia

Escrito por Rodrigo Pereira Fraga em Vários @ 01 11th, 2008 | via http://blog.digows.com | Sem comentários
Rodrigo Pereira Fraga
? X
  • Bookmarks

Blinkbits BlinkLists BlogLines Blogmarks Buddymarks CiteULike Co.mments Del.icio.us Digg Diigo

Fark Feed Me Links Furl Google Linkagogo ma.gnolia Mister Wong Newsvine Propeller Rawsugar

Reddit Rojo Simpy Sphinn Spurl Squidoo StumbleUpon Tailrank Technorati Yahoo

More »

Estava eu olhando as notícias dos meus Feeds, e entrei em um site de filmes que contém alguns curtas muito bons. E encontrei um vídeo um pouco que bizarro, mas é interessante vale a pena olhar.

OH My God!!

 

Abraços e até a Próxima!

+)

Jan 3

Proposta de Arquitetura com Adobe Flex e PHP usando Zend Framework

Escrito por Rodrigo Pereira Fraga em Adobe Flex, amfphp, PHP @ 01 3rd, 2008 | via http://blog.digows.com | Sem comentários
Rodrigo Pereira Fraga
? X
  • Bookmarks

Blinkbits BlinkLists BlogLines Blogmarks Buddymarks CiteULike Co.mments Del.icio.us Digg Diigo

Fark Feed Me Links Furl Google Linkagogo ma.gnolia Mister Wong Newsvine Propeller Rawsugar

Reddit Rojo Simpy Sphinn Spurl Squidoo StumbleUpon Tailrank Technorati Yahoo

More »

Olá Pessoal,

Um item básico quando se trata de sites, é um local onde o visitante pode de alguma forma entrar em contato com a empresa do site, hoje existem algumas boas soluções para isso, como por exemplo um client msn que pode ser colocado no site e se o visitante quiser, pode entrar em contato com o msn da empresa.

Mas hoje vou mostrar a vocês uma forma simples e funcional, que consiste em um formulário onde o visitante preenche os dados, e gera um e-mail para o destinatário.

Mostrarei isso usando PHP/ZEND/AMFPHP/FLEX, poderia fazer isso somente com HTTPService? concerteza, ficaria menos código e até mais simples, porém concordamos que ninguém iria fazer uma aplicação só com essa funcionalidade, pois o Formulário de Contato seria apenas um módulo do sistema.

Então vou lhes mostrar também uma proposta de como você pode trabalhar arquiteturalmente com Flex e PHP, trocando apenas VO/TO/DTO entre as camadas, lembrando que isso é uma boa prática, vejo muitos porae trocando array’s com Flex e PHP, isso é totalmente desnecessário.

Detalhes da Arquitetura

ZEND Framework;

AMFPHP;

Adobe Flex;

A arquitetura usa o ZEND para abstração do banco de dados usando a Classe Zend_Db_Table, e outros recursos como o Zend_Loader e Zend_Registry.

AMFPHP para a comunicação entre o AdobeFlex e o PHP, esta comunicação rodando em cima do protocolo AMF3, que provém comunicação binária não mais String como no HTTP puro, e também compactação.

Estruturando a aplicação

Estrutura de Pastas  
Listagem 1

Crie uma estrutura de pastas como mostrado na Listagem 1

O package entitybean contém classes que segue os conceitos de um EntityBean como nas especificações J2EE/JEE, só que claro BMP através do Zend_Db_Table, e uma outra classe que eu fiz chamada EntityBeanImpl, que abstrai ainda mais os métodos CRUD de um caso de uso, como por Exemplo eliminei os métodos Inserir e Atualizar, e criei um Salvar, que insere ou atualiza baseado na Primary-Key. Em poucas palavras, um EntityBean, é reponsável pela abstração de um Banco de Dados Relacional, as camadas acima de entityBean apenas conhecem o entitybean, não tem acesso ao Banco de dados.

Para Garantir transação e concorrência, criei uma classe chamada DB que cotém um singleton me garantindo apenas uma instância da mesma em uma transação,  ela é reponsavel por iniciar uma transação através do método beginTransaction() realizar o commit se toda a operação ocorrer com sucesso atraveés do método commit()  e realizar o roolback no banco de dados através do método rollback().

O package sessionbean contém classes que segue os conceitos de um SessionBean também como nas especificações J2EE/JEE só que apenas sendo Stateless. Em poucas palavras um SessionBean tem a responsábilidade de implementar a regra de negócio do caso de uso, como por exemplo validações, calculos e etc.

O package facade contém classes que implementam o Pattern Facade em outras palavras é a fachada do sistema, neta arquitetura ela é responsável por garantir a transação usando a classe DB, também é reponsável pelo tratamento de exceções (Erros).

O package vo contém simples classes que implementam os Patterns VO/TO/DTO, são os vo’s encarregados de transportar entre as camadas as informações de cada caso de uso. Lembrando que o mesmo VO no PHP, será automaticamente serializado pelo AMFPHP para um VO no Flex para isso os VO devem ficar assim:

No PHP:
*Coloque a tag do php no inicio e no fim.

PLAIN TEXT
PHP:

  1. class ContatoVO
  2. {
  3.     var $idContato;
  4.     var $dsNome;
  5.     var $dsEmail;
  6.     var $nuTelefone;
  7.     var $dsCidade;
  8.     var $dsEstado;
  9.     var $dsMensagem;
  10.  
  11. //NOME DO VO NO FLEX
  12.     var $_explicitType = “ContatoVO”;
  13. }

No Flex/AS3

PLAIN TEXT
Actionscript:

  1. package com.digows.Artigos.FlexPHP.vo
  2. {
  3.     //NOME DO VO NO PHP
  4.      [RemoteClass(alias=“ContatoVO”)]
  5.     [Bindable]
  6.     public class ContatoVO
  7.     {
  8.         public var idContato:int;
  9.         public var dsNome:String;
  10.         public var dsEmail:String;
  11.         public var nuTelefone:String;
  12.         public var dsCidade:String;
  13.         public var dsEstado:String;
  14.         public var dsMensagem:String;
  15.     }
  16. }

O package services contem as classes de serviços de toda aplicação, estes serviços podem ser disponibilizados para o AMFPHP como veremos a seguir, ou também se você conhece bem o Zend Framework, pode gerar serviços através de WebServices ou até mesmo serviços para o Controller do Zend Framework, neste caso usando HTML na View.

O package config apenas contém arquivos de configuração, como por exemplo path do servidor, dados do banco de dados e etc.

E finalmente o package libs que contém as bibliotecas utilizadas na aplicação, no caso o AMFPHP e Zend Framework.

Configurando a aplicação

Nós precisamos fazer uma integração com o Zend Framework, e o AMFPHP, então primeiramente vamos gerar o application-config.php do Zend.

Dentro do package config, crie um arquivo chamado application-config.php  com este conteúdo:

*Coloque a tag do php no inicio e no fim.

PLAIN TEXT
PHP:

  1. set_include_path(‘.’.PATH_SEPARATOR.‘../../libs’.PATH_SEPARATOR.get_include_path());
  2.     require_once (‘Zend/Loader.php’);
  3.     /**
  4.     * Loaders
  5.     */
  6.     //Registrador de Variaveis
  7.     Zend_Loader::loadClass(‘Zend_Registry’);
  8.     //Carregador de configuracoes de um .ini
  9.     Zend_Loader::loadClass(‘Zend_Config_Ini’);
  10.       //Classe que encapsula o Banco
  11.     Zend_Loader::loadClass(‘Zend_Db’);
  12.     //Classe para usar as tabelas como objetos.
  13.     Zend_Loader::loadClass(‘Zend_Db_Table’);
  14.     //Usada para fazer o parser dos xml
  15.     Zend_Loader::loadClass(‘Zend_Config_Xml’);
  16.  
  17. /**
  18.     * Configuracoes da Persistencia.
  19.     */
  20.     //Carrega o arquivo de configuracoes.
  21.     $configDB = new Zend_Config_Ini(dirname(__FILE__).‘/config.ini’, ‘database’);
  22.     Zend_Registry::set(‘configDB’, $configDB);
  23.     $configPaths = new Zend_Config_Ini(dirname(__FILE__).‘/config.ini’, ‘paths’);
  24.     Zend_Registry::set(‘configPaths’, $configPaths);
  25.     /**
  26.      * Configuracoees variadas…
  27.      */
  28.        //Configura o formato para moeda
  29.       setlocale(LC_MONETARY, ‘ptb’);
  30.     //Configura as mensagens de erro que devem ser apresentadas.   
  31.     error_reporting(E_ALL | E_STRICT);

Perceba que a configuração usa um arquivo chamado config.ini este contém as configurações do Banco de Dados e paths:

PLAIN TEXT
CODE:

  1. [database]
  2. db.adapter=PDO_MYSQL
  3. db.config.host=localhost
  4. db.config.username=root
  5. db.config.password=
  6. db.config.dbname=flexphp
  7. [paths]
  8. path.dirImg=C:/resources/img

No package libs você coloca os arquivos do ZEND e do AMFPHP ficando assim:

Libs
Listagem 2

A única coisa que precisa ser feita com o AMFPHP, é dizer a ele aonde está os services, que usa para mandar os VO’s para o PHP, e aonde se encontra o package dos VO’s, que ele usa para serializar os VO’s Flex e PHP.

Para isso, abra o arquivo globals.php dentro da pasta do AMFPHP e deixe assim:

*Coloque a tag do php no inicio e no fim.

PLAIN TEXT
PHP:

  1. //This file is intentionally left blank so that you can add your own global settings
  2.     //and includes which you may need inside your services. This is generally considered bad
  3.     //practice, but it may be the only reasonable choice if you want to integrate with
  4.     //frameworks that expect to be included as globals, for example TextPattern or WordPress
  5.  
  6. //Set start time before loading framework
  7.     list($usec, $sec) = explode(” “, microtime());
  8.     $amfphp[‘startTime’] = ((float)$usec + (float)$sec);
  9.  
  10. $servicesPath = “../../application/services/”;
  11.     $voPath = “../../application/business/vo/”;
  12.  
  13. //As an example of what you might want to do here, consider:
  14.     /*
  15.     if(!PRODUCTION_SERVER)
  16.     {
  17.         define("DB_HOST", "localhost");
  18.         define("DB_USER", "root");
  19.         define("DB_PASS", "");
  20.         define("DB_NAME", "amfphp");
  21.     }
  22.     */

Perceba as variaveis $servicesPath e $voPath.

É preciso configurar os sources_paths do projeto no caso o src_flex e src_php, para isso:

No seu projeto de um botão direito -> Properties -> Selecione a opção Flex Build Path -> clique no botão Add Folder e procure a pasta src_php -> Em Main source folder selecione a pasta src_flex.

Esta tela deverá ficar assim:

Flex Build Path
Listagem 3

E para concluir, precisamos informar ao compilador Flex qual o endereço do gateway onde será possível trocar dados em cima do protocolo AMF3, para isso gere um arquivo com o nome de     services-config.xml  na raiz da pasta src_flex  com este conteúdo:

XML

   1: <services-config>
   2:     <services>
   3:         <service id="amfphp-flashremoting-service"
   4:             class="flex.messaging.services.RemotingService"
   5:                 messageTypes="flex.messaging.messages.RemotingMessage">
   6:             <destination id="amfgateway">
   7:                 <channels>
   8:                     <channel ref="channel-amf"/>
   9:                 </channels>
  10:                 <properties>
  11:                     <scope>session</scope>
  12:                     <source>*</source>
  13:                 </properties>
  14:             </destination>
  15:         </service>
  16:     </services>
  17:     <channels>
  18:         <channel-definition id="channel-amf" class="mx.messaging.channels.AMFChannel">
  19:             <endpoint uri="http://{server.name}:{server.port}/FlexPHP/libs/amfphp/gateway.php"
  20:                 class="flex.messaging.endpoints.AMFEndpoint"/>
  21:         </channel-definition>
  22:     </channels>
  23: </services-config>

E nos Properties do Projeto, o FlexCompiler deverá ficar assim:

Flex Compiler

Listagem 4

Detalhando as Camadas

O Fluxo das Camada é a seguinte:

O Flex chama um Serviço através do AMFPHP que direciona para uma classe com um especifico método no package services;

Ex: O Flex Chama a classe ContatoService, solicitando o método  save(), passando por parâmentro uma instância de ContatoVO.

A Service chama uma classe da Facade  com o respectivo método solicitado;

Ex: O ContatoService chama o ContatoFacade solicitando o método save() passando por parâmentro uma instância de ContatoVO.

A Facade abre uma transação, e chama um SessionBean;

Ex: O ContatoFacade  chama o ContatoBean solicitando o método save() passando por parâmentro uma instância de ContatoVO.

O SessionBean faz a regra de negócio específica do caso de uso,  e se tudo tiver ok chama um EntityBean para fazer a persistência, se não dispara uma nova Exception dando rollback no banco e mostrando uma mensagem de erro para o Flex através do catch na Facade;

Ex: O ContatoSession chama o ContatoBean solicitando para que insira ou atualize os dados através do ContatoVO  passado por parâmentro.

Tendo conhecimento do Fluxo das camadas pode se observar que o código ficou bem separado, o que garante baixo acoplamento e alta coesão.

E como Fica no Flex?

Estrutura de Pastas Flex 
Listagem 5

Como este exemplo tem por finalidade de mostrar uma proposta de arquitetura com Flex e PHP, este exemplo não adota padrões de projetos no lado Flex, mas é extremamente recomendável o uso de Padrões seja com o Cairngorm da Adobe ou tantos outros existentes porae.

A classe RemoteConnection é uma classe que tem por finalidade de abstrair o uso do RemoteObject, como por exemplo você pode chamar o ContatoService desta forma:

PLAIN TEXT
Actionscript:

  1. var contatoVO:ContatoVO = new ContatoVO();
  2. contatoVO.dsNome     = txtNome.text;
  3. contatoVO.dsEmail    = txtEmail.text;
  4. contatoVO.nuTelefone = txtTelefone.text;
  5. contatoVO.dsCidade   = txtCidade.text;
  6. contatoVO.dsEstado   = txtEstado.text;
  7. contatoVO.dsMensagem = txtMensagem.text;
  8.  
  9. RemoteConnection.call(“ContatoService”,“save”,
  10.      function(event:ResultEvent):void
  11.      {
  12.          Alert.show(“Email enviado com sucesso!”,“SUCESSO!”);
  13.          clear();       
  14.     },
  15.     contatoVO
  16. );

Perceba que gero um VO com as informações da Tela, e Solicito o serviço ContatoService chamando o método save() passando por parâmetro uma instância de ContatoVO.

A Função de retorno implementei dentro do próprio método, mas eu poderia criar uma função só para tratar o retorno do método assíncrono.

Bom Senhores, acredito que consegui dar uma boa explicação sobre como trabalhar arquiteturalmente com Flex e PHP.

Estarei diponibilizando o projeto usado no exemplo, para executar, dentro da pasta docs contém 2 arquivos, um chamado localhost.sql.zip que pode ser usado para gerar o banco de dados e outro chamado MER.xml que é o MER feito com o DBDesigner. Após gerar o banco, é só importar no seu Flex Builder 3.

Aplicação Rodando

FlexPHP

Source do Projeto: Projeto FlexPHP

Para aqueles que tiverem dúvidas, sujestões ou críticas podem entrar em contato comigo, na medida do possível estarei lhes respondendo.

Obrigado a Todos e um Bom Proveito!

Liz.. te amo querida! =*

|

ACERCA

O que é o RedeRIA ?

O redeRIA não é nada mais que um agregador de feed's que disponibiliza o conteudo de varios blogs e autores ao redor do mundo RIA, actualmente agregamos mais de 2750 entradas vindas de 53 blogs especializados em ria’s, pelo que só fica a ganhar em assinar o feed ou seguir a comunidade no twitter.

Se acha que o seu blog ou um blog de um amigo é interessante e util para os leitores o redeRIA, faça a sua submissão aqui.

Feed: assine já
Twitter: siga-nos

GOOGLE

Votação


Deveria o RedeRia agregar conteúdo em inglês?
Ver Resultados

AUTORES


Eduardo KrausAlexandre TadashiBindableCognitiva SoluçõesDaniel LopesDaniel SchmitzDanielPedrinhaDClick TeamEbercomEdgard DavidsonElvis FernandesErko BrideeFabiel PrestesFábio Batista da SilvaFabio da SilvaFabriccio BernardesFelipe BorellaFlavia MoreiraGabriel VersalliniGabriela T. PerryIgor MusardoJanderson CardosoJoão AugustoJose Carlos FielKelps SousaLeonardo FrançaLucas MarçalLuis MessiasLuiz TarabalMario JuniorMário SantosMauro MartinsPablo SouzaPedro ClaudioreneRia BrazilriaPTRicardo CerqueiraRobson FernandesRodrigo Pereira FragaSaintBrSamuelFacchinelloSergio SouzaSilva DeveloperStefan HorochovecTech CaffeTecinforThiago BuenoVedVinícius SandimWillian ManoXAML Cast

PUBLICIDADE








Powered by Wordpress & msdevstudio.com