persistent_classes.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:5
msgid "Persistent Classes"
msgstr "Clases Persistentes"

#: index.docbook:7
msgid ""
"Persistent classes are classes in an application that implement the entities "
"of the business problem (e.g. Customer and Order in an E-commerce "
"application). Not all instances of a persistent class are considered to be "
"in the persistent state - an instance may instead be transient or detached."
msgstr ""
"Clases presistentes son clases en una aplicaci&#x00f3;n que implementan las "
"entidades del problema de negocio (por ejemplo, Customer y Order en una "
"aplicaci&#x00f3;n de comercio electr&#x00f3;nico). No todas las instancias "
"de una clase persistente se considera que est&#x00e9;n en el estado "
"persistente, una instancia puede en cambio ser transitoria o estar separada."

#: index.docbook:14
msgid ""
"Hibernate works best if these classes follow some simple rules, also known "
"as the Plain Old Java Object (POJO) programming model. However, none of "
"these rules are hard requirements. Indeed, Hibernate3 assumes very little "
"about the nature of your persistent objects. You may express a domain model "
"in other ways: using trees of <literal>Map</literal> instances, for example."
msgstr ""
"Hibernate funciona mejor si las clases siguen algunas simples reglas, "
"tambi&#x00e9;n conocidas como el modelo de programaci&#x00f3;n de Viejas "
"Clases Java Planas (Plain Old Java Object o POJO). Sin embargo, ninguna de "
"estas reglas son requerimientos r&#x00ed;gidos. En cambio, Hibernate3 asume "
"muy poco acerca de la naturaleza de tus objetos persistentes. Puedes "
"expresar un modelo de dominio en otras formas: usando &#x00e1;rboles de "
"instancias de <literal>Map</literal>, por ejemplo."

#: index.docbook:23
msgid "A simple POJO example"
msgstr "Un ejemplo simple de POJO"

#: index.docbook:25
msgid "Most Java applications require a persistent class representing felines."
msgstr ""
"La mayor&#x00ed;a de aplicaciones Java requieren una clase representando "
"felinos."

