SSH框架中的部分代码记录

首先在applicationContext.xml文件中配置

    <!-- 打开组件扫描 -->
    <context:component-scan base-package="cn.com.*" />

封装一个父类

package cn.com.*.core.web;

import java.io.IOException;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.apache.struts2.ServletActionContext;
import com.opensymphony.xwork2.ActionSupport;

/**描述：struts 工具类<br>
 */
public class Struts2Action extends ActionSupport {

    public int page;
    public int rows;

   /**
     * 方法名称: getHttpSession<br>
     * 描述：获取session对象
     * @return
     */
    public HttpSession getHttpSession(){
        return getHttpServletRequest().getSession();
    }

/**
     * 方法名称: getHttpSession<br>
     * 描述：获取session对象
     * @param flag
     * @return
     */
    public HttpSession getHttpSession(boolean flag){
        return getHttpServletRequest().getSession(flag);
    }
    
    /**
     * 方法名称: getHttpServletRequest<br>
     * 描述：获取request对象
     * @return
     */
    public HttpServletRequest getHttpServletRequest(){
        return ServletActionContext.getRequest();
    }
    /**
     * 方法名称: getHttpServletResponse<br>
     * 描述：获取response对象
     * @return
     */
    public HttpServletResponse getHttpServletResponse(){
        return ServletActionContext.getResponse();
    }
    /**
     * 方法名称: getServletContext<br>
     * 描述：获取servletContext对象
     * @return
     */
    public ServletContext getServletContext(){
        return ServletActionContext.getServletContext();
    }
    
    /**
     * 方法名称: setRequestAttribute<br>
     * 描述：设置request 属性
     * @param name
     * @param value
     */
    public void setRequestAttribute(String name,Object value){
        this.getHttpServletRequest().setAttribute(name, value);
    }

    /**
     * 方法名称: getParameter<br>
     * 描述：获取参数
     * @param name
     * @return
     */
    public String getParameter(String name){
        return this.getHttpServletRequest().getParameter(name);
    }
    
    /**
     * 方法名称: render<br>
     * 描述：返回给浏览器
     * @param text
     * @param contentType
     */
    public void render(String text, String contentType){
        HttpServletResponse response;
        try{
          response = getHttpServletResponse();
          response.setContentType(contentType);
          response.getWriter().write(text);
          response.getWriter().flush();
        }
        catch (IOException e) {
          throw new IllegalStateException(e);
        }
    }
    
    /**
     * 方法名称: renderText<br>
     * 描述：返回普通文本浏览器
     * @param text
     */
    public void renderText(String text){
        render(text, "text/plain;charset=UTF-8");
    }
    
    /**
     * 方法名称: renderHtml<br>
     * 描述：返回HTML格式浏览器
     * @param text
     */
    public void renderHtml(String text){
        render(text, "text/html;charset=UTF-8");
    }

    /**
     * 方法名称: renderXML<br>
     * 描述：返回XML格式浏览器
     * @param text
     */
    public void renderXML(String text){
        render(text, "text/xml;charset=UTF-8");
    }
    
    
    /**
     * 方法名称: renderJson<br>
     * 描述：返回JSON格式数据
     * @param text
     */
    public void renderJson(String text){
        render(text,"text/json;charset=UTF-8");
    }

    public int getPage() {
        return page;
    }

    public void setPage(int page) {
        this.page = page;
    }

    public int getRows() {
        return rows;
    }

    public void setRows(int rows) {
        this.rows = rows;
    }   
}
所有子类继承父类

package cn.com.*.web.business;

import java.io.BufferedOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import net.sf.json.JsonConfig;
import org.apache.struts2.convention.annotation.Action;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class OrderAction extends Struts2Action{

@Action(value="orderList")
    public String jumpOrderListPage(){
        return "/page/orderList";
    }

@Action(value="findOrderData")
    public void findOrderData(){

         Page<GeOrder> pageobj = orderService.getOrderByPage(geOrder, policyCode, page, rows);
        OrderDto orderDto = new OrderDto();
        orderDto.setTotal(pageobj.getTotal()+"");
        List<GeOrder> orders = (List<GeOrder>)pageobj.getData();
        List<OrderRow> rows = new ArrayList<OrderDto.OrderRow>();
        for (GeOrder geOrder : orders) {
            OrderRow row = new OrderRow();

           ......

           rows.add(row);

        }

         orderDto.setRows(rows);
        JsonConfig jsonConfig = new JsonConfig();
        jsonConfig.registerJsonValueProcessor(Date.class , new JsonDateValueProcessor("yyyy-MM-dd"));
        renderJson(JsonUtils.convertObject(orderDto,jsonConfig));

  }

}

