HibernateDaoImpl16(441)

goodddd · 发表于 2010-12-16 10:14:52

/**
   * 功能描述:根据ID删除对象
   *
   * @param ids 要删除对象的主键
   * @throws DataAccessException 数据库访问异常数据访问异常
   */
public void removeById(PK... ids) throws DataAccessException
{
      try
      {
         if (null == ids || ids.length == 0)
         {
            throw new ValidatorException("ids is null...");
         }
         for (PK id : ids)
         {
            remove(get(id));
         }
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

/**
   * 功能描述：保存对象，可处理新增和修改
   *
   * @param object 要保存的对象
   * @return 实体对象
   * @throws DataAccessException 数据库访问异常数据访问异常
   */
public Serializable save(T object) throws DataAccessException
{
      try
      {
         Validator.checkParmIsNull(object);
         return this.getHibernateTemplate().save(object);
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

/**
   * 功能描述：更新对象
   *
   * @param object 要更新的对象
   * @throws DataAccessException 数据库访问异常数据访问异常
   */
public void update(T object) throws DataAccessException
{
      try
      {
         Validator.checkParmIsNull(object);
         getHibernateTemplate().merge(object);
      }
      catch (ValidatorException ve)
      {
         log.error("", ve);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, ve);
      }
}

/**
   * 功能描述：保存对象，可处理新增和修改
   *
   * @param object 要保存的对象
   * @throws DataAccessException 数据库访问异常数据访问异常
   */
public void saveOrUpdate(T object) throws DataAccessException
{
      try
      {
         Validator.checkParmIsNull(object);
         getHibernateTemplate().saveOrUpdate(object);
      }
      catch (ValidatorException ve)
      {
         log.error("", ve);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, ve);
      }
}

/**
   * 功能描述：根据过滤条件查询出列表数据。
   *
   * @param filters 过滤条件
   * @return 满足条件的列表
   * @throws DataAccessException 数据库访问异常数据访问异常
   */
@SuppressWarnings("unchecked")
public List<T> find(final List<Filter> filters) throws DataAccessException
{
      try
      {
         return (List<T>) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Criteria criteria = createCriteria(filters, session);
                        return criteria.list();
                     };
                  });
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

goodddd · 发表于 2010-12-16 10:16:16

/**661
   * 功能描述：根据过滤条件查询出列表数据, 可以排序。
   *
   * @param filters 过滤条件
   * @param sorts 排序条件
   * @return 满足条件的列表
   * @throws DataAccessException 数据库访问异常数据库操作异常
   */
@SuppressWarnings("unchecked")
public List<T> find(final List<Filter> filters, final List<Sort> sorts)
         throws DataAccessException
{
      try
      {
         return (List<T>) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Criteria criteria = createCriteria(filters, session);
                        if (null != sorts && sorts.size() > 0)
                        {
                              for (Sort sort : sorts)
                              {
                                 if (sort.getOrder().equals(Sort.ASC))
                                 {
                                    criteria.addOrder(Order.asc(sort
                                             .getColumn()));
                                 }
                                 else
                                 {
                                    criteria.addOrder(Order.desc(sort
                                             .getColumn()));
                                 }
                              }
                        }
                        return criteria.list();
                     };
                  });
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

/**
   * 功能描述：根据过滤条件查询出列表数据，增加投影和distinct功能 Dec 30, 2008 s65785
   *
   * @param filters 过滤条件
   * @param fields 投影字段
   * @param distinctField distinct字段
   * @return 满足条件的列表
   * @throws DataAccessException 数据库访问异常数据访问异常
   */
public List<?> find(final List<Filter> filters, final List<String> fields,
         final String distinctField) throws DataAccessException
{
      try
      {
         return (List<?>) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Criteria criteria = createCriteria(filters, session);
                        if (null != fields && !fields.isEmpty())
                        {
                              ProjectionList selectList = Projections
                                    .projectionList();
                              for (String field : fields)
                              {
                                 if (field.equals(distinctField))
                                 {
                                    selectList.add(Projections
                                             .distinct(Projections
                                                      .property(field)));
                                 }
                                 else
                                 {
                                    selectList.add(Projections
                                             .property(field));
                                 }
                              }
                              criteria.setProjection(selectList);
                        }
                        return criteria.list();
                     };
                  });

      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

