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