Spring Mybatis-分頁插件使用

Mybatis分頁切入點

Mybatis內部有個plugins(插件)概念，本質上屬於攔截器的思想。具體的解析可見他文MyBatis攔截器原理探究。本文將在此基礎上直接展示實際項目的實現代碼和其他的相關解析

分頁具體代碼實現

首先我們可以定義方言抽象類，用於實現分頁AbstractDialect.java

public abstract class AbstractDialect{
    /**
     * 是否支持limit和偏移量
     * @return
     */
    public abstract boolean supportsLimitOffset();

    /**
     * 是否支持limit
     * @return
     */
    public abstract boolean supportsLimit();

    /**
     * 獲取增加了分頁屬性之后的SQL
     * @param sql
     * @param offset
     * @param limit
     * @return
     */
    public abstract String getLimitString(String sql, int offset, int limit);
}

再而我們就以Oracle與Mysql數據庫的分頁技術作下分別的實現

---

MySQLDialect.java-Mysql分頁方言

public class MySQLDialect extends AbstractDialect {

    public boolean supportsLimitOffset() {
        return true;
    }

    public boolean supportsLimit() {
        return true;
    }

    public String getLimitString(String sql, int offset, int limit) {
        if (offset > 0) {
            return sql + " limit " + offset + "," + limit;
        } else {
            return sql + " limit " + limit;
        }
    }

}

OracleDialect.java-Oracle方言實現

public class OracleDialect extends ADialect{
    @Override
    public boolean supportsLimitOffset() {
        return false;
    }

    @Override
    public boolean supportsLimit() {
        return false;
    }

    @Override
    public String getLimitString(String sql, int start, int limit) {
        if(start < 0){
            start = 0;
        }
        if(limit < 0){
            limit = 10;
        }
        StringBuilder pageSql = new StringBuilder(100);
        pageSql.append("select * from ( select temp.*, rownum row_id from ( ");
        pageSql.append(sql);
        pageSql.append(" ) temp where rownum <= ").append(start+limit);
        pageSql.append(") where row_id > ").append(start);
        return pageSql.toString();
    }
}

---

對應的Mybatis插件攔截器實現如下，攔截StatementHandler#prepare(Connection con)創建SQL語句對象方法

PaginationInterceptor.java

@Intercepts({ @Signature(type = StatementHandler.class, method = "prepare", args = { Connection.class }) })
public final class PaginationInterceptor implements Interceptor {

    private final static Logger log = LoggerFactory
        .getLogger(PaginationInterceptor.class);

    private ADialect dialect;

    public void setDialect(ADialect dialect) {
        this.dialect = dialect;
    }

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
		// 直接獲取攔截的對象，其實現類RoutingStatementHandler
        StatementHandler statementHandler = (StatementHandler) invocation
            .getTarget();
		
		// 獲取元對象，主要用於獲取statementHandler所關聯的對象及屬性
        MetaObject metaStatementHandler = MetaObject.forObject(
            statementHandler, new DefaultObjectFactory(),
            new DefaultObjectWrapperFactory());

        MappedStatement mappedStmt= (MappedStatement) metaStatementHandler
            .getValue("delegate.mappedStatement".intern());
	   // 只對queryPagination()方法進行分頁操作
	   if(mappedStmt.getId().indexOf("queryPagination")==-1){
			return invocation.proceed();
		}
        
		// 重新構造分頁的sql
        String originalSql = (String) metaStatementHandler
            .getValue("delegate.boundSql.sql".intern());
        
        // 注意RowBounds是必須被提前指定的，用於分頁語句的拼裝
        RowBounds rowBounds = metaStatementHandler.getValue("delegate.rowBounds") ;

        metaStatementHandler.setValue("delegate.boundSql.sql".intern(), dialect
            .getLimitString(originalSql, rowBounds.getOffset(),
                rowBounds.getLimit()));

        metaStatementHandler.setValue("delegate.rowBounds.offset".intern(),
            RowBounds.NO_ROW_OFFSET);

        metaStatementHandler.setValue("delegate.rowBounds.limit".intern(),
            RowBounds.NO_ROW_LIMIT);

        log.debug("page sql : " + boundSql.getSql());

        return invocation.proceed();

    }

    // 攔截對象
    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);

    }

    @Override
    public void setProperties(Properties properties) {

    }

}

---