goodddd · 发表于 2010-12-16 10:17:26

/**762
   * 功能描述：使用Hibernate配置文件中的查询命名SQL查询列表数据
   *
   * @param queryName 命名SQL查询名称
   * @param params 参数列表
   * @return 满足条件的列表
   * @throws DataAccessException 数据库访问异常数据访问异常
   */
@SuppressWarnings("unchecked")
public List<?> findByNamedQuery(final String queryName,
         final Map<String, Object> params) throws DataAccessException
{
      try
      {
         Validator.checkStringLen(queryName);
         return (List<?>) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Query query = session.getNamedQuery(queryName);
                        setQueryParameter(query, params);
                        return query.list();
                     };
                  });
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

/**
   * 功能描述：查询分页列表记录
   *
   * @param currentPage 页码
   * @param pageSize 页面大小
   * @return 满足条件的一页列表记录
   * @throws DataAccessException 数据库访问异常数据访问异常
   */
public List<T> getPageList(int currentPage, int pageSize)
         throws DataAccessException
{
      return getPageList(null, null, currentPage, pageSize);
}

/**
   * 功能描述：根据过滤和排序条件查询出分页列表记录
   *
   * @param filters 过滤条件
   * @param sorts 排序条件
   * @param currentPage 页码
   * @param pageSize 页面大小
   * @return 满足条件的一页列表记录
   * @throws DataAccessException 数据库访问异常数据访问异常
   */
@SuppressWarnings("unchecked")
public List<T> getPageList(final List<Filter> filters,
         final List<Sort> sorts, final int currentPage, final int pageSize)
         throws DataAccessException
{
      try
      {
         return (List<T>) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Criteria criteria = createCriteria(filters, session);
                        if (null != sorts && sorts.size() > 0)
                        {
                              for (Sort sort : sorts)
                              {
                                 if (sort.getOrder().equals(Sort.ASC))
                                 {
                                    criteria.addOrder(Order.asc(sort
                                             .getColumn()));
                                 }
                                 else
                                 {
                                    criteria.addOrder(Order.desc(sort
                                             .getColumn()));
                                 }
                              }
                        }
                        int startIndex = (currentPage - 1) * pageSize;
                        return criteria.setFirstResult(startIndex)
                                 .setMaxResults(pageSize).list();
                     };
                  });
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

goodddd · 发表于 2010-12-16 10:18:09

/**843
   * 功能描述：使用命名SQL查询列表数据
   *
   * @param queryName 命名SQL查询名称
   * @param params 参数列表
   * @param currentPage 页码
   * @param pageSize 页面大小
   * @return 满足条件的一页列表记录
   * @throws DataAccessException 数据库访问异常数据访问异常
   */
@SuppressWarnings("unchecked")
public List<T> getPageListByNamedQuery(final String queryName,
         final Map<String, Object> params, final int currentPage,
         final int pageSize) throws DataAccessException
{
      try
      {
         Validator.checkStringLen(queryName);
         return (List<T>) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Query query = session.getNamedQuery(queryName);
                        setQueryParameter(query, params);
                        int startIndex = (currentPage - 1) * pageSize;
                        return query.setFirstResult(startIndex)
                                 .setMaxResults(pageSize).list();
                     };
                  });
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

/**
   * 功能描述：查询列表总数
   *
   * @return 记录总数
   * @throws DataAccessException 数据库访问异常数据访问异常
   */
public int getTotalCount() throws DataAccessException
{
      return getTotalCount(null);
}

/**
   * 功能描述：根据过滤条件查询列表总数
   *
   * @param filters 过滤条件
   * @return 满足条件的记录总数
   * @throws DataAccessException 数据库访问异常数据访问异常
   */
public int getTotalCount(final List<Filter> filters)
         throws DataAccessException
{
      try
      {
         return (Integer) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Criteria criteria = createCriteria(filters, session);
                        return criteria.setProjection(
                                 Projections.rowCount()).uniqueResult();
                     };
                  });
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

goodddd · 发表于 2010-12-16 10:18:53

/**931
   * 功能描述：使用命名SQL查询列表数据总数
   *
   * @param queryName 命名SQL查询名称
   * @param params 参数列表，可以是一个null
   * @return 满足条件的记录总数
   * @throws DataAccessException 数据库访问异常数据访问异常
   */
