springBoot基于myBites分页Interceptor

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.UUID;
import java.util.Map.Entry;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.Interceptor;
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.reflection.SystemMetaObject;
import org.apache.ibatis.scripting.defaults.DefaultParameterHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Intercepts({@Signature(
    type = StatementHandler.class,
    method = "prepare",
    args = {Connection.class, Integer.class}
)})
public class PageInterceptor implements Interceptor {
    private static final String pageFlag = "paged";
    private Logger log = LoggerFactory.getLogger(this.getClass());

    public PageInterceptor() {
    }

    public Object intercept(Invocation arg0) throws Throwable {
        if (arg0.getTarget() instanceof StatementHandler) {
            StatementHandler statementHandler = (StatementHandler)arg0.getTarget();
            MetaObject metaObject = SystemMetaObject.forObject(statementHandler);
            MappedStatement mappedStatement = (MappedStatement)metaObject.getValue("delegate.mappedStatement");
            String selectId = mappedStatement.getId();
            SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
            if (selectId.substring(selectId.lastIndexOf(".") + 1).toLowerCase().contains("paged") && sqlCommandType == SqlCommandType.SELECT) {
                BoundSql boundSql = (BoundSql)metaObject.getValue("delegate.boundSql");
                String sql = boundSql.getSql();
                Map param = (Map)boundSql.getParameterObject();
                Connection connection = (Connection)arg0.getArgs()[0];
                String countSql = this.concatCountSql(sql, param);
                String pageSql = this.getPageSql(connection, sql, param);
                PreparedStatement statement = null;
                ResultSet rs = null;
                int totalCount = 0;

                try {
                    statement = connection.prepareStatement(countSql);
                    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
                    Object parameterObject = boundSql.getParameterObject();
                    BoundSql countBoundSql = new BoundSql(mappedStatement.getConfiguration(), countSql, parameterMappings, parameterObject);
                    Field additionalParametersField = BoundSql.class.getDeclaredField("additionalParameters");
                    additionalParametersField.setAccessible(true);
                    Map<String, Object> additionalParameters = (Map)additionalParametersField.get(boundSql);
                    Iterator var21 = additionalParameters.keySet().iterator();

                    while(var21.hasNext()) {
                        String key = (String)var21.next();
                        countBoundSql.setAdditionalParameter(key, additionalParameters.get(key));
                    }

                    ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, parameterObject, countBoundSql);
                    parameterHandler.setParameters(statement);
                    rs = statement.executeQuery();
                    if (rs.next()) {
                        totalCount = rs.getInt(1);
                    }
                } catch (SQLException var31) {
                    this.log.error("执行sql时发生错误:" + var31.getMessage());
                    BaseUtil.saveLog(0, "执行sql时发生错误", var31.getMessage());
                } finally {
                    try {
                        if (rs != null) {
                            rs.close();
                        }

                        if (statement != null) {
                            statement.close();
                        }
                    } catch (SQLException var30) {
                        this.log.error("执行sql时发生错误:" + var30.getMessage());
                        BaseUtil.saveLog(0, "执行sql时发生错误", var30.getMessage());
                    }

                }

                metaObject.setValue("delegate.boundSql.sql", pageSql);
                param.put("total", totalCount);
                int size = Integer.valueOf(param.get("rows").toString());
                double pageCount = Math.ceil((double)totalCount / (double)size);
                param.put("pageCount", (int)pageCount);
            }
        }

