Olá, pessoal.

No artigo de hoje, vamos ver como usar annotations no Spring para fazer a injeção de dependência. Nos artigos anteriores, vimos como fazer isso de forma declarativa, ou seja, usando o xml. Agora, vamos para algo mais clear, pois sistemas grandes e muitas informações no xml podem ser um pesadelo durante a manutenção.

Let’s go…

Iniciando

Vamos criar um java project SpringAnnotations com a seguinte estrutura:

Criaremos uma interface e uma classe que implementa a mesma:

    public interface MachineRegister {

                    public void register();

    }

    public class Caixa1 implements MachineRegister {

                    @Override

                    public void register() {

                                   System.out.println(“Caixa 1 registrado”);}

    }

 

E agora teremos a classe que tem dependência:

public class CentralMachine {

                    private MachineRegister machineRegister;

                    public CentralMachine(MachineRegister machineRegister) {

                                   super();

                                   this.machineRegister = machineRegister;

                    }

                    public void setMachineRegister(MachineRegister machineRegister) {

                                   this.machineRegister = machineRegister;

                    }

                    public MachineRegister getMachineRegister() {

                                   return machineRegister;

                    }

                    public void register() {

                                   machineRegister.register();                      

                    }}

                }

                public void register() {

                               machineRegister.register();                      

                }}

 

Se fôssemos declarar essa classe no xml, seria assim:

<bean  id=”caixa1″ class=”br.com.camilolopes.classes.Caixa1″/>

 <bean  id=”centralMachine” class=”br.com.camilolopes.classes.CentralMachine”>

 <constructor-arg name=”caixa1″ ref=”caixa1″/>

 </bean>

Mas veremos como será via Annotations a seguir.

Usando Annotations

Vamos ver alguns conceitos importantes com os quais você vai se deparar no código a seguir, mas resolvi dar um overview antes.

No Spring, a dependency injection via annotations não vem configurada por default, é preciso informar isso ao .xml. Para fazer isso, precisamos apenas adicionar a seguinte linha

<context:annotation-config />

E atualizar o cabeçalho do beans para:

    xmlns:context=”http://www.springframework.org/schema/context”

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context-3.1.xsd”

Feito isso, podemos remover as injeções de dependência.

O arquivo ficará assim:

    <beans xmlns=”http://www.springframework.org/schema/beans”

    xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”

    xmlns:context=”http://www.springframework.org/schema/context”

    xsi:schemaLocation=”http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context-3.1.xsd“>

    <!– Aqui estamos declarando o beans  –>

    <bean  id=”caixa1″/>

     <bean  id=”centralMachine” class=”br.com.camilolopes.classes.CentralMachine”/>

     <context:annotation-config/>

    </beans>

 

Agora vamos dizer ao Spring as dependências via annotations. Na classe CentralMachine, adicione a seguinte anotação:

public class CentralMachine {

                    @Autowired

                    private MachineRegister machineRegister;

                    @Autowired

                    public CentralMachine(MachineRegister machineRegister) {

                                   super();

                                   this.machineRegister = machineRegister;

                    }

 

@AutoWired Annotation

Para injetar a dependência, usamos anotação @Autowired. Assim estamos dizendo que a classe X tem uma dependência de Y.

Problema

Quando temos uma interface que é implementada por mais de uma classe, como o Spring vai saber qual queremos?

Ele não vai saber, porque o Spring não tem bola de Cristal. Simplesmente vai lançar uma exceção NoSuchBeanDefinitionException.

Resolução

    @Qualifier Annotations

    Permite dizer para o Spring qual implementação ele deve considerar, passamos o id do bean.

    public class CentralMachine {

                    @Autowired

                    @Qualifier(“caixa1″)

                    private MachineRegister machineRegister;

 

Agora vamos criar uma classe com o método main para testar:

public class Main {

                    public static void main(String[] args) {

    //                           essa classe é o container

                    ApplicationContext applicationContext = new ClassPathXmlApplicationContext(

                                                                   “conf/springconfiguration.xml”);

                     CentralMachine bean = (CentralMachine) applicationContext.getBean(“centralMachine”);

                                   bean.register();

                    }}

 

Resultado:

Pronto. Estamos usando annotations para fazer a injeção de dependência no Spring. Simples, não? Observe que diminuímos algumas configurações que teríamos no xml e passamos a fazer direito no código. Particularmente, eu gosto muito de annotations.

Os projetos

GitHub: https://github.com/camilolopes/workspacespring

Vou ficando por aqui…

See ya!!