public int getTotalCountByNamedQuery(final String queryName,
         final Map<String, Object> params) throws DataAccessException
{

      try
      {
         Validator.checkStringLen(queryName);
         return (Integer) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Query query = session.getNamedQuery(queryName);
                        setQueryParameter(query, params);
                        String hql = query.getQueryString();
                        String countQueryString = "select count (*) "
                                 + removeSelect(removeOrders(hql));
                        List<?> countlist = null;
                        query = session.createQuery(countQueryString);
                        if (params != null)
                        {
                              setQueryParameter(query, params);
                              countlist = query.list();
                        }
                        else
                        {
                              countlist = query.list();
                        }
                        return ((Long) countlist.get(0)).intValue();
                     };
                  });
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

/**
   * 功能描述：根据原生SQL来查询对象
   *
   * @author g67943
   * @param queryName 命名查询名称
   * @param parameters 查询参数，按照SQL中的参数顺序来构造的
   * @return List<?> 返回查询结果
   * @throws DataAccessException 数据库访问异常数据访问异常
   */
public List<?> findBySQLQuery(final String queryName,
         final Map<String, Object> parameters) throws DataAccessException
{
      try
      {
         Validator.checkStringLen(queryName);
         return (List<?>) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Query query = session.getNamedQuery(queryName);
                        setQueryParameter(query, parameters);
                        return query.list();
                     };
                  });
      }
      catch (ValidatorException ve)
      {
         log.error("", ve);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, ve);
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

goodddd · 发表于 2010-12-16 10:19:20

/**1053
   * 功能描述：根据原生SQL来查询对象个数
   *
   * @param queryName 查询名称
   * @param parameters 参数
   * @return int
   * @throws DataAccessException 数据库访问异常
   */
public int findCountBySQLQuery(final String queryName,
         final Map<String, Object> parameters) throws DataAccessException
{

      try
      {
         Validator.checkStringLen(queryName);
         return (Integer) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Query query = session.getNamedQuery(queryName);
                        setQueryParameter(query, parameters);
                        Object result = query.list().get(0);
                        return result;
                     };
                  });
      }
      catch (ValidatorException ve)
      {
         log.error("", ve);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, ve);
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }

}

/**
   * 功能描述：根据原生SQL分页查询对象
   *
   * @author g67943
   * @param queryName 命名查询名称
   * @param parameters 查询参数，按照SQL中的参数顺序来构造的
   * @return List<?> 返回查询结果
   * @param curPage 当前页码
   * @param pageSize 每页显示多少条记录
   * @throws DataAccessException 数据库访问异常数据访问异常
   */
public List<?> findBySQLQueryPaged(final String queryName,
         final Map<String, Object> parameters, final int curPage,
         final int pageSize) throws DataAccessException
{
      try
      {
         Validator.checkStringLen(queryName);
         return (List<?>) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Query query = session.getNamedQuery(queryName);
                        setQueryParameter(query, parameters);
                        return query.setFirstResult(
                                 (curPage - 1) * pageSize).setMaxResults(
                                 pageSize).list();
                     };
                  });
      }
      catch (ValidatorException ve)
      {
         log.error("", ve);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, ve);
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

/**
   * 功能描述：开放式的query查询
   *
   * @param query 查询对象
   * @return List<?>
   * @throws DataAccessException 数据库访问异常
   */
public List<?> findBySQLQuery(final Query query) throws DataAccessException
{
      try
      {
         Validator.checkParmIsNull(query);
         return (List<?>) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        return query.list();
                     };
                  });
      }
      catch (ValidatorException ve)
      {
         log.error("", ve);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, ve);
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

goodddd · 发表于 2010-12-16 10:20:15

/**1135
   * 功能描述：根据条件查询动态表，返回指定的对象
   *
   * @param queryName 命名查询名称
   * @param filters 查询条件
   * @param table 动态表名
   * @param alias 命名查询中返回对象的别名,可以为null,此时returnType无效
   * @param returnType 返回对象的类型
   * @return List<?>
   * @throws DataAccessException 数据库访问异常
   */
