Desenvolvendo em java visando o baixo acoplamento.

A apresentação foi bem legal e creio que consegui passar a mensagem para o pessoal. Por falar nisso, agradeço a todos que pararam alguns minutos pra me escutar.

Abaixo segue os slides da apresentação. O código fonte utilizado durante a apresentação está aqui.

O objetivo deste breve post é demonstrar um pouco de como criar e utilizar seus próprios objetos em javascript.

A forma mais simples de declarar um objeto em javascript é utilizando a forma literal

O código abaixo mostra exemplos de como utilizar este objeto.

Na leitura de uma propriedade, caso ela não exista, o retorno será undefined.

Objetos podem ser compostos de outros objetos, ex:

Objetos podem ter métodos.

Diferente da linguagem Java, é obrigatório o uso do operador this para acessar a variável valor. O uso do this em javascript vale mais um artigo, portanto, não entrarei em detalhes aqui.

A notação literal se parece e muito com o Json. O Json é uma forma simples e enxuta de representarmos um recurso. Por este motivo, vem ganhando muito espaço quando o assunto é integração de sistemas. Mais um assunto para outro post, rs.

Function Objects

Funções são objetos em javascript. Isto é responsável pela grande mágica que envolve a linguagem. Por exemplo, podemos criar uma função e atribuí-la a uma variável.

É possível criar um função sem nome e neste caso ela é considerada uma função anônima. Por exemplo, como uma função é um objeto, podemos ter um função que espera como parâmetro outra função. Confuso?

O código acima pode ser considerado um pouco de programação funcional com javascript.

Conclusão

Vejo muita gente dizendo que javascript é uma linguagem ruim e difícil de programar. Concordo que a linguagem peca em alguns detalhes, porém, quando utilizada de forma correta, nos possibilita fazer coisas sensacionais.

Para tirar o máximo da linguagem é preciso aprender a encapsular as lógicas em objetos, utilizar programação funcional, entender closures, etc… Tentarei explicar estes itens com mais detalhes nos próximos posts.

No time temos bons programadores que sempre utilizaram o hibernate mas não conheciam todo o potencial deste framework.

Abaixo segue os slides utilizados na apresentação.

Meu objetivo aqui não é mostrar a fundo como funciona a tecnologia e sim demonstrar em um pequeno exemplo algumas de suas vantagens. O exemplo consiste em um sistema de envio de mensagens. O usuário digita uma mensagem em um textfield e esta mensagem pode ser enviada de diversas formas, como email ou sms. Porém, no exemplo, teremos quatro módulos. A interface gráfica, o domínio, o enviador de mensagens por email e o enviador por SMS.

Seguindo a nomenclatura do OSGI, cada módulo é um Bundle. Um Bundle nada mais é do que um “jar” com algumas informações adicionais do MANIFEST.MF. Estas informações são utilizadas pelo framework OSGI. Como quase tudo no Java, a tecnologia OSGI é uma especificação e portanto, temos diversas implementações para escolher. Dentre elas, as mais famosas são Equinox (Projeto Eclipse) e Felix (Apache). Neste artigo utilizaremos o Equinox.

Faça o download no Equinox. Para este artigo precisaremos apenas do Jar. Execute o Jar para ter acesso ao console do Equinox.

java -jar org.eclipse.osgi_3.4.2.R34x_v20080826-1230.jar -console

Para visualizar os Bundles instalados, basta digitar o comando ss.

Como podemos ver, neste momento só temos um bundle instalado. O bundle do Equinox. Agora iremos criar o nosso bundle e adicioná-lo do Equinox. Criar um bundle é muito simples. Crie um simples projeto com a seguinte classe:

Esta classe é o activator do nosso bundle. O activator é utilizado pelo framework OSGI para iniciar ou parar um bundle.  Neste primeiro exemplo, o activator irá apenas imprimir mensagens quando for iniciado e parado. Agora precisamos alterar o MANIFEST do jar para torná-lo um bundle OSGI.

