spring+hibernate+struts2 annotation实现分页（1）

这几天写了个ssh2分页实现，放到博客里留个记号，先贴代码有空再写说明了

@Entity(name="t_person")
public class Person implements Serializable {

	private static final long serialVersionUID = 1L;
	@Id
    @GeneratedValue(strategy=GenerationType.AUTO)
	private int id;

	@Column(length=50,name="p_name")
	private String name;

	@Column(name="p_sex",nullable=true)
	private String sex;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
}

package com.xangqun.base;

import java.io.Serializable;
import java.util.concurrent.locks.Condition;

import com.xangqun.page.OrderBy;
import com.xangqun.page.Pagination;


public interface BaseDao <T extends Serializable>{

	/**
	 * 
	 * @param eg 示例对象
	 * @param anyWhere 是否模糊查询，默认false。
	 * @param conds 排序和is null的字段。分别为OrderBy和String。
	 * @param pageNo 当前页号
	 * @param pageSize 每页记录数
	 * @param exclude 需要排除的属性
	 * @return
	 * @throws Exception 
	 */
	public Pagination find(T eg, boolean anyWhere,
			Condition[] conds, int pageNo, int pageSize, String... exclude) ;

	public Pagination findAll(int pageNo, int pageSize, OrderBy... orders);
}

package com.xangqun.base;

import static org.hibernate.EntityMode.POJO;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;

import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.criterion.Example.PropertySelector;
import org.hibernate.metadata.ClassMetadata;
import org.hibernate.type.Type;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;

import com.xangqun.page.Nullable;
import com.xangqun.page.OrderBy;
import com.xangqun.page.Pagination;

@Transactional
public abstract class BaseDaoImpl<T extends Serializable>  implements BaseDao<T> {

	public static final NotBlankPropertySelector NOT_BLANK = new NotBlankPropertySelector();

	private Class<T> persistentClass;

	protected SessionFactory sessionFactory;


