Hibernate example source code file (persistent_classes.po)

This example Hibernate source code file (persistent_classes.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

for, hibernate, hibernate, if, it, java, pojo, pojo, tag, tag, the, the, tuplizer, you

The Hibernate persistent_classes.po source code

msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2010-02-04T04:51:22\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#. Tag: title
#, no-c-format
msgid "Persistent Classes"
msgstr "영속 클래스들"

#. Tag: para
#, fuzzy, no-c-format
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. For example, an instance can instead be transient "
"or detached."
msgstr ""
"영속 클래스들은 비지니스 문제의 엔티티들(예를 들어 E-Commerce 어플리케이션에"
"서 고객이나 주문)을 구현하는 어플리케이션 내의 클래스들이다. 영속 클래스들의 "
"인스턴스들은 영속 상태에 있는 것으로 전혀 간주되지 않는다 - 대신에 하나의 인"
"스턴스는 transient 또는 detached 상태일 수 있다."

#. Tag: para
#, fuzzy, no-c-format
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 can express a domain model "
"in other ways (using trees of <literal>Map instances, for example)."
msgstr ""
"Hibernate는 이들 클래스들이 Plain Old Java Object (POJO) 프로그래밍 모형으로"
"서 알려진, 몇몇 간단한 규칙들을 따를 경우에 가장 잘 동작한다. 하지만 이들 규"
"칙들 중 어떤 것도 어려운 사양들이 아니다. 진정 Hibernate3는 당신의 영속 객체"
"들의 특징에 대해 매우 적은 것을 가정한다. 당신은 다른 방법들로 도메인 모형을 "
"표현할 수 있다 : 예를 들어 <literal>Map 인스턴스의 트리들을 사용하"
"기."

#. Tag: title
#, no-c-format
msgid "A simple POJO example"
msgstr "간단한 POJO 예제"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Most Java applications require a persistent class representing felines. For "
"example:"
msgstr ""
"대부분의 자바 어플리케이션들은 고양이과들을 표현하는 영속 클래스를 필요로 한"
"다."

#. Tag: para
#, no-c-format
msgid ""
"The four main rules of persistent classes are explored in more detail in the "
"following sections."
msgstr ""

#. Tag: title
#, no-c-format
msgid "Implement a no-argument constructor"
msgstr "아규먼트 없는 생성자를 구현하라"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>Cat has a no-argument constructor. All persistent classes "
"must have a default constructor (which can be non-public) so that Hibernate "
"can instantiate them using <literal>Constructor.newInstance(). It "
"is recommended that you have a default constructor with at least "
"<emphasis>package visibility for runtime proxy generation in "
"Hibernate."
msgstr ""
"<literal>Cat은 아규먼트 없는 생성자를 갖는다. 모든 영속 클래스들은 "
"Hibernate는 <literal>Constructor.newInstance()를 사용하여 그것들을 "
"초기화 시킬 수 있도록 디폴트 생성자 (public이 아닐 수 있다)를 가져야 한다. 우"
"리는 Hibernate 내에서 런타임 프락시 생성을 위한 최소한의 <emphasis>패키지 has a property called id. 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 or "
"<literal>java.util.Date. If your legacy database table has "
"composite keys, you can use a user-defined class with properties of these "
"types (see the section on composite identifiers later in the chapter.)"
msgstr ""
"<literal>Cat은 id로 명명된 하나의 프로퍼티를 갖"
"는다. 이 프로퍼티는 데이터베이스 테이블의 프라이머리 키 컬럼으로 매핑된다. "
"이 프로퍼티는 어떤 것으로 명명될 수도 있고, 그것의 타입은 임의의 원시 타입, "
"원시 \"wrapper\" 타입, <literal>java.lang.String 또는 "
"<literal>java.util.Date일 수 있다. (만일 당신의 리거시 데이터베이"
"스 테이블이 composite 키들을 갖고 있다면, 당신은 이들 타입들을 가진 사용자 정"
"의 클래스를 사용할 수도 있다 - 나중에 composite 식별자들에 대한 절을 보라)"

#. Tag: para
#, no-c-format
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 ""
"identifier 프로퍼티는 엄격하게 옵션이다. 당신은 그것을 생략할 수도 있고, "
"Hibernate로 하여금 내부적으로 객체 식별자들을 추적하도록 할 수 있다. 하지만 "
"우리는 이것을 권장하지 않는다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"In fact, some functionality is available only to classes that declare an "
"identifier property:"
msgstr ""
"사실, 어떤 기능은 identifier 프로퍼티를 선언하는 클래스들에 대해서만 이용 가"
"능하다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Transitive reattachment for detached objects (cascade update or cascade "
"merge) - see <xref linkend=\"objectstate-transitive\" />"
msgstr ""
"detached 객체들에 대한 Transitive reattachment(cascade update 또는 cascade "
"merge) - <xref linkend=\"objectstate-transitive\"/>"

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>Session.saveOrUpdate()"
msgstr "Session.saveOrUpdate()"

#. Tag: para
#, fuzzy, no-c-format
msgid "<literal>Session.merge()"
msgstr "Session.merge()"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"We recommend that you declare consistently-named identifier properties on "
"persistent classes and that you use a nullable (i.e., non-primitive) type."
msgstr ""
"우리는 당신이 영속 클래스들에 대해 일관되게 명명된 identifier 프로퍼티들을 선"
"언할 것을 권장한다. 게다가 우리는 당신이 nullable 타입(예를 들어 non-"
"primitive)을 사용할 것을 권장한다."

#. Tag: title
#, no-c-format
msgid "Prefer non-final classes (optional)"
msgstr "final이 아닌 클래스들을 선호하라(옵션)"

#. Tag: para
#, no-c-format
msgid ""
"A central feature of Hibernate, <emphasis>proxies, depends upon "
"the persistent class being either non-final, or the implementation of an "
"interface that declares all public methods."
msgstr ""
"Hibernate의 중심 특징인, 프락시(<emphasis>proxies)들은 final이 아"
"닌 영속 클래스들 또는 모두 public 메소드들로 선언된 인터페이스의 구현인 영속 "
"클래스들에 의존한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"You can persist <literal>final classes that do not implement an "
"interface with Hibernate. You will not, however, be able to use proxies for "
"lazy association fetching which will ultimately limit your options for "
"performance tuning."
msgstr ""
"당신은 Hibernate로 인터페이스를 구현하지 않은 <literal>final 클래스"
"들을 영속화 시킬 수 있지만 당신은 lazy 연관 페칭(lazy association fetching)"
"에 대해 프락시들을 사용할 수 없을 것이다 -그것은 퍼포먼스 튜닝을 위한 당신의 "
"옵션들을 제한시킬 것이다."

#. Tag: para
#, no-c-format
msgid ""
"You should also avoid declaring <literal>public final methods on "
"the non-final classes. If you want to use a class with a <literal>public "
"final</literal> method, you must explicitly disable proxying by setting "
"<literal>lazy=\"false\"."
msgstr ""
"당신은 또한 non-final 클래스들 상에 <literal>public final 메소드들"
"을 선언하는 것을 피해야 한다. 만일 당신이 <literal>public final 메"
"소드를 가진 클래스를 사용하고자 원할 경우, 당신은 <literal>lazy=\"false\" declares accessor methods for all its persistent "
"fields. Many other ORM tools directly persist instance variables. It is "
"better to provide an indirection between the relational schema and internal "
"data structures of the class. By default, Hibernate persists JavaBeans style "
"properties and recognizes method names of the form <literal>getFooisFoo and setFoo. If "
"required, you can switch to direct field access for particular properties."
msgstr ""
"<literal>Cat은 그것의 모든 영속 필드들에 대해 accessor 메소드들을 "
"선언한다. 많은 다른 ORM 도구들은 인스턴스 변수들을 직접 영속화 시킨다. 우리"
"는 관계형 스키마와 클래스의 내부적인 데이터 구조들 사이에 간접적인 수단을 제"
"공하는 것이 더 좋다고 믿고 있다. 디폴트로 Hibernate는 자바빈즈 스타일 프로퍼"
"티들을 영속화 시키고, <literal>getFoo, isFoo와 "
"<literal>setFoo 형식의 메소드 이름들을 인지한다. 당신은 진정으로 특"
"정 프로퍼티에 대한 직접적인 필드 접근으로 전환할 수도 있다."

#. Tag: para
#, no-c-format
msgid ""
"Properties need <emphasis>not be declared public - Hibernate can "
"persist a property with a default, <literal>protected or "
"<literal>private get / set pair."
msgstr ""
"프로퍼티들은 public으로 선언될 필요가 <emphasis>없다 - Hibernate"
"는 디폴트로 <literal>protected get/set 쌍 또는 private. For example:"
msgstr ""
"서브클래스는 또한 첫 번째 규칙들과 두 번째 규칙들을 주시해야 한다. 그것은 슈"
"퍼클래스 <literal>Cat으로부터 그것의 identifier 프로퍼티를 상속받는"
"다."

#. Tag: title
#, no-c-format
msgid ""
"Implementing <literal>equals() and hashCode()"
msgstr "<literal>equals()와 hashCode() 구현하기"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"You have to override the <literal>equals() and hashCode()"
"</literal> methods if you:"
msgstr ""
"만일 당신이 다음의 경우라면, 당신은 <literal>equals()와 "
"<literal>hashCode() 메소드들을 오버라이드 시켜야 한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"intend to put instances of persistent classes in a <literal>Set "
"(the recommended way to represent many-valued associations); <emphasis>and 속에 영속 클래스들의 인스턴스들을 집어넣고자 의"
"도하고 (many-valued 연관들에 대해 권장되는 방법) <emphasis>그리고"

#. Tag: para
#, no-c-format
msgid "intend to use reattachment of detached instances"
msgstr "detached 인스턴스들의 reattachment(재첨부)를 사용하고자 의도하는"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Hibernate guarantees equivalence of persistent identity (database row) and "
"Java identity only inside a particular session scope. When you mix instances "
"retrieved in different sessions, you must implement <literal>equals()hashCode() if you wish to have meaningful "
"semantics for <literal>Sets."
msgstr ""
"Hibernate는 특정 session 범위 내에서만 persistent identity(데이터베이스 행)"
"과 Java identity의 같음을 보장한다. 따라서 우리가 다른 세션들에서 검색된 인스"
"턴스들을 혼합시키자마자, 우리가 <literal>Set들에 대해 유의미하게 만"
"들고자 원할 경우, 우리는 <literal>equals()와 hashCode()/"
"<literal>hashCode() by comparing the identifier value of both "
"objects. If the value is the same, both must be the same database row, "
"because they are equal. If both are added to a <literal>Set, you "
"will only have one element in the <literal>Set). Unfortunately, "
"you cannot use that approach with generated identifiers. Hibernate will only "
"assign identifier values to objects that are persistent; a newly created "
"instance will not have any identifier value. Furthermore, if an instance is "
"unsaved and currently in a <literal>Set, saving it will assign an "
"identifier value to the object. If <literal>equals() and "
"<literal>hashCode() are based on the identifier value, the hash "
"code would change, breaking the contract of the <literal>Set. See "
"the Hibernate website for a full discussion of this problem. This is not a "
"Hibernate issue, but normal Java semantics of object identity and equality."
msgstr ""
"가장 명백한 방법은 두 객체들의 identifier 값을 비교함으로써 <literal>equals()"
"</literal>/hashCode()를 구현하는 것이다. 만일 그 값이 동일"
"하다면, 둘다 동일한 데이터베이스 행이어야 하고, 그러므로 그것들은 같다(둘다 "
"하나의 <literal>Set에 추가되는 경우에, 우리는 Set 속에 있을 경우에, 그것을 저장하는것은 하나의 식별자 값"
"을 그 객체에게 할당할 것이다. 만일 <literal>equals()와 "
"<literal>hashCode()가 그 식별자 값에 기초할 경우, hash 코드는 "
"<literal>Set의 계약을 파기하여 변경될 것이다. 이 문제에 대한 전체 "
"논의에 대해서는 Hibernate 웹 사이트를 보라. 이것은 Hibernate 쟁점이 아닌, 객"
"체 identity와 equality에 관한 통상의 자바 의미론임을 노트하라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"It is recommended that you implement <literal>equals() and "
"<literal>hashCode() using Business key equalityequals() "
"method compares only the properties that form the business key. It is a key "
"that would identify our instance in the real world (a <emphasis>natural를 사용하여 equals"
"()</literal>와 hashCode()를 구현할 것 권장한다. Business "
"key equality는 <literal>equals() 메소드가 비지니스 키, 즉 실세계에"
"서 우리의 인스턴스를 식별하게 될 키(<emphasis>natural 후보 키)를 "
"형성하는 프로퍼티들만을 비교한다는 점을 의미한다 :"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"A business key does not have to be as solid as a database primary key "
"candidate (see <xref linkend=\"transactions-basics-identity\" />). Immutable "
"or unique properties are usually good candidates for a business key."
msgstr ""
"하나의 비지니스 키는 데이터베이스 프라이머리 키 후보 만큼 견고하지 않아야 한"
"다(<xref linkend=\"transactions-basics-identity\"/>를 보라). 대개 변경할 수 "
"없는 프로퍼티 또는 유일한(unique) 프로퍼티는 대개 비지니스 키에 대한 좋은 후"
"보들이다."

#. Tag: title
#, no-c-format
msgid "Dynamic models"
msgstr "동적인 모형들"

#. Tag: title
#, no-c-format
msgid "Note"
msgstr ""

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<emphasis>The following features are currently considered experimental and "
"may change in the near future.</emphasis>"
msgstr ""
"다음 특징들은 현재 실험적으로 고려되고 있으며 장래에는 변경될 수 있음을 노트"
"하라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Persistent entities do not necessarily have to be represented as POJO "
"classes or as JavaBean objects at runtime. Hibernate also supports dynamic "
"models (using <literal>Maps of Maps at runtime) "
"and the representation of entities as DOM4J trees. With this approach, you "
"do not write persistent classes, only mapping files."
msgstr ""
"영속 엔티티들은 반드시 실행시에 POJO 클래스들로 또는 자바빈즈 객체들로 표현되"
"어야할 필요는 없다. Hibernate는 또한 (실행 시에 <literal>Map들을 가"
"진 <literal>Map들을 사용하여) 동적인 모형들을 지원하고 DOM4J 트리들"
"로서 엔티티들에 대한 표현을 지원한다. 이 접근법으로, 당신은 영속 클래스들을 "
"작성하지 않고, 오직 매핑 파일들 만을 작성한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"By default, Hibernate works in normal POJO mode. You can set a default "
"entity representation mode for a particular <literal>SessionFactorydefault_entity_mode configuration "
"option (see <xref linkend=\"configuration-optional-properties\" />)."
msgstr ""
"디폴트로, Hibernate는 통산의 POJO 모드로 동작한다. 당신은 "
"<literal>default_entity_mode 구성 옵션을 사용하여 특별한 "
"<literal>SessionFactory에 대해 디폴트 엔티티 표현 모드를 설정할 수 "
"있다 (<xref linkend=\"configuration-optional-properties\"/>을 보라)."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The following examples demonstrate the representation using <literal>Mapentity-name has "
"to be declared instead of, or in addition to, a class name:"
msgstr ""
"다음 예제들은<literal>Map들을 사용하는 표현을 설명한다. 먼저 매핑 "
"파일에서, <literal>entity-name은 클래스 이름 대신에(또는 클래스 이"
"름에 덧붙여) 선언되어야 한다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Even though associations are declared using target class names, the target "
"type of associations can also be a dynamic entity instead of a POJO."
msgstr ""
"심지어 비록 연관들이 대상(target) 클래스 이름들을 사용하여 선언될지라도, 연관"
"들의 대상(target) 타입은 또한 POJO가 아닌 동적인 엔티티일 수 있음을 노트하라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"After setting the default entity mode to <literal>dynamic-map for "
"the <literal>SessionFactory, you can, at runtime, work with "
"<literal>Maps of Maps:"
msgstr ""
"<literal>SessionFactory에 대한 디폴트 엔티티 모드를 "
"<literal>dynamic-map으로 설정한 후에, 우리는 Map"
"들을 가진 <literal>Map들에 대해 실행 시에 작업할 수 있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"One of the main advantages of dynamic mapping is quick turnaround time for "
"prototyping, without the need for entity class implementation. However, you "
"lose compile-time type checking and will likely deal with many exceptions at "
"runtime. As a result of the Hibernate mapping, the database schema can "
"easily be normalized and sound, allowing to add a proper domain model "
"implementation on top later on."
msgstr ""
"dynamic 매핑의 장점들은 엔티티 클래스 구현에 대한 필요 없이도 프로토타이핑을 "
"위한 빠른 전환 시간이다. 하지만 당신은 컴파일 시 타입 체킹을 잃고 실행 시에 "
"많은 예외상황들을 다루게 될 것이다. Hibernate 매핑 덕분에, 나중에 고유한 도메"
"인 모형 구현을 상단에 추가하는 것이 허용되어서, 데이터베이스 스키마가 쉽게 정"
"규화 되고 소리가 울려 퍼질 수 있다."

#. Tag: para
#, no-c-format
msgid ""
"Entity representation modes can also be set on a per <literal>Session 기준에 대해 "
"설정될 수 있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Please note that the call to <literal>getSession() using an "
"<literal>EntityMode is on the Session API, not "
"the <literal>SessionFactory. That way, the new Sessionclose() on the secondary Session를 사용하는 getSession()에 대"
"한 호출은 <literal>SessionFactory가 아닌, Session은 기본 JDBC 커넥션, 트랜잭션, 그리고 다른 컨텍스"
"트 정보를 공유한다. 이것은 당신이 두 번째 <literal>Session 상에서 "
"<literal>flush()와 close()를 호출하지 말아야 하"
"고, 또한 트랜잭션 및 커넥션 핸들링을 주된 작업 단위에게 맡긴다는 점을 의미한"
"다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"More information about the XML representation capabilities can be found in "
"<xref linkend=\"xml\" />."
msgstr ""
"XML 표현 가용성들에 대한 추가 정보는 <xref linkend=\"xml\"/>에서 찾을 수 있"
"다."

#. Tag: title
#, no-c-format
msgid "Tuplizers"
msgstr "Tuplizer들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<literal>org.hibernate.tuple.Tuplizer, and its sub-interfaces, are "
"responsible for managing a particular representation of a piece of data "
"given that representation's <literal>org.hibernate.EntityMode. If "
"a given piece of data is thought of as a data structure, then a tuplizer is "
"the thing that knows how to create such a data structure and how to extract "
"values from and inject values into such a data structure. For example, for "
"the POJO entity mode, the corresponding tuplizer knows how create the POJO "
"through its constructor. It also knows how to access the POJO properties "
"using the defined property accessors."
msgstr ""
"<literal>org.hibernate.tuple.Tuplizer, 그리고 그것의 서브-인터페이"
"스들은 데이터의 조각에 대한 특별한 표현의 <literal>org.hibernate.EntityModeorg.hibernate.tuple.component."
"ComponentTuplizer</literal> 인터페이스에 의해 표현되는 두 가지 고급 유형의 "
"Tuplizer들이 존재한다. <literal>EntityTuplizer들은 엔티티들에 관해"
"서는 위에 언급된 계약들을 매핑할 책임이 있는 반면에, "
"<literal>ComponentTuplizer들은 컴포넌트들에 대해서도 동일한 것을 행"
"한다."

#. Tag: para
#, no-c-format
msgid ""
"There are two high-level types of Tuplizers, represented by the <literal>org."
"hibernate.tuple.entity.EntityTuplizer</literal> and org.hibernate."
"tuple.component.ComponentTuplizer</literal> interfaces. "
"<literal>EntityTuplizers are responsible for managing the above "
"mentioned contracts in regards to entities, while "
"<literal>ComponentTuplizers do the same for components."
msgstr ""

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Users can also plug in their own tuplizers. Perhaps you require that a "
"<literal>java.util.Map implementation other than java."
"util.HashMap</literal> be used while in the dynamic-map entity-mode. Or "
"perhaps you need to define a different proxy generation strategy than the "
"one used by default. Both would be achieved by defining a custom tuplizer "
"implementation. Tuplizer definitions are attached to the entity or component "
"mapping they are meant to manage. Going back to the example of our customer "
"entity:"
msgstr ""
"사용자들은 또한 그들 자신의 tuplizer들을 플러그 시킬 수 있다. 아마 당신은 "
"dynamic-map entity-mode 동안에 사용되는 <literal>java.util.HashMap "
"대신에 하나의 <literal>java.util.Map 구현을 필요로 한다; 또는 아마 "
"당신은 디폴트로 사용되는 방도 보다는 하나의 다른 다른 프릭시 산출 방도를 필요"
"로 한다. 둘다 하나의 맞춤형 tuplizer를 정의함으로써 성취될 것이다. Tuplizer"
"들 정의들은 그것들이 관리할 수단인 엔티티 매핑 또는 컴포넌트 매핑에 첨부된"
"다. 우리의 고객 엔티티에 대한 예제로 되돌아가면:"

#. Tag: title
#, no-c-format
msgid "EntityNameResolvers"
msgstr ""

#. Tag: para
#, no-c-format
msgid ""
"The <interfacename>org.hibernate.EntityNameResolver "
"interface is a contract for resolving the entity name of a given entity "
"instance. The interface defines a single method "
"<methodname>resolveEntityName which is passed the entity "
"instance and is expected to return the appropriate entity name (null is "
"allowed and would indicate that the resolver does not know how to resolve "
"the entity name of the given entity instance). Generally speaking, an "
"<interfacename>org.hibernate.EntityNameResolver is going to "
"be most useful in the case of dynamic models. One example might be using "
"proxied interfaces as your domain model. The hibernate test suite has an "
"example of this exact style of usage under the <package>org.hibernate.test."
"dynamicentity.tuplizer2</package>. Here is some of the code from that "
"package for illustration."
msgstr ""

#. Tag: para
#, no-c-format
msgid ""
"In order to register an <interfacename>org.hibernate.EntityNameResolvergetEntityNameResolvers "
"method."
msgstr ""

#. Tag: para
#, no-c-format
msgid ""
"Register it with the <classname>org.hibernate.impl.SessionFactoryImplorg."
"hibernate.SessionFactory</interfacename>) using the "
"<methodname>registerEntityNameResolver method."
msgstr ""

#~ msgid "There are four main rules to follow here:"
#~ msgstr "준수할 네 개의 주요 규칙들이 다음에 있다:"

#~ msgid ""
#~ "TODO: Document user-extension framework in the property and proxy packages"
#~ msgstr ""
#~ "TODO: property 패키지와 proxy 패키지 내에 user-extension 프레임웍을 문서"
#~ "화 할 것."