Spring Framework Parte 1 -> Dependency Injection

By Felipe Saab

Quem é dessa área e nunca ouviu falar de Spring Framework por favor levante a mão………….. Ótimo, todo mundo pelo menos já ouviu falar desse tal de Spring.

Durante esta série de tutoriais eu vou demonstrar o que é, pra que server e como vc pode utilizar o Spring para facilitar seus projetos.

Primeiramente, o que é esse tal de Spring afinal de contas? Spring é um framework que propicia um container para sua aplicação, ou seja, sua aplicação roda em cima do container do Spring. Tal container provê principalmente a Injeção de Dependência (ou Inversão de Controle, como era conhecido anteriormente) e a Programação Orientada a Aspectos.

Nesta primeira parte eu vou falar sobre o padrão Injeção de Dependência e os benefícios que ele provê. Vamos lá então:

O padrão de projeto Injeção de Dependência diz que uma classe não deve criar as suas dependências, em outras palavras, uma classe não deve instanciar seus atributos. Ao invés disso, eles devem ser injetados na classe através de um mecanismo externo, ou através de quem criou o objeto desta classe.

Ainda não está claro né… Vamos a um exemplo (baseado em um dos exemplos do livro Spring in Action 2, 2008) para facilitar as coisas.

Vamos imaginar que fomos contratados para desenvolver o software do Ídolos Spring?, uma competição de talentos musicais onde as pessoas cantam e/ou tocam. Primeiro de tudo vamos desenvolver uma interface genérica o suficiente para todos os nossos competidores:

public interface Competidor
    public void apresentar();
}

Pronto, agora todo mundo que for competir no Ídolos Spring vai ter que implementar essa interface para poder participar (é quase como se fosse a inscrição da competição… hahahahah péssima analogia.. ).

Vamos então aos competidores, vamos começar com um cantor. Um cantor não toca nenhum instrumento musical, ele apenas canta uma música. Vamos então à interface que descreve uma música:

public interface Musica
    public void cantar();
}

Baseado na interface, já podemos criar uma música:

public class AtireiOPauNoGato implements Musica {
 
    private static String[] letra = {
        "Atirei o páu no gato tô tô",
        "Mas o gato tô tô",
        "Não morreu reu reu",
        "Dona Chica cá",
        "Admirou-se se",
        "Do berro, do berro que o gato deu",
        "Miau !!!!!!"};
 
    public void cantar() {
        for (int i = 0; i < letra.length; i++) {
            System.out.println(letra[i]);
        }
    }
}

Legal, alguém vai cantar a famosa cantiga Atirei o pau no gato. Vamos codificar o cantor que irá fazer isso então:

public class Cantor implements Competidor {
 
    private Musica musica;
 
    public Cantor() {
        this.musica = new AtireiOPauNoGato();
    }
 
    public void apresentar() {
        musica.cantar();
    }
 
}

Prontinho. Agora toda vez que um cantor for se apresentar ele irá cantar Atirei o Pau no Gato. Mas pera ai, tem alguma coisa que não faz muito sentido aqui não tem?

Será que TODO cantor da nossa competição vai cantar a mesma música? Acho que não né… E do jeito que esta classe está implementada, nós temos que mudar a classe para ele cantar uma outra musica. Isso não é lá muito viável…

O que a Injeção de Dependência prega é que ao invés de o cantor se preocupar em ficar preparando a música que ele vai cantar, ele apenas vai receber a música impressa um pouco antes da competição e pronto.

Pensando nisso, o cantor ficaria assim:

public class Cantor implements Competidor {
 
    private Musica musica;
 
    public Cantor() {
    }
 
    public void setMusica(Musica musica) {
        this.musica = musica;
    }
 
    public void apresentar() {
        musica.cantar();
    }
}

Pronto, o cantor já não está mais preparando a sua música, pouco antes da apresentação ele vai receber a música (através do setter) e vai cantá-la (porque quem é bom faz ao vivo! hehehe).