	@Autowired
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}

	protected Session getSession() {
		return sessionFactory.getCurrentSession();
	}


	@SuppressWarnings("unchecked")
	public BaseDaoImpl() {
		this.persistentClass = (Class<T>) ((ParameterizedType) getClass()
				.getGenericSuperclass()).getActualTypeArguments()[0];
	}

	/**
	 * 
	 * @param eg 示例对象
	 * @param anyWhere 是否模糊查询，默认false。
	 * @param conds 排序和is null的字段。分别为OrderBy和String。
	 * @param pageNo 当前页号
	 * @param pageSize 每页记录数
	 * @param exclude 需要排除的属性
	 * @return
	 */
	@Override
	@Transactional(isolation=Isolation.DEFAULT,readOnly=true)
	public Pagination find(T eg, boolean anyWhere, Condition[] conds,
			int pageNo, int pageSize, String... exclude) {
		Order[] orderArr=null;
		Condition[] condArr=null;
		if (conds != null && conds.length > 0) {
			List<Order> orderList = new ArrayList<Order>();
			List<Condition> condList = new ArrayList<Condition>();
			for (Condition c : conds) {
				if (c instanceof OrderBy) {
					orderList.add(((OrderBy) c).getOrder());
				} else {
					condList.add(c);
				}
			}
			orderArr = new Order[orderList.size()];
			condArr = new Condition[condList.size()];
			orderArr = orderList.toArray(orderArr);
			condArr = condList.toArray(condArr);
		}
		Criteria crit = getCritByEg(eg, anyWhere, condArr, exclude);
		return findByCriteria(crit, pageNo, pageSize, null, orderArr);
	}

	@SuppressWarnings("unchecked")
	protected ClassMetadata getCmd(Class clazz) {
		return (ClassMetadata) getSessionFactory().getClassMetadata(clazz);
	}
	@Transactional(isolation=Isolation.DEFAULT,readOnly=true)
	protected Criteria getCritByEg(T eg, boolean anyWhere, Condition[] conds,
			String[] exclude) {
		System.out.println(getSession().isOpen());
		Criteria crit = getSession().createCriteria(getPersistentClass());
		Example example = Example.create(eg);
		System.out.println(eg);
		example.setPropertySelector(NOT_BLANK);
		if (anyWhere) {
			example.enableLike(MatchMode.ANYWHERE);
			example.ignoreCase();
		}
		for (String p : exclude) {
			example.excludeProperty(p);
		}
		crit.add(example);
		// 处理排序和is null字段
		if (conds != null) {
			for (Condition o : conds) {
				if (o instanceof OrderBy) {
					OrderBy order = (OrderBy) o;
					crit.addOrder(order.getOrder());
				} else if (o instanceof Nullable) {
					Nullable isNull = (Nullable) o;
					if (isNull.isNull()) {
						crit.add(Restrictions.isNull(isNull.getField()));
					} else {
						crit.add(Restrictions.isNotNull(isNull.getField()));
					}
				} else {
					// never
				}
			}
		}
		// 处理many to one查询
		ClassMetadata cm = getCmd(eg.getClass());
		String[] fieldNames = cm.getPropertyNames();
		for (String field : fieldNames) {
			Object o = cm.getPropertyValue(eg, field, POJO);
			if (o == null) {
				continue;
			}
			ClassMetadata subCm = getCmd(o.getClass());
			if (subCm == null) {
				continue;
			}
			Serializable id = subCm.getIdentifier(o, POJO);
			if (id != null) {
				Serializable idName = subCm.getIdentifierPropertyName();
				crit.add(Restrictions.eq(field + "." + idName, id));
			} else {
				crit.createCriteria(field).add(Example.create(o));
			}
		}
		return crit;
	}
	@Transactional(isolation=Isolation.DEFAULT,readOnly=true)
	 protected Pagination findByCriteria(Criteria crit, int pageNo,
			int pageSize, Projection projection, Order... orders) {
		int totalCount = ((Number) crit.setProjection(Projections.rowCount())
				.uniqueResult()).intValue();
		Pagination p = new Pagination(pageNo, pageSize, totalCount);
		if (totalCount < 1) {
			p.setList(new ArrayList());
			return p;
		}
		crit.setProjection(projection);
		if (projection == null) {
			crit.setResultTransformer(Criteria.ROOT_ENTITY);
		}
		if (orders != null) {
			for (Order order : orders) {
				crit.addOrder(order);
			}
		}
		crit.setFirstResult(p.getFirstResult());
		crit.setMaxResults(p.getPageSize());
		p.setList(crit.list());
		return p;
	}

	static final class NotBlankPropertySelector implements PropertySelector {
		private static final long serialVersionUID = 1L;

		public boolean include(Object object, String property, Type type) {
			return object != null
					&& !(object instanceof String && StringUtils
							.isBlank((String) object));
		}
	}
	public Pagination findAll(int pageNo, int pageSize, OrderBy... orders) {
		Criteria crit = createCriteria();
		return findByCriteria(crit, pageNo, pageSize, null, OrderBy
				.asOrders(orders));
	}
	protected Criteria createCriteria(Criterion... criterions) {
		Criteria criteria = getSession().createCriteria(getPersistentClass());
		for (Criterion c : criterions) {
			criteria.add(c);
		}
		return criteria;
	}

	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}
	public void setPersistentClass(Class<T> persistentClass) {
		this.persistentClass = persistentClass;
	}

	public Class<T> getPersistentClass() {
		return persistentClass;
	}

}

package com.xangqun.page;

/**
 * 可分页接口
 * @author xangqun
 *
 */
public interface Paginable {

	public int getTotalCount();//总数

	public int getTotalPage(); //总分页

	public boolean isFirst(); //是否第一页

	public boolean isLast();  //是否最后页

	public int getPageSize(); //每页显示个数

	public int getcurrentPage();  //取得当前页

	public int getNextPage();  //取得下一页

	public int getPrePage();  //取得前一页
}

package com.xangqun.page;

public class SimplePage implements Paginable {

	public static final int DEFAULT_COUNT = 10;

	protected int currentPage; //当前页号
	protected int pageSize; //每页记录数
	protected int totalCount; //总记录数
	protected int totalPage;

	public SimplePage(){};

	public SimplePage(int currentPage, int pageSize, int totalCount) {
		this.currentPage = currentPage<0?1:currentPage;
		this.pageSize = pageSize<0?10:pageSize;
		this.totalCount = totalCount<0?0:totalCount;
		if ((this.currentPage - 1) * this.pageSize >= totalCount) {
			this.currentPage = totalCount / pageSize;
		}
	}

