© 2010, LinkedIn Corporation
Dentro os vários pradrões de projetos definidos e cultivados em diversas comunidades de desenvolvimento, surgiu um padrão que têm recebido uma atenção especial, O Repository. A necessidade da utilização desse padrão surgiu junto com a solidificação dos ORMs (Object Relacional Mapping), como o Hibernate, Entity Framework e etc.
O objetivo do Repository é fazer uma interface de abstração entre a camada de negócios e a camada de dados, criando um repositório de objetos do domínio, onde esses objetos podem ser acessados de maneira simples por quem o utiliza. Para sistemas com uma complexidade maior, pode trazer a solução para a conversação com o banco de dados, pois faz uma abstração total de como e onde estão armazenadas as informações, trazendo ao desenvolvedor somente a necessidade de instânciação de do objeto repository para acessar os objetos de seu modelo Como Funciona? Para a implementação deste padrão o primeiro passo é definir uma interface e uma classe abstrata que serão a base do repositório, assim partindo dessa base vamos definir classes Repository para cada objeto do nosso modelo (domínio), mas para objetos que estão agregados ou que estão dentro de uma composição não existe essa necessidade. Desta forma quando precisar de algum objeto do seu domínio basta instanciar o objeto repository correspondente ao objeto do seu modelo, e todos os objetos vão estar ao alcance do desenvolvedor.  Hoje um dos paradigmas mais utilizados para integração de sistemas é a arquitetura orientada a serviços SOA, e para entender e aplicar esse novo conceito é necessário o conhecimento de uma série de ferramentas e outros paradigmas, entre eles BPM( Bussiness Process Modeling), Linguagem BPEL, Documentos XML como o WSDL (Web Service Description Language), XSDs.
No meu trabalho final de curso, estou desenvolvendo a implementação de SOA em buscadores de Imagem, e uma boa parte do trabalho já está implementado. Quem tiver interesse de pesquisar e conhecer mais sobre o assunto pode entrar em contato direto comigo. Abaixo estou colocando o link para minha revisão bibliográfica, onde tem uma descrição detalhada de todas linguagens e conceitos que citei acima, e nos próximos posts pretendo falar um pouco mais desse assunto. Download
A Arquitetura Orientada à Serviços (SOA), é um dos assuntos mais discutidos entre os programadores, e tem seus diversos benefícios, entre eles a interoperabilidade, que é a capacidade de rodar seus serviços em qualquer plataforma ou linguagem.
Hoje vou mostrar como montar um serviço (Web Service) em Asp.Net, e cosumir o mesmo através da Linguagem Java. Web Service Asp.Net Primeiro criamos um projeto no Visual Studio, no meu caso utilizo o VS2010, vá em File->New->Project , na janela Wizard que abrir procure pela aba WEB e selecione ASP.NET Web Service Application:  Após a tela o wizard do Visual Studio vai gerar um serviço HelloWorld, no meu caso alterei para um Serviço que irá devolver um Objeto Livro, implementei a classe Livro dentro da própria classe do Web Service, como segue o código abaixo: namespace MeuServico
{
/// Feito isso é só rodar a aplicação que vamos ter nosso serviço rodando. Cliente Java Já temos o serviço rodando no Visual Studio agora vamos implementar um cliente Java para consumir esse serviço, para isso abra o NetBeans IDE, e contrua um projeto Java Application com o Nome ClientJava, na aba Projects clique com o botão direito, vá em New->Others e procure por Web Service Client, uma janela similar a esta se abrirá:   Selecione o método getLivro e clique em OKo código gerado será semelhante a este:  Agora rode o projeto Java e seu serviço am Asp.Net, já está sendo consumido em Java. Essa interoperabilidade é incrivel não é?.
 Olá Pessoal, hoje vou falar um pouco sobre Programação Orientada a Teste ou TDD, essa é uma das técnicas que vem sendo muito utilizadas dentro dos ambientes de desenvolvimento e que também está dentro da filosofia agile e XP(Extreme Programming) e sua utilização vem crescendo cada vez mais. Essa filosofia de desenvolvimento traz muitos benefícios, entre eles estão o desenvolvimento de um produto final melhor, uma boa organização de código, e um dos pontos mais importantes é que quando houver uma grande mudança no sistema você pode rastrear quais são os efeitos destas mudanças por meio dos teste feitos anteriormente. Para dar uma introdução de como funciona o TD vou dar um exemplo de como desenvolver um Placar de Futebol. Primeiro Cliclo O TDD é desenvolvido em ciclos. Em primeiro lugar desenvolvemos o a Interface do placar. Essa interface pode ser vista como o projeto do Placar, onde vão ser definidas as funções e variáveis. Para isso vamos criar um projeto Class Library no VS2010, com o nome de Placar, vamos criar uma Interface IPlacar uma classe Placar que vai implementar a interface criada, o projeto e os códigos devem ficar semelhantes as figuras abaixo:  namespace Placar
{
public interface IPlacar
{
int jogador1 { get; }
int jogador2 { get; }
string getPlacarAtual();
void addJogador1();
void addJogador2();
void clearPlacar();
}
}
namespace Placar
{
class Placar: IPlacar
{
public int jogador1 { get; set; }
public int jogador2 { get; set; }
public string getPlacarAtual()
{
throw new NotImplementedException();
}
public void addJogador1()
{
throw new NotImplementedException();
}
public void addJogador2()
{
throw new NotImplementedException();
}
public void clearPlacar()
{
throw new NotImplementedException();
}
}
}
Após montado o projeto básico, vamos começar a montar nosso primeiro teste, para isso vamos criar um novo projeto Class Library chamado Placar.Test, que é onde vamos testar nosso placar, para realizar os teste eu utilizo o NUnit que pode ser baichado aqui. para que o Nunit possa achar nossos teste adicione na referência do projeto a DLL do NUnit (nunit.framework) que está na pasta da instalação do NUnit. Criamos a classe de teste, com os primeiros teste:  namespace Placar.Teste
{
[TestFixture]
public class PlacarTest
{
[Test]
public void PlacarZerado()
{
IPlacar placar = new Placar();
Assert.AreEqual("0", placar.jogador1);
Assert.AreEqual("0", placar.jogador2);
Assert.AreEqual("0x0", placar.getPlacarAtual());
}
}
}
Com isso pronto podemos começar a testar. Abra o NUnit na aba file click em Open Project e procure pela DLL do Placar.Test, click em Run e terá o resultado do teste:  Segundo Cliclo O segundo ciclo consiste em implementar as falhas do primeiro teste e rodar o teste novamente, após feita a implementação temos o código abaixo: namespace Placar
{
public class Placar: IPlacar
{
public int jogador1 { get; set; }
public int jogador2 { get; set; }
public Placar()
{
jogador1 = 0;
jogador2 = 0;
}
public string getPlacarAtual()
{
return jogador1.ToString() + "x" + jogador2.ToString();
}
public void addJogador1()
{
throw new NotImplementedException();
}
public void addJogador2()
{
throw new NotImplementedException();
}
public void clearPlacar()
{
throw new NotImplementedException();
}
}
}
Fazendo o teste novamente vemos que occorre tudo como o esperado:  Terceiro Ciclo Agora montamos o segundo deste, onde adicionamos pontos a jogador1 e ao jogador2 também zeramos o placar: namespace Placar.Teste
{
[TestFixture]
public class PlacarTest
{
[Test]
public void PlacarZerado()
{
IPlacar placar = new Placar();
Assert.AreEqual(0, placar.jogador1);
Assert.AreEqual(0, placar.jogador2);
Assert.AreEqual("0x0", placar.getPlacarAtual());
}
[Test]
public void PontuaJogadores()
{
IPlacar placar = new Placar();
placar.addJogador1();
placar.addJogador2();
Assert.AreEqual("1x1", placar.getPlacarAtual());
placar.clearPlacar();
Assert.AreEqual("0x0", placar.getPlacarAtual());
}
}
}
Executando o teste temos o resultado:  Da mesma forma fazemos a implementação do Placar e aplicamos o teste novamente: namespace Placar
{
public class Placar: IPlacar
{
public int jogador1 { get; set; }
public int jogador2 { get; set; }
public Placar()
{
jogador1 = 0;
jogador2 = 0;
}
public string getPlacarAtual()
{
return jogador1.ToString() + "x" + jogador2.ToString();
}
public void addJogador1()
{
jogador1++;
}
public void addJogador2()
{
jogador2++;
}
public void clearPlacar()
{
jogador1 = 0;
jogador2 = 0;
}
}
}
 Esse post foi apenas uma introdução, de como fazer um desenvolvimento orientado a testes. No começo pode ser um pouco trabalhoso, mas com o andamento do desenvolvimento esse processo pode até facilitar, pois tudo que foi desenvolvido até um dado ponto foi bem testado, e a cada mudança que você faz no programa os testes anteriores checam se houve alguma alteração no comportamento geral do sistema. Por hoje é só, no próximo post vou aprofundar um pouco mais no NUnit e suas funções.Abraço.
Olá Pessoal, este é o primeiro post no Blog, e finalmente depois de algumas tentativas de encontrar um nome, ele simplesmente apareceu, estava no adesivo da janela do quarto, nunca tinha reparado, mas muito legal, ele tem um desenho meio psicodélico, e no centro o escrito “Groover”, depois posto a foto aqui, e para começar um blog nada melhor que um bom nome “Programming On Groove”.
Bem, o objetivo é mostrar um pouco do mundo da programação, de maneira objetiva e descontraída, e também de compartilhar minha caminhada de aprendizagem. Espero que gostem, e comentem. Um abraço a todos e Aproveitem.
Assinar:
Postagens (Atom)
Gabriel Oliveira
|
Lembrete sobre o convite de Lúcio Gabriel Oliveira de Almeida
... | segunda-feira, 8 de novembro de 2010 |