#: index.docbook:29
msgid ""
"<![CDATA[package eg;\n"
"import java.util.Set;\n"
"import java.util.Date;\n"
"\n"
"public class Cat {\n"
"    private Long id; // identifier\n"
"\n"
"    private Date birthdate;\n"
"    private Color color;\n"
"    private char sex;\n"
"    private float weight;\n"
"    private int litterId;\n"
"\n"
"    private Cat mother;\n"
"    private Set kittens = new HashSet();\n"
"\n"
"    private void setId(Long id) {\n"
"        this.id=id;\n"
"    }\n"
"    public Long getId() {\n"
"        return id;\n"
"    }\n"
"\n"
"    void setBirthdate(Date date) {\n"
"        birthdate = date;\n"
"    }\n"
"    public Date getBirthdate() {\n"
"        return birthdate;\n"
"    }\n"
"\n"
"    void setWeight(float weight) {\n"
"        this.weight = weight;\n"
"    }\n"
"    public float getWeight() {\n"
"        return weight;\n"
"    }\n"
"\n"
"    public Color getColor() {\n"
"        return color;\n"
"    }\n"
"    void setColor(Color color) {\n"
"        this.color = color;\n"
"    }\n"
"\n"
"    void setSex(char sex) {\n"
"        this.sex=sex;\n"
"    }\n"
"    public char getSex() {\n"
"        return sex;\n"
"    }\n"
"\n"
"    void setLitterId(int id) {\n"
"        this.litterId = id;\n"
"    }\n"
"    public int getLitterId() {\n"
"        return litterId;\n"
"    }\n"
"\n"
"    void setMother(Cat mother) {\n"
"        this.mother = mother;\n"
"    }\n"
"    public Cat getMother() {\n"
"        return mother;\n"
"    }\n"
"    void setKittens(Set kittens) {\n"
"        this.kittens = kittens;\n"
"    }\n"
"    public Set getKittens() {\n"
"        return kittens;\n"
"    }\n"
"    \n"
"    // addKitten not needed by Hibernate\n"
"    public void addKitten(Cat kitten) {\n"
"            kitten.setMother(this);\n"
"        kitten.setLitterId( kittens.size() ); \n"
"        kittens.add(kitten);\n"
"    }\n"
"}]]>"
msgstr ""
"<![CDATA[package eg;\n"
"import java.util.Set;\n"
"import java.util.Date;\n"
"\n"
"public class Cat {\n"
"    private Long id; // identifier\n"
"\n"
"    private Date birthdate;\n"
"    private Color color;\n"
"    private char sex;\n"
"    private float weight;\n"
"    private int litterId;\n"
"\n"
"    private Cat mother;\n"
"    private Set kittens = new HashSet();\n"
"\n"
"    private void setId(Long id) {\n"
"        this.id=id;\n"
"    }\n"
"    public Long getId() {\n"
"        return id;\n"
"    }\n"
"\n"
"    void setBirthdate(Date date) {\n"
"        birthdate = date;\n"
"    }\n"
"    public Date getBirthdate() {\n"
"        return birthdate;\n"
"    }\n"
"\n"
"    void setWeight(float weight) {\n"
"        this.weight = weight;\n"
"    }\n"
"    public float getWeight() {\n"
"        return weight;\n"
"    }\n"
"\n"
"    public Color getColor() {\n"
"        return color;\n"
"    }\n"
"    void setColor(Color color) {\n"
"        this.color = color;\n"
"    }\n"
"\n"
"    void setSex(char sex) {\n"
"        this.sex=sex;\n"
"    }\n"
"    public char getSex() {\n"
"        return sex;\n"
"    }\n"
"\n"
"    void setLitterId(int id) {\n"
"        this.litterId = id;\n"
"    }\n"
"    public int getLitterId() {\n"
"        return litterId;\n"
"    }\n"
"\n"
"    void setMother(Cat mother) {\n"
"        this.mother = mother;\n"
"    }\n"
"    public Cat getMother() {\n"
"        return mother;\n"
"    }\n"
"    void setKittens(Set kittens) {\n"
"        this.kittens = kittens;\n"
"    }\n"
"    public Set getKittens() {\n"
"        return kittens;\n"
"    }\n"
"    \n"
"    // addKitten not needed by Hibernate\n"
"    public void addKitten(Cat kitten) {\n"
"            kitten.setMother(this);\n"
"        kitten.setLitterId( kittens.size() ); \n"
"        kittens.add(kitten);\n"
"    }\n"
"}]]>"

#: index.docbook:31
msgid "There are four main rules to follow here:"
msgstr "Aqu&#x00ed; hay cuatro reglas principales a seguir:"

#: index.docbook:37
msgid "Implement a no-argument constructor"
msgstr "Implementa un constructor sin argumentos"

#: index.docbook:39
msgid ""
"<literal>Cat</literal> has a no-argument constructor. All persistent classes "
"must have a default constructor (which may be non-public) so that Hibernate "
"can instantiate them using <literal>Constructor.newInstance()</literal>. We "
"strongly recommend having a default constructor with at least "
"<emphasis>package</emphasis> visibility for runtime proxy generation in "
"Hibernate."
msgstr ""
"<literal>Cat</literal> tiene un contructor sin argumentos. Todas las clases "
"persistentes deben tener un constructor por defecto (que puede no ser "
"p&#x00fa;blico) de modo que Hibernate pueda instanciarlas usando "
"<literal>Constructor.newInstance()</literal>. Recomendamos fuertemente tener "
"un constructor por defecto con al menos visibilidad de <emphasis>package</"
"emphasis> para la generaci&#x00f3;n de proxies en tiempo de ejecuci&#x00f3;n "
"en Hibernate."

#: index.docbook:49
msgid "Provide an identifier property (optional)"
msgstr "Provee una propiedad identificadora (opcional)"

