Vida de Coder

Autowiring

2009-03-16T11:14:00.000-07:00

Um adendo à postagem do Conde:

Se quiser deixar tudo "anotado", inclusive seu DAO, não precisa configurar o SessionFactory, uma opção é colocar ele como "autowired".

Ou configure "na mão":

@Autowired
public ISIDaoImpl(SessionFactory sessionFactory) {
setSessionFactory(sessionFactory);
}

Ou coloque como padrão no seu contexto:

<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-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd"
default-autowire="byName">

O autowire significa que o Spring irá descobrir qual é a dependência.

No segundo exemplo, você nem precisa colocar na classe o que será autowired. O Spring vai procurar todas as dependências da classe e se encontrar outra classe com o mesmo nome, irá injetar esta dependência. Como mágica!

Embora este método seja muito prático, é bom não abusar. Ele pode incentivar alguns erros humanos e inconsistência. Às vezes apesar de levar mais tempo, é melhor ter o xml com as dependências explicitas para maior controle.

Além disso, essas comodidades podem custar tempo. Tempo de execução! Segundo o blog ObjectLab, autowiring é mais lento. Eu pessoalmente não fiz o teste. Na grande maioria das vezes esse é um fator de peso na modelagem de um sistema, então talvez ainda valha a pena usar um contexto artesanal.

O que acham? Qual á a experiência de vocês com isso? Vale a pena sacrificar rapidez do sistema para praticidade do código?

Chuck Norris

2009-02-27T06:33:00.001-08:00

Alguém viu isso?

http://www.submarino.com.br/produto/6/21321654/biography+-+chuck+norris+-+vox+music+comercio+importacao+exp.ltda.

Funcionalidades bizarras do Java

2009-02-27T06:22:00.000-08:00

Alguém já viu var args aplicado em algum projeto de verdade?

E generics (com wildcards)?

Spring - Injeção de dependência por anotação

2009-02-26T14:10:00.000-08:00

Primeiramente gostaria de agradecer a Lia por ter me convidado a postar neste blog. Agora vamos ao que interessa :-)

Algo que tenho usado no meu dia a dia é injeção de dependência no Spring por anotação. Nada contra configurar todos os beans em um contexto XML, mas as vezes usar anotação facilita um pouco nossa vida.

As anotações são muito simples, vejam:

@Component - Anotação que faz com que o bean seja registrado no Spring. Esta anotação é genérica e serve para qualquer bean, seja ele um serviço, um dao, um controller, etc...

@Resource - Procura pelo bean especificado e o injeta na classe, exemplo, @Resource(name="serviceA") vai procurar pelo bean serviceA que está registrado no contexto Spring.

As anotações abaixo são especializações de @Component e servem para registrar o bean no spring, entretanto, podem prover algumas funcionalidades inerentes a camada a que pertencem:

@Repository - Para anotar sua camada de persistência.
@Service - Para anotar sua camada de serviço
@Controller - Para anotar sua camada de controller.

Para que o spring possa procurar por classes anotadas no seu classpath, é necessário adicionar a seguinte linha no seu applicationContext.xml :
<context:component-scan package="br.com...">
onde base-package seria a partir de qual pacote você deseja que o spring procure por beans gerenciaveis.

Vou mostrar um exemplo muito simples de como utilizar o spring desta forma...

A estrutura do projeto é a seguinte:

O applicationContext.xml fica desta forma:

<beans xmlns="http://www.springframework.org/schema/beans" xsi="http://www.w3.org/2001/XMLSchema-instance" context="http://www.springframework.org/schema/context" schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

<context:component-scan package="br.com.vidadecoder">

</context:component-scan>

</beans>

A classe ServiceA:

package br.com.vidadecoder.service;
import org.springframework.stereotype.Service;

@Service(value="serviceA") //Faz com que o Spring registre o bean como serviceA no contexto.
public class ServiceA {
public void doServiceAStuff() {
System.out.println("Doing something with service A");
}
}

A classe ServiceB:

package br.com.vidadecoder.service;
import org.springframework.stereotype.Service;

@Service("serviceB") //Faz com que o Spring registre o bean como serviceB no contexto.
public class ServiceB {
public void doServiceBStuff() {
System.out.println("Doing something with service B");
}
}

O bean Facade, que é o bean onde estes dois serviços serão injetados:

package br.com.vidadecoder.controller;

import javax.annotation.Resource;
import org.springframework.stereotype.Controller;
import br.com.vidadecoder.service.ServiceA;
import br.com.vidadecoder.service.ServiceB;

@Controller(value="facade")
public class Facade {

@Resource(name="serviceA") //Faz com que o spring injete o bean serviceA
private ServiceA serviceA;

@Resource(name="serviceB")//Faz com que o spring injete o bean serviceB

private ServiceB serviceB;

public ServiceA getServiceA() {
return serviceA;
}
public void setServiceA(ServiceA serviceA) {
this.serviceA = serviceA;
}

public ServiceB getServiceB() {
return serviceB;
}
public void setServiceB(ServiceB serviceB) {
this.serviceB = serviceB;
}

public void runBothServices() {
serviceA.doServiceAStuff();
serviceB.doServiceBStuff();
}

}

e por fim classe Main:

package br.com.vidadecoder.cmd;

import org.springframework.context.support.ClassPathXmlApplicationContext;
import br.com.vidadecoder.controller.Facade;

public class Main {

public static void main(String[] args) {
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
Facade facade = (Facade) ctx.getBean("facade");
facade.runBothServices();
}

}

Para maiores informações, acessem a documentação do Spring, na parte Annotation Driven Configuration:

Documentação do Spring

Neste exemplo utilizei o Spring na versão 2.5 .

Primeiro Post

2009-02-26T10:49:00.000-08:00

Sejam bem-vindos ao blog Vida de Coder.

Esperamos compartilhar nossas experiências técnicas, pessoais e profissionais por aqui. Desde as mais básicas até as mais bizarras.

Divirtam-se!