CreateDAO_es

This is version 17. 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 unica 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 quiere cambiar las dimensiones de las columnas, especifique el atributo length=size en su tag @hibernate.property. Si quiere 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.

To start, create a PersonDaoTest.java class in the test/dao/**/dao directory. This class should extend BaseDaoTestCase, which already exists in this package. This parent class is used to load Spring's ApplicationContext (since Spring binds the layers together), and for automatically loading a .properties file (ResourceBundle) that has the same name as your *Test.class. In this example, if you put a PersonDaoTest.properties file in the same directory as PersonDaoTest.java, this file's properties will be available via an "rb" variable.

I usually copy (open → save as) an existing test (i.e. UserDaoTest.java) and find/replace [Uu]ser with [Pp]erson, or whatever the name of my object is.

The code you see above is what we need for a basic JUnit test that initializes and destroys our PersonDao. The "ctx" object is a reference to Spring's ApplicationContext, which is initialized in a static block of the BaseDaoTestCase's class.

Now we need to actually test that the CRUD (create, retrieve, update, delete) methods work in our DAO. To do this we created methods that begin with "test" (all lower case). As long as these methods are public, have a void return type and take no arguments, they will be called by our <junit> task in our Ant build.xml file. Here's some simple tests for testing CRUD. An important thing to remember is that each method (also known as a test), should be autonomous. Add the following methods to your PersonDaoTest.java file:

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>

This way, you can eliminate the "create new" functionality in the testGetPerson method. If you'd rather add this record directly into the database (via SQL or a 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).