一个封装dao层

@SuppressWarnings("unchecked")
public class SimpleHibernateDao<T, PK extends Serializable> {

protected Logger logger = LoggerFactory.getLogger(getClass());

protected SessionFactory sessionFactory;

protected Class<T> entityClass;

/**
* 用于Dao层子类使用的构造函数.
* 通过子类的泛型定义取得对象类型Class.
* eg.
* public class UserDao extends SimpleHibernateDao<User, Long>
*/
public SimpleHibernateDao() {
this.entityClass = ReflectionUtils.getSuperClassGenricType(getClass());
}

/**
* 用于用于省略Dao层, 在Service层直接使用通用SimpleHibernateDao的构造函数.
* 在构造函数中定义对象类型Class.
* eg.
* SimpleHibernateDao<User, Long> userDao = new SimpleHibernateDao<User, Long>(sessionFactory, User.class);
*/
public SimpleHibernateDao(final SessionFactory sessionFactory, final Class<T> entityClass) {
this.sessionFactory = sessionFactory;
this.entityClass = entityClass;
}

public SessionFactory getSessionFactory() {
return sessionFactory;
}

@Resource(name="sessionFactory")
public void setSessionFactory(final SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}

/**
* 取得当前Session.
*/
public Session getSession() {
return sessionFactory.getCurrentSession();
}

/**
* 保存新增或修改的对象.
*/
public void save(final T entity) {
Assert.notNull(entity, "entity不能为空");
getSession().save(entity);
logger.debug("save entity: {}", entity);
}
public void update(final T entity) {
Assert.notNull(entity, "entity不能为空");
getSession().update(entity);
logger.debug("update entity: {}", entity);
}

/**
* 删除对象.
*
* @param entity 对象必须是session中的对象或含id属性的transient对象.
*/
public void delete(final T entity) {
Assert.notNull(entity, "entity不能为空");
getSession().delete(entity);
logger.debug("delete entity: {}", entity);
}

/**
* 按id删除对象.
*/
public void delete(final PK id) {
Assert.notNull(id, "id不能为空");
delete(get(id));
logger.debug("delete entity {},id is {}", entityClass.getSimpleName(), id);
}

/**
* 按id获取对象.
*/
public T get(final PK id) {
Assert.notNull(id, "id不能为空");
return (T) getSession().get(entityClass, id);
}
public void evict(final T entity) {
Assert.notNull(entity, "entity不能为空");
getSession().evict(entity);
logger.debug("evict entity: {}", entity);
}
/**
* 获取全部对象.
*/
public List<T> getAll() {
return find();
}

/**
* 按属性查找对象列表,匹配方式为相等.
*/
public List<T> findBy(final String propertyName, final Object value) {
Assert.hasText(propertyName, "propertyName不能为空");
Criterion criterion = Restrictions.eq(propertyName, value);
return find(criterion);
}

/**
* 按属性查找唯一对象,匹配方式为相等.
*/
public T findUniqueBy(final String propertyName, final Object value) {
Assert.hasText(propertyName, "propertyName不能为空");
Criterion criterion = Restrictions.eq(propertyName, value);
return (T) createCriteria(criterion).uniqueResult();
}

/**
* 按id列表获取对象.
*/
public List<T> findByIds(List<PK> ids) {
return find(Restrictions.in(getIdName(), ids));
}

/**
* 按HQL查询对象列表.
*
* @param values 数量可变的参数,按顺序绑定.
*/
public <X> List<X> find(final String hql, final Object... values) {
return createQuery(hql, values).list();
}

/**
* 按HQL查询对象列表.
*
* @param values 命名参数,按名称绑定.
*/
public <X> List<X> find(final String hql, final Map<String, Object> values) {
return createQuery(hql, values).list();
}

/**
* 按HQL查询唯一对象.
*
* @param values 数量可变的参数,按顺序绑定.
*/
public <X> X findUnique(final String hql, final Object... values) {
return (X) createQuery(hql, values).uniqueResult();
}

/**
* 按HQL查询唯一对象.
*
* @param values 命名参数,按名称绑定.
*/
public <X> X findUnique(final String hql, final Map<String, Object> values) {
return (X) createQuery(hql, values).uniqueResult();
}

/**
* 执行HQL进行批量修改/删除操作.
*/
public int batchExecute(final String hql, final Object... values) {
return createQuery(hql, values).executeUpdate();
}

/**
* 执行HQL进行批量修改/删除操作.
* @return 更新记录数.
*/
public int batchExecute(final String hql, final Map<String, Object> values) {
return createQuery(hql, values).executeUpdate();
}

/**
* 根据查询HQL与参数列表创建Query对象.
*
* 本类封装的find()函数全部默认返回对象类型为T,当不为T时使用本函数.
*
* @param values 数量可变的参数,按顺序绑定.
*/
public Query createQuery(final String queryString, final Object... values) {
Assert.hasText(queryString, "queryString不能为空");
Query query = getSession().createQuery(queryString);
if (values != null) {
for (int i = 0; i < values.length; i++) {
query.setParameter(i, values[i]);
}
}
return query;
}

/**
* 根据查询HQL与参数列表创建Query对象.
*
* @param values 命名参数,按名称绑定.
*/
public Query createQuery(final String queryString, final Map<String, Object> values) {
Assert.hasText(queryString, "queryString不能为空");
Query query = getSession().createQuery(queryString);
if (values != null) {
query.setProperties(values);
}
return query;
}

/**
* 按Criteria查询对象列表.
*
* @param criterions 数量可变的Criterion.
*/
public List<T> find(final Criterion... criterions) {
return createCriteria(criterions).list();
}

/**
* 按Criteria查询唯一对象.
*
* @param criterions 数量可变的Criterion.
*/
public T findUnique(final Criterion... criterions) {
return (T) createCriteria(criterions).uniqueResult();
}

/**
* 根据Criterion条件创建Criteria.
*
* 本类封装的find()函数全部默认返回对象类型为T,当不为T时使用本函数.
*
* @param criterions 数量可变的Criterion.
*/
public Criteria createCriteria(final Criterion... criterions) {
Criteria criteria = getSession().createCriteria(entityClass);
for (Criterion c : criterions) {
criteria.add(c);
}
return criteria;
}

/**
* 初始化对象.
* 使用load()方法得到的仅是对象Proxy, 在传到View层前需要进行初始化.
* 只初始化entity的直接属性,但不会初始化延迟加载的关联集合和属性.
* 如需初始化关联属性,可实现新的函数,执行:
* Hibernate.initialize(user.getRoles())，初始化User的直接属性和关联集合.
* Hibernate.initialize(user.getDescription())，初始化User的直接属性和延迟加载的Description属性.
*/
public void initEntity(T entity) {
Hibernate.initialize(entity);
}

/**
* @see #initEntity(Object)
*/
public void initEntity(List<T> entityList) {
for (T entity : entityList) {
Hibernate.initialize(entity);
}
}

/**
* 为Query添加distinct transformer.
*/
public Query distinct(Query query) {
query.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
return query;
}

/**
* 为Criteria添加distinct transformer.
*/
public Criteria distinct(Criteria criteria) {
criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
return criteria;
}

/**
* 通过Set将不唯一的对象列表唯一化.
* 主要用于HQL/Criteria预加载关联集合形成重复记录,又不方便使用distinct查询语句时.
*/
public <X> List<X> distinct(List list) {
Set<X> set = new LinkedHashSet<X>(list);
return new ArrayList<X>(set);
}

/**
* 取得对象的主键名.
*/
public String getIdName() {
ClassMetadata meta = getSessionFactory().getClassMetadata(entityClass);
return meta.getIdentifierPropertyName();
}
}

