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);
}
}