Veja que no MANIFEST passamos para o OSGI algumas informações do nosso bundle. Dentre elas o nome do bundle (SymbolicName) e qual a classe Activator. Agora vamos instalar este bundle no Equinox. Gere um jar do projeto e para instalá-lo no Equinox é simples:

install file:<nomeDoBundle>.jar

Para verificar se o bundle foi corretamente instalado, basta executar o comando ss:

O bundle está corretamente instalado, agora basta iniciá-lo:

start <idDoBundle>

Para parar o bundle:

stop <idDoBundle>

Agora que já sabemos como criar um bundle, vamos iniciar nosso exemplo. No exemplo, teremos quatro bundles.

• Domínio:  Como o próprio nome diz, ele armazena as classes de domínio do nosso exemplo. Teremos duas classes: Message e IMessageSender.
• EnviadorSMS: implementação de IMessageSender que envia mensagens por SMS.
• EnviadorEmail: implementação de IMessageSender que envia mensagens por Email.
• UI: interface gráfica do exemplo

Bundle UI

Iremos começar pelo bundle UI. O activator irá apenas criar o frame para o usuário entrar com a mensagem.

Veja que o bundle depende de uma classe chamada Message. Esta classe é nosso domínio, portanto, ela não faz parte deste bundle. Aqui entra outro detalhe do OSGI. A comunicação entre bundles é feita através de serviços. Podemos considerar este modelo como sendo um SOA dentro da VM. O bundle UI irá utilizar serviços do bundle Core. Vamos analisar o MANIFEST do bundle UI.

Veja a declaração Import-Package. Estamos importando um pacote do bundle core. Neste pacote estão os serviços que nosso domínio está disponibilizando. Importamos também o pacote javax.swing.

Agora precisamos criar o serviço.

Bundle Core

O Bundle Core possui duas classes de domínio. A interface dos enviadores e o domínio Message.

Interface:

Domínio:

Veja que a classe Message é composta por uma lista de services. Estes services são os enviadores de mensagens que serão utilizados. Veja que o método send apenas itera sobre a lista enviando a mensagem. Até aqui tudo é muito simples. Agora precisamos exportar a classe Message como sendo um serviço do bundle core. O módulo UI irá iteragir diretamente com este serviço para enviar as mensagens.

Primeiro precisamos dizer ao OSGI para exportar este pacote para outros bundles. Veja o MANIFEST:

Veja a informação Export-Package. Para uma classe ser visível para outro bundle, ela precisa estar dentro de um pacote exportado. No nosso caso, o bundle UI precisa da classe Message, portanto, precisamos exportar o pacote onde a classe está. Lembre-se que o bundle UI importou este pacote.

Para registrar o componente Message como um serviço, teremos que interagir diretamente com a API do OSGI. Quando o bundle core for iniciado, iremos registrar o serviço no contexto do OSGI. O código é simples:

O método registerService espera como parâmetros o nome do serviço (por recomendação é o nome da classe), o serviço em si e algumas configurações adicionais.

Agora precisamos alterar o bundle UI para utilizar o serviço Message. No activator do bundle UI, basta fazer o “lookup” do serviço utilizando seu nome (nome da classe) :

Se adicionarmos os dois bundles no Equinox, veremos que os dois bundles estão se comunicando. Agora precisamos criar os bundles que realmente enviam as mensagens.

Bundle Enviador Email e SMS

Os serviços de envio por email e por SMS serão novos serviços de nosso sistema. Portanto, deveremos criar um bundle para cada um. Desta forma poderemos controlá-los separadamente. Por exemplo, podemos parar o serviço de envio por SMS e deixar apenas o de Email sem afetar o funcionamento do sistema. O dois bundles possuem praticamente a mesma estrutura, portanto, irei economizar um pouco de linhas aqui.

O bundle enviador terá apenas uma classe que implementa a interface IMessageSender e a classe Activator. Esta interface está no bundle core, portanto, precisaremos importar o pacote da mesma forma que fizemos no bundle UI.

A classe enviador apenas implementa a nossa interface:

