DAO

Panimula sa DAO

Kapag nagtatrabaho sa isang database sa pamamagitan ng JDBC o kahit na sa pamamagitan ng Hibernate, ang code ay madalas na nagiging mas masahol kaysa sa gusto namin. Ang isang query sa database ay kadalasang naglalaman ng:

• pagpapatunay ng datos
• pagtatakda ng mga parameter ng kahilingan
• Pagpili ng query ng HQL depende sa mga parameter ng query
• pagbuo ng query gamit ang Criteria API
• mga setting ng pag-cache
• paunang paghawak ng error, atbp.

Samakatuwid, ang karaniwang kasanayan ay lumikha ng mga espesyal na klase para sa pagtatrabaho sa database. Ang ganitong mga klase ay tinatawag na DAO, Data Access Object. Ang kanilang gawain ay upang itago ang lahat ng mga kumplikado ng pagtatrabaho sa database at magbigay ng isang maganda at maginhawang interface sa labas.

Halimbawa:

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

Mayroon kaming klase na EmployeeDAO , sa tulong kung saan nakakakuha kami ng mga bagay na may uri ng Employee mula sa database. Ang klase mismo, bagama't puno ng mga anotasyon, ay hindi naglalaman ng mga pamamaraan para sa pag-save ng sarili nito sa database.

Mga benepisyo ng DAO

Mayroong maraming mga pakinabang sa pamamaraang ito:

Una, ganap naming itinago ang gawain kasama ang database sa klase ng DAO. Kung magpasya ka sa hinaharap na muling isulat ang lahat ng mga query mula sa HQL patungo sa Criteria API o Native Query, hindi ito makakaapekto sa code sa labas ng klase na ito sa anumang paraan.

Pangalawa, maaari mong gawing kumplikado ang pag-uugali ng mga pamamaraang ito. Maaari kang magdagdag ng caching, mga kaganapan, pagpapatunay ng parameter. Ang lahat ng ito ay itatago mula sa labas ng code.

Pangatlo, kung kailangan mo ng paraan na wala pa, idagdag mo lang dito. Halimbawa, kailangan ko ng paraan na magbabalik sa lahat ng gawain ng user na nag-expire na. Pagkatapos ay gagawin ko lang ito:

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

Nagdagdag ako ng dalawang pamamaraan sa klase:

• getExpiredTasksCount() - ibinabalik ang bilang ng mga nag-expire na gawain para sa user
• getExpiredTasks() - nagbabalik ng listahan ng mga nag-expire na gawain para sa user

Kailangan ko ng mga pamamaraan - idinagdag ko ang mga ito. At magagamit ko ito kaagad. I-optimize ko sila mamaya.

Bukod dito, ang mga pamamaraang ito ay maaaring saklawin ng mga pagsubok sa yunit bago muling isulat at mga pag-optimize, kaya malalaman natin na ang gawain sa database ay nanatiling katulad ng dati.

Pamantayan na Pagdulog

Kadalasan, ang mga klase ng DAO ay may mga pamamaraan na pareho. Halimbawa, ang mga ito:

Ang mga pamamaraang ito ay matatagpuan sa halos bawat klase ng DAO sa mundo. Ngayon, kung mayroong ilang uri ng klase ng DAO, pagkatapos ay may 90% na posibilidad na magkakaroon ito ng mga ganitong pamamaraan.

Oo, maaaring may iba, ngunit magkakaroon din ng mga iyon. Dahil napaka-convenient. At pinapayagan ka nitong huwag makipag-ugnayan sa base o direkta sa Hibernate.

At kung may magkaparehong pamamaraan, ano ang kailangan nila? Tama, ilagay ito sa base class.

Mukhang ganito:

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

At pagkatapos ay magiging ganito ang hitsura ng aming EmployeeDAO :

public class EmployeeDAO extends AbstractHibernateDAO<Employee> {

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

At ang TaskDAO ay ganito:

public class TaskDAO extends AbstractHibernateDAO<Task> {

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

At ang parehong mga klase ay magkakaroon ng lahat ng mga pamamaraan na ipinahayag namin sa AbstractHibernateDAO . Ang pag-iisa ay napaka-maginhawa at praktikal.