ThreadLocal分页逻辑的封装处理（转）_JAVA_编程开发_程序员俱乐部

分页逻辑的封装处理（请参考AbstractManager.java）
ThreadLocal设计模式，线程局部变量，因为每一次请求都对应一个线程，把初始化的分页数据放在这个局部变量中
当用到时，直接从当前线程中获取。原理同HibernateOpenSessionInView.
为避免在Action(呈现层)和Manager(业务逻辑层)之间传递大量的参数，
可以使用ThreadLocal模式来传递分页参数(包括：offset和pagesize)。
-定义：参考SystemContext.java
-往ThreadLocal中赋值：参考PagerFilter.java
-从ThreadLocal中获取分页参数：参考AbstractManager.java

-------------------------------------------------------------
具体代码如下：
1.定义分页数据封装类
package com.feihu.oa.page;
import java.util.List;
public class PagerModel
{
private List datas; // 分页数据列表
private int total; // 查询总记录数
public List getDatas()
{
  return datas;
}
public void setDatas(List datas)
{
  this.datas = datas;
}
public int getTotal()
{
  return total;
}
public void setTotal(int total)
{
  this.total = total;
}
}
2.使用ThreadLocal存储分页起始索引记录位置　与　分页页面显示的记录数
package com.feihu.oa.page;
public class SystemContext {
private static ThreadLocal offset = new ThreadLocal(); //记录起始索引位置
private static ThreadLocal pagesize = new ThreadLocal(); //每页显示多少条记录

public static void setOffset(int _offset){
  offset.set(_offset);
}

public static int getOffset(){
  Integer _offset = (Integer)offset.get();
  if(_offset == null){
   return 0;
  }
  return _offset;
}

public static void removeOffset(){
  offset.remove();
}

public static void setPagesize(int _pagesize){
  pagesize.set(_pagesize);
}

public static int getPagesize(){
  Integer _pagesize = (Integer)pagesize.get();
  if(_pagesize == null){
   return Integer.MAX_VALUE;
  }
  return _pagesize;
}

public static void removePagesize(){
  pagesize.remove();
}
}


3.定义分页逻辑处理封装类AbstractManager.java
--------------------------------------------------------------------------
package com.feihu.dao;