	/**
	 * 调整分页参数，使合理化
	 */
	public void adjustPage() {
		if (totalCount <= 0) {
			totalCount = 0;
		}
		if (pageSize <= 0) {
			pageSize = DEFAULT_COUNT;
		}
		if (currentPage <= 0) {
			currentPage = 1;
		}
		if ((currentPage - 1) * pageSize >= totalCount) {
			currentPage = totalCount / pageSize;
		}
	}

	@Override
	public int getcurrentPage() {
		return currentPage;
	}

	@Override
	public int getPageSize() {
		return pageSize;
	}

	@Override
	public int getNextPage() {
		return isLast()?currentPage:(currentPage+1);
	}

	@Override
	public int getPrePage() {
		return isFirst()?currentPage:(currentPage-1);
	}

	@Override
	public int getTotalCount() {
		return totalCount;
	}

	@Override
	public int getTotalPage() {
		return (totalCount%pageSize!=0||totalCount==0)?(totalCount/pageSize+1):totalCount/pageSize;
	}

	@Override
	public boolean isFirst() {
		return (currentPage<=1)?true:false;
	}

	@Override
	public boolean isLast() {
		return currentPage>=totalCount?true:false;
	}

	public void setCurrentPage(int currentPage) {
		this.currentPage = currentPage;
	}

	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}

	public void setTotalCount(int totalCount) {
		this.totalCount = totalCount;
	}

	public void setTotalPage(int totalPage) {
		this.totalPage = totalPage;
	}	
}

package com.xangqun.page;

import java.io.Serializable;
import java.util.List;
/**
 * 分页实现
 * @author xangqun
 *
 */
public class Pagination extends SimplePage implements Paginable,Serializable {

	private static final long serialVersionUID = 1L;
	public List<? extends Object> list;

	public Pagination() {
	}

	public Pagination(int currentPage, int pageSize, int totalCount) {
		super(currentPage, pageSize, totalCount);
	}

	public Pagination(int currentPage, int pageSize, int totalCount, List<? extends Object> list) {
		super(currentPage, pageSize, totalCount);
		this.list = list;
	}

	public int getFirstResult() {
		return (currentPage - 1) * pageSize;
	}

	public List<? extends Object> getList() {
		return list;
	}

	public void setList(List<? extends Object> list) {
		this.list = list;
	}

}

package com.xangqun.page;

import java.io.Serializable;

public class Condition implements Serializable {
	private static final long serialVersionUID = 1L;
	protected String field;

	public String getField() {
		return field;
	}
}

package com.xangqun.page;

public class Nullable  extends Condition {

	private static final long serialVersionUID = 1L;
	private boolean isNull;

	public Nullable(String field, boolean isNull) {
		this.field = field;
		this.isNull = isNull;
	}

	public static Nullable isNull(String field) {
		return new Nullable(field, true);
	}

	public static Nullable isNotNull(String field) {
		return new Nullable(field, false);
	}

	public boolean isNull() {
		return isNull;
	}
}

package com.xangqun.page;

import org.hibernate.criterion.Order;

public class OrderBy extends Condition{

	private static final long serialVersionUID = 1L;
	public static enum OrderType {
		ASC, DESC
	}
	private OrderType orderType;

	public OrderBy(){}
	public OrderBy(String field,OrderType orderType){
		this.field=field;
		this.orderType=orderType;
	}

	public static OrderBy asc(String field) {
		return new OrderBy(field, OrderType.ASC);
	}

	public static OrderBy desc(String field) {
		return new OrderBy(field, OrderType.DESC);
	}

	public Order getOrder(){
		Order order = null;
		if (OrderType.ASC == orderType) {
			order = Order.asc(getField());
		} else if (OrderType.DESC == orderType) {
			order = Order.desc(getField());
		}
		return order;
	}

	public static Order[] asOrders(OrderBy[] orderBys) {
		if (orderBys != null) {
			Order[] orders = new Order[orderBys.length];
			for (int i = 0; i < orderBys.length; i++) {
				orders[i] = orderBys[i].getOrder();
			}
			return orders;
		} else {
			return null;
		}

	}
}