定义分页类

public class Page<T> implements Serializable{
    private static final long serialVersionUID = 1L;
    private static final int DEFAULT_PAGE_SIZE = 20;
    private int pageSize;
    private int pageNo;
    private int total;
    private List<T> data;
  
    public Page(int pageNo) {
        this(DEFAULT_PAGE_SIZE,pageNo);
    }
    
    public Page(int pageSize, int pageNo) {
        this.pageSize = pageSize;
        this.pageNo = pageNo;
        this.total = total;
    }
    
    public Page(int pageSize, int pageNo, int total, List data) {
        super();
        this.pageSize = pageSize;
        this.pageNo = pageNo;
        this.total = total;
        this.data = data;
    }

    public int getPageSize() {
        return pageSize;
    }
    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }
    
    public int getPageNo() {
        return pageNo;
    }

    public void setPageNo(int pageNo) {
        this.pageNo = pageNo;
    }

    public int getTotal() {
        return total;
    }
    public void setTotal(int total) {
        this.total = total;
    }
    public List getData() {
        return data;
    }
    public void setData(List data) {
        this.data = data;
    }
    
    public int getTotalPageCount(){
        if(this.total % this.pageSize==0){
            return this.total/ this.pageSize;
        }
        else{
            return this.total/ this.pageSize +1;
        }
    }
}
定义一个父类实体DAO

package cn.com.*.core.hibernate;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Projections;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.dao.DataAccessException;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.util.Assert;
import cn.com.sinosoft.core.exception.PersistenceException;
import cn.com.sinosoft.core.exception.enumerate.ExceptionGrade;

public class EntityDao extends HibernateDaoSupport implements ApplicationContextAware{
    /**sprign 上下文环境*/
    private  ApplicationContext applicationContext;
    
    /**
     * 方法名称: get<br>
     * 描述：获取单个实体
     * @param entityClass 实体类
     * @param id 组件
     * @return 返回单个实体
     */
    public <T> T get(Class<T> entityClass,Serializable id){
        return get(entityClass,id,false);
    }
    
