Hibernate example source code file (quickstart.po)

This example Hibernate source code file (quickstart.po) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Hibernate tags/keywords

cat, cdata, el, el, hibernate, hibernate, java, jdbc, jdbc, session, sql, tomcat, tomcat, xml

The Hibernate quickstart.po source code

#, fuzzy
msgid ""
msgstr ""
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Content-Type: text/plain; charset=utf-8\n"
#: index.docbook:5
msgid "appended paragraph 1"
msgstr "Comienzo rápido con Tomcat"

#: index.docbook:8
msgid "appended paragraph 2"
msgstr "Empezando con Hibernate"

#: index.docbook:10
msgid "appended paragraph 3"
msgstr "Este tutorial explica una instalación de Hibernate con el contenedor de servlets Apache Tomcat (hemos usado la versión 4.1, las diferencias con la 5.0 deben ser mínimas) para una aplicación basada en web. Hibernate trabaja bien en un entorno manejado con todos los servidores de aplicaciones J2EE importantes, o incluso en aplicaciones Java independientes. El sistema de base de datos es sólo una cuestión de cambiar la configuración del dialecto SQL de Hibernate y las propiedades de conexión."

#: index.docbook:21
msgid "appended paragraph 4"
msgstr "Primero, tenemos que copiar todas las bibliotecas requeridas a la instalación de Tomcat. Usamos un contexto web separado (<literal>webapps/quickstart) para este tutorial, de modo que tenemos que considerar tanto la ruta de búsqueda de bibliotecas global (TOMCAT/common/lib) como también el cargador de clases a nivel de contexto en webapps/quickstart/WEB-INF/lib (para ficheros JAR) y webapps/quickstart/WEB-INF/classes. Nos referiremos a ambos niveles de cargador de clases como el classpath global y el classpath de contexto, respectivamente."

#: index.docbook:32
msgid "appended paragraph 5"
msgstr "Ahora, copia las bibliotecas a los dos classpaths:"

#: index.docbook:38
msgid "appended paragraph 6"
msgstr "Copia el driver JDBC para la base de datos al classpath global. Esto se requiere para el software de pool de conexiones DBCP que se distribuye con Tomcat. Hibernate usa conexiones JDBC para ejecutar SQL sobre la base de datos, de modo que, o bien tienes que proveer conexiones JDBC en pool, o bien configurar Hibernate para que use uno de los pools soportados directamente (C3P0, Proxool). Para este tutorial, copia la biblioteca <literal>pg74jdbc3.jar (para PostgreSQL 7.4 y JDK 1.4) al classpath del cargador global. Si quisieras usar una base de datos diferente, simplemente copia su apropiado driver JDBC."

#: index.docbook:51
msgid "appended paragraph 7"
msgstr "Nunca copies nada más dentro de la ruta del cargador de clases global en Tomcat, o tendrás problemas con varias herramientas, incluyendo Log4J, commons-logging y otras. Siempre usa el classpath de contexto para cada aplicación web, esto es, copia las bibliotecas a <literal>WEB-INF/lib y tus propias clases y ficheros de configuración/propiedades a WEB-INF/classes. Ambos directorios están a nivel del classpath de contexto por defecto."

#: index.docbook:62
msgid "appended paragraph 8"
msgstr "Hibernate está empaquetado como una biblioteca JAR. El fichero <literal>hibernate3.jar debe ser copiado en el classpath de contexto junto a las otras clases de la aplicación. Hibernate requiere algunas bibliotecas de terceros en tiempo de ejecución; éstas vienen incluídas con la distribución de Hibernate en el directorio lib/. Ver . Copia las bibliotecas de terceros requeridas al classpath de contexto."

#: index.docbook:75
msgid "appended paragraph 9"
msgstr "Bibliotecas de terceros de Hibernate"

#: index.docbook:83
msgid "appended paragraph 10"
msgstr "Biblioteca"

#: index.docbook:86
msgid "appended paragraph 11"
msgstr "Descripción"

#: index.docbook:93
msgid "appended paragraph 12"
msgstr "antlr (requerida)"

#: index.docbook:96
msgid "appended paragraph 13"
msgstr "Hibernate usa ANTLR para producir analizadores de consultas, esta biblioteca también se necesita en tiempo de ejecución."

#: index.docbook:102
msgid "appended paragraph 14"
msgstr "dom4j (requerida)"

