Raible's Wiki: CreateDAO

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

Edit this page

Referenced by
Articles
Articles_pt
LeftMenu

JSPWiki v2.2.33

Hide Menu

CreateDAO_es	Search Wiki:
Your trail:

Parte I: Creación de nuevos DAOs y Objetos en AppFuse - Esto es un HowTo de cómo crear nuevos Objetos (que representan tablas en la BD's) y la creación de clases Java para hacer persistentes dichos objetos Java en la base de datos.

Sobre este tutorial

Este tutorial nos muestra cómo crear una nueva tabla en la base de datos, y cómo crear código Java para acceder a dicha tabla.

Crearemos un objeto y algunas clases para hacer persistente (save/retrieve/delete) ese objeto en la base de datos. En el lenguaje Java, llamamos a esos objetos como "Antiguo Objeto Java Plano" (a.k.a. un POJO ). Jeje, si lo decimos en castellano andaluz será POLLO :o) Este objeto representa una tabla de la base de datos básicamente. Las otras clases serán :

Un Objeto de Acceso a Datos (Datos de Acceso a un Objeto) (a.k.a. un DAO), una Interfaz y una implementación de Hibernate
Una clase JUnit para testear que nuestro DAO funciona :-)

AppFuse utiliza Hibernate para la capa de persistencia. Hibernate es una herramienta Objeto/Relacional (O/R) que nos permite mapear nuestros objetos Java como tablas en la base de datos. Esto nos permite realizar más fácilmente métodos CRUD (Create, Retrieve, Update, Delete) a nuestros objetos (En castellano sería CRAB, Crear-Recibir-Actualizar-Borrar).

: Puedes usar también iBATIS como capa de persistencia. Para instalar BATIS en AppFuse, refiérase al README.txt que se encuentra en extras/ibatis. Si prefieres iBATIS sobre Hibernate, espero que tengas tus razones y que estés familiarizado con esa tecnologia. Espero tambien que puedas adaptar este tutorial al usar iBATIS. ;-)

: Te diré como hago las cosas en la práctica en esta guia.

Empezaremos creando un nuevo objeto, un DAO y un Test en la arquitectura AppFuse.

Tabla de contenidos

[1] Creación de un nuevo Objeto y añadir los tags XDoclet
[2] Crear una nueva tabla en la base de datos a partir del objeto recién creado usando Ant
[3] Crear una nueva clase DaoTest que ejecutará los tests JUnit tests en la capa DAO
[4] Crear una nueva clase DAO que ejecute operaciones Anadir/Lectura/Actualización/Borrado del nuevo objeto Person
[5] Configurar Spring para el objeto Person y PersonDao
[6] Ejecutar DaoTest

Creación de un nuevo Objeto y añadir los tags XDoclet[#1]

Primeramente,necesitamos crear la clase a guardar en la base de datos. Para ello crearemos una clase simple "Person" (en el subdirectorio src/dao/**/model ) que contiene como atributos un id, un firstName y un lastName como atributos.




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

    */

}

: Normalmente edito una clase existente (i.e. User.java o Resume.java) y lo guardo como un nuevo fichero y borro todos los métodos y atributos. Esto me da el encabezamiento básico de JavaDoc. También podria crear templates en Eclipse, pero debido a que programo usando 3 pc distintas, es más fácil hacerlo de la manera anterior.

En el código anterior estamos heredando de la claseBaseObject porque contiene los siguientes métodos : toString(), equals(), hashCode() - los últimos dos son necesarios para el uso de Hibernate.

Ahora que tenemos creado este POJO, necesitamos añadir los tags XDoclet para generar el fichero de mapeo que corresponde a este POJO. Este fichero es usado por Hibrenate para mapear objetos → tablas y atributos (variables) → columnas.

Primero, añadiremos un tag @hibernate.class que indica a Hibernate a que tabla va a estar asociada:




/**

 * @hibernate.class table="person"

 */

public class Person extends BaseObject {

También adicionamos el mapeo para la llave primaria para que XDoclet funcione correctament al general el fichero XML. Note que todos los tags @hibernate deben ponerse en los getters' Javadocs de tus POJOs.




    /**

     * @return Returns the id.

     * @hibernate.id column="id"

     *  generator-class="increment" unsaved-value="null"

     */



