SSH框架里实现带条件的分页查询？~急。

捞个沙发。这个网上一搜应该一大把观望中ing...

可以将查询条件放到session里，但不推荐，还是放到request里来回传吧

public List<ResDevice> searchDevice(ResDevice object, int pageNo,
int pageSize) {
Criteria criteria=super.getSession().createCriteria(ResDevice.class);
if(object.getCode()!=null&&!object.getCode().equals("")){
criteria.add(Restrictions.eq("code", object.getCode()));
}
if(object.getName()!=null&&!object.getName().equals("")){
criteria.add(Restrictions.eq("name", object.getName()));
}
if(object.getHardwareid()!=null&&!object.getHardwareid().equals("")){
criteria.add(Restrictions.eq("hardwareid", object.getHardwareid()));
}
if(object.getBelong()!=null&&!object.getBelong().equals("")){
criteria.add(Restrictions.eq("belong", object.getBelong()));
}
criteria.setFirstResult(pageSize*(pageNo-1));
criteria.setMaxResults(pageSize);
return criteria.list();
}

int count = 0;
int pageindex = 1;// 页码
int pagesize = 25;// 页面大小

System.out.println(request.getParameter("newTypename"));
DetachedCriteria c = DetachedCriteria.forClass(NewInfo.class);
c.addOrder(Order.desc("newId"));
if (request.getParameter("page") != null) {
if (request.getParameter("page") != "") {
pageindex = Integer.parseInt(request.getParameter("page"));
request.setAttribute("page", pageindex);
}
}
String tp;
if(request.getParameter("newTypename") != null){
if(request.getParameter("newTypename") != ""){
tp =request.getParameter("newTypename");
DetachedCriteria c1 = DetachedCriteria.forClass(NewTypeInfo.class);
c1.add(Expression.eq("newTypename", tp));
NewTypeInfo newtp = null;
if(this.newTYpeInfoService.ListDeptInfor(c1).size()>0){
newtp = (NewTypeInfo) this.newTYpeInfoService.ListDeptInfor(c1).get(0);
}
request.setAttribute("newTypename", tp);
c.add(Expression.eq("newTypeInfo", newtp));
// 浙江新闻
if(request.getParameter("zhejiang") != null){
DetachedCriteria AreaInfoC = DetachedCriteria.forClass(AreaInfo.class);
AreaInfoC.add(Expression.eq("areaName", "浙江省"));
AreaInfo areainfo=(AreaInfo)this.areaInfoService.ListDeptInfor(AreaInfoC).get(0);

DetachedCriteria areainfoc = DetachedCriteria.forClass(AreaInfo.class);
areainfoc.add(Expression.eq("areaSid",areainfo.getAreaBid()));
c.add(Expression.in("areaInfo",this.areaInfoService.ListDeptInfor(areainfoc)));
}
}
}
if(request.getParameter("newtitle") != null){
if(request.getParameter("newtitle") !=""){
// String title = new String(request.getParameter("newtitle").getBytes("ISO8859-1"),"UTF-8");
String title = request.getParameter("newtitle");
c.add(Expression.like("newTitle", "%"+title+"%"));
}
}
if (request.getParameter("quyu") != null) {
if (request.getParameter("quyu") != "") {
String quyu = request.getParameter("quyu");
request.setAttribute("quyu", quyu);
DetachedCriteria areaInfoC = DetachedCriteria
.forClass(AreaInfo.class);
areaInfoC.add(Expression.eq("premeditation1", quyu));
List shengList = this.areaInfoService.ListDeptInfor(areaInfoC);
List shengId = new ArrayList();
for (int i = 0; i < shengList.size(); i++) {
AreaInfo info = (AreaInfo) shengList.get(i);
shengId.add(info.getAreaBid());
}
DetachedCriteria shiInfoC = DetachedCriteria
.forClass(AreaInfo.class);
shiInfoC.add(Expression.in("areaSid", shengId));
c.add(Expression.in("areaInfo", this.areaInfoService
.ListDeptInfor(shiInfoC)));
}
}
count = this.newInfoService.ListDeptInfor(c).size();
int start = (pageindex - 1) * pagesize;// 设置起始位置
int end = pagesize;// 设置查询记录数
List list = this.newInfoService.findByPage(c, start, end);
request.setAttribute("list", list);
request.setAttribute("pageindex", pageindex);// 页码
request.setAttribute("dateCount", count);// 数据总条数
request.setAttribute("pageCount", PageMana.getPageCount(count, end));// 总页数

