CreateDAO_es

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

Sobre este tutorial

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.

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:

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.

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

[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):

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

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.

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:

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

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]

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.

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:

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.

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:

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]

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