#: index.docbook:105
msgid "appended paragraph 15"
msgstr "Hibernate usa dom4j para analizar ficheros de configuración XML y ficheros de metadatos de mapeo XML."

#: index.docbook:111
msgid "appended paragraph 16"
msgstr "CGLIB, asm (requerida)"

#: index.docbook:114
msgid "appended paragraph 17"
msgstr "Hibernate usa la biblioteca de generación de código para aumentar las clases en tiempo de ejecución (en combinación con reflección Java)."

#: index.docbook:121
msgid "appended paragraph 18"
msgstr "Commons Collections, Commons Logging (requeridas)"

#: index.docbook:124
msgid "appended paragraph 19"
msgstr "Hibernate usa varias bibliotecas de utilidad del proyecto Jakarta Commons de Apache."

#: index.docbook:130
msgid "appended paragraph 20"
msgstr "EHCache (requerida)"

#: index.docbook:133
msgid "appended paragraph 21"
msgstr "Hibernate puede usar varios provedores de caché para el caché de segundo nivel. EHCache es el provedor de caché por defecto si no se cambia en la configuración."

#: index.docbook:140
msgid "appended paragraph 22"
msgstr "Log4j (opcional)"

#: index.docbook:143
msgid "appended paragraph 23"
msgstr "Hibernate usa la API de Commons Logging, que a su vez puede usar Log4J como el mecanismo de logging subyacente. Si la biblioteca Log4J está disponible en el directorio de bibliotecas del contexto, Commons Logging usará Log4J y la configuración <literal>log4j.properties en el classpath de contexto. Un fichero de propiedades de ejemplo para Log4J se incluye con la distribución de Hibernate. Así que copia log4j.jar y el fichero de configuración (de src/) a tu classpath de contexto si quieres ver que ocurre tras escénas."

#: index.docbook:157
msgid "appended paragraph 24"
msgstr "¿Requerida o no?"

#: index.docbook:160
msgid "appended paragraph 25"
msgstr "Echa una mirada al fichero <literal>lib/README.txt en la distribución de Hibernate. Esta es una lista actualizada de bibliotecas de terceros distribuídas con Hibernate. Encontrarás listadas ahí todas las bibliotecas requeridas y opcionales (Observa que \"buildtame required\" significa aquí para la construcción de Hibernate, no de tu aplicación)."

#: index.docbook:174
msgid "appended paragraph 26"
msgstr "Ahora instalamos el pooling y modo compartido de conexiones de base de datos tanto en Tomcat como Hibernate. Esto significa que Tomcat proveerá conexiones JDBC en pool (usando su funcionalidad prefabricada de pooling DBCP). Hibernate pide esas conexiones a través de JNDI. Alternativamente, puedes dejar que Hibernate maneje el pool de conexiones. Tomcat liga su pool de conexiones a JNDI; agregamos una declaración de recurso al fichero de configuración principal de Tomcat, <literal>TOMCAT/conf/server.xml:"

#: index.docbook:184
msgid "appended paragraph 27"
msgstr ""
      "<![CDATA[\n"
      "            <value>org.apache.commons.dbcp.BasicDataSourceFactory\n"
      "        </parameter>\n"
      "\n"
      "        <!-- DBCP database connection settings -->\n"
      "        <parameter>\n"
      "            <name>url\n"
      "            <value>jdbc:postgresql://localhost/quickstart\n"
      "        </parameter>\n"
      "        <parameter>\n"
      "            <name>driverClassNameorg.postgresql.Driver\n"
      "        </parameter>\n"
      "        <parameter>\n"
      "            <name>username\n"
      "            <value>quickstart\n"
      "        </parameter>\n"
      "        <parameter>\n"
      "            <name>password\n"
      "            <value>secret\n"
      "        </parameter>\n"
      "\n"
      "        <!-- DBCP connection pooling options -->\n"
      "        <parameter>\n"
      "            <name>maxWait\n"
      "            <value>3000\n"
      "        </parameter>\n"
      "        <parameter>\n"
      "            <name>maxIdle\n"
      "            <value>100\n"
      "        </parameter>\n"
      "        <parameter>\n"
      "            <name>maxActive\n"
      "            <value>10\n"
      "        </parameter>\n"
      "    </ResourceParams>\n"
      "</Context>]]>"

