इकाई-बीन (जेपीए) में यूनिडायरेक्शनल रिलेशनशिप

Question

ईजेबी 3.0 एंटीटी-बीन्स (जेपीए) में यूनिडायरेक्शनल रिलेशनशिप कैसे करें?

उदाहरण के लिए ग्राहक ऑर्डर के बारे में जानते हैं लेकिन ऑर्डर के पास ग्राहक के लिए कोई विधि नहीं है। (@OneToMany या @OneToOne या @ManyToMany) का उपयोग कर

सादर

Answer 1

का तरीका यहां बताया जेपीए 2.0 का उपयोग कर एक यूनिडायरेक्शनल @OneToMany संबंध बनाने करेंगे:

@Entity 
public class Customer { 
    @Id 
    @Column(name="cust_id") 
    private long id; 
    ... 
    @OneToMany 
    @JoinColumn(name="owner_id", referencedColumnName="cust_id") 
    private List<Order> order; 
    ... 
} 

@Entity 
public class Order { 
    @Id 
    @Column(name="order_id") 
    private long id; 
    ... 
} 

संबंधपरक डेटाबेस:

ग्राहक:

+---------+---------+------+-----+---------+-------+ 
| Field | Type | Null | Key | Default | Extra | 
+---------+---------+------+-----+---------+-------+ 
| cust_id | int(11) | NO | PRI | NULL |  | 
+---------+---------+------+-----+---------+-------+ 

आदेश:

+----------+---------+------+-----+---------+-------+ 
| Field | Type | Null | Key | Default | Extra | 
+----------+---------+------+-----+---------+-------+ 
| order_id | int(11) | NO | PRI | NULL |  | 
| owner_id | int(11) | NO | MUL | NULL |  | 
+----------+---------+------+-----+---------+-------+ 

Answer 2

छोड़कर "uni-दिशात्मक" एक तरफ पल के लिए, एक एक ग्राहक आदेश संबंध इस प्रकार मॉडल सकता है।

@Entity 
public class Customer { 
    // ... 
    @Id @GeneratedValue 
    int id; 
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "customer") 
    Set<Order> orders; 
    // ... 
} 

@Entity 
public class Order { 
    // ... 
    @ManyToOne(optional = false) 
    Customer customer; 
    // ... 
} 

यहां मैं मान रहा हूं कि प्रत्येक आदेश में बिल्कुल एक ग्राहक है। डेटाबेस में, ऑर्डर तालिका में ग्राहक तालिका के "आईडी" कॉलम के लिए एक विदेशी कुंजी वाला "ग्राहक_आईडी" कॉलम होगा। डीडीएल निम्नलिखित की तरह कुछ दिखता है।

CREATE TABLE Customer (
    id INT NOT NULL, 
    ... 
    PRIMARY KEY (id) 
); 

CREATE TABLE Order (
    ... 
    customer_id INT NOT NULL, 
    ... 
    FOREIGN KEY (customer_id) REFERENCES Customer (id) 
); 

हालांकि ग्राहक वर्ग में ऑर्डर का संग्रह होता है, यह वास्तव में किसी भी तरह से डेटाबेस संरचना को प्रभावित नहीं करता है; यह ग्राहक से संबंधित आदेशों को पुनर्प्राप्त/प्रबंधित करने का एक सुविधाजनक तरीका है। उदाहरण के लिए, आप ग्राहक से "ऑर्डर" सदस्य को पूरी तरह से छोड़ सकते हैं और इसके बजाय इन रिकॉर्ड्स को लाने के लिए क्वेरी पर भरोसा कर सकते हैं।

जिस बिंदु को मैं बनाने की कोशिश कर रहा हूं वह यह है कि डेटाबेस के परिप्रेक्ष्य से, वास्तव में "यूनी-दिशात्मक" संबंध जैसी कोई चीज़ नहीं है। उदाहरण reverendgreen प्रदान की गई जावा कक्षाएं उत्पन्न करेगी जहां कोई ऑर्डर ऑब्जेक्ट से ग्राहक ऑब्जेक्ट प्राप्त करने के लिए प्रत्यक्ष तरीका नहीं है, लेकिन परिणामस्वरूप डेटाबेस संरचना समान होगी (कॉलम नामों में मामूली अंतर को अनदेखा कर सकती है)। आप हमेशा एक प्रश्न के माध्यम से दिए गए आदेश के लिए ग्राहक को पा सकते हैं।