DAO和Service公共抽象接口实现

1、分页帮助类

 

public class Page<T> {
	//-- 公共变量 --//
	public static final String ASC = "asc";
	public static final String DESC = "desc";

	//-- 分页参数 --//
	protected int pageNo = 1;
	protected int pageSize = -1;
	protected String orderBy = null;
	protected String order = null;
	protected boolean autoCount = true;

	//-- 返回结果 --//
	protected List<T> result = Lists.newArrayList();
	protected long totalCount = -1;

	//-- 构造函数 --//
	public Page() {
	}

	public Page(int pageSize) {
		this.pageSize = pageSize;
	}

	//-- 分页参数访问函数 --//
	/**
	 * 获得当前页的页号,序号从1开始,默认为1.
	 */
	public int getPageNo() {
		return pageNo;
	}

	/**
	 * 设置当前页的页号,序号从1开始,低于1时自动调整为1.
	 */
	public void setPageNo(final int pageNo) {
		this.pageNo = pageNo;

		if (pageNo < 1) {
			this.pageNo = 1;
		}
	}

	/**
	 * 返回Page对象自身的setPageNo函数,可用于连续设置。
	 */
	public Page<T> pageNo(final int thePageNo) {
		setPageNo(thePageNo);
		return this;
	}

	/**
	 * 获得每页的记录数量, 默认为-1.
	 */
	public int getPageSize() {
		return pageSize;
	}

	/**
	 * 设置每页的记录数量.
	 */
	public void setPageSize(final int pageSize) {
		this.pageSize = pageSize;
	}

	/**
	 * 返回Page对象自身的setPageSize函数,可用于连续设置。
	 */
	public Page<T> pageSize(final int thePageSize) {
		setPageSize(thePageSize);
		return this;
	}

	/**
	 * 根据pageNo和pageSize计算当前页第一条记录在总结果集中的位置,序号从1开始.
	 */
	public int getFirst() {
		return ((pageNo - 1) * pageSize) + 1;
	}

	/**
	 * 获得排序字段,无默认值. 多个排序字段时用','分隔.
	 */
	public String getOrderBy() {
		return orderBy;
	}

	/**
	 * 设置排序字段,多个排序字段时用','分隔.
	 */
	public void setOrderBy(final String orderBy) {
		this.orderBy = orderBy;
	}

	/**
	 * 返回Page对象自身的setOrderBy函数,可用于连续设置。
	 */
	public Page<T> orderBy(final String theOrderBy) {
		setOrderBy(theOrderBy);
		return this;
	}

	/**
	 * 获得排序方向, 无默认值.
	 */
	public String getOrder() {
		return order;
	}

	/**
	 * 设置排序方式向.
	 * 
	 * @param order 可选值为desc或asc,多个排序字段时用','分隔.
	 */
	public void setOrder(final String order) {
		String lowcaseOrder = StringUtils.lowerCase(order);

		//检查order字符串的合法值
		String[] orders = StringUtils.split(lowcaseOrder, ',');
		for (String orderStr : orders) {
			if (!StringUtils.equals(DESC, orderStr) && !StringUtils.equals(ASC, orderStr)) {
				throw new IllegalArgumentException("排序方向" + orderStr + "不是合法值");
			}
		}

		this.order = lowcaseOrder;
	}

	/**
	 * 返回Page对象自身的setOrder函数,可用于连续设置。
	 */
	public Page<T> order(final String theOrder) {
		setOrder(theOrder);
		return this;
	}

	/**
	 * 是否已设置排序字段,无默认值.
	 */
	public boolean isOrderBySetted() {
		return (StringUtils.isNotBlank(orderBy) && StringUtils.isNotBlank(order));
	}

	/**
	 * 获得查询对象时是否先自动执行count查询获取总记录数, 默认为false.
	 */
	public boolean isAutoCount() {
		return autoCount;
	}

	/**
	 * 设置查询对象时是否自动先执行count查询获取总记录数.
	 */
	public void setAutoCount(final boolean autoCount) {
		this.autoCount = autoCount;
	}

	/**
	 * 返回Page对象自身的setAutoCount函数,可用于连续设置。
	 */
	public Page<T> autoCount(final boolean theAutoCount) {
		setAutoCount(theAutoCount);
		return this;
	}