    public Long getId() {

        return this.id;

    }

: Estoy usando generator-class="increment" en vez de generate-class="native" porque he encontrado problemas cuando uso "native" con otras bases de datos. Si solamente planea usar MySQL, le recomiendo que use el valor "native".

Crear una nueva tabla en la base de datos a partir del objeto recién creado usando Ant

[#2] En este momento podemos crear la tabla Person si ejecutamos "ant setup-db". Esta tarea creará un fichero Person.hbm.xml y una tabla llamada "Person". A partir de la consola de antm puede ver el esquema de la tabla que Hibernate ha creado.

[schemaexport] create table person (
[schemaexport]    id BIGINT NOT NULL AUTO_INCREMENT,
[schemaexport]    primary key (id)
[schemaexport] )

Si quiere mirar el fichero Person.hbm.xml que generó Hibernate, refiérase al directorio build/dao/gen/**/hibernate. El contenido del fichero Person.hbm.xml es el siguiente (por el momento):




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

Ahora adicionaremos otros tags @hibernate.property para las otras columnas (first_name, last_name):




    /**

     * @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;

    }

En este ejemplo, la única razón para añadir el atributo column es porque el nombre de la columna en la tabla es distinto al nombre del atributo. Si son iguales, no hay necesidad de especificar el atributo column. Consulte el manual de referencia @hibernate.property para otros atributos que se pueden especificar con este tag.

Ejecute "ant setup-db" para crear las columnas que faltan en la tabla.

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

Si quieres cambiar las dimensiones de las columnas, especifique el atributo length=size en su tag @hibernate.property. Si quieres hacerlo obligatorio(NOT NULL), añada not-null="true".

Crear una nueva clase DaoTest que ejecutará los tests JUnit tests en la capa DAO[#3]

Ahora crearemos la clase DaoTest y examinaremos como funciona la capa DAO. Me dirás que no hemos creado nuestro DAO, y tienes razón. Sin embargo, he visto que Test-Driven Development contribuye a desarrollar software de mayor calidad. Por años pensé que escribir los tests antes de las clases no tenia sentido, que era estúpido. Pero lo ensayé y vi que funcionaba a las mil maravillas. La unica razón por la que escribo primero los tests es porque acelera el proceso de desarrollo de software.

Para empezar, crea una clase PersonDaoTest.java class en el directorio test/dao/**/dao. Esta clase debe extender BaseDaoTestCase, la cual ya existe en este paquete. La clase padre es usada para leer Spring's ApplicationContext (ya que Spring une las distintas capas juntas), para que automáticamente lea un fichero con extension .properties (ResourceBundle) que tenga tenga el mismo nombre que *Test.class.En este ejemplo, si colocas el fichero PersonDaoTest.properties en el mismo directorio que PersonDaoTest.java entonces las propiedades del fichero estarán disponibles via la variable "rb".

: Normalment copio un test existente(open → save as) an existing test (i.e. UserDaoTest.java) y reemplazo [Uu]ser por [Pp]erson, o cualquiera que sea el nombre del 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);

    }

}

El código anterior es lo que Ud. necesita para realizar una prueba unitaria básica que inicialize y destruya nuestro PersonDao. El objeto "ctx" es una referencia al objeto Application Context de Spring, el cual es inicializado en un bloque estático de la clase BaseDaoTestCase's .

Ahora necesitamos probar que las operaciones CRUD (create, retrieve, update, delete) methods funcionan en nuestro DAO. Para ello, crearemos metodos que empiecen con el vocablo "test" (en minúsculas). Estos mét;odos al ser públicos,retornan void y no aceptan parámetros de entrada, serán ejecutados por la tarea <junit> que se encuentra en el fichero build.xml de Ant .

Aca le mostramos algunas pruebas sencillas para probar las operaciones CRUD. Lo importante a recordad es que cada método debe ser autónomo. Añada los siguientes métodos a la clase PersonDaoTest.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()));

    }

: En el método testGetPerson , estamos creando una persona y luego lo recuperamos de la base de datos. Generalmente adiciono métodos en la base de datos de manera que puedo siempre contar con datos fiables. Debido que DBUnit es usado para llenar la base de datos con datos para prueba, Ud. puede simplemente añadir una nueva tabla o un record al fichero 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>

: De esta manera,puedes eliminar la funcionalidad "create new" en el método testGetPerson. Si prefiere añadir este record directamente a la base de datos , (via SQL o una intefaz GUI), puede reconstruir el fichero sample-data.xml usando "ant db-export" y luego "cp db-export.xml metadata/sql/sample-data.xml".