#: index.docbook:186
msgid "appended paragraph 28"
msgstr "El contexto que configuramos en este ejemplo se llama <literal>quickstart, su base es el directorio TOMCAT/webapp/quickstart. Para acceder a cualquier servlet, llama a la ruta http://localhost:8080/quickstart en tu navegador (por supuesto, agregando el nombre del servlet como se mapee en tu web.xml). Puedes también ir más allá y crear ahora un servlet simple que tenga un método process() vacío."

#: index.docbook:196
msgid "appended paragraph 29"
msgstr "Tomcat provee ahora conexiones a través de JNDI en <literal>java:comp/env/jdbc/quickstart. Si tienes problemas obteniendo el pool de conexiones en ejecución, refiérete a la documentación de Tomcat. Si obtienes mensajes de excepción del driver JDBC, intenta instalar primero el pool de conexiones JDBC sin Hibernate. Hay disponibles en la Web tutoriales de Tomcat y JDBC."

#: index.docbook:205
msgid "appended paragraph 30"
msgstr "Tu próximo paso es configurar Hibernate. Hibernate tiene que saber cómo debe obtener conexiones JDBC. Usamos la configuración de Hibernate basada en XML. El otro enfoque, usando un ficheros de propiedad, es casi equivalente pero pierde unas pocas funcionalidades que sí permite la sintaxis XML. El fichero de configuración XML se ubica en el classpath de contexto (<literal>WEB-INF/classes), como hibernate.cfg.xml:"

#: index.docbook:214
msgid "appended paragraph 31"
msgstr ""
      "<![CDATA[\n"
      "        <property name=\"show_sql\">false\n"
      "        <property name=\"dialect\">org.hibernate.dialect.PostgreSQLDialect\n"
      "\n"
      "        <!-- Mapping files -->\n"
      "        <mapping resource=\"Cat.hbm.xml\"/>\n"
      "\n"
      "    </session-factory>\n"
      "\n"
      "</hibernate-configuration>]]>"

#: index.docbook:216
msgid "appended paragraph 32"
msgstr "Desactivamos el registro (logging) de comandos SQL y decimos a Hibernate qué dialecto SQL de base de datos se usa y dónde obtener conexiones JDBC (declarando la dirección JNDI del pool ligado a Tomcat). El dialecto es una configuración requerida, las bases de datos difieren en su interpretación del \"estándar\" de SQL. Hibernate cuidará de las diferencias y viene con dialectos incluídos para todas las principales bases de datos comerciales y de código abierto."

#: index.docbook:227
msgid "appended paragraph 33"
msgstr "Una <literal>SessionFactory es el concepto de Hibernate de un almacén de datos solo. Pueden usarse múltiples bases de datos creando múltiples ficheros de configuración XML y creando múltiples objetos Configuration y SessionFactory en tu aplicación."

#: index.docbook:235
msgid "appended paragraph 34"
msgstr "El último elemento del <literal>hibernate.cfg.xml declara Cat.hbm.xml como el nombre de un fichero de mapeo XML para la clase persistente Cat. Este fichero contiene los metadatos para el mapeo de la clase POJO Cat a una tabla (o tablas) de base de datos. Volveremos a este fichero pronto. Escribamos primero la clase POJO y luego declaremos los metadatos de mapeo para ella."

#: index.docbook:248
msgid "appended paragraph 35"
msgstr "Primera clase persistente"

#: index.docbook:250
msgid "appended paragraph 36"
msgstr "Hibernate trabaja mejor con el modelo de programación de los Viejos Objetos Planos de Java (POJOs, a veces llamados Ordinarios Objetos Planos de Java) para clases persistentes. Un POJO es como un JavaBean, con las propiedades de la clase accesible vía métodos getter y setter, encapsulando la representación interna de la interfaz publicamente visible (Hibernate puede también acceder a los campos directamente, si se necesita):"

#: index.docbook:260
msgid "appended paragraph 37"
msgstr ""
      "<![CDATA[package org.hibernate.examples.quickstart;\n"
      "\n"
      "public class Cat {\n"
      "\n"
      "    private String id;\n"
      "    private String name;\n"
      "    private char sex;\n"
      "    private float weight;\n"
      "\n"
      "    public Cat() {\n"
      "    }\n"
      "\n"
      "    public String getId() {\n"
      "        return id;\n"
      "    }\n"
      "\n"
      "    private void setId(String id) {\n"
      "        this.id = id;\n"
      "    }\n"
      "\n"
      "    public String getName() {\n"
      "        return name;\n"
      "    }\n"
      "\n"
      "    public void setName(String name) {\n"
      "        this.name = name;\n"
      "    }\n"
      "\n"
      "    public char getSex() {\n"
      "        return sex;\n"
      "    }\n"
      "\n"
      "    public void setSex(char sex) {\n"
      "        this.sex = sex;\n"
      "    }\n"
      "\n"
      "    public float getWeight() {\n"
      "        return weight;\n"
      "    }\n"
      "\n"
      "    public void setWeight(float weight) {\n"
      "        this.weight = weight;\n"
      "    }\n"
      "\n"
      "}]]>"

