हाइबरनेट: सेट

Question

का ऑर्डर करना मेरे पास एक क्लास व्यक्ति है जिसमें पुस्तकें हैं। किसी विशेष आदेश में क्रमबद्ध या सॉर्ट किए गए संग्रह के लिए यह अर्थपूर्ण नहीं है।

अब कहें कि मेरे पास एक टेबल के साथ एक खोज पृष्ठ है जिसमें व्यक्ति और पुस्तक शामिल है। मैं व्यक्तियों और पुस्तक दोनों के क्षेत्रों द्वारा परिणामों को क्रमबद्ध करने में सक्षम होना चाहता हूं, और उसके बाद हाइबरनेट से एक सूची प्राप्त कर सकता हूं, और इसके ऊपर पुनरावृत्ति कर सकता हूं।

क्योंकि संग्रह एक सेट है, पुस्तकों का क्रम गायब हो गया है (हाइबरनेट के पर्सिस्टेंटसेट पुस्तकें के हैशसेट को लपेटता है, जिसे आदेश नहीं दिया जाता है)।

तो, इस दृष्टिकोण के साथ मुझे पुस्तक फ़ील्ड द्वारा भी आदेश नहीं दिए जा सकते हैं।

यदि मैं संग्रह से सूची में संग्रह बदलता हूं, तो मेरा मॉडल अर्थात् गलत है। मॉडल में आदेश रखने के लिए कोई मतलब नहीं है।

क्या किताबों के क्रम को रखने के लिए कोई दृष्टिकोण है? शायद PersistentSet को एक LinkedHashSet (जिसे आदेश दिया गया है) को लपेटने का एक तरीका है, जहां आदेश मेरी खोज मानदंड द्वारा परिभाषित किया गया है?

चीयर्स!

Answer 1

हाइबरनेट SortedSet के रूप में संग्रह को मैप करने का समर्थन करता है। आपके मैपिंग में आपको मूल रूप से केवल order-by खंड निर्दिष्ट करने की आवश्यकता होती है। this chapter in the reference manual पर एक नज़र डालें।

Answer 2

यह सुनिश्चित नहीं है कि मुझे सही प्रश्न मिल गया है, लेकिन यदि आप बस अपनी सूची का एक ordererd संस्करण चाहते हैं तो आप इसे java.util.Collections क्लास और एक तुलनाकर्ता के साथ सॉर्ट कर सकते हैं। हो सकता है कि आप इस तरह अपने pojo पर एक क्षणिक विधि बनाना चाहते हैं:

@Transient 
public List<Book> getBooksASC() 
{ 
    Collections.sort(this.books, new BookSorter.TitelASCSorter()); 
    return this.books; 
} 

बस एक कक्षा लिखें जो तुलनात्मक लागू करता है।

Answer 3

तरह Markos Fragkakis कहा

दुर्भाग्य से आदेश-मानचित्रण में (या @OrderBy) पूर्वता है, जो आदेश मानदंड बेकार द्वारा निर्धारित करता है लेता है।

लेकिन अगर आप सेट ऑर्डर करना चाहते हैं तो आपको @ ऑर्डर सेट करना होगा।

तुम अब भी HQL का उपयोग कर सकते बजाय (हाइबरनेट 3.3.2.GA पर परीक्षण), जो HQL क्वेरी में आदेश से सबसे पहले आदेश:

@Entity 
    @Table(name = "Person") 
    public class Person { 

     @Id 
     @Column(name = "ID_PERSON", unique = true, nullable = false, precision = 8, scale = 0) 
     private Long id; 

     @OneToMany(fetch = FetchType.LAZY, mappedBy = "person") 
     @OrderBy 
     private Set<Book> books = new HashSet<Book>(0); 

     public Person() { 
     } 

     public Long getId() { 
      return this.id; 
     } 

     public void setId(Long id) { 
      this.id = id; 
     } 


     public Set<Book> getBooks() { 
      return this.books; 
     } 

     public void setBooks(Set<Book> books) { 
      this.books = books; 
     } 

    } 

     /** 
     * hql Version 
     *  
     * Result in : 
     * order by 
     *  book1_.TITLE asc, 
     *  book1_.ID_BOOK asc 
     **/ 

     @Override 
     public Person getFullPerson(Long idPerson) { 

      StringBuilder hqlQuery = new StringBuilder(); 
      hqlQuery.append("from Person as p "); 
      hqlQuery.append("left join fetch p.books as book "); 
      hqlQuery.append("where p.id = :idPerson "); 
      hqlQuery.append("order by book.title "); 
      Query query = createQuery(hqlQuery.toString()); 
      query.setLong("idPerson", id); 
      return uniqueResult(query); 

     } 




     /** 
     * criteria Version // not usable 
     *  
     * Result in : 
     * order by 
     *  book1_.ID_BOOK asc, 
     *  book1_.TITLE asc 
     **/ 

     @Override 
    public Person getFullPersonCriteria(Long idPerson) { 

     Criteria criteria = ... 
     criteria.add(Restrictions.eq("id", idPerson)); 
     criteria.createAlias("books", "book", CriteriaSpecification.LEFT_JOIN); 
     criteria.addOrder(Order.asc("book.title")); 
      return criteria.uniqueResult(); 
     } 

Answer 4

यह एक में स्मृति तरह से यह ठीक हो जाएगा जॉइन टेबल में डुप्लिकेट करें।

@OneToMany 
    @JoinTable(name = "person_book", joinColumns = @JoinColumn(name = "person_id"), 
      inverseJoinColumns = @JoinColumn(name = "book_id")) 
    @Sort(type = SortType.COMPARATOR, comparator = MyBookComparator.class) 
    private SortedSet<BookEntity> books;