Hibernate example source code file (component_mapping.po)

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

a, components, composite, hibernate, hibernate, if, note, tag, tag, the, the, this, you, you

The Hibernate component_mapping.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 "Component Mapping"
msgstr "Component 매핑"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The notion of a <emphasis>component is re-used in several "
"different contexts and purposes throughout Hibernate."
msgstr ""
"<emphasis>component의 개념은 Hibernate에서 다른 용도로 몇몇 다른 "
"컨텍스트들 내에서 재사용된다."

#. Tag: title
#, no-c-format
msgid "Dependent objects"
msgstr "종속 객체들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"A component is a contained object that is persisted as a value type and not "
"an entity reference. The term \"component\" refers to the object-oriented "
"notion of composition and not to architecture-level components. For example, "
"you can model a person like this:"
msgstr ""
"하나의 컴포넌트는 엔티티 참조가 아닌, value 타입으로서 영속화 되는 하나의 포"
"함된 객체이다. \"컴포넌트\" 용어는 (아키텍처 수준의 컴포넌트들이 아닌) "
"composition(구성,합성)에 대한 객체-지향적인 개념을 언급한다. 예를 들어 당신"
"은 다음과 같이 개인을 모형화 시킬 수도 있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Now <literal>Name can be persisted as a component of "
"<literal>Person. Name defines getter and setter "
"methods for its persistent properties, but it does not need to declare any "
"interfaces or identifier properties."
msgstr ""
"이제 <literal>Name은 Person의 컴포넌트로서 영속"
"화 될 수도 있다. <literal>Name이 그것의 영속 프로퍼티들에 대한 "
"getter 메소드와 setter 메소드를 정의하지만, 어떤 인터페이스들이나 식별자 프로"
"퍼티들을 선언하는 것을 필요로 하지 않음을 주목하라."

#. Tag: para
#, fuzzy, no-c-format
msgid "Our Hibernate mapping would look like this:"
msgstr "우리의 Hibernate 매핑은 다음과 같을 것이다:"

#. Tag: para
#, no-c-format
msgid ""
"The person table would have the columns <literal>pid, "
"<literal>birthday, initial, firstlast."
msgstr ""
"person 테이블은 <literal>pid, birthday, "
"<literal>initial, first, last. 포함된 "
"객체를 다시 로드시킬 때, Hibernate는 모든 컴포넌트 컬럼들이 null일 경우에 전"
"체 컴포넌트가 null이라고 가정할 것이다. 이것은 대부분의 용도에 맞을 것이다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The properties of a component can be of any Hibernate type (collections, "
"many-to-one associations, other components, etc). Nested components should "
"<emphasis>not be considered an exotic usage. Hibernate is "
"intended to support a fine-grained object model."
msgstr ""
"컴포넌트의 프로퍼티들은 임의의 Hibernate 타입일 수 있다(콜렉션들, many-to-"
"one 연관들, 다른 컴포넌트들, 기타). 내포된 컴포넌트들은 신종의 사용례로 간주"
"되지 <emphasis>않을 것이다. Hibernate는 매우 잘 정제된 객체 모형"
"을 지원하도록 고안되어있다."

#. Tag: para
#, no-c-format
msgid ""
"The <literal><component> element allows a <"
"parent></literal> subelement that maps a property of the component class "
"as a reference back to the containing entity."
msgstr ""
"<literal><component> 요소는 컴포넌트 클래스의 프로퍼티를 포함"
"되는 엔티티에 대한 역 참조로서 매핑시키는 <literal><parent> "
"서브요소를 허용한다."

