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
LeftMenu




JSPWiki v2.2.33

[RSS]


Hide Menu

CreateDAO_es


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


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 = (PersonDaoctx.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étodos 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. Anada los siguientes metodos 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()));
    }

In the testGetPerson method, we're creating a person and then calling a get. I usually enter a record in the database that I can always rely on. Since DBUnit is used to populate our database with test data before our tests are run, you can simply add the new table/record to the metadata/sql/sample-data.xml file:

<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 anadir este record directamente a la base de datos , (via SQL o una intefaz GUI), you can rebuild your sample-data.xml file using "ant db-export" and then "cp db-export.xml metadata/sql/sample-data.xml".

In the above example, you can see that we're calling person.set*(value) to populate our object before saving it. This is easy in this example, but it could get quite cumbersome if we're persisting an object with 10 required fields (not-null="true"). This is why I created the ResourceBundle in the BaseDaoTestCase. Simply create a PersonDaoTest.properties file in the same directory as the PersonDaoTest.java file and define your property values inside it:

I tend to just hard-code test values into Java code - but the .properties file is an option.
firstName=Matt
lastName=Raible
Then, rather than calling person.set* to populate your objects, you can use the BaseDaoTestCase.populate(java.lang.Object) method:


person = new Person();
person = (Personpopulate(person);

At this point, the PersonDaoTest class won't compile yet because there is no PersonDao.class in our classpath, we need to create it. PersonDAO.java is an interface, and PersonDAOHibernate.java is the Hibernate implementation of that interface. Let's go ahead and create those.

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 (PersongetHibernateTemplate().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: 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   More info...   Attach file...
This particular version was published on 06-Nov-2006 13:52:32 MST by PatriaLukman.