这是dao
package com.quanguowuliu.dao;
import java.util.*;import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.orm.hibernate3.SessionFactoryUtils;
public class BaseDAO extends HibernateDaoSupport implements IBaseDAO{
     /**
     * 向数据库添加一条对应于一个业务对象实例的记录
     *
     * @param entity
     *            业务对象实例
     * @throws DaoException
     *
     */
    public boolean create(Object entity)  {
        try {
         super.getHibernateTemplate().save(entity);
         return true;
        } catch (Exception e) {
            System.out.println("保存 " + entity.getClass().getName() + " 实例到数据库失败"+e);
            return false;
        }
    }
    public List findByPage(DetachedCriteria dc,int start,int end)
{
     List listpage=this.getHibernateTemplate().findByCriteria(dc, start, end);
     return listpage;
}
    public List ListDeptInfor(DetachedCriteria dc) throws HibernateException{
     List lists= this.getHibernateTemplate().findByCriteria(dc);
return lists;
     }
/**
     * 获得一个session
     */
    public Session openSession() {
            return SessionFactoryUtils.getSession(super.getHibernateTemplate().getSessionFactory(), false);
    } /**
     * 获得Query对象
     */
    public Query getQuery(String sql){
        Session session = this.openSession();
        Query query = session.createQuery(sql);
        return query;
    }

    /**
     * 获得Criteria对象
     */
    public Criteria getCriteria(Class clazz){

    Session session=this.openSession();
    Criteria criteria = session.createCriteria(clazz);
    return criteria;
    }    /**
     * 向数据库更新一条对应于一个业务对象实例的记录
     *
     * @param entity
     *            业务对象实例
     * @throws DaoException
     *
     */
    public boolean update(Object entity)  {
        try {
            super.getHibernateTemplate().update(entity);
            return true;
        } catch (Exception e) {
            System.out.println("更新 " + entity.getClass().getName() + " 实例到数据库失败"+e);
           return false;
        }
    }     /**
     * 从数据库删除一条对应于一个业务对象的记录
     *
     * @param entity
     *            业务对象实例
     * @throws DaoException
     *
     */
    public boolean delete(Object entity)  {
        try {
            super.getHibernateTemplate().delete(entity);
            return true;
        } catch (Exception e) {
            System.out.println("从数据库删除 " + entity.getClass().getName() + " 实例失败"+e);
            return false;
        }
    }
    /**
     * 从数据库删除所有对应于一个业务对象的记录
     * @param clazz
     *            指定类型的业务对象
     * @throws DaoException
     */
    public boolean deleteAll(Class clazz) {
        try {
            List result = super.getHibernateTemplate().loadAll(clazz);
            super.getHibernateTemplate().deleteAll(result);
            return true;
        } catch (Exception e) {
            System.out.println("从数据库删除 " + clazz.getName() + " 的所有记录失败"+ e);
           return false;
        }
    }     public boolean deleteAll(Collection entities) {
        try {
            super.getHibernateTemplate().deleteAll(entities);
            return true;
        } catch(Exception e) {
           return false;
        }
    }
    /**
     * 从数据库查询一个业务对象的所以记录
     * @param clazz
     *            指定类型的业务对象
     */
    public List LoadAll(Class clazz){
        List list=null;
        try{
               list=super.getHibernateTemplate().loadAll(clazz);
        }catch(Exception e){
           System.out.println("从数据库查询"+clazz.getName()+"失败");
       }
        return list;
    }


    /**
     * 根据关键字从数据库加载指定类型的业务对象。
     *
     * @param clazz
     *            业务对象的Class
     * @param keyName
     *            指定关键字对应的字段名称
     * @param keyValue
     *            指定关键字的值
     * @return <ul>
     *         <li>当关键字唯一并存在该记录时，返回该记录对应的业务对象</li>
     *         <li>当关键字不唯一，返回查询结果的第一条记录所对应的业务对象</li>
     *         <li>当不存在该记录时,返回null</li>
     *         </ul>
     * @throws DaoException
     *
     */
    public Object loadByKey(Class clazz, String keyName, Object keyValue)
            {

            List result = super.getHibernateTemplate().find(
                    "from " + clazz.getName() + " where " + keyName + " = ?",
                    keyValue);
            if (result != null && result.size() > 0) {
                return result.get(0);
            } else {
                return null;
            }
     }

    /**
     * 根据主键查询唯一数据对象。
     *
     * @param clazz
     *            业务对象的Class
     * @return 返回查询结果包含的业务对象
     * @throws DaoException
     *
     */
    public Object getByPk(Class clazz,Integer id){
      Object obj = (Object)super.getHibernateTemplate().get(clazz,id);
      return obj;

    }
    public Object getByPk(Class clazz,Long id){
      Object obj = (Object)super.getHibernateTemplate().get(clazz,id);
      return obj;
    }
    public Object getByPk(Class clazz,String id){
      Object obj = (Object)super.getHibernateTemplate().get(clazz,id);
      return obj;
    }

