জেপিএ: একই সত্তা টাইপের এক থেকে একাধিক সম্পর্ক কীভাবে থাকতে পারে

Question 1

একটি সত্তা ক্লাস "এ" আছে। ক্লাস এ এর একই ধরণের "এ" এর শিশু থাকতে পারে। এছাড়াও "এ" এর যদি এটি সন্তান হয় তবে তার পিতামাতাকে ধরে রাখা উচিত।

এটা কি সম্ভব? যদি তা হয় তবে কীভাবে আমি সত্ত্বার শ্রেণিতে সম্পর্কের মানচিত্র করব? ["এ" এর একটি আইডি কলাম রয়েছে]]

Question 2

হ্যাঁ, এটি সম্ভব। এটি স্ট্যান্ডার্ড দ্বিদ্বিতীয় @ManyToOne/ @OneToManyসম্পর্কের একটি বিশেষ ক্ষেত্রে । এটি বিশেষ কারণ সম্পর্কের প্রতিটি প্রান্তে সত্তা একই। সাধারণ কেসটি জেপিএ ২.০ অনুচ্ছেদের ২.১০.২ বিভাগে বিশদে রয়েছে ।

এখানে একটি কাজের উদাহরণ। প্রথম, সত্তা শ্রেণি A:

@Entity
public class A implements Serializable {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Long id;
    @ManyToOne
    private A parent;
    @OneToMany(mappedBy="parent")
    private Collection<A> children;

    // Getters, Setters, serialVersionUID, etc...
}

এখানে একটি রুক্ষ main()পদ্ধতি যা এই জাতীয় তিনটি সত্তাকে স্থায়ী করে:

public static void main(String[] args) {

    EntityManager em = ... // from EntityManagerFactory, injection, etc.

    em.getTransaction().begin();

    A parent   = new A();
    A son      = new A();
    A daughter = new A();

    son.setParent(parent);
    daughter.setParent(parent);
    parent.setChildren(Arrays.asList(son, daughter));

    em.persist(parent);
    em.persist(son);
    em.persist(daughter);

    em.getTransaction().commit();
}

এক্ষেত্রে লেনদেনের প্রতিশ্রুতি দেওয়ার আগে তিনটি সত্তা উদাহরণ থাকতে হবে। আমি যদি পিতা-মাতার সন্তানের সম্পর্কের গ্রাফের কোনও একটি সত্তাকে অবিচল রাখতে ব্যর্থ হই, তবে তার ব্যতিক্রমও ছুঁড়ে দেওয়া হবে commit()। ইক্লিপসেলিংকে, RollbackExceptionএটি অসঙ্গতিটির বিবরণ দেয় is

এই আচরণ মাধ্যমে কনফিগার করা যাবে cascadeউপর অ্যাট্রিবিউট Aএর @OneToManyএবং @ManyToOneটীকা। উদাহরণস্বরূপ, যদি আমি cascade=CascadeType.ALLএই দুটি টীকাকে সেট করে রাখি তবে আমি নিরাপদে সত্তার একটির চালিয়ে যেতে এবং অন্যকে উপেক্ষা করতে পারি। বলুন আমি parentআমার লেনদেনে জেদ করেছিলাম জেপিএ বাস্তবায়ন parentএর childrenসম্পত্তি চিহ্নিত করেছে কারণ এটি চিহ্নিত রয়েছে CascadeType.ALL। জেপিএ বাস্তবায়ন খুঁজে পায় sonএবং daughterসেখানে। এটি তখন উভয় বাচ্চাকে আমার পক্ষে চালিয়ে যায়, যদিও আমি স্পষ্টভাবে এটির জন্য অনুরোধ করি নি।

আরও একটি নোট। দ্বিপাক্ষিক সম্পর্কের উভয় পক্ষকে আপডেট করা সর্বদা প্রোগ্রামারের দায়িত্ব। অন্য কথায়, আমি যখনই কোনও সন্তানের পিতামাতার সাথে যুক্ত করি তখন অবশ্যই আমাকে সেই অনুযায়ী সন্তানের পিতামাতার সম্পত্তি আপডেট করতে হবে। দ্বি নির্দেশমূলক সম্পর্কের কেবলমাত্র এক পক্ষ আপডেট করা জেপিএ-এর অধীনে ত্রুটি। সম্পর্কের উভয় দিক সর্বদা আপডেট করুন। এটি জেপিএ ২.০ অনুচ্ছেদের ৪২ পৃষ্ঠায় নির্বিঘ্নে লেখা হয়েছে:

