logo
  • Home
  • Acerca
  • Autores
  • Faq
  • Rede
  Twitter   Feed-me! RSS!
Jun 6

Repositórios Com Spring JPA

Escrito por Ebercom em .NET, 1, 2.0, 2009, 4, action, app, AR, auto, BI, busca, buscas, C#, class, classe, CRUD, dados, Diversos, Documentação, dynamic, email, Flex, geo, git, gmail, html, IE, if, image, int, interface, Java, JPA, map, mg, O, on, procura, rails, reference, RIA, Ria’s Geral, S+S, Spring, string, tag, TAT, Tecnologia, UI, XML, XP @ 06 6th, 2011 | via http://www.flexdev.com.br/home | Sem comentários
Ebercom
? 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á.

Escrevendo o post Java + MongoDB + Spring Data descobri o Spring Data JPA
e fiquei surpreso em descobrir algumas features como a criação de repositórios e consultas dinâmicas.
Neste Post vou falar um pouco sobre o Spring Data JPA e como ele pode lhe proporcionar uma maneira rápida e elegante de implementar seus repositórios.

O Spring Data JPA tem como principal objetivo facilitar a implementação das camadas de acesso a dados.
O Spring fica responsável pela implementação dos repositórios e oferece algumas funcionalidades sofisticadas e comuns na maioria dos CRUDs baseado na entidade que esta sendo gerenciada.

Nessa aplicação vou usar as entidades Contact, Phone, e o repositório ContactRepository.

As entidades são bem simples, é anotadas com o mapeamento de seus atributos e relacionamentos.
Contact.java

@Entity
@Table(name="phones")
public class Phone 
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  private Long id;

  @ManyToOne
  @JoinColumn(name="id_contact")
  private Contact contact;
  //getter and setter methods 
  ...

Phone.java

@Entity
@Table(name="contacts")
public class Contact 

   @Id
   @Column(name="id_contact")
   @GeneratedValue(strategy = GenerationType.AUTO)
   private Long id;

   @Column(name="name")
   private String name;

   @Column(name="email",unique=true)
   private String email;

   @OneToMany(mappedBy="contact",cascade=CascadeType.ALL, fetch=FetchType.LAZY)
   @Fetch(FetchMode.JOIN)
   @private Set phones = new HashSet();

  //getter and setter methods 
  ...

ContactRepository.java

public interface ContactRepository extends JpaRepository 

    public Contact findByEmail(String email);

Até aqui nada de novo, porem agora como a “mágica” do Spring JPA ..rsrs

A interface do repositório estende JpaRepository, essa interface tem alguns métodos comuns como findAll, findOne, save, delete, etc…
Normalmente teríamos que implementar essa interface criando uma classe ContactRepositoryImpl e registra-la como um bean do spring
para que então possamos utilizar o repositório.

Com o Spring JPA não é necessário escrever essa implementação :) ..
Não é magia meus amigos, é tecnologia !!!…rsrs

O Spring JPA vai procurar por interfaces de repositórios que estendam a interface JpaRepository,
e então criar uma implementação para a interface e registra-la como um bean.

Para isso so é necessário apenas adicionar a tag jpa:repositories no contexto do spring,
com isso o Spring sabe onde procurar os repositórios que ele teve implementar.

applicationContext.xml

// Declaração dos Beans, TransactionManager, DataSource, etc...

<jpa:repositories base-package="br.com.flexria.springjpa.repository" />

Com isso a implementação do repositório já esta pronta para ser injetada é utilizada na aplicação.

@Autowired
ContactRepository repository;

repository.save(contact);

repository.delete(contact);

List list = contactRepository.findAll();

Isso por si so ja é algo incrível so que o Spring Data JPA vai alem.

Algo que ja é comum no Rails, são os Dynamic attribute-based finders que é a possibilidade de realizar buscas dinâmica baseadas nos atributos do objeto
Em rails temos :

//"SQL : SELECT * FROM contacts WHERE email = 'fabio.bat.silva@gmail.com'"

Contact.where(:email =&gt;"fabio.bat.silva@gmail.com")

//Usando Dynamic attribute-based finders
Contact.find_by_email "fabio.bat.silva@gmail.com"

É exatamente isso que o Spring Data JPA faz,
além de implementar do repositório com ele é possível utilizar buscas dinâmica baseadas nos atributos do objeto.

   // HQL : select c from Contact c where c.email = ?1
    public Contact findByEmail(String email);

   // HQL : select c from Contact c where c.name like ?1
    public List findBynameLike(String email);

Com base em algumas palavras chaves varias consultas podem ser feitas :

Keyword Sample JPQL snippet
1
And
1
findByLastnameAndFirstname
1
2
… where x.lastname = ?1 and<br />
                    x.firstname = ?2
1
Or
1
findByLastnameOrFirstname
1
2
… where x.lastname = ?1 or<br />
                    x.firstname = ?2
1
Between
1
findByStartDateBetween
1
2
… where x.startDate between 1? and<br />
                    ?2
1
LessThan
1
findByAgeLessThan
1
… where x.age < ?1
1
GreaterThan
1
findByAgeGreaterThan
1
… where x.age > ?1
1
IsNull
1
findByAgeIsNull
1
… where x.age is null
1
IsNotNull,NotNull
1
findByAge(Is)NotNull
1
… where x.age not null
1
Like
1
findByFirstnameLike
1
… where x.firstname like ?1
1
NotLike
1
findByFirstnameNotLike
1
… where x.firstname not like ?1
1
OrderBy
1
findByAgeOrderByLastnameDesc
1
2
… where x.age = ?1 order by<br />
                    x.lastname desc
1
Not
1
findByLastnameNot
1
… where x.lastname <> ?1

Repositórios dinâmicos, consultas dinâmicas, Buscas baseadas em NamedQuery ou anotações, etc..
com certeza tem muita coisa a ser explorada no Spring Data JPA, me surpreendi com a facilidade e agilidade.

Vale apena dar uma conferida na documentação do Spring Data JPA

E Para quem tiver o interesse deixei a app no git
https://github.com/FabioBatSilva/spring-data-jpa

Abraço e até a próxima….

Click aqui para ver o post Original
Fábio B. Silva
Fabio B. Silva
http://www.flexria.com.br

Mai 31

Java + MongoDB + Spring Data

Escrito por Ebercom em 1, 2.0, 2009, 4, 6, api, app, AR, auto, back, BI, C#, case, class, collection, configuração, dados, demo, email, exemplo, Flex, for, git, Hibernate, IE, if, int, interface, Java, JPA, lista, map, mg, O, on, Opinião, Outros, PHP, RIA, Ria’s Geral, S+S, Spring, string, super(), tag, TAT, Tecnologia, template, UI, XML @ 05 31st, 2011 | via http://www.flexdev.com.br/home | Sem comentários
Ebercom
? 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á.

A alguns dias escrevi um post sobre PHP + MongoDB e recebi um feedback muito positivo
então resolvi repetir a dose e mostrar um pouco da integração entre Java e MongoDB.