只要dao层extends就行了,@Resouce (sessionFactory)注入sessionFactory.
些类一般放在声明式事务中.


/**
* 提供访问私有变量，提取泛型类型Class,提取集合中元素的属性等Utils函数。
*
* @author Allen
*
*/
public class ReflectionUtils {

private static Logger logger = LoggerFactory
.getLogger(ReflectionUtils.class);

/**
* 转换object 到clazz的property类型的值.
*
* @param value 待转换的对象
* @param clazz 提供类型信息的Class
* @param propertyName 提供类型信息的Class的属性.
*/
public static Object convertValue(Object value, Class<?> clazz, String propertyName) {
try {
Class<?> toType = BeanUtils.getPropertyDescriptor(clazz, propertyName).getPropertyType();
DateConverter dc = new DateConverter();
dc.setUseLocaleFormat(true);
dc.setPatterns(new String[] { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss" });
ConvertUtils.register(dc, Date.class);
return ConvertUtils.convert(value, toType);

} catch (Exception e) {
throw convertToUncheckedException(e);
}
}


/**
* 提取集合中的对象的属性(通过getter函数),组合成由分割符分隔的字符串.
*
* @param collection 来源集合.
* @param propertyName 要提取的属性名.
* @param separator 分隔符.
*/
@SuppressWarnings("unchecked")
public static String fetchElementPropertyToString(final Collection collection,final String propertyName,final String separator)
{
List list=fetchElementPropertyToList(collection, propertyName);
return StringUtils.join(list, separator);
}


/**
* 提取集合中的对象的属性(通过getter函数),组合成List.
*
* @param collection 来源集合.
* @param propertyName 要提取的属性名.
*
*/
@SuppressWarnings("unchecked")
public static List fetchElementPropertyToList(final Collection collection,final String propertyName)
{
List list=new ArrayList();

for(Object obj:collection)
{
try {
list.add(PropertyUtils.getProperty(obj, propertyName));
} catch (Exception e) {
e.printStackTrace();
convertToUncheckedException(e);

}
}
return list;
}

/**
* 将反射时的checked exception转换为unchecked exception.
*/
public static IllegalArgumentException convertToUncheckedException(Exception e)
{
if(e instanceof IllegalAccessException|| e instanceof IllegalArgumentException||e instanceof NoSuchMethodException)
{
return new IllegalArgumentException("Refelction Exception.",e);

}
else
return new IllegalArgumentException(e);
}


/**
* 通过反射,获得Class定义中声明的父类的泛型参数的类型.
* eg.
* public UserDao extends HibernateDao<User>
*
* @param clazz The class to introspect
* @return the first generic declaration, or Object.class if cannot be determined
*/
@SuppressWarnings("unchecked")
public static <T> Class<T> getSuperClassGenricType(final Class clazz)
{
return getSuperClassGenricType(clazz,0);
}

/**
* 通过反射,获得定义Class时声明的父类的泛型参数的类型.
*
* 如public UserDao extends HibernateDao<User,Long>
*
* @param clazz clazz The class to introspect
* @param index the Index of the generic declaration,start from 0.
* @return the index generic declaration, or Object.class if cannot be determined
*/
@SuppressWarnings("unchecked")
public static Class getSuperClassGenricType(final Class clazz,final int index)
{
Type genType=clazz.getGenericSuperclass();//注意由于只有一个父类，所以这么写

//如果不是参数化类型，则返回Object.class
if(!(genType instanceof ParameterizedType))
{
logger.warn(clazz.getSimpleName()+"'s superclass not ParameterizedType");
return Object.class;
}

//可能有多个参数，所以这么写
Type[] params=((ParameterizedType)genType).getActualTypeArguments();

if(index>=params.length||index<0){
logger.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
+ params.length);
return Object.class;
}

//如果是基本类型,如int
if (!(params[index] instanceof Class)) {
logger.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
return Object.class;
}

return (Class)params[index];
}






public static Object invokeMethod(final Object object,final String methodName,final Class<?>[] parameterTypes,
final Object[] parameters)throws InvocationTargetException{
Method method=getDeclaredMethod(object,methodName,parameterTypes);

if(method==null)
throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + object + "]");

method.setAccessible(true);

try {
return method.invoke(object, parameters);
} catch (IllegalAccessException e) {

e.printStackTrace();
logger.error("不可能抛出的异常:{}", e.getMessage());
}
return null;
}

/**
* 循环向上转型，获取对象的DeclaredMethod.
* @param object
* @param methodName
* @param parameterTypes
* @return
*/
protected static Method getDeclaredMethod(Object object,String methodName,Class<?>[] parameterTypes)
{
Assert.notNull(object,"object不能为空");

for(Class<?> superClass=object.getClass();superClass!=Object.class;superClass=superClass.getSuperclass())
{
try {
return superClass.getDeclaredMethod(methodName, parameterTypes);
}
catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
return null;
}



/**
* 直接设置对象属性值，无视private/protected修饰符，不经过setter函数。
* @param object
* @param fieldName
* @param value
*/
public static void setFieldValue(final Object object,final String fieldName,final Object value)
{
Field field=getDeclaredField(object, fieldName);

if(field==null)
throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");

makeAccessible(field);

try {
field.set(object, value);
} catch (IllegalAccessException e) {
e.printStackTrace();
logger.error("不可能抛出的异常：{}",e.getMessage());
}
}

/**
* 直接读取对象属性值，不管private/protected修饰符，不经过getter函数。
*
* @param object
* @param fieldName
* @return
*/
public static Object getFieldValue(final Object object,
final String fieldName) {
Field field = getDeclaredField(object, fieldName);

if (field == null)
throw new IllegalArgumentException("Could not find field ["
+ fieldName + "] on target [" + object + "]");

makeAccessible(field);

Object result = null;
try {
result = field.get(object);
} catch (IllegalAccessException e) {
e.printStackTrace();
logger.error("不可能抛出的异常{}", e.getMessage());
}
return result;

}

/**
* 循环向上转型，获取对象的DeclaredField.
*
* @param field
*/
protected static void makeAccessible(final Field field) {
if (!Modifier.isPublic(field.getModifiers())
|| !Modifier.isPublic(field.getDeclaringClass().getModifiers()))
field.setAccessible(true);

}

/**
* 循环向上转型，获取对象的DeclaredField.
*
* @param object
* @param fieldName
* @return
*/
protected static Field getDeclaredField(final Object object,
final String fieldName) {
Assert.notNull(object, "object不能为空");
// 必须有东西，null和"  "均不可++
Assert.hasText(fieldName, "必须指定fieldName");

// 找不到时从父类里去找。
for (Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass
.getSuperclass()) {
try {
return superClass.getDeclaredField(fieldName);
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
}
return null;
}

}