public List<?> findByDynamicTable(final String queryName,
         final List<Filter> filters, final String table, final String alias,
         final Class<?> returnType) throws DataAccessException
{
      try
      {
         return (List<?>) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Query query = session.getNamedQuery(queryName);
                        SQLQuery sqlQuery = makeQueryForDynamicTable(query,
                                 filters, table, null, session);
                        if (alias != null)
                        {
                              sqlQuery.addEntity(alias, returnType);
                        }
                        return sqlQuery.list();
                     };
                  });
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

/**
   * 功能描述：根据条件查询动态表，返回指定的对象
   *
   * @param queryName 命名查询名称
   * @param filters 查询条件
   * @param table 动态表名
   * @param clazz 返回对象的类型
   * @return List<?>
   * @throws DataAccessException 数据库访问异常
   */
public List<?> findByDynamicTableReturnEntity(final String queryName,
         final List<Filter> filters, final String table, final Class<?> clazz)
         throws DataAccessException
{
      try
      {
         return (List<?>) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Query query = session.getNamedQuery(queryName);
                        SQLQuery sqlQuery = makeQueryForDynamicTable(query,
                                 filters, table, null, session);
                        if (null != clazz)
                        {
                              sqlQuery.setResultTransformer(Transformers
                                    .aliasToBean(clazz));
                        }
                        return sqlQuery.list();
                     };
                  });
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

goodddd · 发表于 2010-12-16 10:20:52

/**1249
   * 功能描述：根据条件构造原生sql查询
   *
   * @param queryName 命名查询名称
   * @param filters 查询条件
   * @param clazz 实体类
   * @return List<?>
   * @throws DataAccessException 数据库访问异常
   */
public List<?> findByDynamicFilter(final String queryName,
         final List<Filter> filters, final Class<?> clazz)
         throws DataAccessException
{
      try
      {
         return (List<?>) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Query query = session.getNamedQuery(queryName);
                        SQLQuery sqlQuery = makeQueryForDynamicFilter(
                                 query, filters, null, session);
                        if (null != clazz)
                        {
                              sqlQuery.setResultTransformer(Transformers
                                    .aliasToBean(clazz));
                        }
                        return sqlQuery.list();
                     };
                  });
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

/**
   * 功能描述：根据条件构造原生sql查询
   *
   * @param queryName 命名查询名称
   * @param parameters 查询条件
   * @param clazz 实体类
   * @return List<?>
   * @throws DataAccessException 数据库访问异常
   */
public List<?> findBySQLQuery(final String queryName,
         final Map<String, Object> parameters, final Class<?> clazz)
         throws DataAccessException
{

      try
      {
         return (List<?>) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Query query = session.getNamedQuery(queryName);
                        setQueryParameter(query, parameters);
                        if (null != clazz)
                        {
                              query.setResultTransformer(Transformers
                                    .aliasToBean(clazz));
                        }
                        return query.list();
                     };
                  });
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }

}

/**
   * 功能描述：根据条件构造原生sql查询
   *
   * @param queryName 命名查询名称
   * @param filters 查询条件
   * @return List<?>
   * @throws DataAccessException 数据库访问异常
   */
public int getCountByDynamicFilter(final String queryName,
         final List<Filter> filters) throws DataAccessException
{
      try
      {
         return (Integer) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Query query = session.getNamedQuery(queryName);
                        SQLQuery sqlQuery = makeCountQueryForDynamicFilter(
                                 query, filters, null, session);
                        return sqlQuery.list().get(0);
                     };
                  });
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }
}

goodddd · 发表于 2010-12-16 10:48:53

//1250
public int getCountByDynamicFilterBySubQuery(final String queryName,
         final List<Filter> filters) throws DataAccessException
{

      try
      {
         return (Integer) getHibernateTemplate().execute(
                  new HibernateCallback()
                  {
                     public Object doInHibernate(Session session)
                     {
                        Query query = session.getNamedQuery(queryName);
                        SQLQuery sqlQuery = makeSubQueryCountQueryForDynamicFilter(
                                 query, filters, null, session);
                        return sqlQuery.list().get(0);
                     };
                  });
      }
      catch (Exception he)
      {
         log.error("", he);
         throw new DataAccessException(
                  IDataAccessExceptionConstants.E_HIBERNATE_ERROR, he);
      }

}

		自动登录	找回密码
密码			(注-册)加入51Testing

[原创] HibernateDaoImpl16(441)

相关帖子

站长推荐 /1