নোট করুন যে এটি সেই অ্যাপ্লিকেশন যা রানটাইম সম্পর্কের ধারাবাহিকতা বজায় রাখার জন্য দায়িত্ব বহন করে - উদাহরণস্বরূপ, দ্বিমুখী সম্পর্কের "এক" এবং "অনেক" পক্ষ একে অপরের সাথে সামঞ্জস্যপূর্ণ হওয়ার জন্য বীমাটি প্রয়োগ করার সময় অ্যাপ্লিকেশন রানটাইমের সময় সম্পর্কের আপডেট করে ।

Question 3

আমার জন্য কৌশলটি ছিল বহু থেকে বহু সম্পর্ক ব্যবহার করা relationship মনে করুন যে আপনার সত্তা A একটি বিভাগ যা উপ-বিভাগ থাকতে পারে। তারপরে (অপ্রাসঙ্গিক বিশদটি বাদ দেওয়া):

@Entity
@Table(name = "DIVISION")
@EntityListeners( { HierarchyListener.class })
public class Division implements IHierarchyElement {

  private Long id;

  @Id
  @Column(name = "DIV_ID")
  public Long getId() {
        return id;
  }
  ...
  private Division parent;
  private List<Division> subDivisions = new ArrayList<Division>();
  ...
  @ManyToOne
  @JoinColumn(name = "DIV_PARENT_ID")
  public Division getParent() {
        return parent;
  }

  @ManyToMany
  @JoinTable(name = "DIVISION", joinColumns = { @JoinColumn(name = "DIV_PARENT_ID") }, inverseJoinColumns = { @JoinColumn(name = "DIV_ID") })
  public List<Division> getSubDivisions() {
        return subDivisions;
  }
...
}

যেহেতু শ্রেণিবদ্ধ কাঠামোর চারপাশে আমার কিছু বিস্তৃত ব্যবসার যুক্তি ছিল এবং এটি সমর্থন করার জন্য জেপিএ (রিলেশনাল মডেলের উপর ভিত্তি করে) খুব দুর্বল আমি ইন্টারফেস IHierarchyElementএবং সত্তা শ্রোতার সাথে পরিচয় করিয়ে দিয়েছি HierarchyListener:

public interface IHierarchyElement {

    public String getNodeId();

    public IHierarchyElement getParent();

    public Short getLevel();

    public void setLevel(Short level);

    public IHierarchyElement getTop();

    public void setTop(IHierarchyElement top);

    public String getTreePath();

    public void setTreePath(String theTreePath);
}


public class HierarchyListener {

    @PrePersist
    @PreUpdate
    public void setHierarchyAttributes(IHierarchyElement entity) {
        final IHierarchyElement parent = entity.getParent();

        // set level
        if (parent == null) {
            entity.setLevel((short) 0);
        } else {
            if (parent.getLevel() == null) {
                throw new PersistenceException("Parent entity must have level defined");
            }
            if (parent.getLevel() == Short.MAX_VALUE) {
                throw new PersistenceException("Maximum number of hierarchy levels reached - please restrict use of parent/level relationship for "
                        + entity.getClass());
            }
            entity.setLevel(Short.valueOf((short) (parent.getLevel().intValue() + 1)));
        }

        // set top
        if (parent == null) {
            entity.setTop(entity);
        } else {
            if (parent.getTop() == null) {
                throw new PersistenceException("Parent entity must have top defined");
            }
            entity.setTop(parent.getTop());
        }

        // set tree path
        try {
            if (parent != null) {
                String parentTreePath = StringUtils.isNotBlank(parent.getTreePath()) ? parent.getTreePath() : "";
                entity.setTreePath(parentTreePath + parent.getNodeId() + ".");
            } else {
                entity.setTreePath(null);
            }
        } catch (UnsupportedOperationException uoe) {
            LOGGER.warn(uoe);
        }
    }

}