    /**
     * 方法名称: get<br>
     * 描述：获取单个实体，是否启动查询缓存
     * @param entityClass
     * @param id
     * @param isQueryCache
     * @return
     */
    public <T> T get(Class<T> entityClass,Serializable id ,boolean isQueryCache){
        HibernateTemplate hibernateTemplate = getHibernateTemplate();
        hibernateTemplate.setCacheQueries(isQueryCache);
        try {
            return getHibernateTemplate().get(entityClass, id);
        } catch (DataAccessException e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
    }
    
    /**
     * 方法名称: get<br>
     * 描述：获取单个实体，是否启动查询缓存 ,锁机制
     * @param <T>
     * @param entityClass
     * @param id
     * @param isQueryCache
     * @param lockMode
     * @return
     */
    public <T> T get(Class<T> entityClass,Serializable id ,boolean isQueryCache,LockMode lockMode){
        HibernateTemplate hibernateTemplate = getHibernateTemplate();
        hibernateTemplate.setCacheQueries(isQueryCache);
        hibernateTemplate.lock(entityClass, lockMode);
        try {
            return getHibernateTemplate().get(entityClass, id);
        } catch (DataAccessException e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
    }
    
    /**
     * 方法名称: getAll<br>
     * 描述：查询所有实体
     * @param entityClass
     * @return
     */
    public <T> List<T> getAll(Class<T> entityClass){
        return getAll(entityClass,false);
    }
    /**
     * 方法名称: getAll<br>
     * 描述：获取所有实体,是否开启查询缓存
     * @param entityClass 实体类
     * @param isQueryCache 是否开启查询缓存
     * @return 返回所有实体
     */
    public <T> List<T> getAll(Class<T> entityClass,boolean isQueryCache){
        HibernateTemplate hibernateTemplate = getHibernateTemplate();
        hibernateTemplate.setCacheQueries(isQueryCache);
        try {
            return hibernateTemplate.loadAll(entityClass);
        } catch (DataAccessException e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
        
    }
    
    /**
     * 方法名称: getAll<br>
     * 描述：获取所有实体,是否开启查询缓存,锁机制
     * @param entityClass 实体类
     * @param isQueryCache 是否开启查询缓存
     * @return 返回所有实体
     */
    public <T> List<T> getAll(Class<T> entityClass,boolean isQueryCache,LockMode lockMode){
        HibernateTemplate hibernateTemplate = getHibernateTemplate();
        hibernateTemplate.setCacheQueries(isQueryCache);
        hibernateTemplate.lock(entityClass, lockMode);
        try {
            return hibernateTemplate.loadAll(entityClass);
        } catch (DataAccessException e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
        
    }
    /**
     * 方法名称: save<br>
     * 描述：保存单个实体
     * @param entity 实体对象
     */
    public void save(Object entity){
        try {
            getHibernateTemplate().saveOrUpdate(entity);
        } catch (DataAccessException e) {
            throw new PersistenceException(ExceptionGrade.SEVERITY,e);
        }
        
    }
    /**
     * 方法名称: saveEntity<br>
     * 描述：增加单个实体
     * @param entity 实体对象
     */
    public void saveEntity(Object entity){
        try {
            getHibernateTemplate().save(entity);
        } catch (DataAccessException e) {
            throw new PersistenceException(ExceptionGrade.SEVERITY,e);
        }
    }
    
    /**
     * 方法名称: update<br>
     * 描述：更新单个实体
     * @param entity
     */
    public void update(Object entity){
        try {
            getHibernateTemplate().update(entity);
        } catch (DataAccessException e) {
            throw new PersistenceException(ExceptionGrade.SEVERITY,e);
        }
        
    }
    /**
     * 方法名称: saveAll<br>
     * 描述：保存多个实体
     * @param entitys 多个实体
     */
    public void saveAll(List entitys ){
        try {
            getHibernateTemplate().saveOrUpdateAll(entitys);
        } catch (DataAccessException e) {
            throw new PersistenceException(ExceptionGrade.SEVERITY,e);
        }
        
    }
    
    /**
     * 方法名称: delete<br>
     * 描述：删除一个实体
     * @param entity 实体
     */
    public void delete(Object entity){
        try {
            getHibernateTemplate().delete(entity);
        } catch (DataAccessException e) {
            throw new PersistenceException(ExceptionGrade.SEVERITY,e);
        }
        
    }
    /**
     * 方法名称: deleteAll<br>
     * 描述：删除多个实体
     * @param entitys 多个实体
     */
    public void deleteAll(List entitys){
        try {
            getHibernateTemplate().deleteAll(entitys);
        } catch (DataAccessException e) {
            throw new PersistenceException(ExceptionGrade.SEVERITY,e);
        }
        
    }
    
    /**
     * 方法名称: deleteByPk<br>
     * 描述：按主键删除某个实体
     * @param entity 实体
     * @param id 主键
     */
    public <T> void deleteByPk(Class<T> entity,Serializable id){
        Object obj = get(entity,id);
        if(obj != null){
            delete(obj);
        }
    }

    /**
     * 方法名称: evict<br>
     * 描述：把指定的缓存对象进行清除
     * @param entity
     */
    public void evict(Object entity){
        try {
            getHibernateTemplate().evict(entity);
        } catch (DataAccessException e) {
            throw new PersistenceException(ExceptionGrade.SEVERITY,e);
        }
        
    }
    
    /**
     * 方法名称: clear<br>
     * 描述：把所有的缓存对象删除
     */
    public void clear(){
        try {
            getHibernateTemplate().clear();
        } catch (DataAccessException e) {
            throw new PersistenceException(ExceptionGrade.SEVERITY,e);
        }
        
    }
    
    /**
     * 方法名称: findByHql<br>
     * 描述：HQL 查询多条记录
     * @param hql hql 语句
     * @param values 参数值
     * @return 多个实体
     */
    public List findByHql(final String hql,final Object[] values){
        //如果hql不是字符串会抛出IllegalArgumentException违法的参数
        Assert.hasText(hql);
        try {
            List list = getHibernateTemplate().executeFind(new HibernateCallback() {
                public Object doInHibernate(Session session)
                        throws HibernateException, SQLException {
                    Query query = session.createQuery(hql);
                    for(int i=0;i<values.length;i++){
                        query.setParameter(i, values[i]);
                    }
                    return query.list();
                }
            });
            return list;
        } catch (Exception e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
        
        
    }
    
    /**
     * 方法名称: findByHql<br>
     * 描述：HQL 查询多条记录
     * @param hql hql 语句
     * @param values 参数值
     * @return 多个实体
     */
    public List findByHql(final String hql,final List values){
        //如果hql不是字符串会抛出IllegalArgumentException违法的参数
        Assert.hasText(hql);
        try {
            List list = getHibernateTemplate().executeFind(new HibernateCallback() {
                public Object doInHibernate(Session session)
                        throws HibernateException, SQLException {
                    Query query = session.createQuery(hql);
                    for(int i=0;i<values.size();i++){
                        query.setParameter(i, values.get(i));
                    }
                    return query.list();
                }
            });
            return list;
        } catch (Exception e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
        
        
    }
    
    
    /**
     * 方法名称: findByHql<br>
     * 描述：HQL 查询多条记录,锁机制
     * @param hql hql 语句
     * @param values 参数值
     * @return 多个实体
     */
    public List findByHql(final String hql,final Object[] values,final String lockTable,final LockMode lockMode){
        //如果hql不是字符串会抛出IllegalArgumentException违法的参数
        Assert.hasText(hql);
        try {
            List list = getHibernateTemplate().executeFind(new HibernateCallback() {
                public Object doInHibernate(Session session)
                        throws HibernateException, SQLException {
                    Query query = session.createQuery(hql);
                    query.setLockMode(lockTable, lockMode);
                    for(int i=0;i<values.length;i++){
                        query.setParameter(i, values[i]);
                    }
                    return query.list();
                }
            });
            return list;
        } catch (Exception e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
        
        
    }
    
    /**
     * 方法名称: findByHql<br>
     * 描述：HQL 查询多条记录
     * @param hql hql 语句
     * @param top 多少条记录
     * @param values 参数值
     * @return 多个实体
     */
    public List findByHql(final String hql,final int top ,final Object[] values){
        //如果hql不是字符串会抛出IllegalArgumentException违法的参数
        Assert.hasText(hql);
        try {
            List list = getHibernateTemplate().executeFind(new HibernateCallback() {
                public Object doInHibernate(Session session)
                        throws HibernateException, SQLException {
                    Query query = session.createQuery(hql);
                    for(int i=0;i<values.length;i++){
                        query.setParameter(i, values[i]);
                    }
                    query.setFirstResult(0);
                    query.setMaxResults(top);
                    return query.list();
                }
            });
            return list;
        } catch (Exception e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
        
        
    }
    
    /**
     * 方法名称: findByHql<br>
     * 描述：HQL 查询多条记录,锁机制
     * @param hql hql 语句
     * @param top 多少条记录
     * @param values 参数值
     * @return 多个实体
     */
    public List findByHql(final String hql,final int top ,final Object[] values,final String lockTable,final LockMode lockMode){
        //如果hql不是字符串会抛出IllegalArgumentException违法的参数
        Assert.hasText(hql);
        try {
            List list = getHibernateTemplate().executeFind(new HibernateCallback() {
                public Object doInHibernate(Session session)
                        throws HibernateException, SQLException {
                    Query query = session.createQuery(hql);
                    query.setLockMode(lockTable, lockMode);
                    for(int i=0;i<values.length;i++){
                        query.setParameter(i, values[i]);
                    }
                    query.setFirstResult(0);
                    query.setMaxResults(top);
                    return query.list();
                }
            });
            return list;
        } catch (Exception e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
        
        
    }
    
    /**
     * 方法名称: findByHql<br>
     * 描述：分页查询多条记录
     * @param hql hql 语句
     * @param pageNo 页号（从1开始）
     * @param pageSize 页码大小
     * @param values 参数值
     * @return page对象
     */
    public Page findByHql(final String hql,final int pageNo,final int pageSize ,final Object[] values){
        //如果hql不是字符串会抛出IllegalArgumentException违法的参数
        Assert.hasText(hql);
        try {
            List list = getHibernateTemplate().executeFind(new HibernateCallback() {
                public Object doInHibernate(Session session)
                        throws HibernateException, SQLException {
                    Query query = session.createQuery(hql);
                    for(int i=0;i<values.length;i++){
                        query.setParameter(i, values[i]);
                    }
                    query.setFirstResult((pageNo-1)*pageSize);
                    query.setMaxResults(pageSize);
                    return query.list();
                }
            });
            
            final String newHql = "SELECT COUNT(1) "+hql.substring(hql.toUpperCase().indexOf("FROM"));
            Object total  = getHibernateTemplate().execute(new HibernateCallback() {
                public Object doInHibernate(
                        Session session) throws HibernateException, SQLException {
                    Query query = session.createQuery(newHql);
                    for(int i=0;i<values.length;i++){
                        query.setParameter(i, values[i]);
                    }
                    return query.uniqueResult();
                }
            });
            return new Page(pageSize, pageNo, Integer.parseInt(total.toString()), list);
        } catch (Exception e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
        
        
    }
    

    /**
     * 方法名称: findByHql<br>
     * 描述：分页查询多条记录
     * @param hql
     * @param pageNo
     * @param pageSize
     * @param values
     * @return
     */
    public Page findByHql(final String hql,final int pageNo,final int pageSize ,final List values){
        //如果hql不是字符串会抛出IllegalArgumentException违法的参数
        Assert.hasText(hql);
        try {
            List list = getHibernateTemplate().executeFind(new HibernateCallback() {
                public Object doInHibernate(Session session)
                        throws HibernateException, SQLException {
                    Query query = session.createQuery(hql);
                    for(int i=0;i<values.size();i++){
                        query.setParameter(i, values.get(i));
                    }
                    query.setFirstResult((pageNo-1)*pageSize);
                    query.setMaxResults(pageSize);
                    return query.list();
                }
            });
            
            final String newHql = "select count(*) "+hql.substring(hql.toUpperCase().indexOf("FROM"));
            Object total  = getHibernateTemplate().execute(new HibernateCallback() {
                public Object doInHibernate(
                        Session session) throws HibernateException, SQLException {
                    Query query = session.createQuery(newHql);
                    for(int i=0;i<values.size();i++){
                        query.setParameter(i, values.get(i));
                    }
                    return query.uniqueResult();
                }
            });
            return new Page(pageSize, pageNo, Integer.parseInt(total.toString()), list);
        } catch (Exception e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
    }
    
    /**
     * 方法名称: findByHql<br>
     * 描述：分页查询多条记录,锁机制
     * @param hql hql 语句
     * @param pageNo 页号（从1开始）
     * @param pageSize 页码大小
     * @param values 参数值
     * @return page对象
     */
    public Page findByHql(final String hql,final int pageNo,final int pageSize ,final Object[] values,final String lockTable,final LockMode lockMode){
        //如果hql不是字符串会抛出IllegalArgumentException违法的参数
        Assert.hasText(hql);
        try {
            List list = getHibernateTemplate().executeFind(new HibernateCallback() {
                public Object doInHibernate(Session session)
                        throws HibernateException, SQLException {
                    Query query = session.createQuery(hql);
                    query.setLockMode(lockTable, lockMode);
                    for(int i=0;i<values.length;i++){
                        query.setParameter(i, values[i]);
                    }
                    query.setFirstResult((pageNo-1)*pageSize);
                    query.setMaxResults(pageSize);
                    return query.list();
                }
            });
            
            String newHql = "SELECT COUNT(1) "+hql.toUpperCase().substring(hql.toUpperCase().indexOf("FROM"));
            Object total  = getHibernateTemplate().execute(new HibernateCallback() {
                public Object doInHibernate(
                        Session session) throws HibernateException, SQLException {
                    Query query = session.createQuery(hql);
                    for(int i=0;i<values.length;i++){
                        query.setParameter(i, values[i]);
                    }
                    return query.uniqueResult();
                }
            });
            return new Page(pageSize, pageNo, Integer.parseInt(total.toString()), list);
        } catch (Exception e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
        
        
    }
    
    /**
     * 方法名称: findUnique<br>
     * 描述：查询唯一数据
     * @param entityClass
     * @param propertyName
     * @param value
     * @return 单个实体
     */
    public <T> T findUnique(Class<T> entityClass,String propertyName,Object value){
        try {
            QueryRule queryRule = QueryRule.getInstance();
            queryRule.addEqual(propertyName, value);
            List<T> list = find(entityClass, queryRule);
            if(list.isEmpty()){
                return null;
            }
            if(list.size() ==1){
                return list.get(0);
            }
            else{
                throw new IllegalStateException("查询出"+list.size()+"条数据，不合法");
            }
        } catch (Exception e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
        
    }
    
    /**
     * 方法名称: find<br>
     * 描述：查询
     * @param entityClass
     * @param queryRule
     * @return 多条数据
     */
    public <T> List<T> find(final Class<T> entityClass,final QueryRule queryRule){
        try {
            List<T> list = getHibernateTemplate().execute(new HibernateCallback<List<T>>() {
                public List<T> doInHibernate(Session session) throws HibernateException,
                        SQLException {
                    Criteria criteria = session.createCriteria(entityClass);
                    QueryRuleUtils.initCriteriaByQueryRule(criteria, queryRule);
                    List<T> list = criteria.setFirstResult(0).list();
                    return list;
                }
            });
            return list;
        } catch (Exception e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
        
    }
    
    
    /**
     * 方法名称: find<br>
     * 描述：查询,锁机制
     * @param entityClass
     * @param queryRule
     * @return 多条数据
     */
    public <T> List<T> find(final Class<T> entityClass,final QueryRule queryRule,final LockMode lockMode){
        try {
            List<T> list = getHibernateTemplate().execute(new HibernateCallback<List<T>>() {
                public List<T> doInHibernate(Session session) throws HibernateException,
                        SQLException {
                    Criteria criteria = session.createCriteria(entityClass);
                    criteria.setLockMode(lockMode);
                    QueryRuleUtils.initCriteriaByQueryRule(criteria, queryRule);
                    List<T> list = criteria.setFirstResult(0).list();
                    return list;
                }
            });
            return list;
        } catch (Exception e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
        
    }
    
    /**
     * 方法名称: exists<br>
     * 描述：是否存在实体
     * @param entityClass
     * @param id 主键
     * @return
     */
    public <T> boolean exists(Class<T> entityClass,Serializable id){
        try {
            Object entity = getHibernateTemplate().get(entityClass, id);
            return (entity != null);
        } catch (Exception e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
        
    }
    
    /**
     * 方法名称: find<br>
     * 描述：分页查询实体条数
     * @param entityClass
     * @param queryRule
     * @param pageNo
     * @param pageSize
     * @return 分页查询实体条数
     */
    public <T> Page find(final Class<T> entityClass,final QueryRule queryRule,final int pageNo,final int pageSize){
        try {
            Page page = getHibernateTemplate().execute(new HibernateCallback<Page>() {
                public Page doInHibernate(Session session) throws HibernateException,
                        SQLException {
                    Criteria criteria = session.createCriteria(entityClass);
                    QueryRuleUtils.initCriteriaByQueryRule(criteria, queryRule);
                    int total = findTotal(entityClass, session,queryRule);
                    criteria.setFirstResult((pageNo-1)*pageSize);
                    //criteria.setMaxResults(pageNo*pageSize);
                    criteria.setMaxResults(pageSize);
                    List list = criteria.list();
                    Page page = new Page(pageSize, pageNo, total, list);
                    return page;
                }
            });
            return page;
        } catch (Exception e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
        
        
    }
    /**
     * 方法名称: findTotal<br>
     * 描述：找总数
     * @param <T>
     * @param entityClass
     * @param session
     * @return
     */
    public <T> int findTotal(Class<T> entityClass,Session session,QueryRule queryRule){
        try {
            Criteria criteria = session.createCriteria(entityClass);
            QueryRuleUtils.initCriteriaByQueryRule(criteria, queryRule);
            return ((Number)criteria.setProjection(Projections.rowCount()).uniqueResult()).intValue();
        } catch (Exception e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
        
    }
    
    /**
     * 根据hql更新实体字段
     * @param hql
     * @param values
     */
    public void updateByHql(final String hql , final Object[] values){
        //如果hql不是字符串会抛出IllegalArgumentException违法的参数
        Assert.hasText(hql);
        try {
            getHibernateTemplate().bulkUpdate(hql, values) ;
        } catch (Exception e) {
            throw new PersistenceException(ExceptionGrade.GENERAL,e);
        }
    }
    
    /**方法名称：setApplicationContext <br>
     * 描述： <br>
     * @param arg0
     * @throws BeansException
     */
    public void setApplicationContext(ApplicationContext applicationContext)
            throws BeansException {
        this.applicationContext = applicationContext;
    }

    public ApplicationContext getApplicationContext() {
        return applicationContext;
    }
   
}

新建工具类JsonUtils

public class JsonUtils {
    /**
     * 方法名称: convertObject<br>
     * 描述：把对象类型转换成json格式
     * 作者: honghui
     * 修改日期：2013年12月22日下午5:40:53
     * @return
     */
    public static String convertObject(Object object){
        JSONObject json = JSONObject.fromObject(object);
        return json.toString();
    }
    
    /**
     * 方法名称: convertObject<br>
     * 描述：把对象类型转换成json格式
     * @param object
     * @param jsonConfig
     * @return
     */
    public static String convertObject(Object object,JsonConfig jsonConfig){
        JSONObject json = JSONObject.fromObject(object,jsonConfig);
        return json.toString();
    }
    /**
     * 方法名称: convertObjectIncludeDate<br>
     * 描述：转换对象，包换日期格式
     * @param object
     * @param dateFormat
     * @return
     */
    public static String convertJsonIncludeDate(Object object,String dateFormat){
        JsonConfig jsonConfig = new JsonConfig();
        jsonConfig.registerJsonValueProcessor(Date.class , new JsonDateValueProcessor(dateFormat));
        JSONObject json = JSONObject.fromObject(object,jsonConfig);
        return json.toString();
    }
    
    /**
     * 方法名称: convertArray<br>
     * 描述：把对象类型转换成数组json
     * @param object
     * @return
     */
    public static String convertArray(Object object){
        JSONArray jsonArray =  JSONArray.fromObject(object);
        return jsonArray.toString();
    }
    
    /**
     * 方法名称: convertArray<br>
     * 描述：把对象类型转换成数组json
     * @param object
     * @param jsonConfig
     * @return
     */
    public static String convertArray(Object object,JsonConfig jsonConfig){
        JSONArray jsonArray =  JSONArray.fromObject(object,jsonConfig);
        return jsonArray.toString();
    }
    
    /**
     * 方法名称: convertObject<br>
     * 描述：JSON字符串转换对象
     * @param val
     * @param clazz
     * @return
     */
    public static <T> T convertObject(String val,Class<T> clazz,Map<String, Class> map){
         T t=(T)JSONObject.toBean(JSONObject.fromObject(val),clazz , map);
            return t;
    }
    /**
     * 方法名称: convertObject<br>
     * 描述：JSON字符串转换对象包含Date类型
     * @param val
     * @param clazz
     * @return
     */
    public static <T> T convertObjectIncludeDate(String val,Class<T> clazz,Map<String, Class> map,String[] dateMorpher){
        JSONUtils.getMorpherRegistry().registerMorpher(
                  new DateMorpher(dateMorpher));
         T t=(T)JSONObject.toBean(JSONObject.fromObject(val),clazz , map);
            return t;
    }
}

页面引入ETab.js

var ETab = function(){};
ETab.prototype.reload = false;


CreateTab = function(title,id,url){
    var tab  = new ECSTab();
    tab.reload = true;
    tab.addTab(title, id, url);
};
FlushTab = function(which){
    var tab  = new ETab();
    tab.flushTab(which);
};
CloseTab = function(which){
    var tab  = new ETab();
    tab.closeTab(which);
};
/**
 * 选择菜单树，添加tab页
 * @param title
 * @param id
 * @param url
 */
ETab.prototype.addTab = function(title,id,url){
    var exists = $("#mainTab").tabs('exists',title);
    
    if(!exists){
        $("#mainTab").tabs('add',{
            id:id,
            title:title,
            content:'<iframe id="'+title+'" src="'+url+'" width="100%" height="99%" align="top" scrolling="auto" frameborder="0"></iframe>',
            closable:true,
            onBeforeOpen:function(){
                //ajaxLoading();
            },
            tools:[{
                iconCls:'icon-mini-refresh',
                handler:function(){
                    $('#mainTab').tabs('update', {
                        tab: $('#mainTab').tabs('getTab',title),
                        options: {
                        }
                    });

                }
            }]
        });
        $("#"+title).load(function(){
            //ajaxLoadEnd();
        });
    }
    else{
        var tab = $("#mainTab").tabs('getTab',title);
        this.updateTab(url, tab,title);
        $("#"+title).load(function(){
            //ajaxLoadEnd();
        });
        $("#mainTab").tabs('select',title);
    }
}


ETab.prototype.updateTab=function(url,tab,title) {
    /*$("#mainTab").tabs('update', {
        tab: tab,
        options: {
          href: url
        }
    });*/
    if(this.reload){
        $('#mainTab').tabs('update', {
            tab: tab,
            options: {
            }
        });
        
         $("#"+title).attr("src",url);
    }
    else{
        $('#mainTab').tabs('update', {
            tab: tab,
            options: {
            }
        });
    }
    
}

/**
 * 刷新标签页（如果未指定which 则刷新当前）
 * @param which 可以是选项卡面板的标题或索引
 */
ETab.prototype.flushTab=function(which){
    var tab = $('#mainTab').tabs('getSelected');
    if(which){
        tab = $('#mainTab').tabs('getTab',which);
    }
    var index = $('#mainTab').tabs('getTabIndex',tab);
    $('#mainTab').tabs('select',index);
    $('#mainTab').tabs('update', {
        tab: tab,
        options: {
        }
    });
};

/**
 * 关闭标签页（如果未指定which 则关闭当前）
 * @param which 可以是选项卡面板的标题或索引
 */
ETab.prototype.closeTab=function(which){
    var tab = $('#mainTab').tabs('getSelected');
    if(!which){
        which = $('#mainTab').tabs('getTabIndex',tab);
    }
    $('#mainTab').tabs('close', which);
};



function ajaxLoading(){
    $("<div class=\"datagrid-mask\"></div>").css({display:"block",width:"100%",height:$(window).height()}).appendTo("body");
    $("<div class=\"datagrid-mask-msg\">数据加载中...</div>").html("&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;").appendTo("body").css({display:"block",left:($(document.body).outerWidth(true)) / 2,top:($(window).height()) / 2});
 }
 function ajaxLoadEnd(){
     $(".datagrid-mask").remove();
     $(".datagrid-mask-msg").remove();            
}

新建对象JS

var Obj = function(){};

Obj.prototype.c** = null;

Obj.view = {
    text : "",
    iconCls : 'icon-search',
    handler : function() {
        var rows =$('#orderData').datagrid('getChecked');
        if(rows.length > 1){
          //提示

           $.messager.alert("提示","请选择**");

            return false;
        } else if(rows== null || rows.length == 0){
          //提示
            return false;
        }
        else{
            var row = rows[0];
            var tab = new ETab();
            tab.target = $('#mainTab', window.parent.document);
            window.parent.CreateTab("订单详情","orderInfo","url“);
        }
    }
};

/**
 * 工具栏
 */

Obj.prototype.toolbar = [];

/**
 * 初始化工具栏
 */

Order.prototype.initToolBar = function(){

         this.toolbar.push("-");
        this.toolbar.push(Obj.**);

}

/**
 * 自定义工具栏
 */
Order.prototype.initOwnToolBar = function(){
    $('.datagrid-toolbar').append("<table><tr><td></td></tr></table>");
    $('#searchBar div').appendTo('.datagrid-toolbar table:last tr td');
};

/**
 * 创建用户信息数据表格
 */
Obj.prototype.createDataGrid = function(){
    this.initToolBar();
    var that = this;
    $('#orderData').datagrid({
        toolbar : this.toolbar,
        url :**/findOrderData',
        fit : true,
        pagination:true,
        rownumbers:true,
        pageSize:20,
        pageList:[15,20,25,30],
        loading:"数据加载中...",
        //idField:"orderno",
        checkbox:true,
        width : $("#orderData").width(),
        fitColumns:true,
        columns : [ [ {
            field : 'ordern*',
            title : 'ordern*',
            hidden: true
        }, {
            checkbox:true,
            field : 'checkbox',
            title : 'checkbox'
        }, {
            field : '**',
            title : '订单号',
            width : $("#orderData").width() * 0.15,
            halign: 'center',
            align:'center'
        }, {
            field : '**',
            title : '保单号',
            width : $("#orderData").width() * 0.10,
            halign: 'center',
            align:'center'
        }, {
            field : '**',
            title : '产品名称',
            width : $("#orderData").width() * 0.2,
            halign: 'center',
            align:'center'
        }, {
            field : '**',
            title : '支付状态',
            formatter: function(value){
                return **;
            },
            halign: 'center',
            align:'center'
        }, {
            field : '**',
            title : '支付时间',
            width : $("#orderData").width() * 0.1,
            halign: 'center',
            align:'center'
        },{
            field : 'createdate',
            title : '创建时间',
            width : $("#orderData").width() * 0.1,
            halign: 'center',
            align:'center'
        /*},{
            field : '**',
            title : '配送方式',
            width : $("#orderData").width() * 0.1,
            halign: 'center',
            align:'center'*/
        },{
            field : '**',
            title : '接收人姓名',
            width : $("#orderData").width() * 0.1,
            halign: 'center',
            align:'center'
        },{
            field : '**',
            title : '订单金额',
            formatter: function(value){
                return "￥ "+value;
            },
            halign: 'center'
        } ] ]
    });
    this.initOwnToolBar();
};

页面

$(document).ready(function(){
    order.createDataGrid();
});

<body>
    <table id="orderData" width="100%"></table>
    <div id="searchBar" style="margin :0px; padding :5px;padding-right: 10px;width: 100%; display: none;">
    </div>
</body>