JPA में ManyToMany संबंध के साथ इकाई कैसे निकालें (और इसी तालिका पंक्तियों में शामिल हों)?

Question 1

मान लीजिए कि मेरी दो इकाइयाँ हैं: समूह और उपयोगकर्ता। हर उपयोगकर्ता कई समूहों का सदस्य हो सकता है और हर समूह में कई उपयोगकर्ता हो सकते हैं।

@Entity
public class User {
    @ManyToMany
    Set<Group> groups;
    //...
}

@Entity
public class Group {
    @ManyToMany(mappedBy="groups")
    Set<User> users;
    //...
}

अब मैं एक समूह को हटाना चाहता हूं (मान लें कि इसके कई सदस्य हैं)।

समस्या यह है कि जब मैं कुछ ग्रुप पर EntityManager.remove () कॉल करता हूं, तो JPA प्रदाता (मेरे मामले में हाइबरनेट) पंक्तियों को ज्वाइन टेबल से नहीं हटाता है और विदेशी मुख्य बाधाओं के कारण ऑपरेशन विफल हो जाता है। उपयोगकर्ता को हटाने का आह्वान () ठीक काम करता है (मुझे लगता है कि इसका संबंध संबंधों के साथ कुछ करना है)।

तो मैं इस मामले में एक समूह को कैसे हटा सकता हूं?

जिस तरह से मैं साथ आ सकता था, वह है समूह के सभी उपयोगकर्ताओं को लोड करना, फिर प्रत्येक उपयोगकर्ता अपने समूहों से वर्तमान समूह को हटा दें और उपयोगकर्ता को अपडेट करें। लेकिन समूह से हर उपयोगकर्ता पर अपडेट () कॉल करने के लिए इस समूह को हटाने में सक्षम होना मेरे लिए हास्यास्पद लगता है।

Question 2

संबंध के स्वामित्व को निर्धारित किया जाता है जहां आप एनोटेशन के लिए 'मैप्डबी' विशेषता रखते हैं। 'MappedBy' लगाई जाने वाली इकाई वह है जो स्वामी नहीं है। मालिकों के लिए दोनों पक्षों के लिए कोई मौका नहीं है। यदि आपके पास 'उपयोगकर्ता को हटाएं' उपयोग-मामला नहीं है, तो आप बस स्वामित्व को Groupइकाई में स्थानांतरित कर सकते हैं , जैसा कि वर्तमान Userमें मालिक है।
दूसरी ओर, आप इसके बारे में नहीं पूछ रहे हैं, लेकिन एक बात जानने लायक है। groupsऔर usersएक दूसरे के साथ संयुक्त नहीं कर रहे हैं। मेरा मतलब है, Group1.users से User1 उदाहरण हटाने के बाद, User1.groups संग्रह स्वचालित रूप से नहीं बदला गया है (जो मेरे लिए काफी आश्चर्यजनक है),
सब सब में, मैं आपको सुझाव दूंगा कि मालिक कौन है। मान लीजिए कि Userमालिक है। फिर किसी उपयोगकर्ता को हटाते समय संबंधित उपयोगकर्ता-समूह स्वचालित रूप से अपडेट हो जाएगा। लेकिन जब किसी समूह को हटाते हैं तो आपको इस तरह से स्वयं को हटाने का ध्यान रखना पड़ता है:

entityManager.remove(group)
for (User user : group.users) {
     user.groups.remove(group);
}
...
// then merge() and flush()

Question 3

निम्नलिखित मेरे लिए काम करता है। निम्न विधि को उस इकाई में जोड़ें जो संबंध का स्वामी नहीं है (समूह)

@PreRemove
private void removeGroupsFromUsers() {
    for (User u : users) {
        u.getGroups().remove(this);
    }
}

ध्यान रखें कि इसके लिए काम करने के लिए, समूह के पास उपयोगकर्ताओं की एक अद्यतन सूची होनी चाहिए (जो स्वचालित रूप से नहीं होती है)। इसलिए हर बार जब आप उपयोगकर्ता इकाई में समूह सूची में एक समूह जोड़ते हैं, तो आपको उपयोगकर्ता को समूह इकाई में उपयोगकर्ता सूची में भी जोड़ना चाहिए।

Question 4

मुझे एक संभव समाधान मिला, लेकिन ... मुझे नहीं पता कि यह एक अच्छा समाधान है।

@Entity
public class Role extends Identifiable {

