封装JPA的数据操作公共DAO基类

/**
 * 数据库通用操作基类接口
 */
public interface IObjectDao<T> extends Serializable {

	/**
	 * 不需确定新建实体是否已经存在
	 */
	public T save(T t);

	/**
	 * 不需确定新建实体是否已经存在
	 */
	public Collection<T> save(Collection<T> ts);

	/**
	 * 可确定为新建实体；返回处于托管状态的实例
	 */
	public T persist(T t);

	public boolean persist(Collection<T> ts);

	/**
	 * 若数据库中已有此记录，置为托管状态
	 */
	public T merge(T t);

	/**
	 * 若数据库中已有此记录，置为托管状态
	 */
	public Collection<T> merge(Collection<T> t);

	/**
	 * 删除
	 */
	public void remove(T t);

	/**
	 * 批量删除 传入集合
	 */
	public void remove(Collection<T> ts);

	/**
	 * 删除指定id、指定class的实例
	 */
	public void remove(Class<T> clazz, String id);

	/**
	 * 删除指定id、指定class的实例
	 */
	public void remove(Class<T> clazz, Collection<String> ids);

	/**
	 * 清除一级缓存
	 */
	public void clear();

	/**
	 * 将对象置为游离状态
	 */
	public void detach(T t);

	/**
	 * 将对象置为游离状态
	 */
	public void detach(Collection<T> ts);

	/**
	 * 检查实例是否处于托管状态
	 */
	public boolean isManaged(T t);

	/**
	 * 同步jpa容器和数据库
	 */
	public void flush();

/**
 * 数据库通用操作基类 包含共同方法
 */
@Component("objectDao")
public class ObjectDaoImpl<T> implements IObjectDao<T> {

	private static final long serialVersionUID = 7433224241393375192L;
	public EntityManager entityManager;

	/**
	 * 不需确定新建实体是否已经存在
	 */
	@Override
	public T save(T t) throws RuntimeException {
		try {
			t = entityManager.contains(t) ? t : entityManager.merge(t);
		} catch (Exception e) {
			throw new RuntimeException("保存失败，请联系管理员！");
		}
		return t;
	}

	/**
	 * 不需确定新建实体是否已经存在 传入对象集合
	 */
	@Override
	public Collection<T> save(Collection<T> ts) {
		Collection<T> collection = new HashSet<T>();
		for (T t : ts) {
			collection.add(save(t));
		}
		return collection;
	}

	/**
	 * 可确定为新建实体
	 */
	@Override
	public T persist(T t) {
		try {
			entityManager.persist(t);
			return t;
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException("错误：保存新建实例时，发生异常：" + e.getMessage());
		}
	}

