DAO

DAO चा परिचय

JDBC द्वारे किंवा हायबरनेट द्वारे डेटाबेससह काम करताना, कोड बर्‍याचदा आपल्या इच्छेपेक्षा अधिक अवजड असल्याचे दिसून येते. डेटाबेस क्वेरीमध्ये सहसा हे समाविष्ट असते:

• माहितीचे वैधीकरण
• विनंती पॅरामीटर्स सेट करणे
• क्वेरी पॅरामीटर्सवर अवलंबून HQL क्वेरी निवड
• निकष API वापरून क्वेरी तयार करणे
• कॅशिंग सेटिंग्ज
• प्रारंभिक त्रुटी हाताळणी इ.

म्हणून, डेटाबेससह कार्य करण्यासाठी विशेष वर्ग तयार करणे ही सामान्य पद्धत आहे. अशा वर्गांना DAO, Data Access Object असे म्हणतात. डेटाबेससह कार्य करण्याच्या सर्व गुंतागुंत लपविणे आणि बाहेरून एक सुंदर आणि सोयीस्कर इंटरफेस प्रदान करणे हे त्यांचे कार्य आहे.

उदाहरण:

public class EmployeeDAO {

   public List<Employee> getEmployeeList(int from, int count) {
   	String hqlQuery = “from Employee”;
   	Query<Employee> query = session.createQuery(hqlQuery, Employee.class);
   	query.setFirstResult(from);
   	query.setMaxResults(count);
   	return query.getResultList();
  }

	public int getEmployeeCount() {
	     String hqlQuery = “select count(*) from Employee”;
     	Query<Integer> query = session.createQuery(hqlQuery, Integer.class);
     	return query.getSingleResult();
   }

	public Employee getEmployeeByUniqName(String name) {
	     String hqlQuery = “from Employee where name = :name”;
     	Query<Integer> query = session.createQuery(hqlQuery, Employee.class);
     	query.setParameterr(“name”, name);
     	return query.getSingleResult();
   }
}

आमच्याकडे EmployeeDAO वर्ग आहे , ज्याच्या मदतीने आम्ही डेटाबेसमधून कर्मचारी प्रकारातील वस्तू मिळवतो. वर्ग स्वतःच, जरी भाष्यांनी भरलेला असला तरी, डेटाबेसमध्ये स्वतःला जतन करण्याच्या पद्धतींचा समावेश नाही.

DAO चे फायदे

या पद्धतीचे बरेच फायदे आहेत:

प्रथम, आम्ही DAO वर्गातील डेटाबेससह कार्य पूर्णपणे लपवले आहे. तुम्ही भविष्यात HQL ते Criteria API किंवा नेटिव्ह क्वेरीवर सर्व क्वेरी पुन्हा लिहिण्याचे ठरविल्यास, याचा या वर्गाच्या बाहेरील कोडवर कोणत्याही प्रकारे परिणाम होणार नाही.

दुसरे म्हणजे, आपण या पद्धतींचे वर्तन गुंतागुंत करू शकता. तुम्ही कॅशिंग, इव्हेंट्स, पॅरामीटर प्रमाणीकरण जोडू शकता. हे सर्व बाहेरील कोडपासून लपवले जाईल.

तिसरे म्हणजे, तुम्हाला अद्याप अस्तित्वात नसलेली पद्धत हवी असल्यास, तुम्ही ती येथे जोडा. उदाहरणार्थ, मला अशी पद्धत हवी आहे जी आधीच कालबाह्य झालेली सर्व वापरकर्ता कार्ये परत करेल. मग मी फक्त हे करेन:

public class EmployeeDAO {

   public List<Task> getExpiredTasks(int userId, int from, int count) {
   	String hqlQuery = “from Task where task.user.id = :id and deadline < curdate()”;
   	Query<Task> query = session.createQuery(hqlQuery, Task.class);
   	query.setFirstResult(from);
   	query.setMaxResults(count);
   	return query.getResultList();
  }

   public int getExpiredTasksCount(int userId) {
   	String hqlQuery = “select count(*) from Task where task.user.id = :id and deadline < curdate()”;
   	Query<Integer> query = session.createQuery(hqlQuery, Integer.class);
   	return query.getSingleResult();
  }
}

मी वर्गात दोन पद्धती जोडल्या:

• getExpiredTasksCount() - वापरकर्त्यासाठी कालबाह्य झालेल्या कार्यांची संख्या परत करते
• getExpiredTasks() - वापरकर्त्यासाठी कालबाह्य झालेल्या कार्यांची सूची परत करते

मला पद्धती आवश्यक आहेत - मी त्या जोडल्या. आणि मी ते लगेच वापरू शकतो. मी त्यांना नंतर ऑप्टिमाइझ करेन.

शिवाय, या पद्धती पुनर्लेखन आणि ऑप्टिमायझेशनपूर्वी युनिट चाचण्यांसह कव्हर केल्या जाऊ शकतात, त्यामुळे आम्हाला कळेल की डेटाबेससह कार्य जसे होते तसेच राहिले आहे.

मानक दृष्टीकोन

बर्‍याचदा, DAO वर्गांमध्ये समान पद्धती असतात. उदाहरणार्थ, हे:

या पद्धती जगातील जवळजवळ प्रत्येक DAO वर्गात आढळतात. आता, जर काही प्रकारचे DAO वर्ग असेल, तर 90% संभाव्यतेसह अशा पद्धती असतील.

होय, इतर असू शकतात, परंतु ते देखील असतील. कारण ते खूप सोयीचे आहे. आणि हे तुम्हाला बेस किंवा हायबरनेटशी थेट संवाद साधण्याची परवानगी देते.

आणि जर एकसारख्या पद्धती असतील तर त्यांना काय आवश्यक आहे? बरोबर आहे, बेस क्लासमध्ये टाका.

हे असे काहीतरी दिसते:

public abstract class AbstractHibernateDao<T > {
    private final Class<T> clazz;
    private SessionFactory sessionFactory;

    public AbstractHibernateDao(final Class<T> clazzToSet)   {
    	this.clazz = clazzToSet;
    }

    public T getById(final long id) {
    	return (T) getCurrentSession().get(clazz, id);
    }

    public List<T> getItems(int from, int count) {
    	Query query = getCurrentSession().createQuery(clazz , "from " + clazz.getName())
    	query.setFirstResult(offset);
    	query.setMaxResults(count);
  	  return query.singleResult();
    }

    public List<T> findAll() {
    	return getCurrentSession().createQuery(clazz, "from " + clazz.getName()).list();
    }

    public T create(final T entity) {
    	getCurrentSession().saveOrUpdate(entity);
    	return entity;
    }

    public T update(final T entity) {
    	return (T) getCurrentSession().merge(entity);
    }

    public void delete(final T entity) {
    	getCurrentSession().delete(entity);
    }

    public void deleteById(final long entityId) {
    	final T entity = getById(entityId);
    	delete(entity);
    }

    protected Session getCurrentSession() {
    	return sessionFactory.getCurrentSession();
    }
}

आणि मग आमचे कर्मचारी DAO असे दिसेल:

public class EmployeeDAO extends AbstractHibernateDAO<Employee> {

   public EmployeeDAO (){
  	super(Employee.class );
   }
}

आणि TaskDAO असे आहे:

public class TaskDAO extends AbstractHibernateDAO<Task> {

   public TaskDAO (){
  	super(Task.class );
   }
}

आणि या दोन्ही वर्गांमध्ये आम्ही AbstractHibernateDAO वर घोषित केलेल्या सर्व पद्धती असतील . एकीकरण अतिशय सोयीस्कर आणि व्यावहारिक आहे.