Top Posts

Estágio em T.I

Continue lendo

Série Spring:Injeção de dependência com Spring via Annotations

Posted by camilolopes | Posted in Series, Spring | Posted on 05-04-2013

0

olá Pessoal,

No post de hoje vamos ver como usar annotations no Spring para fazer a injeção de depência. Nos posts 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 pode ser um pensadelo durante a manuteção.

lets go…

Iniciando

Vamos criar um java project SpringAnnotations com a seguinte estrutura:

springannotationsproject

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();                      

                }}

 

Se fossemos 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 que você vai se deparar no código a seguir, mas resolvi dar um overview antes. 

No Spring a dependency injection via annotations nao vem configurado 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 injenção 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 injectar a dependencia 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:

resultspringannotations

 

Pronto. Estamos usando annotations para fazer a injeção de depência no Spring. Simples não? Observe que diminuimos  algumas configuração que teriamos que 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!!

Related Posts with Thumbnails

Write a comment