import java.util.List;
import org.hibernate.Query;
import com.feihu.oa.manager.SystemException;
import com.feihu.oa.page.PagerModel;
import com.feihu.oa.page.SystemContext;
public abstract class AbstractManager extends MyDaoSupport
{

public PagerModel searchPaginated(String hql){
  return searchPaginated(hql, null);
}

public PagerModel searchPaginated(String hql,Object value){
  return searchPaginated(hql, new Object[]{value});
}

public PagerModel searchPaginated(String hql,Object[] values){
  return searchPaginated(hql, values, SystemContext.getOffset(), SystemContext.getPagesize());
}

public PagerModel searchPaginated(String hql,int offset,int pagesize){
  return searchPaginated(hql, null, offset, pagesize);
}

public PagerModel searchPaginated(String hql,Object value,int offset,int pagesize){
  return searchPaginated(hql, new Object[]{value}, offset, pagesize);
}

public PagerModel searchPaginated(String hql,Object[] values,int offset,int pagesize)
{
  String countHql = getCountQuery(hql);//使用传递进来的hql语句　构造出查询总记录数的语句
  Query query = getSession().createQuery(countHql);//创建hql查询语句，获取总记录数，要用session,getHibernateTemplate没有此方法
  if(values != null && values.length > 0)
  {
   for(int i = 0; i<values.length;i++)
   {
    query.setParameter(i, values[i]);
   }
  }
  int total = ((Long)query.uniqueResult()).intValue(); //返回结果只有一个时可用此方法
 
  query = getSession().createQuery(hql);//创建查询语句以获取数据集合
  query.setFirstResult(offset); //设置hibernate查询开始索引
  query.setMaxResults(pagesize); //设置hibernate查询多少条记录
  List datas = query.list();  //得到查询数据结果列表集合
 
  PagerModel pm = new PagerModel();
  pm.setDatas(datas); //将结果集合设置进　封装好的　分页类
  pm.setTotal(total);  //将总记录数设置进　　分页类
  return pm;
}
//
//
private String getCountQuery(String hql)
{
  int index = hql.indexOf("from");
  if(index!=-1)
  {
   return "select count(*) " + hql.substring(index);//hql语句中，只有查询总记录数才能用select count(*)这样的写法
  }
  throw new SystemException("无效的HQL查询语句【"+hql+"】","exception.hql.query");
}
}
++++++++++++++++++++++++++++++++++++
涉及到的其他类如下：
++++++++++++++++++++++++++++++++++++
package com.feihu.dao;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
public abstract class MyDaoSupport extends HibernateDaoSupport
{
private SessionFactory mySessionFacotry; 
    @Resource
    public void setMySessionFacotry(SessionFactory sessionFacotry) { 
        this.mySessionFacotry = sessionFacotry; 
    } 
    @PostConstruct
    public void injectSessionFactory() { 
        super.setSessionFactory(mySessionFacotry); 
    }
}
+++++++++++++++++++++++++++++++
异常信息自定义类
package com.feihu.oa.manager;
public class SystemException extends RuntimeException
{
//异常代码关键字，其值在MessageResources.properties文件定义
String key;
//可以输出一些异常时的参数
Object[] values;
public String getKey()
{
  return key;
}
public SystemException(String message,String key)
{
  super(message);
  this.key=key;
  // TODO Auto-generated constructor stub
}
public SystemException()
{
  super();
  // TODO Auto-generated constructor stub
}
public SystemException(String message, Throwable cause)
{
  super(message, cause);
  // TODO Auto-generated constructor stub
}
public SystemException(String message)
{
  super(message);
  // TODO Auto-generated constructor stub
}
public Object[] getValues()
{
  return values;
}
public SystemException(Throwable cause)
{
  super(cause);
  // TODO Auto-generated constructor stub
}
public SystemException(String message,String key,Object[] values)
{
  super(message);
  this.key = key;
  this.values = new Object[]{values};
  // TODO Auto-generated constructor stub
}

public SystemException(String message,String key,Object value)
{
  super(message);
  this.key = key;
  this.values = new Object[]{value};
  // TODO Auto-generated constructor stub
}
}
++++++++++++++++++++++++++++++++++++++++++
异常信息处理类
package com.feihu.oa.web.action;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionMessage;
import org.apache.struts.action.ExceptionHandler;
import org.apache.struts.config.ExceptionConfig;
import com.feihu.oa.manager.SystemException;
public class SystemExceptionHandler extends ExceptionHandler
{
@Override
public ActionForward execute(Exception ex, ExceptionConfig ae, ActionMapping mapping, ActionForm formInstance, HttpServletRequest request, HttpServletResponse response) throws ServletException
{
  ActionForward forward = null;
  if(ae.getPath() != null)
  {
   forward = new ActionForward(ae.getPath());
  }else
  {
   forward = mapping.getInputForward();
  }
   if (ex instanceof SystemException)
  {
    SystemException sysex = (SystemException) ex;
    String key = sysex.getKey();
    ActionMessage error = null;
    if(key==null)
    {
     error= new ActionMessage(sysex.getKey(),sysex.getMessage());
    }else if(sysex.getValues()!=null)
    {
     error=new ActionMessage(key,sysex.getValues());
    }
    this.storeException(request, key, error, forward, ae.getScope());
  
  }
  return super.execute(ex, ae, mapping, formInstance, request, response);
}
}
++++++++++++++++++++++++++++++++++++++++++
struts-config.xml文件配置
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE struts-config PUBLIC
          "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
          "http://struts.apache.org/dtds/struts-config_1_3.dtd">
<struts-config>

<form-beans>
  <form-bean name="orgform"
   type="com.feihu.oa.web.formbean.OrgForm">
  </form-bean>
