tutorial.po

hibernate-distribution-3.3.1.GA-dist.zip源码

msgid "Startup and helpers"
msgstr ""
"Esto dirá a Ant que agregue todos los ficheros en el directorio lib "
"que terminen con <literal>.jar</literal> al classpath usado para la "
"compilaci&#x00f3;n. Tambi&#x00e9;n copiar&#x00e1; todos los ficheros que no "
"sean c&#x00f3;digo Java al directorio objetivo, por ejemplo, ficheros de "
"configuraci&#x00f3;n y mapeos de Hibernate. Si ahora corres Ant, debes "
"obtener esta salida:"

#: index.docbook:336
msgid ""
"It's time to load and store some <literal>Event</literal> objects, but first "
"we have to complete the setup with some infrastructure code. We have to "
"startup Hibernate. This startup includes building a global "
"<literal>SessionFactory</literal> object and to store it somewhere for easy "
"access in application code. A <literal>SessionFactory</literal> can open up "
"new <literal>Session</literal>'s. A <literal>Session</literal> represents a "
"single-threaded unit of work, the <literal>SessionFactory</literal> is a "
"thread-safe global object, instantiated once."
msgstr ""
"<![CDATA[C:\\hibernateTutorial\\>ant\n"
"Buildfile: build.xml\n"
"\n"
"copy-resources:\n"
"     [copy] Copying 2 files to C:\\hibernateTutorial\\bin\n"
"\n"
"compile:\n"
"    [javac] Compiling 1 source file to C:\\hibernateTutorial\\bin\n"
"\n"
"BUILD SUCCESSFUL\n"
"Total time: 1 second ]]>"

#: index.docbook:346
msgid ""
"We'll create a <literal>HibernateUtil</literal> helper class which takes "
"care of startup and makes accessing a <literal>SessionFactory</literal> "
"convenient. Let's have a look at the implementation:"
msgstr "Arranque y ayudantes"

#: index.docbook:352
msgid ""
"<![CDATA[package util;\n"
"\n"
"import org.hibernate.*;\n"
"import org.hibernate.cfg.*;\n"
"\n"
"public class HibernateUtil {\n"
"\n"
"    private static final SessionFactory sessionFactory;\n"
"\n"
"    static {\n"
"        try {\n"
"            // Create the SessionFactory from hibernate.cfg.xml\n"
"            sessionFactory = new Configuration().configure()."
"buildSessionFactory();\n"
"        } catch (Throwable ex) {\n"
"            // Make sure you log the exception, as it might be swallowed\n"
"            System.err.println(\"Initial SessionFactory creation failed.\" + "
"ex);\n"
"            throw new ExceptionInInitializerError(ex);\n"
"        }\n"
"    }\n"
"\n"
"    public static SessionFactory getSessionFactory() {\n"
"        return sessionFactory;\n"
"    }\n"
"\n"
"}]]>"
msgstr ""
"Es momento de cargar y almacenar algunos objetos <literal>Event</literal>, "
"pero primero tenemos que completar la configuraci&#x00f3;n de alg&#x00fa;n "
"c&#x00f3;digo de infraestructura. Tenemos que arrancar Hibernate. Este "
"arranque incluye construir un objeto <literal>SessionFactory</literal> "
"global y almacenarlo en alg&#x00fa;n sitio de f&#x00e1;cil acceso en el "
"c&#x00f3;digo de aplicaci&#x00f3;n. Una <literal>SessionFactory</literal> "
"puede abrir nuevas <literal>Session</literal>'s. Una <literal>Session</"
"literal> representa un unidad de trabajo mono-hebra. La "
"<literal>SessionFactory</literal> es un objeto global seguro entre hebras, "
"instanciado una sola vez."

#: index.docbook:354
msgid ""
"This class does not only produce the global <literal>SessionFactory</"
"literal> in its static initializer (called once by the JVM when the class is "
"loaded), but also hides the fact that it uses a static singleton. It might "
"as well lookup the <literal>SessionFactory</literal> from JNDI in an "
"application server."
msgstr ""
"Crearemos una clase de ayuda <literal>HibernateUtil</literal> que cuide del "
"arranque y haga conveniente el manejo de <literal>Session</literal>. El "
"as&#x00ed; llamado patr&#x00f3;n <emphasis>Sesi&#x00f3;n de Hebra Local "
"(ThreadLocal Session)</emphasis> es &#x00fa;til aqu&#x00ed;; mantenemos la "
"unidad de trabajo actual asociada a la hebra actual. Echemos una mirada a la "
"implementaci&#x00f3;n:"

