分页查询的实现

看到robbin的"应用Hibernate3的DetachedCriteria实现分页查询",我把最近的写的关于
分页方法的算法拿出来现一下丑，还请大家手下留情，^_^

1.PaginationMethod.java
[code]
package com.airinbox.pagination;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
* 用于标识支持分页的方法，如果一个类中有多个用PaginationMethod标识的方法，请指定name，否则将
* 不能正确的得到方法。另外此注释支持从超类或者接口中查询此注释类型。
* @author wuyunlong
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface PaginationMethod {
/**
* 为此方法指定的名称。
*
* @return 返回方法的名称。
*/
public String name() default "";

/**
* 在方法中记录偏移量的参数位置，默认为0。
*
* @return 返回方法中记录偏移量的参数位置。
*/
public int offsetParamIndex() default 0;

/**
* 在方法中记录最大返回长度的参数位置，默认为1。
*
* @return
*/
public int maxLengthParamIndex() default 1;

/**
* 用户表示返回的列表中是否全部的元素还是分页的元素。
*
* @return 返回true，表示全部元素，此时offsetParamIndex和maxLengthParamIndex的值将
* 不会再起作用；否则表示返回分页的元素。
*/
public boolean all() default false;
}
[/code]


2.Pagination.java
[code]
package com.airinbox.pagination;

import java.util.Collection;

/**
* 分页导航属性信息。
*
* @author wuyunlong
*
* @param <T>
* Method的返回集合（目前只支持数组类型和java.util.Collection类型急子类型的返
* 回类型)中元素的类型。
*/
public interface Pagination {
/**
* 返回结果，则这个被包装成了Collection类型。
* @return
*/
public Collection<?> getMethodReturnValue();
/**
* 表示是否有下一页。
* @return
*/
public boolean hasNext();
/**
* 用户判断是否有前页。
* @return 布尔值。
*/
public boolean hasBefore();

public int getCurrentPageNumber();

/**
* n的默认值，为1。
*/
public static final int DEFAULT_N = 1;
/**
* 判断是否包含上n页的值。
* @return 布尔值。
*/
public boolean hasFollowingSeveralPages();
/**
* 判断是否包含下n页的值。
* @return 布尔值。
*/
public boolean hasFormerSeveralPages();

public int getFollowingSeveralPagesNumberMax();
/**
* 获取第一条记录的偏移量。
* @return
*/
public int getStartOffset();
}

[/code]

3.PageinationBuilder.java

[code]
package com.airinbox.pagination;

