no commit message

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/dialect/DB2Dialect.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.dialect;
+
+import com.jeespring.common.persistence.dialect.Dialect;
+
+/**
+ * DB2的分页数据库方言实现
+ *
+ * @author poplar.yfyang
+ * @version 1.0 2010-10-10 下午12:31
+ * @since JDK 1.5
+ */
+public class DB2Dialect implements Dialect {
+    @Override
+    public boolean supportsLimit() {
+        return true;
+    }
+
+    private static String getRowNumber(String sql) {
+        StringBuilder rownumber = new StringBuilder(50)
+                .append("rownumber() over(");
+
+        int orderByIndex = sql.toLowerCase().indexOf("order by");
+
+        if (orderByIndex > 0 && !hasDistinct(sql)) {
+            rownumber.append(sql.substring(orderByIndex));
+        }
+
+        rownumber.append(") as rownumber_,");
+
+        return rownumber.toString();
+    }
+
+    private static boolean hasDistinct(String sql) {
+        return sql.toLowerCase().contains("select distinct");
+    }
+
+    @Override
+    public String getLimitString(String sql, int offset, int limit) {
+        return getLimitString(sql, offset, Integer.toString(offset), Integer.toString(limit));
+    }
+
+    /**
+     * 将sql变成分页sql语句,提供将offset及limit使用占位符号(placeholder)替换.
+     * <pre>
+     * 如mysql
+     * dialect.getLimitString("select * from user", 12, ":offset",0,":limit") 将返回
+     * select * from user limit :offset,:limit
+     * </pre>
+     *
+     * @param sql               实际SQL语句
+     * @param offset            分页开始纪录条数
+     * @param offsetPlaceholder 分页开始纪录条数－占位符号
+     * @param limitPlaceholder  分页纪录条数占位符号
+     * @return 包含占位符的分页sql
+     */
+    public String getLimitString(String sql, int offset, String offsetPlaceholder, String limitPlaceholder) {
+        int startOfSelect = sql.toLowerCase().indexOf("select");
+
+        StringBuilder pagingSelect = new StringBuilder(sql.length() + 100)
+                .append(sql.substring(0, startOfSelect)) //add the comment
+                .append("select * from ( select ") //nest the main query in an outer select
+                .append(getRowNumber(sql)); //add the rownnumber bit into the outer query select list
+
+        if (hasDistinct(sql)) {
+            pagingSelect.append(" row_.* from ( ") //add another (inner) nested select
+                    .append(sql.substring(startOfSelect)) //add the main query
+                    .append(" ) as row_"); //close off the inner nested select
+        } else {
+            pagingSelect.append(sql.substring(startOfSelect + 6)); //add the main query
+        }
+
+        pagingSelect.append(" ) as temp_ where rownumber_ ");
+
+        //add the restriction to the outer select
+        if (offset > 0) {
+//			int end = offset + limit;
+            String endString = offsetPlaceholder + "+" + limitPlaceholder;
+            pagingSelect.append("between ").append(offsetPlaceholder)
+                    .append("+1 and ").append(endString);
+        } else {
+            pagingSelect.append("<= ").append(limitPlaceholder);
+        }
+
+        return pagingSelect.toString();
+    }
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/dialect/DerbyDialect.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.dialect;
+
+import com.jeespring.common.persistence.dialect.Dialect;
+
+/**
+ * @author poplar.yfyang
+ * @version 1.0 2010-10-10 下午12:31
+ * @since JDK 1.5
+ */
+public class DerbyDialect implements Dialect {
+    @Override
+    public boolean supportsLimit() {
+        return false;
+	}
+
+    @Override
+    public String getLimitString(String sql, int offset, int limit) {
+//        return getLimitString(sql,offset,Integer.toString(offset),limit,Integer.toString(limit));
+        throw new UnsupportedOperationException("paged queries not supported");
+    }
+
+    /**
+     * 将sql变成分页sql语句,提供将offset及limit使用占位符号(placeholder)替换.
+     * <pre>
+     * 如mysql
+     * dialect.getLimitString("select * from user", 12, ":offset",0,":limit") 将返回
+     * select * from user limit :offset,:limit
+     * </pre>
+     *
+     * @param sql               实际SQL语句
+     * @param offset            分页开始纪录条数
+     * @param offsetPlaceholder 分页开始纪录条数－占位符号
+     * @param limit             分页每页显示纪录条数
+     * @param limitPlaceholder  分页纪录条数占位符号
+     * @return 包含占位符的分页sql
+     */
+	public String getLimitString(String sql, int offset,String offsetPlaceholder, int limit, String limitPlaceholder) {
+		throw new UnsupportedOperationException( "paged queries not supported" );
+	}
+
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/dialect/Dialect.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.dialect;
+
+/**
+ * 类似hibernate的Dialect,但只精简出分页部分
+ *
+ * @author poplar.yfyang
+ * @version 1.0 2011-11-18 下午12:31
+ * @since JDK 1.5
+ */
+public interface Dialect {
+
+    /**
+     * 数据库本身是否支持分页当前的分页查询方式
+     * 如果数据库不支持的话，则不进行数据库分页
+     *
+     * @return true：支持当前的分页查询方式
+     */
+    boolean supportsLimit();
+
+    /**
+     * 将sql转换为分页SQL，分别调用分页sql
+     *
+     * @param sql    SQL语句
+     * @param offset 开始条数
+     * @param limit  每页显示多少纪录条数
+     * @return 分页查询的sql
+     */
+    String getLimitString(String sql, int offset, int limit);
+
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/dialect/H2Dialect.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.dialect;
+
+import com.jeespring.common.persistence.dialect.Dialect;
+
+/**
+ * A dialect compatible with the H2 database.
+ *
+ * @author JeeSpring
+ * @version 1.0 2010-10-10 下午12:31
+ * @since JDK 1.5
+ */
+public class H2Dialect implements Dialect {
+
+    @Override
+    public boolean supportsLimit() {
+        return true;
+    }
+
+    /**
+     * 将sql变成分页sql语句,提供将offset及limit使用占位符号(placeholder)替换.
+     * <pre>
+     * 如mysql
+     * dialect.getLimitString("select * from user", 12, ":offset",0,":limit") 将返回
+     * select * from user limit :offset,:limit
+     * </pre>
+     *
+     * @param sql               实际SQL语句
+     * @param offset            分页开始纪录条数
+     * @param offsetPlaceholder 分页开始纪录条数－占位符号
+     * @param limit             分页每页显示纪录条数
+     * @param limitPlaceholder  分页纪录条数占位符号
+     * @return 包含占位符的分页sql
+     */
+    private String getLimitString(String sql, int offset, String offsetPlaceholder, int limit, String limitPlaceholder) {
+        return sql + ((offset > 0) ? " limit " + limitPlaceholder + " offset "
+                + offsetPlaceholder : " limit " + limitPlaceholder);
+    }
+
+    @Override
+    public String getLimitString(String sql, int offset, int limit) {
+        return getLimitString(sql, offset, Integer.toString(offset), limit, Integer.toString(limit));
+    }
+}
\ No newline at end of file

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/dialect/HSQLDialect.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.dialect;
+
+import com.jeespring.common.persistence.dialect.Dialect;
+
+/**
+ * Dialect for HSQLDB
+ *
+ * @author poplar.yfyang
+ * @version 1.0 2010-10-10 下午12:31
+ * @since JDK 1.5
+ */
+public class HSQLDialect implements Dialect {
+    @Override
+    public boolean supportsLimit() {
+        return true;
+    }
+
+    @Override
+    public String getLimitString(String sql, int offset, int limit) {
+        return getLimitString(sql, offset, Integer.toString(offset),
+                Integer.toString(limit));
+    }
+
+    /**
+     * 将sql变成分页sql语句,提供将offset及limit使用占位符号(placeholder)替换.
+     * <pre>
+     * 如mysql
+     * dialect.getLimitString("select * from user", 12, ":offset",0,":limit") 将返回
+     * select * from user limit :offset,:limit
+     * </pre>
+     *
+     * @param sql               实际SQL语句
+     * @param offset            分页开始纪录条数
+     * @param offsetPlaceholder 分页开始纪录条数－占位符号
+     * @param limitPlaceholder  分页纪录条数占位符号
+     * @return 包含占位符的分页sql
+     */
+    public String getLimitString(String sql, int offset, String offsetPlaceholder, String limitPlaceholder) {
+        boolean hasOffset = offset > 0;
+        return
+                new StringBuffer(sql.length() + 10)
+                        .append(sql)
+                        .insert(sql.toLowerCase().indexOf("select") + 6, hasOffset ? " limit " + offsetPlaceholder + " " + limitPlaceholder : " top " + limitPlaceholder)
+                        .toString();
+    }
+
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/dialect/MySQLDialect.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.dialect;
+
+import com.jeespring.common.persistence.dialect.Dialect;
+
+/**
+ * Mysql方言的实现
+ *
+ * @author poplar.yfyang
+ * @version 1.0 2010-10-10 下午12:31
+ * @since JDK 1.5
+ */
+public class MySQLDialect implements Dialect {
+
+
+    @Override
+    public String getLimitString(String sql, int offset, int limit) {
+        return getLimitString(sql, offset, Integer.toString(offset),
+                Integer.toString(limit));
+    }
+
+    @Override
+    public boolean supportsLimit() {
+        return true;
+    }
+
+    /**
+     * 将sql变成分页sql语句,提供将offset及limit使用占位符号(placeholder)替换.
+     * <pre>
+     * 如mysql
+     * dialect.getLimitString("select * from user", 12, ":offset",0,":limit") 将返回
+     * select * from user limit :offset,:limit
+     * </pre>
+     *
+     * @param sql               实际SQL语句
+     * @param offset            分页开始纪录条数
+     * @param offsetPlaceholder 分页开始纪录条数－占位符号
+     * @param limitPlaceholder  分页纪录条数占位符号
+     * @return 包含占位符的分页sql
+     */
+    public String getLimitString(String sql, int offset, String offsetPlaceholder, String limitPlaceholder) {
+        StringBuilder stringBuilder = new StringBuilder(sql);
+        stringBuilder.append(" limit ");
+        if (offset > 0) {
+            stringBuilder.append(offsetPlaceholder).append(",").append(limitPlaceholder);
+        } else {
+            stringBuilder.append(limitPlaceholder);
+        }
+        return stringBuilder.toString();
+    }
+
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/dialect/OracleDialect.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.dialect;
+
+/**
+ * Oracle的方言实现
+ * @author poplar.yfyang
+ * @version 1.0 2010-10-10 下午12:31
+ * @since JDK 1.5
+ */
+public class OracleDialect implements Dialect {
+    @Override
+    public boolean supportsLimit() {
+        return true;
+    }
+
+    @Override
+    public String getLimitString(String sql, int offset, int limit) {
+        return getLimitString(sql, offset, Integer.toString(offset), Integer.toString(limit));
+    }
+
+    /**
+     * 将sql变成分页sql语句,提供将offset及limit使用占位符号(placeholder)替换.
+     * <pre>
+     * 如mysql
+     * dialect.getLimitString("select * from user", 12, ":offset",0,":limit") 将返回
+     * select * from user limit :offset,:limit
+     * </pre>
+     *
+     * @param sql               实际SQL语句
+     * @param offset            分页开始纪录条数
+     * @param offsetPlaceholder 分页开始纪录条数－占位符号
+     * @param limitPlaceholder  分页纪录条数占位符号
+     * @return 包含占位符的分页sql
+     */
+    public String getLimitString(String sql, int offset, String offsetPlaceholder, String limitPlaceholder) {
+        sql = sql.trim();
+        boolean isForUpdate = false;
+        if (sql.toLowerCase().endsWith(" for update")) {
+            sql = sql.substring(0, sql.length() - 11);
+            isForUpdate = true;
+        }
+        StringBuilder pagingSelect = new StringBuilder(sql.length() + 100);
+
+        if (offset > 0) {
+			pagingSelect.append("select * from ( select row_.*, rownum rownum_ from ( ");
+		} else {
+			pagingSelect.append("select * from ( ");
+		}
+		pagingSelect.append(sql);
+		if (offset > 0) {
+			String endString = offsetPlaceholder + "+" + limitPlaceholder;
+			pagingSelect.append(" ) row_ where rownum <= "+endString+") where rownum_ > ").append(offsetPlaceholder);
+		} else {
+			pagingSelect.append(" ) where rownum <= "+limitPlaceholder);
+		}
+
+        if (isForUpdate) {
+            pagingSelect.append(" for update");
+        }
+
+        return pagingSelect.toString();
+    }
+
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/dialect/PostgreSQLDialect.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.dialect;
+
+import com.jeespring.common.persistence.dialect.Dialect;
+
+/**
+ * Postgre Sql的方言实现
+ * @author poplar.yfyang
+ * @version 1.0 2010-10-10 下午12:31
+ * @since JDK 1.5
+ */
+public class PostgreSQLDialect implements Dialect {
+
+    @Override
+    public boolean supportsLimit() {
+        return true;
+    }
+
+    @Override
+    public String getLimitString(String sql, int offset, int limit) {
+        return getLimitString(sql, offset, Integer.toString(offset),
+                Integer.toString(limit));
+    }
+
+    /**
+     * 将sql变成分页sql语句,提供将offset及limit使用占位符号(placeholder)替换.
+     * <pre>
+     * 如mysql
+     * dialect.getLimitString("select * from user", 12, ":offset",0,":limit") 将返回
+     * select * from user limit :offset,:limit
+     * </pre>
+     *
+     * @param sql               实际SQL语句
+     * @param offset            分页开始纪录条数
+     * @param offsetPlaceholder 分页开始纪录条数－占位符号
+     * @param limitPlaceholder  分页纪录条数占位符号
+     * @return 包含占位符的分页sql
+     */
+    public String getLimitString(String sql, int offset,
+                                 String offsetPlaceholder, String limitPlaceholder) {
+        StringBuilder pageSql = new StringBuilder().append(sql);
+        pageSql = offset <= 0
+                ? pageSql.append(" limit ").append(limitPlaceholder) :
+                pageSql.append(" limit ").append(limitPlaceholder).append(" offset ").append(offsetPlaceholder);
+        return pageSql.toString();
+    }
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/dialect/SQLServer2005Dialect.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.dialect;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.jeespring.common.persistence.dialect.Dialect;
+
+/**
+ * Sql 2005的方言实现
+ * @author poplar.yfyang
+ * @version 1.0 2010-10-10 下午12:31
+ * @since JDK 1.5
+ */
+public class SQLServer2005Dialect implements Dialect {
+
+    @Override
+    public boolean supportsLimit() {
+        return true;
+    }
+
+    @Override
+    public String getLimitString(String sql, int offset, int limit) {
+        return getLimitString(sql, offset,
+                limit, Integer.toString(limit));
+    }
+
+    /**
+     * Add a LIMIT clause to the given SQL SELECT
+     * <p/>
+     * The LIMIT SQL will look like:
+     * <p/>
+     * WITH query AS
+     * (SELECT TOP 100 percent ROW_NUMBER() OVER (ORDER BY CURRENT_TIMESTAMP) as __row_number__, * from table_name)
+     * SELECT *
+     * FROM query
+     * WHERE __row_number__ BETWEEN :offset and :lastRows
+     * ORDER BY __row_number__
+     *
+     * @param querySqlString   The SQL statement to base the limit query off of.
+     * @param offset           Offset of the first row to be returned by the query (zero-based)
+     * @param limit            Maximum number of rows to be returned by the query
+     * @param limitPlaceholder limitPlaceholder
+     * @return A new SQL statement with the LIMIT clause applied.
+     */
+    private String getLimitString(String querySqlString, int offset, int limit, String limitPlaceholder) {
+        StringBuilder pagingBuilder = new StringBuilder();
+        String orderby = getOrderByPart(querySqlString);
+        String distinctStr = "";
+
+        String loweredString = querySqlString.toLowerCase();
+        String sqlPartString = querySqlString;
+        if (loweredString.trim().startsWith("select")) {
+            int index = 6;
+            if (loweredString.startsWith("select distinct")) {
+                distinctStr = "DISTINCT ";
+                index = 15;
+            }
+            sqlPartString = sqlPartString.substring(index);
+        }
+        pagingBuilder.append(sqlPartString);
+
+        // if no ORDER BY is specified use fake ORDER BY field to avoid errors
+        if (StringUtils.isEmpty(orderby)) {
+            orderby = "ORDER BY CURRENT_TIMESTAMP";
+        }
+
+        StringBuilder result = new StringBuilder();
+        result.append("WITH query AS (SELECT ")
+                .append(distinctStr)
+                .append("TOP 100 PERCENT ")
+                .append(" ROW_NUMBER() OVER (")
+                .append(orderby)
+                .append(") as __row_number__, ")
+                .append(pagingBuilder)
+                .append(") SELECT * FROM query WHERE __row_number__ BETWEEN ")
+                .append(offset + 1).append(" AND ").append(offset + limit)
+                .append(" ORDER BY __row_number__");
+
+        return result.toString();
+    }
+
+    static String getOrderByPart(String sql) {
+        String loweredString = sql.toLowerCase();
+        int orderByIndex = loweredString.indexOf("order by");
+        if (orderByIndex != -1) {
+            // if we find a new "order by" then we need to ignore
+            // the previous one since it was probably used for a subquery
+            return sql.substring(orderByIndex);
+        } else {
+            return "";
+        }
+    }
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/dialect/SQLServerDialect.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.dialect;
+
+import com.jeespring.common.persistence.dialect.Dialect;
+
+/**
+ * MSSQLServer 数据库实现分页方言
+ *
+ * @author poplar.yfyang
+ * @version 1.0 2010-10-10 下午12:31
+ * @since JDK 1.5
+ */
+public class SQLServerDialect implements Dialect {
+
+    @Override
+    public boolean supportsLimit() {
+        return true;
+    }
+
+    static int getAfterSelectInsertPoint(String sql) {
+        int selectIndex = sql.toLowerCase().indexOf("select");
+        final int selectDistinctIndex = sql.toLowerCase().indexOf("select distinct");
+        return selectIndex + (selectDistinctIndex == selectIndex ? 15 : 6);
+    }
+
+    @Override
+    public String getLimitString(String sql, int offset, int limit) {
+        return getLimit(sql, offset, limit);
+    }
+
+    /**
+     * 将sql变成分页sql语句,提供将offset及limit使用占位符号(placeholder)替换.
+     * <pre>
+     * 如mysql
+     * dialect.getLimitString("select * from user", 12, ":offset",0,":limit") 将返回
+     * select * from user limit :offset,:limit
+     * </pre>
+     *
+     * @param sql    实际SQL语句
+     * @param offset 分页开始纪录条数
+     * @param limit  分页每页显示纪录条数
+     * @return 包含占位符的分页sql
+     */
+    public String getLimit(String sql, int offset, int limit) {
+        if (offset > 0) {
+            throw new UnsupportedOperationException("sql server has no offset");
+        }
+        return new StringBuffer(sql.length() + 8)
+                .append(sql)
+                .insert(getAfterSelectInsertPoint(sql), " top " + limit)
+                .toString();
+    }
+
+
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/dialect/SybaseDialect.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.dialect;
+
+import com.jeespring.common.persistence.dialect.Dialect;
+
+/**
+ * Sybase数据库分页方言实现。
+ * 还未实现
+ *
+ * @author poplar.yfyang
+ * @version 1.0 2010-10-10 下午12:31
+ * @since JDK 1.5
+ */
+public class SybaseDialect implements Dialect {
+
+    @Override
+    public boolean supportsLimit() {
+        return false;
+    }
+
+
+    @Override
+    public String getLimitString(String sql, int offset, int limit) {
+        return null;
+    }
+
+    /**
+     * 将sql变成分页sql语句,提供将offset及limit使用占位符号(placeholder)替换.
+     * <pre>
+     * 如mysql
+     * dialect.getLimitString("select * from user", 12, ":offset",0,":limit") 将返回
+     * select * from user limit :offset,:limit
+     * </pre>
+     *
+     * @param sql               实际SQL语句
+     * @param offset            分页开始纪录条数
+     * @param offsetPlaceholder 分页开始纪录条数－占位符号
+     * @param limit             分页每页显示纪录条数
+     * @param limitPlaceholder  分页纪录条数占位符号
+     * @return 包含占位符的分页sql
+     */
+    public String getLimitString(String sql, int offset, String offsetPlaceholder, int limit, String limitPlaceholder) {
+        throw new UnsupportedOperationException("paged queries not supported");
+    }
+
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/interceptor/BaseInterceptor.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.interceptor;
+
+import com.jeespring.common.config.Global;
+import com.jeespring.common.persistence.Page;
+import com.jeespring.common.persistence.dialect.*;
+import com.jeespring.common.utils.Reflections;
+import org.apache.ibatis.logging.Log;
+import org.apache.ibatis.logging.LogFactory;
+import org.apache.ibatis.plugin.Interceptor;
+
+import java.io.Serializable;
+import java.util.Properties;
+
+/**
+ * Mybatis分页拦截器基类
+ *
+ * @author poplar.yfyang / HuangBingGui
+ * @version 2013-8-28
+ */
+public abstract class BaseInterceptor implements Interceptor, Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    protected static final String PAGE = "page";
+
+    protected static final String DELEGATE = "delegate";
+
+    protected static final String MAPPED_STATEMENT = "mappedStatement";
+
+    protected Log log = LogFactory.getLog(this.getClass());
+
+    protected Dialect DIALECT;
+
+
+    /**
+     * 对参数进行转换和检查
+     *
+     * @param parameterObject 参数对象
+     * @param page            分页对象
+     * @return 分页对象
+     * @throws NoSuchFieldException 无法找到参数
+     */
+    @SuppressWarnings("unchecked")
+    protected static Page<Object> convertParameter(Object parameterObject, Page<Object> page) {
+        try {
+            if (parameterObject instanceof Page) {
+                return (Page<Object>) parameterObject;
+            } else {
+                return (Page<Object>) Reflections.getFieldValue(parameterObject, PAGE);
+            }
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    /**
+     * 设置属性，支持自定义方言类和制定数据库的方式
+     * <code>dialectClass</code>,自定义方言类。可以不配置这项
+     * <ode>dbms</ode> 数据库类型，插件支持的数据库
+     * <code>sqlPattern</code> 需要拦截的SQL ID
+     *
+     * @param p 属性
+     */
+    protected void initProperties(Properties p) {
+        Dialect dialect = null;
+        String dbType = Global.getJdbcType();
+        if ("db2".equals(dbType)) {
+            dialect = new DB2Dialect();
+        } else if ("derby".equals(dbType)) {
+            dialect = new DerbyDialect();
+        } else if ("h2".equals(dbType)) {
+            dialect = new H2Dialect();
+        } else if ("hsql".equals(dbType)) {
+            dialect = new HSQLDialect();
+        } else if ("mysql".equals(dbType)) {
+            dialect = new MySQLDialect();
+        } else if ("oracle".equals(dbType)) {
+            dialect = new OracleDialect();
+        } else if ("postgre".equals(dbType)) {
+            dialect = new PostgreSQLDialect();
+        } else if ("mssql".equals(dbType) || "sqlserver".equals(dbType)) {
+            dialect = new SQLServer2005Dialect();
+        } else if ("sybase".equals(dbType)) {
+            dialect = new SybaseDialect();
+        }
+        if (dialect == null) {
+            log.error("user the mysql dialect");
+            dialect = new MySQLDialect();
+        }
+        DIALECT = dialect;
+
+    }
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/interceptor/PaginationInterceptor.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.interceptor;
+
+import java.util.Properties;
+
+import org.apache.ibatis.executor.Executor;
+import org.apache.ibatis.mapping.BoundSql;
+import org.apache.ibatis.mapping.MappedStatement;
+import org.apache.ibatis.mapping.SqlSource;
+import org.apache.ibatis.plugin.Intercepts;
+import org.apache.ibatis.plugin.Invocation;
+import org.apache.ibatis.plugin.Plugin;
+import org.apache.ibatis.plugin.Signature;
+import org.apache.ibatis.reflection.MetaObject;
+import org.apache.ibatis.session.ResultHandler;
+import org.apache.ibatis.session.RowBounds;
+
+import com.jeespring.common.persistence.Page;
+import com.jeespring.common.utils.Reflections;
+import com.jeespring.common.utils.StringUtils;
+
+/**
+ * 数据库分页插件，只拦截查询语句.
+ * @author poplar.yfyang / HuangBingGui
+ * @version 2013-8-28
+ */
+@Intercepts({@Signature(type = Executor.class, method = "query",
+        args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})})
+public class PaginationInterceptor extends BaseInterceptor {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public Object intercept(Invocation invocation) throws Throwable {
+
+        final MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
+        
+//        //拦截需要分页的SQL
+////        if (mappedStatement.getId().matches(_SQL_PATTERN)) {
+//        if (StringUtils.indexOfIgnoreCase(mappedStatement.getId(), _SQL_PATTERN) != -1) {
+            Object parameter = invocation.getArgs()[1];
+            BoundSql boundSql = mappedStatement.getBoundSql(parameter);
+            Object parameterObject = boundSql.getParameterObject();
+
+            //获取分页参数对象
+            Page<Object> page = null;
+            if (parameterObject != null) {
+                page = convertParameter(parameterObject, page);
+            }
+
+            //如果设置了分页对象，则进行分页
+            if (page != null && page.getPageSize() != -1) {
+
+            	if (StringUtils.isBlank(boundSql.getSql())){
+                    return null;
+                }
+                String originalSql = boundSql.getSql().trim();
+            	
+                //得到总记录数
+                page.setCount(SQLHelper.getCount(originalSql, null, mappedStatement, parameterObject, boundSql, log));
+
+                //分页查询 本地化对象 修改数据库注意修改实现
+                String pageSql = SQLHelper.generatePageSql(originalSql, page, DIALECT);
+//                if (log.isDebugEnabled()) {
+//                    log.debug("PAGE SQL:" + StringUtils.replace(pageSql, "\n", ""));
+//                }
+                invocation.getArgs()[2] = new RowBounds(RowBounds.NO_ROW_OFFSET, RowBounds.NO_ROW_LIMIT);
+                BoundSql newBoundSql = new BoundSql(mappedStatement.getConfiguration(), pageSql, boundSql.getParameterMappings(), boundSql.getParameterObject());
+                //解决MyBatis 分页foreach 参数失效 start
+                if (Reflections.getFieldValue(boundSql, "metaParameters") != null) {
+                    MetaObject mo = (MetaObject) Reflections.getFieldValue(boundSql, "metaParameters");
+                    Reflections.setFieldValue(newBoundSql, "metaParameters", mo);
+                }
+                //解决MyBatis 分页foreach 参数失效 end
+                MappedStatement newMs = copyFromMappedStatement(mappedStatement, new BoundSqlSqlSource(newBoundSql));
+
+                invocation.getArgs()[0] = newMs;
+            }
+//        }
+        return invocation.proceed();
+    }
+
+
+    @Override
+    public Object plugin(Object target) {
+        return Plugin.wrap(target, this);
+    }
+
+    @Override
+    public void setProperties(Properties properties) {
+        super.initProperties(properties);
+    }
+
+    private MappedStatement copyFromMappedStatement(MappedStatement ms,
+                                                    SqlSource newSqlSource) {
+        MappedStatement.Builder builder = new MappedStatement.Builder(ms.getConfiguration(),
+                ms.getId(), newSqlSource, ms.getSqlCommandType());
+        builder.resource(ms.getResource());
+        builder.fetchSize(ms.getFetchSize());
+        builder.statementType(ms.getStatementType());
+        builder.keyGenerator(ms.getKeyGenerator());
+        if (ms.getKeyProperties() != null) {
+            for (String keyProperty : ms.getKeyProperties()) {
+                builder.keyProperty(keyProperty);
+            }
+        }
+        builder.timeout(ms.getTimeout());
+        builder.parameterMap(ms.getParameterMap());
+        builder.resultMaps(ms.getResultMaps());
+        builder.cache(ms.getCache());
+        builder.useCache(ms.isUseCache());
+        return builder.build();
+    }
+
+    public static class BoundSqlSqlSource implements SqlSource {
+        BoundSql boundSql;
+
+        public BoundSqlSqlSource(BoundSql boundSql) {
+            this.boundSql = boundSql;
+        }
+
+        @Override
+		public BoundSql getBoundSql(Object parameterObject) {
+            return boundSql;
+        }
+    }
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/interceptor/PreparePaginationInterceptor.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.interceptor;
+
+import java.sql.Connection;
+import java.util.Properties;
+
+import org.apache.ibatis.executor.statement.BaseStatementHandler;
+import org.apache.ibatis.executor.statement.RoutingStatementHandler;
+import org.apache.ibatis.executor.statement.StatementHandler;
+import org.apache.ibatis.mapping.BoundSql;
+import org.apache.ibatis.mapping.MappedStatement;
+import org.apache.ibatis.plugin.Intercepts;
+import org.apache.ibatis.plugin.Invocation;
+import org.apache.ibatis.plugin.Plugin;
+import org.apache.ibatis.plugin.Signature;
+
+import com.jeespring.common.persistence.Page;
+import com.jeespring.common.utils.Reflections;
+
+/**
+ * Mybatis数据库分页插件，拦截StatementHandler的prepare方法
+ * @author poplar.yfyang / HuangBingGui
+ * @version 2013-8-28
+ */
+@Intercepts({
+	@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class})
+})
+public class PreparePaginationInterceptor extends BaseInterceptor {
+    
+    private static final long serialVersionUID = 1L;
+
+    public PreparePaginationInterceptor() {
+        super();
+    }
+
+    @Override
+    public Object intercept(Invocation ivk) throws Throwable {
+        if (ivk.getTarget().getClass().isAssignableFrom(RoutingStatementHandler.class)) {
+            final RoutingStatementHandler statementHandler = (RoutingStatementHandler) ivk.getTarget();
+            final BaseStatementHandler delegate = (BaseStatementHandler) Reflections.getFieldValue(statementHandler, DELEGATE);
+            final MappedStatement mappedStatement = (MappedStatement) Reflections.getFieldValue(delegate, MAPPED_STATEMENT);
+
+//            //拦截需要分页的SQL
+////            if (mappedStatement.getId().matches(_SQL_PATTERN)) { 
+//            if (StringUtils.indexOfIgnoreCase(mappedStatement.getId(), _SQL_PATTERN) != -1) {
+                BoundSql boundSql = delegate.getBoundSql();
+                //分页SQL<select>中parameterType属性对应的实体参数，即Mapper接口中执行分页方法的参数,该参数不得为空
+                Object parameterObject = boundSql.getParameterObject();
+                if (parameterObject == null) {
+                    log.error("参数未实例化");
+                    throw new NullPointerException("parameterObject尚未实例化！");
+                } else {
+                    final Connection connection = (Connection) ivk.getArgs()[0];
+                    final String sql = boundSql.getSql();
+                    //记录统计
+                    final int count = SQLHelper.getCount(sql, connection, mappedStatement, parameterObject, boundSql, log);
+                    Page<Object> page = null;
+                    page = convertParameter(parameterObject, page);
+                    page.setCount(count);
+                    String pagingSql = SQLHelper.generatePageSql(sql, page, DIALECT);
+                    if (log.isDebugEnabled()) {
+                        log.debug("PAGE SQL:" + pagingSql);
+                    }
+                    //将分页sql语句反射回BoundSql.
+                    Reflections.setFieldValue(boundSql, "sql", pagingSql);
+                }
+                
+                if (boundSql.getSql() == null || "".equals(boundSql.getSql())){
+                    return null;
+                }
+                
+            }
+//        }
+        return ivk.proceed();
+    }
+
+
+    @Override
+    public Object plugin(Object o) {
+        return Plugin.wrap(o, this);
+    }
+
+    @Override
+    public void setProperties(Properties properties) {
+        initProperties(properties);
+    }
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/interceptor/SQLHelper.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.interceptor;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.ibatis.executor.ErrorContext;
+import org.apache.ibatis.executor.ExecutorException;
+import org.apache.ibatis.logging.Log;
+import org.apache.ibatis.mapping.BoundSql;
+import org.apache.ibatis.mapping.MappedStatement;
+import org.apache.ibatis.mapping.ParameterMapping;
+import org.apache.ibatis.mapping.ParameterMode;
+import org.apache.ibatis.reflection.MetaObject;
+import org.apache.ibatis.reflection.property.PropertyTokenizer;
+import org.apache.ibatis.scripting.xmltags.ForEachSqlNode;
+import org.apache.ibatis.session.Configuration;
+import org.apache.ibatis.type.TypeHandler;
+import org.apache.ibatis.type.TypeHandlerRegistry;
+
+import com.jeespring.common.config.Global;
+import com.jeespring.common.persistence.Page;
+import com.jeespring.common.persistence.dialect.Dialect;
+import com.jeespring.common.utils.Reflections;
+import com.jeespring.common.utils.StringUtils;
+
+/**
+ * SQL工具类
+ *
+ * @author poplar.yfyang / HuangBingGui
+ * @version 2013-8-28
+ */
+public class SQLHelper {
+
+    /**
+     * 对SQL参数(?)设值,参考org.apache.ibatis.executor.parameter.DefaultParameterHandler
+     *
+     * @param ps              表示预编译的 SQL 语句的对象。
+     * @param mappedStatement MappedStatement
+     * @param boundSql        SQL
+     * @param parameterObject 参数对象
+     * @throws SQLException 数据库异常
+     */
+    @SuppressWarnings("unchecked")
+    public static void setParameters(PreparedStatement ps, MappedStatement mappedStatement, BoundSql boundSql, Object parameterObject) throws SQLException {
+        ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
+        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
+        if (parameterMappings != null) {
+            Configuration configuration = mappedStatement.getConfiguration();
+            TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
+            MetaObject metaObject = parameterObject == null ? null :
+                    configuration.newMetaObject(parameterObject);
+            for (int i = 0; i < parameterMappings.size(); i++) {
+                ParameterMapping parameterMapping = parameterMappings.get(i);
+                if (parameterMapping.getMode() != ParameterMode.OUT) {
+                    Object value;
+                    String propertyName = parameterMapping.getProperty();
+                    PropertyTokenizer prop = new PropertyTokenizer(propertyName);
+                    if (parameterObject == null) {
+                        value = null;
+                    } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
+                        value = parameterObject;
+                    } else if (boundSql.hasAdditionalParameter(propertyName)) {
+                        value = boundSql.getAdditionalParameter(propertyName);
+                    } else if (propertyName.startsWith(ForEachSqlNode.ITEM_PREFIX) && boundSql.hasAdditionalParameter(prop.getName())) {
+                        value = boundSql.getAdditionalParameter(prop.getName());
+                        if (value != null) {
+                            value = configuration.newMetaObject(value).getValue(propertyName.substring(prop.getName().length()));
+                        }
+                    } else {
+                        value = metaObject == null ? null : metaObject.getValue(propertyName);
+                    }
+                    @SuppressWarnings("rawtypes")
+                    TypeHandler typeHandler = parameterMapping.getTypeHandler();
+                    if (typeHandler == null) {
+                        throw new ExecutorException("There was no TypeHandler found for parameter " + propertyName + " of statement " + mappedStatement.getId());
+                    }
+                    typeHandler.setParameter(ps, i + 1, value, parameterMapping.getJdbcType());
+                }
+            }
+        }
+    }
+
+
+    /**
+     * 查询总纪录数
+     *
+     * @param sql             SQL语句
+     * @param connection      数据库连接
+     * @param mappedStatement mapped
+     * @param parameterObject 参数
+     * @param boundSql        boundSql
+     * @return 总记录数
+     * @throws SQLException sql查询错误
+     */
+    public static int getCount(final String sql, final Connection connection,
+                               final MappedStatement mappedStatement, final Object parameterObject,
+                               final BoundSql boundSql, Log log) throws SQLException {
+        String dbName = Global.getJdbcType();
+        final String countSql;
+        if ("oracle".equals(dbName)) {
+            countSql = "select count(1) from (" + sql + ") tmp_count";
+        } else {
+            countSql = "select count(1) from (" + removeOrders(sql) + ") tmp_count";
+        }
+        Connection conn = connection;
+        PreparedStatement ps = null;
+        ResultSet rs = null;
+        try {
+            if (log.isDebugEnabled()) {
+                log.debug("COUNT SQL: " + StringUtils.replaceEach(countSql, new String[]{"\n", "\t"}, new String[]{" ", " "}));
+            }
+            if (conn == null) {
+                conn = mappedStatement.getConfiguration().getEnvironment().getDataSource().getConnection();
+            }
+            ps = conn.prepareStatement(countSql);
+            BoundSql countBS = new BoundSql(mappedStatement.getConfiguration(), countSql,
+                    boundSql.getParameterMappings(), parameterObject);
+            //解决MyBatis 分页foreach 参数失效 start
+            if (Reflections.getFieldValue(boundSql, "metaParameters") != null) {
+                MetaObject mo = (MetaObject) Reflections.getFieldValue(boundSql, "metaParameters");
+                Reflections.setFieldValue(countBS, "metaParameters", mo);
+            }
+            //解决MyBatis 分页foreach 参数失效 end
+            SQLHelper.setParameters(ps, mappedStatement, countBS, parameterObject);
+            rs = ps.executeQuery();
+            int count = 0;
+            if (rs.next()) {
+                count = rs.getInt(1);
+            }
+            return count;
+        } finally {
+            if (rs != null) {
+                rs.close();
+            }
+            if (ps != null) {
+                ps.close();
+            }
+            if (conn != null) {
+                conn.close();
+            }
+        }
+    }
+
+
+    /**
+     * 根据数据库方言，生成特定的分页sql
+     *
+     * @param sql     Mapper中的Sql语句
+     * @param page    分页对象
+     * @param dialect 方言类型
+     * @return 分页SQL
+     */
+    public static String generatePageSql(String sql, Page<Object> page, Dialect dialect) {
+        if (dialect.supportsLimit()) {
+            return dialect.getLimitString(sql, page.getFirstResult(), page.getMaxResults());
+        } else {
+            return sql;
+        }
+    }
+
+    /**
+     * 去除qlString的select子句。
+     *
+     * @param qlString
+     * @return
+     */
+    @SuppressWarnings("unused")
+    private static String removeSelect(String qlString) {
+        int beginPos = qlString.toLowerCase().indexOf("from");
+        return qlString.substring(beginPos);
+    }
+
+    /**
+     * 去除hql的orderBy子句。
+     *
+     * @param qlString
+     * @return
+     */
+    private static String removeOrders(String qlString) {
+        Pattern p = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*", Pattern.CASE_INSENSITIVE);
+        Matcher m = p.matcher(qlString);
+        StringBuffer sb = new StringBuffer();
+        while (m.find()) {
+            m.appendReplacement(sb, "");
+        }
+        m.appendTail(sb);
+        return sb.toString();
+    }
+
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/proxy/PageConfiguration.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.proxy;
+
+import org.apache.ibatis.binding.MapperRegistry;
+import org.apache.ibatis.session.Configuration;
+import org.apache.ibatis.session.SqlSession;
+
+/**
+ * <p>
+ * 自定义Mybatis的配置，扩展.
+ * </p>
+ *
+ * @author poplar.yfyang
+ * @version 1.0 2012-05-13 上午10:06
+ * @since JDK 1.5
+ */
+public class PageConfiguration extends Configuration {
+	
+    protected MapperRegistry mapperRegistry = new PaginationMapperRegistry(this);
+
+    @Override
+    public <T> void addMapper(Class<T> type) {
+        mapperRegistry.addMapper(type);
+    }
+
+    @Override
+    public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
+        return mapperRegistry.getMapper(type, sqlSession);
+    }
+
+    @Override
+    public boolean hasMapper(Class<?> type) {
+        return mapperRegistry.hasMapper(type);
+    }
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/proxy/PaginationMapperMethod.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.proxy;
+
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.binding.BindingException;
+import org.apache.ibatis.mapping.MappedStatement;
+import org.apache.ibatis.mapping.SqlCommandType;
+import org.apache.ibatis.session.Configuration;
+import org.apache.ibatis.session.RowBounds;
+import org.apache.ibatis.session.SqlSession;
+
+import com.jeespring.common.persistence.Page;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * <p>
+ * 执行代理类，扩展Mybatis的方式来让其Mapper接口来支持.
+ * </p>
+ *
+ * @author poplar.yfyang
+ * @version 1.0 2012-05-13 上午10:09
+ * @since JDK 1.5
+ */
+public class PaginationMapperMethod {
+
+    private final SqlSession sqlSession;
+    private final Configuration config;
+
+    private SqlCommandType type;
+    private String commandName;
+    private String commandCountName;
+
+    private final Class<?> declaringInterface;
+    private final Method method;
+
+    private Integer rowBoundsIndex;
+    private Integer paginationIndex;
+
+    private final List<String> paramNames;
+    private final List<Integer> paramPositions;
+
+    private boolean hasNamedParameters;
+
+    public PaginationMapperMethod(Class<?> declaringInterface, Method method,
+                                  SqlSession sqlSession) {
+        paramNames = new ArrayList<String>();
+        paramPositions = new ArrayList<Integer>();
+        this.sqlSession = sqlSession;
+        this.method = method;
+        this.config = sqlSession.getConfiguration();
+        this.declaringInterface = declaringInterface;
+        this.hasNamedParameters = false;
+        setupFields();
+        setupMethodSignature();
+        setupCommandType();
+        validateStatement();
+    }
+
+    /**
+     * 代理执行方法。
+     *
+     * @param args 参数信息
+     * @return 执行结果
+     */
+    @SuppressWarnings("unchecked")
+    public Object execute(Object[] args) {
+        final Object param = getParam(args);
+        Page<Object> page;
+        RowBounds rowBounds;
+        if (paginationIndex != null) {
+            page = (Page<Object>) args[paginationIndex];
+            rowBounds =  new RowBounds(page.getFirstResult(), page.getMaxResults());
+        } else if (rowBoundsIndex != null) {
+            rowBounds = (RowBounds) args[rowBoundsIndex];
+            page = new Page<Object>();
+        } else {
+            throw new BindingException("Invalid bound statement (not found rowBounds or pagination in paramenters)");
+        }
+        page.setCount(executeForCount(param));
+        page.setList(executeForList(param, rowBounds));
+        return page;
+    }
+
+    /**
+     * 执行总数的方法，调用方法执行计算总数，取得总结果
+     *
+     * @param param 参数信息
+     * @return 查询的总记录数
+     */
+    private long executeForCount(Object param) {
+        Number result = (Number) sqlSession.selectOne(commandCountName, param);
+        return result.longValue();
+    }
+
+    /**
+     * 取得分页的执行结果，返回的是纪录信息
+     *
+     * @param param     参数
+     * @param rowBounds row
+     * @return 纪录列表
+     */
+    private List<Object> executeForList(Object param, RowBounds rowBounds) {
+        return sqlSession.selectList(commandName, param, rowBounds);
+    }
+
+    /**
+     * 取得当前执行的参数信息
+     *
+     * @param args 参数
+     * @return 参数信息
+     */
+    private Object getParam(Object[] args) {
+        final int paramCount = paramPositions.size();
+        if (args == null || paramCount == 0) {
+            return null;
+        } else if (!hasNamedParameters && paramCount == 1) {
+            return args[paramPositions.get(0)];
+        } else {
+            Map<String, Object> param = new HashMap<String, Object>();
+            for (int i = 0; i < paramCount; i++) {
+                param.put(paramNames.get(i), args[paramPositions.get(i)]);
+            }
+            return param;
+        }
+    }
+
+    private void setupMethodSignature() {
+        final Class<?>[] argTypes = method.getParameterTypes();
+        for (int i = 0; i < argTypes.length; i++) {
+            if (Page.class.isAssignableFrom(argTypes[i])) {
+                paginationIndex = i;
+            } else if (RowBounds.class.isAssignableFrom(argTypes[i])) {
+                rowBoundsIndex = i;
+            } else {
+                String paramName = String.valueOf(paramPositions.size());
+                paramName = getParamNameFromAnnotation(i, paramName);
+                paramNames.add(paramName);
+                paramPositions.add(i);
+            }
+        }
+    }
+
+    private String getParamNameFromAnnotation(int i, String paramName) {
+        Object[] annotations = method.getParameterAnnotations()[i];
+        for (Object annotation : annotations) {
+            if (annotation instanceof Param) {
+                hasNamedParameters = true;
+                paramName = ((Param) annotation).value();
+            }
+        }
+        return paramName;
+    }
+
+    /**
+     * 设置当前的查询总记录数的ID
+     */
+    private void setupFields() {
+        commandName = declaringInterface.getName() + "." + method.getName();
+        commandCountName = commandName + "Count"; // 命名约定
+    }
+
+    /**
+     * 设置当前的参数的类型信息
+     */
+    private void setupCommandType() {
+        MappedStatement ms = config.getMappedStatement(commandName);
+        type = ms.getSqlCommandType();
+        if (type != SqlCommandType.SELECT) {
+            throw new BindingException("Unsupport execution method for: " + commandName);
+        }
+    }
+
+    /**
+     * 验证Statement
+     */
+    private void validateStatement() {
+        if (!config.hasStatement(commandName)) {
+            throw new BindingException("Invalid bound statement (not found): " + commandName);
+        }
+        if (!config.hasStatement(commandCountName)) {
+            throw new BindingException("Invalid bound statement (not found): " + commandCountName);
+        }
+    }
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/proxy/PaginationMapperProxy.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.proxy;
+
+import org.apache.ibatis.binding.BindingException;
+import org.apache.ibatis.binding.MapperMethod;
+import org.apache.ibatis.session.SqlSession;
+
+import com.jeespring.common.persistence.Page;
+import com.jeespring.common.utils.Reflections;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * <p>
+ * .
+ * </p>
+ *
+ * @author poplar.yfyang
+ * @version 1.0 2012-05-13 上午10:07
+ * @since JDK 1.5
+ */
+public class PaginationMapperProxy implements InvocationHandler {
+
+
+    private static final Set<String> OBJECT_METHODS = new HashSet<String>() {
+        private static final long serialVersionUID = -1782950882770203583L;
+        {
+            add("toString");
+            add("getClass");
+            add("hashCode");
+            add("equals");
+            add("wait");
+            add("notify");
+            add("notifyAll");
+        }
+    };
+
+    private boolean isObjectMethod(Method method) {
+        return OBJECT_METHODS.contains(method.getName());
+    }
+
+    private final SqlSession sqlSession;
+
+    private PaginationMapperProxy(final SqlSession sqlSession) {
+        this.sqlSession = sqlSession;
+    }
+
+    @Override
+    public Object invoke(Object proxy, Method method, Object[] args)
+            throws Throwable {
+        if (isObjectMethod(method)) {
+            return null;
+        }
+        final Class<?> declaringInterface = findDeclaringInterface(proxy, method);
+        if (Page.class.isAssignableFrom(method.getReturnType())) {
+            // 分页处理
+            return new PaginationMapperMethod(declaringInterface, method, sqlSession).execute(args);
+        }
+        // 原处理方式
+        final MapperMethod mapperMethod = new MapperMethod(declaringInterface, method, sqlSession.getConfiguration());
+        final Object result = mapperMethod.execute(sqlSession, args);
+        if (result == null && method.getReturnType().isPrimitive()) {
+            throw new BindingException(
+                    "Mapper method '"
+                            + method.getName()
+                            + "' ("
+                            + method.getDeclaringClass()
+                            + ") attempted to return null from a method with a primitive return type ("
+                            + method.getReturnType() + ").");
+        }
+        return result;
+    }
+
+    private Class<?> findDeclaringInterface(Object proxy, Method method) {
+        Class<?> declaringInterface = null;
+        for (Class<?> mapperFaces : proxy.getClass().getInterfaces()) {
+            Method m = Reflections.getAccessibleMethod(mapperFaces,
+                    method.getName(),
+                    method.getParameterTypes());
+            if (m != null) {
+                declaringInterface = mapperFaces;
+            }
+        }
+        if (declaringInterface == null) {
+            throw new BindingException(
+                    "Could not find interface with the given method " + method);
+        }
+        return declaringInterface;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> T newMapperProxy(Class<T> mapperInterface, SqlSession sqlSession) {
+        ClassLoader classLoader = mapperInterface.getClassLoader();
+        Class<?>[] interfaces = new Class[]{mapperInterface};
+        PaginationMapperProxy proxy = new PaginationMapperProxy(sqlSession);
+        return (T) Proxy.newProxyInstance(classLoader, interfaces, proxy);
+    }
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/persistence/proxy/PaginationMapperRegistry.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.persistence.proxy;
+
+import org.apache.ibatis.binding.BindingException;
+import org.apache.ibatis.binding.MapperRegistry;
+import org.apache.ibatis.session.Configuration;
+import org.apache.ibatis.session.SqlSession;
+
+/**
+ * <p>
+ * .
+ * </p>
+ *
+ * @author poplar.yfyang
+ * @version 1.0 2012-05-13 上午10:06
+ * @since JDK 1.5
+ */
+public class PaginationMapperRegistry extends MapperRegistry {
+    public PaginationMapperRegistry(Configuration config) {
+        super(config);
+    }
+
+    @Override
+    public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
+        if (!hasMapper(type)) {
+            throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
+        }
+        try {
+            return PaginationMapperProxy.newMapperProxy(type, sqlSession);
+        } catch (Exception e) {
+            throw new BindingException("Error getting mapper instance. Cause: " + e, e);
+        }
+    }
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/redis/JedisUtils.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://www.jeespring.org>JeeSpring</a> All rights reserved.
+ */
+package com.jeespring.common.redis;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.jeespring.common.utils.ObjectUtils;
+import com.jeespring.common.utils.SpringContextHolder;
+import com.jeespring.common.utils.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.JedisPool;
+import redis.clients.jedis.exceptions.JedisException;
+
+/**
+ * Jedis Cache 工具类
+ * 
+ * @author JeeSpring
+ * @version 2014-6-29
+ */
+public class JedisUtils {
+
+	private static Logger logger = LoggerFactory.getLogger(JedisUtils.class);
+	
+	private static JedisPool jedisPool = SpringContextHolder.getBean(JedisPool.class);
+
+	//public static final String KEY_PREFIX = Global.getConfig("redis.keyPrefix");
+	
+	/**
+	 * 获取缓存
+	 * @param key 键
+	 * @return 值
+	 */
+	public static String get(String key) {
+		String value = null;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			if (jedis.exists(key)) {
+				value = jedis.get(key);
+				value = StringUtils.isNotBlank(value) && !"nil".equalsIgnoreCase(value) ? value : null;
+				logger.debug("get {} = {}", key, value);
+			}
+		} catch (Exception e) {
+			logger.warn("get {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return value;
+	}
+	
+	/**
+	 * 获取缓存
+	 * @param key 键
+	 * @return 值
+	 */
+	public static Object getObject(String key) {
+		Object value = null;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			if (jedis.exists(getBytesKey(key))) {
+				value = toObject(jedis.get(getBytesKey(key)));
+				logger.debug("getObject {} = {}", key, value);
+			}
+		} catch (Exception e) {
+			logger.warn("getObject {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return value;
+	}
+	
+	/**
+	 * 设置缓存
+	 * @param key 键
+	 * @param value 值
+	 * @param cacheSeconds 超时时间，0为不超时
+	 * @return
+	 */
+	public static String set(String key, String value, int cacheSeconds) {
+		String result = null;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			result = jedis.set(key, value);
+			if (cacheSeconds != 0) {
+				jedis.expire(key, cacheSeconds);
+			}
+			logger.debug("set {} = {}", key, value);
+		} catch (Exception e) {
+			logger.warn("set {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 设置缓存
+	 * @param key 键
+	 * @param value 值
+	 * @param cacheSeconds 超时时间，0为不超时
+	 * @return
+	 */
+	public static String setObject(String key, Object value, int cacheSeconds) {
+		String result = null;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			result = jedis.set(getBytesKey(key), toBytes(value));
+			if (cacheSeconds != 0) {
+				jedis.expire(key, cacheSeconds);
+			}
+			logger.debug("setObject {} = {}", key, value);
+		} catch (Exception e) {
+			logger.warn("setObject {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 获取List缓存
+	 * @param key 键
+	 * @return 值
+	 */
+	public static List<String> getList(String key) {
+		List<String> value = null;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			if (jedis.exists(key)) {
+				value = jedis.lrange(key, 0, -1);
+				logger.debug("getList {} = {}", key, value);
+			}
+		} catch (Exception e) {
+			logger.warn("getList {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return value;
+	}
+	
+	/**
+	 * 获取List缓存
+	 * @param key 键
+	 * @return 值
+	 */
+	public static List<Object> getObjectList(String key) {
+		List<Object> value = null;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			if (jedis.exists(getBytesKey(key))) {
+				List<byte[]> list = jedis.lrange(getBytesKey(key), 0, -1);
+				value = Lists.newArrayList();
+				for (byte[] bs : list){
+					value.add(toObject(bs));
+				}
+				logger.debug("getObjectList {} = {}", key, value);
+			}
+		} catch (Exception e) {
+			logger.warn("getObjectList {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return value;
+	}
+	
+	/**
+	 * 设置List缓存
+	 * @param key 键
+	 * @param value 值
+	 * @param cacheSeconds 超时时间，0为不超时
+	 * @return
+	 */
+	public static long setList(String key, List<String> value, int cacheSeconds) {
+		long result = 0;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			if (jedis.exists(key)) {
+				jedis.del(key);
+			}
+			result = jedis.rpush(key, (String[])value.toArray());
+			if (cacheSeconds != 0) {
+				jedis.expire(key, cacheSeconds);
+			}
+			logger.debug("setList {} = {}", key, value);
+		} catch (Exception e) {
+			logger.warn("setList {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 设置List缓存
+	 * @param key 键
+	 * @param value 值
+	 * @param cacheSeconds 超时时间，0为不超时
+	 * @return
+	 */
+	public static long setObjectList(String key, List<Object> value, int cacheSeconds) {
+		long result = 0;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			if (jedis.exists(getBytesKey(key))) {
+				jedis.del(key);
+			}
+			List<byte[]> list = Lists.newArrayList();
+			for (Object o : value){
+				list.add(toBytes(o));
+			}
+			result = jedis.rpush(getBytesKey(key), (byte[][])list.toArray());
+			if (cacheSeconds != 0) {
+				jedis.expire(key, cacheSeconds);
+			}
+			logger.debug("setObjectList {} = {}", key, value);
+		} catch (Exception e) {
+			logger.warn("setObjectList {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 向List缓存中添加值
+	 * @param key 键
+	 * @param value 值
+	 * @return
+	 */
+	public static long listAdd(String key, String... value) {
+		long result = 0;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			result = jedis.rpush(key, value);
+			logger.debug("listAdd {} = {}", key, value);
+		} catch (Exception e) {
+			logger.warn("listAdd {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 向List缓存中添加值
+	 * @param key 键
+	 * @param value 值
+	 * @return
+	 */
+	public static long listObjectAdd(String key, Object... value) {
+		long result = 0;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			List<byte[]> list = Lists.newArrayList();
+			for (Object o : value){
+				list.add(toBytes(o));
+			}
+			result = jedis.rpush(getBytesKey(key), (byte[][])list.toArray());
+			logger.debug("listObjectAdd {} = {}", key, value);
+		} catch (Exception e) {
+			logger.warn("listObjectAdd {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+
+	/**
+	 * 获取缓存
+	 * @param key 键
+	 * @return 值
+	 */
+	public static Set<String> getSet(String key) {
+		Set<String> value = null;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			if (jedis.exists(key)) {
+				value = jedis.smembers(key);
+				logger.debug("getSet {} = {}", key, value);
+			}
+		} catch (Exception e) {
+			logger.warn("getSet {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return value;
+	}
+	
+	/**
+	 * 获取缓存
+	 * @param key 键
+	 * @return 值
+	 */
+	public static Set<Object> getObjectSet(String key) {
+		Set<Object> value = null;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			if (jedis.exists(getBytesKey(key))) {
+				value = Sets.newHashSet();
+				Set<byte[]> set = jedis.smembers(getBytesKey(key));
+				for (byte[] bs : set){
+					value.add(toObject(bs));
+				}
+				logger.debug("getObjectSet {} = {}", key, value);
+			}
+		} catch (Exception e) {
+			logger.warn("getObjectSet {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return value;
+	}
+	
+	/**
+	 * 设置Set缓存
+	 * @param key 键
+	 * @param value 值
+	 * @param cacheSeconds 超时时间，0为不超时
+	 * @return
+	 */
+	public static long setSet(String key, Set<String> value, int cacheSeconds) {
+		long result = 0;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			if (jedis.exists(key)) {
+				jedis.del(key);
+			}
+			result = jedis.sadd(key, (String[])value.toArray());
+			if (cacheSeconds != 0) {
+				jedis.expire(key, cacheSeconds);
+			}
+			logger.debug("setSet {} = {}", key, value);
+		} catch (Exception e) {
+			logger.warn("setSet {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 设置Set缓存
+	 * @param key 键
+	 * @param value 值
+	 * @param cacheSeconds 超时时间，0为不超时
+	 * @return
+	 */
+	public static long setObjectSet(String key, Set<Object> value, int cacheSeconds) {
+		long result = 0;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			if (jedis.exists(getBytesKey(key))) {
+				jedis.del(key);
+			}
+			Set<byte[]> set = Sets.newHashSet();
+			for (Object o : value){
+				set.add(toBytes(o));
+			}
+			result = jedis.sadd(getBytesKey(key), (byte[][])set.toArray());
+			if (cacheSeconds != 0) {
+				jedis.expire(key, cacheSeconds);
+			}
+			logger.debug("setObjectSet {} = {}", key, value);
+		} catch (Exception e) {
+			logger.warn("setObjectSet {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 向Set缓存中添加值
+	 * @param key 键
+	 * @param value 值
+	 * @return
+	 */
+	public static long setSetAdd(String key, String... value) {
+		long result = 0;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			result = jedis.sadd(key, value);
+			logger.debug("setSetAdd {} = {}", key, value);
+		} catch (Exception e) {
+			logger.warn("setSetAdd {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+
+	/**
+	 * 向Set缓存中添加值
+	 * @param key 键
+	 * @param value 值
+	 * @return
+	 */
+	public static long setSetObjectAdd(String key, Object... value) {
+		long result = 0;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			Set<byte[]> set = Sets.newHashSet();
+			for (Object o : value){
+				set.add(toBytes(o));
+			}
+			result = jedis.rpush(getBytesKey(key), (byte[][])set.toArray());
+			logger.debug("setSetObjectAdd {} = {}", key, value);
+		} catch (Exception e) {
+			logger.warn("setSetObjectAdd {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 获取Map缓存
+	 * @param key 键
+	 * @return 值
+	 */
+	public static Map<String, String> getMap(String key) {
+		Map<String, String> value = null;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			if (jedis.exists(key)) {
+				value = jedis.hgetAll(key);
+				logger.debug("getMap {} = {}", key, value);
+			}
+		} catch (Exception e) {
+			logger.warn("getMap {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return value;
+	}
+	
+	/**
+	 * 获取Map缓存
+	 * @param key 键
+	 * @return 值
+	 */
+	public static Map<String, Object> getObjectMap(String key) {
+		Map<String, Object> value = null;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			if (jedis.exists(getBytesKey(key))) {
+				value = Maps.newHashMap();
+				Map<byte[], byte[]> map = jedis.hgetAll(getBytesKey(key));
+				for (Map.Entry<byte[], byte[]> e : map.entrySet()){
+					value.put(StringUtils.toString(e.getKey()), toObject(e.getValue()));
+				}
+				logger.debug("getObjectMap {} = {}", key, value);
+			}
+		} catch (Exception e) {
+			logger.warn("getObjectMap {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return value;
+	}
+	
+	/**
+	 * 设置Map缓存
+	 * @param key 键
+	 * @param value 值
+	 * @param cacheSeconds 超时时间，0为不超时
+	 * @return
+	 */
+	public static String setMap(String key, Map<String, String> value, int cacheSeconds) {
+		String result = null;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			if (jedis.exists(key)) {
+				jedis.del(key);
+			}
+			result = jedis.hmset(key, value);
+			if (cacheSeconds != 0) {
+				jedis.expire(key, cacheSeconds);
+			}
+			logger.debug("setMap {} = {}", key, value);
+		} catch (Exception e) {
+			logger.warn("setMap {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 设置Map缓存
+	 * @param key 键
+	 * @param value 值
+	 * @param cacheSeconds 超时时间，0为不超时
+	 * @return
+	 */
+	public static String setObjectMap(String key, Map<String, Object> value, int cacheSeconds) {
+		String result = null;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			if (jedis.exists(getBytesKey(key))) {
+				jedis.del(key);
+			}
+			Map<byte[], byte[]> map = Maps.newHashMap();
+			for (Map.Entry<String, Object> e : value.entrySet()){
+				map.put(getBytesKey(e.getKey()), toBytes(e.getValue()));
+			}
+			result = jedis.hmset(getBytesKey(key), (Map<byte[], byte[]>)map);
+			if (cacheSeconds != 0) {
+				jedis.expire(key, cacheSeconds);
+			}
+			logger.debug("setObjectMap {} = {}", key, value);
+		} catch (Exception e) {
+			logger.warn("setObjectMap {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 向Map缓存中添加值
+	 * @param key 键
+	 * @param value 值
+	 * @return
+	 */
+	public static String mapPut(String key, Map<String, String> value) {
+		String result = null;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			result = jedis.hmset(key, value);
+			logger.debug("mapPut {} = {}", key, value);
+		} catch (Exception e) {
+			logger.warn("mapPut {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 向Map缓存中添加值
+	 * @param key 键
+	 * @param value 值
+	 * @return
+	 */
+	public static String mapObjectPut(String key, Map<String, Object> value) {
+		String result = null;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			Map<byte[], byte[]> map = Maps.newHashMap();
+			for (Map.Entry<String, Object> e : value.entrySet()){
+				map.put(getBytesKey(e.getKey()), toBytes(e.getValue()));
+			}
+			result = jedis.hmset(getBytesKey(key), (Map<byte[], byte[]>)map);
+			logger.debug("mapObjectPut {} = {}", key, value);
+		} catch (Exception e) {
+			logger.warn("mapObjectPut {} = {}", key, value, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 移除Map缓存中的值
+	 * @param key 键
+	 * @return
+	 */
+	public static long mapRemove(String key, String mapKey) {
+		long result = 0;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			result = jedis.hdel(key, mapKey);
+			logger.debug("mapRemove {}  {}", key, mapKey);
+		} catch (Exception e) {
+			logger.warn("mapRemove {}  {}", key, mapKey, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 移除Map缓存中的值
+	 * @param key 键
+	 * @return
+	 */
+	public static long mapObjectRemove(String key, String mapKey) {
+		long result = 0;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			result = jedis.hdel(getBytesKey(key), getBytesKey(mapKey));
+			logger.debug("mapObjectRemove {}  {}", key, mapKey);
+		} catch (Exception e) {
+			logger.warn("mapObjectRemove {}  {}", key, mapKey, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 判断Map缓存中的Key是否存在
+	 * @param key 键
+	 * @return
+	 */
+	public static boolean mapExists(String key, String mapKey) {
+		boolean result = false;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			result = jedis.hexists(key, mapKey);
+			logger.debug("mapExists {}  {}", key, mapKey);
+		} catch (Exception e) {
+			logger.warn("mapExists {}  {}", key, mapKey, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 判断Map缓存中的Key是否存在
+	 * @param key 键
+	 * @return
+	 */
+	public static boolean mapObjectExists(String key, String mapKey) {
+		boolean result = false;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			result = jedis.hexists(getBytesKey(key), getBytesKey(mapKey));
+			logger.debug("mapObjectExists {}  {}", key, mapKey);
+		} catch (Exception e) {
+			logger.warn("mapObjectExists {}  {}", key, mapKey, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 删除缓存
+	 * @param key 键
+	 * @return
+	 */
+	public static long del(String key) {
+		long result = 0;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			if (jedis.exists(key)){
+				result = jedis.del(key);
+				logger.debug("del {}", key);
+			}else{
+				logger.debug("del {} not exists", key);
+			}
+		} catch (Exception e) {
+			logger.warn("del {}", key, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+
+	/**
+	 * 删除缓存
+	 * @param key 键
+	 * @return
+	 */
+	public static long delObject(String key) {
+		long result = 0;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			if (jedis.exists(getBytesKey(key))){
+				result = jedis.del(getBytesKey(key));
+				logger.debug("delObject {}", key);
+			}else{
+				logger.debug("delObject {} not exists", key);
+			}
+		} catch (Exception e) {
+			logger.warn("delObject {}", key, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 缓存是否存在
+	 * @param key 键
+	 * @return
+	 */
+	public static boolean exists(String key) {
+		boolean result = false;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			result = jedis.exists(key);
+			logger.debug("exists {}", key);
+		} catch (Exception e) {
+			logger.warn("exists {}", key, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+	
+	/**
+	 * 缓存是否存在
+	 * @param key 键
+	 * @return
+	 */
+	public static boolean existsObject(String key) {
+		boolean result = false;
+		Jedis jedis = null;
+		try {
+			jedis = getResource();
+			result = jedis.exists(getBytesKey(key));
+			logger.debug("existsObject {}", key);
+		} catch (Exception e) {
+			logger.warn("existsObject {}", key, e);
+		} finally {
+			returnResource(jedis);
+		}
+		return result;
+	}
+
+	/**
+	 * 获取资源
+	 * @return
+	 * @throws JedisException
+	 */
+	public static Jedis getResource() throws JedisException {
+		Jedis jedis = null;
+		try {
+			jedis = jedisPool.getResource();
+//			logger.debug("getResource.", jedis);
+		} catch (JedisException e) {
+			logger.warn("getResource.", e);
+			returnBrokenResource(jedis);
+			throw e;
+		}
+		return jedis;
+	}
+
+	/**
+	 * 归还资源
+	 * @param jedis
+	 */
+	public static void returnBrokenResource(Jedis jedis) {
+		if (jedis != null) {
+			jedisPool.returnBrokenResource(jedis);
+		}
+	}
+	
+	/**
+	 * 释放资源
+	 * @param jedis
+	 */
+	public static void returnResource(Jedis jedis) {
+		if (jedis != null) {
+			jedisPool.returnResource(jedis);
+		}
+	}
+
+	/**
+	 * 获取byte[]类型Key
+	 * @return
+	 */
+	public static byte[] getBytesKey(Object object){
+		if(object instanceof String){
+    		return StringUtils.getBytes((String)object);
+    	}else{
+    		return ObjectUtils.serialize(object);
+    	}
+	}
+	
+	/**
+	 * 获取byte[]类型Key
+	 * @param key
+	 * @return
+	 */
+	public static Object getObjectKey(byte[] key){
+		try{
+			return StringUtils.toString(key);
+		}catch(UnsupportedOperationException uoe){
+			try{
+				return JedisUtils.toObject(key);
+			}catch(UnsupportedOperationException uoe2){
+				uoe2.printStackTrace();
+			}
+		}
+		return null;
+	}
+	
+	/**
+	 * Object转换byte[]类型
+	 * @return
+	 */
+	public static byte[] toBytes(Object object){
+    	return ObjectUtils.serialize(object);
+	}
+
+	/**
+	 * byte[]型转换Object
+	 * @return
+	 */
+	public static Object toObject(byte[] bytes){
+		return ObjectUtils.unserialize(bytes);
+	}
+
+}