aramzamzam-commons/commons-hibernate/src/main/java/net/aramzamzam/commons/hibernate/dao/GenericHibernateDAO.java

   1 package net.aramzamzam.commons.hibernate.dao;
   2
   3 import java.io.Serializable;
   4 import java.lang.reflect.ParameterizedType;
   5 import java.util.List;
   6
   7 import net.aramzamzam.commons.hibernate.utils.AssociationExample;
   8
   9 import org.apache.tapestry5.hibernate.HibernateSessionManager;
  10 import org.hibernate.Criteria;
  11 import org.hibernate.Session;
  12 import org.hibernate.criterion.Criterion;
  13 import org.hibernate.criterion.Example;
  14
  15 /** DAO pattern from "Generic Data Access Objects": http://www.hibernate.org/328.html*/
  16 public class GenericHibernateDAO<T, ID extends Serializable>
  17                 implements GenericDAO<T, ID> {
  18
  19         private Class<T> persistentClass;
  20         private final HibernateSessionManager sessionManager;
  21
  22         @SuppressWarnings("unchecked")
  23         public GenericHibernateDAO(HibernateSessionManager sessionManager){
  24                 this.persistentClass = (Class<T>) ((ParameterizedType) getClass()
  25                                 .getGenericSuperclass()).getActualTypeArguments()[0];
  26                 this.sessionManager = sessionManager;
  27         }
  28
  29         protected Session getSession() {
  30                 return sessionManager.getSession();
  31         }
  32
  33         public Class<T> getPersistentClass() {
  34                 return persistentClass;
  35         }
  36
  37         public List<T> findAll() {
  38                 return findByCriteria();
  39         }
  40
  41         /**
  42          * Finds list of entities by example
  43          * @param <X>
  44          *      entity class
  45          * @param exampleInstance
  46          *      entity instance
  47          * @param includeAssociations
  48          *      include associations in search
  49          * @param excludeProperty
  50          *      array of excluded properties
  51          * @return
  52          *      list of founded entites (nulls and zero properties are expluded)
  53          */
  54         @SuppressWarnings("unchecked")
  55         public <X extends T> List<X> findByExample(X exampleInstance, boolean includeAssociations,  String... excludeProperty) {
  56                 Criteria crit = getSession().createCriteria(exampleInstance.getClass());
  57                 Criterion example;
  58                 if (includeAssociations)
  59                 {
  60                         AssociationExample e = AssociationExample.create(exampleInstance);
  61                         e.setIncludeAssociations(true);
  62                         for (String exclude : excludeProperty)
  63                                 e.excludeProperty(exclude);
  64                         example=e;
  65                 }
  66                 else
  67                 {
  68                         Example e = Example.create(exampleInstance);
  69                         for (String exclude : excludeProperty)
  70                                 e.excludeProperty(exclude);
  71                         example=e;
  72                 }
  73                 crit.add(example);
  74                 return crit.list();
  75         }
  76
  77         public <X extends T> List<X> findByExample(X exampleInstance) {
  78                 return findByExample(exampleInstance,false, new String[0]);
  79         }
  80
  81         public T makePersistent(T entity) {
  82                 getSession().saveOrUpdate(entity);
  83                 return entity;
  84         }
  85
  86         public void makeTransient(T entity) {
  87                 getSession().delete(entity);
  88         }
  89
  90         public void flush() {
  91                 getSession().flush();
  92         }
  93
  94         public void clear() {
  95                 getSession().clear();
  96         }
  97
  98         /**
  99          * Use this inside subclasses as a convenience method.
 100          */
 101         @SuppressWarnings("unchecked")
 102         protected List<T> findByCriteria(Criterion... criterion) {
 103                 Criteria crit = getSession().createCriteria(getPersistentClass());
 104                 for (Criterion c : criterion) {
 105                         crit.add(c);
 106                 }
 107                 return crit.list();
 108         }
 109
 110         /**
 111          * returns null, if entity was not found
 112          * @param id
 113          *      entity id
 114          * @return
 115          */
 116         @SuppressWarnings("unchecked")
 117         public T findById(ID id) {
 118                 return (T) getSession().get(getPersistentClass(), id);
 119         }
 120
 121         /**
 122          * returns null, if entity was not found
 123          * @param id
 124          *      entity id
 125          * @param entityClass
 126          *      entity class
 127          * @return
 128          */
 129         @SuppressWarnings("unchecked")
 130         public <X extends T> X findById(ID id, Class<X> entityClass) {
 131                 return (X) getSession().get(entityClass, id);
 132         }
 133
 134 }