Na minha opinião essa é uma das principais vantagens do MongoDB em relação a outros bancos de dados NoSQL,
O MongoDB e extremamente fácil de se integrar com a maioria das linguagens.

Neste Post vou falar um pouco sobre o MongoDB e a integração com o java utilizando o Spring Data.
O MongoDB fornece o mongo-java-driver que atualmente esta na versão 2.6.X é uma API completa para acessar o MongoDB.
O Spring Data é um projeto recente, lançado em 2010, ele oferecer suporte a novas tecnologias não relacionais, suporte a extensões específicas a bancos de dados relacionais. Spring Data trabalha como uma camada intermediária entre seus POJOs e o MongoDB.

Nesse exemplo estou usando o maven para gerencias as dependências do projeto
Então alem das dependências habituais do projeto: Spring, JUnit e etc.. vamos precisar adiciona ao pow.xml as dependências do MongoDB e Spring Data

pow.xml

Feito isso as dependências do projeto estão configuradas e podemos partir para a configuração do spring.
A configuração é bem simples, nesse exemplo existem apenas 2 beans que configuram o MongoDB e Spring Data mongoTemplate e mongo

applicationContext.xml

O Spring Data oferece uma serie de anotações que permitem mapear o POJO de forma bem similar ao Hibernate/JPA
Contact.java

@Document(collection="contacts")
public class Contact 
    @Id
    private ObjectId id;
    private String name;
    private String email;

  //getter and setter methods 
  ...

E é através do mongoTemplate que vamos interagir com o MongoDB por exemplo :

@Autowired
MongoTemplate template;

// insere um novo registro		
template.insert("contacts", contact);

// insere/altera um registro
template.save("contacts", contact);

// remove um registro
template.remove(contact);

// lista todos os registros
List list = template.getCollection(collectionName, Contact.class);

Apesar do Spring Data suportar o JPA repository fiz uma implementação genérica para um repositório usando o Spring Data.

GenericRepositoryWithMongo.java – Repositório genérico

public abstract class GenericRepositoryWithMongo 

  @Autowired
  protected MongoTemplate template;
  protected Class targetClass;
  protected String collectionName;

  @SuppressWarnings("unchecked")
  public GenericRepositoryWithMongo() 
     this.targetClass = (Class) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
  

  @PostConstruct
  public void initCollection() 
    if(this.targetClass.isAnnotationPresent(Document.class))
      Document document   = this.targetClass.getAnnotation(Document.class);
      this.collectionName = document.collection();
    
    else
      this.collectionName = this.targetClass.getSimpleName().toLowerCase();
    
  }

  public List getCollection() 
    return template.getCollection(collectionName, targetClass);
  

  public void persist(T entity) 
    template.insert(collectionName, entity);
  

  public void merge(T entity) 
    template.save(collectionName, entity);
  

  public void remove(T entity) 
    template.remove(entity);
  

  public List findAll() 
    return getCollection();
  

  public long count() 
    return getCollection().size();
  
}

E então a interface do repositório e sua implementação

ContactRepository.java – Repositório de contatos

public interface ContactRepository 

    public Contact findByEmail(String email);

    public void persist(Contact entity);

    public void merge(Contact entity);

    public void remove(Contact entity);

    public List findAll();

ContactRepositoryImpl.java – Implementação do repositório de contatos

@Service("contactRepository")
@Repository
public class ContactRepositoryImpl extends GenericRepositoryWithMongo implements ContactRepository

	public Contact findByEmail(String email) 
	   Criteria criteria	 = Criteria.where("email").is(email);
	   Query query 	         = new Query(criteria);
	   return template.findOne(query, targetClass);
	
}

Realmente me surpreendi com a facilidade da integração usando o Spring Data
é um exemplo bem simples da integração porem mais da o caminho das pedras para quem esta se aventurando no mundo NoSQL.
Espero que seja util..

Para quem tiver o interesse deixei app no git
https://github.com/FabioBatSilva/spring-mongodb

Abraço e até a próxima….

Click aqui para ver o post Original
Fábio B. Silva
Fabio B. Silva
http://www.flexria.com.br

Mai 20

Desenvolvedores Flex / Java – Home Office

Escrito por Fabio da Silva em 1, 2.0, 3.5, 4, 6, Air, AR, BI, Blazeds, blog, Blogs, C#, Desenvolvedor, desenvolvedores, Flex, Flex 4, framework, Google, Hibernate, IE, int, Java, mg, mvc, O, Office, on, Ria’s Geral, Spring, Tech, Tecnologia, UI, Ved @ 05 20th, 2011 | via http://fabiophx.blogspot.com | Sem comentários
Fabio da Silva
? 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 »

A Integritas Tecnologia – Open Solutions está contratando 3 a 4 desenvolvedores Flex/Java, para trabalho em tempo integral, com horário flexível, para início em meados de Junho, via home office, na modalidade PJ.

Requisitos:
1) conhecimento de um framework Flex MVC, especialmente Cairgor
m 3
2) conhecimento do framework BlazeDS, para integração Flex/Java

3) Flex 4

4) Spring + Hibernate

Por favor, enviem currículo para: rh@integritas.com.br

Mai 5

Spring @Transactional Transações Java

Escrito por Felipe Borella em 1, action, apache, app, AR, back, Banco de Dados, class, control, dados, Desenvolvedor, Documentação, for, Java, O, on, Outros, Pessoal, problema, problemas, pt, Ria’s Geral, servidor, Spring, tag, TAT, UI, Ved @ 05 5th, 2011 | via http://www.fborella.com.br/blog/ | Sem comentários
Felipe Borella
? 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 »

E ai pessoal blza?
Uma coisa que as vezes eu vejo por ai são aplicações sem o uso do controle de transações. Descobri a poucos dias que isso pode ser tornar uma dor de cabeça para o desenvolvedor. Então se você usa o Spring ( que é o meus caso ) basta incluir no seu ApplicationContext essa tag abaixo:

<tx:annotation-driven transaction-manager="transactionManager"/>

Depois nos seus services basta fazer isso:

@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)

Isso pode evitar alguns indesejáveis problemas no banco de dados, inconsistências e até mesmo a quedra do servidor ( apache tomcat, jboos etc ).

ps – Esse controle de aplicação aplica-se para outros, não apenas no Spring ( veja a documentação )

Att
Felipe

Mar 7

BlazeDS – do básico ao avançado – Parte 1

Escrito por DClick Team em 1, 2009, 4, 6, action, Actionscript, Adobe, AMF, apache, app, AR, arte, auto, BI, Blazeds, blog, botão, class, classe, cliente, código, código fonte, Componente, componente flex, Componentes, comunicação, configuração, control, Controls, Crossdomain, custom, dados, demo, developer, Diversos, Documentação, Download, Eclipse, err, erro, event, Evento, events, exemplo, Exemplos, falha, flash, Flex, fonte, for, framework, Frameworks, function, Galileo, git, handle, Hibernate, HTTPService, ide, IE, if, image, instalação, int, Java, library, LOB, Messaging, mg, MXML, NaN, O, on, opensource, Outros, Plugin, problema, problemas, pt, reference, referencia, Remoting, RIA, Ria’s Geral, runtime, screen, Screencast, screencasts, Segurança, Sem categoria, server, serviço, Serviços, servidor, site, spark, Spring, string, tag, TAT, Tecnologia, Twitter, UI, uint, web, Webservice, window, XML @ 03 7th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários
DClick Team
? 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 »

