इकाई मैपिंग सेटिंग

Question

के बिना एकाधिक तालिकाओं से डेटा पुनर्प्राप्त करने के लिए हाइबरनेट मानदंड का उपयोग करना मुझे अपनी परियोजना में कोई समस्या है। मैं उपयोगकर्ता तालिका से उपयोगकर्ताओं को खोजने के लिए एक खोज फ़ंक्शन बनाने की कोशिश कर रहा हूं, लेकिन इसी दौरान, मैं किसी अन्य अवतार तालिका से उपयोगकर्ता के अवतार के संबंधित "url" को भी पुनर्प्राप्त करना चाहता हूं। मैं इन दो तालिकाओं के बीच एक कठिन मैपिंग बनाना चाहता हूं। हाइबरनेट मानदंड का उपयोग करके मैं इसे लचीला रूप से कैसे कर सकता हूं? दोनों टेबल "loginID" की प्राथमिक कुंजी का उपयोग कर रहे हैं।

public class User{ 
    private String loginID; 
    private String screenname; 
    ...... 
} 
public class Avatar{ 
    private Integer id; 
    private String loginID; 
    private String url; 
    ....... 
} 

मैं क्या लिखा है:

मैं दो वर्गों है

public List<Users> searchLogin(String keywords, int startFrom) { 
     List<Users> userList = new ArrayList<Users>(); 
     try { 
      Session session = HibernateUtil.beginTransaction(); 
      Criteria criteria = session.createCriteria(Users.class,"users"); 
      criteria.add(Restrictions.ilike("loginID", keywords, MatchMode.ANYWHERE)); 
      userList = criteria.list(); 
      if (session.isOpen()) { 
       session.close(); 
      } 
      return userList; 
     } catch (Exception e) { 
      e.printStackTrace(); 
      return null; 
     } 
    } 

धन्यवाद लोग !!

Answer 1

उपयोग HQL

from User u,Avatar a where where u.loginID = a.loginID and u.loginID = :loginID 

यह [उपयोगकर्ता, अवतार] सरणियों की एक सूची वापस आ जाएगी।

Answer 2

दोनों टेबल "loginID" की प्राथमिक कुंजी का उपयोग कर रहे हैं।

क्या यह सही है? मैं Avatar कक्षा को 'id' नामक फ़ील्ड वाला देखता हूं, क्या यह आईडी/प्राथमिक कुंजी नहीं है?

मैंने यह भी देखा कि फ़ील्ड का उपयोग करके आप Avatar से User देखें। इकाइयों को जोड़ने का एक सही तरीका उनकी कक्षा से है। टिप्पणियों का उपयोग करने में यह इस तरह दिखना चाहिए:

@Entity 
public class User 
{ 
    @Id 
    private String loginId; 
    private String screenName; 
    @OneToOne(mappedBy = "user") 
    private Avatar avatar; 
} 

@Entity 
public class Avatar 
{ 
    @Id 
    private Integer id; 
    @OneToOne 
    private User user; 
    private String url; 
} 

आप तो एक User और AvatarUser सबसे अच्छी बात आप कर सकते हैं से संबंधित होने के URL को प्राप्त करने के लिए लाने के एक User चाहते हैं और यह Avatar एक में शामिल होने का उपयोग कर और फिर Avatar के यूआरएल तक पहुंचें और इस प्रकार Object से User और Avatar को संरक्षित प्रकार की सुरक्षा से नहीं डालना है।

User user = fetchUserJoinAvatar("123"); 
String url = user.getAvatar().getUrl(); 

public User fetchUserJoinAvatar(String loginId) 
{ 
    CriteriaBuilder cb = em.getCriteriaBuilder(); 
    CriteriaQuery<User> query = cb.createQuery(User.class); 

    Root<User> user = query.from(User.class); 
    user.fetch("avatar"); 
    query.select(user).where(cb.equal(user.get("loginId"), loginId)); 
    return em.createQuery(query).getSingleResult(); 
} 

Answer 3

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

ऐसे करें:

CriteriaBuilder builder = em.getCriteriaBuilder(); 
    CriteriaQuery<Tuple> criteria = builder.createTupleQuery(); 
    Root<EntityA> entityARoot= criteria.from(EntityA.class); 
    Root<EntityB> entityBRoot = criteria.from(EntityB.class); 

    //Predicates 
    List<Predicate> predicates = new ArrayList<>(); 
    //Add the predicates you need 

    //And predicates 
    List<Predicate> andPredicates = new ArrayList<>(); 
    andPredicates.add(builder.equal(entityARoot.get("id"), entityBRoot.get("id"))); 
    andPredicates.add(builder.and(predicates.toArray(new Predicate[0]))); 

    criteria.multiselect(entityARoot, entityBRoot); 
    criteria.where(andPredicates.toArray(new Predicate[0])); 

    TypedQuery<Tuple> query = em.createQuery(criteria); 

    List<Tuple> result = query.getResultList();