Raible's Wiki

Raible Designs
Wiki Home
News
Recent Changes

AppFuse

Homepage
  - Korean
  - Chinese
  - Italian
  - Japanese

QuickStart Guide
  - Chinese
  - French
  - German
  - Italian
  - Korean
  - Portuguese
  - Spanish
  - Japanese

User Guide
  - Korean
  - Chinese

Tutorials
  - Chinese
  - German
  - Italian
  - Korean
  - Portuguese
  - Spanish

FAQ
  - Korean

Latest Downloads

Other Applications

Struts Resume
Security Example
Struts Menu

Set your name in
UserPreferences

Referenced by
Articles
Articles_pt
CreateManager_pt
LeftMenu




JSPWiki v2.2.33

[RSS]


Hide Menu

CreateDAO_pt
Search Wiki:
Your trail:

This is version 24. It is not the current version, and thus it cannot be edited.
[Back to current version]   [Restore this version]

Parte I: Criando novos DAOs e Objetos no AppFuse - Um HowTo para criar Objetos Java (que representam tabelas) e criar classes Java para persistir estes objetos no banco de dados.

Sobre este Tutorial

Este tutorial mostrara a você como criar uma nova tabela no banco de dados, e como criar código java para acessar esta tabela.

Nós criaremos um objeto e então mais algumas classes para persistir (save/retrieve/delete) aquele objeto do banco de dados. Em termos java, chamaremos o objeto de “Plain Old Java Object” (a.k.a. a POJO). Este objeto basicamente representa uma tabela do banco de dados. As outras classes serão:

  • Um Objeto de Acesso a Dados (a.k.a. a DAO), uma Interface e uma implementação Hibernate
  • Uma classe JUnit para testar se nosso DAO está funcionado
NOTA: Se você está usando MySQL e quer usar transações (provavelmente usará) você tem de usar tabelas InnoDB. Para fazê-lo, adicione o seguinte ao seu arquivo mysql de configurações (/etc/my.cnf ou c:\Windows\my.ini). O segundo ajuste (para um character set UTF-8) é necessário para a versão 4.1.7+. 
[mysqld]
default-table-type=innodb
default-character-set=utf8
Se você está usando PostgreSQL e obtém erros confusos sobre processamento batch, tente desabilitá-lo adicionando <prop key="hibernate.jdbc.batch_size">0</prop> ao seu arquivo src/dao/**/hibernate/applicationContext-hibernate.xml.

AppFuse usa Hibernate para sua camada de persistência. Hibernate é um framework Objeto/Relacional (OR) que nos permite relacionar objetos Java à tabelas no banco de dados. Permitindo muito facilmente efetuar CRUD (Create, Retrieve, Update, Delete) em nossos objetos.

Você também pode usar iBATIS como opção de framework de persistência. Para instalar iBATIS no AppFuse, veja o arquivo README.TXT em extras/ibatis. Se você estiver usando iBATIS, espero que tenha suas razões e que conheça este framework. Espero também que você descubra como adaptar este tutorial para que funcione com iBATIS. ;-)
I will tell you how I do stuff in the Real World in text like this.

Vamos começar criando um novo Objeto, DAO, Test na arquitetura AppFuse.

Tabela de Conteúdo

  • [1] Criar um novo Objeto e adicionar tags XDoclet
  • [2] Criar uma nova tabela no banco de dados a partir do objeto, usando Ant
  • [3] Criar uma nova classe DaoTest para executar testes JUnit no DAO
  • [4] Criar uma nova classe DAO para efetuar CRUD no objeto
  • [5] Configurar o framework Spring para o objeto Pessoa e PessoaDAO
  • [6] Executar o DaoTest

