Spring – DI Utilizando Annotations

Para que se possa habilitar a configuração dos beans por anotações, será utilizado no arquivo de configuração do Spring o elemento <context:annotationconfig/>. A listagem a seguir ilustra o uso deste elemento.


<?xml version="1.0" encoding="UTF-8"?>
<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.0.xsd">
<context:annotation-config/>
</beans>

A listagem seguinte ilustra a classe Message, que possui alguns atributos prédefinidos no código e seus respectivos métodos de acesso.


@Component
public class Message {
@Value("Somebody")
private String author;
@Value("It's DI with Spring's annotation")
private String message;
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}

A classe MessegerImpl implementa a interface Messeger. A anotação @Service é uma especialização da anotação @Component, ela é usada especificamente para indicar um serviço.


@Service("messeger")
public class MessegerImpl implements Messeger {
@Override
public void writeMessage(Message message) {
System.out.println("Author: " + message.getAuthor());
System.out.println("Message: " + message.getMessage());
}
}

A próxima classe é a WelcomeController, nesta classe de controle existem dois atributos: uma mensagem e um mensageiro. Estes atributos são anotados com o @Autowired, isto fará com que o Spring injete uma instância da classe correspondente no atributo. Pode-se notar então que os atributos não são instanciados, eles são usados diretamente.


@Controller
public class WelcomeController {
@Autowired
private Message message;
@Autowired
private Messeger messeger;
@RequestMapping("/showMessage")
public void showMessage(){
messeger.writeMessage(message);
}
}

Fonte: TAVARES, L. A; TRIPOLI, C. S. – SAS – Sistema de Avaliações e Simulados – Pouso Alegre. UNIVÁS, 2010. 76f.

SAS – Sistema de Avaliações e Simulados

No final do ano passado apresentei o meu TCC – Trabalho de Conclusão de Curso, que consistiu em um projeto chamado SAS – Sistema de Avaliações e Simulados.

Este trabalho tem como objetivo apresentar uma proposta de software para auxiliar nos processos avaliativos. A ferramenta desenvolvida possibilita ao professor a geração de avaliações e simulados, correção e análise de desempenho dos mesmos. Os testes poderão ser realizados online ou poderão ser impressos. Alunos também poderão acessar relatórios de desempenho. A modelagem do sistema foi feita utilizando a metodologia de desenvolvimento ICONIX que é apresentada no decorrer do trabalho. O sistema foi desenvolvido utilizando a linguagem Java, e alguns frameworks como Spring e EclipseLink. Além das tecnologias, são abordados conceitos relacionados à avaliação, ao ENADE e à avaliação institucional.

O trabalho e a apresentação em Power Point pode ser baixada nos links abaixo:

TCC – SAS Sistema de Avaliações e Simulados em PDF

TCC – Apresentação SAS Sistema de Avaliações e Simulados em PDF

Artigo Integrando Spring 3.0 e JPA 2.0 – Java Magazine 83

A revista Java Magazine deste mês (edição 83) trás um artigo que escrevi sobre a integração do framework Spring com JPA.

O artigo trata de como fazer a integração do Spring 3.0 e JPA 2.0. No decorrer do artigo é implementado um exemplo demonstrando o funcionamento das duas tecnologias e como elas podem trazer vantagens para a camada de persistência da sua aplicação, simplificando e desacoplando código, obtendo desta forma, facilidade de manutenção e um código mais limpo.

Abaixo segue a lista de todos os artigos publicados nesta edição:

A versão digital desta edição já está liberada e acredito que em breve a versão impressa já deve estar nas bancas. Espero que gostem do artigo!

Integração JPA + Spring

Neste exemplo será utilizado a versão do spring 2.5.6, hibernate-distribuition 3.3.1, hibernate-entitymanager 3.4 e hibernate-annotation 3.4, como IDE está sendo usado o Eclipse e como servidor o Tomcat. Abaixo segue a relação com os jars necessários:

hibernate3.jar c3p0.jar
antlr.jar commons-beanutils-1.7.0.jar
asm.jar commons-pool-1.4.jar
asm-attrs.jar jstl.jar
cglib.jar jta.jar
commons-collections.jar oro.jar
commons-logging.jar slf4j-api.jar
dom4j.jar slf4j-simple.jar
ehcache.jar spring.jar
javassist.jar spring-aop.jar
jta.jar spring-beans.jar
hibernate-annotations.jar spring-context.jar
hibernate-commons-annotations.jar spring-context-support.jar
hibernate-entitymanager.jar spring-core.jar
ejb3-persistence.jar spring-orm.jar
jboss-archive-browsing.jar spring-tx.jar
postgresql-8.2-504.jdbc4.jar spring-web.jar
spring-webmvc.jar standard.jar

