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 13. 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

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.

No fragmento de código acima, nós estamos extendendo BaseObject porque ela contem os seguintes métodos úteis: toString(), equals(), hashCode() - os dois últimos são requeridos pelo Hibernate.

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 AUTO_INCREMENT,
[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/**/hibernate. 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 BIGINT 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]

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 Uuser com Ppessoa, ou qualquer que seja o nome do meu objeto.


package org.appfuse.dao;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.appfuse.model.Person;


public class PersonDaoTest extends BaseDaoTestCase {
    

    //~ Instance fields ========================================================

    private Person person = null;
    private PersonDao dao = null;

    //~ Methods ================================================================
    protected void setUp() {
        log = LogFactory.getLog(PersonDaoTest.class);
        dao = (PersonDao) ctx.getBean("personDao");
    }

    protected void tearDown() {
        dao = null;
    }

    public static void main(String[] args) {
        junit.textui.TestRunner.run(PersonDaoTest.class);
    }
}

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.

Create a new DAO to perform CRUD on the object [#4]

First off, create a PersonDao.java interface in the src/dao/**/dao directory and specify the basic CRUD methods for any implementation classes. I've eliminated the JavaDocs in the class below for display purposes.


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);
}

Notice in the class above there are no exceptions on the method signatures. This is due to the power of Spring and how it wraps Exceptions with RuntimeExceptions. At this point, you should be able to compile all the source in src/dao and test/dao using "ant compile-dao". However, if you try to run "ant test-dao -Dtestcase=PersonDao", you will get an error: No bean named 'personDao' is defined. This is an error message from Spring - indicating that we need to specify a bean named personDAO in applicationContext-hibernate.xml. Before we do that, we need to create the PersonDao implementation class.

The ant task for running dao tests is called "test-dao". If you pass in a testcase parameter (using -Dtestcase=name), it will look for **/*${testcase}* - allowing us to pass in Person, PersonDao, or PersonDaoTest - all of which will execute the PersonDaoTest class.

Let's start by creating a PersonDaoHibernate class that implements the methods in PersonDao and uses Hibernate to get/save/delete the Person object. To do this, create a new class in src/dao/**/dao/hibernate and name it PersonDAOHibernate.java. It should extend BaseDaoHibernate and implement PersonDAO. Javadocs eliminated for brevity.


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);
    }
}

You'll notice here that we're doing nothing with the person parameter. This is just a placeholder for now - in the future you may want to filter on it's properties using Hibernate's Query Language (HQL) or using Criteria Queries.

An example using a 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();

Now, if you try to run "ant test-dao -Dtestcase=PersonDao", you will get the same error. We need to configure Spring so it knows that PersonDaoHibernate is the implementation of PersonDAO, and we also need to tell it about the Person object.

Configure Spring for the Person object and PersonDao [#5]

First, we need to tell Spring where the Hibernate mapping file is located. To do this, open src/dao/**/dao/hibernate/applicationContext-hibernate.xml and add Person.hbm.xml to the following code block.


<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> 

Now we need to add some XML to this file to bind PersonDaoHibernate to PersonDao. To do this, add the following at the bottom of the file:


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

You could also use autowire="byName" to the <bean> and get rid of the "sessionFactory" property. Personally, I like having the dependencies of my objects documented (in XML).

Run the DaoTest [#6]

Save all your edited files and try running "ant test-dao -Dtestcase=PersonDao" one more time.

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

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.