BlazeDS é uma aplicação Java opensource mantida pela Adobe, sob licensa GNU Lesser General Public License, Version 3 (LGPL v3), que fornece um conjunto de serviços, todos sobre o protocolo HTTP(Hyper Text Transfer Protocol), para permitir uma aplicação Flex fazer chamadas a serviços remotos Java, retornando os dados tanto de forma assíncrona como em tempo real.

Por utilizar o formato de dados binário chamado AMF(Action Message Format) para a serialiazação e deserialização de dados, a comunicação entre uma aplicação Flex e o servidor Web se torna muito otimizada. Existem estudos feitos comparando as diversas tecnologias, como o Jamesward, mostrando o potencial do AMF.

Outra grande vantagem quando usamos o BlazeDS é a facilidade de ter classe Java automaticamente convertida para uma classe ActionScript e vice-versa.

O BlazeDS pode ser baixado do site da Adobe em dois formatos:

  1. Turnkey – Versão que já vem com exemplos e servidor tomcat pré configurado
  2. Binary – Versão com os binários

Você pode optar também por fazer o download do código fonte. A documentação também está disponível neste link.


Entendendo os arquivos de configuração do BlazeDS
A estrutura de arquivos do BlazeDS é bem simples, quando descompactamos o blazeds.war, presente na versão binária, podemos ver a seguinte estrutura:

Devemos nos atentar a duas pastas. A pasta lib, que contém todos os jars necessários, e a pasta flex, que contém todos os arquivos de configuração do BlazeDS. Vamos ver o que cada arquivo significa:

  1. services-config.xml: É neste arquivo que estão as principais configurações do BlazeDS como segurança, logging, serviços disponíveis (Canais), fábricas para a integração com Frameworks Java como Spring e EJB3 e as referências para os outros três arquivos de configuração.
  2. remoting-config.xml: É nesse arquivo que iremos configurar os serviços Java para serem “consumidos” pela aplicação Flex. Sempre quando configuramos este arquivo, iremos trabalhar com o componente Flex chamado RemoteObject.
  3. message-config.xml: Aqui é configurado tudo o que for relacionado com mensageria, sempre necessário quando trabalhamos com os componentes Flex Consumer e Producer. Um exemplo da utilização desta tecnologia seria fazer um bate bapo, ou até mesmo aplicações colaborativas, onde é desejável a iteração simultânea de diversos usuários.
  4. proxy-config.xml: Além da possibilidade de utilizarmos o componente RemoteObject, o Flex disponibiliza mais duas formas de integração: O HTTPService e o WebService. Porém, por questões de segurança, os serviços só podem ser chamados quando os mesmos estão no mesmo domínio que a aplicação, ou que exista uma configuração específica que permita um cliente Flex fazer a consulta (esta configuração é feita por um arquivo chamado crossdomain.xml e está sempre no servidor onde está o serviço chamado). Caso uma das duas condições acima não seja satisfeita, deveremos utilizar o BlazeDS como proxy , e é ai que configuração deste arquivo se torna necessário.



Criando o seu primeiro projeto com o BlazeDS

Para criar o projeto iremos precisar de:

  1. Eclipse Galileo JEE
  2. FlashBuilder Plugin
  3. BlazeDS 4 Binary
  4. Tomcat 6



Feito os downloads e a instalação do Eclipse e FlashBuilder, vamos iniciar o FlashBuilder para criar o projeto.
Antes de criar o projeto, vamos configurar o Tomcat:

  1. Nas preferências do Eclipse, vá em Server — Runtime Environments e clique em Add…
  2. Na pasta Apache selecione Apache Tomcat v6.0 e clique em Next
  3. Selecione a pasta onde você descompactou o Tomcat e clique em Finish

Feito a configuração do Tomcat, vamos criar o projeto:

  1. Vá em File – New – Flex Project
  2. Preencha os dados do primeiro passo como na imagem abaixo e clique em Next
  3. Neste passo vamos configurar os dados do servidor. Deixe tudo configurado como na imagem e clique em Next


    Para selecionar o “Target Runtime”, clique em New e depois escolha o Apache Tomcat 6, como na imagem abaixo.
  4. No último passo não será necessário mudar nada, clique em Finish

Agora vamos criar a classe Java que terá o serviço para retornar a string “HelloBlazeDS”

  1. Crie uma classe Java br.com.dclick.service.RemotingService
  2. Crie o serviço:
    1
    2
    3
    4
    5
    6
    7
    8
    package br.com.dclick.service;
    public class RemotingService {

    ? ? public String sayHello() {
    ? ? ? ? return “HelloBlazeDS”;
    ? ? }
    ? ?
    }

Agora vamos configurar o BlazeDS para disponibilizar o serviço que acabamos de criar.

  1. Abra o arquivo remoting-config.xml que está na pasta WebContent/WEB-INF/flex
  2. Para que seja possível chamar os métodos da classe Java, precisamos configurar um destination. Isso é necessário para cada classe Java.
    O arquivo fica assim:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    xml version=“1.0″ encoding=“UTF-8″?>
    “remoting-service” class=“flex.messaging.services.RemotingService”>
    ? ?
    ? ? ? ? “java-object”
    ? ? ? ? ? ? class=“flex.messaging.services.remoting.adapters.JavaAdapter”
    ? ? ? ? ? ? default=“true” />
    ? ?

    ? ?
    ? ? ? ? “my-amf” />
    ? ?

    ? ? “blazeServices”>
    ? ? ? ? ? ? ? ? ? ? br.com.dclick.service.RemotingService
    ? ? ? ?
    ? ?