import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
* 分页导航构造器。
*
* @author wuyunlong
*
*/
class PageinationBuilder {
private final static Map<String, MethodInfo> METHODINFO_CACHE;

static {
METHODINFO_CACHE = new HashMap<String, MethodInfo>();
}

private final static int PAGE_NUMBER_MIN_VALUE = 1;

/**
* 页码。
*/
private final int currentPageNumber;

/**
* 每页里面包含记录的最大条数。
*/
private final int pageSize;

/**
* 包含支持分页方法的对象的实例。
*/
private Object instance;

/**
* 支持的分页方法的在{@link PaginationMethod}中的名称。
*/
private String name;

/**
* 除了偏移量，最大长度之外的参数。
*/
private Object[] otherParameters;

/**
* 分页方法的返回值。
*/
private Object returnValue;

/**
* 上下n页的n值。
*/
private final int severalPagesNumber;

/**
* 分页方法的信息。
*/
private MethodInfo methodInfo;

/**
* 第一页开始记录的偏移量。
*/
private final int offset;

/**
* 返回列表中第一个记录的索引值。
*/
private int firstReturnedOffset;

/**
* 返回列表的最大长度。
*/
private int maxLength;

/**
* 返回列表的实际需要最大长。
*/
private int checkoutMaxLength;
/**
* 第一个输出元素在方法的返回列表中的位置。
*/
private int cur;
/**
* 做大页码值。
*/
private final int maxPageNumber;

/**
* 构造函数。
*
* @param page
* 页码，从1开始的整数值。
* @param pageSize
* 每页里面包含记录的最大条数。
* @param maxPageNumber
* 最多显示的页码。
* @param offset
* 第一页开始记录的偏移量。
* @param severalPagesNumber
* 上下n页的n值。
* @param instance
* 包含支持分页方法的对象的实例。
* @param name
* 支持的分页方法的在{@link PaginationMethod}中的名称。
* @param otherParameters
* 除了偏移量，最大长度之外的参数值（按照原有的顺序排列）。
* @throws NullPointerException
* 如果instance为null，则抛出此异常。
* @throws MethodConfigurationException
* PaginationMethod中参数配置错误或者在目标方法返回值既不是数组也不是{@link Collection}。
*/
public PageinationBuilder(int page, int pageSize, int maxPageNumber,
int offset, int severalPagesNumber, Object instance, String name,
Object... otherParameters) throws NullPointerException,
MethodConfigurationException {
super();
if (instance == null)
throw new NullPointerException("实例不能为空");
this.name = name;
this.instance = instance;
methodInfo = checkoutMethodInfo();
this.maxPageNumber = maxPageNumber;
this.currentPageNumber = checkoutRealPage(page, maxPageNumber);
this.pageSize = checkoutPageSize(pageSize);
this.offset = checkoutRealOffset(offset);
firstReturnedOffset = (this.currentPageNumber - 1) * this.pageSize
+ this.offset;

if (methodInfo.getMethodMeta().all()) {
this.cur = firstReturnedOffset;
} else {
this.cur = 0;
}

this.otherParameters = otherParameters;
this.severalPagesNumber = checkoutSeveralPagesNumber(severalPagesNumber);
if(currentPageNumber + this.severalPagesNumber > this.maxPageNumber){
if(this.currentPageNumber == this.maxPageNumber){
this.maxLength = this.pageSize;
this.checkoutMaxLength = this.pageSize;
}else{
maxLength = this.pageSize * (this.maxPageNumber - currentPageNumber);
checkoutMaxLength = maxLength + 1;
}
}else{
maxLength = this.pageSize * this.severalPagesNumber;
checkoutMaxLength = maxLength + 1;
}
}

/**
* 构造函数。
*
* @param page
* 页码，从1开始的整数值。
* @param pageSize
* 每页里面包含记录的最大条数。
* @param offset
* 第一页开始记录的偏移量。
* @param severalPagesNumber
* 上下n页的n值。
* @param instance
* 包含支持分页方法的对象的实例。
* @param name
* 支持的分页方法的在{@link PaginationMethod}中的名称。
* @param otherParameters
* 除了偏移量，最大长度之外的参数值（按照原有的顺序排列）。
* @throws NullPointerException
* 如果instance为null，则抛出此异常。
* @throws MethodConfigurationException
* PaginationMethod中参数配置错误或者在目标方法返回值既不是数组也不是{@link Collection}。
*/
public PageinationBuilder(int page, int pageSize, int offset,
int severalPagesNumber, Object instance, String name,
Object... otherParameters) throws NullPointerException,
MethodConfigurationException {
this(page, pageSize, Integer.MAX_VALUE, offset, severalPagesNumber,
instance, name, otherParameters);
}

/**
* 取出可用的每页里面包含记录的最大条数
*
* @param size
* 用户输入的页码值。
* @return 返回实际可用的每页里面包含记录的最大条数。
*/
private int checkoutPageSize(int size) {
return size > 0 ? size : 5;
}

/**
* 取出可用的第一页开始记录的偏移量。
*
* @param offset
* 第一页开始记录的偏移量。
* @return 返回可用的第一页开始记录的偏移量。
*/
private int checkoutRealOffset(int offset) {
return offset >= 0 ? offset : 0;
}

/**
* 取出可用的页码。
*
* @param page
* 用户输入的页码。
* @return 返回可用的页码。
*/
private int checkoutRealPage(int page, int maxValue) {
if (page > maxValue)
return PAGE_NUMBER_MIN_VALUE;
return page >= PAGE_NUMBER_MIN_VALUE ? page : PAGE_NUMBER_MIN_VALUE;
}

private int checkoutSeveralPagesNumber(int n) {
return n > 0 ? n : 1;
}

private MethodInfo checkoutMethodInfo() throws MethodConfigurationException {
MethodInfo am = lookupMethodInfo(instance.getClass());
if (am == null) {
throw new MethodConfigurationException("在"
+ instance.getClass().getName()
+ "中没有找到注释为PaginationMethod(name=\"" + name + "\")的方法");
}
return am;
}

private boolean implement(Class<?> type, Class<?> interf) {
Class<?>[] superInterf = type.getInterfaces();
for (Class<?> clazz : superInterf) {
if (clazz.equals(interf))
return true;
}
return false;
}

public Pagination invoke() throws MethodConfigurationException {
try {
Object[] parameters = buildParameters();
returnValue = methodInfo.getMethod().invoke(instance, parameters);
} catch (Exception e) {
throw new MethodConfigurationException(e);
}
return createPagination();
}

private Object[] buildParameters() throws MethodConfigurationException {
List<Object> list = new ArrayList<Object>();
for (Object object : otherParameters) {
list.add(object);
}
insertParameters(list);
return list.toArray(new Object[0]);
}

private void insertParameters(List<Object> paramList)
throws MethodConfigurationException {
PaginationMethod meta = methodInfo.getMethodMeta();
if (!meta.all()) {
try {
int osi = meta.offsetParamIndex();
int mli = meta.maxLengthParamIndex();
if (osi < mli) {
paramList.add(osi, firstReturnedOffset);
paramList.add(mli, checkoutMaxLength);
} else {
paramList.add(mli, checkoutMaxLength);
paramList.add(osi, firstReturnedOffset);
}
} catch (IndexOutOfBoundsException e) {
throw new MethodConfigurationException(e);
}
}
}

private MethodInfo lookupMethodInfo(Class<?> type)
throws MethodConfigurationException {
MethodInfo ret = null;
final String key = type.getName() + "@PaginationMethod(name=\"" + name
+ "\")";
synchronized (METHODINFO_CACHE) {
ret = METHODINFO_CACHE.get(key);
}
if (ret != null) {
return ret;
} else {
synchronized (METHODINFO_CACHE) {
if (METHODINFO_CACHE.containsKey(key))
return null;
}
}
ret = lookupMethodInfoFromClass(type);
synchronized (METHODINFO_CACHE) {
METHODINFO_CACHE.put(key, ret);
}
return ret;
}

private MethodInfo lookupMethodInfoFromClass(Class<?> type)
throws MethodConfigurationException {
MethodInfo ret = null;
Method[] methodArr = type.getMethods();
for (Method method : methodArr) {
PaginationMethod pd = method.getAnnotation(PaginationMethod.class);
if (pd == null)
continue;
if (name.equals(pd.name())) {
ret = new MethodInfo();
boolean isCollection = false;
Class<?> returnType = method.getReturnType();
if (!(isCollection = implement(returnType, Collection.class))
&& !returnType.isArray()) {
throw new MethodConfigurationException(name
+ "的返回类型应该是Collection或者数组");
}
ret.setReturnValueInstanceOfCollection(isCollection);
ret.setMethod(method);
ret.setMethodMeta(pd);
break;
}
if (ret != null) {
break;
}
}
if (ret != null)
return ret;
// 从超类中查询。
if (ret == null && !type.isInterface()
&& !type.getSuperclass().equals(Object.class)) {
ret = lookupMethodInfoFromClass(type.getSuperclass());
}
// 从接口中查询。
if (ret == null) {
Class<?>[] sx = type.getInterfaces();
for (Class<?> c : sx) {
ret = lookupMethodInfoFromClass(c);
if (ret != null) {
break;
}
}
}
return ret;
}

private MethodReturnValueInfo getCollectionReturn() {
Collection<?> c = (Collection<?>) returnValue;
List<Object> list = new ArrayList<Object>();
int realCount = c.size();
if (cur < realCount) {
int count = 0;
int pos = 0;
for (Iterator<?> iterator = c.iterator(); iterator.hasNext()
&& count < pageSize;) {
Object t = (Object) iterator.next();
if (pos >= cur) {
list.add(t);
count++;
}
pos++;
}
}
return new MethodReturnValueInfo(realCount, list);
}

private MethodReturnValueInfo getArrayReturn() {
List<Object> list = new ArrayList<Object>();
int realCount = Array.getLength(returnValue);
int c = this.cur + pageSize;
int end = c > realCount ? realCount : c;
for (int i = this.cur; i < end; i++) {
list.add(Array.get(returnValue, i));
}
return new MethodReturnValueInfo(realCount, list);
}

private Pagination createPagination() {
DefaultPagination dp = new DefaultPagination();
dp.setCurrentPageNumber(currentPageNumber);
MethodReturnValueInfo mrvi = null;
if (methodInfo.returnValueInstanceOfCollection()) {
mrvi = getCollectionReturn();
} else {
mrvi = getArrayReturn();
}
dp.setMethodReturnValue(mrvi.getReturnValue());
dp.setNext(mrvi.getRealCount() > pageSize + cur);
dp.setFollowingSeveralPages(mrvi.getRealCount() > maxLength + cur);

int d = mrvi.getRealCount() - cur;
if (d > checkoutMaxLength) {
d = checkoutMaxLength;
}

int mod = d % pageSize;
int number = d / pageSize + (mod == 0 ? 0 : 1);
dp.setFollowingSeveralPagesNumberMax(number);

dp.setBefore(currentPageNumber > 1);
dp.setFormerSeveralPages(currentPageNumber > severalPagesNumber);
dp.setStartOffset(firstReturnedOffset);
return dp;
}

private class MethodReturnValueInfo {
private int realCount;
private List<?> returnValue;

public MethodReturnValueInfo(int realCount, List<?> returnValue) {
super();
this.realCount = realCount;
this.returnValue = returnValue;
}

public int getRealCount() {
return realCount;
}

public List<?> getReturnValue() {
return returnValue;
}

}

private static class DefaultPagination implements Pagination {
private Collection<?> methodReturnValue;

private boolean next;

private boolean before;

private boolean followingSeveralPages;

private boolean formerSeveralPages;

private int followingSeveralPagesNumberMax;

private int firstRecorderOffset;

private int currentPageNumber;

public DefaultPagination() {
super();
}

public void setMethodReturnValue(Collection<?> value) {
this.methodReturnValue = value;
}

public Collection<?> getMethodReturnValue() {
return methodReturnValue;
}

public void setNext(boolean value) {
this.next = value;
}

public boolean hasNext() {
return next;
}

public boolean hasBefore() {
return before;
}

public void setBefore(boolean before) {
this.before = before;
}

public boolean hasFollowingSeveralPages() {
return followingSeveralPages;
}

public void setFollowingSeveralPages(boolean value) {
this.followingSeveralPages = value;
}

public boolean hasFormerSeveralPages() {
return formerSeveralPages;
}

public void setFormerSeveralPages(boolean value) {
this.formerSeveralPages = value;
}

public int getFollowingSeveralPagesNumberMax() {
return followingSeveralPagesNumberMax;
}

public void setFollowingSeveralPagesNumberMax(
int followingSeveralPagesNumberMax) {
this.followingSeveralPagesNumberMax = followingSeveralPagesNumberMax;
}

public int getStartOffset() {
return firstRecorderOffset;
}

public void setStartOffset(int value) {
firstRecorderOffset = value;
}

public int getCurrentPageNumber() {
return currentPageNumber;
}

public void setCurrentPageNumber(int currentPageNumber) {
this.currentPageNumber = currentPageNumber;
}

}

private static class MethodInfo {
private Method method;

private PaginationMethod methodMeta;

/**
* 分页方法的返回值是否是集合类型。
*/
private boolean returnValueInstanceOfCollection;

public Method getMethod() {
return method;
}

public void setMethod(Method method) {
this.method = method;
}

public PaginationMethod getMethodMeta() {
return methodMeta;
}

public void setMethodMeta(PaginationMethod methodMeta) {
this.methodMeta = methodMeta;
}

public void setReturnValueInstanceOfCollection(boolean value) {
this.returnValueInstanceOfCollection = value;
}

public boolean returnValueInstanceOfCollection() {
return returnValueInstanceOfCollection;
}
}
}
[/code]

