DAO

DAO அறிமுகம்

JDBC மூலமாகவோ அல்லது Hibernate மூலமாகவோ தரவுத்தளத்துடன் பணிபுரியும் போது, ​​குறியீடு பெரும்பாலும் நாம் விரும்புவதை விட சிக்கலானதாக மாறிவிடும். ஒரு தரவுத்தள வினவல் பெரும்பாலும் கொண்டுள்ளது:

• தகவல் மதிப்பீடு
• கோரிக்கை அளவுருக்களை அமைத்தல்
• வினவல் அளவுருக்களைப் பொறுத்து HQL வினவல் தேர்வு
• Criteria 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 அல்லது Native Query க்கு அனைத்து வினவல்களையும் மீண்டும் எழுத முடிவு செய்தால், இது இந்த வகுப்பிற்கு வெளியே உள்ள குறியீட்டை எந்த வகையிலும் பாதிக்காது.

இரண்டாவதாக, இந்த முறைகளின் நடத்தையை நீங்கள் சிக்கலாக்கலாம். நீங்கள் கேச்சிங், நிகழ்வுகள், அளவுரு சரிபார்ப்பு ஆகியவற்றைச் சேர்க்கலாம். இவை அனைத்தும் வெளிப்புற குறியீட்டிலிருந்து மறைக்கப்படும்.

மூன்றாவதாக, இதுவரை இல்லாத ஒரு முறை உங்களுக்குத் தேவைப்பட்டால், அதை இங்கே சேர்க்கவும். எடுத்துக்காட்டாக, ஏற்கனவே காலாவதியான அனைத்து பயனர் பணிகளையும் திரும்பப் பெறும் ஒரு முறை எனக்குத் தேவை. பின்னர் நான் இதைச் செய்வேன்:

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();
    }
}

பின்னர் எங்கள் EmployeeDAO இப்படி இருக்கும்:

public class EmployeeDAO extends AbstractHibernateDAO<Employee> {

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

மற்றும் TaskDAO இது போன்றது:

public class TaskDAO extends AbstractHibernateDAO<Task> {

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

இந்த இரண்டு வகுப்புகளிலும் நாம் AbstractHibernateDAO இல் அறிவித்த அனைத்து முறைகளும் இருக்கும் . ஒருங்கிணைப்பு மிகவும் வசதியானது மற்றும் நடைமுறையானது.