Wiki
Tutorial Laboratório Módulo 2 Persistência
Tutorial – Módulo 02 – Persistência
LABORATÓRIO 02 – Persistência #
Este laboratório tem por objetivo fixar os conceitos da camada de persistência do Framework Demoiselle e orientar o processo de configuração das aplicações.
Objetivos: #
- Configurar a camada de Persistência através do Demoiselle Wizard.
- Criar a camada de persistência da aplicação Escola.
- Interfaces DAO;
- Implementações DAO;
- Filtros de Consulta;
- Testar o funcionamento da camada de persistência.
Exercício 2.1 – Configuração do Projeto #
1. Este laboratório utilizará o projeto “escola” criado no laboratório anterior.
2. Clique com o botão direito sob o projeto a acione a opção Demoiselle → Configurar Projeto.
Figura 1: Configurar Projeto
3. Na guia “Hibernate”, configure os campos conforme seu banco de dados. Este tutorial utilizará como exemplo o HypersonicSQL.
- URL: jdbc:hsqldb:hsql://127.0.0.1/escola
Figura 2: Configuração da conexão com o banco de dados
Altere as informações:
URL=> jdbc:hsqldb:hsql://127.0.0.1/escola Usuário=>sa
4. Clique no botão Finish. O Wizard irá configurar o hibernate.cfg.xml na pasta de resources do projeto conforme figura abaixo:
Figura 3: hibernate.cfg.xml
5. Adicione a dependência do HSQLDB versão 1.8.0.1 no arquivo pom.xml da aplicação (logo após a tag }profiles>) conforme abaixo:
<dependencies> ... <dependency> <groupId>hsqldb</groupId> <artifactId>hsqldb</artifactId> <version>1.8.0.1</version> </dependency> ... </dependencies>
Exercício 2.2 – Desenvolvimento da camada de persistência. #
Pacote Bean
1. Pojo Aluno #
No pacote br.gov.demoiselle.escola.bean Implemente o Pojo de Aluno conforme abaixo:
package br.gov.demoiselle.escola.bean; import java.util.ArrayList; import java.util.Date; import java.util.HashSet; import java.util.List; import java.util.Set; import javax.persistence.Entity; import javax.persistence.Table; import javax.persistence.Column; import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.Temporal; import javax.persistence.TemporalType; import javax.persistence.CascadeType; import javax.persistence.OneToMany; import javax.persistence.GenerationType; import br.gov.framework.demoiselle.core.bean.IPojo; @Entity @Table(name="aluno") @SequenceGenerator(name="AlunoSequence", sequenceName="aluno_seq", allocationSize=1) public class Aluno implements IPojo { private static final long //serialVersionUID// = 1L; @Id @GeneratedValue(generator="AlunoSequence", strategy=GenerationType.//SEQUENCE//) @Column(name="id_aluno") private Long id; @Column(name="nome", length=100) private String nome; @Column(name="pai", length=100) private String pai; @Column(name="mae", length=100) private String mae; @Column(name="nascimento") @Temporal(value=TemporalType.//DATE//) private Date nascimento; @OneToMany(cascade=CascadeType.//ALL//, fetch=FetchType.//LAZY//) private Set<Endereco> enderecos; public Aluno() { enderecos = new HashSet<Endereco>(); } public Aluno(long** id) { this(); this.id = id; } public Long getId() {return id; } public void setId(Long id) { this.id = id; } public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } public String getPai() { return pai; } public void setPai(String pai) { this.pai = pai; } public String getMae() { return mae; } public void setMae(String mae) { this.mae = mae; } public Date getNascimento() { return nascimento; } public void setNascimento(Date nascimento) { this.nascimento = nascimento; } public Set<Endereco> getEnderecos() { return enderecos; } public List<Endereco> getListaEndereco() { return new ArrayList<Endereco>(enderecos); } public void setEnderecos(Set<Endereco> enderecos) { this.enderecos = enderecos; } }
2. Pojo Endereço #
No mesmo pacote implemente o Pojo de Endereço:
package br.gov.demoiselle.escola.bean; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.ManyToOne; import javax.persistence.Table; import br.gov.component.demoiselle.common.pojo.extension.Description; import br.gov.component.demoiselle.common.pojo.extension.EqualsField; import br.gov.component.demoiselle.common.pojo.extension.PojoExtension; import br.gov.framework.demoiselle.core.bean.IPojo; @Entity @Table(name="endereco") @SequenceGenerator(name="EnderecoSequence", sequenceName="Endereco_seq", allocationSize=1) public class Endereco extends PojoExtension implements IPojo { private static final long serialVersionUID = 1L; @EqualsField @Id @GeneratedValue(generator="EnderecoSequence", strategy=GenerationType.SEQUENCE) @Column(name="id_endereco") private Long id; @EqualsField @Description @Column(name="logradouro", length=100) private String logradouro; @Description @Column(name="numero", length=100) private String numero; @Description @Column(name="complemento", length=100) private String complemento; @Description @Column(name="bairro", length=100) private String bairro; @Description @Column(name="cep", length=100) private String cep; @Column(name="municipio", length=100) private String municipio; @Description @Column(name="tipo") private Integer tipo; @Description @ManyToOne(fetch=FetchType.LAZY) @JoinColumn(name="aluno") private Aluno aluno; public Endereco() { } public Endereco(String logradouro, String numero, String complemento, String bairro, String cep, String Municipio, Integer tipo) { super(); this.logradouro = logradouro; this.numero = numero; this.complemento = complemento; this.bairro = bairro; this.cep = cep; this.municipio = Municipio; this.tipo = tipo; } public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getLogradouro() { return logradouro; } public void setLogradouro(String logradouro) { this.logradouro = logradouro; } public String getNumero() { return numero; } public void setNumero(String numero) { this.numero = numero; } public String getComplemento() { return complemento; } public void setComplemento(String complemento) { this.complemento = complemento; } public String getBairro() { return bairro; } public void setBairro(String bairro) { this.bairro = bairro; } public String getCep() { return cep; } public void setCep(String cep) { this.cep = cep; } public Integer getTipo() { return tipo; } public void setTipo(Integer tipo) { this.tipo = tipo; } public String getMunicipio() { return municipio; } public void setMunicipio(String Municipio) { this.municipio = Municipio; } public Aluno getAluno() { return aluno; } public void setAluno(Aluno aluno) { this.aluno = aluno; } }
3. Associando POJOs ao Hibernate #
Para associar os POJOS ao hibernate.cfg.xml acione o menu: Demoiselle → Configurar Projeto.
- Na guia Hibernate, clique no botão Adicionar Pojo (figura 4).
Figura 4: Adicionar Pojo
Na Tela seguinte (figura 5) selecione a Classe que deseja associar.
Figura 5: Seleção de POJOs
Acione o botão Finish e verifique que o Wizard associou o arquivo hibernate.cfg.xml às duas classes selecionadas:
<property name="hibernate.connection.driver_class">org.hsqldb.jdbcDriver</property> <property name="hibernate.connection.url">jdbc:hsqldb:hsql://localhost/escola/</property> <property name="hibernate.connection.username">sa</property> <property name="hibernate.connection.password" /> <property name="hibernate.dialect">org.hibernate.dialect.HSQLDialect</property> <property name="show_sql">true</property> <property name="format_sql">true</property> <property name="hbm2ddl.auto">update</property> <mapping class="br.gov.demoiselle.escola.bean.Aluno" /> <mapping class="br.gov.demoiselle.escola.bean.Endereco" />
4. Implementação dos Pacotes DAO #
1. Para geração das classes de acesso a dados (DAO), utilize o Menu → Demoiselle → Editar Projeto:
Figura 6: Editar Projeto
2. Na guia DAOs acione o botão Adicionar para criar o DAO responsável pelo Pojo Aluno.
Figura 7: Adicionar DAO
3. No campo Pacote selecione o pacote: br.gov.demoiselle.escola.persistence.dao} no campo Pojo selecione a classe: br.gov.demoiselle.escola.bean.Aluno. Selecione o tipo DAO Hibernate conforme mostrado na figura abaixo:
Figura 8: Salvar DAO
4. Acione o botão Salvar.
5. Acione o botão Finish e aguarde a criação das classes nos pacotes conforme abaixo:
Figura 9: Interface para DAO e sua implementação
- A classe 'IAlunoDAOespecifica apenas os métodos de consulta.
Adicione na interface IAlunoDAO os seguintes métodos, conforme o código abaixo:
package br.gov.demoiselle.escola.persistence.dao; import java.util.List; import br.gov.framework.demoiselle.core.layer.IDAO; import br.gov.framework.demoiselle.util.page.Page; import br.gov.framework.demoiselle.util.page.PagedResult; import br.gov.demoiselle.escola.bean.Aluno; import br.gov.demoiselle.escola.bean.Endereco; public interface IAlunoDAO extends IDAO<Aluno> { public PagedResult<Aluno> listar(Page pagina); public List<Aluno> listar(); public PagedResult<Aluno> filtrar(Aluno aluno, Page pagina); public Aluno buscar(Aluno aluno); public void alterarEndereco(Endereco endereco); }
- A classe 'AlunoDAO' implementará apenas os métodos definidos na interface IAlunoDAO, pois as demais operações (Create Read Update Delete) = Criar, Ler, Atualizar e Excluir, encontram-se implementadas por herança.
Por enquanto crie os métodos da classe AlunoDAO sem implementação;
import java.util.List; import br.gov.framework.demoiselle.persistence.hibernate.HibernateGenericDAO; import br.gov.framework.demoiselle.util.page.Page; import br.gov.framework.demoiselle.util.page.PagedResult; import br.gov.demoiselle.escola.bean.Aluno; import br.gov.demoiselle.escola.bean.Endereco; import br.gov.demoiselle.escola.persistence.dao.IAlunoDAO; public class AlunoDAO extends HibernateGenericDAO<Aluno> implements IAlunoDAO public void alterarEndereco(Endereco endereco) { // TODO Auto-generated method stub } public List<Aluno> listar() { // TODO Auto-generated method stub return null; } public Aluno buscar(Aluno aluno) { // TODO Auto-generated method stub return null; } public PagedResult<Aluno> filtrar(Aluno aluno, Page pagina) { // TODO Auto-generated method stub return null; } public PagedResult<Aluno> listar(Page pagina) { // TODO Auto-generated method stub return null; } }
Exercício 2.3 – Filtros – Uso do Componente #
1. Criar a classe FiltroAluno #
No pacote br.gov.demoiselle.escola.persistence.dao.filter crie a classe FiltroAluno e inclua os campos ID e NOME para a filtragem conforme exemplo abaixo.
package br.gov.demoiselle.escola.persistence.dao.filter; import br.gov.component.demoiselle.hibernate.filter.Filter; import br.gov.demoiselle.escola.bean.Aluno; public class FiltroAluno extends Filter { private static final long serialVersionUID = 1L; public static final String ID = "id"; public static final String NOME = "nome"; public FiltroAluno(){ setClazz(Aluno.class); addOrder(NOME, ASC); } }
Para utilizar o componente Hibernate-Filter, as classes DAOs deverão estender a classe HibernateFilterGenericDAO.
2. Alterar a classe AlunoDAO #
Modifique a classe AlunoDAO conforme exemplo abaixo:
De:
public class AlunoDAO extends HibernateGenericDAO<Aluno> implements IAlunoDAO
Para:
public class AlunoDAO extends HibernateFilterGenericDAO<Aluno> implements IAlunoDAO
Retire o import:
import br.gov.framework.demoiselle.persistence.hibernate.HibernateGenericDAO;
Inclua:
import br.gov.component.demoiselle.hibernate.filter.dao.HibernateFilterGenericDAO; import br.gov.framework.demoiselle.persistence.hibernate.HibernateUtil; import br.gov.demoiselle.escola.persistence.dao.filter.FiltroAluno;
3. Implementar os métodos da classe AlunoDAO #
Para cada método, conforme o código abaixo:
- Listar alunos:
public PagedResult<Aluno> listar(Page pagina) { HibernateUtil.getInstance().getSession().flush(); return findHQL("FROM Aluno ORDER BY nome ASC", pagina); } public List<Aluno> listar() { HibernateUtil.getInstance().getSession().flush(); return findHQL("FROM Aluno ORDER BY nome ASC"); }
- Filtrar alunos:
public PagedResult<Aluno> filtrar(Aluno aluno, Page pagina) { HibernateUtil.getInstance().getSession().flush(); return findByExample(aluno, pagina); }
- Buscar Aluno:
public Aluno buscar(Aluno aluno) { HibernateUtil.getInstance().getSession().flush(); FiltroAluno filtro = new FiltroAluno(); filtro.addEquals(FiltroAluno.ID, aluno.getId()); List<Aluno> retorno = find(filtro); if (retorno != null && retorno.size() > 0 ) return retorno.get(0); return null; }
- Alterar Endereço:
public void alterarEndereco(Endereco endereco) { HibernateUtil.getInstance().getSession().update(endereco); }
Sua camada de acesso a dados está implementada e pronta para ser testada!
Exercício 2.4 – Execução e Testes #
1. Para realizar os testes, utilizaremos o banco de dados HSQLDB, que foi incluído como dependência.
2. Para realizar os testes, podemos utilizar o banco de dados HSQLDB disponível no material de treinamento. (repositório SVN do Demoiselle: https://demoiselle.svn.sourceforge.net/svnroot/demoiselle/trunk/docs/others/tutorial/tools/hsqldb.zip);
3. Inicie-o em modo servidor da seguinte forma:
- Se ambiente Windows:
- Execute a arquivo: ./hsqldb/run.bat
- Se ambiente Linux:
- Execute a arquivo: ./hsqldb/run.sh
Mantenha o console aberto enquanto utilizar o banco.
Figura 10: Console com inicialização do Hsqldb
- Se utilizar este modo vá para o item 5.
4. Para iniciar o banco através do Eclipse, Inicie-o em modo servidor da seguinte forma:
- No ambiente Eclipse, Crie o arquivo server.properties na raiz do projeto:
Figura 11: Configuração do banco escola
- texto do arquivo, server.properties:
server.database.0=./db_escola/escola</tt> server.dbname.0=escola server.silent=false server.trace=true
- Depois, Selecione o Menu: Run → Run Configurations...
Figura 12: Run configurations
Clique com o botão direito do mouse e depois clique em New
Figura 13: New configuration
- Nesta tela, clique no Botão Search
Figura 14: Search class
Digite ou procure o item Server, depois clique em OK.
- Ao voltar na tela Anterior, escolha um nome para Configuração (Name) e clique no botão Apply e depois Run.
- Com isto, toda vez que precisar rodar o banco, basta escolher esta configuração.
- Resultado na Console do Eclipse:
[Server@173831b]: [Thread[main,5,main]]: checkRunning(false) entered [Server@173831b]: [Thread[main,5,main]]: checkRunning(false) exited [Server@173831b]: Startup sequence initiated from main() method [Server@173831b]: Loaded properties from [/home/80621732915/work_teste/escola/server.properties] [Server@173831b]: [Thread[main,5,main]]: start() entered [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: run() entered [Server@173831b]: Initiating startup sequence... [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: server.tls=false [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: server.port=9001 [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: server.trace=true [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: server.database.0=./db_escola/escola [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: server.restart_on_shutdown=false [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: server.no_system_exit=false [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: server.silent=false [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: server.default_page=index.html [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: server.address=0.0.0.0 [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: server.dbname.0=escola [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: server.root=. [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: openServerSocket() entered [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: Got server socket: ServerSocket[addr=0.0.0.0/0.0.0.0,port=0,localport=9001] [Server@173831b]: Server socket opened successfully in 16 ms. [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: openServerSocket() exiting [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: openDatabases() entered [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: Opening database: [file:./db_escola/escola] [Server@173831b]: Database [index=0, id=0, db=file:./db_escola/escola, alias=escola] opened sucessfully in 171 ms. [Server@173831b]: [Thread[HSQLDB Server @173831b,5,main]]: openDatabases() exiting [Server@173831b]: Startup sequence completed in 190 ms. [Server@173831b]: 2009-08-18 09:45:38.833 HSQLDB server 1.8.0 is online [Server@173831b]: To close normally, connect and execute SHUTDOWN SQL [Server@173831b]: From command line, use [Ctrl]+[C] to abort abruptly [Server@173831b]: [Thread[main,5,main]]: start() exiting
O HSQLDB vem com uma ferramenta chamada Database Manager, que é uma interface gráfica que permite navegar pelas tabelas do banco. É muito útil para acompanhar o efeito das operações de persistência. Ela pode ser executada com o comando:
java -cp hsqldb/lib/hsqldb.jar org.hsqldb.util.DatabaseManager
5. Para geração das classes de testes da camada DAO, utilize o Menu → Demoiselle → Editar Projeto:
Figura 15: Editar Projeto
Selecione a Aba: Teste Unitário:
Figura 16: Gerar Teste Unitário
Clique no botão Adicionar, para habilitar a inclusão de um novo teste unitário e os campos do lado direito da tela. Depois clique no botão Pesquisar, por padrão o Tipo da Interface já estará marcada como DAO, e será deste tipo que iremos criar o teste.
Figura 17: Selecionar Classe para Teste
Selecione a interface IAlunoDAO, e clique no botão Finish.
Figura 18: Salvando Classe de Teste Com a interface selecionada, clique no botão Salvar.
Figura 19: Aplicando Alterações JUnit Na sequência, clique no botão Aplicar. Aguarde a confirmação dos resultados.
Figura 20: Finalizando Alterações JUnit
Depois clique no botão Finish. O caso de testes deverá ser criado conforme a estrutura abaixo:
Figura 21: Pacote de Classes de Teste
6. Altere o teste para a inclusão do aluno:
@Test public void testInsertObject() { Aluno obj_Aluno = new Aluno(); obj_Aluno.setNome("Aluno 01"); obj_Aluno.setNascimento(new Date()); obj_Aluno.setMae("Mae do aluno 01"); obj_Aluno.setPai("Pai do aluno 01"); Endereco obj_Endereco = new Endereco(); obj_Endereco.setBairro("Bairro do aluno 01"); obj_Endereco.setCep("01010101"); obj_Endereco.setComplemento("Complementdo ao Aluno 01"); obj_Endereco.setLogradouro("Logra"); obj_Endereco.setAluno(obj_Aluno); obj_Aluno.setEnderecos(new HashSet<Endereco>()); obj_Aluno.getEnderecos().add(obj_Endereco); alunoDAO.insert(obj_Aluno); assertTrue(obj_Aluno.getId() >= 0); Endereco endereco = (Endereco) obj_Aluno.getEnderecos().toArray()[0]; assertNotNull(endereco); assertTrue(endereco.getId() >= 0); }
Para este teste serão necessários os seguintes imports:
import java.util.Date; import java.util.HashSet; import br.gov.demoiselle.escola.bean.Aluno; import br.gov.demoiselle.escola.bean.Endereco;
7. Altere o teste de alteração do Aluno:
@Test public void testUpdate() { //Cria um novo aluno Aluno obj_Aluno = new Aluno(); obj_Aluno.setNome("Aluno_criado"); Endereco endereco = new Endereco(); endereco.setLogradouro("Endereco_criado"); endereco.setAluno(obj_Aluno); obj_Aluno.setEnderecos(new HashSet<Endereco>()); obj_Aluno.getEnderecos().add(endereco); alunoDAO.insert(obj_Aluno); long id = obj_Aluno.getId(); //Altera o aluno criado obj_Aluno = alunoDAO.buscar(new Aluno(id)); obj_Aluno.setNome("Aluno_alterado"); endereco = (Endereco) obj_Aluno.getEnderecos().toArray()[0]; endereco.setLogradouro("Endereco_alterado"); alunoDAO.update(obj_Aluno); //Consulta aluno alterado obj_Aluno = alunoDAO.buscar(new Aluno(id)); assertEquals("Aluno_alterado", obj_Aluno.getNome()); endereco = (Endereco) obj_Aluno.getEnderecos().toArray()[0]; endereco.setLogradouro("Endereco_alterado"); assertEquals("Endereco_alterado", endereco.getLogradouro()); }
8. Altere o seguinte método para testar a remoção de Aluno.
@Test public void testRemove() { //Cria um aluno para ser removido Aluno obj_Aluno = new Aluno(); obj_Aluno.setNome("Aluno_criado"); Endereco endereco = new Endereco(); endereco.setLogradouro("Endereco_criado"); endereco.setAluno(obj_Aluno); obj_Aluno.setEnderecos(new HashSet<Endereco>()); obj_Aluno.getEnderecos().add(endereco); alunoDAO.insert(obj_Aluno); long id = obj_Aluno.getId(); //Remove o aluno obj_Aluno = alunoDAO.buscar(new Aluno(id)); assertNotNull(obj_Aluno); alunoDAO.remove(obj_Aluno); //Verifica se foi removido obj_Aluno = alunoDAO.buscar(new Aluno(id)); assertNull(obj_Aluno); }
9. Altere também o teste para o método de consulta.
@Test public void testListarList() { List<Aluno> lista = new ArrayList<Aluno>(); lista = alunoDAO.listar(); for (Aluno varios : lista ) { System.out.println(varios.getId()); } assertTrue(lista.size()>0); }
Para este teste serão necessários os seguintes imports:
import java.util.List; import java.util.ArrayList;
* Importante: O teste de Listagem só terá sucesso, se estiver após o teste de inclusão. Ou ainda após a primeira execução dos testes.
10. Os outros testes estarão como assertTrue(false), e portanto deverão falhar. Para o exercício proposto os testes que foram implementados são suficientes para testar a camada DAO.
11. Após as alterações execute o comando CLEAN do Eclipse. Menu Project-> Clean …
Figura 22: Eclipse Clean
12. Rode os testes e verifique seus resultados.
Figura 23: Executar JUnit Perceba que em os resultado em verde ocorreram com sucesso.
Última Figura: Testes OK
Exercício 2.5 – Criação de DAO Stub e Fábrica Customizada #
1. Criar uma nova implementação para a interface IAlunoDAO chamada AlunoDAOStub. Esta classe armazenará os dados em memória.
Dica:
public class AlunoDAOStub implements IAlunoDAO { private static List<Aluno> listAluno = new ArrayList<Aluno>(); private static Long idAluno = 0l; private static Long idEndereco = 0l;
continue.....
2. Duplique a classe AlunoDAOTest com o novo nome AlunoDAOStubTest., altere apenas a notação do atributo IAlunoDAO conforme abaixo:
public class AlunoDAOStubTest implements IFacade{ @Injection(name="br.gov.demoiselle.escola.persistence.dao.implementation.AlunoDAOStub") private IAlunoDAO alunoDAO; ....
3. Rode os testes e verifique seus resultados.
4. Para a construção da fábrica customizada de Daos crie um pacote factory dentro do pacote persistence:
package br.gov.demoiselle.escola.persistence.factory;
5. Crie a classe EscolaDAOFactory no pacote criado:
public class EscolaDAOFactory extends WebDAOFactory { @SuppressWarnings("unchecked") public IDAO create(InjectionContext ctx) { IDAO newDao = null; String className = ctx.getFieldType().getName(); className = className.replace(".dao.", ".dao.implementation."); className = className.replace(".I", "."); className += "Stub"; try { Class c = Class.forName(className); newDao = (IDAO) c.newInstance(); } catch (Exception e) { throw new RuntimeException(e); } return newDao; } }
6. Volte a classe AlunoDAOStubTest, inclua a anotação @Factory para indicar que esta classe utilizará a fábrica customizada e volte a utilizar apenas o @Injection na atributo alunoDAO
@Factory(factory=EscolaDAOFactory.class) public class AlunoDAOStubTest implements IFacade{ @Injection private IAlunoDAO alunoDAO; ...
7. Rode os testes de unidade e verifique os resultados Sugestão de Exercício – Criar os testes restantes.
Créditos
Laboratório criado por Vanderson Botellho da Silva (SERPRO/SUPST/STCTA)
Contribuições:
Emerson Saito (SERPRO/CETEC/CTCTA)
Flávio Gomes da Silva Lisboa (SERPRO/CETEC/CTCTA)
Robson Ximenes (SERPRO/CETEC/CTSDR)
Rodrigo Hjort (SERPRO/CETEC/CTCTA)Rafael Bomfim