No eclipse será criado um Web Dinamic Project, dentro do projeto criado será adicionado as libs no diretório WebContent -> WEB-INF -> lib:

imagem

A aplicação exemplo rodando:

imagem

Clique no link para baixar o tutorial completo em PDF: Spring+JPA

Clique aqui para baixar o projeto sem as libs

Clique aqui para baixar as bibliotecas necessárias

Clique aqui para baixar o sql do exemplo

Injeção de Dependência com Spring

Injeção de dependência nada mais é que quando um componente não instancia suas dependências mas sim o ambiente as fornece automaticamente. Vamos demonstrar isso com e sem o Spring:

Primeiro temos uma classe Monitor que será usada para interação com o usuário. Ela apenas escreve uma mensagem no console:

public class Monitor {

	public void exibeMensagem(String mensagem) {
		//Exibe mesagens para o usuário

		System.out.println("[MONITOR]" + mensagem);
	}
}

Agora teremos uma classe Teclado que será usada para ler algo que o usuario digitar:

public class Teclado {

	public String ler() {
		//Lè texto do usuário

		String texto = null;
		System.out.println("[TECLADO]>");
		try {
			texto = new BufferedReader(
new InputStreamReader(System.in)).readLine();
		} catch (IOException e) {
			System.out.println("Erro lendo teclado");
			e.printStackTrace();
		}
		return texto;
	}
}

Depois teremos a classe Impressora que apenas imprime o texto que a classe Teclado leu.

public class Impressora {

	public void imprimirTexto(String texto) {
		//Nossa impressora apenas escreve na tela
		//o texto digitado pelo usuario

		System.out.println("[IMPRESSORA]" + texto);
	}
}

E agora iremos montar o computador!!! Nesta classe temos referencias de todas as classe que compoe o computador, a classe Teclado, Monitor e Teclado. Perceba que não iremos instanciar nenhuma das dependências aqui.

Não podemos esquecer os metodos setter, pois é ele será usado para injetar as dependências tanto com o Spring quanto sem ele. Esta classe possui també, um método para ligarmos o nosso computador, que chamará o monitor para exibir uma mensagem ao usuário, o teclado para ler a mensagem e a impressora para imprimir:

public class Computador{

	private Teclado _teclado = null;
	private Monitor _monitor = null;
	private Impressora _impressora = null;

	public void setImpressora(Impressora impressora){
		_impressora = impressora;
	}

	public void setMonitor(Monitor monitor){
		_monitor = monitor;
	}

	public void setTeclado(Teclado teclado){
		_teclado = teclado;
	}

	public void ligar(){
		_monitor.exibeMensagem("Digite texo para impressão:");
		String texto = _teclado.ler();
		_impressora.imprimirTexto(texto);
		_monitor.exibeMensagem("Texto impresso!");
	}
}

Primeiro vamos criar uma classe para inicializar nossas depêndencias. Veja que criamos um objeto computador e configuramos cada dependência e depois ligamos o computador.

public class IniciaComputadorSemSpring {

	public static void main(String[] args) {

		Computador computador = new Computador();
		computador.setImpressora(new Impressora());
		computador.setTeclado(new Teclado());
		computador.setMonitor(new Monitor());
		computador.ligar();
	}
}

Agora iremos fazer o mesmo trabalho acima usando o Spring:

cria-se então o arquivo applicationContext.xml, este arquivo deve ficar no src do seu projeto. Cria-se um bean para a classe computador e passamos como propriedade para ele três outros beans que referenciam cada um respectivamente as classes Impressora, Teclado e Monitor.


<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

	<bean id="computadorBean" class="teste.computador.Computador">
<property name="impressora" ref="impressoraBean" />
<property name="teclado" ref="tecladoBean" />
<property name="monitor" ref="monitorBean" />
	</bean>

	<bean id="impressoraBean" class="teste.computador.Impressora" />

	<bean id="tecladoBean" class="teste.computador.Teclado" />

	<bean id="monitorBean" class="teste.computador.Monitor" />

</beans>

Agora criaremos a classe com outro método main para a inicialização com o Spring, aqui carregamos nosso applicationContext.xml e criamos um objeto Computador inicializando-o com o computadorBean declarado no applicationContext.xml

<pre>public class IniciaUsandoSpring {

	public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
		Computador computador = (Computador) applicationContext.getBean("computadorBean");
		computador.ligar();
	}
}

Referência Bibliográfica:  Apostila Spring – Phillip Calçado “Shoes”