#: index.docbook:262
msgid "appended paragraph 38"
msgstr "Hibernate no está restringido en su uso de tipos de propiedad, todos los tipos y tipos primitivos del JDK de Java (como <literal>String, char y Date) pueden ser mapeados, incluyendo clases del framework de colecciones de Java. Puedes mapearlos como valores, colecciones de valores, o asociaciones a otras entidades. El id es una propiedad especial que representa el identificador de base de datos (clave primaria) de la clase. Es altamente recomendado para entidades como un Cat. Hibernate puede usar identificadores sólo internamente, pero perderíamos algo de la flexibilidad en nuestra arquitectura de aplicación."

#: index.docbook:275
msgid "appended paragraph 39"
msgstr "No tiene que implementarse ninguna interface especial para las clases persistentes ni tienes que subclasear de una clase persistente raíz en especial. Hibernate tampoco requiere ningún procesamiento en tiempo de construcción, como manipulación del byte-code. Se basa solamente en reflección de Java y aumentación de clases en tiempo de ejecución (a través de CGLIB). De modo que, sin ninguna dependencia de la clase POJO en Hibernate, podemos mapearla a una tabla de base de datos."

#: index.docbook:288
msgid "appended paragraph 40"
msgstr "Mapeando el gato"

#: index.docbook:290
msgid "appended paragraph 41"
msgstr "El fichero de mapeo <literal>Cat.hbm.xml contiene los metadatos requeridos para el mapeo objeto/relacional. Los metadatos incluyen la declaración de clases persistentes y el mapeo de propiedades (a columnas y relaciones de claves foráneas a otras entidades) a tablas de base de datos."

#: index.docbook:298
msgid "appended paragraph 42"
msgstr ""
      "<![CDATA["

#: index.docbook:300
msgid "appended paragraph 43"
msgstr "Cada clase persistente debe tener un atributo identificador (realmente, sólo las clases que representen entidades, no las clases dependientes de tipo-valor, que son mapeadas como componentes de una entidad). Esta propiedad es usada para distinguir los objetos persistentes: Dos gatos son iguales si <literal>catA.getId().equals(catB.getId()) es verdadero. Este concepto se llama identidad de base de datos (database identity). Hibernate viene empaquetado con varios generadores de identificador para diferentes escenarios (incluyendo generadores nativos para secuencias de base de datos, tablas de identificadores alto/bajo, e identificadores asignados por aplicación). Usamos el generador UUID (recomendado sólo para pruebas, pues deben preferirse las claves enteras delegadas generadas por la base de datos) y también especificamos la columna CAT_ID de la tabla CAT para el valor identificador generado por Hibernate (como una clave primaria de la tabla)."

#: index.docbook:317
msgid "appended paragraph 44"
msgstr "Todas las demás propiedades de <literal>Cat son mapeadas a la misma tabla. En el caso de la propiedad name, la hemos mapeado con una declaración explícita de columna de base de datos. Esto es especialmente útil cuando el esquema de base de datos es generado automáticamente (como sentencias DDL de SQL) desde la declaración de mapeo con la herramienta SchemaExport de Hibernate. Todas las demás propiedades son mapeadas usando la configuración por defecto de Hibernate, que es lo que necesitas la mayoría del tiempo. La tabla CAT en la base de datos se ve así como:"

#: index.docbook:329
msgid "appended paragraph 45"
msgstr ""
      "<![CDATA[ Columna |         Tipo          | Modificadores\n"
      "--------+-----------------------+-----------\n"
      " cat_id | character(32)         | not null\n"
      " name   | character varying(16) | not null\n"
      " sex    | character(1)          |\n"
      " weight | real                  |\n"
      "Indexes: cat_pkey primary key btree (cat_id)]]>"

