DAO

DAO పరిచయం

JDBC ద్వారా లేదా హైబర్‌నేట్ ద్వారా డేటాబేస్‌తో పని చేస్తున్నప్పుడు, కోడ్ తరచుగా మనం కోరుకునే దానికంటే ఎక్కువ గజిబిజిగా మారుతుంది. డేటాబేస్ ప్రశ్న తరచుగా వీటిని కలిగి ఉంటుంది:

• సమాచారం ప్రామాణీకరణ
• అభ్యర్థన పారామితులను సెట్ చేయడం
• ప్రశ్న పారామితులపై ఆధారపడి HQL ప్రశ్న ఎంపిక
• క్రైటీరియా APIని ఉపయోగించి ప్రశ్నను నిర్మిస్తోంది
• కాషింగ్ సెట్టింగ్‌లు
• ప్రారంభ లోపం నిర్వహణ, మొదలైనవి.

అందువల్ల, డేటాబేస్తో పనిచేయడానికి ప్రత్యేక తరగతులను సృష్టించడం సాధారణ అభ్యాసం. ఇటువంటి తరగతులను DAO, డేటా యాక్సెస్ ఆబ్జెక్ట్ అంటారు. వారి పని డేటాబేస్తో పని చేసే అన్ని సంక్లిష్టతలను దాచడం మరియు వెలుపల అందమైన మరియు అనుకూలమైన ఇంటర్ఫేస్ను అందించడం.

ఉదాహరణ:

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 నుండి క్రైటీరియా 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();
    }
}

ఆపై మా 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 లో మేము ప్రకటించిన అన్ని పద్ధతులను కలిగి ఉంటాయి . ఏకీకరణ చాలా అనుకూలమైనది మరియు ఆచరణాత్మకమైనది.