        return arg0.proceed();
    }

    public Object plugin(Object arg0) {
        return arg0 instanceof StatementHandler ? Plugin.wrap(arg0, this) : arg0;
    }

    public void setProperties(Properties arg0) {
    }

    private String getPageSql(Connection conn, String sql, Map param) throws SQLException {
        StringBuffer sqlBuffer = new StringBuffer(sql);
        DatabaseMetaData dbmd = conn.getMetaData();
        String dataBaseType = dbmd.getDatabaseProductName().toLowerCase();
        if (dataBaseType.contains("mysql")) {
            return param.get("filter") == null && param.get("sort") == null ? this.concatMysqlPageSql(sql, param) : this.kendoMysqlPageSql(sql, param);
        } else if (dataBaseType.contains("oracle")) {
            return param.get("filter") == null && param.get("sort") == null ? this.concatOraclePageSql(sql, param) : this.kendoCountSql(sql, param);
        } else {
            return sqlBuffer.toString();
        }
    }

    private String concatMysqlPageSql(String sql, Map param) {
        String sqlPage = String.format(" %s limit %d,%d", sql, param.get("offset"), param.get("rows"));
        return sqlPage;
    }

    private String concatOraclePageSql(String sql, Map param) {
        StringBuffer buffer = new StringBuffer();
        return buffer.toString();
    }

    private String concatCountSql(String sql, Map param) {
        StringBuffer buffer = new StringBuffer();
        buffer.append("select count(1) from (");
        buffer.append(sql);
        buffer.append(") v");
        return buffer.toString();
    }

    private String kendoMysqlPageSql(String sql, Map param) {
        StringBuffer buffer = new StringBuffer();
        Map filter = (Map)param.get("filter");
        Map condition = buildCondition(filter);
        String clauseSql = condition.get("clause").toString();
        ArrayList sortField = (ArrayList)param.get("sort");
        if (clauseSql.length() > 0) {
            buffer.append("select * from (");
            buffer.append(sql);
            buffer.append(") v where 1 = 1 and ");
            buffer.append(clauseSql);
        } else {
            buffer.append("select * from (");
            buffer.append(sql);
            buffer.append(") v");
        }

        String sortStr;
        if (sortField != null && sortField.size() > 0) {
            sortStr = "";

            Map field;
            for(Iterator var9 = sortField.iterator(); var9.hasNext(); sortStr = sortStr + String.format("%s %s,", field.get("field"), field.get("dir"))) {
                Object item = var9.next();
                field = (Map)item;
            }

            String sort = String.format(" order by %s", sortStr.substring(0, sortStr.length() - 1));
            buffer.append(sort);
        }

        sortStr = String.format(" limit %d,%d", param.get("offset"), param.get("rows"));
        buffer.append(sortStr);
        return buffer.toString();
    }

    private String kendoCountSql(String sql, Map param) {
        StringBuffer buffer = new StringBuffer();
        Map filter = (Map)param.get("filter");
        Map condition = buildCondition(filter);
        String clauseSql = condition.get("clause").toString();
        if (clauseSql.length() > 0) {
            buffer.append("select count(1) from (");
            buffer.append(sql);
            buffer.append(") v where 1 = 1 and ");
            buffer.append(clauseSql);
        } else {
            buffer.append("select count(1) from (");
            buffer.append(sql);
            buffer.append(") v");
        }

        return buffer.toString();
    }

    private static Map buildCondition(Map filter) {
        Map data = new HashMap();
        if (filter == null) {
            data.put("clause", "");
            return data;
        } else {
            StringBuilder clause = new StringBuilder();
            ArrayList filters = (ArrayList)filter.get("filters");
            if (filters != null) {
                clause.append("(");

                for(int i = 0; i < filters.size(); ++i) {
                    Map f = (Map)filters.get(i);
                    Map temp;
                    if (f.get("logic") == null && f.get("filters") == null) {
                        temp = (Map)filters.get(i);
                        Map temp = createSimpleCondition(temp);
                        clause.append(temp.get("clause"));
                        if (i != filters.size() - 1) {
                            clause.append(String.format(" %s ", filter.get("logic")));
                        }
                    } else {
                        temp = createCondition(f);
                        clause.append(temp.get("clause"));
                        if (i < filters.size() - 1) {
                            clause.append(String.format(" %s ", filter.get("logic")));
                        }
                    }
                }

                clause.append(")");
            }

            data.put("clause", clause.toString());
            return data;
        }
    }

    private static Map createCondition(Map filter) {
        Map data = new HashMap();
        if (filter == null) {
            data.put("clause", "");
            return data;
        } else {
            ArrayList filters = (ArrayList)filter.get("filters");
            StringBuilder clause = new StringBuilder();
            if (filters != null) {
                clause.append("(");

                for(int i = 0; i < filters.size(); ++i) {
                    Map f = (Map)filters.get(i);
                    Map temp = createSimpleCondition(f);
                    clause.append(temp.get("clause"));
                    if (i < filters.size() - 1) {
                        clause.append(String.format(" %s ", filter.get("logic")));
                    }
                }

                clause.append(")");
            }

            data.put("clause", clause.toString());
            return data;
        }
    }

    private static Map createSimpleCondition(Map filterDesc) {
        Map data = new HashMap();
        String key = String.format("%s_%s", filterDesc.get("field"), UUID.randomUUID());
        String val = filterDesc.get("value") == null ? "" : filterDesc.get("value").toString();
        String value = "'" + val + "'";
        String op = filterDesc.get("operator") == null ? "" : filterDesc.get("operator").toString();
        if (op.equals("eq")) {
            data.put("clause", filterDesc.get("field") + " = " + value);
        } else if (op.equals("contains")) {
            data.put("clause", filterDesc.get("field") + " LIKE '%" + val + "%'");
        } else if (op.equals("doesnotcontain")) {
            data.put("clause", filterDesc.get("field") + " NOT LIKE '%" + val + "%'");
        } else if (op.equals("startswith")) {
            data.put("clause", filterDesc.get("field") + " LIKE '" + val + "%'");
        } else if (op.equals("endswith")) {
            data.put("clause", filterDesc.get("field") + " LIKE '%" + val + "'");
        } else if (op.equals("iscontainedin")) {
            data.put("clause", filterDesc.get("field") + " IN " + val);
        } else if (op.equals("gt")) {
            data.put("clause", filterDesc.get("field") + " > " + value);
        } else if (op.equals("gte")) {
            data.put("clause", filterDesc.get("field") + " >= " + value);
        } else if (op.equals("lt")) {
            data.put("clause", filterDesc.get("field") + " < " + value);
        } else if (op.equals("lte")) {
            data.put("clause", filterDesc.get("field") + " <= " + value);
        } else if (op.equals("neq")) {
            data.put("clause", filterDesc.get("field") + " != " + value);
        } else if (op.equals("in")) {
            if (filterDesc.get("value").getClass().getName() == "java.util.ArrayList") {
                ArrayList array = (ArrayList)filterDesc.get("value");
                String str = "";

                for(int i = 0; i < array.size(); ++i) {
                    if (i == array.size() - 1) {
                        str = str + "'" + array.get(i).toString() + "'";
                    } else {
                        str = str + "'" + array.get(i).toString() + "',";
                    }
                }

                data.put("clause", filterDesc.get("field") + " in (" + str + ")");
            } else if (filterDesc.get("value").getClass().getName() == "java.lang.String") {
                data.put("clause", filterDesc.get("field") + " in (" + value + ")");
            }
        } else {
            data.put("clause", filterDesc.get("field") + " = " + value);
        }

        return data;
    }

    private static Map buildParams(Map params) {
        Iterator var1 = params.entrySet().iterator();

        while(true) {
            Entry entry;
            do {
                if (!var1.hasNext()) {
                    return params;
                }

                Object item = var1.next();
                entry = (Entry)item;
            } while(!entry.getValue().getClass().isArray());

            Object[] arr = (Object[])((Object[])entry.getValue());
            String res = "";

            for(int i = 0; i < arr.length; ++i) {
                if (i < i - 1) {
                    res = res + arr[i] + ",";
                } else {
                    res = res + arr[i];
                }
            }

            params.put(entry.getKey(), res);
        }
    }
}