分页插件PagePlugin
/*
*分页插件
*/
@Intercepts({@Signature(type=StatementHandler.class,method="prepare",args={Connection.class})})
public class PagePlugin implements Interceptor {
//数据库方言
private static String dialect = "";
//mapper.xml中需要拦截的ID（正则匹配）
private static String pageSqlId = "";
public Object intercept(Invocation ivk) throws Throwable {
if (ivk.getTarget() instanceof RoutingStatementHandler) {
RoutingStatementHandler statementHandler = (RoutingStatementHandler) ivk.getTarget();
BaseStatementHandler delegate = (BaseStatementHandler) ReflectHelper.getValueByFiledName(statementHandler,"delegate");
MappedStatement mappedStatement = (MappedStatement) ReflectHelper.getValueByFieldName(delegate,"mappedStatement");
//拦截需要分页的sql
if (mappedStatement.getId().matches(pageSqlId)) {
BoundSql boundSql = delegate.getBoundSql();
String sql = boundSql.getSql();
//分页sql
Object parameterObject = boundSql.getParameterObject();
if (parameterObject == null) {
throw new NullPointerException("parameterObject尚未实例化！");
} else {
Page page = null;
Field pageField = null;
int count = 0;
//参数就是Page实体
if (parameterObject instanceof Page) {
page = (Page) parameterObject;
} else {
//参数为其他某个实体，该实体拥有page属性
pageField = ReflectHelper.getFieldByFieldName(parameterObject,"page");
if (pageField != null) {
page = (Page) ReflectHelper.getValueByFieldName(parameterObject,"page");
if (page == null) {
page = new Page();
}
}
}
if (page != null && page.getIsPage()) {
Connection connection = (Connection) ivk.getArgs()[0];
//记录统计
String countSql = "select count(0) from (" + sql + ") tmp_count";
PreparedStatement countStmt = connection.prepareStatement(countSql);
BountSql countBs = new BountSql(mappedStatement.getConfiguration(),countSql,boundSql.getParameterMappings(),parameterObject);
setParameters(countStmt,mappedStatement,countBs,parameterObject);
ResultSet rs = countStmt.executeQuery();
if (rs.next()) {
//根据拼接的sql获得分页信息总数
count = rs.getInt(1);
}
rs.close();
countStmt.close();
}
if (parameterObject instanceof Page) {
page = (Page) parameterObject;
page.setTotal(count);
} else {
if (pageField != null) {
page = (Page) ReflectHelper.getValueByFieldName(parameterObject,"page");
if (page == null)
page = new Page();
page.setTotal(count);
//通过反射，对实体对象设置分页对象
ReflectHelper.setValueByFieldName(parameterObject,"page",page);
} else {
throw new NoSuchFieldException(parameterObject.getClass().getName() + "不存在page属性";
}
}
//添加排序
if (page.getSorter() != null && !"".equalsIgnoreCase(page.getSorter().trim()))
sql += " order by " + page.getSorter();
String pageSql = sql;
if (page.getIsPage())
pageSql = generatePageSql(sql,page.getPageIndex(),page.getPageSize());
//将分页sql语句反射回BoundSql
ReflectHelper.setValueByFieldName(bountSql,"sql",pageSql);
}
}
}
return ivk.proceed();
}
/*
*对sql中的参数进行设值
*
*/
private void setParameters(PreparedStatement ps,MappedStatement mappedStatement,BoundSql boundSql,Object parameterObject) throws SQLException {
//？？？
ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
//获得sql中参数的映射集合
List parameterMappings = boundSql.getParameterMapping();
if (parameterMappings != null) {
//如果集合不为空，意思就是sql中有参数需要处理
//得到mybatis配置信息管理器（管理mybatis所有的配置信息）
Configuration configuration = mappedStatement.getConfiguration();
//通过配置信息管理器获得一个TypeHandler注册器，有关TypeHandler看下面备注
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类，对参数进行注入
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);
}
//得到一个类型处理器
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());
}
}
}
}
/*
*根据sql、页码、每页显示的记录数，生成分页sql
*/
private String generatePageSql(String sql,int pageNumber,int pageSize) {
//根据不同数据库计算各自的起始行号
int begin = getBegin(pageNumber,pageSize);
if ("oracle".equals(dialect)) {
int end = begin + pageSize - 1;
return "select * from (\n" +
"select t.*,rownum rn from (" + sql + ") t\n" +
"where rownum <= " + end + ") where rn >=" + begin;
} else if ("mysql".equals(dialect)) {
return "select * from (" + sql + " limit " + begin + "," + pageSize + ") t";
} else {
return sql;
}
}
/*
*获取开始游标
*/
private static int getBegin(int pageNumber,int pageSize) {
if ("oracle".equals(dialect)) {
return (pageNumber - 1) * pageSize + 1;
} else if ("mysql".equals(dialect)) {
return (pageNumber - 1) * pageSize;
}
return 0;
}
public Object plugin(Object arg0) {
return Plugun.wrap(arg0,this);
}
/*
*读取配置文件，获得相关属性：方言、拦截的ID
*/
public void setProperties(Properties p) {
dialect = p.getProperty("dialect");
if (StringUtil.isEmpty(dialect)) {
try {
throw new PropertyException("dialect property is not found!");
} catch (PropertyException e) {
e.printStackTrace();
}
}
pageSqlId = p.getProperty("pageSqlId");
if (StringUtil.isEmpty(pageSqlId)) {
try {
throw new PropertyException("pageSqlId property is not found!");
} catch (PrppertyException e) {
e.printStackTrace();
}
}
}
} 该插件使用的是spring的动态拦截器机制，详情请参考：
http://blog.csdn.net/fangdengfu123/article/details/69542464
关于代码中ReflectHelper类，为反射帮助类，详情见：
http://blog.csdn.net/fangdengfu123/article/details/69564664
BoundSql：该对象只是一个简单的对象，该对象中有两个比较重要的属性
sql：从解析时可以看出这个sql不是配置文件中的sql,这个sql已经经过了处理(如:占用位符的处理、动态语句的解析if、foreach等待)
parameterMappings：sql对应的参数列表
详情参考：http://blog.csdn.net/ashan_li/article/details/50370035
MappedStatement：
一个MappedStatement对象对应Mapper配置文件中的一个select/update/insert/delete节点，主要描述的是一条SQL语句。
详情参考：http://blog.csdn.net/ashan_li/article/details/50351080
MetaObject：MetaObject类相当于一个工具类，Mybatis在sql参数设置和结果集映射里经常使用到这个对象。
详情参考：http://blog.csdn.net/ashan_li/article/details/50375466
Configuration ：Configuration就像是Mybatis的总管，Mybatis的所有配置信息都存放在这里，此外，它还提供了设置这些配置信息的方法。Configuration可以从配置文件里获取属性值，也可以通过程序直接设置。
详情参考：http://blog.csdn.net/hupanfeng/article/details/9080545/
TypeHandlerRegistry ： TypeHandler注册器，用于管理TypeHandler，并生成该对象。
TypeHandler ： 无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时，都会用类型处理器将获取的值以合适的方式转换成 Java 类型。Mybatis默认为我们实现了许多TypeHandler, 当我们没有配置指定TypeHandler时，Mybatis会根据参数或者返回结果的不同，默认为我们选择合适的TypeHandler处理。
详情参考：http://www.cnblogs.com/dongying/p/4040435.html
MetaObject：MetaObject类相当于一个工具类，Mybatis在sql参数设置和结果集映射里经常使用到这个对象。
详情参考：http://blog.csdn.net/ashan_li/article/details/50375466
PropertyTokenizer：这个类是property包中的重量级类，该类会被reflection包中其他的类频繁的引用到。这个类实现了Iterable和Iterator这两个接口，但在使用时经常被用到的是Iterator接口中的hasNext这个函数。
详情参考：http://www.cnblogs.com/sunzhenchao/p/3328053.html