#: index.docbook:331
msgid "appended paragraph 46"
msgstr "Ahora debes crear esta tabla manualmente en tu base de datos, y luego leer el <xref linkend=\"toolsetguide\"/> si quieres automatizar este paso con la herramienta hbm2ddl. Esta herramienta puede crear un DDL SQL completo, incluyendo definición de tablas, restricciones personalizadas de tipo de columnas, restricciones de unicidad e índices."

#: index.docbook:342
msgid "appended paragraph 47"
msgstr "Jugando con gatos"

#: index.docbook:344
msgid "appended paragraph 48"
msgstr "Ahora estamos listos para comenzar la <literal>Session de Hibernate. Es el manejador de persistencia que usamos para almacenar y traer Cats hacia y desde la base de datos. Pero primero, tenemos que obtener una Session (unidad de trabajo de Hibernate) de la SessionFactory:"

#: index.docbook:352
msgid "appended paragraph 49"
msgstr ""
      "<![CDATA[SessionFactory sessionFactory =\n"
      "            new Configuration().configure().buildSessionFactory();]]>"

#: index.docbook:354
msgid "appended paragraph 50"
msgstr "La llamada a <literal>configure() carga el fichero de configuración hibernate.cfg.xml e inicializa la instancia de Configuration. Puedes establecer otras propiedades (e incluso cambiar los metadatos de mapeo) accediendo a la Configuration antes que construyas la SessionFactory (que es inmutable). ¿Dónde creamos la SessionFactory y cómo accedemos a ella en nuestra aplicación?"

#: index.docbook:365
msgid "appended paragraph 51"
msgstr "Una <literal>SessionFactory usualmente se construye una vez, por ejemplo, al arrancar con un servlet load-on-startup. Esto significa también que no debes mantenerla en una variable de instancia en tus servlets, sino en alguna otro sitio. Además, necesitamos algún tipo de Singleton, de modo que podamos acceder a la SessionFactory fácilmente en el código de aplicación. El siguiente enfoque mostrado resuelve ambos problemas: configuración de arranque y fácil acceso a una SessionFactory."

#: index.docbook:377
msgid "appended paragraph 52"
msgstr "Implementamos una clase de ayuda <literal>HibernateUtil:"

#: index.docbook:381
msgid "appended paragraph 53"
msgstr ""
      "<![CDATA[import org.hibernate.*;\n"
      "import org.hibernate.cfg.*;\n"
      "\n"
      "public class HibernateUtil {\n"
      "\n"
      "    private static Logger log = LoggerFactory.getLogger(HibernateUtil.class);\n"
      "\n"
      "    private static final SessionFactory sessionFactory;\n"
      "\n"
      "    static {\n"
      "        try {\n"
      "            // Create the SessionFactory\n"
      "            sessionFactory = new Configuration().configure().buildSessionFactory();\n"
      "        } catch (Throwable ex) {\n"
      "            // Make sure you log the exception, as it might be swallowed\n"
      "            log.error(\"Initial SessionFactory creation failed.\", ex);\n"
      "            throw new ExceptionInInitializerError(ex);\n"
      "        }\n"
      "    }\n"
      "\n"
      "    public static final ThreadLocal session = new ThreadLocal();\n"
      "\n"
      "    public static Session currentSession() {\n"
      "        Session s = (Session) session.get();\n"
      "        // Open a new Session, if this Thread has none yet\n"
      "        if (s == null) {\n"
      "            s = sessionFactory.openSession();\n"
      "            session.set(s);\n"
      "        }\n"
      "        return s;\n"
      "    }\n"
      "\n"
      "    public static void closeSession() {\n"
      "        Session s = (Session) session.get();\n"
      "        if (s != null)\n"
      "            s.close();\n"
      "        session.set(null);\n"
      "    }\n"
      "}]]>"

#: index.docbook:383
msgid "appended paragraph 54"
msgstr "Esta clase no sólo cuida de la <literal>SessionFactory con su inicializador static, sino que además tiene una variable ThreadLocal que tiene la Session para la hebra actual. Asegúrate de entender el concepto Java de una variable local a una hebra antes de intentar usar esta ayuda. Una clase HibernateUtil más compleja y potente puede encontrarse en CaveatEmptor, http://caveatemptor.hibernate.org/"

#: index.docbook:393
msgid "appended paragraph 55"
msgstr "Una <literal>SessionFactory es segura entre hebras, muchas hebras pueden acceder a ella concurrentemente y pedirle Sessions. Una Session no es un objeto seguro entre hebras que representa una sola unidad-de-trabajo con la base de datos. Las Sessions se abren desde una SessionFactory y son cerradas cuando todo el trabajo está completo. Un ejemplo en el método process() de tu servlet podría parecerse a esto (sin manejo de excepciones):"