#: index.docbook:51
msgid ""
"<literal>Cat</literal> has a property called <literal>id</literal>. This "
"property maps to the primary key column of a database table. The property "
"might have been called anything, and its type might have been any primitive "
"type, any primitive \"wrapper\" type, <literal>java.lang.String</literal> or "
"<literal>java.util.Date</literal>. (If your legacy database table has "
"composite keys, you can even use a user-defined class with properties of "
"these types - see the section on composite identifiers later.)"
msgstr ""
"<literal>Cat</literal> tiene una propiedad llamada <literal>id</literal>. "
"Esta propiedad mapea a la columna clave primaria de la tabla de base de "
"datos. La propiedad podr&#x00ed;a llamarse cualquierCosa, y su tipo "
"podr&#x00ed;a haber sido cualquier tipo primitivo, cualquier tipo de "
"\"envoltura\" primitivo, <literal>java.lang.String</literal> o <literal>java."
"util.Date</literal>. (Si tu tabla de base de datos heredada tiene claves "
"compuestas, puedes incluso usar una clase definida por el usuario con "
"propiedades de estos tipos, ver la secci&#x00f3;n sobre identificadores "
"compuestos luego.)"

#: index.docbook:60
msgid ""
"The identifier property is strictly optional. You can leave them off and let "
"Hibernate keep track of object identifiers internally. We do not recommend "
"this, however."
msgstr ""
"La propiedad identificadora es estrictamente opcional. Puedes olvidarla y "
"dejar que Hibernate siga internamente la pista de los identificadores del "
"objeto. Sin embargo, no recomendamos esto."

#: index.docbook:65
msgid ""
"In fact, some functionality is available only to classes which declare an "
"identifier property:"
msgstr ""
"De hecho, alguna funcionalidad est&#x00e1; disponible s&#x00f3;lo para "
"clases que declaran una propiedad identificadora:"

#: index.docbook:72
msgid ""
"Transitive reattachment for detached objects (cascade update or cascade "
"merge) - see"
msgstr ""
"Reasociaci&#x00f3;n transitiva de objetos separados (actualizaciones o "
"fusiones en cascada) - ver"

#: index.docbook:79
msgid "Session.saveOrUpdate()"
msgstr "Session.saveOrUpdate()"

#: index.docbook:84
msgid "Session.merge()"
msgstr "Session.merge()"

#: index.docbook:89
msgid ""
"We recommend you declare consistently-named identifier properties on "
"persistent classes. We further recommend that you use a nullable (ie. non-"
"primitive) type."
msgstr ""
"Recomendamos que declares propiedades identificadoras nombradas-"
"consistentemente en clases persistentes. Mas a&#x00fa;n, recomendamos que "
"uses un tipo nulable (es decir, no primitivo)."

#: index.docbook:96
msgid "Prefer non-final classes (optional)"
msgstr "Prefiere las clases no finales (opcional)"

#: index.docbook:97
msgid ""
"A central feature of Hibernate, <emphasis>proxies</emphasis>, depends upon "
"the persistent class being either non-final, or the implementation of an "
"interface that declares all public methods."
msgstr ""
"Un aspecto central de Hibernate, <emphasis>proxies</emphasis>, depende de "
"que las clases persistentes sean ya no finales, o sean ya la "
"implementaci&#x00f3;n de una interface que declare todos los m&#x00e9;todos "
"p&#x00fa;blicos."

#: index.docbook:102
msgid ""
"You can persist <literal>final</literal> classes that do not implement an "
"interface with Hibernate, but you won't be able to use proxies for lazy "
"association fetching - which will limit your options for performance tuning."
msgstr ""
"Puedes persistir con Hibernate clases <literal>final</literal> que no "
"implementen una interface, pero no ser&#x00e1;s capaz de usar proxies para "
"recuperaci&#x00f3;n perezosa de asociaciones, lo que limitar&#x00e1; tus "
"opciones para afinar el rendimiento."

#: index.docbook:107
msgid ""
"You should also avoid declaring <literal>public final</literal> methods on "