tutorial.po

hibernate 开源框架的代码 jar包希望大家能喜欢

#, 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:7
msgid "Introduction to Hibernate"
msgstr "Introducci&#x00f3;n a Hibernate"

#: index.docbook:10
msgid "Preface"
msgstr "Prefacio"

#: index.docbook:12
msgid ""
"This chapter is an introductory tutorial for new users of Hibernate. We "
"start with a simple command line application using an in-memory database and "
"develop it in easy to understand steps."
msgstr ""
"Este cap&#x00ed;tulo es un tutorial introductorio de Hibernate. Comenzamos "
"con una aplicaci&#x00f3;n simple de l&#x00ed;nea de comandos usando un base "
"de datos en-memoria y desarroll&#x00e1;ndola en f&#x00e1;cil para entender "
"los pasos."

#: index.docbook:18
msgid ""
"This tutorial is intended for new users of Hibernate but requires Java and "
"SQL knowledge. It is based on a tutorial by Michael Gloegl, the third-party "
"libraries we name are for JDK 1.4 and 5.0. You might need others for JDK 1.3."
msgstr ""
"Este tutorial est&#x00e1; concebido para usuarios nuevos de Hibernate pero "
"requiere conocimiento en Java y SQL. Est&#x00e1; basado en un tutorial de "
"Michael Gloegl. Las bibliotecas de terceros que mencionamos son para JDK 1.4 "
"y 5.0. Podr&#x00ed;as necesitar otras para JDK 1.3."

#: index.docbook:24
msgid ""
"The source code for the tutorial is included in the distribution in the "
"<literal>doc/reference/tutorial/</literal> directory."
msgstr ""
"UNTRANSLATED!!! The source code for the tutorial is included in the "
"distribution in the <literal>doc/reference/tutorial/</literal> directory."

#: index.docbook:32
msgid "Part 1 - The first Hibernate Application"
msgstr "Parte 1 - La primera Aplicaci&#x00f3;n Hibernate"

#: index.docbook:34
msgid ""
"First, we'll create a simple console-based Hibernate application. We use an "
"Java database (HSQL DB), so we do not have to install any database server."
msgstr ""
"Primero, crearemos una aplicaci&#x00f3;n simple de Hibenate basada en "
"consola. Usamos usamos una base de datos en-memoria (HSQL DB), de modo que "
"no necesitamos instalar ning&#x00fa;n servidor de base de datos."

#: index.docbook:39
msgid ""
"Let's assume we need a small database application that can store events we "
"want to attend, and information about the hosts of these events."
msgstr ""
"Asumamos que necesitamos una aplicaci&#x00f3;n peque&#x00f1;a de base de "
"datos que pueda almacenar eventos que queremos atender, e informaci&#x00f3;n "
"acerca de los hostales de estos eventos."

#: index.docbook:44
msgid ""
"The first thing we do, is set up our development directory and put all the "
"Java libraries we need into it. Download the Hibernate distribution from the "
"Hibernate website. Extract the package and place all required libraries "
"found in <literal>/lib</literal> into into the <literal>/lib</literal> "
"directory of your new development working directory. It should look like "
"this:"
msgstr ""
"La primera cosa que hacemos, es armar nuestro directorio de desarrollo y "
"poner en &#x00e9;l todas las bibliotecas Java que necesitamos. Descarga la "
"distribuci&#x00f3;n de Hibernate del sitio web de Hibernate. Extrae el "
"paquete y coloca todas las bibliotecas requeridas encontradas en <literal>/"
"lib</literal> dentro del directorio <literal>/lib</literal> de nuestro nuevo "
"directorio de desarrollo de trabajo. Debe asemejarse a esto:"

#: index.docbook:52
msgid ""
"<![CDATA[.\n"
"+lib\n"
"  antlr.jar\n"
"  cglib.jar\n"
"  asm.jar\n"
"  asm-attrs.jars\n"
"  commons-collections.jar\n"
"  commons-logging.jar\n"
"  hibernate3.jar\n"
"  jta.jar\n"
"  dom4j.jar\n"
"  log4j.jar ]]>"
msgstr ""
"<![CDATA[.\n"
"+lib\n"
"  antlr.jar\n"
"  cglib-full.jar\n"
"  asm.jar\n"
"  asm-attrs.jars\n"
"  commons-collections.jar\n"
"  commons-logging.jar\n"
"  ehcache.jar\n"
"  hibernate3.jar\n"
"  jta.jar\n"
"  dom4j.jar\n"
"  log4j.jar ]]>"

