Java
Integração Flex 4 & Spring 3 com Spring BlazeDS [Parte I]
22/06/10
No final de 2008, a comunidade Spring começou a trabalhar no projeto de integração Spring BlazeDS para adicionar suporte ao Flex no desenvolvimento de aplicações com Java e Spring.
O BlazeDS cria instâncias de objetos do lado do servidor Java e usa os para responder aos pedidos do remote object. A integração com Spring BlazeDS permite que você configure o Spring beans como um destino BlazeDS para utilização de remote objects no Flex.
Ferramentas necessárias:
• Eclipse 3.5 (Galileo) para Java EE Developers – http://www.eclipse.org/downloads/
ou, SpringSource Tool Suite : http://www.springsource.com/products/springsource-tool-suite-download/
• Flash Builder 4, plugin para instalar na distribuição do eclipse 3.5 - http://www.adobe.com/go/try_fashbuilder
• Tomcat 6: http://tomcat.apache.org/
• BlazeDS 4 (Binary Distribution): http://opensource.adobe.com/wiki/display/blazeds/BlazeDS/
• Spring Framework 3.0.2 (vanilla release): http://www.springsource.org/download
• Spring BlazeDS Integration 1.0.3 (vanilla release): http://www.springsource.org/spring-flex
• AOP Alliance 1.0: http://sourceforge.net/projects/aopalliance/files/
• backport-util-concurrent 3.1: http://sourceforge.net/projects/backport-jsr166/files/backport-jsr166/
• cglib 2.2 http://sourceforge.net/projects/cglib/files/
• asm 3.2 http://forge.ow2.org/projects/asm/
Como fazer:
1) Primeiro instale o Eclipse e, em seguida, instalar o Flash Builder 4 plugin para a distribuição Eclipse que você acabou de instalar.
2) No Eclipse crie um servidor:
1. File > New > Other
2. Selecione Server > Server
3. Clique em Avançar
4. Selecione> Apache Tomcat v6.0 Server
5. Clique em Avançar
6. Especifique o local onde o Tomcat está instalado e selecione o JRE
7. Clique em Concluir
3) Criar um “Dynamic Web project”
No Eclipse, importe o arquivo blazeds.war para criar o projeto:
1. Escolha File > Import
2. Selecione WAR file. Especifique o local do arquivo blazeds.war.
Dê um nome para o projecto web, flexcomspring
3. Clique em Concluir
Primeiro remova o arquivo xalan.jar do diretório: WebContent/WEB-INF/lib. Em seguida, vá em propriedades do projeto. Selecione Java Build Path e em seguida, clique na guia Source. Defina o
diretório de saída: flexcomspring/WebContent/WEB-INF/classes
Isso faz com que todas as classes Java criadas no projeto serem implantadas na aplicação web.
No WebContent/WEB-INF/flex atualizar o services-config.xml para o seguinte código:
<?xml version="1.0" encoding="UTF-8"?> <services-config> <channels> <channel-definition id="my-amf" class="mx.messaging.channels.AMFChannel"> <endpoint url="http://{server.name}:{server.port}/{context.root}/messagebroker/amf" class="flex.messaging.endpoints.AMFEndpoint" /> </channel-definition> <channel-definition id="my-streaming-amf" class="mx.messaging.channels.StreamingAMFChannel"> <endpoint url="http://{server.name}:{server.port}/{context.root}/messagebroker/streamingamf" class="flex.messaging.endpoints.StreamingAMFEndpoint" /> </channel-definition> <channel-definition id="my-polling-amf" class="mx.messaging.channels.AMFChannel"> <endpoint url="http://{server.name}:{server.port}/{context.root}/messagebroker/amfpolling" class="flex.messaging.endpoints.AMFEndpoint" /> </channel-definition> </channels> </services-config>
Lista 1 – services-config.xml
4) Em seguida, você precisa adicionar as dependências necessárias para a aplicação web. Copie todas as bibliotecas do Spring Framework / arquivos .JAR (localizado na pasta dist) para o seguinte diretório: WebContent/WEB-INF/lib.
Também copie as bibliotecas do Spring BlazeDS Integration (localizado na pasta dist ) para a pasta lib. Faça o mesmo para aopalliance.jar, backport-util- concurrent.jar, cglib-2.2.jar, asm-3.2.jar.
5) Para configurar o servidor para o Flex Remoting, primeiro editar o web.xml em: WebContent/WEB-INF. Substituir seu conteúdo para:
<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation=" http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5"> <listener> <listener-class> org.springframework.web.context.ContextLoaderListener </listener-class> </listener> <listener> <listener-class>flex.messaging.HttpFlexSession</listener-class> </listener> <servlet> <servlet-name>flexcomspring</servlet-name> <servlet-class> org.springframework.web.servlet.DispatcherServlet </servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value></param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>flexcomspring</servlet-name> <url-pattern>/messagebroker/*</url-pattern> </servlet-mapping> </web-app>
Lista 2 – web.xml
O Spring irá agora tratar os pedidos para o messagebroker / url.
6) Agora configure o Spring criando um arquivo applicationContext.xml em WebContent/WEB-INF com o seguinte código:
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:flex="http://www.springframework.org/schema/flex" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/flex http://www.springframework.org/schema/flex/spring-flex-1.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> <flex:message-broker> <flex:remoting-service default-channels="my-amf" /> </flex:message-broker> <context:component-scan base-package="com.luis.flex" /> </beans>
Lista 3 – applicationContext.xml
Na lista 3 cria-se o Flex message-broker, que permitirá ao Flex habilitar o remoting-service, utilizando o canal my-amf. O component-scan vai encontrar classes no pacote “com.luis.flex” que foram anotados para Remoting.
7) Agora crie uma classe Java simples que será exposta através do AMF channel para uma aplicação Flex. Na pasta src criar uma nova classe no pacote criado anteriormente com o nome “OlaMundoService”. Definir com o seguinte código em OlaMundoService.java para:
package com.luis.flex; import org.springframework.flex.remoting.RemotingDestination; import org.springframework.flex.remoting.RemotingInclude; import org.springframework.stereotype.Service; @Service @RemotingDestination public class OlaMundoService { @RemotingInclude public String olaUser(String name) { return "Olá, " + name; } }
Lista 4 – OlaMundoService.java
Na classe OlaMundoService você vai notar duas anotações. O @Service annotation diz ao Spring qual classe é um serviço e @RemotingDestination expõe a classe como um remoting endpoint para o Flex. Esta classe também contém um único método chamado olaUser, que simplesmente recebe uma string. Por padrão, todos os métodos públicos de uma classe estão disponíveis para remoting. Você pode ocultar um método público de ser exposto como um endpoint remoto usando o @RemotingExclude.
8 ) Agora crie uma aplicação Flex que vai chamar o método olaUser em OlaMundoService. Para começar a construir a aplicação Flex, basta criar um novo projeto Flex. No assistente para Novo projeto Flex de o nome: “olaMundo”, selecione Web como o tipo de aplicação, e definir o Flex SDK versão para Flex 4.0 (geralmente o padrão). Também escolha J2EE como o tipo de servidor de aplicativos, habilite Use Remote Object Access Service, e selecione BlazeDS. Certifique-se que Create Combined Java/Flex Project Using WTP não está marcada e clique em Avançar. Agora insira as informações para o projeto flexcomspring. A pasta raiz é a pasta WebContent no projeto flexcomspring. A URL raiz deve ser http://localhost:8080/flexcomspring /. A raiz de contexto deve ser /flexcomspring.
Clique em Concluir para criar o projeto. Agora você deve ver o código da aplicação. Substitua o código pelo seguinte:
<?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"> <fx:Declarations> <s:RemoteObject id="ro" destination="olaMundoService" endpoint="http://localhost:8080/flexcomspring/messagebroker/amf"/> </fx:Declarations> <s:layout><s:VerticalLayout/></s:layout> <s:TextInput id="txt"/> <s:Button label="Enviar" click="ro.olaUser(txt.text)"/> <s:Label id="lbl" text="{ro.olaUser.lastResult}"/> </s:Application>
Lista 5 – olaMundo.mxml
Agora, execute a aplicação olaMundo (uma maneira é clicar com o botão direito no olaMundo. mxml, selecione Executar como e, em seguida, selecione Web Application). Digite seu nome no TextInput Clique no botão Enviar. Isto irá iniciar um pedido Flex Remoting para o servidor Tomcat chamando o Spring DispatcherServlet, que então procura o serviço OlaMundoService. Este destino é automaticamente mapeado para o Spring OlaMundoService Bean. Em seguida, o método olaUser será chamado no bean, passando para a chamada do RemoteObject no cliente. O método retorna uma nova String, que é então serializado em AMF, inserido no corpo da resposta HTTP, e enviados de volta para o cliente. Você acabou de concluir uma aplicação web com Flex para comunicar através de aplicações com Spring BlazeDS usando o Spring BlazeDS Integration!
Popularity: 100% [?]
Como iniciar Programação em Java
23/04/10
O Java é uma linguagem de programação “object-oriented” que surgiu no início dos anos 90, criada pela Sun. Esta é uma Linguagem de Programação muito popular no mundo da programação como podemos ver pela tabela seguinte:
Principais Vantagens
Não basta dizer que Java é bom só porque sim, quanto a mim, eis as principais “virtudes” do Java:
- Object-Oriented;
- Multi-Plataforma (“write once, run anywhere” – apesar de às vezes não ser bem assim);
- Garbage Collector;
- Sintaxe muito user-friendly e, quanto a mim, muito intuitiva mesmo para novatos;
- Programas muito bem estruturados devido à organização por packages e classes e, devido à capacidade de hierarquizar estas últimas;
- Bom mecanismo para apanhar e tratar excepções;
- Extensa comunidade de programadores o que facilita a resolução de problemas;
- Extensa API com packages para tudo e mais alguma coisa (Redes, Criptografia, Web-Services, Applets, Manuseamento de ficheiros, e muito muito mais).
O que eu preciso para programar em Java no meu PC
Para começar a programar em Java não precisa de muita coisa. Antes de mais precisa de fazer o download do JDK (atenção que somente o JRE – Java Runtime Environment – não serve) – Java Development Kit. Poderá fazê-lo do seguinte site: http://java.sun.com/products/archive/.
Em seguida, aconselho a instalação de um IDE – Integrated Development Environment – para desenvolver em Java. Para iniciar talvez um mais simples como o Notepad++ ou o GEdit seja o indicado, no entanto, se pretender avançar a fundo na programação em Java, deverá recorrer a uma ferramenta mais completa pois estas ajudam (e muito!) a aumentar a produtividade. Recomendo, pela minha experiência, o Netbeans (da Sun tal como o Java) ou, o meu preferido, Eclipse. Estes programas poderão ter uma curva de aprendizagem não muito acentuada inicialmente mas, o tempo investido nos mesmos acabará por compensar a longo prazo.
Estrutura e Sintaxe
Definição e Diferenças entre Classe e Objeto
Para programar em Java é fundamental perceber o que são classes e objetos. Sendo esta uma linguagem object-oriented, o que o programador faz é nada mais do que definir os objetos e as mensagens com que será possível comunicar com os primeiros.
Ou seja, poderemos considerar um objeto como que uma caixa enquanto que os métodos do objeto são os botões dessa caixa que ao “pressionar” iniciam ações dentro da mesma. Existem botões que poderão não estar disponíveis para carregar do exterior directamente pelo utilizador, só são pressionados pelas ações iniciadas internamente quando o utilizador carrega um dos botões a que tem acesso.
No caso da imagem anterior, o utilizador definiu o objeto tendo no seu interior os métodos A, B, C, D e E. Definiu que o utilizador teria acesso aos métodos A, B e C e, que ao “pressionar o botão A” este internamente accionaria o “botão D” e que, ao pressionar os “botões” B ou C, este accionam o “botão” E. Não é necessário haver acções internas interligadas, poderia-se definir um “botão F” possível de aceder do exterior da “caixa” que quando o utilizador pressiona-se limitava-se a realizar as suas acções.
Quanto às diferenças, se me perguntarem “O que entendes entre classe e objeto? Mas quais são as diferenças?”, eu diria que classe é um modelo ou especificação que define um tipo de objeto enquanto que o objeto em si é uma ferramenta, uma forma de comunicação entre o utilizador e o seu programa, ferramenta essa que apresenta um conjunto de variáveis e métodos definidos na classe. A comunicação é feita enviando mensagens para os objetos. Essas mensagens não são nada mais do que “chamar” os métodos que o objeto disponibiliza para o exterior.
Como definir uma classe
Uma classe em Java obedece – generalizando obviamente – à estrutura seguinte.
A primeira declaração é sempre o package onde a classe se insere (caso esteja dentro de algum obviamente). Em seguida são adicionados os imports de outras packages (bibliotecas) das quais pretendemos utilizar alguns objetos e respectivos métodos, na classe que estamos a definir.
O nome da classe é sempre igual ao nome do ficheiro onde ela está a ser criada (ou seja, o ficheiro teria o nome MinhaClasse.java).
O método com o mesmo nome da classe é nada mais do que o construtor desta. O construtor de uma classe é um método (função) especial que não retorna qualquer valor e que, é chamado sempre que se cria um objeto daquele tipo. Tudo o que estiver dentro do construtor é executado aquando da criação do objeto. Não é necessário definir um construtor uma vez que o Java assume um vazio por omissão. Ao invés, é possível definir vários construtores diferentes, ou seja, construtores que contenham diferentes argumentos de entrada.
E, para finalizar, declaramos e definimos todos os métodos da nossa classe. Caso este seja um ficheiro que será executado, deverá conter um método “especial”, o método main, que é declarado da forma indicada.
Comentários
Para comentar uma linha individualmente utiliza-se ‘//’
Para comentar um bloco utiliza-se ‘/* texto a comentar */’.
Modificadores de Acesso
Os modificadores de acesso são palavras reservadas que, quando colocados na declaração de classes, métodos ou variáveis, modificam/limitam o modo como se pode aceder aos mesmos.
Existem os seguintes modificadores de acesso:
- private – só será possível aceder dentro da classe onde o método/variável foi criado(a);
- protected – acessível dentro do package onde foi feita a declaração através de uma subclasse;
- public – sem qualquer restrição de acesso;
- static – a declaração de um método ou de uma variável static serve para:
- aquando a declaração de uma variável dentro de uma classe, para que todas as instâncias de objetos dessa classe possam aceder a essa variável como sendo comum entre todas elas. Ou seja, quando alteram a variável numa das instâncias criadas, o seu valor será alterado em todas as instâncias daquele mesmo objeto;
- quando utilizado na definição de um método para que este seja utilizado apenas na sua classe e não nas instâncias da mesma.
Juntamente com estes últimos, podemos ainda utilizar dois outros modificador: abstract e final.
O abstract quando se aplica a métodos, serve para indicar que o método em causa deverá ser definido nas suas subclasses (classes que herdem a classe onde o método foi definido). No caso das classes, indica que a classe não está completamente definida e como tal não pode ser instanciada (utilizado, por exemplo, em Interfaces).
Já o final, utiliza-se para declarar constantes, ou seja, valores que não são alterados durante a execução de um programa.
Declaração de variáveis
Vamos agora ver alguns aspectos relacionados com a síntaxe da linguagem. A declaração das variáveis obedece à seguinte forma:
Ou seja,
Nos objetos que são estruturas de dados pode-se (deve-se – sempre que seja possível dentro do contexto) definir a seguir ao tipo do objeto o tipo de dados que o objeto recebe entre . Para qualquer declaração de um objeto, deverá inicializar-se (não é obrigatório mas terá de ser feito antes de ser utilizado) o mesmo recorrendo ao método especial new().
Declarar e Utilizar Classes e Métodos
O que difere um método de outro em Java é a sua assinatura (nome, valor de retorno e parâmetros de entrada. Como tal, um método poderá ser definido da seguinte forma:
É possível utilizar-se um método de uma classe chamando o mesmo dentro dessa mesma classe se este for static ou, declarando um objeto do tipo ClasseDoMetodoAChamar e chamar o dito método (A.B – chama o método B sobre o objeto A, ou seja, o objeto A disponibiliza o método B para para ser invocado e nós invocamo-lo utilizando a notação objeto(ponto)método ).
Extends e Implements
Quando uma classe faz extends de uma outra classe, está a herdar todos os métodos e variáveis definidos na classe que foram criados nessa classe. No entanto, se essa última classe definir uma variável/método que já exista na classe herdada, será feito um override, ou seja, ignora a criação prévia na “classe pai” (o termo é superclasse). Vejam o exemplo seguinte:
O Java não suporta herança múltipla, ou seja, apenas pode “extender” uma classe. No entanto, pode implementar (implements) várias Interfaces como vamos ver.
Uma interface serve para “obrigar” uma classe a ter uma determinada estrutura que a implemente. Nesta apenas estão definidas as assinaturas dos métodos.
Nested Classes
São classes definidas dentro de classes e que serão utilizadas no contexto destas últimas.
Exemplos de Código
Mostro agora alguns exemplos de código Java:
Hello World
Compilar e executar os nossos programas
Para correr os programas que desenvolvemos, temos de primeiro compilar o ficheiro .java por nós criado e depois correr o executável gerado. Para tal:
Como compilar o programa?
% javac NomeFicheiro.java
Como executar o programa?
% java NomeFicheiro
Notas:
- O nome do ficheiro contendo código tem de ter o nome da classe executável mais a extensão .java
- A compilação da classe dá origem a um ficheiro com o mesmo nome, mas com a extensão .class
- Para executar, chama-se o nome da classe e não o nome do ficheiro (ex: java Hello e não java Hello.class)
Notas Finais
Nos próximos tutoriais irei dar a conhecer alguns aspectos mais “avançados” não mencionados neste tutorial. Espero que tenham gostado e que seja útil a alguém.
Links Úteis:
Popularity: 22% [?]
Agendamento de tarefas com Quartz
26/02/10
<bean id="target" class="com.luismessias.facade.GeralFacadeImplements"/> <bean id="task" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"> <property name="targetObject" ref="target"/> <property name="targetMethod" value="importarExcel"/> </bean> <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail" ref="task"/> <!-- tarefa agendada para as 12horas --> <property name="cronExpression" value="0 0 12 * * ?" /> </bean> <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <property name="triggers"> <list> <ref bean="cronTrigger"/> </list> </property> </bean>
Popularity: 19% [?]


