Ok ok, até aqui não teve absolutamente NADA do tal do Spring, e vc provavelmente ainda não entendeu o porque desse monte de interfaces que parecem bobas não é mesmo?…

Vamos lá, advinhem quem vai dar a musica para o cantor? EXATO!! O container do Spring é quem vai ser responsável por entregar a música para o nosso cantor, ou em termos mais técnicos, o container é quem faz toda a linkagem dos beans (cada objeto manipulado pelo container é um bean, ex: uma musica, um cantor, um objeto que acessa o banco de dados, etc).

Para nós vermos como isso tudo funciona (pq ngm gosta de bla bla bla), vou abrir o NetBeans 6.8, criar uma nova Aplicação Java e criar as interfaces e classes descritas até aqui.

O NetBeans já traz as bibliotecas do Spring Framework junto com a IDE, o que te economiza um tempinho baixando-as. Clique com o botão direito na pasta Bibliotecas e cliquem “Adicionar bliblioteca…” e adicione a biblioteca “Spring Framework 2.5″

Uma vez que o Spring já está no classpath nós já podemos criar um arquivo de configuração para descrever os beans da nossa aplicação. Toda a configuração do container é feita através de arquivos XML.

Sendo assim eu criei mais um pacote (conf) e criei o arquivo idolos.xml dentro dele, este será o arquivo que o Spring irá utilizar para o container da nossa aplicação.

A tag root dos arquivos de configuração do Spring é a tag <beans> que define os namespaces e os DTDs necessários. De começo deixe o arquivo assim:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
</beans>

Essa é a estrutura básica de um arquivo de configuração (não se assuste com o tamanho dessa tag, vc não precisa decorar essas coisas).

Já que nossas classes estão prontas, vamos para o nosso primeiro competidor: José. O José vai cantar Atirei o Pau no Gato. Para declará-lo e dar a música pra ele vai ficar assim:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
       <bean id="atireiopau" class="injecaodependencia.AtireiOPauNoGato" />
 
       <bean id="jose" class="injecaodependencia.Cantor">
           <property name="musica" ref="atireiopau" />
       </bean>
 
</beans>

Aqui é que o Spring começa a trabalhar, cada tag no arquivo de configuração representa um objeto que o container irá gerenciar. No nosso exemplo, temos o bean “atireiopau” que é um objeto da classe AtireiOPauNoGato e o bean “jose” que eh um Cantor e vai cantar a música referenciada pelo bean “atireiopau”.

Em termos de código, seria como se o container fizesse o seguinte:

injecaodependencia.AtireiOPauNoGato atireiopau = new injecaodependencia.AtireiOPauNoGato();
injecaodependencia.Cantor jose = new injecaodependencia.Cantor();
jose.setMusica(atireiopau);

Essa é a mágica da Injeção de Dependência, o José teve a música “injetada” nele, se a gente quiser que ele cante outra música não precisamos reescrever a classe Cantor, apenas injetar uma música diferente nele.

Isso torna a aplicação muito mais desacoplada, muito mais fácil de testar e de reusar os módulos!!!

Mas e para usar isso agora? Como que a gente põe isso pra funcionar? Eu quero ver o José cantar!!!! hehehe

Vamos lá então, vamos ao código da classe principal do nosso exemplo:

public class Main {
 
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("conf/idolos.xml");
 
        Competidor competidor = (Competidor) ctx.getBean("jose");
 
        competidor.apresentar();
    }
 
}

A interface ApplicationContext é justamente o container (um dos existentes) do Spring Framework. Existe também a BeanFactory mas essa é bem mais simples e eu não irei comentá-la.

O que acontece nesse código então é o seguinte: é criado o container passando o arquivo de configuração que ele irá utilizar, depois é recuperado o bean “jose” do container (nesse momento o container instancia o bean e todas as suas dependências) e por fim, nós pedimos pro José se apresentar.

Você deverá ver ele cantando incrivelmente bem o clássico Atirei o Pau no Gato.

Porém o próximo competidor promete! Ele irá cantar E tocar Ciranda Cirandinha com uma gaita!! Essa eu quero ver!!

