Mybatis 拦截器介绍
Mybatis 拦截器介绍java
1.1 目录mysql
1.2 前言sql
1.3 Interceptor接口数据库
1.4 注册拦截器apache
1.5 Mybatis可拦截的方法数组
1.6 利用拦截器进行分页session
拦截器的一个做用就是咱们能够拦截某些方法的调用，咱们能够选择在这些被拦截的方法执行先后加上某些逻辑，也能够在执行这些被拦截的方法时执行本身的逻辑而再也不执行被拦截的方法。Mybatis拦截器设计的一个初衷就是为了供用户在某些时候能够实现本身的逻辑而没必要去动Mybatis固有的逻辑。打个比方，对于Executor，Mybatis中有几种实现：BatchExecutor、ReuseExecutor、SimpleExecutor和CachingExecutor。这个时候若是你以为这几种实现对于Executor接口的query方法都不能知足你的要求，那怎么办呢？是要去改源码吗？固然不。咱们能够创建一个Mybatis拦截器用于拦截Executor接口的query方法，在拦截以后实现本身的query方法逻辑，以后能够选择是否继续执行原来的query方法。mybatis
对于拦截器Mybatis为咱们提供了一个Interceptor接口，经过实现该接口就能够定义咱们本身的拦截器。咱们先来看一下这个接口的定义：oracle
package org.apache.ibatis.plugin;
import java.util.Properties;
public interface Interceptor {
Object intercept(Invocation invocation) throws Throwable;
Object plugin(Object target);
void setProperties(Properties properties);
}
咱们能够看到在该接口中一共定义有三个方法，intercept、plugin和setProperties。plugin方法是拦截器用于封装目标对象的，经过该方法咱们能够返回目标对象自己，也能够返回一个它的代理。当返回的是代理的时候咱们能够对其中的方法进行拦截来调用intercept方法，固然也能够调用其余方法，这点将在后文讲解。setProperties方法是用于在Mybatis配置文件中指定一些属性的。app
定义本身的Interceptor最重要的是要实现plugin方法和intercept方法，在plugin方法中咱们能够决定是否要进行拦截进而决定要返回一个什么样的目标对象。而intercept方法就是要进行拦截的时候要执行的方法。
对于plugin方法而言，其实Mybatis已经为咱们提供了一个实现。Mybatis中有一个叫作Plugin的类，里面有一个静态方法wrap(Object target,Interceptor interceptor)，经过该方法能够决定要返回的对象是目标对象仍是对应的代理。这里咱们先来看一下Plugin的源码：
package org.apache.ibatis.plugin;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.apache.ibatis.reflection.ExceptionUtil;
public class Plugin implements InvocationHandler {
private Object target;
private Interceptor interceptor;
private Map<Class<?>, Set<Method>> signatureMap;
private Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) {
this.target = target;
this.interceptor = interceptor;
this.signatureMap = signatureMap;
}
public static Object wrap(Object target, Interceptor interceptor) {
Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
Class<?> type = target.getClass();
Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
if (interfaces.length > 0) {
return Proxy.newProxyInstance(
type.getClassLoader(),
interfaces,
new Plugin(target, interceptor, signatureMap));
}
return target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
Set<Method> methods = signatureMap.get(method.getDeclaringClass());
if (methods != null && methods.contains(method)) {
return interceptor.intercept(new Invocation(target, method, args));
}
return method.invoke(target, args);
} catch (Exception e) {
throw ExceptionUtil.unwrapThrowable(e);
}
}
private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
if (interceptsAnnotation == null) { // issue #251
throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());
}
Signature[] sigs = interceptsAnnotation.value();
Map<Class<?>, Set<Method>> signatureMap = new HashMap<Class<?>, Set<Method>>();
for (Signature sig : sigs) {
Set<Method> methods = signatureMap.get(sig.type());
if (methods == null) {
methods = new HashSet<Method>();
signatureMap.put(sig.type(), methods);
}
try {
Method method = sig.type().getMethod(sig.method(), sig.args());
methods.add(method);
} catch (NoSuchMethodException e) {
throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);
}
}
return signatureMap;
}
private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) {
Set<Class<?>> interfaces = new HashSet<Class<?>>();
while (type != null) {
for (Class<?> c : type.getInterfaces()) {
if (signatureMap.containsKey(c)) {
interfaces.add(c);
}
}
type = type.getSuperclass();
}
return interfaces.toArray(new Class<?>[interfaces.size()]);
}
}
咱们先看一下Plugin的wrap方法，它根据当前的Interceptor上面的注解定义哪些接口须要拦截，而后判断当前目标对象是否有实现对应须要拦截的接口，若是没有则返回目标对象自己，若是有则返回一个代理对象。而这个代理对象的InvocationHandler正是一个Plugin。因此当目标对象在执行接口方法时，若是是经过代理对象执行的，则会调用对应InvocationHandler的invoke方法，也就是Plugin的invoke方法。因此接着咱们来看一下该invoke方法的内容。这里invoke方法的逻辑是：若是当前执行的方法是定义好的须要拦截的方法，则把目标对象、要执行的方法以及方法参数封装成一个Invocation对象，再把封装好的Invocation做为参数传递给当前拦截器的intercept方法。若是不须要拦截，则直接调用当前的方法。Invocation中定义了定义了一个proceed方法，其逻辑就是调用当前方法，因此若是在intercept中须要继续调用当前方法的话能够调用invocation的procced方法。
这就是Mybatis中实现Interceptor拦截的一个思想，若是用户以为这个思想有问题或者不能彻底知足你的要求的话能够经过实现本身的Plugin来决定何时须要代理何时须要拦截。如下讲解的内容都是基于Mybatis的默认实现即经过Plugin来管理Interceptor来说解的。
对于实现本身的Interceptor而言有两个很重要的注解，一个是@Intercepts，其值是一个@Signature数组。@Intercepts用于代表当前的对象是一个Interceptor，而@Signature则代表要拦截的接口、方法以及对应的参数类型。来看一个自定义的简单Interceptor：
package com.tiantian.mybatis.interceptor;
import java.sql.Connection;
import java.util.Properties;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.MappedStatement;
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.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
@Intercepts( {
@Signature(method = "query", type = Executor.class, args = {
MappedStatement.class, Object.class, RowBounds.class,
ResultHandler.class }),
@Signature(method = "prepare", type = StatementHandler.class, args = { Connection.class }) })
public class MyInterceptor implements Interceptor {
public Object intercept(Invocation invocation) throws Throwable {
Object result = invocation.proceed();
System.out.println("Invocation.proceed()");
return result;
}
public Object plugin(Object target) {
return Plugin.wrap(target, this);
}
public void setProperties(Properties properties) {
String prop1 = properties.getProperty("prop1");
String prop2 = properties.getProperty("prop2");
System.out.println(prop1 + "------" + prop2);
}
}
首先看setProperties方法，这个方法在Configuration初始化当前的Interceptor时就会执行，这里只是简单的取两个属性进行打印。
其次看plugin方法中咱们是用的Plugin的逻辑来实现Mybatis的逻辑的。
接着看MyInterceptor类上咱们用@Intercepts标记了这是一个Interceptor，而后在@Intercepts中定义了两个@Signature，即两个拦截点。第一个@Signature咱们定义了该Interceptor将拦截Executor接口中参数类型为MappedStatement、Object、RowBounds和ResultHandler的query方法；第二个@Signature咱们定义了该Interceptor将拦截StatementHandler中参数类型为Connection的prepare方法。
最后再来看一下intercept方法，这里咱们只是简单的打印了一句话，而后调用invocation的proceed方法，使当前方法正常的调用。
对于这个拦截器，Mybatis在注册该拦截器的时候就会利用定义好的n个property做为参数调用该拦截器的setProperties方法。以后在新建可拦截对象的时候会调用该拦截器的plugin方法来决定是返回目标对象自己仍是代理对象。对于这个拦截器而言，当Mybatis是要Executor或StatementHandler对象的时候就会返回一个代理对象，其余都是原目标对象自己。而后当Executor代理对象在执行参数类型为MappedStatement、Object、RowBounds和ResultHandler的query方法或StatementHandler代理对象在执行参数类型为Connection的prepare方法时就会触发当前的拦截器的intercept方法进行拦截，而执行这两个接口对象的其余方法时都只是作一个简单的代理。
注册拦截器是经过在Mybatis配置文件中plugins元素下的plugin元素来进行的。一个plugin对应着一个拦截器，在plugin元素下面咱们能够指定若干个property子元素。Mybatis在注册定义的拦截器时会先把对应拦截器下面的全部property经过Interceptor的setProperties方法注入给对应的拦截器。因此，咱们能够这样来注册咱们在前面定义的MyInterceptor：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<properties resource="config/jdbc.properties"></properties>
<typeAliases>
<package name="com.tiantian.mybatis.model"/>
</typeAliases>
<plugins>
<plugin interceptor="com.tiantian.mybatis.interceptor.MyInterceptor">
<property name="prop1" value="prop1"/>
<property name="prop2" value="prop2"/>
</plugin>
</plugins>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="com/tiantian/mybatis/mapper/UserMapper.xml"/>
</mappers>
</configuration>
Mybatis拦截器只能拦截四种类型的接口：Executor、StatementHandler、ParameterHandler和ResultSetHandler。这是在Mybatis的Configuration中写死了的，若是要支持拦截其余接口就须要咱们重写Mybatis的Configuration。Mybatis能够对这四个接口中全部的方法进行拦截。
下面将介绍一个Mybatis拦截器的实际应用。Mybatis拦截器经常会被用来进行分页处理。咱们知道要利用JDBC对数据库进行操做就必需要有一个对应的Statement对象，Mybatis在执行Sql语句前也会产生一个包含Sql语句的Statement对象，并且对应的Sql语句是在Statement以前产生的，因此咱们就能够在它成Statement以前对用来生成Statement的Sql语句下手。在Mybatis中Statement语句是经过RoutingStatementHandler对象的prepare方法生成的。因此利用拦截器实现Mybatis分页的一个思路就是拦截StatementHandler接口的prepare方法，而后在拦截器方法中把Sql语句改为对应的分页查询Sql语句，以后再调用StatementHandler对象的prepare方法，即调用invocation.proceed()。更改Sql语句这个看起来很简单，而事实上来讲的话就没那么直观，由于包括sql等其余属性在内的多个属性都没有对应的方法能够直接取到，它们对外部都是封闭的，是对象的私有属性，因此这里就须要引入反射机制来获取或者更改对象的私有属性的值了。对于分页而言，在拦截器里面咱们经常还须要作的一个操做就是统计知足当前条件的记录一共有多少，这是经过获取到了原始的Sql语句后，把它改成对应的统计语句再利用Mybatis封装好的参数和设置参数的功能把Sql语句中的参数进行替换，以后再执行查询记录数的Sql语句进行总记录数的统计。先来看一个咱们对分页操做封装的一个实体类Page：
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 对分页的基本数据进行一个简单的封装
*/
public class Page<T> {
private int pageNo = 1;//页码，默认是第一页
private int pageSize = 15;//每页显示的记录数，默认是15
private int totalRecord;//总记录数
private int totalPage;//总页数
private List<T> results;//对应的当前页记录
private Map<String, Object> params = new HashMap<String, Object>();//其余的参数咱们把它分装成一个Map对象
public int getPageNo() {
return pageNo;
}
public void setPageNo(int pageNo) {
this.pageNo = pageNo;
}
public int getPageSize() {
return pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public int getTotalRecord() {
return totalRecord;
}
public void setTotalRecord(int totalRecord) {
this.totalRecord = totalRecord;
//在设置总页数的时候计算出对应的总页数，在下面的三目运算中加法拥有更高的优先级，因此最后能够不加括号。
int totalPage = totalRecord%pageSize==0 ? totalRecord/pageSize : totalRecord/pageSize + 1;
this.setTotalPage(totalPage);
}
public int getTotalPage() {
return totalPage;
}
public void setTotalPage(int totalPage) {
this.totalPage = totalPage;
}
public List<T> getResults() {
return results;
}
public void setResults(List<T> results) {
this.results = results;
}
public Map<String, Object> getParams() {
return params;
}
public void setParams(Map<String, Object> params) {
this.params = params;
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("Page [pageNo=").append(pageNo).append(", pageSize=")
.append(pageSize).append(", results=").append(results).append(
", totalPage=").append(totalPage).append(
", totalRecord=").append(totalRecord).append("]");
return builder.toString();
}
}
对于须要进行分页的Mapper映射，咱们会给它传一个Page对象做为参数，咱们能够看到Page对象里面包括了一些分页的基本信息，这些信息咱们能够在拦截器里面用到，而后咱们把除分页的基本信息之外的其余参数用一个Map对象进行包装，这样在Mapper映射语句中的其余参数就能够从Map中取值了。接着来看一下咱们的PageInterceptor的定义，对于PageInterceptor我就不作过多的说明，代码里面附有很详细的注释信息：
package com.tiantian.mybatis.interceptor;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Properties;
import org.apache.ibatis.executor.parameter.ParameterHandler;
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.mapping.ParameterMapping;
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.scripting.defaults.DefaultParameterHandler;
import com.tiantian.mybatis.model.Page;
/**
*
* 分页拦截器，用于拦截须要进行分页查询的操做，而后对其进行分页处理。
* 利用拦截器实现Mybatis分页的原理：
* 要利用JDBC对数据库进行操做就必需要有一个对应的Statement对象，Mybatis在执行Sql语句前就会产生一个包含Sql语句的Statement对象，并且对应的Sql语句
* 是在Statement以前产生的，因此咱们就能够在它生成Statement以前对用来生成Statement的Sql语句下手。在Mybatis中Statement语句是经过RoutingStatementHandler对象的
* prepare方法生成的。因此利用拦截器实现Mybatis分页的一个思路就是拦截StatementHandler接口的prepare方法，而后在拦截器方法中把Sql语句改为对应的分页查询Sql语句，以后再调用
* StatementHandler对象的prepare方法，即调用invocation.proceed()。
* 对于分页而言，在拦截器里面咱们还须要作的一个操做就是统计知足当前条件的记录一共有多少，这是经过获取到了原始的Sql语句后，把它改成对应的统计语句再利用Mybatis封装好的参数和设
* 置参数的功能把Sql语句中的参数进行替换，以后再执行查询记录数的Sql语句进行总记录数的统计。
*
*/
@Intercepts( {
@Signature(method = "prepare", type = StatementHandler.class, args = {Connection.class}) })
public class PageInterceptor implements Interceptor {
private String databaseType;//数据库类型，不一样的数据库有不一样的分页方法
/**
* 拦截后要执行的方法
*/
public Object intercept(Invocation invocation) throws Throwable {
//对于StatementHandler其实只有两个实现类，一个是RoutingStatementHandler，另外一个是抽象类BaseStatementHandler，
//BaseStatementHandler有三个子类，分别是SimpleStatementHandler，PreparedStatementHandler和CallableStatementHandler，
//SimpleStatementHandler是用于处理Statement的，PreparedStatementHandler是处理PreparedStatement的，而CallableStatementHandler是
//处理CallableStatement的。Mybatis在进行Sql语句处理的时候都是创建的RoutingStatementHandler，而在RoutingStatementHandler里面拥有一个
//StatementHandler类型的delegate属性，RoutingStatementHandler会依据Statement的不一样创建对应的BaseStatementHandler，即SimpleStatementHandler、
//PreparedStatementHandler或CallableStatementHandler，在RoutingStatementHandler里面全部StatementHandler接口方法的实现都是调用的delegate对应的方法。
//咱们在PageInterceptor类上已经用@Signature标记了该Interceptor只拦截StatementHandler接口的prepare方法，又由于Mybatis只有在创建RoutingStatementHandler的时候
//是经过Interceptor的plugin方法进行包裹的，因此咱们这里拦截到的目标对象确定是RoutingStatementHandler对象。
RoutingStatementHandler handler = (RoutingStatementHandler) invocation.getTarget();
//经过反射获取到当前RoutingStatementHandler对象的delegate属性
StatementHandler delegate = (StatementHandler)ReflectUtil.getFieldValue(handler, "delegate");
//获取到当前StatementHandler的 boundSql，这里不论是调用handler.getBoundSql()仍是直接调用delegate.getBoundSql()结果是同样的，由于以前已经说过了
//RoutingStatementHandler实现的全部StatementHandler接口方法里面都是调用的delegate对应的方法。
BoundSql boundSql = delegate.getBoundSql();
//拿到当前绑定Sql的参数对象，就是咱们在调用对应的Mapper映射语句时所传入的参数对象
Object obj = boundSql.getParameterObject();
//这里咱们简单的经过传入的是Page对象就认定它是须要进行分页操做的。
if (obj instanceof Page<?>) {
Page<?> page = (Page<?>) obj;
//经过反射获取delegate父类BaseStatementHandler的mappedStatement属性
MappedStatement mappedStatement = (MappedStatement)ReflectUtil.getFieldValue(delegate, "mappedStatement");
//拦截到的prepare方法参数是一个Connection对象
Connection connection = (Connection)invocation.getArgs()[0];
//获取当前要执行的Sql语句，也就是咱们直接在Mapper映射语句中写的Sql语句
String sql = boundSql.getSql();
//给当前的page参数对象设置总记录数
this.setTotalRecord(page,
mappedStatement, connection);
//获取分页Sql语句
String pageSql = this.getPageSql(page, sql);
//利用反射设置当前BoundSql对应的sql属性为咱们创建好的分页Sql语句
ReflectUtil.setFieldValue(boundSql, "sql", pageSql);
}
return invocation.proceed();
}
/**
* 拦截器对应的封装原始对象的方法
*/
public Object plugin(Object target) {
return Plugin.wrap(target, this);
}
/**
* 设置注册拦截器时设定的属性
*/
public void setProperties(Properties properties) {
this.databaseType = properties.getProperty("databaseType");
}
/**
* 根据page对象获取对应的分页查询Sql语句，这里只作了两种数据库类型，Mysql和Oracle
* 其它的数据库都 没有进行分页
*
* @param page 分页对象
* @param sql 原sql语句
* @return
*/
private String getPageSql(Page<?> page, String sql) {
StringBuffer sqlBuffer = new StringBuffer(sql);
if ("mysql".equalsIgnoreCase(databaseType)) {
return getMysqlPageSql(page, sqlBuffer);
} else if ("oracle".equalsIgnoreCase(databaseType)) {
return getOraclePageSql(page, sqlBuffer);
}
return sqlBuffer.toString();
}
/**
* 获取Mysql数据库的分页查询语句
* @param page 分页对象
* @param sqlBuffer 包含原sql语句的StringBuffer对象
* @return Mysql数据库分页语句
*/
private String getMysqlPageSql(Page<?> page, StringBuffer sqlBuffer) {
//计算第一条记录的位置，Mysql中记录的位置是从0开始的。
int offset = (page.getPageNo() - 1) * page.getPageSize();
sqlBuffer.append(" limit ").append(offset).append(",").append(page.getPageSize());
return sqlBuffer.toString();
}
/**
* 获取Oracle数据库的分页查询语句
* @param page 分页对象
* @param sqlBuffer 包含原sql语句的StringBuffer对象
* @return Oracle数据库的分页查询语句
*/
private String getOraclePageSql(Page<?> page, StringBuffer sqlBuffer) {
//计算第一条记录的位置，Oracle分页是经过rownum进行的，而rownum是从1开始的
int offset = (page.getPageNo() - 1) * page.getPageSize() + 1;
sqlBuffer.insert(0, "select u.*, rownum r from (").append(") u where rownum < ").append(offset + page.getPageSize());
sqlBuffer.insert(0, "select * from (").append(") where r >= ").append(offset);
//上面的Sql语句拼接以后大概是这个样子：
//select * from (select u.*, rownum r from (select * from t_user) u where rownum < 31) where r >= 16
return sqlBuffer.toString();
}
/**
* 给当前的参数对象page设置总记录数
*
* @param page Mapper映射语句对应的参数对象
* @param mappedStatement Mapper映射语句
* @param connection 当前的数据库链接
*/
private void setTotalRecord(Page<?> page,
MappedStatement mappedStatement, Connection connection) {
//获取对应的BoundSql，这个BoundSql其实跟咱们利用StatementHandler获取到的BoundSql是同一个对象。
//delegate里面的boundSql也是经过mappedStatement.getBoundSql(paramObj)方法获取到的。
BoundSql boundSql = mappedStatement.getBoundSql(page);
//获取到咱们本身写在Mapper映射语句中对应的Sql语句
String sql = boundSql.getSql();
//经过查询Sql语句获取到对应的计算总记录数的sql语句
String countSql = this.getCountSql(sql);
//经过BoundSql获取对应的参数映射
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
//利用Configuration、查询记录数的Sql语句countSql、参数映射关系parameterMappings和参数对象page创建查询记录数对应的BoundSql对象。
BoundSql countBoundSql = new BoundSql(mappedStatement.getConfiguration(), countSql, parameterMappings, page);
//经过mappedStatement、参数对象page和BoundSql对象countBoundSql创建一个用于设定参数的ParameterHandler对象
ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, page, countBoundSql);
//经过connection创建一个countSql对应的PreparedStatement对象。
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
pstmt = connection.prepareStatement(countSql);
//经过parameterHandler给PreparedStatement对象设置参数
parameterHandler.setParameters(pstmt);
//以后就是执行获取总记录数的Sql语句和获取结果了。
rs = pstmt.executeQuery();
if (rs.next()) {
int totalRecord = rs.getInt(1);
//给当前的参数page对象设置总记录数
page.setTotalRecord(totalRecord);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
if (rs != null)
rs.close();
if (pstmt != null)
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/**
* 根据原Sql语句获取对应的查询总记录数的Sql语句
* @param sql
* @return
*/
private String getCountSql(String sql) {
int index = sql.indexOf("from");
return "select count(*) " + sql.substring(index);
}
/**
* 利用反射进行操做的一个工具类
*
*/
private static class ReflectUtil {
/**
* 利用反射获取指定对象的指定属性
* @param obj 目标对象
* @param fieldName 目标属性
* @return 目标属性的值
*/
public static Object getFieldValue(Object obj, String fieldName) {
Object result = null;
Field field = ReflectUtil.getField(obj, fieldName);
if (field != null) {
field.setAccessible(true);
try {
result = field.get(obj);
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return result;
}
/**
* 利用反射获取指定对象里面的指定属性
* @param obj 目标对象
* @param fieldName 目标属性
* @return 目标字段
*/
private static Field getField(Object obj, String fieldName) {
Field field = null;
for (Class<?> clazz=obj.getClass(); clazz != Object.class; clazz=clazz.getSuperclass()) {
try {
field = clazz.getDeclaredField(fieldName);
break;
} catch (NoSuchFieldException e) {
//这里不用作处理，子类没有该字段可能对应的父类有，都没有就返回null。
}
}
return field;
}
/**
* 利用反射设置指定对象的指定属性为指定的值
* @param obj 目标对象
* @param fieldName 目标属性
* @param fieldValue 目标值
*/
public static void setFieldValue(Object obj, String fieldName,
String fieldValue) {
Field field = ReflectUtil.getField(obj, fieldName);
if (field != null) {
try {
field.setAccessible(true);
field.set(obj, fieldValue);
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
接着咱们在Mybatis的配置文件里面注册该拦截器：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<properties resource="config/jdbc.properties"></properties>
<typeAliases>
<package name="com.tiantian.mybatis.model"/>
</typeAliases>
<plugins>
<plugin interceptor="com.tiantian.mybatis.interceptor.PageInterceptor">
<property name="databaseType" value="Oracle"/>
</plugin>
</plugins>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="com/tiantian/mybatis/mapper/UserMapper.xml"/>
</mappers>
这样咱们的拦截器就已经定义而且配置好了，接下来咱们就来测试一下。假设在咱们的UserMapper.xml中有以下这样一个Mapper映射信息：
<select id="findPage" resultType="User" parameterType="page"> select * from t_user </select>
那咱们就能够这样来测试它：
SqlSession sqlSession = sqlSessionFactory.openSession();
try {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
Page<User> page = new Page<User>();
page.setPageNo(2);
List<User> users = userMapper.findPage(page);
page.setResults(users);
System.out.println(page);
} finally {
sqlSession.close();
}
相关文章
- 1. SpringMvc 拦截器介绍
- 2. Struts2拦截器介绍
- 3. vue axios拦截器介绍
- 4. Mybatis拦截器
- 5. MyBatis 拦截器（3）
- 6. Mybatis Interceptor 拦截器
- 7. MyBatis 拦截器（4）
- 8. mybatis 拦截器拦截全部sql
- 9. MyBatis拦截器原理探究MyBatis拦截器原理探究
- 10. Mybatis拦截器介绍及分页插件
- 更多相关文章...
- • 网站主机 介绍 - 网站主机教程
- • MySQL触发器简介 - MySQL教程
- • Java Agent入门实战（一）-Instrumentation介绍与使用
- • Docker容器实战(七) - 容器眼光下的文件系统
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. CVPR 2020 论文大盘点-光流篇
- 2. Photoshop教程_ps中怎么载入图案？PS图案如何导入？
- 3. org.pentaho.di.core.exception.KettleDatabaseException:Error occurred while trying to connect to the
- 4. SonarQube Scanner execution execution Error --- Failed to upload report - 500: An error has occurred
- 5. idea 导入源码包
- 6. python学习 day2——基础学习
- 7. 3D将是页游市场新赛道？
- 8. osg--交互
- 9. OSG-交互
- 10. Idea、spring boot 图片(pgn显示、jpg不显示)解决方案
欢迎关注本站公众号,获取更多信息
相关文章