Enviar por SMS será um serviço do nosso sistema. Portanto, precisamos registrá-lo no contexto OSGI:

O bundle de Email é praticamente o mesmo código. A única diferença é a mensagem no System.out.

Veja que registramos o serviço com o nome da interface. Portanto, teremos dois serviços com o mesmo nome. Sempre que pedimos para o contexto o serviço com o nome da interface, ele irá executar uma lógica de prioridade para retornar apenas uma implementação.

Agora que temos dois serviços de envio de mensagem, precisamos alterar nosso bundle core para utilizá-los.  Para isso, utilizaremos um ServiceTrackerCustomizer.

ServiceTrackerCustomizer e ServiceTracker

Como vimos, utilizamos o serviceTracker para fazer o lookup de um serviço. Porém, no caso dos enviadores, precisamos saber quando um novo serviço de enviador está disponível ou quando um enviador for removido. Estas informações são importantes para alimentar a lista de serviços dentro do objeto Message.

Para ter acesso a estas informações, usaremos um ServiceTrackerCustomizer. O código é simples:

Basta implementar a interface ServiceTrackerCustomizer e codificar o que você deseja quando um serviço for adicionado, modificado ou removido. Simples!!!!

No nosso caso iremos adicionar ou remover o serviço da lista de serviços do nosso objeto Message. Também tem uma mensagem de “log” para nos ajudar com os testes.

Agora precisamos fazer mais uma pequena alteração no activator do bundle core. Precisamos registrar o nosso ServiceTrackerCustomizer como um listener para os serviços do tipo IMessageSender.

Utilizamos o serviceTrackerCustomizer junto com o ServiceTracker. Sempre que um serviço for adicionado, modificado ou removido, nosso componente será chamado.

Testando a aplicação

Agora que já codificamos, vamos testar a aplicação.

Crie os quatro jars ou faça ou download aqui:

• bundleCore.jar
• blundleUI.jar
• bundleEnviadorEmail.jar
• bundleEnviadorSMS.jar

Instale os quatro bundles no Equinox:

Inicie os bundles e teste a aplicação.

Veja que as mensagens serão enviadas por email e por SMS. No console do Equinox, pause o serviço de email:

stop <idBundle>

Tente enviar novamente uma mensagem. Como o serviço não está mais disponível, a mensagem foi enviada somente por SMS.

Poder parar módulos da aplicação sem que ela sofra efeitos colaterais é sensacional. Imagine que você descubra um erro crítico no módulo de SMS. Você não precisa tirar toda a aplicação do ar para corrigir este problema. Basta pausar o módulo de SMS. Todo o resto do sistema continuará funcionamento normal. Faça o teste com este pequeno exemplo. Pause e Inicie os serviços. Isto não afetará o Core e muito menos o UI.

Espero ter conseguido explicar um pouco do que é OSGI. Vale ressaltar que tem muito mais detalhes sobre controle de classpath e configuração de bundles que não nos atentamos aqui. Fica como tarefa para quem se interessou dar uma olhada nas outras funcionalidades.

Vale a pena olhar o projeto Spring-DM. O spring facilita muito a configuração de serviços além de propiciar um excelente conteiner de IoC.

Apartir do dia 04 de setembro eu faço parte de mais uma estatística do Brasil. A lista de desempregados. Isso mesmo!!! Estou saindo da Tata Consultancy Services. Passei quase um ano nesta empresa e aprendi muito com excelentes colegas de trabalho.

O motivo da saída é um intercâmbio de 03 meses no Canadá, mais específico em Vancouver. Espero poder praticar e melhorar meu inglês pois um bom conhecimento do inglês é muito importante na área de TI. Estou indo em busca de mais este conhecimento.

Bem… quem quiser me ajudar.. em dezembro estarei procurando emprego…rs

Estas linguagens são linguagens de alto nível, a grande maioria com tipagem dinâmica e com um Protocolo de Meta-Objeto (Meta-Object Protocol), ou MOP. Estas duas características proporcionam muitas facilidades e um enorme poder no desenvolvimento. Porém, quando não usadas com cuidado, podem causar grandes problemas.