Criar um novo Objeto e Adicionar tags XDoclet [#1]

A primeira coisa que precisamos fazer é criar um objeto a persistir. Vamos criar um simples objeto “Pessoa” (no diretório src/dao/**model) que tem um id, primeiroNome e ultimoNome (como propriedades).


package org.appfuse.model;

public class Person extends BaseObject {
  private Long id;
  private String firstName;
  private String lastName;

    /*
     Generate your getters and setters using your favorite IDE: 
     In Eclipse:
     Right-click -> Source -> Generate Getters and Setters
    */
}

Usualmente abro um objeto existente (ex.: User.java ou Resume.java) e o salvo como um novo arquivo. Então deleto todos os métodos e propriedades. Isto me dá um básico cabeçalho JavaDoc. Estou certo que poderia editar os Templates Eclipse para fazer isto, mas eu desenvolvo em 3 diferentes máquinas, e isso é justamente mais fácil.

Esta classe deve extender BaseObject, a qual tem 3 métodos abstratos: (equals(), hashCode() and toString()) que você precisará implementar na classe Pessoa. Os dois primeiros são requeridos pelo Hibernate. A maneira mais simples de fazer isto é usando Commonclipse. Mais informações em usar esta ferramenta pode ser encontrada em Lee Grey's site. Outro Eclipse Plugin que você pode usar é Commons4E. Eu não o usei, assim eu não posso comentar sua funcionalidade.

Se você está usando IntelliJ IDEA, você pode gerar equals() and hashCode(), mas não toString(). Há um ToStringPlugin, mas não o testei pessoalmente.

Agora que temos este POJO criado, nós precisamos adicionar tags XDoclet para gerar o arquivo de mapeamento Hibernate. Este arquivo de mapeamento é usado pelo Hibernate para mapear objetos => tabelas e propriedades => colunas.

Primeiro de tudo, nós adicionaremos uma tag @hibernate.class que diz ao Hibernate que tabela este objeto se relaciona:


/**
 * @hibernate.class table="person"
 */
public class Person extends BaseObject {

Nós também precisamos adicionar um mapeamento de chave primária ou XDoclet irá vomitar quando gerar o arquivo de mapeamento. Note que todos os tags @hibernate.* deverão ser colocados no JavaDocs dos métodos get de seus POJOs.



    /**
     * @return Returns the id.
     * @hibernate.id column="id"
     *  generator-class="increment" unsaved-value="null"
     */

    public Long getId() {
        return this.id;
    }

Estou usando generator-class="increment" ao invés de generate-class="native" porque encontrei alguns problemas ao usar “native” em outros bancos de dados. Se você somente planeja usar o MySql, eu recomendo que você use o valor “native”.

Criar uma nova tabela no banco de dados a partir do objeto, usando Ant [#2]

Neste ponto, você pode atualmente criar a tabela pessoa executando “ant setup-db”. Esta tarefa cria o arquivo Pessoa.hbm.xml e cria uma tabela no banco de dados chamada “pessoa”. A partir do console ant, você pode ver o schema da tabela que Hibernate cria para você: 

[schemaexport] create table person (
[schemaexport]    id bigint not null,
[schemaexport]    primary key (id)
[schemaexport] )

Se você quiser procurar o arquivo Pessoa.hbm.xml que Hibernate gera para você, procure no diretório build/dao/gen/**/model. Aqui está o conteúdo do Pessoa.hbm.xml (até aqui):


<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 2.0//EN" 
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>
    <class
        name="org.appfuse.model.Person"
        table="person"
        dynamic-update="false"
        dynamic-insert="false"
    >

        <id
            name="id"
            column="id"
            type="java.lang.Long"
            unsaved-value="null"
        >
            <generator class="increment">
            </generator>
        </id>

        <!--
            To add non XDoclet property mappings, create a file named
                hibernate-properties-Person.xml
            containing the additional properties and place it in your merge dir.
        -->

    </class>

</hibernate-mapping>

Agora nós iremos adicionar tags @hibernate.property para nossas colunas (primeiroNome, ultimoNome):


    /**
     * @return Returns the firstName.
     * @hibernate.property column="first_name" length="50"
     */
    public String getFirstName() {
        return this.firstName;
    }

    /**
     * @return Returns the lastName.
     * @hibernate.property column="last_name" length="50"
     */
    public String getLastName() {
        return this.lastName;
    }

Neste exemplo, a única razão de adicionar o atributo column é porque o nome da coluna é diferente do nome da propriedade. Se elas forem iguais, você não necessita especificar o atributo column. Veja a referência @hibernate.property para outros atributos que você pode especificar para este tag.

Execute “ant setup-db” outra vez para ter as colunas adicionais adicionadas à sua tabela. 

[schemaexport] create table person (
[schemaexport]    id bingint NOT NULL,
[schemaexport]    first_name varchar(255),
[schemaexport]    last_name varchar(255),
[schemaexport]    primary key (id)
[schemaexport] )

Se você quiser alterar o tamanho de suas colunas, especifique um atributo length=tamanho no tag @hibernate.property. Se quiser que ele se torne um campo requerido (NOT NULL), adicione not-null=”true”.

Criar uma nova classe DaoTest para executar testes JUnit no DAO [#3]

NOTE: AppFuse versions 1.6.1+ contain include an AppGen tool that can be used to generate all the classes for the rest of these tutorials. However, it's best that you go through these tutorials before using this tool - then you'll know what code it's generating.

Agora iremos criar uma classe DaoTest para testar se nosso DAO funciona. “Espere um minuto” você diz, “nós não criamos um DAO!” Você está correto. No entanto, eu descobri que Desenvolvimento dirigido por Testes produz softwares de alta qualidade. Por anos, pensei que escrever seu teste antes de sua classe era tolice. Simplesmente parecia estúpido. Então eu tentei e descobri que funciona notavelmente. A única razão de fazer todo este desenvolvimento dirigido por teste agora é porque descobri que ele rapidamente aumenta a velocidade do processo de desenvolvimento de software.

Para começar, crie uma classe PessoaDaoTest.java no diretório test/dao/**/dao. Esta classe deve estender BaseDaoTestCase, que já existe neste pacote. Esta classe pai é usada para carregar ApplicationContext do Spring's (Spring une todas as camadas), e para automaticamente carregar um arquivo .properties (ResourceBundle) que tem o mesmo nome que sua classe *Test.class. Neste exemplo, se você colocar um arquivo PessoaDAOTest.properties no mesmo diretório que PessoaDAOTest.java, este arquivo de propriedades estará disponível via uma variável “rb”.

Usualmente copio (abrir salvar como) um teste existente (ex.: UserDaoTest.java) e procurar/substituir [Uu]ser com [Pp]essoa, ou qualquer que seja o nome do meu objeto.


package org.appfuse.dao;

import org.appfuse.model.Person;
import org.springframework.dao.DataAccessException;

public class PersonDaoTest extends BaseDaoTestCase {
    
    private Person person = null;
    private PersonDao dao = null;

    protected void setUp() throws Exception {
        super.setUp();
        dao = (PersonDao) ctx.getBean("personDao");
    }

    protected void tearDown() throws Exception {
        super.tearDown();
        dao = null;
    }
}

O código que você vê acima é o que precisamos para um teste JUnit básico, que inicializa e destrói nosso PessoaDAO. O objeto “ctx” é uma referência ao ApplicationContext do Spring, o qual é inicializado em um bloco estático da classe BaseDaoTestCase's class.

Agora precisamos realmente testar que os métodos CRUD (Create, Retrieve, Update, Delete) funcionem em nosso DAO. Para fazê-lo, criamos métodos que começam com “test” (tudo letra minúscula). Contanto que estes métodos sejam públicos, tenham o tipo void como retorno e não receba argumentos, eles serão chamados por nossa tarefa em nosso arquivo build.xml. Aqui esta alguns testes simples para testar CRUD. Uma coisa importante a lembrar é que cada método (também conhecido como test) deve ser autônomo. Adicione os seguintes métodos para seu arquivo PessoaDaoTest.java:


    public void testGetPerson() throws Exception {
        person = new Person();
        person.setFirstName("Matt");
        person.setLastName("Raible");

        dao.savePerson(person);
        assertNotNull(person.getId());

        person = dao.getPerson(person.getId());
        assertEquals(person.getFirstName(), "Matt");
    }

    public void testSavePerson() throws Exception {
        person = dao.getPerson(new Long(1));
        person.setFirstName("Matt");
        person.setLastName("Last Name Updated");

        dao.savePerson(person);

        if (log.isDebugEnabled()) {
            log.debug("updated Person: " + person);
        }

        assertTrue(person.getLastName().equals("Last Name Updated"));
    }

    public void testAddAndRemovePerson() throws Exception {
        person = new Person();
        person.setFirstName("Bill");
        person.setLastName("Joy");

        dao.savePerson(person);

        assertEquals(person.getFirstName(), "Bill");
        assertNotNull(person.getId());

        if (log.isDebugEnabled()) {
            log.debug("removing person...");
        }

        dao.removePerson(person.getId());
        assertNull(dao.getPerson(person.getId()));
    }

No método testGetPessoa, estamos criando uma pessoa e então chamado um get. Costumo inserir um registro no banco de dados que possa sempre confiar. Como DBUnit é usado para popular nosso banco de dados com dados de teste antes da execução, você pode simplesmente adicionar uma nova table/record ao arquivo metadata/sql/sample-data.xml:

<table name='person'>
    <column>id</column>
    <column>first_name</column>
    <column>last_name</column>
    <row>
      <value>1</value>
      <value>Matt</value>
      <value>Raible</value>
    </row>
</table>
Desta forma, você pode eliminar a funcionalidade “criar um novo” no método testGetPessoa. Se você preferir adicionar este registro diretamente no banco de dados (via SQL ou GUI), você pode reconstruir seu arquivo sample-data.xml usando “ant db-export” e então “cp db-export metadata/sql/sample-data.xml”.

No exemplo acima, você pode vê que estamos chamando pessoa.set*(valor) para popular nosso objeto antes de salvá-lo. Isto é fácil neste exemplo, mas poderia se tornar bastante incômodo se estivermos persistindo um objeto com 10 campos requeridos (not-null=”true”). Dai o porque da criação do ResourceBundle na classe BaseDaoTestCase. Simplesmente crie um arquivo PessoaDaoTest.properties no mesmo diretório que o arquivo PessoaDAOTest.java e defina o valor das propriedades dentro dele:

Tendo simplesmente a codificar valores de testes no código java – mas o arquivo .properties é uma opção.
firstName=Matt
lastName=Raible
Então, ao invés de chamar pessoa.set* para popular seus objetos, você pode usar o método BaseDaoTestCase.populate(java.lang.Object):


person = new Person();
person = (Person) populate(person);

Neste ponto, a classe PessoaDaoTest não irá compilar ainda porque não há PessoaDAO.class em nosso classpath, nós precisamos criá-la. PessoaDAO.java é uma Interface, e PessoaDAOHibernate é uma implementação Hibernate desta interface. Vamos seguir adiante e criar todas elas.

Criar uma nova classe DAO para efetuar CRUD no objeto [#4]

Primeiro, crie a interface PessoaDAO.java no diretório src/dao/**/dao e especifique os métodos CRUD básicos para qualquer classe de implementação. Eliminei as partes JavaDocs na classe abaixo apenas por propósito de visualização.


package org.appfuse.dao;

import org.appfuse.model.Person;

import java.util.List;

public interface PersonDao extends Dao {

    public List getPeople(Person person);

    public Person getPerson(Long personId);

    public void savePerson(Object person);

    public void removePerson(Long personId);
}

Note na classe acima que não há exceções nas assinaturas dos métodos. Isto devido à força do Spring e como ele encapsula Exceptions com RuntimeExceptions. Neste ponto, você deve ser capaz de compilar todo fonte em src/dao e test/dao usando “ant compile-dao”. No entanto, se você tentar executar “ant -Dtestcase=PessoaDAO”, você receberá um erro: No bean named 'pessoaDAO' is defined. Esta é uma mensagem de erro do Spring – indicando que nós precisamos especificar um bean nomeado pessoaDAO no arquivo ApplicationContex-hibernate.xml. Antes de fazê-lo, precisamos criar a classe que implementa a interface PessoaDAO.

A tarefa Ant para executar os testes dao é chamada “test-dao”. Se você passar um parâmetro testcase (usando -Dtestcase=nome), a tarefa irá procurar por **/*${testcase}* - nos permitindo passar Pessoa, PessoaDAO ou PessoaDaoTest – todos o qual executará a classe PessoaDAOTest.

Vamos começar, criando uma classe PessoaDAOHibernate que implementa os métodos em PessoaDAO e usa Hibernate para get/save/delete o objeto Pessoa. Para fazê-lo, crie uma nova classe em src/dao/**/dao/hibernate e a nomeie PessoaDAOHibernate.java. Ela deverá estender BaseDaoHibernate e implementar PessoaDAO. JavaDocs eliminados por brevidade.


package org.appfuse.dao.hibernate;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.appfuse.model.Person;
import org.appfuse.dao.PersonDao;

import java.util.List;


public class PersonDaoHibernate extends BaseDaoHibernate implements PersonDao {

    private Log log = LogFactory.getLog(PersonDaoHibernate.class);

    public List getPeople(Person person) {
        return getHibernateTemplate().find("from Person");
    }

    public Person getPerson(Long id) {
        return (Person) getHibernateTemplate().get(Person.class, id);
    }

    public void savePerson(Object person) {
        getHibernateTemplate().saveOrUpdate(person);
    }

    public void removePerson(Long id) {
        Object person = getHibernateTemplate().load(Person.class, id);
        getHibernateTemplate().delete(person);
    }
}

Você notará aqui que não estamos fazendo nada com o parâmetro pessoa. Isto é somente um “place holder” por enquanto – no futuro você pode filtrar suas propriedades usando Hibernate's Query Language (HQL) ou usando Criteria Queries.

Um exemplo usando Criteria Query:


    Example example = Example.create(person)
                             .excludeZeroes()   //exclude zero valued properties
                             .ignoreCase();       //perform case insensitive string comparisons
    try {
        return getSession().createCriteria(Person.class)
                           .add(example)
                           .list();
    } catch (Exception e) {
        throw new DAOException(e);
    }
    return new ArrayList();

Agora, se você tentar executar “ant test-dao -Dtestcase=PessoaDAO”, você obterá o mesmo erro. Precisamos configurar Spring de forma que ele saiba que PessoaDAOHibernate é a implementação de PessoaDAO, e precisamos também informá-lo sobre o objeto Pessoa.

Configurar o framework Spring para o objeto Pessoa e PessoaDAO [#5]

Primeiro, necessitamos dizer ao Spring onde o arquivo de mapeamento do Hibernate está localizado. Para isso, abra src/dao/**/dao/hibernate/ApplicationContext.xml e adicione Pessoa.hbm.xml ao seguinte bloco de código.


<property name="mappingResources"> 
    <list> 
        <value>org/appfuse/model/Person.hbm.xml</value> 
        <value>org/appfuse/model/Role.hbm.xml</value> 
        <value>org/appfuse/model/User.hbm.xml</value> 
        <value>org/appfuse/model/UserCookie.hbm.xml</value> 
        <value>org/appfuse/model/UserRole.hbm.xml</value> 
    </list> 
</property> 

Agora precisamos adicionar algum XML a este arquivo para ligar PessoaDAOHibernate à PessoaDAO. Para fazê-lo, adicione o seguinte na parte inferior do arquivo:


<!-- PersonDao: Hibernate implementation --> 
<bean id="personDao" class="org.appfuse.dao.hibernate.PersonDaoHibernate"> 
    <property name="sessionFactory"><ref local="sessionFactory"/></property> 
</bean> 

Você poderia também usar autowire="byName" ao <bean> e se livrar da propriedade “sessionFactory”. Pessoalmente, gosto de ter as dependências de meus objetos documentadas (em XML).

Executar o DaoTest [#6]

Salve todos os arquivos editados e tente executar “ant test-dao -Dtestcase=PessoaDAO” uma vez mais.

Yeah Baby, Yeah: BUILD SUCCESSFUL
Total time: 14 seconds

Nota: Antes que você envie críticas, peço que compreenda que estou apenas contribuindo com o projeto e que não sou um profundo conhecedor da idioma Inglês. Sinta-se no direito de corrigir os erros de tradução ou mesmo os erros ortográficos – não sou perfeito!;-)

Next Up: Part II: Creating new Managers - A HowTo for creating Business Delegates that talk to the database tier (DAOs) and the web tier (Struts Actions).


Go to top   More info...   Attach file...
This particular version was published on 06-Nov-2006 13:52:32 MST by Gilbertoca.