	//-- 访问查询结果函数 --//

	/**
	 * 获得页内的记录列表.
	 */
	public List<T> getResult() {
		return result;
	}

	/**
	 * 设置页内的记录列表.
	 */
	public void setResult(final List<T> result) {
		this.result = result;
	}

	/**
	 * 获得总记录数, 默认值为-1.
	 */
	public long getTotalCount() {
		return totalCount;
	}

	/**
	 * 设置总记录数.
	 */
	public void setTotalCount(final long totalCount) {
		this.totalCount = totalCount;
	}

	/**
	 * 根据pageSize与totalCount计算总页数, 默认值为-1.
	 */
	public long getTotalPages() {
		if (totalCount < 0) {
			return -1;
		}

		long count = totalCount / pageSize;
		if (totalCount % pageSize > 0) {
			count++;
		}
		return count;
	}

	/**
	 * 是否还有下一页.
	 */
	public boolean isHasNext() {
		return (pageNo + 1 <= getTotalPages());
	}

	/**
	 * 取得下页的页号, 序号从1开始.
	 * 当前页为尾页时仍返回尾页序号.
	 */
	public int getNextPage() {
		if (isHasNext()) {
			return pageNo + 1;
		} else {
			return pageNo;
		}
	}

	/**
	 * 是否还有上一页.
	 */
	public boolean isHasPre() {
		return (pageNo - 1 >= 1);
	}

	/**
	 * 取得上页的页号, 序号从1开始.
	 * 当前页为首页时返回首页序号.
	 */
	public int getPrePage() {
		if (isHasPre()) {
			return pageNo - 1;
		} else {
			return pageNo;
		}
	}
}

 

 2、session获取方式

 

public abstract class AbstractHibernateDaoSupport {

	protected Session getSession(){
		return getSessionFactory().getCurrentSession();
	}
	protected abstract SessionFactory getSessionFactory();
}

 

 3、基础接口实现

 