#: index.docbook:361
msgid ""
"If you give the <literal>SessionFactory</literal> a name in your "
"configuration file, Hibernate will in fact try to bind it to JNDI after it "
"has been built. To avoid this code completely you could also use JMX "
"deployment and let the JMX-capable container instantiate and bind a "
"<literal>HibernateService</literal> to JNDI. These advanced options are "
"discussed in the Hibernate reference documentation."
msgstr ""
"<![CDATA[import org.hibernate.*;\n"
"import org.hibernate.cfg.*;\n"
"\n"
"public class HibernateUtil {\n"
"\n"
"    public static final SessionFactory sessionFactory;\n"
"\n"
"    static {\n"
"        try {\n"
"            // Create the SessionFactory from hibernate.cfg.xml\n"
"            sessionFactory = new Configuration().configure()."
"buildSessionFactory();\n"
"        } catch (Throwable ex) {\n"
"            // Make sure you log the exception, as it might be swallowed\n"
"            System.err.println(\"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() throws HibernateException {\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"
"            // Store it in the ThreadLocal variable\n"
"            session.set(s);\n"
"        }\n"
"        return s;\n"
"    }\n"
"\n"
"    public static void closeSession() throws HibernateException {\n"
"        Session s = (Session) session.get();\n"
"        if (s != null)\n"
"            s.close();\n"
"        session.set(null);\n"
"    }\n"
"}]]>"

#: index.docbook:370
msgid ""
"Place <literal>HibernateUtil.java</literal> in the development source "
"directory, in a package next to <literal>events</literal>:"
msgstr ""
"Esta clase no &#x00f3;lo produce la <literal>SessionFactory</literal> global "
"en su inicializador static (llamado s&#x00f3;lo una vez por la JVM al cargar "
"la clase), sino que tambi&#x00e9;n tiene una variable <literal>ThreadLocal</"
"literal> para tener la <literal>Session</literal> para la hebra actual. No "
"importa cu&#x00e1;ndo llames a <literal>HibernateUtil.currentSession()</"
"literal>, siempre devolver&#x00e1; la misma unidad de trabajo de Hibernate "
"en la misma hebra. Una llamada a <literal>HibernateUtil.closeSession()</"
"literal> termina la unidad de trabajo actualmente asociada a la hebra."

#: index.docbook:375
msgid ""
"<![CDATA[.\n"
"+lib\n"
"  <Hibernate and third-party libraries>\n"
"+src\n"
"  +events\n"
"    Event.java\n"
"    Event.hbm.xml\n"
"  +util\n"
"    HibernateUtil.java\n"
"  hibernate.cfg.xml\n"
"+data\n"
"build.xml]]>"
msgstr ""
"Aseg&#x00fa;rate de entender el concepto Java de una variable local a una "
"hebra antes de usar esta ayuda. Una clase <literal>HibernateUtil</literal> "
"m&#x00e1;s potente puede encontrarse en <literal>CaveatEmptor</literal>, "
"http://caveatemptor.hibernate.org/, as&#x00ed; como en el libro \"Java "
"Persistence with Hibernate\". Observa que esta clase no es necesaria si "
"despliegas Hibernate en un servidor de aplicaciones J2EE: una "
"<literal>Session</literal> ser&#x00e1; autom&#x00e1;ticamente ligada a la "
"transacci&#x00f3;n JTA actual, y puedes buscar la <literal>SessionFactory</"
"literal> a trav&#x00e9;s de JNDI. Si usas JBoss AS, Hibernate puede ser "
"desplegado como un servicio de sistema manejado y autom&#x00e1;ticamente "
"ligar&#x00e1; la <literal>SessionFactory</literal> a un nombre JNDI."

#: index.docbook:377
msgid ""
"This should again compile without problems. We finally need to configure a "
"logging system - Hibernate uses commons logging and leaves you the choice "
"between Log4j and JDK 1.4 logging. Most developers prefer Log4j: copy "
"<literal>log4j.properties</literal> from the Hibernate distribution (it's in "
"the <literal>etc/</literal> directory) to your <literal>src</literal> "
"directory, next to <literal>hibernate.cfg.xml</literal>. Have a look at the "
"example configuration and change the settings if you like to have more "
"verbose output. By default, only Hibernate startup message are shown on "
"stdout."
msgstr ""
"Coloca <literal>HibernateUtil.java</literal> en el directorio de fuentes de "
"desarrollo, junto a <literal>Event.java</literal>:"