Tipagem dinâmica é muito criticada pela comunidade de desenvolvedores, principalmente porque “escondem” alguns erros em tempo de desenvolvimento (compilação). Linguagens dinâmicas não são compiladas, portanto tipagem dinâmica faz todo sentido. Porém, existe algumas linguagens dinâmicas que utilizam de tipagem estática, como Groovy, para utilizar de técnicas como overloading de métodos e de construtor.

Meta-Object Protocol sem dúvida é a grande vantagem das linguagens dinâmicas. Em linguagens de programação como java, os objetos armazenam seus métodos e seus atributos. Com MOP, cada objeto tem um meta objeto associado e é no meta objeto que ficam os métodos. O objeto é responsável por armazenar seu estado. A grande vantagem é a possibilidade de alterar o meta objeto em tempo de execução e adicionar novas funcionalidades nos objetos.

Com o surgimento do Ruby e do framework Ruby on Rails, as linguagens dinâmicas vem ganhando força. Muitas empresas que utilizam metodologias agéis, estão aderindo a este tipo de linguagem, principalmente ao Ruby on Rails. Portanto, é visível que as linguagens dinâmicas e principalmente a linguagem Ruby poderá ser o próximo “boom” no desenvolvimento de software.

No último final de semana participei do evento falando em java 2009. Como sempre, o pessoal da Caelum arrebentou. As duas paletras do Jim Webber foram sensacionais.

As dicas que o Sérgio Lopes deu sobre o hibernate também foram excelentes. Concordo com ele que o grande problema do hibernate são os desenvolvedores que não se preocupam em utilizá-lo adequadamente.

Outra grande novidade foi o anúncio do vRaptor 3. Particularmente, eu sou fã deste framework.

Estou ansioso para o lançamento do livro que o pessoal da Caelum está escrevendo.

Infelizmente,  ainda não foi este ano que ganhei o Wii….

Tive o prazer de participar de mais um grande evento. Fico feliz por ver eventos bem organizados e com palestrantes de alto nível no Brasil.

Cada vez mais posso comprovar que a dupla SCRUM e RoR está muito forte e tem tudo para revolucionar o mercado de TI.

Destaco as palestras do Fabiano Milani e do Guilherme Chapiewski. Gostei muito das dicas do Guilherme sobre como se tornar um bom profissional de TI.

Resumindo, foi um bom esquenta para o Falando em Java 2009.

Quem quiser me seguir:
http://twitter.com/celodemelo

Namespace

O Módulo pode ser utilizado para prover um namespace para os componentes, mantendo-os mais organizados evitando possíveis problemas de sobrescrita. Veja o exemplo abaixo:

Devido às características dinâmicas da linguagem, o método verify da classe AccessControl foi sobrescrito e o resultado do código será ‘verify 2′. Esta sobrescrita pode ser intencional ou não.

Para deixar o código mais organizado e prevenir que o componente seja sobrescrito por engano, pode-se utilizar o módulo como namespace:

Para referenciar elementos que estão dentro de um módulo, usa-se Modulo::Elemento

Desta forma, a sobrescrita por engano já está evitada. O código abaixo irá imprimir:

verify
verify 2

Mixin

Mixin é um recurso interessante. Um módulo pode ser incluído em uma classe. Quando isso ocorre, a classe passa a ter os métodos declarados no módulo. Veja o exemplo abaixo:

A classe AccessControl não possui o método “testing”. Quando o interpretador do ruby não encontra um método um um objeto, o método method_missing é invocado.

No exemplo, o módulo MethodMissing foi incluído dentro da classe AccessControl. Desta forma, a classe AccessControl passou a ter os métodos definidos no módulo.

O código imprime:
verify 2
The method ‘testing’ doesn’t exist!!!!

—-

O conceito de módulo é sem dúvida um recurso muito interessante e bastante utilizado pelo framework Ruby on Rails.