#: index.docbook:54
msgid ""
"This is the minimum set of required libraries (note that we also copied "
"hibernate3.jar, the main archive) for Hibernate <emphasis>at the time of "
"writing</emphasis>. The Hibernate release you are using might require more "
"or less libraries. See the <literal>README.txt</literal> file in the "
"<literal>lib/</literal> directory of the Hibernate distribution for more "
"information about required and optional third-party libraries. (Actually, "
"Log4j is not required but preferred by many developers.)"
msgstr ""
"Este es el conjunto m&#x00ed;nimo de bibliotecas requeridas para Hibernate "
"(observa que tambi&#x00e9;n hemos copiado hibernate3.jar, el fichero "
"principal). Ver el fichero <literal>README.txt</literal> en el directorio "
"<literal>lib/</literal> de la distribuci&#x00f3;n de Hibernate para m&#x00e1;"
"s informaci&#x00f3;n sobre bibliotecas de terceros requeridas y opcionales. "
"(Realmente, Log4J no es requerida aunque preferida por muchos "
"desarrolladores)."

#: index.docbook:63
msgid ""
"Next we create a class that represents the event we want to store in "
"database."
msgstr ""
"Por siguiente, creamos una clase que represente el evento que queremos "
"almacenar en base de datos."

#: index.docbook:68
msgid "The first class"
msgstr "La primera clase"

#: index.docbook:70
msgid ""
"Our first persistent class is a simple JavaBean class with some properties:"
msgstr ""
"Nuestra primera clase persistente es un JavaBean simple con algunas "
"propiedades:"

#: index.docbook:74
msgid ""
"<![CDATA[package events;\n"
"\n"
"import java.util.Date;\n"
"\n"
"public class Event {\n"
"    private Long id;\n"
"\n"
"    private String title;\n"
"    private Date date;\n"
"\n"
"    public Event() {}\n"
"\n"
"    public Long getId() {\n"
"        return id;\n"
"    }\n"
"\n"
"    private void setId(Long id) {\n"
"        this.id = id;\n"
"    }\n"
"\n"
"    public Date getDate() {\n"
"        return date;\n"
"    }\n"
"\n"
"    public void setDate(Date date) {\n"
"        this.date = date;\n"
"    }\n"
"\n"
"    public String getTitle() {\n"
"        return title;\n"
"    }\n"
"\n"
"    public void setTitle(String title) {\n"
"        this.title = title;\n"
"    }\n"
"}]]>"
msgstr ""
"<![CDATA[import java.util.Date;\n"
"\n"
"public class Event {\n"
"    private Long id;\n"
"\n"
"    private String title;\n"
"    private Date date;\n"
"\n"
"    Event() {}\n"
"\n"
"    public Long getId() {\n"
"        return id;\n"
"    }\n"
"\n"
"    private void setId(Long id) {\n"
"        this.id = id;\n"
"    }\n"
"\n"
"    public Date getDate() {\n"
"        return date;\n"
"    }\n"
"\n"
"    public void setDate(Date date) {\n"
"        this.date = date;\n"
"    }\n"
"\n"
"    public String getTitle() {\n"
"        return title;\n"
"    }\n"
"\n"
"    public void setTitle(String title) {\n"
"        this.title = title;\n"
"    }\n"
"}]]>"

#: index.docbook:76
msgid ""
"You can see that this class uses standard JavaBean naming conventions for "
"property getter and setter methods, as well as private visibility for the "
"fields. This is a recommended design - but not required. Hibernate can also "
"access fields directly, the benefit of accessor methods is robustness for "
"refactoring. The no-argument constructor is required to instantiate an "
"object of this class through reflection."
msgstr ""
"Puedes ver que esta clase usa las convenciones de nombrado est&#x00e1;ndar "
"de JavaBean para m&#x00e9;todos getter y setter de propiedad, as&#x00ed; "
"como visibilidad privada para los campos. Esto es un dise&#x00f1;o "
"recomendado, aunque no requerido. Hibernate tambi&#x00e9;n puede acceder a "
"los campos directamente; el beneficio de los m&#x00e9;todos de acceso es la "
"robustez para la refactorizaci&#x00f3;n."