4.PaginationFactory.java
[code]
package com.airinbox.pagination;

import java.util.Collection;

public class PaginationFactory {

/**
* 创建分页导航。
*
* @param page
* 页码，从1开始的整数值。
* @param pageSize
* 每页里面包含记录的最大条数。
* @param maxPage
* 分页时返回能够看到的最大页码数。
* @param offset
* 第一页开始记录的偏移量。
* @param severalPagesNumber
* 上下n页的n值。
* @param instance
* 包含支持分页方法的对象的实例。
* @param name
* 支持的分页方法的在{@link PaginationMethod}中的名称。
* @param otherParameters
* 除了偏移量，最大长度之外的参数值（按照原有的顺序排列）。
* @throws NullPointerException
* 如果instance为null，则抛出此异常。
* @throws MethodConfigurationException
* PaginationMethod中参数配置错误或者在目标方法返回值既不是数组也不是{@link Collection}。
*/
public static Pagination createPagination(int page, int pageSize,int maxPage,
int offset, int severalPagesNumber, Object instance, String name,
Object... otherParameters) throws NullPointerException,
MethodConfigurationException {
PageinationBuilder pb = new PageinationBuilder(page, pageSize,maxPage,
offset, severalPagesNumber, instance, name, otherParameters);
return pb.invoke();
}
/**
* 创建分页导航。
*
* @param page
* 页码，从1开始的整数值。
* @param pageSize
* 每页里面包含记录的最大条数。
* @param offset
* 第一页开始记录的偏移量。
* @param severalPagesNumber
* 上下n页的n值。
* @param instance
* 包含支持分页方法的对象的实例。
* @param name
* 支持的分页方法的在{@link PaginationMethod}中的名称。
* @param otherParameters
* 除了偏移量，最大长度之外的参数值（按照原有的顺序排列）。
* @throws NullPointerException
* 如果instance为null，则抛出此异常。
* @throws MethodConfigurationException
* PaginationMethod中参数配置错误或者在目标方法返回值既不是数组也不是{@link Collection}。
*/
public static Pagination createPagination(int page, int pageSize,
int offset, int severalPagesNumber, Object instance, String name,
Object... otherParameters) throws NullPointerException,
MethodConfigurationException {
PageinationBuilder pb = new PageinationBuilder(page, pageSize,
offset, severalPagesNumber, instance, name, otherParameters);
return pb.invoke();
}

/**
* 创建分页导航，它同{@link #createPagination(int, int, int, int, Object, String, Object[])}
* 区别是：此方法用户于不包含otherParameters的分页导航。
* @param page
* 页码，从1开始的整数值。
* @param pageSize
* 每页里面包含记录的最大条数。
* @param offset
* 第一页开始记录的偏移量。
* @param severalPagesNumber
* 上下n页的n值。
* @param instance
* 包含支持分页方法的对象的实例。
* @param name
* 支持的分页方法的在{@link PaginationMethod}中的名称。
* @throws NullPointerException
* 如果instance为null，则抛出此异常。
* @throws MethodConfigurationException
* PaginationMethod中参数配置错误或者在目标方法返回值既不是数组也不是{@link Collection}。
*/
public static Pagination createPagination2(int page, int pageSize,
int offset, int severalPagesNumber, Object instance, String name)
throws NullPointerException, MethodConfigurationException {
return createPagination(page, pageSize, offset, severalPagesNumber,
instance, name);
}

/**
* 创建分页导航，它同{@link #createPagination(int, int, int, int, Object, String, Object[])}
* 区别是：指定“第一页开始记录的偏移量”为0。
* @param page
* 页码，从1开始的整数值。
* @param pageSize
* 每页里面包含记录的最大条数。
* @param severalPagesNumber
* 上下n页的n值。
* @param instance
* 包含支持分页方法的对象的实例。
* @param name
* 支持的分页方法的在{@link PaginationMethod}中的名称。
* @param otherParameters
* 除了偏移量，最大长度之外的参数值（按照原有的顺序排列）。
* @throws NullPointerException
* 如果instance为null，则抛出此异常。
* @throws MethodConfigurationException
* PaginationMethod中参数配置错误或者在目标方法返回值既不是数组也不是{@link Collection}。
*/
public static Pagination createPagination3(int page, int pageSize,
int severalPagesNumber, Object instance, String name,Object... otherParameters)
throws NullPointerException, MethodConfigurationException {
return createPagination(page, pageSize, 0, severalPagesNumber,
instance, name,otherParameters);
}

/**
* 创建分页导航，它通{@link #createPagination(int, int, int, int, Object, String, Object[])}
* 区别是：此方法用户于不包含otherParameters的分页导航，并且指定“第一页开始记录的偏移量”
* 为0。
* @param page
* 页码，从1开始的整数值。
* @param pageSize
* 每页里面包含记录的最大条数。
* @param severalPagesNumber
* 上下n页的n值。
* @param instance
* 包含支持分页方法的对象的实例。
* @param name
* 支持的分页方法的在{@link PaginationMethod}中的名称。
* @throws NullPointerException
* 如果instance为null，则抛出此异常。
* @throws MethodConfigurationException
* PaginationMethod中参数配置错误或者在目标方法返回值既不是数组也不是{@link Collection}。
*/
public static Pagination createPagination4(int page, int pageSize,
int severalPagesNumber, Object instance, String name)
throws NullPointerException, MethodConfigurationException {
return createPagination(page, pageSize, 0, severalPagesNumber,
instance, name);
}

/**
* 创建分页导航，它通{@link #createPagination(int, int, int, int, Object, String, Object[])}
* 区别是：此方法用户于不包含otherParameters的分页导航，并且指定更多页中n值为{@link Pagination.DEFAULT_N}。
* @param page
* 页码，从1开始的整数值。
* @param pageSize
* 每页里面包含记录的最大条数。
* @param severalPagesNumber
* 上下n页的n值。
* @param instance
* 包含支持分页方法的对象的实例。
* @param name
* 支持的分页方法的在{@link PaginationMethod}中的名称。
* @param otherParameters
* 除了偏移量，最大长度之外的参数值（按照原有的顺序排列）。
* @throws NullPointerException
* 如果instance为null，则抛出此异常。
* @throws MethodConfigurationException
* PaginationMethod中参数配置错误或者在目标方法返回值既不是数组也不是{@link Collection}。
*/
public static Pagination createPagination5(int page, int pageSize,
int severalPagesNumber,Object instance, String name,
Object... otherParameters)
throws NullPointerException, MethodConfigurationException {
return createPagination(page, pageSize, 0,
severalPagesNumber,instance, name, otherParameters);
}

/**
* 创建分页导航，它通{@link #createPagination(int, int, int, int, Object, String, Object[])}
* 区别是：指定更多页中n值为{@link Pagination.DEFAULT_N}。
* @param page
* 页码，从1开始的整数值。
* @param pageSize
* 每页里面包含记录的最大条数。
* @param severalPagesNumber
* 上下n页的n值。
* @param instance
* 包含支持分页方法的对象的实例。
* @param name
* 支持的分页方法的在{@link PaginationMethod}中的名称。
* @param otherParameters
* 除了偏移量，最大长度之外的参数值（按照原有的顺序排列）。
* @throws NullPointerException
* 如果instance为null，则抛出此异常。
* @throws MethodConfigurationException
* PaginationMethod中参数配置错误或者在目标方法返回值既不是数组也不是{@link Collection}。
*/
public static Pagination createPagination6(int page, int pageSize,
int severalPagesNumber, Object instance,String name)
throws NullPointerException, MethodConfigurationException {
return createPagination(page, pageSize, 0, severalPagesNumber,
instance, "");
}

/**
* 创建分页导航，它通{@link #createPagination(int, int, int, int, Object, String, Object[])}
* 区别是：指定“第一页开始记录的偏移量”为0的分页导航和指定更多页中n值为{@link Pagination.DEFAULT_N}。
* @param page
* 页码，从1开始的整数值。
* @param pageSize
* 每页里面包含记录的最大条数。
* @param offset
* 第一页开始记录的偏移量。
* @param severalPagesNumber
* 上下n页的n值。
* @param instance
* 包含支持分页方法的对象的实例。
* @param name
* 支持的分页方法的在{@link PaginationMethod}中的名称。
* @param otherParameters
* 除了偏移量，最大长度之外的参数值（按照原有的顺序排列）。
* @throws NullPointerException
* 如果instance为null，则抛出此异常。
* @throws MethodConfigurationException
* PaginationMethod中参数配置错误或者在目标方法返回值既不是数组也不是{@link Collection}。
*/
public static Pagination createPagination7(int page, int pageSize,
Object instance, String name,Object... otherParameters) throws NullPointerException,
MethodConfigurationException {
return createPagination(page, pageSize, 0, Pagination.DEFAULT_N,
instance, name,otherParameters);
}

/**
* 创建分页导航，它通{@link #createPagination(int, int, int, int, Object, String, Object[])}
* 区别是：此方法用户于不包含otherParameters的分页导航，并且指定“第一页开始记录的偏移量”
* 为0和指定更多页中n值为{@link Pagination.DEFAULT_N}。
* @param page
* 页码，从1开始的整数值。
* @param pageSize
* 每页里面包含记录的最大条数。
* @param offset
* 第一页开始记录的偏移量。
* @param severalPagesNumber
* 上下n页的n值。
* @param instance
* 包含支持分页方法的对象的实例。
* @param name
* 支持的分页方法的在{@link PaginationMethod}中的名称。
* @param otherParameters
* 除了偏移量，最大长度之外的参数值（按照原有的顺序排列）。
* @throws NullPointerException
* 如果instance为null，则抛出此异常。
* @throws MethodConfigurationException
* PaginationMethod中参数配置错误或者在目标方法返回值既不是数组也不是
* {@link Collection}。
*/
public static Pagination createPagination8(int page, int pageSize,
Object instance, String name) throws NullPointerException,
MethodConfigurationException {
return createPagination(page, pageSize, 0, Pagination.DEFAULT_N,
instance, name);
}


/**
* 创建分页导航，它通{@link #createPagination(int, int, int, int, Object, String, Object[])}
* 区别是：此方法用户于不包含otherParameters的分页导航，并且指定“第一页开始记录的偏移量”
* 为0。
* @param page
* 页码，从1开始的整数值。
* @param pageSize
* 每页里面包含记录的最大条数。
* @param offset
* 第一页开始记录的偏移量。
* @param instance
* 包含支持分页方法的对象的实例。
* @param name
* 支持的分页方法的在{@link PaginationMethod}中的名称。
* @param otherParameters
* 除了偏移量，最大长度之外的参数值（按照原有的顺序排列）。
* @throws NullPointerException
* 如果instance为null，则抛出此异常。
* @throws MethodConfigurationException
* PaginationMethod中参数配置错误或者在目标方法返回值既不是数组也不是{@link Collection}。
*/
public static Pagination createPagination9(int page, int pageSize,
int offset, Object instance, String name, Object... otherParameters)
throws NullPointerException, MethodConfigurationException {
return createPagination(page, pageSize, offset, Pagination.DEFAULT_N,
instance, name, otherParameters);
}

}
[/code]

5.MethodConfigurationException.java
[code]
package com.airinbox.pagination;

public class MethodConfigurationException extends Exception {

private static final long serialVersionUID = -1568337814489507868L;

public MethodConfigurationException() {
super();
}

public MethodConfigurationException(String message, Throwable cause) {
super(message, cause);
}

public MethodConfigurationException(String message) {
super(message);
}

public MethodConfigurationException(Throwable cause) {
super(cause);
}


}

[/code]

6.Example
[code]
public class Forum{
@PaginationMethod(name = "ABC", offsetParamIndex = 1, maxLengthParamIndex = 2)
public Article[] getArticleList(int forumId, int start, int len)
throws ForumNotFoundException{
...
}
}
[/code]

7.Reference.jsp
[code]
....
Forum forum = ...;
Pagination pagi = PaginationFactory.createPagination8(1,10.forum,"ABC");
Collection<?> c = pagi.getMethodReturnValue();//getArticleList返回的数据被包装到Collection里了
for(Iterator<?> iter = c.iterator();ite.hasNext();){
Article art = (Article)iter.next();
...
}
...
[/code]