    /**
     * 根据查询语句查询数据库并返回查询结果所包含的业务对象集合。
     *
     * @param queryString
     *            指定查询语句
     * @return 返回查询结果包含的业务对象集合
     * @throws DaoException
     *
     */
    public List find(String queryString)  {
     List list =null;
        try {
            list= super.getHibernateTemplate().find(queryString); ;
        } catch (Exception e) {
            System.out.println("执行查询 " + queryString + " 失败"+e);

        }
        return list;
    }
    /**
     * 根据带一个参数的查询语句查询数据库并返回查询结果所包含的业务对象集合。
     *
     * @param queryString
     *            指定查询语句
     * @param param
     *            指定所带参数
     * @return 返回查询结果包含的业务对象集合
     * @throws DaoException
     *            牭±查询失败时抛??鲆斐??
     */
    public List find(String queryString, Object param)  {
     List list= null;
        try {
            list = super.getHibernateTemplate().find(queryString, param);
        } catch (Exception e) {
            System.out.println("执行参数为 " + param + " 的查询 " + queryString + " 失败"+e);

        }
        return list;
    }
    /**
     * 根据带多个参数的查询语句查询数据库并返回查询结果所包含的业务对象集合。
     *
     * @param queryString
     *            指定查询语句
     * @param params
     *            指定参数数组
     * @return 返回查询结果包含的业务对象集合
     * @throws DaoException
     *
     */
    public List find(String queryString, Object[] params) {
     List list= null;
        try {
            list= super.getHibernateTemplate().find(queryString, params);
        } catch (Exception e) {
            StringBuffer paramString = new StringBuffer("");
            for (int i = 0; i < params.length; i++) {
                paramString.append(params[i]);
                paramString.append(" ");
            }
            System.out.println("执行参数为 " + paramString + "的查询 " + queryString + " 失败"+e);

        }
        return list;
    } }

可不可以使用hibernate ，通过hql来拼接字段，把查询条件放在一个map里，这样子可行吗？

不需要这么多功能的话可以删除一些参数 @SuppressWarnings("unchecked")
@Override
@Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
public <T> QueryResult<T> getScrollData(Class<T> entityClass, int firstIndex, int maxResult, String wherejpql,
Object[] queryParams, LinkedHashMap<String, String> orderby) {
QueryResult<T> qr = new QueryResult<T>();
String entityName = getEntityName(entityClass);
Query query = em.createQuery("select o from " + entityName + " o " + (wherejpql == null ? "" : "where " + wherejpql) + buildOrderby(orderby));
setQueryParams(query, queryParams);
if (firstIndex != -1 && maxResult != -1) {
query.setFirstResult(firstIndex).setMaxResults(maxResult);
}
qr.setResultList(query.getResultList());
query = em.createQuery("select count(o) from " + entityName + " o " + (wherejpql == null ? "" : "where " + wherejpql));
setQueryParams(query, queryParams);
qr.setTotalRecord((Long)query.getSingleResult());
return qr;
}

action 里写好查询条件的属性，get set 方法。查询时根据条件查询，属性还在 action类里的，页面查询添加 text 上写个
value=<s:property value="..."> 懂？

我那个你看着还晕？无语了我那应该是最简单的方式了用的hibernate

刚刚忘记把这个方法贴上来： protected void setQueryParams(Query query, Object[] queryParams) {
if (queryParams != null && queryParams.length > 0) {
for (int i = 0; i < queryParams.length; i++) {
query.setParameter(i + 1, queryParams[i]);
}
}
}其中的类QueryResult是这样写的：package cn.itcast.bean;import java.util.List;//泛型定义在类上面，每一个方法都可以使用这个泛型
/**
* @ClassName: QueryResult
* @Description: 分页数据
* @author lubinsu lubinsu_gmail_com
* @date Nov 26, 2011 11:47:22 AM
* @param <T>
*/
public class QueryResult<T> {
/** @Fields resultList : 结果集 **/
private List<T> resultList;
/** @Fields totalRecord : 总记录数 **/
private long totalRecord; public List<T> getResultList() {
return resultList;
} public void setResultList(List<T> resultList) {
this.resultList = resultList;
} public long getTotalRecord() {
return totalRecord;
} public void setTotalRecord(long totalRecord) {
this.totalRecord = totalRecord;
}}

调试易

SSH框架里实现带条件的分页查询？~急。

解决方案 »