</form-beans>
<global-exceptions>
  <exception key="errors.detail"
   type="com.feihu.oa.manager.SystemException"
   path="/common/exception.jsp" scope="request"
   handler="com.feihu.oa.web.action.SystemExceptionHandler" />
</global-exceptions>
<action-mappings>
  <action path="/org" parameter="method" name="orgform">
   <!-- struts异常自动处理 -->
   <!--   <exception key="errors.detail" type="java.lang.RuntimeException" path="/common/exception.jsp" scope="request"/>
   -->
   <!-- 自定义异常 -->
   <forward name="index" path="/org/index.jsp"></forward>
   <forward name="add_input" path="/org/add_input.jsp"></forward>
   <forward name="add_success"
    path="/common/pub_add_success.jsp">
   </forward>
   <forward name="del_success"
    path="/common/pub_del_success.jsp">
   </forward>
   <!--  forward name="exception" path="/common/exception.jsp"></forward>-->
  </action>
</action-mappings>
<controller><!-- spring提供的，用于管理 structs请求的action,控制器根据当前的action的path寻找bean,用bean对应的action处理请求 -->
  <set-property property="processorClass"
   value="org.springframework.web.struts.DelegatingRequestProcessor" />
</controller><!--配置spring控制器-->
<!-- 使用异常机制时要定义这个资源树文件 -->
<message-resources parameter="MessageResources"></message-resources>
</struts-config>

-------------------------------------------------------------------------------
4.定义PagerFilter过滤类，从TreadLocal中获取并设置初始化分页参数

package com.feihu.web.filter;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import com.feihu.oa.page.SystemContext;

public class PagerFilter implements Filter {
public void destroy() {
}
public void doFilter(ServletRequest request, ServletResponse response,
   FilterChain chain) throws IOException, ServletException {
 
  HttpServletRequest httpRequest = (HttpServletRequest)request;
 
  SystemContext.setOffset(getOffset(httpRequest));
  SystemContext.setPagesize(getPagesize(httpRequest));
 
  try{
   chain.doFilter(request, response);
  }finally{
   SystemContext.removeOffset();
   SystemContext.removePagesize();
  }
}

private int getOffset(HttpServletRequest request){
  int offset = 0;
  try {
   offset = Integer.parseInt(request.getParameter("pager.offset"));
  } catch (Exception ignore) {
  }
  return offset;
}

private int getPagesize(HttpServletRequest request){
  return 10;
}
public void init(FilterConfig arg0) throws ServletException {
}
}
-----------------------------------------------------------------------------
5.配置web.xml文件，将过滤类加入到web.xml文件中
<filter>
  <filter-name>PagerFilter</filter-name>
  <filter-class>com.feihu.web.filter.PagerFilter</filter-class>
</filter>
<filter-mapping>
  <filter-name>PagerFilter</filter-name>
  <url-pattern>
@Override
protected ActionForward unspecified(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception
{
  OrgForm formbean = (OrgForm)form;
  Integer parentId = formbean.getParentId();
  request.setAttribute("orgs", orgManager.searchOrgs(parentId));
 
  int ppid=0;
  if(formbean.getParentId()!=null && formbean.getParentId()>0)
  {
   Organization org = orgManager.findOrg(formbean.getParentId());
   Organization parent = org.getParent();
   if(parent!=null)
   {
    ppid = parent.getId();
   }
  }
  request.setAttribute("ppid", ppid);
  return mapping.findForward("index");
}
public ActionForward addInput(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception
{
 
  return mapping.findForward("add_input");
}
public ActionForward add(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception
{
  OrgForm formbean = (OrgForm)form;
  Integer parentId=formbean.getParentId();
  Organization org = new Organization();
  BeanUtils.copyProperties(org, formbean);

  return mapping.findForward("add_success");
}
public ActionForward del(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception
{
  OrgForm formbean = (OrgForm)form;
 

  return mapping.findForward("del_success");
}
}