సోమరితనం లోడ్ అవుతోంది

1.1 సమస్య నేపథ్యం

మీరు నిజమైన డేటాబేస్‌లతో పని చేయడం ప్రారంభించినప్పుడు, "అకాల ఆప్టిమైజేషన్ అన్ని చెడులకు మూలం" అనే పదబంధాన్ని మీరు వెంటనే గుర్తుంచుకుంటారు. ఇప్పుడు మాత్రమే మీరు ఆమెను ప్రతికూలంగా గుర్తుంచుకుంటారు. డేటాబేస్తో పని చేస్తున్నప్పుడు, ఆప్టిమైజేషన్ ఎంతో అవసరం. మరియు మీరు డిజైన్ దశలో ఇప్పటికే దానితో పని చేయాలి.

హైబర్నేట్ డేటాబేస్తో పని చేయడం చాలా సౌకర్యవంతంగా చేస్తుంది. సరిగ్గా ఉల్లేఖించడం ద్వారా మీరు ఏవైనా పిల్లల వస్తువులను సులభంగా పొందవచ్చు @OneToManyమరియు @ManyToMany. ఉదాహరణ:

@Entity
@Table(name="user")
class User {
   @Column(name="id")
   public Integer id;

   @OneToMany(cascade = CascadeType.ALL)
   @JoinColumn(name = "user_id")
   public List<Comment> comments;
}

మరియు వినియోగదారు వ్యాఖ్యలను పొందడం ఎంత సులభం:

User user = session.get(User.class, 1);
List<Comment> comments = user.getComments();

మరియు మీరు ఒక పెద్ద ఆశ్చర్యానికి లోనవుతారు. వినియోగదారు అనేక వేల వ్యాఖ్యలను కలిగి ఉన్నారు. మీరు ఇలా కోడ్‌ని వ్రాస్తే, హైబర్‌నేట్ ఖచ్చితంగా యూజర్ యొక్క అన్ని వ్యాఖ్యలను లోడ్ చేస్తుంది. కానీ ఇది చాలా నెమ్మదిగా ఉంటుంది, వ్యాఖ్యలు చాలా మెమరీని తీసుకుంటాయి మరియు మొదలైనవి.

అందుకే అలా రాయలేం కదా! సిద్ధాంతంలో, అవును, కానీ ఆచరణలో, కాదు.

1.2 సేకరణలతో పరిస్థితిని మరింత దిగజార్చడం

సమస్య మరింత ఆసక్తికరంగా ఉంది. అన్నింటికంటే, సాధారణంగా మీకు అన్ని వినియోగదారు వ్యాఖ్యలు అవసరం లేదు. మీరు వాటిని క్లయింట్‌లో ఎక్కడో ప్రదర్శించినప్పటికీ, మీరు దీన్ని భాగాలు - పేజీలలో చేయడానికి ఇష్టపడతారు.

కాబట్టి మీకు ఇలాంటి పద్ధతులు అవసరం:

public class CommentsManager {
    private static final PAGE_SIZE = 50;

    public List<Comment> getCommentsPage(int userId, int pageIndex){
     	User user = session.get(User.class, userId);
     	List<Comment> comments = user.getComments();
     	return comments.subList(pageIndex * PAGE_SIZE, PAGE_SIZE);
    }

   public int getCommentsPageCount(int userId)   {
     	User user = session.get(User.class, userId);
     	List<Comment> comments = user.getComments();
     	return Math.ceil(  comments.size()/PAGE_SIZE);
   }

}

మొదటి పద్ధతి వ్యాఖ్యల యొక్క ఒక పేజీని మాత్రమే అందిస్తుంది - 50 ముక్కలు. రెండవ పద్ధతి వ్యాఖ్యల పేజీల సంఖ్యను అందిస్తుంది. మరియు ఇది చెత్త. వ్యాఖ్యల సంఖ్యను తెలుసుకోవడానికి, మీరు డేటాబేస్ నుండి అన్ని వ్యాఖ్యలను డౌన్‌లోడ్ చేసుకోవాలి!

1.3 సొరంగం చివర కాంతి

అందువల్ల, మా అద్భుతమైన పిల్లల సేకరణలను ఎవరూ ఉపయోగించరు. లేదు, వాస్తవానికి అవి ఉపయోగించబడతాయి, కానీ HQL ప్రశ్నలలో భాగంగా మాత్రమే. ఉదాహరణకు ఇలా:

public class CommentsManager {
      private static final PAGE_SIZE = 50;

       public List<Comment> getCommentsPage(int userId, int pageIndex){
           	String hql = "select comments from User where id = :id";
           	Query<Comment> query = session.createQuery( hql, Comment.class);
           	query.setParametr("id", userId);
           	query.setOffset(pageIndex * PAGE_SIZE);
           	query.setLimit(PAGE_SIZE);
           	return query.list();
      }

      public int getCommentsPageCount(int userId)   {
           	String hql = "select count(comments) from User where id = :id";
           	Query<Integer> query = session.createQuery( hql, Integer.class);
           	query.setParametr("id", userId);
           	return Math.ceil(query.singleResult()/PAGE_SIZE);
     }

}

శుభవార్త ఏమిటంటే, మేము డేటాబేస్ నుండి అదనపు డేటాను లోడ్ చేయవలసిన అవసరం లేని విధంగా మా పద్ధతులను అమలు చేయవచ్చు. చెడు వార్త ఏమిటంటే, మా కలెక్షన్లతో పని చేయడం అంత సులభం కాదు.