	/**
	 * 可确定为新建实体 成功返回true 失败返回false
	 */
	@Override
	public boolean persist(Collection<T> ts) {

		try {
			for (T t : ts) {
				entityManager.persist(t);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 若数据库中已有此记录，置为托管状态并刷新实体信息
	 */
	@Override
	public T merge(T t) throws RuntimeException {
		try {
			t = entityManager.contains(t) ? t : entityManager.merge(t);
		} catch (Exception e) {
			throw new RuntimeException("更新失败，请联系管理员！");
		}
		return t;
	}

	/**
	 * 若数据库中已有此记录，置为托管状态
	 */
	@Override
	public Collection<T> merge(Collection<T> ts) {
		Collection<T> collection = new HashSet<T>();
		for (T t : ts) {
			collection.add(merge(t));
		}
		return collection;
	}

	/**
	 * 删除
	 */
	@Override
	public void remove(T t) throws RuntimeException {
		if (null == t) {
			throw new RuntimeException("请求删除的对象为空!");
		}
		try {
			if (entityManager.contains(t)) {
				entityManager.remove(t);
			} else {
				Object id = entityManager.getEntityManagerFactory()
						.getPersistenceUnitUtil().getIdentifier(t);
				entityManager.remove(entityManager.find(t.getClass(), id));
			}
		} catch (Exception e) {
			throw new RuntimeException("删除对象时出错，请联系管理员!");
		}
	}

	/**
	 * 批量删除 传入集合
	 */
	@Override
	public void remove(Collection<T> ts) {
		for (T t : ts) {
			remove(t);
		}
	}

	/**
	 * 删除
	 */
	@Override
	public void remove(Class<T> clazz, String id) throws RuntimeException {
		if (isEmpty(id)) {
			throw new RuntimeException("请求删除的对象为空!");
		}
		try {
			entityManager.remove(entityManager.find(clazz, id));
		} catch (Exception e) {
		}
	}

	/**
	 * 删除
	 */
	@Override
	public void remove(Class<T> clazz, Collection<String> ids) {
		for (String id : ids) {
			remove(clazz, id);
		}
	}

	/**
	 * 若数据库中存在，返回最新状态；否则，返回空
	 * 
	 * @param clazz
	 * @param t
	 * @param id
	 * @return
	 */
	protected T refresh(Class<T> clazz, T t) throws RuntimeException {
		String id = (String) entityManager.getEntityManagerFactory()
				.getPersistenceUnitUtil().getIdentifier(t);
		if (null == t) {
			throw new RuntimeException("请求刷新的实体为空！");
		}
		if (StringUtil.isEmpty(id)) {
			return null;
		}
		if (entityManager.contains(t)) {
			entityManager.refresh(t);
			return t;
		} else {
			return entityManager.find(clazz, id);
		}
	}

	/**
	 * 清除一级缓存
	 */
	@Override
	public void clear() {
		entityManager.clear();
	}

	/**
	 * 将对象置为游离状态
	 */
	@Override
	public void detach(T t) {
		entityManager.detach(t);
	}

	/**
	 * 将对象置为游离状态
	 */
	@Override
	public void detach(Collection<T> ts) {
		for (T t : ts) {
			detach(t);
		}
	}

	/**
	 * 判断实体是否处于托管状态
	 */
	@Override
	public boolean isManaged(T t) {
		return entityManager.contains(t);
	}

	/**
	 * 同步jpa容器和数据库
	 */
	@Override
	public void flush() {
		entityManager.flush();
	}

	// --------------------- DataBaseTool -------------------

	public EntityManager getEntityManager() {
		return entityManager;
	}

	@PersistenceContext
	public void setEntityManager(EntityManager entityManager) {
		this.entityManager = entityManager;
	}

	/**
	 * 判断一个字符串是否为空
	 */
	protected boolean isEmpty(String string) {
		return null == string || string.trim().equals("") ? true : false;
	}

	/**
	 * 日期转换 ：将java.util.Date类型转换为java.sql.Date
	 */
	protected java.sql.Date getSqlDate(java.util.Date date) {
		Long times = date.getTime();
		java.sql.Date date1 = new java.sql.Date(times);
		return date1;
	}

	/**
	 * 数据查询
	 * 
	 * @param start
	 *            数据起始游标值
	 * @param pageSize
	 *            分页大小
	 * @param pageResult
	 *            结果集封装对象
	 * @param cq
	 *            数据查询
	 * @param cqCount
	 *            符合条件的总条数
	 * @return
	 */
	protected PageResult<T> getResult(CriteriaQuery<T> cq,
			List<Predicate> predicates, CriteriaQuery<Long> cqCount,
			List<Predicate> predicatesCount, int start, int pageSize) {

		PageResult<T> pageResult = new PageResult<T>();
		// 设置查询条件
		cq.where(predicates.toArray(new Predicate[0]));
		cqCount.where(predicatesCount.toArray(new Predicate[0]));
		try {
			// 查询符合条件的数据总数
			long total = getEntityManager().createQuery(cqCount)
					.getSingleResult();
			// 如果结果总数超过了Integer的最大值 则Integer的返回最大值
			pageResult.setTotalCount(total <= Integer.MAX_VALUE ? (int) total
					: Integer.MAX_VALUE);
		} catch (Exception e) {
			// e.printStackTrace();
			pageResult.setTotalCount(0);
		}
		// 判断分页
		if (start > pageResult.getTotalCount() && pageSize > 0) {
			int newIndex = pageResult.getTotalCount() % pageSize == 0 ? pageResult
					.getTotalCount() / pageSize
					: pageResult.getTotalCount() / pageSize + 1;
			start = (newIndex - 1) * pageSize;
			pageResult.setChangeIndex(newIndex);
			pageResult.setFirst(start);
			pageResult.setPageSize(pageSize);
		}
		// 分页查询
		TypedQuery<T> tq = entityManager.createQuery(cq);
		if (start >= 0 && pageSize > 0) {
			tq.setFirstResult(start).setMaxResults(pageSize);
		}
		pageResult.setPageResultList(tq.getResultList());
		return pageResult;
	}

	/**
	 * 返回指定类的静态元模型名称
	 * 
	 * @param clazz
	 * @return
	 */
	protected String getStaticMetamodelName(Class<T> clazz) {
		return clazz.getName() + "_";
	}

	/**
	 * 根据company Id查找单个对象
	 * 
	 * @param company
	 *            company不能为空，若为空以异常处理
	 * @param clazz
	 *            查询数据类型
	 * @param id
	 * @return
	 * @throws RuntimeException
	 */
	@SuppressWarnings("unchecked")
	protected T findById(Company company, Class<?> clazz, String id)
			throws RuntimeException {
		if (null == company || isEmpty(company.getId())) {
			throw new RuntimeException("company 不能为空!");
		}
		if (isEmpty(id)) {
			return null;
		}
		CriteriaBuilder cb = entityManager.getCriteriaBuilder();
		CriteriaQuery<T> cq = (CriteriaQuery<T>) cb.createQuery(clazz);
		Root<T> root = (Root<T>) cq.from(clazz);
		cq.select(root).where(
				cb.and(cb.equal(root.get("id"), id),
						cb.equal(root.get("company"), company)));
		try {
			return entityManager.createQuery(cq).getSingleResult();
		} catch (Exception e) {
			return null;
		}
	}