basicbizimpl.java

JAVA权限管理

package org.common.biz.impl;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;

import org.common.biz.IBasicBiz;
import org.common.util.PageResult;
import org.common.util.Pagination;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.springframework.dao.DataAccessException;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

@SuppressWarnings("unchecked")
public class BasicBizImpl<T extends Serializable, PK extends Serializable> extends
		HibernateDaoSupport implements IBasicBiz<T, PK> {

	// 实体类类型(由构造方法自动赋值)
	private Class<T> entityClass; 

	// 构造方法，根据实例类自动获取实体类类型
	public BasicBizImpl() {
	
		this.entityClass = null;
		Class c = getClass();
		Type t = c.getGenericSuperclass();// 返回表示此 Class 所表示的实体（类、接口、基本类型或
		// void）的直接超类的 Type。
		if (t instanceof ParameterizedType)// ParameterizedType 表示参数化类型，如
		// Collection<String>。
		{
			Type[] p = ((ParameterizedType) t).getActualTypeArguments();// getActualTypeArguments()方法获得实际绑定的类型
			this.entityClass = (Class<T>) p[0];
		}
	}

	// -------------------- 基本检索、增加、修改、删除操作 --------------------

	// 根据主键获取实体。如果没有相应的实体，返回 null。
	public T get(PK id) throws DataAccessException {
		return (T) getHibernateTemplate().get(entityClass, id);
		
	}

	// 根据主键获取实体。如果没有相应的实体，抛出异常。
	public T load(PK id) throws DataAccessException {
		return (T) getHibernateTemplate().load(entityClass, id);
	}

	// 获取全部实体。
	public List<T> loadAll() throws DataAccessException {
		return (List<T>) getHibernateTemplate().loadAll(entityClass);
	}

	// 更新实体
	public void update(T entity) throws DataAccessException {
		getHibernateTemplate().update(entity);
	}

	// 根据主键更新指定实体
	public void updateByKey(PK id) throws DataAccessException {
		getHibernateTemplate().update(this.get(id));
	}

	// 存储实体到数据库
	public int add(T entity) throws DataAccessException {

		return (Integer) super.getHibernateTemplate().save(entity);
	}

	// 删除指定的实体
	public void delete(T entity) throws DataAccessException {
		getHibernateTemplate().delete(entity);
	}

	// 根据主键删除指定实体
	public void deleteByKey(PK id) throws DataAccessException {
		this.delete(this.get(id));
	}

	// 删除集合中的全部实体
	// public void deleteAll(Collection<T> entities) {
	// getHibernateTemplate().deleteAll(entities);
	// }
	// 根据对象查询所需的数据
	public Criteria search(T entity) throws DataAccessException {
		Example example = Example.create(entity).excludeZeroes() // 排除值为0的属性
				.ignoreCase() // 忽略大小写
				.enableLike(); // 启用模糊查询
		return getSession().createCriteria(entityClass).add(example);
	}

	// 分页
	/**
	 * 功能实现分页
	 * 
	 * 使用Query
	 * 
	 * PageBean condition分页类(其属性指定要显示的页面与行数)
	 * 
	 * String hql condition 表示要查询的条件
	 * 
	 * Query 对象查询类 (此类封装了查询所需要的大部份操作)
	 * 
	 * 指定排序方法类 Order order(可根据要的列名进行 升序 降序)
	 */
	public PageResult searchPagination(PageResult condition, String hql)
			throws DataAccessException {
		try {
			Query query = getSession().createQuery(hql);
			if (null != query && null != condition) {
				int firstResultIndex = (condition.getPageNo() - 1)
						* condition.getPageSize();
				if (0 < condition.getPageNo())
					query.setFirstResult(firstResultIndex);
				/** 表示从第几行开始返回查询到的数据 */
				if (0 < condition.getPageSize())
					query.setMaxResults(condition.getPageSize());
				/** 表示设置返回多少行 */
			}
			condition.setList(query.list());
			/** 将查询到的数据封装在集合中返回 */
			return condition;
		} catch (RuntimeException re) {
			throw re;
		}
	}

	/**
	 * 功能实现分页
	 * 
	 * 使用Criteria
	 * 
	 * Class clz 表示类的实例(实体类通过实体类名.class得到实例)
	 * 
	 * Object condition 表示要查询的条件
	 * 
	 * Criteria c 接口特定持久类的一个查询(此类采用面向对象方式封装查询条件)
	 * 
	 * 指定排序方法类 Order order(可根据要的列名进行 升序 降序)
	 */
	public PageResult searchPagination(Criteria c, PageResult condition,
			Order order) throws DataAccessException {
		try {
			if (null != c && null != condition) {
				int firstResultIndex = (condition.getPageNo() - 1)
						* condition.getPageSize();
				if (0 < condition.getPageNo())
					c.setFirstResult(firstResultIndex);
				/** 表示从第几行开始返回查询到的数据 */
				if (0 < condition.getPageSize())
					c.setMaxResults(condition.getPageSize());
				/** 表示设置返回多少行 */
			}
			/***/
			condition.setList(c.addOrder(order).list());
			/** 将查询到的数据封装在集合中返回 */
			return condition;
		} catch (RuntimeException re) {
			throw re;
		}

	}

	// 使用指定的检索标准检索数据，返回部分记录 (分页)
	public List<T> search(Object exampleEntity, int firstResult, int maxResults)
			throws DataAccessException {
		// TODO Auto-generated method stub
		return getHibernateTemplate().findByExample(exampleEntity, firstResult,
				maxResults);
	}

	/**
	 * 
	 * 返还查询结果的数目
	 * 
	 * String className 查询的类名
	 */
	protected int getResultSize(String className) throws DataAccessException {
		try {
			String hql = "SELECT count(*) FROM " + className;
			/** 当查询的数据只有一条时可以用uniqueResult（）方法获取结果 */
			return (Integer) getSession().createQuery(hql).uniqueResult();
		} catch (RuntimeException re) {
			throw re;
		}
	}

	// 获取全部实体。
	public List<T> loadAll(Class TClass) throws DataAccessException {
		// TODO Auto-generated method stub
		return getHibernateTemplate().loadAll(entityClass);
	}

	// 根据DetachedCriteria来构造查询条件,然后将这个DetachedCriteria作为方法调用参数传递给业务层对象
	// 返回查询后的结果集
	public List<T> search(DetachedCriteria detachedCriteria) {
		// TODO Auto-generated method stub
		return detachedCriteria.getExecutableCriteria(super.getSession())
				.list();
	}

	// 模糊查询后当前页列表
	@SuppressWarnings("unchecked")
	public List<T> findRowsByCriteria(DetachedCriteria detachedCriteria,
			int first, int max) {
		// TODO 自动生成方法存根
		return getHibernateTemplate().findByCriteria(detachedCriteria, first,
				max);

	}

	/**
	 * find totalCount by detachedCriteria
	 */

	// 模糊查询后的所有数据总数
	public int findCountByCriteria(DetachedCriteria detachedCriteria) {
		// TODO 自动生成方法存根
		detachedCriteria.setProjection(Projections.rowCount());
		System.out.println(getHibernateTemplate().findByCriteria(
				detachedCriteria));
		return (Integer) getHibernateTemplate()
				.findByCriteria(detachedCriteria).get(0);
	}
	
	public List<T> find(String hql,T entity) throws DataAccessException {
		return getHibernateTemplate().find(hql, entity);
	}
	public List<T>find(String hql)throws DataAccessException {
		return getHibernateTemplate().find(hql);
	}

}