public class BaseDaoImpl<Entity, PK extends Serializable> extends
		AbstractHibernateDaoSupport implements BaseDao<Entity, PK> {

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

	protected SessionFactory sessionFactory;

	protected Class<Entity> entityClass;

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

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

	/**
	 * 取得sessionFactory.
	 */
	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	/**
	 * 采用@Autowired按类型注入SessionFactory, 当有多个SesionFactory的时候在子类重载本函数.
	 */
	@Resource
	public void setSessionFactory(final SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}

	public Serializable save(Entity entity) {
		return this.getSession().save(entity);
	}

	public void update(Entity entity) {
		this.getSession().update(entity);
	}

	public void merge(Entity entity) {
		this.getSession().merge(entity);
	}

	public void refresh(Entity entity) {
		this.getSession().refresh(entity);
	}

	public void delete(final Entity entity) {
		this.getSession().delete(entity);
	}

	/**
	 * 按id删除对象.
	 */
	public void delete(final PK id) {
		delete(findById(id));
	}

	/**
	 * 按id获取对象.
	 */
	@SuppressWarnings("unchecked")
	public Entity findById(final PK id) {
		return (Entity) getSession().get(entityClass, id);
	}

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

	/**
	 * 获取全部对象.
	 */
	public List<Entity> getAll() {
		return find();
	}

	/**
	 * 获取全部对象, 支持按属性行序.
	 */
	@SuppressWarnings("unchecked")
	public List<Entity> getAll(String orderByProperty, boolean isAsc) {
		Criteria c = createCriteria();
		if (isAsc) {
			c.addOrder(Order.asc(orderByProperty));
		} else {
			c.addOrder(Order.desc(orderByProperty));
		}
		return c.list();
	}

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

	/**
	 * 按属性查找唯一对象, 匹配方式为相等.
	 */
	@SuppressWarnings("unchecked")
	public Entity findUniqueByProperty(final String propertyName,
			final Object value) {
		Criterion criterion = Restrictions.eq(propertyName, value);
		return (Entity) createCriteria(criterion).uniqueResult();
	}

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

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

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

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

	/**
	 * 执行HQL进行批量修改/删除操作.
	 * 
	 * @param values
	 *            数量可变的参数,按顺序绑定.
	 * @return 更新记录数.
	 */
	public int batchExecute(final String hql, final Object... values) {
		return createQuery(hql, values).executeUpdate();
	}

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

	/**
	 * 根据查询HQL与参数列表创建Query对象. 与find()函数可进行更加灵活的操作.
	 * 
	 * @param values
	 *            数量可变的参数,按顺序绑定.
	 */
	public Query createQuery(final String queryString, final Object... values) {
		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对象. 与find()函数可进行更加灵活的操作.
	 * 
	 * @param values
	 *            命名参数,按名称绑定.
	 */
	public Query createQuery(final String queryString,
			final Map<String, ?> values) {
		Query query = getSession().createQuery(queryString);
		if (values != null) {
			query.setProperties(values);
		}
		return query;
	}

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

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

	/**
	 * 根据Criterion条件创建Criteria. 与find()函数可进行更加灵活的操作.
	 * 
	 * @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,
	 * 则只初始化entity的直接属性,但不会初始化延迟加载的关联集合和属性. 如需初始化关联属性,需执行:
	 * Hibernate.initialize(user.getRoles())，初始化User的直接属性和关联集合.
	 * Hibernate.initialize
	 * (user.getDescription())，初始化User的直接属性和延迟加载的Description属性.
	 */
	public void initProxyObject(Object proxy) {
		Hibernate.initialize(proxy);
	}

	/**
	 * Flush当前Session.
	 */
	public void flush() {
		getSession().flush();
	}

	/**
	 * 为Query添加distinct transformer. 预加载关联对象的HQL会引起主对象重复, 需要进行distinct处理.
	 */
	public Query distinct(Query query) {
		query.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
		return query;
	}

	/**
	 * 为Criteria添加distinct transformer. 预加载关联对象的HQL会引起主对象重复, 需要进行distinct处理.
	 */
	public Criteria distinct(Criteria criteria) {
		criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
		return criteria;
	}

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

	/**
	 * 判断对象的属性值在数据库内是否唯一.
	 * 
	 * 在修改对象的情景下,如果属性新修改的值(value)等于属性原来的值(orgValue)则不作比较.
	 */
	public boolean isPropertyUnique(final String propertyName,
			final Object newValue, final Object oldValue) {
		if (newValue == null || newValue.equals(oldValue)) {
			return true;
		}
		Object object = findUniqueByProperty(propertyName, newValue);
		return (object == null);
	}

	public void saveOrUpdate(Entity entity) {
		this.getSession().saveOrUpdate(entity);
	}

}

 

 3、分页查询，复杂查询实现public class BaseEntityDaoImpl<Entity, PK extends Serializable> extends

		BaseDaoImpl<Entity, PK> implements BaseEntityDao<Entity, PK> {
	/**
	 * 用于Dao层子类的构造函数. 通过子类的泛型定义取得对象类型Class. eg. public class UserDao extends
	 * HibernateDao<User, Long>{ }
	 */
	public BaseEntityDaoImpl() {
		super();
	}
	
	public Page<Entity> findPage(final Page<Entity> page,final Criteria c){
		if(page.isAutoCount()){
			long totalCount = countCriteriaResult(c);
			page.setTotalCount(totalCount);
		}
		setPageParameterToCriteria(c, page);
		List result = c.list();
		page.setResult(result);
		return page;
	}


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

	// -- 分页查询函数 --//

	/**
	 * 分页获取全部对象.
	 */
	public Page<Entity> findAllByPage(final Page<Entity> page) {
		return findPage(page);
	}

	/**
	 * 按HQL分页查询.
	 * 
	 * @param page
	 *            分页参数. 注意不支持其中的orderBy参数.
	 * @param hql
	 *            hql语句.
	 * @param values
	 *            数量可变的查询参数,按顺序绑定.
	 * 
	 * @return 分页查询结果, 附带结果列表及所有查询输入参数.
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public Page<Entity> findPage(final Page<Entity> page, final String hql,
			final Object... values) {

		Query q = createQuery(hql, values);

		if (page.isAutoCount()) {
			long totalCount = countHqlResult(hql, values);
			page.setTotalCount(totalCount);
		}

		setPageParameterToQuery(q, page);

		List result = q.list();
		page.setResult(result);
		return page;
	}

	/**
	 * 按HQL分页查询.
	 * 
	 * @param page
	 *            分页参数. 注意不支持其中的orderBy参数.
	 * @param hql
	 *            hql语句.
	 * @param values
	 *            命名参数,按名称绑定.
	 * 
	 * @return 分页查询结果, 附带结果列表及所有查询输入参数.
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public Page<Entity> findPage(final Page<Entity> page, final String hql,
			final Map<String, ?> values) {

		Query q = createQuery(hql, values);

		if (page.isAutoCount()) {
			long totalCount = countHqlResult(hql, values);
			page.setTotalCount(totalCount);
		}

		setPageParameterToQuery(q, page);

		List result = q.list();
		page.setResult(result);
		return page;
	}

	/**
	 * 按Criteria分页查询.
	 * 
	 * @param page
	 *            分页参数.
	 * @param criterions
	 *            数量可变的Criterion.
	 * 
	 * @return 分页查询结果.附带结果列表及所有查询输入参数.
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public Page<Entity> findPage(final Page<Entity> page,
			final Criterion... criterions) {

		Criteria c = createCriteria(criterions);

		if (page.isAutoCount()) {
			long totalCount = countCriteriaResult(c);
			page.setTotalCount(totalCount);
		}

		setPageParameterToCriteria(c, page);

		List result = c.list();
		page.setResult(result);
		return page;
	}

	/**
	 * 设置分页参数到Query对象,辅助函数.
	 */
	protected Query setPageParameterToQuery(final Query q,
			final Page<Entity> page) {

		// hibernate的firstResult的序号从0开始
		q.setFirstResult(page.getFirst() - 1);
		q.setMaxResults(page.getPageSize());
		return q;
	}

	/**
	 * 设置分页参数到Criteria对象,辅助函数.
	 */
	protected Criteria setPageParameterToCriteria(final Criteria c,
			final Page<Entity> page) {

		// hibernate的firstResult的序号从0开始
		c.setFirstResult(page.getFirst() - 1);
		c.setMaxResults(page.getPageSize());

		if (page.isOrderBySetted()) {
			String[] orderByArray = StringUtils.split(page.getOrderBy(), ',');
			String[] orderArray = StringUtils.split(page.getOrder(), ',');

			for (int i = 0; i < orderByArray.length; i++) {
				if (Page.ASC.equals(orderArray[i])) {
					c.addOrder(Order.asc(orderByArray[i]));
				} else {
					c.addOrder(Order.desc(orderByArray[i]));
				}
			}
		}
		return c;
	}

	/**
	 * 执行count查询获得本次Hql查询所能获得的对象总数.
	 * 
	 * 本函数只能自动处理简单的hql语句,复杂的hql查询请另行编写count语句查询.
	 */
	protected long countHqlResult(final String hql, final Object... values) {
		String countHql = prepareCountHql(hql);

		try {
			Long count = findUniqueByHql(countHql, values);
			return count;
		} catch (Exception e) {
			throw new RuntimeException("hql can't be auto count, hql is:"
					+ countHql, e);
		}
	}

	/**
	 * 执行count查询获得本次Hql查询所能获得的对象总数.
	 * 
	 * 本函数只能自动处理简单的hql语句,复杂的hql查询请另行编写count语句查询.
	 */
	protected long countHqlResult(final String hql, final Map<String, ?> values) {
		String countHql = prepareCountHql(hql);

		try {
			Long count = findUniqueByHql(countHql, values);
			return count;
		} catch (Exception e) {
			throw new RuntimeException("hql can't be auto count, hql is:"
					+ countHql, e);
		}
	}

	private String prepareCountHql(String orgHql) {
		String fromHql = orgHql;
		// select子句与order by子句会影响count查询,进行简单的排除.
		fromHql = "from " + StringUtils.substringAfter(fromHql, "from");
		fromHql = StringUtils.substringBefore(fromHql, "order by");

		String countHql = "select count(*) " + fromHql;
		return countHql;
	}

	/**
	 * 执行count查询获得本次Criteria查询所能获得的对象总数.
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	protected long countCriteriaResult(final Criteria c) {
		CriteriaImpl impl = (CriteriaImpl) c;

		// 先把Projection、ResultTransformer、OrderBy取出来,清空三者后再执行Count操作
		Projection projection = impl.getProjection();
		ResultTransformer transformer = impl.getResultTransformer();

		List<CriteriaImpl.OrderEntry> orderEntries = null;
		try {
			orderEntries = (List) ReflectionUtils.getFieldValue(impl,
					"orderEntries");
			ReflectionUtils
					.setFieldValue(impl, "orderEntries", new ArrayList());
		} catch (Exception e) {
			logger.error("不可能抛出的异常:" + e.getMessage());
		}

		// 执行Count查询
		Long totalCountObject = (Long) c.setProjection(Projections.rowCount())
				.uniqueResult();
		long totalCount = (totalCountObject != null) ? totalCountObject : 0;

		// 将之前的Projection,ResultTransformer和OrderBy条件重新设回去
		c.setProjection(projection);

		if (projection == null) {
			c.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
		}
		if (transformer != null) {
			c.setResultTransformer(transformer);
		}
		try {
			ReflectionUtils.setFieldValue(impl, "orderEntries", orderEntries);
		} catch (Exception e) {
			logger.error("不可能抛出的异常:" + e.getMessage());
		}

		return totalCount;
	}

}

 4、基础service实现，针对webservice

 

@Transactional
public abstract class BaseServiceImpl<Entity extends DominObject, PK extends Serializable, EntityDao extends BaseEntityDao<Entity, PK>>
		implements BaseService<Entity, PK> {
	protected Logger log = Logger.getLogger(this.getClass());

	protected EntityDao entityDao;

	public EntityDao getEntityDao() {
		return entityDao;
	}

	/**
	 * 子类进行注入
	 * 
	 * @param entityDao
	 */
	public abstract void setEntityDao(EntityDao entityDao);

	public RetdObj<PK> delete(PK id) {
		RetdObj<PK> rt = new RetdObj<PK>();
		try {
			this.entityDao.delete(id);
			rt.setCode(RetdCodeType.PASS_OK);
			rt.setRealObj(id);
			return rt;
		} catch (Exception ex) {
			log.error(ex.getMessage());
			rt.setCode(RetdCodeType.EX_APP);
			return rt;
		}
	}

	@Transactional(readOnly = true)
	public RetdObj<Page<Entity>> findAllByPage(Page<Entity> page) {
		RetdObj<Page<Entity>> rt = new RetdObj<Page<Entity>>();
		try {
			page = this.entityDao.findAllByPage(page);
			if (page == null || page.getResult() == null
					|| page.getResult().size() < 1) {
				rt.setCode(RetdCodeType.PASS_NODATA);
				return rt;
			} else {
				rt.setCode(RetdCodeType.PASS_OK);
				rt.setRealObj(page);
				return rt;
			}
		} catch (Exception ex) {
			log.error(ex.getMessage());
			rt.setCode(RetdCodeType.EX_APP);
			return rt;
		}

	}

	@Transactional(readOnly = true)
	public RetdObj<Entity> findById(PK id) {
		RetdObj<Entity> rt = new RetdObj<Entity>();
		try {
			Entity entity = this.entityDao.findById(id);
			if (entity == null) {
				rt.setCode(RetdCodeType.PASS_NODATA);
				return rt;
			} else {
				rt.setCode(RetdCodeType.PASS_OK);
				rt.setRealObj(entity);
				return rt;
			}
		} catch (Exception ex) {
			log.error(ex.getMessage());
			rt.setCode(RetdCodeType.EX_APP);
			return rt;
		}

	}

	@Transactional(readOnly = true)
	public RetdObj<List<Entity>> findByIds(Collection<PK> ids) {
		RetdObj<List<Entity>> rt = new RetdObj<List<Entity>>();
		try {
			List<Entity> entities = this.entityDao.findByIds(ids);
			if (entities == null || entities.size() < 1) {
				rt.setCode(RetdCodeType.PASS_NODATA);
				return rt;
			} else {
				rt.setCode(RetdCodeType.PASS_OK);
				rt.setRealObj(entities);
				return rt;
			}
		} catch (Exception ex) {
			log.error(ex.getMessage());
			rt.setCode(RetdCodeType.EX_APP);
			return rt;
		}
	}

	@Transactional(readOnly = true)
	public RetdObj<List<Entity>> getAll() {
		RetdObj<List<Entity>> rt = new RetdObj<List<Entity>>();
		try {
			List<Entity> entities = this.entityDao.getAll();
			if (entities == null || entities.size() < 1) {
				rt.setCode(RetdCodeType.PASS_NODATA);
				return rt;
			} else {
				rt.setCode(RetdCodeType.PASS_OK);
				rt.setRealObj(entities);
				return rt;
			}
		} catch (Exception ex) {
			log.error(ex.getMessage());
			rt.setCode(RetdCodeType.EX_APP);
			return rt;
		}
	}

	@SuppressWarnings("unchecked")
	public RetdObj<PK> save(Entity entity) {
		RetdObj<PK> rt = new RetdObj<PK>();
		try {
			PK id = (PK) this.entityDao.save(entity);
			rt.setCode(RetdCodeType.PASS_OK);
			rt.setRealObj(id);
			return rt;
		} catch (Exception e) {
			log.error(e.getMessage());
			rt.setCode(RetdCodeType.EX_APP);
			return rt;
		}
	}

	public RetdObj<PK> update(Entity entity) {
		RetdObj<PK> rt = new RetdObj<PK>();
		try {
			this.entityDao.update(entity);
			rt.setCode(RetdCodeType.PASS_OK);
			return rt;
		} catch (Exception e) {
			log.error(e.getMessage());
			rt.setCode(RetdCodeType.EX_APP);
			return rt;
		}
	}

	public RetdObj<PK> merge(Entity entity) {
		RetdObj<PK> rt = new RetdObj<PK>();
		try {
			this.entityDao.merge(entity);
			rt.setCode(RetdCodeType.PASS_OK);
			return rt;
		} catch (Exception e) {
			log.error(e.getMessage());
			rt.setCode(RetdCodeType.EX_APP);
			return rt;
		}
	}

	public RetdObj<PK> refresh(Entity entity) {
		RetdObj<PK> rt = new RetdObj<PK>();
		try {
			this.entityDao.refresh(entity);
			rt.setCode(RetdCodeType.PASS_OK);
			return rt;
		} catch (Exception e) {
			log.error(e.getMessage());
			rt.setCode(RetdCodeType.EX_APP);
			return rt;
		}
	}
}

 

6 、基础service，针对自用mvc

 

@Transactional
public abstract class FrontBaseServiceImpl<Entity extends DominObject, PK extends Serializable, EntityDao extends BaseEntityDao<Entity, PK>>
		implements FrontBaseService<Entity, PK> {
	protected Logger log = Logger.getLogger(this.getClass());

	protected EntityDao entityDao;

	public EntityDao getEntityDao() {
		return entityDao;
	}

	/**
	 * 子类进行注入
	 * 
	 * @param entityDao
	 */
	public abstract void setEntityDao(EntityDao entityDao);

	@SuppressWarnings("unchecked")
	public PK save(Entity entity) {
		return (PK) this.entityDao.save(entity);
	}

	public void update(Entity entity) {
		this.entityDao.update(entity);
	}

	public void merge(Entity entity) {
		this.entityDao.merge(entity);		
	}

	public void refresh(Entity entity) {
		this.entityDao.refresh(entity);		
	}

	public void delete(PK id) {
		this.entityDao.delete(id);
	}

	@Transactional(readOnly = true)
	public Entity findById(PK id) {
		return this.entityDao.findById(id);
	}

	@Transactional(readOnly = true)
	public List<Entity> findByIds(Collection<PK> ids) {
		return this.entityDao.findByIds(ids);
	}

	@Transactional(readOnly = true)
	public List<Entity> getAll() {
		return this.entityDao.getAll();
	}

	@Transactional(readOnly = true)
	public Page<Entity> findAllByPage(Page<Entity> page) {
		return this.entityDao.findAllByPage(page);
	}

	public void delete(PK[] ids) {
		for (PK id : ids) {
			this.delete(id);
		}
	}
	public void saveOrUpdate(Entity entity){
		this.entityDao.saveOrUpdate(entity);
	}
}

评论

2 楼 yccn1984 2014-05-14  

/**
     * 子类进行注入
     * 
     * @param entityDao
     */ 
    public abstract void setEntityDao(EntityDao entityDao);

具体的 Service 实现类 如何 注入  ，有没有实际的例子可以参考一下的。

1 楼 yccn1984 2014-05-14  

/**
     * 子类进行注入
     * 
     * @param entityDao
     */ 
    public abstract void setEntityDao(EntityDao entityDao);