Spring.NET: Inje��o de Depend�ncias em Aplica��es Multicamadas

Artigo do tipo Tutorial
Recursos especiais neste artigo:
Cont�m nota Quickupdate, Conte�do sobre boas pr�ticas.

Spring.NET - Como utilizar Injeç�o de Depend�ncias (DI) e Invers�o de Controle (IoC) em Aplicaç�es Multicamadas
A Injeç�o de Depend�ncias veio para trazer mais desacoplamento � programaç�o, apesar da t�cnica n�o ser nova, com o advento das grandes aplicaç�es e da necessidade de maior reuso e testabilidade, este assunto voltou com força total e tem sido conversa frequente entre arquitetos e engenheiros. Veremos todos os conceitos � cerca de DI e IoC juntos com o Spring.NET e depois vamos criar uma aplicaç�o desde a UML at� a implementaç�o final da camada de apresentaç�o, aplicando assim o Spring e sua injeç�o de depend�ncias em um cen�rio bem pr�ximo do real.

Em que situaç�o o tema � �til
Este artigo � �til a qualquer aplicaç�o .NET onde se deseje ter um maior n�vel de desacoplamento e testabilidade, aumentando ainda o reuso e consequentemente a produtividade das equipes que empregarem as pr�ticas citadas aqui.

O termo Injeç�o de Depend�ncias foi usado pela primeira vez por Martin Fowler em seu famoso artigo chamado Inversion of Control Containers and the Dependency Injection pattern que em portugu�s significa Containers de Invers�o de Controles e o Padr�o de Injeç�o de Depend�ncias.

Quando ouvimos falar de �fraco acoplamento� devemos compreender que os objetos precisam ter apenas depend�ncias necess�rias para desempenharem bem o seu papel e estas depend�ncias precisam ser muito poucas. Estas depend�ncias de objetos devem ser uma interface e n�o uma classe concreta. Esta � a vantagem de se usar o fraco acoplamento, porque oferece usabilidade, manutenibilidade e principalmente testabilidade para as aplicaç�es.

De acordo com Fowler, os termos Injeç�o de Depend�ncias (DI) e Invers�o de Controle (IoC) s�o muito parecidos: tendo a DI alguns tipos a menos que IoC, de forma que se use apenas o que h� de melhor na IoC. O motivo da troca de nome fora apenas de sem�ntica para que possa facilitar a compreens�o do leitor e daqueles que est�o aprendendo este padr�o de desenvolvimento.

O objetivo da Injeç�o de Depend�ncia � separar objetos que populam outros � tais objetos s�o chamados de montadores, ou assemblers � dos que fazem uso de implementaç�o de interfaces, onde esta implementaç�o � chamada de serviço.

A Injeç�o de Depend�ncias consiste em dois tipos ou estilos principais:

1) Injeç�o via Construtor

2) Injeç�o via Setter

Injeç�o via Construtor

Consiste em passar um objeto de Serviço que ser� injetado diretamente na classe via construtor. Na Listagem 1 podemos ver um exemplo de uma interface com os m�todos de operaç�o no banco de dados, enquanto que na Listagem 2 temos a simulaç�o de uma classe concreta implementando esta interface. Observe que na linha 5 temos a vari�vel de inst�ncia que ser� injetada na classe e na linha 13 temos a injeç�o propriamente dita atrav�s do construtor da Classe.

Listagem 1. Interface


  01    public interface IContatoDAL
  02     {
  03       void Salvar(Contato entidade);
  04       List<Contato> listarTudo();
  05       Contato listarPorId (int id);
  06       void Atualizar(Contato entidade);
  07       void Apagar(Contato entidade);
  08     }

Listagem 2. Classe acessando o Serviço IContatoDAL


  01 public class ContatoDAL:IContatoDAL    
  02    {  
  03       #region Atributos
  04       public Conexao Conexao{ get; set; }
  05       #endregion
  06       #region Construtor
  07       public ContatoDAL(Conexao conexao)
  08       {
  09         this.Conexao = conexao;
  10       }
  11       #endregion
  12     }

Injeç�o via setter

Faz a DI em um m�todo set dentro da Classe que ir� acessar o serviço, bastando referenci�-lo no framework para injet�-lo na Classe que ir� consumir o serviço, como mostra a Listagem 3.

Listagem 3. Injeç�o de Depend�ncias via Setter


   
         01  public class ManterContato : IManterContato
         02  {                  
         03   //pode ser feito desta forma
         04   private IContatoDAL dao;
         05   
         06   public IContatoDAL Dao
         07   {
         08         set { dao = value; }
         09   }              
         10   
         11   //ou pode ser feito desta forma
         12   
         13   public IContatoDAL Dao {get; set;}
         14   
         15   //Implementaç�o da Classe
         16  }

Veja na Listagem 3 que a depend�ncia que a classe ManterContato t�m da interface IContatoDAL � passada atrav�s de um m�todo Set, dessa forma n�o precisamos inicializar a vari�vel (linha 4), visto que o container de IoC/DI far� isso automaticamente assim que a classe ManterContato for utilizada na aplicaç�o. Al�m disso, podemos observar nesta mesma listagem que podemos fazer isso atrav�s de uma propery manual (linha 6) ou atrav�s de uma property autom�tica (linha 13).

Spring.NET

O Spring.NET � uma vers�o .NET do framework Spring criado para java e que � largamente usado pela comunidade do mesmo, sendo que o Spring.NET n�o se limita � injeç�o de depend�ncias, que � o seu prop�sito b�sico, mas estende suas funcionalidade � integraç�es em aplicaç�es corporativas.