    @ManyToMany(cascade ={CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
    @JoinTable(name="Role_Permission",
            joinColumns=@JoinColumn(name="Role_id"),
            inverseJoinColumns=@JoinColumn(name="Permission_id")
        )
    public List<Permission> getPermissions() {
        return permissions;
    }

    public void setPermissions(List<Permission> permissions) {
        this.permissions = permissions;
    }
}

@Entity
public class Permission extends Identifiable {

    @ManyToMany(cascade = {CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
    @JoinTable(name="Role_Permission",
            joinColumns=@JoinColumn(name="Permission_id"),
            inverseJoinColumns=@JoinColumn(name="Role_id")
        )
    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

मैंने यह कोशिश की है और यह काम करता है। जब आप भूमिका को हटाते हैं, तो संबंध भी हटा दिए जाते हैं (लेकिन अनुमति निकाय नहीं) और जब आप अनुमति हटाते हैं, तो भूमिका के साथ संबंध भी हटा दिए जाते हैं (लेकिन भूमिका उदाहरण नहीं)। लेकिन हम दो बार एक यूनिडायरेक्शनल रिलेशनशिप को मैप कर रहे हैं और दोनों एंटिटी रिलेशन के मालिक हैं। क्या इससे हाइबरनेट को कुछ समस्याएं हो सकती हैं? किस प्रकार की समस्याएं?

धन्यवाद!

ऊपर दिया गया कोड संबंधित किसी अन्य पोस्ट से है।

Question 5

JPA / हाइबरनेट समाधान के विकल्प के रूप में: आप अपनी ज्वाइन टेबल पर अपनी फोरगिन कुंजी की डेटाबेस परिभाषा में CASCADE DELETE क्लॉज का उपयोग कर सकते हैं, जैसे (Oracle सिंटैक्स):

CONSTRAINT fk_to_group
     FOREIGN KEY (group_id)
     REFERENCES group (id)
     ON DELETE CASCADE

इस तरह DBMS खुद ही उस पंक्ति को हटा देता है जो समूह को हटाते समय समूह को इंगित करता है। और यह काम करता है कि क्या डिलीट हाइबरनेट / जेपीए, जेडीबीसी से किया जाता है, मैन्युअल रूप से डीबी या किसी अन्य तरीके से।

कैस्केड हटाने की सुविधा सभी प्रमुख DBMS (Oracle, MySQL, SQL Server, PostgreSQL) द्वारा समर्थित है।

Question 6

इसके लायक के लिए, मैं EclipseLink 2.3.2.v20111125-r10461 का उपयोग कर रहा हूं और अगर मेरे पास @ManyToMany यूनिडायरेक्शनल संबंध है, तो मैं उस समस्या का निरीक्षण करता हूं जिसका आप वर्णन करते हैं। हालाँकि, अगर मैं इसे एक द्वि-दिशात्मक @ManyToMany संबंध बनाता हूं तो मैं एक इकाई को गैर-स्वामित्व पक्ष से हटाने में सक्षम हूं और JOIN तालिका को उचित रूप से अपडेट किया गया है। यह सभी किसी भी झरना विशेषताओं के उपयोग के बिना है।

Question 7

यह मेरे लिए काम करता है:

@Transactional
public void remove(Integer groupId) {
    Group group = groupRepository.findOne(groupId);
    group.getUsers().removeAll(group.getUsers());

    // Other business logic

    groupRepository.delete(group);
}

इसके अलावा, विधि @Transactional (org.springframework.transaction.annotation.Transactional) को चिह्नित करें, यह एक सत्र में पूरी प्रक्रिया करेगा, कुछ समय बचाता है।

Question 8

यह एक अच्छा उपाय है। सबसे अच्छा हिस्सा SQL की तरफ है - किसी भी स्तर तक ठीक ट्यूनिंग करना आसान है।

मैंने आवश्यक विदेशी कुंजी के लिए डिलीट करने के लिए MySql और MySql कार्यक्षेत्र का उपयोग कैस्केड के लिए किया।

ALTER TABLE schema.joined_table 
ADD CONSTRAINT UniqueKey
FOREIGN KEY (key2)
REFERENCES schema.table1 (id)
ON DELETE CASCADE;

Question 9

यही मैंने समाप्त किया। उम्मीद है कि कोई इसे उपयोगी पा सकता है।

@Transactional
public void deleteGroup(Long groupId) {
    Group group = groupRepository.findById(groupId).orElseThrow();
    group.getUsers().forEach(u -> u.getGroups().remove(group));
    userRepository.saveAll(group.getUsers());
    groupRepository.delete(group);
}

Question 10

मेरे मामले के लिए, मैंने मैप किए गए को हटा दिया और इस तरह तालिकाओं में शामिल हो गया:

@ManyToMany(cascade = CascadeType.ALL)
@JoinTable(name = "user_group", joinColumns = {
        @JoinColumn(name = "user", referencedColumnName = "user_id")
}, inverseJoinColumns = {
        @JoinColumn(name = "group", referencedColumnName = "group_id")
})
private List<User> users;

@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JsonIgnore
private List<Group> groups;

Question 11

यह मेरे लिए एक समान मुद्दे पर काम करता है जहां मैं संदर्भ के कारण उपयोगकर्ता को हटाने में विफल रहा। धन्यवाद

@ManyToMany(cascade = {CascadeType.MERGE, CascadeType.PERSIST,CascadeType.REFRESH})