Vamos colocar na aplicação a chamada para o servidor.

  1. A primeira coisa que precisamos fazer é configurar o RemoteObject. Fazer isso é muito simples:
    1
    2
    3
    4
    5
    ? ? ? ?
    ? ? ? ? “services” destination=“blazeServices”
    ? ? ? ? ? ? ? ? ? ? ? ? result=“services_resultHandler(event)”
    ? ? ? ? ? ? ? ? ? ? ? ? fault=“services_faultHandler(event)” />
    ? ?


    Alguns detalhes:

    * Perceba que a propriedade destination aponta para o destination que configuramos no arquivo remoting-config.xml

    * Precisamos declarar um id para poder referenciar o RemoteObject

    * Adicionamos um ResultHandler para tratar o resultdo do serviço

    * Adicionamos um FaultHandler para tratar a falha do serviço

  2. Os Handlers ficam assim:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    ? ? ? ?
    ? ? ? ? [CDATA[
    ? ? ? ? ? ? import mx.controls.Alert;
    ? ? ? ? ? ? import mx.rpc.events.FaultEvent;
    ? ? ? ? ? ? import mx.rpc.events.ResultEvent;

    ? ? ? ? ? ? protected function services_resultHandler(event:ResultEvent):void
    ? ? ? ? ? ? {
    ? ? ? ? ? ? ? ? Alert.show(event.result.toString());
    ? ? ? ? ? ? }

    ? ? ? ? ? ? protected function services_faultHandler(event:FaultEvent):void
    ? ? ? ? ? ? {
    ? ? ? ? ? ? ? ? Alert.show(event.fault.message);
    ? ? ? ? ? ? }

    ? ? ? ? ]]>
    ? ?


    Alguns detalhes:

    * A propriedade result do evento ResultEvent vai conter o resultado do serviço. No nosso caso o serviço retorna uma String “HelloBlazeDS”

    * A propriedade fault do evento FaultEvent contém os detalhes do erro.

  3. A última coisa é chamar o serviço. Vamos fazer isso no evento creationComplete, como segue:
    1
    2
    3
    4
    ? ? ? ? protected function application1_creationCompleteHandler(event:FlexEvent):void
    ? ? ? ? ? ? {
    ? ? ? ? ? ? ? ? services.sayHello();
    ? ? ? ? ? ? }
  4. A aplicação inteira fica assim:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    ? ? ? ? xml version=“1.0″ encoding=“utf-8″?>
    “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)”>
    ? ?
    ? ? ? ? [CDATA[
    ? ? ? ? ? ? import mx.controls.Alert;
    ? ? ? ? ? ? import mx.events.FlexEvent;
    ? ? ? ? ? ? import mx.rpc.events.FaultEvent;
    ? ? ? ? ? ? import mx.rpc.events.ResultEvent;

    ? ? ? ? ? ? protected function services_resultHandler(event:ResultEvent):void
    ? ? ? ? ? ? {
    ? ? ? ? ? ? ? ? Alert.show(event.result.toString());
    ? ? ? ? ? ? }

    ? ? ? ? ? ? protected function services_faultHandler(event:FaultEvent):void
    ? ? ? ? ? ? {
    ? ? ? ? ? ? ? ? Alert.show(event.fault.message);
    ? ? ? ? ? ? }

    ? ? ? ? ? ? protected function application1_creationCompleteHandler(event:FlexEvent):void
    ? ? ? ? ? ? {
    ? ? ? ? ? ? ? ? services.sayHello();
    ? ? ? ? ? ? }

    ? ? ? ? ]]>
    ? ?
    ? ?
    ? ? ? ? “services” destination=“blazeServices”
    ? ? ? ? ? ? ? ? ? ? ? ? result=“services_resultHandler(event)”
    ? ? ? ? ? ? ? ? ? ? ? ? fault=“services_faultHandler(event)” />
    ? ?

Agora só falta fazer o deploy da aplicação e subir o servidor.

  1. Vá em Window – Show View – Other. Na janela que abrir, digite Servers e clique OK
  2. Na view Servers, clique com o botão direito em Tomcat v6.0 e selecione Add and Remove…
  3. Selecione a aplicação HelloBlazeDS e clique em Add e depois Finish
  4. Na view Servers, clique com o botão direito em Tomcat v6.0 e clique em Run

Agora é só executar a aplicação e ver o resultado:

Isso é tudo, guarde esse projeto configurado para ser usado nos próximos posts.

Mar 3

Spring WEBMVC – Annotations

Escrito por DClick Team em 1, 2.0, 4, 6, app, Apresentação, AR, Arquitetura, arte, BI, blog, busca, camp, class, classe, classes, configuração, control, custom, dados, demo, Desenvolvimento, Design, Design Pattern, dispatch, err, exemplo, Ferramenta, for, framework, Google, IE, if, image, int, interface, j2ee, Java, lógica, map, Mercado, mg, mvc, NaN, Negócios, O, on, Outros, padrão, pattern, procura, programação, pt, reference, rest, RIA, Ria’s Geral, screen, Screencast, server, serviço, servidor, site, Spring, SpringFramework, string, Sun, tag, TAT, Tema, Teste, Twitter, UI, uint, UX, validação, web, XML, XP, zend @ 03 3rd, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários
DClick Team
? 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 »

Criando a camada WEB com Spring-WEBMVC – @Annotation


Spring WebMVC é uma ferramenta poderosa para criação de aplicação com uma camada web muito utilizada no mercado.
Algumas de suas características incluem uma separação clara entre camada de apresentação, negócios e modelo, e também uma distinção clara de papéis de controllers, validators, commands, forms, models, views etc. Também é um framework altamente customisável e adaptável, disponibilizando ferramentas para controle de todo o fluxo entre as páginas e se adaptando bem a maioria dos modelos de negócio. Outra característica que é quase obrigatória em todos os módulos do Spring, é o padrão Spring de se organizar e configurar as classes de negócio como beans gerenciados pelo container.
Além das características básicas, ainda estão disponíveis bibliotecas de JSP muito úteis no dia-a-dia de desenvolvimento que facilitam a contrução de interfaces. E ainda existe a possibilidade de configurar os escopos dos beans da aplicação de acordo com o lifecycle do HTTP request que está sendo feito para a aplicação.

Neste post veremos o básico de spring-webmvc e sua configuração feita por anotações, aprendendo os conceitos base do módulo e entendendo melhor como configurar e organizar seus beans de acordo com suas necessidades. Por fim veremos um screencast com um exemplo de aplicação web feita do zero e seguindo todo o caminho desde o modelo, passando pelo controller e terminando na view.

Entendendo o DispatcherServlet


O DispatcherServlet é de fato um servlet Java que é o ponto de entrada para as aplicações Web.

É encarregado de encaminhar as chamadas feitas a aplicação para seu respectivo controller, e uma vez que a resposta do controller foi recebida, encaminhas a resposta para a view correta. Mas como DispatcherServlet faz parte do Spring, para ele e seus beans, nesse caso controllers e suas dependências, estão disponíveis todas as outras features que o container disponibiliza, como gerenciamento de beans e injeção de dependências.

O DispatcherServlet seguem um Design Pattern conhecido como Front Controller. No site do spring está disponível o seguinte diagrama exemplificando o pattern:





No diagrama fica claro o papel do DispatcherServlet.
Uma chamada que acabou de chegar na aplicação, passa pelo DispatcherServlet, que por sua vez escolhe o controller correto para tratar a chamada e delega a mesma. Feito isso o controller devolve o resultado da operação para o DispatcherServlet que dessa vez se encarrega de encontrar a view correta para tratar a resposta. Após a view ter renderizado a página de resposta, o DispatcherServlet devolve para o dono da requisição a resposta.


Configurando o DispatcherServlet