#: index.docbook:404
msgid "appended paragraph 56"
msgstr ""
      "<![CDATA[Session session = HibernateUtil.currentSession();\n"
      "Transaction tx = session.beginTransaction();\n"
      "\n"
      "Cat princess = new Cat();\n"
      "princess.setName(\"Princess\");\n"
      "princess.setSex('F');\n"
      "princess.setWeight(7.4f);\n"
      "\n"
      "session.save(princess);\n"
      "\n"
      "tx.commit();\n"
      "HibernateUtil.closeSession();]]>"

#: index.docbook:406
msgid "appended paragraph 57"
msgstr "En una <literal>Session, cada operación de base de datos ocurre dentro de una transacción que aísla las operaciones de base de datos (incluso operaciones de sólo lectura). Usamos la API de Transaction de Hibernate para abstraer de la estrategia de transacciones subyacente (en nuestro caso, transacciones JDBC). Esto permite que nuestro código sea desplegado con transacciones manejadas por contenedor (usando JTA) sin cambio alguno."

#: index.docbook:416
msgid "appended paragraph 58"
msgstr "Observa que puedes llamar <literal>HibernateUtil.currentSession(); tantas veces como quieras, siempre obtendrás la Session actual de esta hebra. Tienes que asegurarte que la Session sea cerrada después que se complete tu unidad-de-trabajo, ya sea en código de tu servlet o en un filtro de servlet antes que la respuesta HTTP sea enviada. El bonito efecto colateral de la segunda opción es la fácil inicialización perezosa: la Session todavía está abierta cuando se dibuja la vista, de modo que Hibernate puede cargar objetos no inicializados mientras navegas tu actual grafo de objetos."

#: index.docbook:428
msgid "appended paragraph 59"
msgstr "Hibernate tiene varios métodos que pueden ser usados para traer objetos desde la base de datos. La forma más flexible es usando el Lenguaje de Consulta de Hibernate (Hibernate Query Language o HQL), que es una extensión orientada a objetos de SQL fácil de aprender:"

#: index.docbook:436
msgid "appended paragraph 60"
msgstr ""
      "<![CDATA[Transaction tx = session.beginTransaction();\n"
      "\n"
      "Query query = session.createQuery(\"select c from Cat as c where c.sex = :sex\");\n"
      "query.setCharacter(\"sex\", 'F');\n"
      "for (Iterator it = query.iterate(); it.hasNext();) {\n"
      "    Cat cat = (Cat) it.next();\n"
      "    out.println(\"Female Cat: \" + cat.getName() );\n"
      "}\n"
      "\n"
      "tx.commit();]]>"

#: index.docbook:438
msgid "appended paragraph 61"
msgstr "Hibernate también ofrece una API <emphasis>consulta por criterios orientada a objetos que puede ser usada para formular consultas de tipo seguro. Por supuesto, Hibernate usa PreparedStatements y ligado de parámetros para toda la comunicación SQL con la base de datos. También puedes usar la funcionalidad de consulta SQL directa de Hibernate u obtener una conexión plana de JDBC de una Session en casos raros."

#: index.docbook:451
msgid "appended paragraph 62"
msgstr "Finalmente"

#: index.docbook:453
msgid "appended paragraph 63"
msgstr "Rasguñamos solamente la superficie de Hibernate en este pequeño tutorial. Por favor, observa que no incluimos ningún código específico de servlet en nuestros ejemplos. Tienes que crear un servlet por tí mismo e insertar el código de Hibernate como lo veas ubicado."

#: index.docbook:461
msgid "appended paragraph 64"
msgstr "Ten en mente que Hibernate, como capa de acceso a datos, está firmemente integrado dentro de tu aplicación. Usualmente, todas las otras capas dependen del mecanismo de persistencia. Asegúrate de entender las implicaciones de este diseño."

#: index.docbook:468
msgid "appended paragraph 65"
msgstr "Para un ejemplo de aplicación más compleja, ver http://caveatemptor.hibernate.org/ y echa una mirada a los otros tutoriales con links en http://www.hibernate.org/Documentation"

msgid "ROLES_OF_TRANSLATORS"
msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"

msgid "CREDIT_FOR_TRANSLATORS"
msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"