एनोटेशन का उपयोग करके हाइबरनेट में "मानचित्र" को कैसे मैप करते हैं?

Question

एनोटेशन का उपयोग करके आप किसी इकाई में किसी फ़ील्ड को कैसे मैप करते हैं जो किसी ऑब्जेक्ट पर स्ट्रिंग के "मैप" (हैशटेबल) है? ऑब्जेक्ट एनोटेट किया गया है और इसके उदाहरण हाइबरनेट डेटाबेस में पहले ही संग्रहीत हैं। कुंजी के रूप में एक इकाई और इतने की तरह मान के रूप में एक साधारण प्रकार के साथ

<class name="Foo" table="foo"> 
    ... 
    <map role="ages"> 
     <key column="id"/> 
     <index column="name" type="string"/> 
     <element column="age" type="string"/> 
    </map> 
</class> 

और अजीब तरह से:

मैं एक साधारण कुंजी और जैसे मूल्य के साथ एक नक्शा definging के लिए वाक्यविन्यास पाया है

<class name="Foo" table="foo"> 
    ... 
    <map role="ages"> 
    <key column="id"/> 
    <index-many-to-many column="person_id" 
     class="Person"/> 
    <element column="age" type="string"/> 
    </map> 
</class> 
<class name="Person" table="person"> 
    ... 
    <property name="name" column="name" 
     type="string"/> 
</class> 

लेकिन मुझे यह नहीं पता कि तत्व मैपिंग के लिए एक सरल कुंजी के लिए यह कैसे करना है, और मुझे नहीं लगता कि एनोटेशन का उपयोग करके इसे कैसे किया जाए।

Answer 1

आप बस, जेपीए एनोटेशन@MapKey (ध्यान दें कि जेपीए एनोटेशन हाइबरनेट से अलग है, हाइबरनेट @MapKey नक्शे एक डेटाबेस स्तंभ नक्शा कुंजी दबाए रख इस्तेमाल कर सकते हैं, जबकि जेपीए के एनोटेशन के लिए संपत्ति के नक्शे मानचित्र की कुंजी के रूप में इस्तेमाल किया जाना चाहिए)।

@javax.persistence.OneToMany(cascade = CascadeType.ALL) 
@javax.persistence.MapKey(name = "name") 
private Map<String, Person> nameToPerson = new HashMap<String, Person>(); 

Answer 2

आपको शायद उपयोगकर्ता टाइप या उपयोगकर्ता कोलेक्शन टाइप का उपयोग करना चाहिए। या, आप एक कस्टम tupleizer का उपयोग कर सकते हैं।

अवधारणाओं के लिए hibernate core documentation और समकक्ष एनोटेशन दृष्टिकोण के लिए hibernate annotations documentation देखें।

मुझे बताएं कि क्या वह नहीं है जो आप पूछ रहे हैं।

Answer 3

@CollectionOfElements(fetch = FetchType.LAZY) 
@JoinTable(name = "JOINTABLE_NAME", 
    joinColumns = @JoinColumn(name = "id")) 
@MapKey(columns = @Column(name = "name")) 
@Column(name = "age") 
private Map<String, String> ages = new HashMap<String, String>(); 

Answer 4

मुझे पता है कि यह प्रश्न बहुत पुराना है लेकिन शायद यह किसी की मदद कर सकता है। ,

@Entity 
@Table(name = "PREFERENCE", uniqueConstraints = { @UniqueConstraint(columnNames = { "ID_DOMAIN", "ID_USER", "KEY" })}) 
public class Preferences { 
    @Id 
    @GeneratedValue(strategy = GenerationType.AUTO) 
    @Column(name = "ID", unique = true, nullable = false) 
    private Long id; 

    @Column(name = "ID_DOMAIN", unique = false, nullable = false") 
    private Long domainId; 

    @Column (name = "PREFERENCE_KEY") 
    @Enumerated(EnumType.STRING) 
    private PreferenceKey key; 

    @ManyToOne(fetch = FetchType.LAZY) 
    @JoinColumn(name = "ID_USER", referencedColumnName = "ID") 
    private User user; 
} 

and 

@Entity 
@Table(name = "USER", uniqueConstraints = { @UniqueConstraint(columnNames = { "ID_DOMAIN", "LOGIN" })}) 
public class User { 
    @Id 
    @GeneratedValue(strategy = GenerationType.AUTO) 
    @Column(name = "ID", unique = true, nullable = false) 
    private Long id; 

    @Column(name = "ID_DOMAIN", unique = false, nullable = false") 
    private Long domainId; 

    // more fields 

    @ElementCollection(fetch = FetchType.LAZY) 
    @JoinColumns({@JoinColumn(name = "ID_USER", referencedColumnName = "ID"), @JoinColumn(name = "ID_DOMAIN", referencedColumnName = "ID_DOMAIN")}) 
    @OneToMany(targetEntity = Preferences.class, fetch = FetchType.LAZY) 
    @MapKey(name = "key") 
    private Map<PreferenceKey, Preferences> preferencesMap; 
} 

यह केवल का उत्पादन दो तालिकाओं उपयोगकर्ता और प्राथमिकताएं ध्यान दें कि PreferenceKey एक डोमेन