#. Tag: title
#, no-c-format
msgid "Collections of dependent objects"
msgstr "종속 객체들을 가진 콜렉션들"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Collections of components are supported (e.g. an array of type "
"<literal>Name). Declare your component collection by replacing the "
"<literal><element> tag with a <composite-"
"element></literal> tag:"
msgstr ""
"컴포넌트들을 가진 콜렉션들이 지원된다(예를 들면 <literal>Name 타입"
"을 가진 배열). <literal><element> 태그를 <"
"composite-element></literal> 태그로 대체시켜서 당신의 컴포넌트 콜렉션을 선"
"언하라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"If you define a <literal>Set of composite elements, it is "
"important to implement <literal>equals() and hashCode()를 정의"
"할 경우, <literal>equals()와 hashCode()를 정확하"
"게 구현하는 것이 매우 중요하다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Composite elements can contain components but not collections. If your "
"composite element contains components, use the <literal><nested-composite-"
"element></literal> tag. This case is a collection of components which "
"themselves have components. You may want to consider if a one-to-many "
"association is more appropriate. Remodel the composite element as an entity, "
"but be aware that even though the Java model is the same, the relational "
"model and persistence semantics are still slightly different."
msgstr ""
"Composite 요소들은 컴포넌트들을 포함하지만 콜렉션들을 포함하지 않는다. 만일 "
"당신의 composite 요소 자체가 컴포넌트들을 포함할 경우, <literal><nested-"
"composite-element></literal> 태그를 사용하라. 이것은 꽤 신종의 경우-그것"
"들 자체가 컴포넌트들을 갖고 있는 컴포넌트들의 콜렉션-이다. 이 단계에서 당신"
"은 one-to-many 연관이 더 적절한지를 당신 스스로에게 질문하게 될 것이다. 하나"
"의 엔티티로서 composite 요소를 다시 모델링하려고 시도하라 - 그러나 자바 모형"
"들이 동일할지라도, 관계형 모형과 영속화 의미들은 여전히 약간 다르다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"A composite element mapping does not support null-able properties if you are "
"using a <literal><set>. There is no separate primary key "
"column in the composite element table. Hibernate uses each column's value to "
"identify a record when deleting objects, which is not possible with null "
"values. You have to either use only not-null properties in a composite-"
"element or choose a <literal><list>, <map><bag> or <idbag>."
msgstr ""
"당신이 하나의 <literal><set>을 사용 중이라면, 하나의 "
"composite 요소 매핑은 null 가능한 프로퍼티들을 지원하지 않음을 노트하길 바란"
"다. Hibernate는 객체들을 삭제할 때 하나의 레코드를 식별하는데 각각의 컬럼들 "
"값을 사용해야 하며 (composite 요소 테이블 내에 별도의 프라이머리 키 컬럼이 존"
"재하지 않는다), 그것은 null 값들에 대해서는 불가능하다. 당신은 하나의 "
"composite-요소 내에 not-null 프로퍼티들 만을 사용해야 하거나 하나의 "
"<literal><list>, <map>, "
"<literal><bag> 또는 <idbag>을 선택해"
"야 한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"A special case of a composite element is a composite element with a nested "
"<literal><many-to-one> element. This mapping allows you to "
"map extra columns of a many-to-many association table to the composite "
"element class. The following is a many-to-many association from "
"<literal>Order to Item, where "
"<literal>purchaseDate, price and "
"<literal>quantity are properties of the association:"
msgstr ""
"composite 요소에 대한 하나의 특별한 경우는 내포된 <literal><many-to-"
"one></literal> 요소를 가진 composite 요소이다. 이같은 매핑은 many-to-many "
"연관 테이블의 특별한 컬럼들을 composite 요소 클래스로 매핑시키는 것을 당신에"
"게 허용해준다. 다음은 <literal>Order로부터 Item"
"으로의 many-to-many 연관이다. 여기서 <literal>purchaseDate, "
"<literal>price, 그리고 quantity는 연관의 프로퍼"
"티들이다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"There cannot be a reference to the purchase on the other side for "
"bidirectional association navigation. Components are value types and do not "
"allow shared references. A single <literal>Purchase can be in the "
"set of an <literal>Order, but it cannot be referenced by the "
"<literal>Item at the same time."
msgstr ""
"물론, 양방향 연관 네비게이션의 경우, 다른 측 상에 있는 purchase에 대한 참조"
"가 존재할 수 없다. 컴포넌트들이 값(value) 타입들이고 공유된 참조들을 허용하"
"지 않음을 기억하라. 하나의 <literal>Purchase는OrderItem element allows you to map a "
"component class as the key of a <literal>Map. Ensure that you "
"override <literal>hashCode() and equals() "
"correctly on the component class."
msgstr ""
"<literal><composite-map-key> 요소는 당신에게 하나의 컴포넌트 "
"클래스를 하나의 <literal>Map의 키로서 매핑시키도록 한다. 당신은 컴"
"포넌트 클래스 상에서 <literal>hashCode()와 equals()."
msgstr "그것은 <literal>java.io.Serializable을 구현해야 한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"It must re-implement <literal>equals() and hashCode()와 hashCode()를 다시 구현해야 "
"한다."

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

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"In Hibernate3, although the second requirement is not an absolutely hard "
"requirement of Hibernate, it is recommended."
msgstr ""
"노트: Hibernate3에서, 두 번째 사양은 Hibernate의 절대적으로 엄격한 사양이 아"
"니다. 그러나 아무튼 그것을 행하라."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"You cannot use an <literal>IdentifierGenerator to generate "
"composite keys. Instead the application must assign its own identifiers."
msgstr ""
"당신은 compsite 키들을 생성시키는데 <literal>IdentifierGenerator를 "
"사용할 수 없다. 대신에 어플리케이션은 그것 자신의 식별자들을 할당해야 한다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Use the <literal><composite-id> tag, with nested "
"<literal><key-property> elements, in place of the usual "
"<literal><id> declaration. For example, the "
"<literal>OrderLine class has a primary key that depends upon the "
"(composite) primary key of <literal>Order."
msgstr ""
"통상의 <literal><id> 선언 위치에 (내포된 <key-"
"property></literal> 요소들을 가진) <composite-id>OrderLine 클래스는 "
"<literal>Order의 (composite) 프라이머리 키에 의존하는 프라이머리 키"
"를 갖는다."

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Any foreign keys referencing the <literal>OrderLine table are now "
"composite. Declare this in your mappings for other classes. An association "
"to <literal>OrderLine is mapped like this:"
msgstr ""
"이제 <literal>OrderLine 테이블을 참조하는 임의의 foreign 키들이 또"
"한 compsite이다. 당신은 다른 클래스들에 대한 당신의 매핑들 속에 이것을 선언해"
"야 한다. <literal>OrderLine에 대한 하나의 연관은 다음과 같이 매핑"
"될 것이다:"

#. Tag: para
#, no-c-format
msgid ""
"The <literal>column element is an alternative to the "
"<literal>column attribute everywhere. Using the column"
msgstr ""

#. Tag: para
#, no-c-format
msgid ""
"A <literal>many-to-many association to OrderLine에 대한 many-to-many 연관은 또"
"한 composite foreign 키를 사용한다:"

#. Tag: para
#, no-c-format
msgid ""
"The collection of <literal>OrderLines in Order "
"would use:"
msgstr ""
"<literal>Order에서 OrderLine들의 콜렉션이 사용"
"될 것이다:"

#. Tag: para
#, fuzzy, no-c-format
msgid "The <literal><one-to-many> element declares no columns."
msgstr ""
"(통상적으로 <literal><one-to-many> 요소는 컬럼들을 선언하지 "
"않는다.)"

#. Tag: para
#, no-c-format
msgid ""
"If <literal>OrderLine itself owns a collection, it also has a "
"composite foreign key."
msgstr ""
"만일 <literal>OrderLine 자체가 하나의 콜렉션을 소유할 경우, 그것은 "
"또한 하나의 composite foreign 키를 갖는다."

#. Tag: title
#, no-c-format
msgid "Dynamic components"
msgstr "동적인 컴포넌트들"

#. Tag: para
#, fuzzy, no-c-format
msgid "You can also map a property of type <literal>Map:"
msgstr "당신은 <literal>Map 타입의 프로퍼티를 매핑시킬 수도 있다:"

#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The semantics of a <literal><dynamic-component> mapping are "
"identical to <literal><component>. The advantage of this "
"kind of mapping is the ability to determine the actual properties of the "
"bean at deployment time just by editing the mapping document. Runtime "
"manipulation of the mapping document is also possible, using a DOM parser. "
"You can also access, and change, Hibernate's configuration-time metamodel "
"via the <literal>Configuration object."
msgstr ""
"<literal><dynamic-component> 매핑의 의미는 <"
"component></literal>와 동일하다. 이런 종류의 매핑의 장점은 배치 시에 단지 "
"매핑 문서를 편집함으로써 그 bean의 실제 프로퍼티들을 결정하는 가용성이다. 매"
"핑 문서에 대한 런타임 처리는 또한 DOM 파서를 사용하여 가능하다. 더 좋게는 당"
"신이 <literal>Configuration 객체를 통해 Hibernate의 구성-시 메타모"
"형에 접근할 수 있다(그리고 변경시킬 수 있다)"

#~ msgid ""
#~ "(Note that the <literal><column> tag is an alternative to "
#~ "the <literal>column attribute everywhere.)"
#~ msgstr ""
#~ "(<literal><column> 태그가 모든 곳에서 column

Other Hibernate examples (source code examples)
Here is a short list of links related to this Hibernate component_mapping.po source code file:

  
 The search page
  
 Other Hibernate source code examples at this package level
  
 Click here to learn more about this project