#: index.docbook:387
msgid ""
"The tutorial infrastructure is complete - and we are ready to do some real "
"work with Hibernate."
msgstr ""
"<![CDATA[.\n"
"+lib\n"
"  <Hibernate and third-party libraries>\n"
"+src\n"
"  Event.java\n"
"  Event.hbm.xml\n"
"  HibernateUtil.java\n"
"  hibernate.cfg.xml\n"
"+data\n"
"build.xml]]>"

#: index.docbook:395
msgid "Loading and storing objects"
msgstr ""
"Esto tambi&#x00e9;n debe compilar sin problemas. Finalmente necesitamos "
"configurar un sistema de logging (registro). Hibernate usa commons logging y "
"te deja la elecci&#x00f3;n entre Log4J y logging de JDK 1.4. La mayor&#x00ed;"
"a de los desarrolladores prefieren Log4J: copia <literal>log4j.properties</"
"literal> de la distribuci&#x00f3;n de Hibernate (est&#x00e1; en el "
"directorio <literal>etc/</literal>) a tu directorio <literal>src</literal>, "
"junto a <literal>hibernate.cfg.xml</literal>. Echa una mirada a la "
"configuraci&#x00f3;n de ejemplo y cambia los ajustes si te gusta tener una "
"salida m&#x00e1;s verborr&#x00e1;gica. Por defecto, s&#x00f3;lo se muestra "
"el mensaje de arranque de Hibernate en la salida."

#: index.docbook:397
msgid ""
"Finally, we can use Hibernate to load and store objects. We write an "
"<literal>EventManager</literal> class with a <literal>main()</literal> "
"method:"
msgstr ""
"La infraestructura del tutorial est&#x00e1; completa, y estamos listos para "
"hacer alg&#x00fa;n trabajo real con Hibernate."

#: index.docbook:402
msgid ""
"<![CDATA[package events;\n"
"import org.hibernate.Session;\n"
"\n"
"import java.util.Date;\n"
"\n"
"import util.HibernateUtil;\n"
"\n"
"public class EventManager {\n"
"\n"
"    public static void main(String[] args) {\n"
"        EventManager mgr = new EventManager();\n"
"\n"
"        if (args[0].equals(\"store\")) {\n"
"            mgr.createAndStoreEvent(\"My Event\", new Date());\n"
"        }\n"
"\n"
"        HibernateUtil.getSessionFactory().close();\n"
"    }\n"
"\n"
"    private void createAndStoreEvent(String title, Date theDate) {\n"
"\n"
"        Session session = HibernateUtil.getSessionFactory().getCurrentSession"
"();\n"
"\n"
"        session.beginTransaction();\n"
"\n"
"        Event theEvent = new Event();\n"
"        theEvent.setTitle(title);\n"
"        theEvent.setDate(theDate);\n"
"\n"
"        session.save(theEvent);\n"
"\n"
"        session.getTransaction().commit();\n"
"    }\n"
"\n"
"}]]>"
msgstr "Cargando y almacenando objetos"

#: index.docbook:404
msgid ""
"We create a new <literal>Event</literal> object, and hand it over to "
"Hibernate. Hibernate now takes care of the SQL and executes <literal>INSERT</"
"literal>s on the database. Let's have a look at the <literal>Session</"
"literal> and <literal>Transaction</literal>-handling code before we run this."
msgstr ""
"Finalmente, podemos usar Hibernate para cargar y almacenar objetos. "
"Escribimos una clase <literal>EventManager</literal> con un m&#x00e9;todo "
"<literal>main()</literal>:"

#: index.docbook:411
msgid ""
"A <literal>Session</literal> is a single unit of work. For now we'll keep "
"things simple and assume a one-to-one granularity between a Hibernate "
"<literal>Session</literal> and a database transaction. To shield our code "
"from the actual underlying transaction system (in this case plain JDBC, but "
"it could also run with JTA) we use the <literal>Transaction</literal> API "
"that is available on the Hibernate <literal>Session</literal>."
msgstr ""
"<![CDATA[import org.hibernate.Transaction;\n"
"import org.hibernate.Session;\n"
"\n"
"import java.util.Date;\n"
"\n"
"public class EventManager {\n"
"\n"
"    public static void main(String[] args) {\n"
"        EventManager mgr = new EventManager();\n"
"\n"
"        if (args[0].equals(\"store\")) {\n"
"            mgr.createAndStoreEvent(\"My Event\", new Date());\n"
"        }\n"
"\n"
"        HibernateUtil.sessionFactory.close();\n"
"    }\n"
"\n"