Vamos às classes necessárias para o próximo competidor:

public class CirandaCirandinha implements Musica {
 
    private static String[] letra = {
        "Ciranda , cirandinha,",
        "Vamos todos cirandar,",
        "Vamos dar a meia volta,",
        "Volta e meia vamos dar",
        "",
        "O anel que tu me destes,",
        "Era vidro",
        "E se quebrou.",
        "O amor que tu me tinhas",
        "Era pouco e se acabou.",
        "",
        "Ciranda , cirandinha,",
        "Vamos todos cirandar,",
        "Vamos dar a meia volta,",
        "Volta e meia vamos dar"};
 
    public void cantar() {
        for (int i = 0; i < letra.length; i++) {
            System.out.println(letra[i]);
        }
    }
}

public interface Instrumento {
    public void tocar();
}

public class Gaita implements Instrumento {
    public void tocar() {
        System.out.println("FUU FUU FII FII");
    }
}

public class CantorTocador extends Cantor {
 
    private Instrumento instrumento;
 
    public CantorTocador() {
        super();
    }
 
    public void setInstrumento(Instrumento instrumento) {
        this.instrumento = instrumento;
    }
 
    public void apresentar() {
        instrumento.tocar();
        super.apresentar();
        instrumento.tocar();
    }
 
}

Pronto, agora nosso próximo competidor está pronto para se apresentar. Sras e Srs dêem as boas vindas para Carlos:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
       <bean id="atireiopau" class="injecaodependencia.AtireiOPauNoGato" />
       <bean id="jose" class="injecaodependencia.Cantor">
           <property name="musica" ref="atireiopau" />
       </bean>
 
       <bean id="ciranda" class="injecaodependencia.CirandaCirandinha" />
       <bean id="gaita" class="injecaodependencia.Gaita" />
       <bean id="carlos" class="injecaodependencia.CantorTocador">
           <property name="musica" ref="ciranda" />
           <property name="instrumento" ref="gaita" />
       </bean>
 
</beans>

Agora basta chamar o Carlos para se apresentar ao invés do José:

public class Main {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("conf/idolos.xml");
 
        Competidor competidor = (Competidor) ctx.getBean("carlos");
 
        competidor.apresentar();
    }
}

E se a gente quisesse que o Carlos tocasse piano cantando Atirei o Pau no Gato? Simples:

public class Piano implements Instrumento {
    public void tocar() {
        System.out.println("PLIN PLIN PLIN");
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
       <bean id="atireiopau" class="injecaodependencia.AtireiOPauNoGato" />
       <bean id="jose" class="injecaodependencia.Cantor">
           <property name="musica" ref="atireiopau" />
       </bean>
 
       <bean id="ciranda" class="injecaodependencia.CirandaCirandinha" />
       <bean id="gaita" class="injecaodependencia.Gaita" />
 
       <bean id="piano" class="injecaodependencia.Piano" />
       <bean id="carlos" class="injecaodependencia.CantorTocador">
           <property name="musica" ref="atireiopau" />
           <property name="instrumento" ref="piano" />
       </bean>
 
</beans>

Basta “injetar” os beans desejados nas dependências e boa! Tudo segue seu fluxo natural.

Esta foi uma pequena (eu diria mínima) introdução à Injeção de Dependências no Spring Framework. O container ApplicationContext possui muuuuuito mais funções para gerenciar os seus beans, porém isso iria extender demais este assunto.

Acho que se você leu o post até aqui, vc conseguiu pegar o que eu quis passar: programar utilizando interfaces torna o seu código muito mais limpo, fácil de entender, fácil de dar manutenção, fácil de reutilizar, fácil de extender, ou seja, melhora tudo!!

Adicionando isso com a técnica de Injeção de Dependência torna a aplicação altamente desacoplada em termos de componentes (você pode utilizar a classe Cantor em qualquer outra aplicação, só precisa passar uma classe que implemente a interface Musica pra ele e tudo vai funcionar perfeitamente).

Os códigos fontes utilizados neste tutorial estão aqui.

[]s e até a próxima,
Saab.