O Spring.NET cont�m m�dulos de integraç�o para frameworks como NHibernate para persist�ncia, AOP � Programaç�o Orientada a Aspectos, ASP.NET MVC 2, ASP.NET MVC 3, NUnit para testes, Integraç�o SOA e MQs para troca de mensagens entre aplicaç�es utilizando barramentos, conforme podemos ver na Figura 1.

O Spring.NET � uma soluç�o de Container de IoC/DI para .NET, fazendo frente aos j� estabelecidos frameworks Ninject , Structure Map, Castle Windsor e Unity, contendo uma sem�ntica id�ntica a do java, por�m com implementaç�es totalmente distintas, at� por serem linguagens diferentes.

Figura 1. M�dulos do Spring.NET

Devido � extens�o do assunto, neste artigo utilizaremos apenas o m�dulo Core do framework pelo fato de que o mesmo � a base para compreens�o geral do Spring.NET.

Para instruç�es detalhadas sobre o que faz cada m�dulo, consulte a seç�o links. Por�m, entendendo a Spring.Core podemos compreender melhor os outros m�dulos.

Por que usar o Spring.NET?

Para responder a esta pergunta, vamos observar uma implementaç�o sem o Spring e outra com o Spring.

Para fins de exemplo, vamos criar uma classe chamada Conex�o que far� uma simulaç�o de acesso ao Banco de Dados, para isso criaremos ainda uma interface chamada IClasseDAL para o serviço da ClasseDAL. Na Listagem 4 podemos ver estas classes, onde temos a classe de conex�o (linha 1 � 9), a interface IClassDAL (linha 10 � 15), ClasseDAL (linha 17 � 47) e Principal (linha 49 � 60), que seria para simulaç�o da execuç�o da aplicaç�o.

Neste caso, na ClasseDAL temos dois construtores implementados. No primeiro, sem par�metros, ter�amos que instanciar uma nova conex�o para ser utilizada pelos m�todos da classe. J� no segundo receber�amos a conex�o via par�metro. Al�m disso, nos m�todos da classe temos que Abrir (linha 31) e Fechar (linha 43) a conex�o para controlar a mem�ria e evitar problemas de performance.

Listagem 4. Implementaç�o sem Spring.NET


  01     public class Conexao {
  02      public Boolean IsConectado {get; set;}
  03       public String Conexao {get; set;}
  04       public Conexao(){
  05             this.conexao = "Data Source=ALLSPARK;Initial 
                Catalog=ANS;User ID=usuario";
  06             
  07             //instruç�es de conex�o
  08       }
  09     }
  10     public interface IClasseDAL{
  11     
  12       List<Object> listarTudo();
  13       void Salvar(Object o);
  14       void Excluir(Object o);
  15     }
  16     
  17     public class ClasseDAL : IClasseDAL {
  18       private Conexao conexao = null;    
  19       public ClasseDAL(){
  20             this.conexao = new Conexao();
  21       }
  22       
  23       public ClasseDAL(Conexao conexao){
  24             this.conexao = conexao;
  25       }
  26       
  27       private List<Object> listarTudo(){
  28             
  29             try{
  30                   
  31                   conexao.abre
  32                   //Operaç�o
  33                   //...
  34                   ...
  35                   ...
  36                   ...
  37             } catch {
  38             
  39                   throw;
  40             
  41             } finally {
  42                   
  43                   conexao.fecha
  44             
  45             }
  46       }     
  47     }
  48     
  49     public class Principal {
  50       
  51       public static void main(){
  52       
  53             Object classe = new Object();
  54             
  55             ClasseDAL dal = new ClasseDAL();
  56            
  57             dal.Salvar(classe);
  58       }
  59       
  60     }

Na linha 55 instanciamos ClasseDAL para permitir que o objeto DAL acesse todas as operaç�es necess�rias. Observe que neste caso utilizamos o construtor padr�o da mesma, desta forma a conex�o foi criada dentro da pr�pria classe.

Na Listagem 5 temos as mesmas classes existentes na Listagem 4, por�m, com o uso do Spring.

Listagem 5. Mesma implementaç�o utilizando o Spring


   
  01     public class ClasseDAL : IClasseDAL {
           
  02       private Conexao conexao;
           
  03       public Conexao PConexao {
           
  04             set {
  05                   conexao = value;
  06             }
           
  07     }
                 
  08       private List<Object> listarTudo(){
                 
  09             try{
                       
  10                   conexao.Commit;
  11                   //Operaç�o
  12                   //...
                       ...
                       ...
                       ...
  13             } catch {
                 
  14                   conexao.Rollback;
                 
  15             }
  16       }     
  17     }
         
  18     public class Principal {
         
  19       public static void Main(){
                 
  20             IApplicationContext di = ContextRegistry.GetContext();
  21             IClasseDAL dal = (ClasseDAL) di.GetObject("ClasseDAL");
                 
  22             dal.listarTudo();
                 
  23       }
  24     }
"

[...] continue lendo...

Spring.NET: Inje��o de Depend�ncias em Aplica��es Multicamadas - Revista .NET Magazine 103

Veremos todos os conceitos à cerca de DI e IoC juntos com o Spring.NET e depois vamos criar uma aplicação desde a UML até a implementação final da camada de apresentação, aplicando assim o Spring e sua injeção de dependências.

Artigos relacionados