हाइबरनेट एकToMany सूची स्थायी लेकिन उलट करने का आदेश?

Question

मेरे पास एक सतत इकाई है जिसमें @OneToMany किसी अन्य इकाई की सूची है और मुझे उपयोगकर्ता द्वारा संपादित करने में सक्षम होने के लिए सूची आदेश की आवश्यकता है, जो आश्चर्यजनक रूप से काम करता है। मैं पूरी तरह से जावा सूची में स्मृति को फिर से ऑर्डर कर सकता हूं और जब मैं वस्तु को सहेजता हूं() ऑब्जेक्ट लिंकिंग तालिका में लिंक का क्रम बदलता है। हालांकि, यह उपयोगकर्ता सेट के विपरीत क्रम में बदल जाता है। हालांकि, यदि आप प्रोग्राम को बंद करने से पहले इकाई को वापस खींचते हैं, तो यह सही दिखाई देता है, क्योंकि यह पुनः लोड नहीं हो रहा है। यदि आप प्रोग्राम को फिर से लोड करते हैं, तो यह पीछे की तरफ है।

क्या यह ऐसा कुछ नहीं है जो मुझे करना है, उस आदेश पर निर्भर करता है? लेकिन एक और ऑर्डर कॉलम बनाना अनावश्यक लगता है क्योंकि वैसे भी एक ऑर्डर है, और मैं इसे बदल सकता हूं। मुझे बस पीछे की ओर बचाने के लिए इसकी आवश्यकता नहीं है।

कोई विचार?

Answer 1

क्या आपने तुलना की है कि उस ऑब्जेक्ट पदानुक्रम पर?

Answer 2

क्या आपकी हाइबरनेट परत सेट का उपयोग कर रही है? मेरा मानना ​​है कि यह डिफ़ॉल्ट रूप से करता है। सेट इंटरफ़ेस (और इसके ठोस कार्यान्वयन) प्रविष्टि आदेश बनाए रखें।

वैकल्पिक रूप से, आप अपने प्रश्नों को देखना चाहेंगे, क्या आप "ऑर्डर बाय" का उपयोग कर रहे हैं?

मैं डीबगर का उपयोग करके स्मृति में संग्रह को देखने का भी प्रयास करता हूं। आपका व्यू कोड संग्रह को फिर से ऑर्डर कर सकता है। कम से कम डीबगर यह देखने के लिए उपयोगी होगा कि आपका संग्रह किस विपरीत बिंदु पर है।

Answer 3

मुझे लगता है कि सूचियों के साथ सीधे इसे प्राप्त करने का कोई तरीका नहीं है। आप संस्थाओं के आदेश पर अपने उपयोगकर्ता पूर्ण नियंत्रण देना चाहते हैं

, आप उदाहरण के लिए एक नए क्षेत्र जोड़ना चाहिए:: हम काम पर निम्न का उपयोग

@Entity 
public class Todo { 
    @Id private Long id; 
    private int position; 
    // + public setter/getter 
} 

@Entity 
public class Todos { 
    @Id private id; 

    @OneToMany 
    private List<Todo> todos = new LinkedList<Todo>(); 
    // + public setter/getter  
} 

और उसके बाद में स्थिति द्वारा एक आदेश डाल सभी प्रश्नों या टोडोस के लिए एक तुलनात्मक लागू करें और अपनी सूची को स्मृति में क्रमबद्ध करने के लिए Collections.sort (सूची lst, Comparator cmp) का उपयोग करें।

public class TodoComparator implements Comparator { 
    public int compare(Object o1, Object o2) { 
    Todo t1 = (Todo)o1; 
    Todo t2 = (Todo)o2; 
    return t2.getPosition() - t1.getPosition(); 
    } 
} 

संग्रह.sort (todos, new TodosComparator());

अपनी उपभोक्ता सूची को पुन: व्यवस्थित करने के लिए, (से पहले बचाने के लिए) अंकित करना सूची समाप्त हो गया है के बाद:

for(int pos=0; pos < todos.size(); pos++) 
    todos.get(pos).setPosition(pos); 

और सब को बचाने के। और पूर्ण नियंत्रण का आनंद लें।

Answer 4

क्या आप सीधे सूची में काम कर रहे हैं?

object.getItems().add/remove/set ... 

बजाय फिर एक शॉट में पूरा संग्रह की स्थापना एक प्रति

List items = new ArrayList(object.getItems()); 

तो उस पर काम करने की कोशिश करें,:

object.setItems(items) 

Answer 5

हाइबरनेट आदेश दिया IndexColumn एनोटेशन का उपयोग कर तत्वों का समर्थन हासिल है।

@org.hibernate.annotations.CollectionOfElements 
@JoinTable(
name = "ITEM_IMAGE", 
joinColumns = @JoinColumn(name = "ITEM_ID") 
) 
@org.hibernate.annotations.IndexColumn(
name="POSITION", base = 1 
) 
@Column(name = "FILENAME") 
private List<String> images = new ArrayList<String>(); 

Answer 6

मैं एक ही मुद्दे में भाग गया, और मैं बस के रूप में एक अन्य लेख here में सुझाव दिया @OrderBy एनोटेशन जोड़कर तय:

यहाँ "Java Persistence with Hibernate" book से एक उदाहरण है।

@Entity 
    @Table(name = "my_library") 
    public class MyLibrary implements java.io.Serializable{ 

    (...omitted) 

    private List<Book> bookList = new ArrayList<Book>(); 

    @OneToMany(mappedBy = "library", cascade = CascadeType.ALL) 
    @OrderBy 
    public List<Book> getBookList() { 
     return bookList; 
    } 

    public void setBookList(List<Book> bookList) { 
     this.bookList= bookList; 
    } 

    } 

तब मैं getBookList करने में सक्षम हूँ() एक ही आदेश है, जबकि डीबी के लिए बने मैं डाला के रूप में: मुझे लगता है यह रूप में अच्छी तरह अपनी समस्या को हल करने के लिए सक्षम होना चाहिए, यहाँ मेरी कोड है। जब हम कॉलम नाम निर्दिष्ट नहीं करते हैं जैसे @OrderBy ("xxxColumn"), यह डिफ़ॉल्ट रूप से उस इकाई की प्राथमिक कुंजी का उपयोग करता है। मेरे मामले में, यह पुस्तक के इंस्टेंस आईडी का उपयोग करता है, जो हमेशा ऑर्डर ऑर्डर के समान क्रम का पालन करेगा, इसलिए यह मेरी ज़रूरत को अच्छी तरह से पूरा करता है।

हालांकि, मैं उत्सुक हूं कि आदेश पहली जगह क्यों विपरीत था।