Atenção: esse artigo tem um vídeo complementar. Clique e assista!

[lead]De que se trata o artigo:

A base do Spring Framework é seu container de injeção de dependências. Neste artigo veremos algumas boas práticas que, aplicadas ao uso do container de injeção de dependências, minimizam os custos de manutenção de sistemas baseados no framework.

Para que serve:

A maior parte dos problemas enfrentados pelos usuários iniciantes do Spring é decorrente da má gestão das configurações do container de injeção de dependências. Neste artigo, conheceremos algumas dicas que facilitam esta gestão.

Em que situação o tema é útil:

O tema é útil para todos aqueles interessados em extrair o máximo possível de produtividade e qualidade para seus projetos usando o Spring. Este conhecimento se mostra inestimável na compreensão dos demais recursos do framework, pois são todos baseados em seu container de ID.

Boas práticas com Spring:

O Spring Framework já possui seu valor comprovado pelo imenso número de aplicações que o usam como base. Neste artigo, veremos práticas que aumentam a qualidade e manutenibilidade de sistemas baseados nesta poderosa ferramenta, tendo como foco o container de injeção de dependências.[/lead]

O Spring é um framework não intrusivo usado na criação de aplicações corporativas que se tornou bastante popular como uma alternativa ao padrão EJB. É não intrusivo (ou lightweight) pois não é necessário que nossas classes referenciem o código fonte deste projeto, reduzindo assim o acoplamento. A popularidade do Spring é consequência do framework fornecer quase todas as vantagens oferecidas pelo EJB usando apenas POJOs, simplificando bastante o desenvolvimento de aplicações corporativas.

Não é exagero afirmar que todo este sucesso deve-se na realidade à aplicação do padrão de injeção de dependências (ID). A base do framework é o seu container de ID, que possibilitou a implementação de recursos no framework como gerência de transações, programação orientada a aspectos, acesso a dados, MVC e muitos outros. Fica nítida, portanto, a importância de conhecer bem o Container de ID do Spring que, quando usado seguindo boas práticas, tais como as descritas neste artigo, o torna uma poderosa ferramenta presente no cinto de utilidades de qualquer desenvolvedor.

A partir de agora vamos começar a analisar algumas boas práticas que devem ser aplicadas ao container. Como o leitor perceberá, em sua maioria são técnicas adotadas no modo como escrevemos a configuração do container. Estas nos ajudam a melhor gerenciar o comportamento do mesmo e facilitar a manutenção de nossos sistemas.

[subtitulo]Encapsule o container[/subtitulo]

O principal objetivo do container de injeção de dependências é reduzir ao máximo o acoplamento entre os componentes de nossos sistemas. Sendo assim, seria contraditório se o próprio Spring contribuísse para aumentar o número de dependências nos projetos em que é aplicado, o que ocorre quando o expomos diretamente. Para evitar este problema, devemos encapsular o container.

Em aplicações que não são executadas em um servidor de aplicaçõesé interessante que ocultemos o contexto do Spring. Para tal, criamos uma classe envoltória (um wrapper) que oculte o container de injeção de dependências, tal como exposto na Listagem 1. O Spring nos proporciona criar projetos sem a necessidade de um container EJB.

[nota]Wrapper: Uma classe wrapper é aquela usada para encapsular (“embalar”) outra classe. Normalmente este padrão é adotado em situações nas quais deseja-se evitar o acesso direto a algum recurso do sistema, como é o caso da Listagem 1.[/nota]

Listagem 1. Ocultando o Container de Injeção de Dependências.

public class Container {
 
 
    private ApplicationContext contextoSpring;
  
   private ApplicationContext getContextoSpring() {
     if (contextoSpring == null) {
       contextoSpring = new ClassPathXmlApplicationContext("di/spring.xml");
     }
     return contextoSpring;
   }
   
    public synchronized Object getBean(String nome) {
     ApplicationContext contexto = getContextoSpring();
     if (contexto != null) {
       try {
         return contexto.getBean(nome);
       } catch (NoSuchBeanDefinitionException ex) {
         return null;
       }
     }
     return null;
   }
   
    public synchronized Object getBean(String nome, Class classe) {
     ApplicationContext context = getContextoSpring();
     if (context != null) {
       return context.getBean(nome, classe);
     }
     return null;
   }
   
    public static synchronized Container getInstancia() {return _instancia;}
 
 
    private static Container _instancia = new Container();
   
    private Container() {}
   
  }

Como pode ser observado na Listagem 1, todos os métodos necessários para a obtenção dos beans encontram-se implementados nesta classe, evitando assim que os demais componentes do sistema acessem o contexto do Spring diretamente. Adotando esta prática, obtém-se outro benefício além da redução do acoplamento: caso seja necessário adotar algum outro container de injeção de dependências, todas as alterações necessárias serão feitas em um único local.

...

Quer ler esse conteúdo completo? Seja um assinante e descubra as vantagens.
  • 473 Cursos
  • 10K Artigos
  • 100 DevCasts
  • 30 Projetos
  • 80 Guias
Tenha acesso completo