Agora que entendemos que o DispatcherServlet é peça fundamental para nossa aplicação, precisamo configurá-lo. Para isso basta adicioná-lo ao seu arquivo web.xml da seguinte forma:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
-app xmlns=“http://java.sun.com/xml/ns/j2ee” xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
? ? version=“2.4″ xsi:schemaLocation=“http://java.sun.com/xml/ns/j2ee web-app_2_4.xsd”>

? ?
? ? >

? ? ? ? -name>servletName-name>
? ? ? ? -class>org.springframework.web.servlet.DispatcherServlet-class>
? ? ? ? -on-startup>1-on-startup>
? ? >

? ? -mapping>
? ? ? ? -name>servletName-name>
? ? ? ? -pattern>/*-pattern>
? ? -mapping>

-app>



O que fizemos foi dizer ao server, que ele deve instanciar um novo servlet, que nesse caso é o DispatcherServlet, assim que a aplicação subir no servidor. Também estamos dizendo que todas as chamadas para a aplicação, que forem feitas em / devem ser delegadas para o nosso servlet com o nome servletName. Nesse campo você pode escolher o nome que mais fizer sentido para sua aplicação, e perceba que você pode criar mais de um servlet para tratar suas chamadas.

Agora vamos à integração com o IoC do Spring.

Como eu havia dito, esse é um dos benefícios do Spring-WebMVC, e portanto vamos ver como usá-lo corretamente para tirar maior proveito do mesmo.

Todo DispatcherServlet está associado a um contexto de beans do Spring. Tal associação é feita através do nome do servlet e um arquivo de beans padrão do spring. No momento em que o DispatcherServlet for criado, o classpath será percorrido em procura de uma arquivo que, neste caso, deve se chamar /WEB-INF/servletName-servlet.xml. Neste arquivo devem estar definidos os beans específicos para que os seus controllers referentes a este servlet funcionem corretamente. Note que se estiver definido mais de um DispatcherServlet, será necessário definir um arquivo com tais beans para cada um deles.


Controllers



Controllers são parte fundamental da arquitetura MVC (se referem so ‘C’ da sigla), e no Spring-webmcv não é diferente. Saber configurá-los e atribuí-los a suas chamadas específicas é muito importante no desenvolvimento da aplicação. Pensando nisso o Spring disponibiliza várias implementações de controllers que pode ajudar no dia-a-dia e várias ferramentas para associar as chamadas a tais controllers. Como o objetivo do post é tratar da configuração por anotações, não entrarei no detalhe de tais implementações e de tais associações. Iremos utilizar um serviço qualquer da aplicação para servir de controller, e a associação será feita através das anotações.

Para tornar uma classe um controller do spring, basta anotá-lo com @Controller da seguinte forma:

1
2
3
4
? ? package br.com.dclick;

? ? @Controller
? ? public class ServicoComum {



Repare que não é necessário extender nem implementar nenhuma classe ou interface específica, o que colabora bastante para desacoplar a lógica de view de nosso sistema.

Para habilitar esse nosso controller e associá-lo ao servlet, basta pedirmos ao Spring para scannear esse pacote e deixar o bean disponível no contexto do servlet. Para fazer isso adicione o seguinte no arquivo de beans do servlet:

1
2
3
4
5
6
7
8
9
10
11
12
13
<?xml version=“1.0″ encoding=“UTF-8″?>
xmlns=“http://www.springframework.org/schema/beans”
? ? xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance” xmlns:context=“http://www.springframework.org/schema/context”
? ? xsi:schemaLocation=“http://www.springframework.org/schema/beans
? ? ? ? http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
? ? ? ? http://www.springframework.org/schema/context
? ? ? ? http://www.springframework.org/schema/context/spring-context-3.0.xsd”
>

? ? :annotation-config />

? ? :component-scan?base-package=“br.com.dclick” />

>



Perceba que coloquei a tag do contexto do spring que habilita a configuração por anotações.

Agora precisamos definir um método para que o spring faça a chamada quando o request chegar na aplicação. Para isso vamos entender o papel do ModelAndView.


ModelAndView



O ModelAndView é responsável por descrever o modelo e a view (intuitivo? ;) ) daquela chamada, portanto nele estão setados a view a qual a chamada está associada, e todos os atributos de modelo que devem chegar até a view. Tais atributos são guardados como em um Map associando chaves e valores. Veremos que esses valores ficam disponíveis em nossa view e podem ser usados nos JSPs da aplicação, mas agora vamos ao método do controller:

1
2
? ? @RequestMapping(value = “/chamada”, method = RequestMethod.GET)
? ? public ModelAndView trataChamada(@PathVariable(“var”) String var) {



Muita coisa acontecendo aqui, mas vamos por partes. A primeira coisa a se notar é que o método irá tratar todas as chamadas feitas em nomeDaAplicação/chamada, isso porque nosso servlet está associado em / e nosso método está associado com chamada. Nós poderíamos também ter definido o caminha básico para o controller ainda na anotação do controller, por exemplo:

1
2
? ? @Controller(“/base”)
? ? public class ServicoComum {



Assim nosso método trataria todas as chamadas feitas em nomeDaAplicação/base/chamada.

A segunda coisa a se notar é que nosso método só irá tratar requisições do tipo GET, podendo ser alterado para os outros tipos de requisição seguindo um modelo REST.

A terceira coisa a se notar é que nosso método devolve um ModelAndView, portanto saberemos a que view o DispatcherServlet irá direcionar, e também teremos alguns atributos do modelo disponíveis.

A última mas não menos importante, é que o método está esperando um parâmetro. Esse parâmetro foi anotado com @PathVariable, isso significa que a chamada ao controller deve esr da seguinte forma: nomeDaAplicação/chamada?var=teste e assim nosso método irá receber o valor teste. Faça alguns testes e repare que é possível configurar a obrigatoriedade do parâmetro, a validação do mesmo dentre outras coisas. Também poderíamos ter definido o parãmetro como @RequestParam, mas nesse caso a chamada deveria estar em um formato POST e o atributo deveria estar setado no request.


ViewResolver



A última configuração necessária para nossa aplicação funcionar é um ViewResolver. Vamos utilizar um bem simples para que possamos utilizar páginas em JSP em nossa aplicação. Para isso, basta adicionar o seguinte bean no contecto do servlet:

1
2
3
4
5
? ? id=“viewResolver”
? ? ? ?? ?class=“org.springframework.web.servlet.view.UrlBasedViewResolver”>

? ? ? ? name=“prefix” value=“/WEB-INF/jsp/”/>
? ? ? ? name=“suffix” value=“.jsp”/>
? ? >



O que fizemos, foi dizer ao view resolver, que ele deve buscar na pasta WEB-INF/jsp por nossos arquivos JSPs antes de renderizar as páginas de resposta. Também estamos dizendo, que ele deve procurar através do nome da view que o controller devolver, por exemplo, se nosso ModelAndView possuir uma view com nome pagina, o view resolver irá buscar por um arquivo com nome pagina.jsp para renderizá-lo com os atributos setados no ModelAndView.

Existem muitos tipos de view resolvers, e muitas maneiras de configurá-los, mas para uma primeira experiência com o framework essa configuração já é suficiente.

Por @Gust4v0_H4xx0r

Jan 28

Agon News S1G5R4

Escrito por DClick Team em 1, 4, AR, BI, blog, Catalyst, class, Download, err, Ferramenta, flash, Flash Catalyst, ide, IE, image, mg, News, O, on, podcast, pt, Ria’s Geral, Spring, TAT, Treinamento, tv, Twitter, UI, UX @ 01 28th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários
DClick Team
? 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 »

Gustavo fala sobre RabbitMQ, AMQP e Spring-AMQP e o Eduardo continua sua série de posts sobre o Flash Catalyst (um verdadeiro treinamento da ferramenta para você e de graça aqui no blog da DClick).

Video thumbnail. Click to play.
Click to play

Clique aqui para fazer download deste Podcast.

http://blip.tv/file/get/Dclick-AgonNewsS1G5R4452.mp3

Jan 20

RabbitMQ, AMQP e Spring-AMQP

Escrito por DClick Team em 1, 4, 6, Air, api, AR, arte, BI, class, classe, comparação, condicional, configuração, dados, demo, Desenvolvimento, err, event, Evento, Eventos, Experiências, Ferramenta, filtra, for, framework, git, html, ide, IE, if, image, instalação, int, interoperabilidade, Java, Linux, mg, O, on, padrão, painel, Partilha, RIA, Ria’s Geral, screen, Screencast, server, serviço, Serviços, servidor, site, Spring, Spring Framework, SpringFramework, string, strings, tag, TAT, Tema, template, Tutorial, Twitter, UI, UX, window, windows, XP @ 01 20th, 2011 | via http://blog.dclick.com.br/pt/ | Sem comentários
DClick Team
? 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 »

RabbitMQ e AMQP


Quem programa em Java a algum tempo já deve ter cruzado com JMS (Java Message Service) e também deve ter percebido que trabalhar com JMS apesar do conceito ser fácil, não é uma das tarefas mais agradáveis e simples. Isso porque a API possui muitas exceções que devem ser tratadas e as configurações das filas e do sistema são específicas de cada broker.
Mas afinal, pra quê usar JMS então? A resposta é simples, para programar de maneira assíncrona, e portanto mais voltado a reação do que a ação, ou seja, deixar a aplicação orientada a eventos (EDA – Event Driven Architeture) e conseguir distribuir melhor a carga entre servidores aumentando escalabilidade.
Já que mensageria é uma ferramenta poderosa, e JMS não colabora muito com sua utilização, foi criado o AMQP – Advanced Message Queuing Protocol. Diferente de JMS que define uma API Java, AMQP define um protocolo, ou seja, uma descrição de como os dados das mensagens trafegam pelo broker. Com isso qualquer aplicação que entenda esse protocolo consegue se comunicar com o broker independente de sua implementação, facilitando sua configuração e até mesmo a interoperabilidade de brokers.
Atualmente o broker mais utilizado que é open source e suporta tal protocolo é o RabbitMQ. Por isso veremos algumas características do mesmo. Outro fato a favor do RabbitMQ, é que agora faz parte do Springsource e portanto possui um bom suporte do spring-framework.


Começando com o RabbitMQ



Como vimos, uma das maiores vantagens de trabalhar com AMQP, é que a configuração independe do broker que estamos usando, portanto nosso trabalho com o RabbitMQ se resume a instalação e execução do serviço, tarefas as quais são muito simples.
Eu já instalei o RabbitMQ em máquinas com windows e com Linux (CentOS), por isso vou compartilhar ambas as experiências.
No Windows: Comece baixando o bundle completo do RabbitMQ que inclui todas as dependências para que o server funcione: Site oficial do RabbitMQ. Em seguida descompacte o conteúdo em uma pasta do seu sistema e rode o instalador que está dentro da pasta. Pronto! Ao sair do instalador, o serviço estará pronto pra uso, mas ainda não estará executando. Para isso basta abrir o painel de serviços do windows e iniciá-lo.
No CentOS: Pra variar, instalar o RabbitMQ no CentOS é simples com digitar no terminal:

sudo yum install rabbitmq-server



E pronto! O server está instalado, e basta iniciá-lo com:

sudo /sbin/service rabbitmq-server start


Configurando o broker AMQP



Repare que não estou especificando que iremos configurar o RabbitMQ, isso porque as cofigurações servem para qualquer broker AMQP.
Um broker JMS trabalha com filas sendo compartimentos para mensagens. Portanto é necessário configurar tais filas no broker. Para escutar as mensagens que são postadas nas filas, podemos utilizar selectors para filtrar algum tipo específico de mensagem baseado no cabeçalho da mensagem. Ainda podemos escolher o tipo de fila, sendo um modo ponto-a-ponto e um modo publish/subscribe. No primeiro modo, apenas um consumidor de mensagens escuta a fila, sendo que este receberá todas as mensagens enviadas não necessariamente no momento em que são postadas. No segundo modo múltiplos consumidores escutam a fila, sendo que a mensagem é entregue para todos os consumidores que o selector satisfazer as condições.
Com o AMQP é um pouco diferente. A primeira diferença notável, é que as mensagens não são publicadas diretamente nas filas, mas sim em uma nova estrutura chamada de Exchange. Exchanges recebem as mensagens encaminham para as filas baseados em routing keys, que especificam as filas que as mensagens pertencem. Portanto precisamos criar as filas também em um broker AMQP, mas dessa vez associando-as aos exchanges através de Bindings que são definidos pelas routing keys.





Note na imagem que um exchange pode rotear mensagens para mais de uma fila, e uma fila pode receber mensagens de mais de um exchange.
Em AMQP também temos o conceito de ponto-a-ponto chamdo de direct, sendo que nesse caso temos um exchange publicando apenas para uma fila, e também temos o conceito de Topic ou publish/subscribe, onde um exchange pode mandar para mais de uma fila. Nesse segundo caso, se for definida uma routing key, então o exchange irá encaminhar a mensagem para a fila com o binding referente a routing key. Caso não tenha sido definido uma routing key, as mensagens serão distribuídas para as filas de maneira igualitaria baseada em Round Robin.
Em AMQP ainda existe um terceiro modo: Fanout. Nesse modo o exchange pode estar associado a várias filas como em um topic, porém quando uma mensagem for postada no exchange, este replicará a mensagem em todas as filas que estiverem associadas a ele, sem levar em conta a routing key.


Bindings



Bindings entre exchanges e filas podem ser definidos apenas para explicitar uma ligação entre os dois, ou explicitando uma ligação condicional.
A condição para que o binding seja válido é definido pela routing key e pode ser definido de algumas maneiras:
- uma string fixa;
- uma string usada como padrão para fazer o match com as routing keys;
- múltiplas strings definindo mais de uma routing key;
- múltiplos strings usadas como padrão para match;
- comparação algorítmica baseada em uma SQL executada sobre o cabeçalho da mensagem;
- inspeção de conteúdo, verificando se o conteúdo da mensagem atende a uma determinada condição.

Spring AMQP



O RabbitMQ agora é um projeto da springsource, portanto existe já em desenvolvimento e inclusive com milestones publicados e disponíveis em um repositório do maven:

1
2
3
4
5
? ? >
? ? ? ? ? ? >repository.springframework.milestone>
? ? ? ? ? ? >Spring Framework Maven Milestone Repository>
? ? ? ? ? ? >http://maven.springframework.org/milestone>
? ? ? ? >



Todo o projeto está desenvolvido com o ideal do spring e portanto os conceitos básicos e já conhecidos como injeção de dependência e facilidade de configuração e uso estão muito bem empregados no projeto.
Seguindo essa linha existe um classe que serve de template para um broker AMQP.
Veremos no screencast a seguir como adotar utilizar o Spring-AMQP em seu projeto e algumas facilidades e dificuldades.

Por @Gust4v0_H4xx0r

Dez 20

Agon News S1G4R2

Escrito por DClick Team em 1, 4, 6, Android, app, AR, blog, Catalyst, class, Download, flash, Flash Player, ide, image, iphone, mg, News, O, on, player, Ria’s Geral, Spring, TAT, tv, Twitter, UI @ 12 20th, 2010 | via http://blog.dclick.com.br/pt/ | Sem comentários
DClick Team
? 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 »

Eduardo fala sobre o Catalyst e Android (@eduardohorvath 06:38), O Gustavo fala sobre Spring (@Gust4v0_H4xx0r 02:10) e mais IPhone e Contextual Applications com o Flash Player.

Video thumbnail. Click to play.
Click to play

Clique aqui para fazer download

http://blip.tv/file/get/Dclick-AgonNewsS1G4R2435.mp3

Dez 8

Spring Integration

Escrito por DClick Team em 1, 2.0, 4, 6, apache, api, app, AR, Arquitetura, Artigo, BI, class, classe, cliente, código, dados, demo, Design, email, err, event, Evento, Eventos, exemplo, Exemplos, expression, Ferramenta, Flex, for, Formação, framework, futuro, Google, html, ide, IE, if, image, imagens, int, interface, Java, Mac, mg, mudanças, O, on, Outros, padrão, problema, problemas, programação, reference, RIA, Ria’s Geral, serviço, Serviços, site, Spring, SpringFramework, string, Sun, TAT, Tema, Teste, Tutorial, Twitter, UI, uint, Vários, web, Webservice, XML, XP, zend @ 12 8th, 2010 | via http://blog.dclick.com.br/pt/ | Sem comentários
DClick Team
? 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 »

Uma arquitetura desacoplada com o Spring Integration


A cada dia crescem mais as aplicações que disponibilizam serviços Web para que qualquer cliente possa consultá-los. E a cada dia que passa nossas aplicações dependem mais e mais desses serviços para obter informações de usuários, armazenar dados remotamente, consultar emails, postar entradas no twitter dentre outros. Por isso logo surge um problema o qual é bem difícil de lidar: dependência da API dos serviços.

Depender de uma determinada API para algum serviço é um fator de risco bem alto se considerarmos que as APIs podem mudar e nossa aplicação pode parar de funcionar do dia para a noite. E pior, dependendo da mudança é necessário uma reestruturação muito grande em nosso código para se adequar a nova especificação. Pensando nisso que programamos seguindo padrões de design de código e boas práticas de programação. Ainda assim pode não ser suficiente se pensarmos de uma maneira um pouco mais macro em nossa aplicação, pois em algum ponto do nosso sistema ainda existirá uma “ponte” de integração com algum determinado serviço (entenda serviço como qualquer WebService, classe ou biblioteca que consultamos).

A solução é desacoplar o máximo possível nossa aplicação de tais serviços, e deixarmos nossa aplicações executar independente de como o serviço será consultado. Para obter esse nível de abstração é necessário programar e planejar o sistema pronto para se adequar as mudanças, e a melhor maneira de se programar para mudança é não programar. Parece um pensamento meio estranho, mas se analisarmos com cuidado veremos que existe uma certa razão para isso, pois quanto menos código tivermos, menos precisará ser mudado.

Spring Integration permite que criemos serviços de maneira totalmente desacoplada entre si e outros serviços Web, e disponibiliza as conexões em sua própria Bean Factory, ou seja, nosso sistema é livre de qualquer consulta a serviços ou API externa a aplicação. Vamos entender um pouco da arquitetura do Spring Integration.


Entendendo o que está acontecendo


A idéia por trás do spring integration é bem simples na verdade: todo serviço só distribui informação e recebe informação através de channels (canais). Canais são uma forma de acoplar os serviços, sem que estes dependam da API ou da maneira com que as chamadas são feitas.
Toda canal trafega mensagens. Mensagens possuem um cabeçalho e um conteúdo qualquer:


E um canal nada mais é do que o responsável por receber e disponibilizar tais mensagens a quem estiver interessado. Para ser mais direto, qualquer bean definido no contexto do spring tem acesso a tais canais.


Fica claro aqui que podemos ter vários tipos diferentes de canais com várias configurações e comportamentos diferentes. De fato o spring disponibiliza tais configurações e comportamentos out of the box. Veremos mais pra frente.

Exemplo prático


Vamos criar um exemplo para entender melhor os conceitos.
A primeira coisa a se fazer é baixar os jars do spring integration. Feito isso adicione-os ao classpath do seu projeto que deve ser um spring application padrão. Se você está usando o maven, basta adicionar as seguintes dependências:

1
2
3
4
5
6
7
8
9
10
11
? ? >
? ? ? ? >org.springframework>
? ? ? ? >spring-expression>
? ? ? ? >3.0.5.RELEASE>
? ? >

? ? >
? ? ? ? >org.springframework.integration>
? ? ? ? >spring-integration-core>
? ? ? ? >2.0.0.RELEASE>
? ? >


Estou assumindo que as dependências para o contexto do spring já estejam corretamente configuradas.

Agora em nosso arquivo de beans do spring, basta adicionarmos o seguinte namespace e schema location:

1
2
3
4
5
6
7
8
9
10
11
12
<?xml version=“1.0″ encoding=“UTF-8″?>
xmlns=“http://www.springframework.org/schema/beans”
? ? xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance” xmlns:amq=“http://activemq.apache.org/schema/core”
? ? xmlns:context=“http://www.springframework.org/schema/context” xmlns:si=“http://www.springframework.org/schema/integration”
? ? xsi:schemaLocation=“http://activemq.apache.org/schema/core http://www.springframework.org/schema/aop
? ? ? ? http://www.springframework.org/schema/beans
? ? ? ? http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
? ? ? ? http://www.springframework.org/schema/context
? ? ? ? http://www.springframework.org/schema/context/spring-context-3.0.xsd
? ? ? ? http://www.springframework.org/schema/integration
? ? ? ? http://www.springframework.org/schema/integration/spring-integration-2.0.xsd”
>

>


Podemos começar a configurar nossos serviços e canais agora.

Crie um serviço bem simples que recebe e guarda uma String, e disponibiliza-a em um getter:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package br.com.dclick.services;

@Service(“simpleService”)
public class SimpleService {

? ? private String s;

? ? public void setString(String s) {
? ? ? ? this.s = s;
? ? }

? ? public String getS() {
? ? ? ? return s;
? ? }
}


Repare que estou usando a criação de beans por anotação, por isso tenho que colocar em meu arquivo de beans que o pacote de tal serviço deve ser “escaneado”:

1
? ? :component-scan?base-package=“br.com.dclick.services” />


Crie um teste unitário para nosso serviço, e certifique-se que a injeção dos beans está sendo feita corretamente e que o spring está corretamente configurado até aqui. Não é o foco deste artigo mostrar como configurar tal teste, por isso vou supor que as configurações já estão corretas e vou colocar o código do teste diretamente (estou usando JUnit 4):

1
2
3
4
5
6
? ? private SimpleService simpleService;

? ? @Test
? ? public void testChannels() {
? ? ? ? Assert.assertNotNull(this.simpleService);
? ? }


Vamos criar agora um canal de entrada e um canal de saída em nossos beans. Para isso basta adicionar o seguinte código em nosso xml de beans:

1
2
3
4
5
? ? :channel id=“input” />

? ? :channel id=“output”>
? ? ? ? :queue capacity=“10″ />
? ? :channel>


Estou setando uma capacidade para nosso canal de saída para ilustrar uma das possíveis configurações do canal.

Até aqui nenhum segredo. Vamos agora disparar nosso serviço quando uma determinada mensagem for adicionada ao canal de entrada. É aqui que o spring integration se mostra muito flexível e poderoso. Não necessário nenhuma mudança no código para que essa conexão do serviço com o canal seja feita, basta adicionarmos um service-activator para fazer o trabalho. Para isso basta adicionar o seguinte bean ao xml:

1
2
3
? ? :service-activator input-channel=“input”
? ? ? ? output-channel=“output” ref=“simpleService” method=“setString”>

? ? :service-activator>


Estamos dizendo que uma mensagem que chega no canal input, deve ter seu conteúdo enviado para o método setString no bean simpleService, e que o resultado deve ser adicionado no canal output.
Simples não? Vamos testar agora:

1
2
3
4
5
6
7
8
9
10
? ? private MessageChannel input;

? ? @Test
? ? public void testChannels() {
? ? ? ? Assert.assertNotNull(this.simpleService);
? ? ? ?
? ? ? ? input.send(new GenericMessage(“hello!”));
? ? ? ?
? ? ? ? Assert.assertEquals(“hello!”, this.simpleService.getS());
? ? }


Vamos mudar nosso serviço para devolver o valor que foi setado no métodosetString, com isso nosso service activator irá pegar o resultado e enviá-lo para o canal de saída:

1
2
3
4
? ? public String setString(String s) {
? ? ? ? this.s = s;
? ? ? ? return this.s;
? ? }


E agora conseguimos fazer o seguinte teste:

1
2
3
4
5
6
7
8
9
10
11
12
13
? ? private MessageChannel output;

? ? @Test
? ? public void testChannels() {
? ? ? ? Assert.assertNotNull(this.simpleService);
? ? ? ?
? ? ? ? input.send(new GenericMessage(“hello!”));
? ? ? ?
? ? ? ? Assert.assertEquals(“hello!”, this.simpleService.getS());
? ? ? ?
? ? ? ? Message msg = (Message) this.output.receive();
? ? ? ? Assert.assertEquals(“hello!”, msg.getPayload());
? ? }


Rode o teste e verifique que ele passa.
Vamos recapitular então o que vimos até agora. Criamos um serviço que é totalmente livre de qualquer API que apenas guarda uma String que é setada através do método setString. Criamos um canal de entrada (input) e um de saída (output) que guarda até 10 mensagens. Conectamos os canais com um service activator, que quando recebe uma mensagem no canal de entrada, invoca o método setString em nosso serviço e envia uma mensagem para o canal de saída com o valor que o serviço devolveu. Fizemos um teste que envia uma String para o canal de entrada, verifica que chegou até o serviço, e verifica que estava disponível no canal de saída.

Um fato interessante é que o método receive do canal de saída “trava” até que chegue uma nova mensagem, portanto estamos falando de uma arquitetura passiva baseadas em eventos que são disparados com o recebimento de mensagens. Muito bom!

Gateways


O conceito de Gateway existe para facilitar o envio de mensagens aos canais, estabelecendo um interface comum para que possam ser usados de maneira natural no código.
Vamos criar um gateway para invocar nosso serviço que guarda a String:

1
2
3
4
5
package br.com.dclick.services;

public interface SimpleGateway {
? ? void call(String s);
}


Pronto! Basta agora adicionarmos o gateway em nosso arquivo de beans:

1
2
? ? :gateway id=“simpleGateway” default-request-channel=“input”
? ? ? ? service-interface=“br.com.dclick.services.SimpleGateway” />


Estamos dizendo aqui que nosso gateway irá despachar as mensagens para o canal input, e como o gateway recebe uma String, o Spring sabe que o conteúdo da mensagem que deve ser enviada é do tipo String. Vamos ao teste:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
? ? private SimpleGateway simpleGateway;
? ?
? ? @Test
? ? public void testChannels() {
? ? ? ? Assert.assertNotNull(this.simpleService);
? ? ? ?
? ? ? ? input.send(new GenericMessage(“hello!”));
? ? ? ?
? ? ? ? Assert.assertEquals(“hello!”, this.simpleService.getS());
? ? ? ?
? ? ? ? Message msg = (Message) this.output.receive();
? ? ? ? Assert.assertEquals(“hello!”, msg.getPayload());
? ? ? ?
? ? ? ? this.simpleGateway.call(“uma string”);
? ? ? ?
? ? ? ? Assert.assertEquals(“uma string”, this.simpleService.getS());
? ? }


Próximos passos


Spring Integration é uma ferramenta muito poderosa, que permite criarmos aplicações de qualquer porte com uma arquitetura muito desacoplada facilitando a escalabilidade e reação a mudanças externas. Repare que sua aplicação ganha um aspecto de arquitetura voltada a eventos que são disparados através de mensagens, e que não há limitações de tipos e quantidades de conexões. Por exemplo, nosso canal de saída poderia sem problemas ser o canal de entrada para um outro serviço, ou até mesmo para um outro método do mesmo serviço. Também existem várias regras de encaminhamento de mensagens disponíveis no spring integration, como por exemplo um roteador de mensagens, um replicador de mensagens, um agregador, etc. Veremos alguns exemplos no futuro.

Existem muitos outros pacotes disponíveis como por exemplo o de integração com o twitter, o de integração com arquivos, o de integração com jms, dentre outros. Veremos tais integrações mais para frente.

Por @Gust4v0_H4xx0r

As imagens foram tiradas do próprio site do Spring Integration.

« Entradas anteriores | Entradas recentes »

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 2791 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