Virmerson B. Santos virmerson@hightechcursos.com.br Material de Apoio CURSO de JAVA WEB FLEX (cjwebflex)
Ferramentas Flex Builder (Download trial) Windows Processador de 2 GHz ou mais rápido Microsoft Windows XP com Service Pack 3, Windows Vista Ultimate ou Enterprise (32 bits ou 64 bits rodando em modo de 32 bits), Windows Server 2008 (32 bits) ou Windows 7 (32 bits ou 64 bits em execução no modo de 32 bits) 1GB de RAM (2 GB recomendado) 1,5 GB de espaço disponível no disco rígido Java Virtual Machine (32 bits): IBM JRE 1.6 ou JRE 1.6 Sun 1024x768 mostrar (1280x800 recomendado) com 16-bit placa de vídeo DVD-ROM Eclipse 3.6.1 ou Eclipse 3.7 (para instalação do plug-in) * Mac OS Processador Intel Mac OS X v10.6 e v10.7 1GB de RAM (2 GB recomendado) 1,5 GB de espaço disponível no disco rígido Java Virtual Machine (32 bit): JRE 1.6 1024x768 mostrar (1280x800 recomendado) com 16-bit placa de vídeo DVD-ROM Eclipse versão Cocoa 3,6 (para instalação do plug-in) * Para a instalação do Adobe Flash Builder 4 basta você ir avançando as opções, sempre mantendo os valores padrões. A versão Standalone é uma versão Trial que dura 60 dias. No site da Adobe você pode obter gratuitamente uma licensa de utilização caso você se enquadre nas exigências legais (estudantes, profissionais autônomos, etc).
Protocolos: Action Message Format ( AMF ) é um formato binário usado para serializar objetos gráficos, tais ActionScript objetos e XML, ou enviar mensagens entre um Adobe Flash cliente e um serviço remoto, geralmente um Flash Media Server ou alternativas de terceiros. Real Time Messaging Protocol ( RTMP ) foi inicialmente um protocolo proprietário desenvolvido pela Macromedia para streaming de áudio, vídeo e dados através da Internet, entre um flash player e um servidor. HTTP Criando o Projeto Java
Criando o Projeto Flex
O que é BlazeDS BlazeDS é o servidor baseado em Java e web remoting tecnologia de mensagens que permite aos desenvolvedores facilmente conectar-se back-end dados distribuídos e envio de dados em tempo real para o Adobe Flex e Adobe AIR aplicações para Internet aplicação mais ágil rica (RIA) experiências. Baixando o BlazeDS http://opensource.adobe.com/wiki/display/blazeds/download+blazeds+3
Descompacte o BlazeDS Copiando a pasta WEB- INF da pasta descompactada blazeds que contem os arquivos de configuração do Flex e as bibliotecas (JARs) do BlazeDS para o projeto Java WEB. Conteúdo da Pasta WEB-INF:
Colando os arquivos dentro da pasta WebContent\WEB-INF Proxy-Config.xml <?xml version="1.0" encoding="utf-8"?> <service id="proxy-service" class="flex.messaging.services.httpproxyservice"> <properties> <connection-manager> <max-total-connections>100</max-total-connections> <default-max-connections-per-host>2</default-maxconnections-per-host> </connection-manager> <allow-lax-ssl>true</allow-lax-ssl> </properties> <adapters> <adapter-definition id="http-proxy"
class="flex.messaging.services.http.httpproxyadapter" default="true"/> <adapter-definition id="soap-proxy" class="flex.messaging.services.http.soapproxyadapter"/> </adapters> <default-channels> <channel ref="my-amf"/> </default-channels> <destination id="defaulthttp"> </destination> </service> Remote-Config.xml <?xml version="1.0" encoding="utf-8"?> <service id="remoting-service" class="flex.messaging.services.remotingservice"> <adapters> <adapter-definition id="java-object" class="flex.messaging.services.remoting.adapters.javaadapter" default="true"/> </adapters> <default-channels> <channel ref="my-amf"/> </default-channels> </service> Services-config.xml <?xml version="1.0" encoding="utf-8"?> <services-config> <services> <service-include file-path="remoting-config.xml" /> <service-include file-path="proxy-config.xml" /> <service-include file-path="messaging-config.xml" /> </services> <security> <login-command class="flex.messaging.security.tomcatlogincommand" server="tomcat"/> </security> <channels> <channel-definition id="my-amf" class="mx.messaging.channels.amfchannel"> <endpoint url="http://{server.name:{server.port/{context.root/messagebroker/a mf" class="flex.messaging.endpoints.amfendpoint"/>
</channel-definition> <channel-definition id="my-secure-amf" class="mx.messaging.channels.secureamfchannel"> <endpoint url="https://{server.name:{server.port/{context.root/messagebroker/ amfsecure" class="flex.messaging.endpoints.secureamfendpoint"/> <properties> <add-no-cache-headers>false</add-no-cache-headers> </properties> </channel-definition> <channel-definition id="my-polling-amf" class="mx.messaging.channels.amfchannel"> <endpoint url="http://{server.name:{server.port/{context.root/messagebroker/a mfpolling" class="flex.messaging.endpoints.amfendpoint"/> <properties> <polling-enabled>true</polling-enabled> <polling-interval-seconds>4</polling-interval-seconds> </properties> </channel-definition> </channels> <logging> <target class="flex.messaging.log.consoletarget" level="error"> <properties> <prefix>[blazeds] </prefix> <includedate>false</includedate> <includetime>false</includetime> <includelevel>false</includelevel> <includecategory>false</includecategory> </properties> <filters> <pattern>endpoint.*</pattern> <pattern>service.*</pattern> <pattern>configuration</pattern> </filters> </target> </logging> <system> <redeploy> <enabled>false</enabled> <!-- </redeploy> </system> </services-config> Messaging-config.xml <?xml version="1.0" encoding="utf-8"?> <service id="message-service"
class="flex.messaging.services.messageservice"> <adapters> <adapter-definition id="actionscript" class="flex.messaging.services.messaging.adapters.actionscriptad apter" default="true" /> </adapters> <default-channels> <channel ref="my-polling-amf"/> </default-channels> </service>
Ligando os Projetos Java e Flex (Server Settings)
Testando - Acessando Remotamente HTTPService: Use componentes HTTPService para enviar HTTP GET ou pedidos POST e incluir os dados das respostas HTTP em um aplicativo cliente Componentes HTTPService são uma boa opção quando você não pode expor a mesma funcionalidade como um serviço web SOAP ou serviço objeto remoto. Por exemplo, você pode usar componentes HTTPService para interagir com JavaServer Pages (JSPs), servlets e páginas ASP que não estão disponíveis como serviços web ou destinos Serviço Remoting. WebService: WebService componentes permitem acessar serviços web SOAP, que são módulos de software com métodos. Métodos de serviço Web são comumente chamados de operações. Interfaces de serviços Web são definidas usando Web Services Description Language (WSDL). Você pode usar um componente WebService para se conectar a um serviço web SOAP compatível com quando os serviços web são um padrão estabelecido em seu ambiente. WebService componentes também são úteis para objetos que estão dentro de um
ambiente corporativo, mas não necessariamente disponíveis no caminho de origem da aplicação web. Remote Object Serviços objeto remoto permitem que você acesse a lógica do negócio diretamente em seu formato nativo, em vez de formatá-lo como XML, como você faz com estilo REST serviços ou serviços web. Isto poupa-lhe o tempo necessário para expor a lógica existente como XML. Outro benefício dos serviços objeto remoto é a velocidade de comunicação através do fio. Trocas de dados continuam a acontecer em HTTP ou HTTPS, mas os dados em si é serializado em uma representação binária. Utilizando os resultados componentes RemoteObject em menos dados atravessando a rede, uso de memória reduzida do lado do cliente, e tempo de processamento reduzido. JAVA Adicionando o Controlador do Servidor Tomcat Abrindo o painel servers e criando um novos ervidor.
JAVA - Criando a Classe UsuarioService package br.com.hightechcursos.service; public class UsuarioService { public void cadastrar(){ System.out.println("Chamou no Servidor!");
Flex - Criando o Index.xhtml <?xml version="1.0" encoding="utf-8"?> <s:application xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark" xmlns:mx="library://ns.adobe.com/flex/mx" minwidth="955" minheight="600" creationcomplete="application1_creationcompletehandler(event)"> <fx:script> <![CDATA[ import mx.controls.alert; import mx.events.flexevent; import mx.rpc.events.faultevent; import mx.rpc.events.resultevent; protected function application1_creationcompletehandler(event:flexevent):void { objremo.cadastrar(); protected function method1_resulthandler(event:resultevent):void { Alert.show("Deu Certo","Atenção"); protected function method1_faulthandler(event:faultevent):void { Alert.show("Deu Errado" + event+"", "Atenção"); ]]> </fx:script> <fx:declarations> <s:remoteobject id="objremo" destination="usuarioservice" > <s:method name="cadastrar" result="method1_resulthandler(event)" fault="method1_faulthandler(event)"/> </s:remoteobject> </fx:declarations> <s:label x="245" y="116" width="413" height="112" text="seja Bem Vindo!"/> </s:application> Verificando se o index.html e index.swf foram criados.
Aumentando o Timeout do Tomcat- Clique 2 vezes no tomcat no painel server e mude o tempo para 100 segundos. Problema de Versões do entre Jdk e Tomcat. Unsupported major.minor version 51.0
Resolvendo: Clicando o botão direito do Mouse no projeto opção properties e depois Facets. Trocando a versão do Java para 1.6. Testando se a requisição do nosso Objeto Remoto (RemoteObject) consegue estabelecer a comunicação com o Objeto Java UsuarioService.
Testando o projeto http://localhost:8080/cjwebflex_java/index.html Verificando no Console do TomCat Integrando Spring com BlazeDS
Fundamentos do Spring Framework O Spring Antes da sua concepção tínhamos apenas o EJB(2.x) para desenvolver aplicações JEE. Para aqueles que conheceram ou leram sobre o EJB 2.x sabem ou perceberam que desenvolver aplicações com ele era uma tarefa custosa, tanto em questão de tempo, pois era necessário escrever muitos arquivos, quanto em questão de recursos de máquina. Diante disso, a comunidade começou a buscar outras alternativas para desenvolver uma aplicação JEE. O Spring foi uma delas, além de ser uma alternativa ao EJB o ele também colocou o recurso de inversão de controle, que foi o principal responsável pelo seu sucesso. Existem muitas pessoas ligadas ao Spring, mas Rod Jhonson é o principal nome desse framework, onde todas essas pessoas que tinham em mente criar um framework open source para tornar o desenvolvimento J2EE mais fácil e produtivo. O Spring pretende ajudar a estruturar aplicações inteiras de maneira consistente, produtiva, reunindo o que dita a especificação JEE, com integração inúmeros frameworks existentes como Hibernate, Struts, JSF, Wicket, Hessian, etc. Isso é possível justamente pelo mecanismo de IoC, que nos resulta em uma arquitetura coerente e com baixo acoplamento. O Spring não se limita apenas a aplicações web, aplicações J2SE também podem fazer uso dos benefícios do Spring como simplicidade, testabilidade, e baixo acoplamento. Em suma o Spring é... Uma plataforma para "inserirmos" o nosso código Java. Provê uma completa infraestrutura de suporte para as aplicações Java. Dessa maneira podemos direcionar o foco para resolver os problemas de domínio do projeto.
Como plataforma, o Spring nos permite criar aplicações a partir de plain old Java Objects (POJOs), que o Spring chama de Bean e integrar com uma infinidade de outros frameworks. Saiba mais sobre Spring no site oficial: http://www.springsource.org/about Conceitos Importantes IoC Inversion of Control - Inversão de Controle Em suma, podemos dizer que é deixar de fazer algo, de modo que alguém, um controlador/contêiner faça por você. E esse deixar que façam por você consiste em uma configuração que pode ser via xml, programática ou via anotação. DI Dependency Injection - Injeção de Dependência De forma simples e direta, é injeção de dependência é construir, instanciar um objeto e suas dependências que de modo que ele esteja pronto para ser usado. Existe a DI por setter, construtor, atributo e interface. Os mais comuns são os 3 primeiros. Importante: Embora DI e IoC se assemelhem, não são a mesma coisa, a DI é uma parte da IoC. Toda essa robustez do Spring busca diminuir o acoplamento dos objetos existentes na sua aplicação, com isso alcançar o que a programação orientada a objeto tanto vende fica mais próximo, que é a reutilização de código e a manutenção facilitada. Exemplo:
Organização da Ferramenta O Spring é composto por recursos que estão organizados em vários módulos e projetos. Nesse curso estudaremos alguns desses módulos e alguns dos recursos desses módulos. Módulos Arquitetura Módulos Importantes Core Container Beans Core Data Access/Integration JDBC Transactions
Core Container Essa é a parte base do Spring, que realiza o gerenciamento dos objetos e a DI dos objetos da aplicação. Para o Spring todo objeto gerenciado por ele é chamado de bean. Ao container cabe a responsabilidade de obter as instruções para instanciar, configurar o objeto. Para tal, deve ser disponibilizado o configuration metadata. Essa configuração pode ser data por XML, Java Annotation ou código Java. Core Container Beans É a parte base e fundamental do Spring, e provê o mecanismo de DI e IoC. Os principais pacotes são org.springframework.beans e org.springframework.context. Core Container Context Módulo que provê o acesso aos objetos que foram definidos e instanciados. A interface org.springframework.context.applicationcontext, é o por onde se tem acesso aos beans definidos. Em aplicalções standalone, fazemos o uso das classes ClassPathXmlApplicationContext ou FileSystemXmlApplicationContext para instanciar o contexto do Spring. Esquema do funcionamento do Spring.
Context - Metadata Metadados - Como mostrado na figura anterior, o Spring precisa consumir um metadado de configuração; esses metadados dizem ao Spring como instanciar, montar e configurar os objetos da sua aplicação. Os metadados são tradicionalmente fornecidos através de um XML simples; a partir da versão 2.5 já é possível usar annotations. Configuração do Spring A base, o boot da configuração do Spring se dá por meio de arquivos XML. No entanto, montada a base dessa configuração podemos usar: XML Anotação Integrando Spring com BlazeDS Baixando o Spring Faça um cadastro rápido e pronto. http://www.springsource.org/download
Configurando o Spring Factory Adicionando a Classe Spring Factory no Projeto public class SpringFactory implements FlexFactory { private static final String SOURCE = "source"; public void initialize(string id, ConfigMap configmap) { public FactoryInstance createfactoryinstance(string id, ConfigMap properties) { SpringFactoryInstance instance = new SpringFactoryInstance(this, id, properties); instance.setsource(properties.getpropertyasstring(source, instance.getid())); return instance; // end method createfactoryinstance() public Object lookup(factoryinstance inst) { SpringFactoryInstance factoryinstance = (SpringFactoryInstance) inst; return factoryinstance.lookup(); static class SpringFactoryInstance extends FactoryInstance { SpringFactoryInstance(SpringFactory factory, String id, ConfigMap properties)
{ super(factory, id, properties); public String tostring() { return "SpringFactory instance for id=" + getid() + " source=" + getsource() + " scope=" + getscope(); public Object lookup() { ApplicationContext appcontext = WebApplicationContextUtils.getWebApplicationContext(flex.messagi ng.flexcontext.getservletconfig().getservletcontext()); String beanname = getsource(); try { return appcontext.getbean(beanname); catch (NoSuchBeanDefinitionException nexc) { ServiceException e = new ServiceException(); String msg = "Spring service named '" + beanname + "' does not exist."; e.setmessage(msg); e.setrootcause(nexc); e.setdetails(msg); e.setcode("server.processing"); throw e; catch (BeansException bexc) { ServiceException e = new ServiceException(); String msg = "Unable to create Spring service named '" + beanname + "' "; e.setmessage(msg); e.setrootcause(bexc); e.setdetails(msg); e.setcode("server.processing"); throw e; Essa classe pode ser Copiada no Seguinte Link: http://livedocs.adobe.com/blazeds/1/blazeds_devguide/help.html?content=factory_2.html Adicione o seguinte Factory no arquivo Services-config.xml <!-- Spring factory registration --> <factories> <factory id="spring"
class="br.com.hightechcursos.factory.springfactory" /> </factories> web.xml <context-param> <param-name>contextconfiglocation</param-name> <param-value>/web-inf/applicationcontext.xml</param-value> </context-param> <listener> <listenerclass>org.springframework.web.context.contextloaderlistener </listener-class> </listener> Baixe do link abaixo os arquivos de configuração: service-config.xml, web.xml, applicationcontext.xml e classe SpringFactory. www.hightechcursos.com.br/downloads/cjwebflex/configuracao_spring_1.zip <bean name="usuarioservice" class="br.com.hightechcursos.service.usuarioservice" /> Persistência dos Dados com JPA e Hibernate
Facets do JPA Vamos trabalhar neste projeto com o padrão JPA (Java Persistence API) Clicando com o direito do mouse no projeto digite Facets para adicionarmos JPA. Criando a classe de Entidade Usuário
package br.com.hightechcursos.entities; import javax.persistence.entity; import javax.persistence.generatedvalue; import javax.persistence.generationtype; import javax.persistence.id; import javax.persistence.sequencegenerator; @Entity public class Usuario { @Id @SequenceGenerator (name = "SEQ_USUARIO", sequencename = "SEQ_USUARIO",allocationSize=1,initialValue=1) @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="SEQ_ USUARIO") private Integer id; private String nome; private String login; private String senha; //GETTERS AND SETTERS AQUI Mensagem de Erro comum: Class "Usuario" is mapped, but is not included in any persistence unit Resolva Sincronizando a lista
Conhecendo o arquivo de persistence.xml <?xml version="1.0" encoding="utf-8"?> <persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xsi:schemalocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"> <persistence-unit name="cjweb_flex"> <class>br.com.hightechcursos.entities.usuario</class> </persistence-unit> </persistence>
Configurando o Hibernate no Persistence.xml <?xml version="1.0" encoding="utf-8"?> <persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xsi:schemalocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"> <persistence-unit name="cjweb_flex"> <!-- Definindo Hibernate Como Provider --> <provider>org.hibernate.ejb.hibernatepersistence</provider> <class>br.com.hightechcursos.entities.usuario</class> <!-- Definindo as propriedades do Hibernate --> <properties> <property name="hibernate.connection.url" value="jdbc:postgresql://localhost:5432/cjwebflex_db" /> <property name="hibernate.connection.driver_class" value="org.postgresql.driver" /> <property name="hibernate.connection.username" value="postgres" /> <property name="hibernate.connection.password" value="postgres" /> <property name="hibernate.show_sql" value="true" /> <property name="hibernate.format_sql" value="true" /> <property name="hibernate.hbm2ddl.auto" value="update" /> </properties> </persistence-unit> </persistence> Problema na integração do JPA com Spring comum ao iniciar o tomcat : Caused by: java.lang.illegalargumentexception: No persistence unit with name 'default' found Substitua a unidade de persistência para: <persistence-unit name="default">
Startando o Tomcat Verifique se a tabela no banco de dados foi criado automaticamente. Criando um (DAO -DATA ACCESS OBJECT)
Utilizaremos o padrão DAO para este exemplo. O objeto de acesso a dados fará a persistência de nossas entidades no banco de dados. Todos os métodos pertinentes a consultas e transações no banco será implementados nesta classe. classe UsuárioDAO package br.com.hightechcursos.dao; import javax.persistence.entitymanager; import javax.persistence.persistencecontext; import org.springframework.stereotype.repository; import org.springframework.transaction.annotation.transactional; import br.com.hightechcursos.entities.usuario; @Repository public class UsuarioDAO { @PersistenceContext EntityManager entitymanager; @Transactional public void cadastrar(usuario usuario){ entitymanager.persist(usuario);
Adicionando o UsuarioDAO contexto do Spring <bean name="usuariodao" class="br.com.hightechcursos.dao.usuariodao" /> Classe DAO com os métodos básicos de CRUD (Create, Retrieve, Update, Delete) package br.com.hightechcursos.dao; import java.util.list; import javax.persistence.entitymanager; import javax.persistence.persistencecontext; import javax.persistence.query; import org.springframework.stereotype.repository; import org.springframework.transaction.annotation.transactional; import br.com.hightechcursos.entities.usuario; @Repository public class UsuarioDAO { @PersistenceContext EntityManager em; @Transactional public Usuario salvar(usuario usuario){ //Hibernate //Insert into Usuario... //Update usuario set... return em.merge(usuario); @Transactional public void excluir(usuario usuario){ usuario = buscaporid(usuario.getid()); em.remove(usuario); @Transactional public Usuario buscaporid(integer id){ //Selec * from usuario where id=? return em.find(usuario.class, id); @SuppressWarnings("unchecked") public List<Usuario> buscatodos(){ StringBuffer consulta = new StringBuffer(); consulta.append("select u FROM Usuario u "); //Objeto de Consulta Query query = em.createquery(consulta.tostring());
return (List<Usuario>) query.getresultlist(); Criando a classe de teste do UsuarioDAO package br.com.hightechcursos.test; import org.junit.test; import org.junit.runner.runwith; import org.springframework.beans.factory.annotation.autowired; import org.springframework.test.annotation.rollback; import org.springframework.test.context.contextconfiguration; import org.springframework.test.context.junit38.abstractjunit38springcontextt ests; import org.springframework.test.context.junit4.springjunit4classrunner; import br.com.hightechcursos.dao.usuariodao; import br.com.hightechcursos.entities.usuario; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = { "file:webcontent/web- INF/applicationContext.xml" ) public class TestUsuarioDAO extends AbstractJUnit38SpringContextTests { @Autowired UsuarioDAO usuariodao; //@Test @Rollback(value=true) public void testsalvar(){ Usuario usu = new Usuario(); usu.setnome("jao da Lua"); usu.setlogin("jao"); usu.setsenha("jlua123"); usu = usuariodao.salvar(usu); asserttrue(usu.getid()!=null); @Test public void testbuscarporid(){ Usuario usu = usuariodao.buscaporid(1); assertnotnull(usu);
//@Test public void testexcluir(){ Usuario usuario = new Usuario(); usuario.setid(1); usuariodao.excluir(usuario); asserttrue(true); Criando a Classe UsuarioService Nesta classe vamos colocar os métodos de serviço que serão executados pela tela do cliente. package br.com.hightechcursos.service; import org.springframework.beans.factory.annotation.autowired; import org.springframework.stereotype.service; import br.com.hightechcursos.dao.usuariodao; import br.com.hightechcursos.entities.usuario; @Service(value="usuarioService") public class UsuarioService { @Autowired private UsuarioDAO usuariodao; public void salvar(usuario usuario){ usuariodao.salvar(usuario); No Projeto FLEX. Criando a classe Usuário package br.com.hightechcursos.entities{
[RemoteClass(alias="br.com.hightechcursos.entities.Usuario") ] [Bindable] public class Usuario { public var id:*; public var nome:string; public var login:string; public var senha:string; Criando uma tela de Cadastro
Código Inicial <?xml version="1.0" encoding="utf-8"?> <s:titlewindow xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark" xmlns:mx="library://ns.adobe.com/flex/mx" width="400" height="300"> <s:layout> <s:verticallayout/> </s:layout> <fx:declarations> <!-- Place non-visual elements (e.g., services, value objects) here --> </fx:declarations> </s:titlewindow> Tela Index.mxml Fazendo um chamada da tela através de um botão na aplicação principal <?xml version="1.0" encoding="utf-8"?> <s:application xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark"
xmlns:mx="library://ns.adobe.com/flex/mx" minwidth="955" minheight="600"> <fx:script> <![CDATA[ import br.com.hightechcursos.window.usuariowindow; import mx.controls.alert; import mx.managers.popupmanager; import mx.rpc.events.faultevent; import mx.rpc.events.resultevent; import mx.rpc.remoting.remoteobject; protected function button1_clickhandler(event:mouseevent):void { var usuariowindow:usuariowindow = new UsuarioWindow(); PopUpManager.addPopUp(usuarioWindow,this,true); PopUpManager.centerPopUp(usuarioWindow); ]]> </fx:script> <fx:declarations> <!-- Place non-visual elements (e.g., services, value objects) here --> </fx:declarations> <s:label x="68" y="44" text="seja Bem Vindo!"/> <s:button x="68" y="78" label="cadastrar Usuario" click="button1_clickhandler(event)"/> </s:application> Chamando no Browser http://localhost:8080/cjwebflex_java/index.html
Tela UsuarioWindow.mxml Componentes do Formulário Trabalhando com os componentes. <s:form>, <s:panel>, <s:vgroup>, <s:form>, <s:formitem>, <s:textinput>, <s:controlbarcontent> e <s:button> <?xml version="1.0" encoding="utf-8"?> <s:titlewindow xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark" xmlns:mx="library://ns.adobe.com/flex/mx" width="400" height="300"> <s:layout> <s:verticallayout/> </s:layout> <fx:declarations> <!-- Place non-visual elements (e.g., services, value objects) here --> </fx:declarations> <s:vgroup width="100%" height="100%" horizontalalign="center" verticalalign="middle"> <s:panel> <s:form> <s:formitem label="id"> <s:textinput id="txtid"> </s:textinput> </s:formitem> <s:formitem label="nome"> <s:textinput id="txtnome" text="@{usuario.nome"> </s:textinput> </s:formitem> <s:formitem label="login"> <s:textinput id="txtlogin" text="@{usuario.login"> </s:textinput> </s:formitem>
<s:formitem label="senha"> <s:textinput id="txtsenha" displayaspassword="true" text="{usuario.senha"> </s:textinput> </s:formitem> </s:form> <s:controlbarcontent> <s:button label="salvar" id="btnsalvar" click="btnsalvar_clickhandler(event)"> </s:button> </s:controlbarcontent> </s:panel> </s:vgroup> </s:titlewindow> Action Script Programando o Click no botão Salvar. <fx:script> <![CDATA[ import br.com.hightechcursos.entities.usuario; import mx.controls.alert; import mx.rpc.events.faultevent; import mx.rpc.events.resultevent; import mx.rpc.remoting.mxml.remoteobject; [Bindable] private var usuario:usuario = new Usuario; protected function btnsalvar_clickhandler(event:mouseevent):void { var usuarioservice:remoteobject = new RemoteObject("usuarioService"); usuarioservice.salvar(usuario); usuarioservice.addeventlistener(resultevent.result,aosalvar); usuarioservice.addeventlistener(faultevent.fault,aofalhar); public function aosalvar(event:resultevent):void{
Alert.show("Salvo com sucesso","alerta"); public function aofalhar(event:faultevent):void{ Alert.show("Falhou:"+event,"Erro"); ]]> </fx:script> Evento para Carregar o GRID <s:titlewindow xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark" xmlns:mx="library://ns.adobe.com/flex/mx" width="600" height="100%" creationcomplete="carregargrid()"> Declarando um ArrayCollection para armazenar a Lista de Usuários [Bindable] private var listausuarios:arraycollection; Método para Carregar o GRID protected function carregargrid():void { //1)Requisicao para o Service var usuarioservice:remoteobject = new RemoteObject("usuarioService"); usuarioservice.buscatodos(); d); usuarioservice.addeventlistener(resultevent.result,aocarregargri usuarioservice.addeventlistener(faultevent.fault,function (e:faultevent):void{ Alert.show("Não foi Possível Carregar os Usuários:"+e,""); );
Adicionando um GRID para Listar os usuários <mx:datagrid id="dgusuarios" width="332" height="200" dataprovider="{listausuarios"> <mx:columns> <mx:datagridcolumn headertext="id" datafield="id"/> <mx:datagridcolumn headertext="nome" datafield="nome"/> <mx:datagridcolumn headertext="login" datafield="login"/> <mx:datagridcolumn headertext="senha" datafield="senha"/> </mx:columns> </mx:datagrid> Tela de Cadastro de Usuário Completa com GRID <?xml version="1.0" encoding="utf-8"?> <s:titlewindow xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark" xmlns:mx="library://ns.adobe.com/flex/mx" width="600" height="100%" creationcomplete="carregargrid()"> <s:layout> <s:verticallayout/> </s:layout> <fx:script> <![CDATA[ import br.com.hightechcursos.entities.usuario; import mx.collections.arraycollection; import mx.controls.alert; import mx.events.flexevent; import mx.rpc.events.faultevent; import mx.rpc.events.resultevent; import mx.rpc.remoting.remoteobject; [Bindable] private var usuario:usuario = new Usuario; [Bindable] private var listausuarios:arraycollection; protected function btnsalvar_clickhandler(event:mouseevent):void { /* var usu: Usuario = new Usuario(); usu.nome = txtnome.text; usu.login= txtlogin.text; usu.senha=txtsenha.text; */
var usuarioservice:remoteobject = new RemoteObject("usuarioService"); usuarioservice.salvar(usuario); usuarioservice.addeventlistener(resultevent.result,aosalvar); usuarioservice.addeventlistener(faultevent.fault,aofalhar); public function aosalvar(event:resultevent):void{ Alert.show("Salvo com sucesso","alerta"); carregargrid(); public function aofalhar(event:faultevent):void{ Alert.show("Falhou:"+event,"Erro"); protected function carregargrid():void { //1)Requisicao para o Service var usuarioservice:remoteobject = new RemoteObject("usuarioService"); usuarioservice.buscatodos(); d); usuarioservice.addeventlistener(resultevent.result,aocarregargri usuarioservice.addeventlistener(faultevent.fault,function (e:faultevent):void{ Alert.show("Não foi Possível Carregar os Usuários:"+e,""); ); private function aocarregargrid(event:resultevent):void{ listausuarios = event.result as ArrayCollection; ]]> </fx:script> <fx:declarations> <!-- Place non-visual elements (e.g., services, value objects) here --> </fx:declarations>
<s:hgroup width="100%" height="100%"> <s:panel width="250" height="100%"> text="@{usuario.nome"> <s:form width="250"> <s:formitem label="id"> <s:textinput id="txtid"> </s:textinput> </s:formitem> <s:formitem label="nome"> <s:textinput id="txtnome" </s:textinput> </s:formitem> <s:formitem label="login"> <s:textinput id="txtlogin" text="@{usuario.login"> </s:textinput> </s:formitem> <s:formitem label="senha"> <s:textinput id="txtsenha" displayaspassword="true" text="@{usuario.senha"> </s:form> </s:textinput> </s:formitem> <s:controlbarcontent> <s:button label="salvar" id="btnsalvar" click="btnsalvar_clickhandler(event)"> </s:button> </s:controlbarcontent> </s:panel> <mx:datagrid id="dgusuarios" width="332" height="200" dataprovider="{listausuarios"> <mx:columns> datafield="id"/> datafield="nome"/> datafield="login"/> datafield="senha"/> <mx:datagridcolumn headertext="id" <mx:datagridcolumn headertext="nome" <mx:datagridcolumn headertext="login" <mx:datagridcolumn headertext="senha"
</s:titlewindow> </s:hgroup> </mx:columns> </mx:datagrid> Layout Até o momento Referencias Flex http://help.adobe.com/en_us/flex/4.0/accessingdata/wsbde04e3d3e6474c46c45e7b4120d4 13dc14-8000.html http://en.wikipedia.org/wiki/real_time_messaging_protocol AMF : http://download.macromedia.com/pub/labs/amf/amf3_spec_121207.pdf Integração Spring com BlazeDS http://static.springsource.org/spring-flex/docs/1.0.x/reference/html/index.html