#: index.docbook:84
msgid ""
"The <literal>id</literal> property holds a unique identifier value for a "
"particular event. All persistent entity classes (there are less important "
"dependent classes as well) will need such an identifier property if we want "
"to use the full feature set of Hibernate. In fact, most applications (esp. "
"web applications) need to distinguish objects by identifier, so you should "
"consider this a feature rather than a limitation. However, we usually don't "
"manipulate the identity of an object, hence the setter method should be "
"private. Only Hibernate will assign identifiers when an object is saved. You "
"can see that Hibernate can access public, private, and protected accessor "
"methods, as well as (public, private, protected) fields directly. The choice "
"is up to you and you can match it to fit your application design."
msgstr ""
"La propiedad <literal>id</literal> tiene un valor &#x00fa;nico de "
"identificador para un evento en particular. Todas las clase de entidad "
"persistentes ( tambi&#x00e9;n hay clases dependientes menos importantes) "
"necesitar&#x00e1;n una propiedad identificadora similar si queremos usar el "
"conjunto completo de funcionalidades de Hibernate. De hecho, la mayor&#x00ed;"
"a de las aplicaciones (esp. aplicaciones web) necesitan distinguir objetos "
"por identificador, de modo que debes considerar esto como un aspecto en vez "
"de una limitaci&#x00f3;n. Sin embargo, usualmente no manipulamos la "
"identidad de un objeto, por lo tanto el m&#x00e9;todo setter debe ser "
"privado. S&#x00f3;lo Hibernate asignar&#x00e1; identificadores cuando un "
"objeto sea salvado. Puedes ver que Hibernate puede acceder a m&#x00e9;todos "
"de acceso p&#x00fa;blicos, privados y protegidos, tanto como directamente a "
"campos (p&#x00fa;blicos, privados y protegidos). La elecci&#x00f3;n "
"est&#x00e1; en ti, y puedes ajustarla a tu dise&#x00f1;o de aplicaci&#x00f3;"
"n."

#: index.docbook:96
msgid ""
"The no-argument constructor is a requirement for all persistent classes; "
"Hibernate has to create objects for you, using Java Reflection. The "
"constructor can be private, however, package visibility is required for "
"runtime proxy generation and efficient data retrieval without bytecode "
"instrumentation."
msgstr ""
"El constructor sin argumentos es un requerimiento para todas las clases "
"persistentes. Hibernate tiene que crear objetos para ti, usando "
"reflecci&#x00f3;n Java. El constructor puede ser privado, sin embargo, la "
"visibilidad de paquete es requerida para la generaci&#x00f3;n de proxies en "
"tiempo de ejecuci&#x00f3;n y la recuperaci&#x00f3;n de datos sin "
"instrumentaci&#x00f3;n del bytecode."

#: index.docbook:103
msgid ""
"Place this Java source file in a directory called <literal>src</literal> in "
"the development folder, and in its correct package. The directory should now "
"look like this:"
msgstr ""
"Coloca este fichero de c&#x00f3;digo Java en un directorio llamado "
"<literal>src</literal> en la carpeta de desarrollo. El directorio ahora debe "
"verse como esto:"

#: index.docbook:108
msgid ""
"<![CDATA[.\n"
"+lib\n"
"  <Hibernate and third-party libraries>\n"
"+src\n"
"  +events\n"
"    Event.java]]>"
msgstr ""
"<![CDATA[.\n"
"+lib\n"
"  <Hibernate and third-party libraries>\n"
"+src\n"
"  Event.java]]>"

#: index.docbook:110
msgid "In the next step, we tell Hibernate about this persistent class."
msgstr ""
"En el pr&#x00f3;ximo paso, le decimos a Hibernate sobre esta clase "
"persistente."

#: index.docbook:117
msgid "The mapping file"