Spring對應的xml配置可如下，以oracle分頁為例子

	<!-- oracle方言配置，用於oracle的分頁 -->
	<bean id="paginationInterceptor"		class="com.hsnet.winner.cas.admin.core.dao.mybatis.interceptor.PaginationInterceptor">
		<property name="dialect">
			<bean class="cn.cloud.winner.oss.manager.mybatis.page.OracleDialect" />
		</property>
	</bean>
	
	<!--sqlSessionFactoryBean配置plugins插件用於攔截-->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="mapperLocations" value="classpath*:mybatis/*DAO.xml" />
		<property name="plugins">
			<array>
				<ref bean="paginationInterceptor" />
			</array>
		</property>
	</bean>

使用以上的代碼以及配置即可完成對oracle數據庫以及mysql數據庫的分頁操作。並且博主對其中的某個點作下解析

Mybatis#MetaObject-元數據對象解析

以上的代碼博主之前在使用的時候，對其中的MetaObject這個類很費解，其直接通過getValue()方法便可以將所代理的對象的所關聯的屬性全都拿取到。我們可以跟隨源碼深入了解下

MetaObject#forObject()

代理對象均通過此靜態方法進入

public static MetaObject forObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory) {
    if (object == null) {
      return SystemMetaObject.NULL_META_OBJECT;
    } else {
      return new MetaObject(object, objectFactory, objectWrapperFactory);
    }
  }

我們可以直接觀察其中的構造函數，玄機就在此處

private MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory) {
    this.originalObject = object;
    this.objectFactory = objectFactory;
    this.objectWrapperFactory = objectWrapperFactory;
    // 所有的屬性獲取均通過objectWrapper類來獲取，此處主要對所代理的object對象類型進行判斷
    if (object instanceof ObjectWrapper) {
      this.objectWrapper = (ObjectWrapper) object;
    } else if (objectWrapperFactory.hasWrapperFor(object)) {
      this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object);
    } else if (object instanceof Map) {
      this.objectWrapper = new MapWrapper(this, (Map) object);
    } else if (object instanceof Collection) {
      this.objectWrapper = new CollectionWrapper(this, (Collection) object);
    } else {
      // 我們常用的便是BeanWrapper
      this.objectWrapper = new BeanWrapper(this, object);
    }
  }

為了理解的更為滲透，我們繼續跟進，最后我們得知其會調用Reflector類的構造函數

private Reflector(Class<?> clazz) {
    type = clazz;
    // 獲取構造類
    addDefaultConstructor(clazz);
    // 獲取get方法集合
    addGetMethods(clazz);
    // 獲取set方法集合
    addSetMethods(clazz);
    // 獲取內部屬性集合
    addFields(clazz);
    readablePropertyNames = getMethods.keySet().toArray(new String[getMethods.keySet().size()]);
    writeablePropertyNames = setMethods.keySet().toArray(new String[setMethods.keySet().size()]);
    for (String propName : readablePropertyNames) {
      caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
    }
    for (String propName : writeablePropertyNames) {
      caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
    }
  }

由此我們便可知使用Reflector代理類以及MetaObject便可以遍歷代理被代理類的所關聯的所有屬性，就拿RoutingStatementHandler類來說，經過上述操作后其便可以訪問內部屬性delegate以及delegate的內部屬性configuration/objectFactory/typeHandlerRegistry/resultSetHandler/parameterHandler/mappedStatement等屬性

MetaObject#getValue()

上述闡述的是如何代理被代理類的內部屬性，我們也簡單的看下是如何正確的調用

public Object getValue(String name) {
	// PropertyTokenizer與StringTokenizer類似，只是前者寫死以.為分隔符
    PropertyTokenizer prop = new PropertyTokenizer(name);
    if (prop.hasNext()) {
      MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
      if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
        return null;
      } else {
        return metaValue.getValue(prop.getChildren());
      }
    } else {
      return objectWrapper.get(prop);
    }
  }

具體的解析就不在此闡述了，如何用戶想獲取StatementHandler所擁有的sql字符串，可通過getValue("delegate.boundSql.sql")其中以.為分隔符並其中的屬性必須是內部屬性(區分大小寫)。

MetaObject#setValue()

原理同MetaObject#getValue()方法

總結

結合實例以及源碼幫助大家更透徹的了解Mybatis是如何進行分頁操作的，歡迎指正