En el ejemplo anterior, Ud. puede que estamos invocando los métodos person.set*(valor) para llenar el objeto antes de guardarlo en la base de datos. Es fácil en este ejemplo , pero puede ser un poco enredoso si queremos persistir un objeto con 10 atributos que sean obligatorios (not-null="true"). Es por esta razon que he creado un ResourceBundle en la clase BaseDaoTestCase. Crea simplemente un fichero PersonDaoTest.properties en el mismo directorio que el fichero PersonDaoTest.java y defina los valores de los atributos:

: Normalmente tiendo a definir valores fijos en el código Java - pero el fichero .properties es una opción.

firstName=Matt
lastName=Raible

Entonces, en vez de invocar los metodos person.set* para poblar los objetos, puede usar el método BaseDaoTestCase.populate(java.lang.Object) :




person = new Person();

person = (Person) populate(person);

En este momento, la clase PersonDaoTest class no compilará todavia porque no hay ninguna PersonDao.class en el classpath, por lo tanto tenemos que crearlo. PersonDao.java es una interface y la clase PersonDaoHibernate.java es una implementación de esta interface.

Crear una nueva clase DAO que contenga métodos CRUD [#4]

Primeramente, creemos la interface PersonDao.java en el directorio src/dao/**/dao y especifique los métodos básicos CRUD.




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 que en la clase anterior no hay ningún método que provoque excepciones.Esto es debido a la manera que funciona Spring ya que considera las Exceptions como RuntimeExceptions. En este momento, Ud. debe ser capaz de compilar todo el código fuente que se encuentra en src/dao y test/dao usando "ant compile-dao". Sin embargo, si trata de ejecutar "ant test-dao -Dtestcase=PersonDao", verá que hay un error: No bean named 'personDao' is defined. Este es un mensaje de error de Spring- indicando que necesitamos especificar un bean llamado personDAO en el fichero applicationContext-hibernate.xml. Antes de hacer esto, necesitamos crear la clase que implementará PersonDao.

: La tarea ant para ejecutar pruebas dao tests es llamado "test-dao". Si pasa un parámetro (usando -Dtestcase=name), Ant buscará **/*${testcase}* - permitiéndonos pasar Person, PersonDao, o PersonDaoTest - y todas ejecutará la clase PersonDaoTest.

Empecemos la creación de la clase PeronDAOHibernate que implementa los métodos de la clase PersonDao y usa Hibernate para leer/persistir/eliminar la clase Person. Para ello, cree una nueva clase en el directorio src/dao/**/dao/hibernate bajo el nombre PersonDaoHibernate.java. También debe extender BaseDaoHibernate e implementar la clase PersonDao.




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

    }

}

Notará que no estamos usando el parámetro person. En You'll notice here that we're doing nothing with the person parameter. En este momento sirve sólo como variable pero en futuro querrá utilizarla como filtro de sus atributes usando Hibernate's Query Language (HQL) or using Criteria Queries.

Un ejemplo usando el 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();

Ahora, si quiere ejecutar "ant test-dao -Dtestcase=PersonDao", obtendrá el mismo error. Necesitamos configurar Spring para que sepa que PersonDaoHibernate es una implementación de PersonDao, y también necesitamos indicarle de la existencia de la clase Person.

Configure Spring para la clase Person y PersonDao [#5]

Primeramente, necesitamos indicarle a Spring donde se encuentra el fichero de mapeo Hibernate. Para ello, editemos el fichero src/dao/**/dao/hibernate/applicationContext-hibernate.xml y añadimos el fichero Person.hbm.xml al siguiente bloque.




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

    </list> 

</property>

Ahora, necesitamos añadir algo de XML a este fichero para enlazar PersonDaoHibernate a PersonDao. Para ello, añadamos lo siguiente al final del fichero:




<!-- PersonDao: Hibernate implementation --> 

<bean id="personDao" class="org.appfuse.dao.hibernate.PersonDaoHibernate"> 

    <property name="sessionFactory"><ref local="sessionFactory"/></property> 

</bean>

: Podrí también usar autowire="byName" al <bean> y eliminar el atributo "sessionFactory". Personalmente, prefiero documentar las dependencias de los objetos dentro del fichero.

Ejecute DaoTest [#6]

Salve los cambios a los ficheros editados y trate de ejecutar "ant test-dao -Dtestcase=PersonDao" .

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

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

Go to top Edit this page More info... Attach file...

This page last changed on 06-Nov-2006 13:52:58 MST by MattRaible.