This document was uploaded by user and they confirmed that they have the permission to share
it. If you are author or own the copyright of this book, please report to us by using this DMCA
report form. Report DMCA
Overview
Download & View Spring Framework 2.0 - Diego Pacheco as PDF for free.
Spring Framework (2.0) Framework para Desenvolvimento de Aplicações em Java
Diego Pacheco Dez/2007
Apostila desenvolvida especialmente para a Crom Microsystems. Sua cópia ou reprodução é livre.
Sobre o Autor
Diego Pacheco Técnico em Processamento de Dados e graduando em Ciências da Computação(7º sem.) na Ulbra. Já trabalhou com desenvolvimento de software em VB, ASP, .NET e PHP. Atualmente é Arquiteto de Software, certificado pela Sun, atuo desenvolvendo soluções corporativas em arquitetura JEE, provendo coaching/mentoring em software e processo de desenvolvimento de software. Gosto muito de música, tocar guitarra, jogar PSP, Bloggar, Ler e principalmente as incríveis histórias do Conan. Mantenho o blog < http://diego-pacheco.blogspot.com/> a mais de 3 anos.
Spring Framework – Framework para Desenvolvimento de Aplicações Java
Sumário 1. Introdução .................................................................................................................... 1-1 Objetivos ...................................................................................................................................1-2 Conceitos Básicos .................................................................................................................1-3 Cenários de uso ....................................................................................................................1-7 Portifólio ...............................................................................................................................1-10 Download ..............................................................................................................................1-12 Estrutura de Diretórios ..................................................................................................1-13 Exercícios ..............................................................................................................................1-15 Espaço para anotações ....................................................................................................1-16
2. Container IoC .............................................................................................................. 2-1 Objetivos ...................................................................................................................................2-2 IoC – Inversion of control ...............................................................................................2-3 Registrando Beans .............................................................................................................2-13 Singletons e lazy Initialization .................................................................................2-15 Lazy Initialization ...........................................................................................................2-18 Scopos dos Beans ................................................................................................................2-20 Criando seu próprio scope ............................................................................................2-23 Injeção via setter.................................................................................................................2-27 Injeção via construtor ......................................................................................................2-29 Injeção de coleções .............................................................................................................2-31 Injeção entre beans colaboradores ............................................................................2-36 Instanciando o contexto Web .......................................................................................2-40 Exercícios ..............................................................................................................................2-42 Espaço para anotações ....................................................................................................2-43
3. Manipulação de Beans .......................................................................................... 3-1 Objetivos ...................................................................................................................................3-2 Resource Loaders .................................................................................................................3-3 Init-Metohd e InitializingBean ...................................................................................3-4 Herança de Definições ......................................................................................................3-7 Validação ..............................................................................................................................3-10 Bean Wrapper......................................................................................................................3-13 BeanPostProcessors ............................................................................................................3-17 Diego Pacheco – http://diego-pacheco.blogspot.com
I
Spring Framework – Framework para desenvolvimento de aplicações Java
Spring Framework – Framework para desenvolvimento de aplicações Java
4. Persistência .................................................................................................................. 4-1 Objetivos ...................................................................................................................................4-2 Hierarquia de Exceptions ...............................................................................................4-3 Acesso a dados usando JDBC ........................................................................................4-5 Trabalhando com DataSources ....................................................................................4-5 Trabalhando com JDBCTemplate ..............................................................................4-7 Session Factory Bean ........................................................................................................4-11 Hibernate Template..........................................................................................................4-13 Transações Declarativas .................................................................................................4-18 Exercícios ..............................................................................................................................4-22 Espaço para anotações ....................................................................................................4-23
5. Facilitadores ................................................................................................................ 5-1 Objetivos ...................................................................................................................................5-2 Envio de E-mails ................................................................................................................5-3 Agendamento de tarefas com JDK Task .................................................................5-10 @Aspect Support .................................................................................................................5-16 Testing Support ...................................................................................................................5-23 AbstractDependencyInjectionSpringContextTests ..............................................5-24 AbstractAnnotationAwareTransactionalTests .....................................................5-27 AbstractTransactionalDataSourceSpringContextTests.....................................5-28 Remoting com RMI ...........................................................................................................5-29 Exercícios ..............................................................................................................................5-34 Espaço para anotações ....................................................................................................5-35
Diego Pacheco – http://diego-pacheco.blogspot.com
III
Spring Framework – Framework para Desenvolvimento de Aplicações Java
1. Introdução
Diego Pacheco – http://diego-pacheco.blogspot.com
Spring Framework – Framework para desenvolvimento de aplicações java
Objetivos •
Conhecer os conceitos básicos;
•
Conhecer os principais cenários de uso;
•
Prover uma visão de todo o portifólio do Spring;
•
Saber onde baixar o Spring;
•
Conhecer a estrutura de diretórios dos fontes.
Diego Pacheco – http://diego-pacheco.blogspot.com
1-2
Spring Framework – Framework para desenvolvimento de aplicações java
Conceitos Básicos
Spring framework, garanto a você que não é nenhum produto de limpeza, até pode parecer pelo nome, mas não é. Spring é um dos frameworks líderes do mercado full-stack Java/JEE. Esse framework é mantido pela empresa Interface21 que tem como presidente, Rod Johnson, o criador do Spring que é simplesmente uma das maiores autoridades em Java. Spring prove diversos benefícios para muitos projetos, aumentando a produtividade de desenvolvimento e a performance em tempo de runtime em quanto ao mesmo tempo prove uma cobertura para testes e muita qualidade para a aplicação. O Spring prove soluções light-weight para construções de aplicações corporativas. Enquanto ainda suporta e prove a possibilidade de se usar: transações declarativas, acesso remoto através de RMI ou Web Services e muitas opções para persistência de dados. O Spring prove também uma solução completa MVC Framework e maneiras transparentes e elegantes para integração de AOP ao seu software. Esse framework é extremamente modular, assim você pode usar somente as partes que lhe interessam. É possível usar IoC com Struts ou por exemplo, você pode optar por usar somente a camada de integração com Hibernate ou a camada de abstração para JDBC. Desenhado para não ser intrusivo, utilizando apenas ele mesmo ou o mínimo de dependências para suas funcionalidades. Esse framework foi muito bem dividido, e isso pode ser observado com clareza na figura a baixo.
Diego Pacheco – http://diego-pacheco.blogspot.com
1-3
Spring Framework – Framework para desenvolvimento de aplicações java
Figura 1.1 Visão Geral
Utilizando o Spring você já terá um ganho excelente em qualidade de software em termos de design patterns, utilizando ele praticamente anula o uso de patterns como Factory e ServiceLocator. Todo Objeto componente de sua aplicação é por default para o Spring um singleton, assim favorecendo as boas práticas e a performance. A Empresa Interface21 e com certeza o Spring tem como missão os seguintes valores: •
J2EE Deveria ser muito fácil de usar
•
É melhor programar para interfaces do que para classes, Spring reduz o custo e a complexidade de usar interfaces para zero.
•
JavaBeans oferece uma maneira excelente para configurar uma aplicação.
Diego Pacheco – http://diego-pacheco.blogspot.com
1-4
Spring Framework – Framework para desenvolvimento de aplicações java
•
O Design OO é mais importante do que qualquer tecnologia de implementação como, por exemplo, J2EE.
•
Exception checadas são mal utilizadas no Java. Um framework não deveria forçar você a capturar exceptions que você não está apto a se recuperar.
•
Testabilidade é essencial, o Spring ajuda você a testar seu código mais facilmente.
•
O Spring precisa ser prazeroso para quem desenvolve usando ele.
•
O Código de sua aplicação deveria não depender da API do Spring.
•
O Spring não compete com as boas soluções existentes, mas prove integração dessas tecnologias, como exemplo o Hibernate, o Spring não pretende desenvolver outra, apenas integrá-la e prover facilidades.
Algumas das funcionalidades do core do Spring são: O Mais completo lightweight container: Prove centralização, automação de configuração e escrita para seus objetos de negocio. É um container não intrusivo, capaz de suportar sistemas complexos de um conjunto de componentes (POJO) de baixo acoplamento, consistência e transparência. O Container traz agilidade ao desenvolvimento e também testabilidade e uma alta escalabilidade, permitindo que os componentes de software possam ser desenvolvidos e testados isoladamente. Pode ser utilizado em qualquer ambiente de desenvolvimento J2SE ou J2EE. Uma camada comum de abstração para Transações: Permite gerenciamento transacional plugável com uma marcação transacional fácil, assim evitando pequenos problemas de baixo nível. Estratégias para JTA e para um único JDBC DataSource são incluídos. Em contraste com a JTA e o EJB CMT, as transações do spring não estão disponíveis só em ambientes J2EE, é possível utilizar em ambiente J2SE também. Uma Camada de Abstração para JDBC: Prove uma hierarquia de exceptions a partir de SQLException de maneira totalmente significativa. Simplifica o tratamento de erros, e diminuiu muito a quantidade de código a ser escrito. Nunca mais será necessário escrever um bloco finaly para usar JDBC. Integração com Toplink, Hibernate, JDO, and iBATIS SQL Maps: Em termos de resource holders, suporte a implementações de DAOs e estratégias transacionais. Existe um suporte de primeira classe para Hibernate com muitas facilidades providas pelo mecanismo de IoC.
Diego Pacheco – http://diego-pacheco.blogspot.com
1-5
Spring Framework – Framework para desenvolvimento de aplicações java
Funcionalidade AOP: Totalmente integrado com o gerenciamento configuracional do Spring, você pode utilizar AOP com qualquer objeto gerenciado pelo Spring, adicionando aspectos em gerenciamento transacional, por exemplo. Com Spring é possível ter transações declarativas sem EJB e até mesmo sem JTA, caso você esteja utilizando um único banco de dados em um servidor tomcat, por exemplo.
Diego Pacheco – http://diego-pacheco.blogspot.com
1-6
Spring Framework – Framework para desenvolvimento de aplicações java
Cenários de uso
Podemos utilizar Spring nos mais diversos cenários, desde um simples applet até mesmo nas mais complexas aplicações corporativas. Um exemplo típico de uso do Spring em uma aplicação completa Java EE onde teremos:
Figura 1.2 Cenário completo de uso em JEE.
Diego Pacheco – http://diego-pacheco.blogspot.com
1-7
Spring Framework – Framework para desenvolvimento de aplicações java
Uma camada de validações de formulários, soluções em upload de arquivos, bind de objetos de domínio e claro, uma integração com JSP, Velocity, XSLT, PDF e Excel. Após isso o contexto web, gerenciado pelo Spring e utilizando o Spring MVC. No cerne das aplicações o contexto principal do Spring com o container IoC e algumas funcionalidades, como envio de e-mails e acessos remotos através de RMI, SOAP, Burlap, etc. Seguindo da camada de regras de negócio, onde temos facilidades com o módulo de AOP e a integração com o módulo de ORM, chegando finalmente na camada de persistência através do suporte rico ao Hibernate ou via JDBC. Tudo isso rodando em um container JSP/Servlet como o Tomcat ou Jetty. No caso de sua aplicação precisar fazer algum acesso remoto o Spring prove isso de maneira transparente e elegante.
Figura 1.3 Cenário remoto. É normal uma aplicação necessitar fazer acesso remoto a alguma outra aplicação ou serviço, nesse cenário é interessante usar spring também, pois além de facilitar a abstrair muito a complexidade de fazer esses acessos, você pode usar os seus componentes que já estão sendo gerenciados pelo spring obtendo assim uma máxima integração entre seus componentes de negócios e os componentes remotos.
Diego Pacheco – http://diego-pacheco.blogspot.com
1-8
Spring Framework – Framework para desenvolvimento de aplicações java
Podemos usar Spring também se for necessário fazer integração com EJB, é possível utilizar os recursos da camada de acesso e abstração de EJB.
Figura 1.4 Cenário EJB. O Spring permite você reutilizar seus pojos existentes e empacotados em Stateless Session Beans, para serem usados em aplicações web escaláveis, que precisam de segurança declarativa.
Diego Pacheco – http://diego-pacheco.blogspot.com
1-9
Spring Framework – Framework para desenvolvimento de aplicações java
Portifólio
O Spring possui um portifólio muito abrangente, que é composto por uma série de projetos “Spring...”, podemos dizer que é um ecossistema muito diversificado, composto pelos seguintes projetos: Spring Framework: Principal projeto do portifólio da Interface21, esse é o framework base de todos os outros. Contém recursos como container IoC, suporte a Hibernate, jdbc, aop, integração com os principais frameworks do mercado. Spring Web Flow: framework web baseado em fluxos, prove a facilidade de desenvolver modelos de ações dos usuários em alto nível de abstração. É possível agrupar dois fluxos de controle e formar um modulo da junção dos dois. Spring Web Services: Facilita o desenvolvimento de services SOAP, permitindo a criação de web services flexíveis, com suporte a segurança WS, permitindo ecriptação, decriptação. Possui integração com segurança ACGI. Além disso, o Spring Web Services faz as boas práticas serem fáceis, ajudando você desenvolver com baixo acoplamento entre o contrato e a implementação. Spring Acegi: Acegi é uma solução flexível e poderosa para segurança de aplicações Java. Dentre as principais facilidades estão: autenticação, autorização, acesso baseado em instância, canal de segurança e capacidades de detecção humana. Utiliza o contexto do Spring para suas configurações, configuração de forma não intrusiva, utilizando filters. Spring LDAP: Ajuda nas operações LDAP, baseada no pattern Spring’s JdbcTemplate. O Framework alivia o desenvolvedor de abrir e fechar contextos, fazer loopings através de NamingEnumerations, encoding/deconding de valores e filtros.
Diego Pacheco – http://diego-pacheco.blogspot.com
1-10
Spring Framework – Framework para desenvolvimento de aplicações java
Spring Rich Client: Framework para desenvolvimento de aplicações Rich Client, é uma boa solução para construções de aplicações swing de maneira rápida e de qualidade. Possuí um conjunto rico de UI Factories, o foco desse projeto e prover boas práticas de maneira viável para o desenvolvimento swing, possui integração com Jgoodies e layout managers ricos como o TableLayout. Spring IDE para eclipse: Plugin para o ide eclipse com facilidades para o uso de Spring. Preove auto complete para os xmls de configuração do Spring, módulo visual para o Spring Web Flow, negação entre os beans do Spring, e visualização de recursos AOP. Spring BeanDoc: É uma ferramenta que facilita a documentação e desenho gráfico dos beans do contexto do Spring. Desenhado para ser flexível e simples de usar. BeanDoc pode facilitar a visualização das camadas da aplicação e como os objetos interagem. Pode ser configurado por uma task ant. Spring OSGI: Facilita a criação de aplicações Spring que irão rodar em um framework OSGI, uma aplicação escrita dessa forma tem uma separação melhor entre os módulos, com isso ganha a habilitada de remover, adicionar, atualizar os módulos em tempo de execução. Spring JavaConfig: Projeto que prove algumas anotações para efetuar o mapeamento de pojos com menos configurações em XML. Esse projeto não substitui completamente o uso de XML, mas consegue reduzir bastante em algumas funcionalidades de injeção. Spring.NET: Implementação do Core do Spring, com o seu container de IoC, só que para a plataforma da Microsoft .NET, esse projeto não tem todas as funcionalidades do Spring para Java, mas conta com muitos recursos do Spring feitos em Java como AOP, gerenciamento transacional e integração com Web. Spring Extensions: Projeto que é uma coleção de ferramentas para estender as funcionalidades do Spring framework, prove facilidade de integrar o Spring com outros frameworks. Dentre os tantos frameworks que são integrados com esse projeto estão: ant, Lucene, cache declarativo com EHCache, Drools, Jakarta Commons, engines de tamplates como Velocity, jBPM, etc. Spring Batch: Prove suporte para execução de tarefas muito longas. Suporte a programas batch os quais processam um volume muito grande de informações de um banco de dados. Com suporte a agendamento automático ou manual após falhas, esse projeto promove suporte de execuções batch para ambientes corporativos.
Diego Pacheco – http://diego-pacheco.blogspot.com
1-11
Spring Framework – Framework para desenvolvimento de aplicações java
Download O Spring Framework pode ser obtido através do site: http://www.springframework.org/download existe a possibilidade de baixar somente o framework ou baixar o framework e suas dependências. A Versão do Spring que será usada nessa apostila é a 2.0.6 , mas muitos itens descritos aqui são válido também para a versão 1.2.x do framework. O Spring framework necessita apenas uma versão do 1.5 JDK ou superior, não é necessário criar variáveis de ambiente para o Spring. O Spring usa um conjunto de frameworks muito grande, então é recomendado fazer download da versão full com dependência que tem por volta de 60Mb.
Diego Pacheco – http://diego-pacheco.blogspot.com
1-12
Spring Framework – Framework para desenvolvimento de aplicações java
Estrutura de Diretórios
Agora será detalhada a estrutura de diretórios da distribuição do Spring framework. Ao descompactar os binários do Spring teremos uma estrutura de diretórios da seguinte forma:
Figura 1.4 Estrutura de Diretórios da distribuição do Spring.
aspectj: Fontes dos testes dos artefatos que utilizam aspectj, aqui temos alguns artefatos de transação feitos em aspectJ. dist: Distribuição binárias dos fontes do Spring, aqui você encontrará os jars do Spring, bem como todos os jars de todos os módulos separados. docs: Contem toda a documentação do Spring, nessa você irá encontrar o JavaDoc, Reference Guide, documentação das taglibs do Spring. lib: Nesse diretório estão todas as dependências diretas e indiretas do Spring framework, aqui você encontrar jars de diversos frameworks, como por exemplo hibernate, struts, junit, ant.
Diego Pacheco – http://diego-pacheco.blogspot.com
1-13
Spring Framework – Framework para desenvolvimento de aplicações java
mock: Fontes do mecanismo de mock que são utilizados para testes unitários, nesse diretório você encontra os fontes dos testes dos mocks também. samples: Nesse diretório existem diversos exemplos de mini-aplicações utilizando o Spring Framework, como por exemplo a Petclinic que é uma clinica de animais. src: Contém todos os fontes do Spring framework, caso você precise desses fontes para debugar o comportamento de algum código do Spring. test: Nesse diretório você encontrará todos os fontes dos testes realizados com o Spring, é útil para aprender como utilizar algumas classes do Spring. tiger: Todos os fontes que utilizam recursos somente do Java 5.0 estão nesse diretório, como por exemplo, annotations.
Dois arquivos que estão soltos no diretório principal e são interessantes são o changelog.txt e o readme.txt. No arquivo changelog contém todas as mudanças dessa versão do Spring como, por exemplo: quais são as novas features e quais foram os bugs corrigidos. No arquivo readme nós temos a definição de cada modulo do Spring com suas dependências, isso é muito útil se você deseja utilizar somente alguns módulos do Spring e precisa saber as dependências.
Diego Pacheco – http://diego-pacheco.blogspot.com
1-14
Spring Framework – Framework para desenvolvimento de aplicações java
Exercícios
1) Defina com suas palavras qual a utilidade do Spring Framework. 2) Cite três vantagens de se usar Spring framework. 3) Diga um cenário em que poderíamos utilizar Spring. 4) Diga uma das utilidades do arquivo readme.txt.
Diego Pacheco – http://diego-pacheco.blogspot.com
1-15
Spring Framework – Framework para desenvolvimento de aplicações java
Espaço para anotações
Diego Pacheco – http://diego-pacheco.blogspot.com
1-16
Spring Framework – Framework para Desenvolvimento de Aplicações Java
2. Container IoC
Diego Pacheco – http://diego-pacheco.blogspot.com
Spring Framework – Framework para desenvolvimento de aplicações java
Objetivos
•
Conhecer o conceito de IoC;
•
Saber utilizar Lazy initialization e Singletons;
•
Conhecer os escopos dos Beans;
•
Saber registrar beans no container do Spring;
•
Saber fazer injeções com setters e construtores;
•
Saber fazer injeções com coleções;
•
Saber fazer injeção entre beans colaboradores;
•
Saber instanciar o contexto do Spring.
Diego Pacheco – http://diego-pacheco.blogspot.com
2-2
Spring Framework – Framework para desenvolvimento de aplicações java
IoC – Inversion of control
Com a grande demanda de desenvolvimento para o Java corporativo (JEE), surgiu um problema comum, como ligar a camada de acesso a dados com a camada de regra de negócio e por ventura a camada de apresentação? Uma solução é um container de Ioc que também é chamada de Dependency Injection(DI), o Spring framework possui um container de Ioc leve e implementa o pattern de setter injection. Esse container trabalha com serviços definidos pelo programador. Serviço é um componente de software que foi projetado para ser reutilizado em muitos lugares sem a necessidade de alteração de código, é possível alterar o seu comportamento estendendo-o de alguma forma. A Idéia principal da injeção de dependências é separar os Objetos e principalmente o objeto que usa um outro objeto não instanciar diretamente esse objeto. Sendo assim, a principal vantagem da Dependency Injection é separar uma interface de sua implementação concreta. São dois tipos de injeção que o Spring utiliza em seu container de Ioc, veja: Setter Injection: Nesse tipo de injeção de dependências se utiliza de métodos setters baseados em propriedades e padrões de getters/setters da Sun. Você não precisa ter a propriedade de fato em seu serviço, mas o padrão de nomenclatura deve estar correto. Constructor Injection: Nesse tipo de injeção de dependências é utilizado o construtor da própria classe para fazer as injeções necessárias. Esse construtor pode ter quantos parâmetros forem necessários. Principais vantagens do uso de IoC do Spring: •
Desacoplamento
•
Visão fácil de dependência
•
Facilidade para testes
•
Possibilita escrever aplicações para terceiros (fora do seu controle) Para fixar melhor esse conceito considere o seguinte exemplo pratico: Imagine
que um Autor escreveu muitos livros, então considere os seguintes pojos: Diego Pacheco – http://diego-pacheco.blogspot.com
2-3
Spring Framework – Framework para desenvolvimento de aplicações java
package com.targettrust.spring.bad; import java.util.List; public class Autor { private String nome; private List livros; public Autor() {} public Autor(String nome) { super(); this.nome = nome; } public void listarPorNome(){ Listar l = new Listar(); List ret = l.list(nome); System.out.println( (ret.size()==0) ? "NRE" : ret ); } public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } public List getLivros() { return livros; } public void setLivros(List livros) { this.livros = livros; } }
Código 2.1 Autor.java
Diego Pacheco – http://diego-pacheco.blogspot.com
2-4
Spring Framework – Framework para desenvolvimento de aplicações java
package com.targettrust.spring.bad; public class Livro {
private private private private
Autor autor; String titulo; String editora; int ano;
public Livro() {} public Livro(Autor autor, String titulo, String editora, int ano) { super(); this.autor = autor; this.titulo = titulo; this.editora = editora; this.ano = ano; } public Autor getAutor() { return autor; } public void setAutor(Autor autor) { this.autor = autor; } public String getTitulo() { return titulo; } public void setTitulo(String titulo) { this.titulo = titulo; } public String getEditora() { return editora; } public void setEditora(String editora) { this.editora = editora; } public int getAno() { return ano; } public void setAno(int ano) { this.ano = ano; } @Override public String toString() { return "titulo: " + titulo + " editor: " + editora + " ano: " + ano; } }
Código 2.2 Livro.java Diego Pacheco – http://diego-pacheco.blogspot.com
2-5
Spring Framework – Framework para desenvolvimento de aplicações java
package com.targettrust.spring.bad; import java.util.ArrayList; import java.util.List; public class Listar { public List list(String nome){ Autor a = new Autor("Diego Pacheco"); List livros = new ArrayList(); livros.add(new Livro(a,"Livro da Vida","Do Livro",2000)); livros.add(new Livro(a,"Spring for Dummies","O'really",2001)); livros.add(new Livro(a,"Bit ou não","Variados Editora",2002));
List achados = new ArrayList(); for(Livro l: livros){ if (l.getAutor().getNome().equals(nome)) achados.add(l); } return achados; } }
Código 2.3 Listar.java
package com.targettrust.spring.bad; public class MainTest { public static void main(String[] args) { Autor autor = new Autor("Rod"); autor.listarPorNome(); autor.setNome("Diego Pacheco"); autor.listarPorNome(); } }
Código 2.4 MainTest.java
Diego Pacheco – http://diego-pacheco.blogspot.com
2-6
Spring Framework – Framework para desenvolvimento de aplicações java
Nós temos os seguintes objetos: Autor, Livro, Listar e MainTest. Nesse exemplo um Autor pode ter vários livros por isso dentro do Pojo de Autor temos List e a classe Listar se encarrega de armazenar os livros e autores e prover uma procura sobre esses dados. Como vocês devem ter percebido o pojo Autor contém um método chamado: listarPorNome que instância esse objeto Listar e procura pelos livros do autor. Esse exemplo por mais simplório, serve para demonstrar que existe um forte acoplamento entre o pojo Autor e a classe que lista os Livros por Autor, outro grande problema nesse exemplo é que não existem interfaces. O que aconteceria se um Autor pudesse ter outras coisas além de livros como, por exemplo: artigos, co-autorias, vídeos? Nesse caso essa mudança iria implicar em um refactoring muito grande nessas classes, mas como poderíamos resolver esse problema?
Diego Pacheco – http://diego-pacheco.blogspot.com
2-7
Spring Framework – Framework para desenvolvimento de aplicações java
Solução: Criar um interface Publicável e o Livro irá implementar essa classe, no pojo de Autor mude de uma lista de Livros para uma List de Publicáveis, assim criamos a possibilidade de um Autor ter diversos itens em seu portifólio como, por exemplo: Livros, Artigos, Co-autuações. Para resolver o problema de forma de armazenamento e procura de livros, foi criada a interface Listavel e a classe Listar implementa essa interface, agora podemos criar outra classe que faça acesso à base de dados, claro que esse classe deve implementar Listavel. No pojo do Autor precisamos colocar um atributo Listavel e através desse atributo que vamos acessar os dados. Essas novas classes iram ficar conforme os fontes a baixo. package com.targettrust.spring.bad.ok; import java.util.List; public class Autor { private String nome; private List publicaveis; private Listavel list; public Autor() {} public Autor(String nome) { super(); this.nome = nome; } public void listarPorNome(){ List ret = list.list(nome); System.out.println( (ret.size()==0) ? "NRE" : ret ); } public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } public List getPublicaveis() { return publicaveis; } public void setPublicaveis(List publicaveis) { this.publicaveis = publicaveis; } public Listavel getList() { return list; } public void setList(Listavel list) { this.list = list; } }
Código 2.5 Autor.java Diego Pacheco – http://diego-pacheco.blogspot.com
2-8
Spring Framework – Framework para desenvolvimento de aplicações java
package com.targettrust.spring.bad.ok; public class Livro implements Publicavel{ private private private private
Autor autor; String titulo; String editora; int ano;
public Livro() {} public Livro(Autor autor, String titulo, String editora, int ano) { super(); this.autor = autor; this.titulo = titulo; this.editora = editora; this.ano = ano; } @Override public String getNome() { return getTitulo(); } @Override public String getTipo() { return "Livro"; } public String getAutor() { return autor.getNome(); } public void setAutor(Autor autor) { this.autor = autor; } public String getTitulo() { return titulo; } public void setTitulo(String titulo) { this.titulo = titulo; } public String getEditora() { return editora; } public void setEditora(String editora) { this.editora = editora; } public int getAno() { return ano; } public void setAno(int ano) { this.ano = ano; } @Override
Diego Pacheco – http://diego-pacheco.blogspot.com
2-9
Spring Framework – Framework para desenvolvimento de aplicações java
Código 2.6 Livro.java package com.targettrust.spring.bad.ok; public interface Publicavel { public String getAutor(); public String getNome(); public String getTipo(); }
Código 2.7 Publicavel.java package com.targettrust.spring.bad.ok; import java.util.List; public interface Listavel { public List list(String nome); }
Código 2.8 Listavel.java
Diego Pacheco – http://diego-pacheco.blogspot.com
2-10
Spring Framework – Framework para desenvolvimento de aplicações java
package com.targettrust.spring.bad.ok; import java.util.ArrayList; import java.util.List; public class Listar implements Listavel{ public List list(String nome) { Autor a = new Autor("Diego Pacheco"); List publicaveis = new ArrayList(); publicaveis.add(new Livro(a,"Livro da Vida","Do Livro",2000)); publicaveis.add(new Livro(a,"Spring for Dummies","O'really",2001)); publicaveis.add(new Livro(a,"Bit ou não","Variados Editora",2002)); List achados = new ArrayList(); for(Publicavel p: publicaveis){ if (p.getAutor().equals(nome)) achados.add(p); } return achados; } }
Código 2.9 Listar.java package com.targettrust.spring.bad.ok; public class MainTest { public static void main(String[] args) { Autor autor = new Autor(); autor.setList(new Listar()); autor.setNome("Rod"); autor.listarPorNome(); autor.setNome("Diego Pacheco"); autor.listarPorNome(); } }
Código 2.10 MainTest.java
Diego Pacheco – http://diego-pacheco.blogspot.com
2-11
Spring Framework – Framework para desenvolvimento de aplicações java
Nesse exemplo conseguimos resolver os problemas citados acima, mas utilizamos a IoC “na mão”, ou seja, nós mesmos injetamos as dependências, a solução é boa, mas isso em um sistema grande seria muito custoso de se fazer, nesse ponto entra o container de IoC do Spring. O Container possibilita de maneira fácil e simples a injeção dessas dependências e reduz o custo de se trabalhar com essas interfaces quase à zero.
Diego Pacheco – http://diego-pacheco.blogspot.com
2-12
Spring Framework – Framework para desenvolvimento de aplicações java
Registrando Beans
Agora vamos ver como registrar essas classes no contexto do Spring. Esse registro é muito simples, ele consiste em apontar para uma classe Java no seu classpath e dar um id a esse bean. Existem outras configurações que podemos fazer sobre esses beans, mas vamos começar mostrando como declarar um bean no Spring.
Código XML 2.1 Spring-beans.xml Para recuperarmos esse bean do Contexto do Spring, precisamos instanciar um contexto do Spring e solicitar o bean apartir do ID para o contexto, conforme exemplo a baixo. package com.targettrust.spring.primeiro; import org.springframework.beans.factory.BeanFactory; import org.springframework.context.support.ClassPathXmlApplicationContext; public class Test { public static void main(String[] args) { BeanFactory bf = new ClassPathXmlApplicationContext("/com/targettrust/spring/primeiro/Springbeans.xml"); Object bean = bf.getBean("autor"); System.out.println("Autor: " + bean); } }
Código 2.11 Obtendo um bean do Spring
Diego Pacheco – http://diego-pacheco.blogspot.com
2-13
Spring Framework – Framework para desenvolvimento de aplicações java
A BeanFactory é uma interface Java que representa o Container Ioc, essa BeanFactory
precisa
ser instanciada,
nesse
exemplo
foi
usado
a
factory
ClassPathXmlApplicationContext que é uma factory que leva em consideração xmls de configurações que estão no classpath. Existem várias factories no Spring, uma para cada situação, por exemplo, existe uma factory que é utilizada para subir o contexto do Spring em um ambiente Servlet. Após a inicialização do contexto do Spring podemos utilizar o método getBean para recuperar um bean do Spring, nesse exemplo estamos passando o ID do bean que foi o mesmo que registramos no XML: Spring-beans.xml Outra forma de criarmos a BeanFactory seria utilizar um ClassPathResource que aponta para o Xml dos beans e depois utilizar a factory XmlBeanFactory. Conforme o exemplo de código a baixo. ClassPathResource resource = new ClassPathResource("/com/targettrust/spring/primeiro/Spring-beans.xml"); BeanFactory bf = new XmlBeanFactory(resource);
Código 2.12 outra bean factory É possível registrar um Bean no contexto do Spring programaticamente, para isso é necessário utilizar um objeto BeanDefinition que é o objeto que configura o bean no Spring. BeanDefinition beanDefinition = new RootBeanDefinition(Livro.class, RootBeanDefinition.AUTOWIRE_NO); ((BeanDefinitionRegistry)bf).registerBeanDefinition("livro", beanDefinition); Object beanOutro = bf.getBean("livro"); System.out.println("Livro: " + beanOutro);
Código 2.13 Registra um bean programaticamente
Diego Pacheco – http://diego-pacheco.blogspot.com
2-14
Spring Framework – Framework para desenvolvimento de aplicações java
Singletons e lazy Initialization
Para aumentar a performance de sua aplicação com qualidade e aplicando design patterns o Spring por default transforma qualquer bean registrado nele em um singleton. Singleton é um padrão de projeto (Design Pattern) que consiste em manter apenas uma instância de um determinado objeto por classloader. É um pattern muito aplicado para conexões com banco de dados, por exemplo. Podemos ver isso através do seguinte teste. package com.targettrust.spring.singleton; import java.util.ArrayList; import java.util.List; public class Uf { private String nome; private String sigla; private List ufs; public Uf() { System.out.println("Inicio do processamento dos estados..."); initUfs(); } private Uf(String nome, String sigla) { this.nome = nome; this.sigla = sigla; } private void initUfs() { ufs = new ArrayList(); ufs.add(new Uf("Acre","AC")); ufs.add(new Uf("Alagoas","AL")); ufs.add(new Uf("Amapá","AP")); ufs.add(new Uf("Amazonas","AM")); ufs.add(new Uf("Bahia","BA")); ufs.add(new Uf("Ceará","CE")); ufs.add(new Uf("Distrito Federal","DF")); ufs.add(new Uf("Goiás","GO")); ufs.add(new Uf("Espírito Santo","ES")); ufs.add(new Uf("Maranhão","MA")); ufs.add(new Uf("Mato Grosso","MT")); ufs.add(new Uf("Mato Grosso do Sul","MS")); ufs.add(new Uf("Minas Gerais","MG")); ufs.add(new Uf("Pará","PA")); ufs.add(new Uf("Paraiba","PB")); ufs.add(new Uf("Paraná","PR")); ufs.add(new Uf("Pernambuco","PE")); ufs.add(new Uf("Piauí","PI")); ufs.add(new Uf("Rio de Janeiro","RJ")); ufs.add(new Uf("Rio Grande do Norte","RN")); ufs.add(new Uf("Rio Grande do Norte","RS")); ufs.add(new Uf("Rondônia","RO"));
Diego Pacheco – http://diego-pacheco.blogspot.com
2-15
Spring Framework – Framework para desenvolvimento de aplicações java
Código 2.15 Teste Se executarmos esse programa, o resultado será algo semelhante ao representado na figura abaixo. Inicio do processamento dos estados... ufs: [AC, AL, AP, AM, BA, CE, DF, GO, ES, MA, MT, MS, MG, PA, PB, PR, PE, PI, RJ, RN, RS, RO, RR, SP, SC, SE, TO] com.targettrust.spring.singleton.Uf@3ecfff ufs: [AC, AL, AP, AM, BA, CE, DF, GO, ES, MA, MT, MS, MG, PA, PB, PR, PE, PI, RJ, RN, RS, RO, RR, SP, SC, SE, TO] com.targettrust.spring.singleton.Uf@3ecfff ufs: [AC, AL, AP, AM, BA, CE, DF, GO, ES, MA, MT, MS, MG, PA, PB, PR, PE, PI, RJ, RN, RS, RO, RR, SP, SC, SE, TO] com.targettrust.spring.singleton.Uf@3ecfff
Código 2.16 Resultado da Execução Perceba que a criação dos estados ocorre somente na primeira vez, mas nas outras vezes já está em memória, logo além, se não fizer duas vezes o mesmo processamento, existe um ganho de performance.
Diego Pacheco – http://diego-pacheco.blogspot.com
2-17
Spring Framework – Framework para desenvolvimento de aplicações java
Também é possível desativar esse comportamento, ou seja, é possível configurar no spring para que o bean em questão não seja criado como um Singleton. Para isso, basta alterar o registro do bean no Spring, conforme no XML abaixo:
Código XML 2.3 Spring-beans.xml Neste mesmo capítulo serão explicados e exemplificados melhor os possíveis escopos de beans no Spring.
Lazy Initialization Outro recurso importante é o Lazy Initialization, com ele podemos fazer com que o Spring só carregue os beans que forem solicitados, ou seja, se temos 50 beans declarados no contexto do Spring e apenas 10 são utilizados, os outros 40 beans não vão ser instanciados, e assim evitamos um processamento desnecessário e ganhamos em desempenho.
Diego Pacheco – http://diego-pacheco.blogspot.com
2-18
Spring Framework – Framework para desenvolvimento de aplicações java
Para fazer tal configuração é necessário configurar no XML de beans do Spring o atributo lazy-init="true". Veja o exemplo de como faz isso no XML abaixo:
Código XML 2.4 Spring-beans.xml um exemplo lazy initialization. É sempre válido configurar esse comportamento do framework. O Default do Spring é começar com lazy-init=”false”,
então sempre que possível altere essa
configuração para true. Podemos configurar no Spring que todos os beans de um determinado arquivo XML de configurações por default assumam o mesmo valor, podemos fazer isso através do atributo default-lazy-init esse atributo só pode ser setado no modo beans que é a raiz de configurações.
Código XML 2.4 Spring-beans.xml um exemplo de default lazy initialization.
Diego Pacheco – http://diego-pacheco.blogspot.com
2-19
Spring Framework – Framework para desenvolvimento de aplicações java
Scopos dos Beans
Scopo se refere à visibilidade de um objeto gerenciado pelo Spring e também está relacionado ao seu tempo de vida. Existem os seguintes scopos de beans no Spring.
Scopo
Descrição
singleton
Uma única instância de objeto para todo o contexto do Spring.
prototype
Múltiplas instâncias de um objeto para o container do Spring.
request *
Escopo relacionado ao ciclo de vida HTTP Request, a cada request teremos outra instância de bean no Spring
session *
Escopo relacionado ao ciclo de vida HTTP Session, uma única instância do Bean por session.
global
Escopo relacionado ao ciclo de vida global HTTP Session, bean
session *
válido em uma session global. Utilizado para portlets.
* Escopos que só são válidos em um contexto web-aware, ou seja, em uma aplicação JSP/Servlet ou JEE. Criados por uma factory específica para Web, como por exemplo: XmlWebApplicationContext.
Diego Pacheco – http://diego-pacheco.blogspot.com
2-20
Spring Framework – Framework para desenvolvimento de aplicações java
Podemos ver na prática a diferença entre singleton e prototype no exemplo abaixo. Nesse exemplo o mesmo bean é registrado de maneiras diferentes, isso é perfeitamente possível. package com.targettrust.spring.scope; public class SimpleBean { private Long id = 0L; public SimpleBean() {} public SimpleBean(Long id) { super(); this.id = id; } public Long getId() { return id; } public void setId(Long id) { this.id = id; } @Override public String toString() { return super.toString() + " id: " + id; } }
Código 2.17 SimpleBean.java.
Código XML 2.5 Spring-beans.xml xml de configuração.
Diego Pacheco – http://diego-pacheco.blogspot.com
2-21
Spring Framework – Framework para desenvolvimento de aplicações java
package com.targettrust.spring.scope; import org.springframework.beans.factory.BeanFactory; import org.springframework.context.support.ClassPathXmlApplicationContext; public class TestScope { public static void main(String[] args) { BeanFactory bf = new ClassPathXmlApplicationContext("/com/targettrust/spring/scope/Springbeans.xml"); SimpleBean SimpleBean SimpleBean SimpleBean
Spring Framework – Framework para desenvolvimento de aplicações java
Criando seu próprio scope No Spring framework 2.0.X podemos criar nosso próprio scope e ainda mais, podemos redefinir os scopos baseados em web-aware. Os únicos scopos que são intocáveis são: prototype e singleton, se tentarmos reescrevê-los o Spring irá levantar uma IllegalArgumentException. Imagine que em sua aplicação surgiu a necessidade de ter controle sobre todos os objetos Pessoa criados, como poderíamos fazer isso sem reescrever toda a aplicação? Criando o nosso próprio scopo de bean seria uma forma. package com.targettrust.spring.scope.myscope; public class Pessoa { private String nome; public Pessoa() { } public Pessoa(String nome) { super(); this.nome = nome; } public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((nome == null) ? 0 : nome.hashCode()); return result; } @Override public boolean equals(Object obj) { return (obj == null) ? false : nome.equals(((Pessoa) obj).getNome()); } @Override public String toString() { return "nome: " + nome; } }
Código 2.19 Pessoa.java. Diego Pacheco – http://diego-pacheco.blogspot.com
2-23
Spring Framework – Framework para desenvolvimento de aplicações java
package com.targettrust.spring.scope.myscope; import org.springframework.beans.factory.BeanFactory; import org.springframework.context.support.ClassPathXmlApplicationContext; @SuppressWarnings("unused") public class TestScopes { public static void main(String[] args) { BeanFactory bf = new ClassPathXmlApplicationContext("/com/targettrust/spring/scope/myscope/Spri ng-beans.xml"); Pessoa p1 = (Pessoa)bf.getBean("pessoa1"); Pessoa p2 = (Pessoa)bf.getBean("pessoa2"); Pessoa p3 = (Pessoa)bf.getBean("pessoa3"); Pessoa p4 = (Pessoa)bf.getBean("pessoa4"); System.out.println("Todas as pessoas: " + ThreadLocalScope.tl.get()); p3.setNome("Spider-Pig"); System.out.println("Todas as pessoas: " + ThreadLocalScope.tl.get()); } }
Código 2.20 Classe de testesTestScopes.java. <property name="scopes"> <map> <entry key="threadLocal"> <property name="nome" value="Diego Pacheco"/>
Diego Pacheco – http://diego-pacheco.blogspot.com
2-24
Spring Framework – Framework para desenvolvimento de aplicações java
Código XML 2.6 Spring-beans.xml scope customizado. package com.targettrust.spring.scope.myscope; import java.util.HashMap; import java.util.Map; import org.springframework.beans.factory.ObjectFactory; import org.springframework.beans.factory.config.Scope; public class ThreadLocalScope implements Scope{ public static ThreadLocal<Map<String, Object>> tl; public ThreadLocalScope() { tl = new ThreadLocal<Map<String,Object>>(); tl.set(new HashMap<String, Object>()); } @Override public Object get(String name, ObjectFactory objectFactory) { synchronized(tl){ Object realTarget = objectFactory.getObject(); if (realTarget instanceof Pessoa){ tl.get().put(realTarget.hashCode() + ";", realTarget); return realTarget; } throw new RuntimeException("Esse scopo só pode ser utilizado para objetos Pessoa "); } } @Override public Object remove(String name) { synchronized(tl){ Object obj = tl.get().remove(name);
Diego Pacheco – http://diego-pacheco.blogspot.com
2-25
Spring Framework – Framework para desenvolvimento de aplicações java
return obj; } } @Override public void registerDestructionCallback(String name, Runnable callback){ throw new UnsupportedOperationException("Essa operação de registerDestructionCallback, não suportada!"); } @Override public String getConversationId() { return null; } }
Código 2.21 ThreadLocalScope.java classe de scope customizada.
Para criar um scopo personalizado no Spring é necessário implementar a interface
org.springframework.beans.factory.config.Scope,
a
implementação
dessa interface é simples, basicamente só precisamos nos preocupar com os métodos get e remove. Após a implementação dessa interface só será necessário registrar no spring o seu novo scopo, isso é feito com a seguinte configuração em xml: <property name="scopes"> <map> <entry key="threadLocal">
Código XML 2.7 Definição de scope customizado.
Diego Pacheco – http://diego-pacheco.blogspot.com
2-26
Spring Framework – Framework para desenvolvimento de aplicações java
Injeção via setter
Essa é uma das duas formas que o Spring faz injeção de dependências, ele utiliza um método setter conforme padrão da Sun e através desse método setta os valores no objeto em questão. package com.targettrust.spring.setter; public class Aluno { private private private private
String nome; Integer idade; boolean desconto; Character sexo;
public Aluno() {} public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } public Integer getIdade() { return idade; } public void setIdade(Integer idade) { this.idade = idade; } public boolean isDesconto() { return desconto; } public void setDesconto(boolean desconto) { this.desconto = desconto; } public Character getSexo() { return sexo; } public void setSexo(Character sexo) { this.sexo = sexo; } @Override public String toString() { return "nome: " + nome + " idade: " + idade + " desconto: " + desconto + " sexo: " + sexo; } }
Código 2.22 Aluno.java. Diego Pacheco – http://diego-pacheco.blogspot.com
2-27
Spring Framework – Framework para desenvolvimento de aplicações java
Código XML 2.8 Configuração de injeção via setter package com.targettrust.spring.setter; import org.springframework.beans.factory.BeanFactory; import org.springframework.context.support.ClassPathXmlApplicationContext; public class TestSetter { public static void main(String[] args) { BeanFactory bf = new ClassPathXmlApplicationContext("/com/targettrust/spring/setter/Springbeans.xml"); System.out.println(bf.getBean("aluno")); } }
Código 2.23 TestSetter.java
Não existe nada de mágico na injeção via setter, é simples, basta ter o método setter e o tipo de dado injetado ser o mesmo.
Diego Pacheco – http://diego-pacheco.blogspot.com
2-28
Spring Framework – Framework para desenvolvimento de aplicações java
Injeção via construtor Esta é a outra forma de injeção de dependência do Spring. As dependências são injetadas através de um construtor. Considere a seguinte classe Java: package com.targettrust.spring.constructor; public class Pessoa { private String nome; private Integer idade; private boolean cartaMorotista; public Pessoa(String nome, Integer idade, boolean cartaMorotista) { super(); this.nome = nome; this.idade = idade; this.cartaMorotista = cartaMorotista; } @Override public String toString() { return " nome: " + nome + " idade: " + idade + " morotista: " + cartaMorotista; } }
Código 2.24 Pessoa.java Para injetarmos nome, idade, cartaMotorista, é só efetuar essa injeção via construtor no XML de configuração do Spring, conforme código XML abaixo:
Código XML 2.9 Configuração de injeção via construtor
Diego Pacheco – http://diego-pacheco.blogspot.com
2-29
Spring Framework – Framework para desenvolvimento de aplicações java
Para ver a injeção funcionando considere a classe de testes abaixo: package com.targettrust.spring.constructor; import org.springframework.beans.factory.BeanFactory; import org.springframework.context.support.ClassPathXmlApplicationContext; public class TestConstructor { public static void main(String[] args) { BeanFactory bf = new ClassPathXmlApplicationContext("/com/targettrust/spring/constructor/Spring -beans.xml"); System.out.println(bf.getBean("pessoa")); } }
Código 2.25 TestConstructor.java Teste de construtor
Ao rodar esses códigos você terá um retorno semelhante a este:
nome: Diego Pacheco idade: 22 motorista: false
Caso você tenha um construtor que receba uma String e um número, o Spring pode acabar sentando valores indesejados, para resolver esse tipo de situação, podemos especificar o tipo do argumento do construtor, conforme exemplo de XML abaixo.
Código XML 2.10 Exemplo de tipo de argumento para construtor.
Diego Pacheco – http://diego-pacheco.blogspot.com
2-30
Spring Framework – Framework para desenvolvimento de aplicações java
Uma outra opção seria informar qual é a posição do parâmetro no construtor, isso nós chamamos de index, começa em zero(0), como segue o exemplo:
value="Black" /> value="Dog" />
Código XML 2.11 Exemplo de tipo de argumento para construtor com index.
Injeção de coleções Por deafult o Spring possui tags específicas para injeção de coleções, é possível injetar: Map, List, Properties e Set. De fato podemos injetar qualquer Collection, mas para injetar uma coleção que não seja uma das citadas, será necessário usar um Custon Property Editor. Para fazer as injeções das coleções “nativas” do Spring, utilizamos as tags: <map/>, <list/>, <set/> e <props/>. Considerando o seguinte exemplo: <property name="pessoas"> <set> DiegoRodAlef <property name="cadeiras"> <map> <entry> 1diego <entry> 2Rod
Diego Pacheco – http://diego-pacheco.blogspot.com
2-31
Spring Framework – Framework para desenvolvimento de aplicações java
Código XML 2.12 Exemplo de injeção de collections.
Para esse código de injeções de coleções em XML precisamos de uma classe Java, conforme a definida a baixo: package com.targettrust.spring.collection; import import import import
public Estadio() {} public Set<String> getPessoas() { return pessoas; } public void setPessoas(Set<String> pessoas) { this.pessoas = pessoas; }
Diego Pacheco – http://diego-pacheco.blogspot.com
2-32
Spring Framework – Framework para desenvolvimento de aplicações java
public Map getCadeiras() { return cadeiras; } public void setCadeiras(Map cadeiras) { this.cadeiras = cadeiras; } public List<String> getVededoresPipoca() { return vededoresPipoca; } public void setVededoresPipoca(List<String> vededoresPipoca) { this.vededoresPipoca = vededoresPipoca; } public Properties getDetalhes() { return detalhes; } public void setDetalhes(Properties detalhes) { this.detalhes = detalhes; } @Override public String toString() { return " pessoas: " + pessoas + "\n" + " cadeiras: " + cadeiras + "\n" + " Vededores de Pipoca: " + vededoresPipoca + "\n" + " detalhes: " + detalhes; } }
Código 2.26 Estadio.java Classe que usa Collections.
Podemos testar esses recursos através do teste abaixo: package com.targettrust.spring.collection; import org.springframework.beans.factory.BeanFactory; import org.springframework.context.support.ClassPathXmlApplicationContext; public class TestCollections { public static void main(String[] args) { BeanFactory bf = new ClassPathXmlApplicationContext("/com/targettrust/spring/collection/Springbeans.xml"); System.out.println(bf.getBean("estadio")); } }
Código 2.26 TestCollections.java Classe de testes.
Diego Pacheco – http://diego-pacheco.blogspot.com
2-33
Spring Framework – Framework para desenvolvimento de aplicações java
Existem outras váriaveis para a injeção de properties, no exemplo acima foi utilizada a forma mais simplificada, mas poderíamos fazer da forma “completa”, conforme exemplo abaixo: <property name="detalhes"> <props> <prop key="estadio.luz">forte <prop key="estadio.taman.hq.full">grande <prop key="estadio.fundac.since">10/10/2001 <prop key="estadio.status.now">ativo
Código XML 2.13 Outra forma de injeção de Properties.
Dica: Se for explicitamente necessário injetar uma coleção nula, ou settar null em alguma propriedade de algum bean do Spring, podemos utilizar a tag .
Podemos injetar qualquer tipo de coleção através do uso de property editors, essa é uma solução muito elegante do Spring. Quando registramos um editor do tipo Class, por exemplo, toda vez que o Spring for injetar um valor em um objeto que a propriedade seja Class ele vai invocar esse property editor. Veja como usar a Collection do Tipo LinkedList no exemplo abaixo: package com.targettrust.spring.collection; import java.util.LinkedList; public class Cidade { private LinkedList<String> ruas; public Cidade() {} public LinkedList<String> getRuas() { return ruas; } public void setRuas(LinkedList<String> ruas) { this.ruas = ruas; } }
Código 2.27 Cidade.java Classe que usa LinkedList.
Diego Pacheco – http://diego-pacheco.blogspot.com
2-34
Spring Framework – Framework para desenvolvimento de aplicações java
Nesse exemplo foi registrado um property editor de class, chamado: org.springframework.beans.propertyeditors.ClassEditor, que está associado ao tipo Class. Esse property editor é necessário para o property editor de Collections: org.springframework.beans.propertyeditors.CustomCollectionEditor. O Property editor de Collections tem dois parâmetros no construtor, o primeiro é a classe que a collection deve ser, e o segundo é um boolean indicando se deve ser convertido para null uma coleção vazia. Diego Pacheco – http://diego-pacheco.blogspot.com
2-35
Spring Framework – Framework para desenvolvimento de aplicações java
Injeção entre beans colaboradores
No Spring são chamados de beans colaboradores todo objeto que é criado por você, como por exemplo, um objeto de negócio e que deve ser injetado em outro objeto, em síntese é o ato de injetar um pojo em outro. Não existe nada de mágico nisso, além de simples é muito usual, talvez a funcionalidade mais simples do container IoC do Spring, porém a mais utilizada junto com as injeções por setter. A injeção de colaboradores é feita através de setters ou construtor como as outras injeções vistas anteriormente. package com.targettrust.spring.colaboradores; public class Cidade { private String nome; public Cidade() {} public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } @Override public String toString() { return nome; } }
Código 2.28 Cidade.java Classe colaboradora. package com.targettrust.spring.colaboradores; import java.util.List; public class Estado { private String sigla; private List cidades; public Estado() {} public String getSigla() { return sigla; } public void setSigla(String sigla) { this.sigla = sigla; }
Diego Pacheco – http://diego-pacheco.blogspot.com
2-36
Spring Framework – Framework para desenvolvimento de aplicações java
public List getCidades() { return cidades; } public void setCidades(List cidades) { this.cidades = cidades; } @Override public String toString() { return sigla + " cidades: " + cidades; } }
Código 2.28 Estado.java Classe que utiliza a colaboradora.
Diego Pacheco – http://diego-pacheco.blogspot.com
2-37
Spring Framework – Framework para desenvolvimento de aplicações java
Spring Framework – Framework para desenvolvimento de aplicações java
Nesse exemplo foi injetado uma java.util.List de Cidades no objeto Estado. Podemos reutilizar injeções com a tag ref. Quando usamos ref com bean estamos criando a possibilidade de acessar qualquer bean do contexto do Spring em qualquer XML de configuração. Quando utilizado o atributo local só podemos utilizar os beans que estão no mesmo XML, se o bean em questão estiver em outro XML, um erro será levantado. Podemos ver o resultado dessas classes em ação no teste abaixo: package com.targettrust.spring.colaboradores; import org.springframework.beans.factory.BeanFactory; import org.springframework.context.support.ClassPathXmlApplicationContext; public class TestColaboradores { public static void main(String[] args) { BeanFactory bf = new ClassPathXmlApplicationContext("/com/targettrust/spring/colaboradores/Spri ng-beans.xml"); System.out.println(bf.getBean("estado")); } }
Código 2.29 TestColaboradores.java Teste de colaboradores.
Diego Pacheco – http://diego-pacheco.blogspot.com
2-39
Spring Framework – Framework para desenvolvimento de aplicações java
Instanciando o contexto Web O Spring tem uma factory específica para a utilização do framework em ambiente servlet/JEE. É possível utilizar o listener org.springframework.web.context.ContextLoaderListener ou o Servlet org.springframework.web.context.ContextLoaderServlet. Basta configurar isso no web.xml de sua aplicação, conforme exemplo abaixo: <web-app> <param-name>contextConfigLocation <param-value> /WEB-INF/Spring-beans.xml <listener> <listener-class> org.springframework.web.context.ContextLoaderListener
Código XML 2.16 web.xml. Agora é só criar um bean no Spring para podermos utilizar esse contexto web. Nesse exemplo será criado o DateService que é um service que irá prover a data atual. Observe o código abaixo: package com.targettrust.spring.web; public class DateService { public String getDate(){ System.out.println("Provendo serviço de data"); return new java.util.Date().toString(); } }
Código 2.23 DateService.java.
Agora é necessário fazer as configurações desse bean no contexto do Spring, confira isso no XML abaixo:
Diego Pacheco – http://diego-pacheco.blogspot.com
2-40
Spring Framework – Framework para desenvolvimento de aplicações java
Código XML 2.17 Spring-beans.xml.
Para testar, vamos empacotar essa aplicação em um arquivo war. Para fazer esse teste vamos chamar o serviço do Spring através de uma página jsp. Confira o código abaixo: <%@page language="java" contentType="text/html; charset=ISO-8859-1"%> <%@page import="org.springframework.web.context.support.WebApplicationContextUtils "%> <%@page import="com.targettrust.spring.web.DateService"%> Spring WEB
Exemplo de Spring com WEB-Tier
A Data atual é: <%=((DateService)WebApplicationContextUtils.getWebApplicationContext(getSe rvletConfig().getServletContext()).getBean("dateService")).getDate()%>
Código 2.23 index.jsp.
É usado um utilitário do Spring para acessar o contexto dele através de uma página jsp. Através da classe org.springframework.web.context. support.WebApplicationContextUtils nós obtemos o contexto do Spring. Utilizamos o método getWebApplicationContext passando como parâmetro o ServletContext.
Diego Pacheco – http://diego-pacheco.blogspot.com
2-41
Spring Framework – Framework para desenvolvimento de aplicações java
Exercícios
1. Faça a injeção de um objeto Cliente em um Objeto Vendedor. 2. Faça a injeção de uma Lista de Alunos em um Objeto Turma. 3. Faça a injeção de um Mapa de UF com uma Lista de Cidades. 4. Faça a injeção de um UF em um objeto País através de constructor injection. 5. Faça um Serviço de Calculadora e injete funções matemáticas nesse bean.
Diego Pacheco – http://diego-pacheco.blogspot.com
2-42
Spring Framework – Framework para desenvolvimento de aplicações java
Espaço para anotações
Diego Pacheco – http://diego-pacheco.blogspot.com
2-43
Spring Framework – Framework para Desenvolvimento de Aplicações Java
3. Manipulação de Beans
Diego Pacheco – http://diego-pacheco.blogspot.com
Spring Framework – Framework para desenvolvimento de aplicações java
Objetivos
•
Conhecer os Resource Loaders do Spring;
•
Saber utilizar o init-method;
•
Saber utilizar a herança de definições de beans;
•
Saber fazer classes de validações;
•
Saber utilizar Bean Wrapper;
•
Conhecer os PostProcessors do Spring;
•
Conhecer os principais property editors;
•
Conhecer os Eventos do container;
•
Saber utilizar o PropertyPlaceholderConfigurer;
•
Saber utilizar SingletonBeanFactoryLocator;
•
Conhecer os recursos de Internacionalização.
Diego Pacheco – http://diego-pacheco.blogspot.com
3-2
Spring Framework – Framework para desenvolvimento de aplicações java
Resource Loaders
Quando usamos arquivos de configurações como, por exemplo, xml, txt, arquivos de imagem, properties, etc é fortemente recomendado o uso de ResourceLoader que é uma interface do Spring que define a estratégia para carregar arquivos. O Spring prove uma especialização dessa interface que é a classe ResourcePatternResolver que adiciona facilidades como patterns de estilo ant, podemos usar wild cards como, por exemplo: WEB-INF/*-context.xml. Podemos utilizar a classe ServletContextResourceLoader que faz a busca de recursos no ServletContext. As BeanFactorys do Spring como, por exemplo: ClassPathXmlApplicationContext implementa ResourceLoader através de classes em sua hierarquia superior. Em síntese, as outras Beans factories do Spring também implementam essa interface ResourceLoader. Considerando a injeção do seguinte bean. <property name="arquivo" value="classpath:caminho/completo/dados.txt"> Código XML 3.1 injeção de resource Nesse código XML acima utilizando um facilitador o classpath: através dessa diretiva, instruímos o ResourceLoader a carregar esse arquivo que esteja em qualquer lugar no classpath. Poderíamos utilizar o facilitador file: para carregar arquivos que não estão no classpath da aplicação. Exemplo:
<property name="arquivo" value="file:/dados/caminho/completo/da dos.txt"> Código XML 3.2 injeção de resource fora do classpath Esse facilitador também pode ser utilizado para carregar arquivos que estão no classpath, mas para esse caso é mais recomendado o uso de classpath:. Nesse tipo de cenário se utiliza file: quando existem mais de um arquivo com o mesmo nome.
Podemos utilizar wild cards no stilo ant, segue alguns exemplos: /WEB-INF/*-context.xml com/mycompany/**/applicationContext.xml file:C:/some/path/*-context.xml classpath:com/mycompany/**/applicationContext.xml
Código de exemplos wild cards
Diego Pacheco – http://diego-pacheco.blogspot.com
3-3
Spring Framework – Framework para desenvolvimento de aplicações java
Init-Metohd e InitializingBean O Spring prove alguns mecanismos de call back após a inicialização de um bean. Após o container de IoC do Spring resolver as injeções de dependências ele prove um Call Back, ou seja, ele pode estar invocando um método em sua classe e a partir desse método você realiza algum processamento. Essa operação pode ser configurada através da propriedade init-method. Essa solução é elegante, pois não gera acoplamento entre o código do Spring e seu código. Veja isso na prática no exemplo abaixo: package com.targettrust.spring.init; import java.util.Date; public class HoraCertaService { private Date data; private String pais; public HoraCertaService() { System.out.println("Criando Bean de HoraCertaService "); } public void preparar(){ data = new Date(); System.out.println("Ajustado a hora para o pais: " + pais); } @SuppressWarnings("deprecation") public String getHoraCerta(){ return pais + " -> " + data.getHours() + ":" + data.getMinutes() + ":" + data.getSeconds(); }
public void setPais(String pais) { this.pais = pais; } }
Spring Framework – Framework para desenvolvimento de aplicações java
Código XML 3.2 injeção com uso de init-method package com.targettrust.spring.init; import org.springframework.beans.factory.BeanFactory; import org.springframework.context.support.ClassPathXmlApplicationContext; public class Test { public static void main(String[] args) { BeanFactory bf = new ClassPathXmlApplicationContext("/com/targettrust/spring/init/Springbeans.xml"); HoraCertaService bean = (HoraCertaService)bf.getBean("horaCertaService"); System.out.println("Hora: " + bean.getHoraCerta()); } }
Código 3.2 Testjava
Existem outras formas de utilizar Call back no Spring, porém menos elegantes, pois acoplam o código do Spring com o de sua aplicação. Uma possibilidade seria utilizar a interface org.springframework.beans. factory.InitializingBean essa interface possui o método afterPropertiesSet(). Esse método é invocado pela BeanFactory do Spring após todas as dependências serem resolvidas.
Assim como existe a propriedade init-method existe a propriedade destroymethod que é um Call Back para quando o container é destruído. É possível utilizar uma interface para esse Call Back, a interface é org.springframework.beans.factory. DisposableBean essa interface contém o
Diego Pacheco – http://diego-pacheco.blogspot.com
3-5
Spring Framework – Framework para desenvolvimento de aplicações java
método destroy(). Esse método será invocado no momento da destruição do contexto do Spring.
Diego Pacheco – http://diego-pacheco.blogspot.com
3-6
Spring Framework – Framework para desenvolvimento de aplicações java
Herança de Definições
Em uma aplicação orientada a objetos utilizamos com freqüência os recursos de herança, a partir de um objeto pai nasce um objeto filho que herda os métodos e propriedades de seu pai. O Spring framework prove mecanismos para herança de injeções. Considere o seguinte Service: package com.targettrust.spring.extend; public abstract class PessoaService { private String nome; private String telefone; private String email; public PessoaService() {} public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } public String getTelefone() { return telefone; } public void setTelefone(String telefone) { this.telefone = telefone; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } }
Código 3.3 PessoaService.java
Essa é uma Service (Classe de regra de negócios) que representa operação sobre uma pessoa, aqui temos um exemplo simplório, não é usual ter propriedades como nome e telefone em um Service, normalmente se utiliza isso em pojos. Mas como exemplo de herança de definições é valido. package com.targettrust.spring.extend; public class PessoaFisicaService extends PessoaService {
Diego Pacheco – http://diego-pacheco.blogspot.com
3-7
Spring Framework – Framework para desenvolvimento de aplicações java
private String cpf; public PessoaFisicaService() {} public boolean validaCpf(){ return CpfUtils.validaCPF(cpf); } public void mostraPessoa(){ if (validaCpf()){ System.out.println("nome: " + getNome() + " telefone: " + getTelefone() + " email: " + getEmail() + " cpf: " + cpf); }else{ System.out.println("Essa pessoa não tem um CPF Valido."); } } public String getCpf() { return cpf; } public void setCpf(String cpf) { this.cpf = cpf; } }
Código 3.4 PessoaFisicaService.java
Em PessoaFisicaService adicionamos a propriedade cpf e métodos como validaCpf e mostra pessoa, que ira mostrar a pessoa com seus dados caso o cpf seja válido. Foi utilizada a classe CpfUtils para fazer a validação do CPF, você pode verificar os fontes no projeto do eclipse que acompanha a apostila.
Para fazer a herança de definições no Spring é necessário existir uma estrutura de herança. Utilizamos as propriedades abstract e parent para fazer a herança. Veja isso na prática no XML de configurações seguinte: <property name="nome" value="Diego" /> <property name="email"
Diego Pacheco – http://diego-pacheco.blogspot.com
3-8
Spring Framework – Framework para desenvolvimento de aplicações java
Para testar podemos utilizar a classe de testes a baixo: package com.targettrust.spring.extend; import org.springframework.beans.factory.BeanFactory; import org.springframework.context.support.ClassPathXmlApplicationContext; public class Teste { public static void main(String[] args) { BeanFactory bf = new ClassPathXmlApplicationContext("/com/targettrust/spring/extend/Springbeans.xml"); PessoaFisicaService bean = (PessoaFisicaService)bf.getBean("pessoaFisicaService"); bean.mostraPessoa(); } }
Código 3.5 Teste.java
OBS: o atributo abstract=”true” é apenas uma demarcação no Spring e não é obrigatorio que sua classe seja abstrata.
Diego Pacheco – http://diego-pacheco.blogspot.com
3-9
Spring Framework – Framework para desenvolvimento de aplicações java
Validação
Em uma aplicação ter injeções de dependências pode não ser suficiente, é necessário validar. O spring prove mecanismos de validação através da interface org.springframework.validation. Validator. Essa interface trabalha com um objeto de erro e podemos ver um relatório de erros posteriormente. Essa interface pode ser usada em conjunto com um outro framework do portifólio do Spring, o Spring MVC, através de uma tag, pode mostrar os erros de validação de forma elegante em uma pagina JSP. A Interface Validator tem os seguintes métodos: boolean supports(Class clazz); void validate(Object target, Errors errors); No método supports deve-se retornar true se o validador que estamos construindo tem suporte para o Class passado por parâmetro. Normalmente se faz um equals aqui com o parâmetro e a classe que o validador será responsável. O método validate irá validar os dados de fato, caso seja necessário retornar “error”, isso será feito através do objeto de errors. Veja o exemplo prático a seguir: package com.targettrust.spring.validate; import org.springframework.validation.Errors; import org.springframework.validation.ValidationUtils; import org.springframework.validation.Validator; public class Pessoa implements Validator{ private String nome; private Integer idade; public Pessoa() {} @Override @SuppressWarnings("unchecked") public boolean supports(Class clazz) { return Pessoa.class.equals(clazz); } @Override public void validate(Object target, Errors errors) { ValidationUtils.rejectIfEmpty(errors, "nome", "nome.vazio"); Pessoa p = (Pessoa) target; if (p.getIdade() < 0) { errors.rejectValue("idade", "valor negativo"); } else if (p.getIdade() > 120) { errors.rejectValue("idade", "velho demais"); } } public String getNome() {
Diego Pacheco – http://diego-pacheco.blogspot.com
3-10
Spring Framework – Framework para desenvolvimento de aplicações java
return nome; } public void setNome(String nome) { this.nome = nome; } public Integer getIdade() { return idade; } public void setIdade(Integer idade) { this.idade = idade; } }
Código 3.6 Pessoa.java e classe de validação <property name="nome" value="Fulano" /> <property name="idade" value="-1" />
Código XML 3.4 injeção com uso de validator package com.targettrust.spring.validate; import org.springframework.beans.factory.BeanFactory; import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.validation.BeanPropertyBindingResult; import org.springframework.validation.Errors; public class Teste { public static void main(String[] args) { BeanFactory bf = new ClassPathXmlApplicationContext( "/com/targettrust/spring/validate/Spring-beans.xml"); Pessoa p = (Pessoa) bf.getBean("pessoa"); System.out.println("Nome: " + p.getNome() + " idade: " + p.getIdade()); Errors e = new BeanPropertyBindingResult(p,"Pessoa"); p.validate(p, e);
Diego Pacheco – http://diego-pacheco.blogspot.com
3-11
Spring Framework – Framework para desenvolvimento de aplicações java
Nesse exemplo, a partir de uma classe Pessoa foi construído um Validator para validar o objeto. Esse validator está na mesma classe Pessoa, seria possível colar esse código de validação em outra classe também. Foi utilizado uma classe utilitária do Spring que é a ValidateUtils que já tem alguns métodos que facilitam a validação. Para o teste foi instanciado um objeto de Erro e passado esse objeto para o método de validação, e no final foi iterado todos os erros e mostrado no console as mensagens de erros. Nos próximos capítulos essa questão será abordada com outra roupagem na questão dos interceptors do Spring.
Diego Pacheco – http://diego-pacheco.blogspot.com
3-12
Spring Framework – Framework para desenvolvimento de aplicações java
Bean Wrapper
Bean Wrapper é um recurso do Spring que funciona com Java beans como o próprio nome já diz, Java beans é um especificação da Sun que define se um determinado objeto deve ter um construtor vazio e métodos getters e setters de acordo com o padrão da Sun camelCase. Essa funcionalidade é na verdade um pattern do GOF que se chama decorator. Que tambem é conhecido como Wrapper que significa empacotar, no caso nós temos uma camada de adiciona um funcionalidade adicional a algo existente.
BeanWrapper é uma interface do Spring que prove funcionalidades de get e set em propriedades e propriedades de consulta que podem determinar se a propriedade pode ser escrita ou lida. Também possibilita setar propriedades e subpropriedades de uma profundidade ilimitada. Outra funcionalidade é adicionar listeners para quando alguma propriedade mudar de valor.
Esse recurso pode ser utilizado para fazer manipulações com propriedades de objetos de maneira elegante. Também é usual para fazer algum tipo de bind em sua aplicação. Confira como codificar abaixo: package com.targettrust.spring.beanwrapper; public class Funcionario { private String nome; private Long salario; public Funcionario() {} public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } public Long getSalario() { return salario; } public void setSalario(Long salario) { this.salario = salario; } @Override public String toString() { return "Funcionario[ nome: " + nome + " , salario: " + salario + " ]";
Diego Pacheco – http://diego-pacheco.blogspot.com
3-13
Spring Framework – Framework para desenvolvimento de aplicações java
} }
Código 3.8 Funcionario.java package com.targettrust.spring.beanwrapper; public class Empresa { private String nome; private Funcionario gestor; public Empresa() {} public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } public Funcionario getGestor() { return gestor; } public void setGestor(Funcionario gestor) { this.gestor = gestor; } @Override public String toString() { return "Empresa [ " + nome + " | " + gestor.toString() + " ]"; } }
Spring Framework – Framework para desenvolvimento de aplicações java
Código XML 3.5 package com.targettrust.spring.beanwrapper; import org.springframework.beans.BeanWrapper; import org.springframework.beans.BeanWrapperImpl; import org.springframework.beans.PropertyValue; import org.springframework.beans.factory.BeanFactory; import org.springframework.context.support.ClassPathXmlApplicationContext; public class Teste { public static void main(String[] args) { BeanFactory bf = new ClassPathXmlApplicationContext("/com/targettrust/spring/beanwrapper/Sprin g-beans.xml"); System.out.println(bf.getBean("empresa")); BeanWrapper company = new BeanWrapperImpl((Empresa)bf.getBean("empresa")); company.setPropertyValue("nome", "Target Trust"); // ou pode ser algo assim PropertyValue value = new PropertyValue("nome", "Some Company Inc."); company.setPropertyValue(value); BeanWrapper diego = new BeanWrapperImpl((Funcionario)bf.getBean("gestor")); diego.setPropertyValue("nome", "Diego Pacheco"); company.setPropertyValue("gestor", diego.getWrappedInstance()); Long sal = (Long) company.getPropertyValue("gestor.salario"); System.out.println("Salário: " + sal); System.out.println(company); System.out.println(company.getWrappedInstance()); // verifica o tipo da propriedade salario System.out.println(((BeanWrapperImpl)company).getPropertyDescriptor ("gestor.salario").getPropertyType()); diego.setPropertyValue("salario",200L); System.out.println(diego.getPropertyValue("salario")); } }
Código 3.10 Teste.java
Diego Pacheco – http://diego-pacheco.blogspot.com
3-15
Spring Framework – Framework para desenvolvimento de aplicações java
No exemplo acima é criado uma instância de BeanWrapperImpl a partir do bean empresa e outra BeanWrapperImpl a partir do bean gestor. Com os métodos getPropertyValue e setPropertyValue podemos modificar os valores dos objetos. Para acessar objeto “real” utilizamos o método getWrappedInstance. Outra maneira de acessar as propriedades do objeto é através do objeto PropertyValue, porém ainda precisamos de uma instância de BeanWrapper.
As propriedades desse objeto podem ser acessadas com ‘infinita’ profundidade, por exemplo: supondo que temos um objeto Pessoa que tem um objeto Brinquedo que tem uma propriedade tamanho, poderíamos acessar essa propriedade da seguinte maneira: beanWrapperInstancePessoa.getPropertyValue("brinquedo.tamanho"), supondo que temos uma instância de BeanWrapper com a variável beanWrapperInstancePessoa. Outros exemplos de acesso com propriedades:
Expressão
Descrição
nome
Corressponde a propriedade nome do objeto empacotado, irá tentar executar um getNome() ou isNome()
conta.valor
Indica que no objeto corrente existe uma propriedade conta que tem uma propriedade valor, executa algo como: getConta().getValor()
filhos[2]
Acessa a segunda posição da propriedade filhos sendo que filhos pode ser um array ou List ou qualquer outra collection ordenada.
estado[poa]
Indica que está sendo acessado a entrada poa em uma Map chamado estado.
Diego Pacheco – http://diego-pacheco.blogspot.com
3-16
Spring Framework – Framework para desenvolvimento de aplicações java
BeanPostProcessors
Esse é um recurso para customizar beans através de call-backs. Que nada mais são do que métodos a serem invocados após determinada operação ser executada, também conhecidos na literatura computacional como ganchos. Você pode utilizar esse recurso para estender as operações padrão do Spring para: lógica de instanciação, lógica de resolução de dependências e também se necessário para operações após o container do Spring finalizar suas criações de objetos. Você pode configurar múltiplos BeanPostProcessors se desejar assim, é possível configurar a ordem que cada um irá rodar a partir da propriedade order, mas isso só será possível se você implementar a interface Ordered. Existe uma forte recomendação por parte dos criadores do Spring que você faça essa implementação. A atuação do BeanPostProcessors é após a criação do bean do Spring, se desejarmos mudar sua definição é necessário utilizar BeanFactoryPostProcessor que será abordado no próximo tópico. Após cada criação de um bean no container o Spring estará invocando o BeanPostProcessor, isso significa que será executado antes de qualquer método initbean. Existe uma diferença de se usar BeanPostProcessor com BeanFactory e com ApplicationContext, por que no caso da ApplicationContex o Spring irá descobrir todos os BeanPostProcessors e registrar automaticamente para você, já em outra linha, a Bean Factory não fará nada disso, devemos registrá-los manualmente. Conforme o código abaixo: ConfigurableBeanFactory factory = new XmlBeanFactory(new ClassPathResource("beans.xml")); MeuBeanPostProcessor postProcessor = new MeuBeanPostProcessor(); factory.addBeanPostProcessor(postProcessor);
Código 3.11 Exemplo de registro de BeanPostProcessor.
Diego Pacheco – http://diego-pacheco.blogspot.com
3-17
Spring Framework – Framework para desenvolvimento de aplicações java
Esse tipo de Registro não é conveniente, por causa disso que para muitas aplicações as pessoas preferem utilizar ApplicationContex ao invés de BeanFactory. Classes que implementam BeanPostProcessor são classes especiais, logo são tratadas de maneira diferente pelo container. Todas as BenPostProcessors e aqueles beans que estejam diretamente referenciados por eles serão instanciados ao startup do Spring. Os recursos de AOP auto-proxing são implementados como BeanPostProcessor, nenhum BeanPostProcessor ou beans diretamente referenciados serão elegíveis para auto-proxy, ou seja, não haverá aspectos sobre eles. O Spring irá lhe alertar sobre essa situação com uma mensagem semelhante a essa: “Bean 'foo' is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)”. Veja um exemplo prático de como utilizar este recurso: package com.targettrust.spring.beanpostprocessors; public class ObjetoA { }
Código 3.12 ObjetoA.java package com.targettrust.spring.beanpostprocessors; public class ObjetoB { }
Código 3.13 ObjetoB.java package com.targettrust.spring.beanpostprocessors; public class ObjetoC { }
Código 3.14 ObjetoC.java
Diego Pacheco – http://diego-pacheco.blogspot.com
3-18
Spring Framework – Framework para desenvolvimento de aplicações java
Spring Framework – Framework para desenvolvimento de aplicações java
package com.targettrust.spring.beanpostprocessors; import org.springframework.context.support.ClassPathXmlApplicationContext; public class Teste { public static void main(String[] args) { new ClassPathXmlApplicationContext("/com/targettrust/spring/beanpostprocessor s/Spring-beans.xml"); } }
Código 3.16 Teste.java
A interface BeanPostProcessor possui dois métodos, são eles: • postProcessBeforeInitialization • postProcessAfterInitialization
Um dos métodos serve para efetuar operações antes da inicialização e outro após a inicialização do bean no contexto do Spring. Ambos os métodos recebem o objeto e seu nome por parâmetro, assim podemos aplicar algum proxy ou regra de negócio. Aqui poderíamos utilizar um Validator conforme visto nos tópicos anteriores e forçar a validação de determinadas propriedades. Outra possibilidade que temos aqui graças a esse extraordinário recurso do Spring é que podemos criar annotations personalizadas ou fazer os componentes implementarem interfaces e com esse gancho do BeanPostProcessor podemos ler essas informações e efetuar diversas operações que nos desperte interesse.
Diego Pacheco – http://diego-pacheco.blogspot.com
3-20
Spring Framework – Framework para desenvolvimento de aplicações java
BeanFactoryPostProcessors Similar ao BeanPostProcessor, porém o BeanFactoryPostProcessor consegue ler os metadados de configuração do Spring e também mudar esses dados antes que o Spring crie seus beans. Você pode configurar muitos BenFactoryPostProcessor. É possível configurar a ordem de execução dessa classe implementando a interface Ordered. Se você deseja mudar a instância de um bean já criado você deve utilizar o BeanPostProcessor conforme apresentando no tópico anterior. O Próprio Spring utiliza beanFactoryPostProcessor como: PropertyResourceConfigurer e PropertyPlaceholderConfigurer. Se estamos utilizando ApplicationContext o registro é feito de forma automática, se estivermos utilizando uma BeanFactory precisamos fazer isso de forma manual. A Forma de fazer isso está exemplificada logo abaixo: XmlBeanFactory factory = new XmlBeanFactory(new FileSystemResource("beans.xml")); PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer(); cfg.setLocation(new FileSystemResource("jdbc.properties")); cfg.postProcessBeanFactory(factory);
Código 3.17 Exemplo de registro de BeanPostProcessor. No código acima é criando um PropertyPlaceHolderConfigurer que é uma implementação de BeanFactoryPostProcessor e será detalhada nos próximos tópicos. Veja agora um exemplo concreto de como poderia ser utilizado o BeanFactoryPostProcessor: package com.targettrust.spring.beanfactorypostprocessors; import java.text.SimpleDateFormat; import java.util.Date; public class DataService { private String pattern; public String getPattern() { return pattern; } public void setPattern(String pattern) { this.pattern = pattern; } public String showSysDate(){ SimpleDateFormat sdf = new SimpleDateFormat(pattern); return sdf.format(new Date());
Diego Pacheco – http://diego-pacheco.blogspot.com
3-21
Spring Framework – Framework para desenvolvimento de aplicações java