公告

Mybatis使用动态代理实现拦截器功能

正文前先来一波福利推荐：

福利一：

百万年薪架构师视频，该视频可以学到很多东西，是本人花钱买的VIP课程，学习消化了一年，为了支持一下女朋友公众号也方便大家学习，共享给大家。

福利二：

毕业答辩以及工作上各种答辩，平时积累了不少精品PPT，现在共享给大家，大大小小加起来有几千套，总有适合你的一款，很多是网上是下载不到。

获取方式：

微信关注精品3分钟，id为 jingpin3mins，关注后回复 百万年薪架构师 ，精品收藏PPT 获取云盘链接，谢谢大家支持！

-----------------------正文开始---------------------------

1、背景介绍

　　拦截器顾名思义为拦截某个功能的一个武器，在众多框架中均有“拦截器”。这个Plugin有什么用呢？或者说拦截器有什么用呢？可以想想拦截器是怎么实现的。Plugin用到了Java中很重要的一个特性——动态代理。所以这个Plugin可以理解为，在调用一个方法时，我“拦截”其方法做一些我想让它做的事（包括方法的前与后）。在Mybatis中可以拦截以下方法：

这正是mybatis中大名鼎鼎的四大对象；

2、源码过程跟踪，了解拦截器拦截过程以及原理

 1 //ParameterHandler 处理sql的参数对象
 2 public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
 3     ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
 4     //包装参数插件
 5     parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
 6     return parameterHandler;
 7 }
 8 
 9 //ResultSetHandler 处理sql的返回结果集
10 public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
11                                             ResultHandler resultHandler, BoundSql boundSql) {
12     ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
13     //包装返回结果插件
14     resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
15     return resultSetHandler;
16 }
17 
18 //StatementHandler 数据库的处理对象
19 public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
20     StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
21     //包装数据库执行sql插件
22     statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
23     return statementHandler;
24 }
25 
26 public Executor newExecutor(Transaction transaction) {
27     //创建Mybatis的执行器：Executor
28     return newExecutor(transaction, defaultExecutorType);
29 }
30 
31 public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
32     executorType = executorType == null ? defaultExecutorType : executorType;
33     executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
34     Executor executor;
35     //mybatis支持的三种执行器：batch、reuse、simple，其中默认支持的是simple
36     if (ExecutorType.BATCH == executorType) {
37         executor = new BatchExecutor(this, transaction);
38     } else if (ExecutorType.REUSE == executorType) {
39         executor = new ReuseExecutor(this, transaction);
40     } else {
　　　　　　　//默认为SimpleExecutor
41         executor = new SimpleExecutor(this, transaction);
42     }
　　　　　　//如果开启二级缓存  则对executor进行缓存包装
43     if (cacheEnabled) {
44         executor = new CachingExecutor(executor);
45     }
46     //包装执行器插件
47     executor = (Executor) interceptorChain.pluginAll(executor);
48     return executor;
49 }

　　我们可以看到这四大对象在创建的过程中都调用了 (Executor) interceptorChain.pluginAll(Object target) 代码，该代码是怎么样的呢正是我们所说的拦截器链，将四大对象传入到拦截器链进行处理然后返回包装后的四大对象如果我们在拦截器链中进行拦截处理则实现了拦截技术；

下面我们看连接器链中的内容：

public class InterceptorChain {

  private final List<Interceptor> interceptors = new ArrayList<Interceptor>();

  //在pluginAll方法中 遍历拦截器集 将传入的target 也就是四大对象进行传入 在interceptor中的Plugin方法中处理
  public Object pluginAll(Object target) {
    for (Interceptor interceptor : interceptors) {
      target = interceptor.plugin(target);
    }
    return target;
  }

  public void addInterceptor(Interceptor interceptor) {
    interceptors.add(interceptor);
  }

  public List<Interceptor> getInterceptors() {
    return Collections.unmodifiableList(interceptors);
  }

}

下面我们看一下interceptor对象的源代码：

public interface Interceptor {

  Object intercept(Invocation invocation) throws Throwable;

  Object plugin(Object target);

  void setProperties(Properties properties);

}

从源代码看出 interceptor是一个接口接口中有三个方法分别是 intercept plugin 和 setProperties；下面分别介绍着几个方法；

我们自己写插件或者拦截四大对象后进行相应功能的添加就在要实现该接口，然后实现接口的三个方法；

举例实现该接口：

注意： 记住必须使用注解的方式实现声明拦截器拦截哪个类对象原因在后面源码中进行分析


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

    /* 此方法用于实现拦截逻辑
     * @see org.apache.ibatis.plugin.Interceptor#intercept(org.apache.ibatis.plugin.Invocation)
     */
    @Override
　　 public Object intercept(Invocation invocation) throws Throwable
　　 {

　　　　　　doSomeThing();
　　　　　　/* 注：此处实际上使用Invocation.proceed()方法完成interceptorChain链的遍历调用(即执行所有注册的Interceptor的intercept方法)，到最终被代理对象的原始方法调用 */
　　　　　　return invocation.proceed();
　　　　}

/* 使用当前的这个拦截器实现对目标对象的代理（内部实现时Java的动态代理）
     * @see org.apache.ibatis.plugin.Interceptor#plugin(java.lang.Object)
     */

　　 @Override
　　 public Object plugin(Object target)

　　 {

　　　　/* 当目标类是StatementHandler类型时，才包装目标类，不做无意义的代理 */
　　　　return (target instanceof StatementHandler)?Plugin.wrap(target, this):target;
　　 }

/* 初始化Configuration时通过配置文件配置property传递参数给此方法并调用。
     * @see org.apache.ibatis.plugin.Interceptor#setProperties(java.util.Properties)
     */
    @Override
    public void setProperties(Properties properties) {　　
        Iterator iterator = properties.keySet().iterator();
        while (iterator.hasNext()){
            String keyValue = String.valueOf(iterator.next());
            System.out.println(properties.getProperty(keyValue));
        }
    }

}

我们看点在plugin方法中通过Plugin.wrap创建了代理对象我们来看源代码：看到了Plugin 类实现了 InvocationHandler 是不是感觉很熟悉这就是我们上篇文章中讲过的动态代理中的 invocationHandel类

前面说了为什么自己实现拦截器类时为什么必须使用注解的方式因为在获得数字签名Map的方法中存在使用反射获得注解信息的方法

//获得Interceptor注解，@Signature中的type(要拦截的类),method(拦截类的方法)和args(拦截器用于这些类中)

Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);

所以如果没有添加注解方式则会抛出 throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName())

然后我们看一下wrap方法该方法就是通过数据签名然后看数字签名中的是否包含要拦截对象和方法如果包含则创建代理对象返回代理对象

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; //此处的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) {
      //生成代理对象，Plugin对象为该代理对象的InvocationHandler
      return Proxy.newProxyInstance(type.getClassLoader(), interfaces, new Plugin(target, interceptor, signatureMap));
    }
    return target;
  }
 
  @Override
  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)) {
        //调用代理类所属拦截器的intercept方法
        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) {
    //获得Interceptor注解，@Signature中的type(要拦截的类),method(拦截类的方法)和args(拦截器用于这些类中)
    Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
    // issue #251
    if (interceptsAnnotation == null) {
      throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());      
    }
    //获得注解type,method 和args生成一个signature数组
    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()]);
  }
 
}

到这里代理对象以及中间对象invocationHandler对象已经创建完成现在我们看一下被代理对象被代理对象就是 statementHandler 该接口的子类这类的是

SimpleStatementHandler

由此可以看到该类实现了 statementHandler接口的方法。

通过看这里的源码也可以看出其实mysql的底层其实也是使用了底层的jdbc来实现的！

public abstract class BaseStatementHandler implements StatementHandler {
 
  protected final Configuration configuration;
  protected final ObjectFactory objectFactory;
  protected final TypeHandlerRegistry typeHandlerRegistry;
  protected final ResultSetHandler resultSetHandler;
  protected final ParameterHandler parameterHandler;
 
  protected final Executor executor;
  protected final MappedStatement mappedStatement;
  protected final RowBounds rowBounds;
 
  protected BoundSql boundSql;
 
  protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    this.configuration = mappedStatement.getConfiguration();
    this.executor = executor;
    this.mappedStatement = mappedStatement;
    this.rowBounds = rowBounds;
 
    this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
    this.objectFactory = configuration.getObjectFactory();
 
    if (boundSql == null) { // issue #435, get the key before calculating the statement
      generateKeys(parameterObject);
      boundSql = mappedStatement.getBoundSql(parameterObject);
    }
 
    this.boundSql = boundSql;
 
    this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
    this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
  }
  //获取BoundSql
  public BoundSql getBoundSql() {
    return boundSql;
  }
  //获取ParameterHandler
  public ParameterHandler getParameterHandler() {
    return parameterHandler;
  }
 
  //准备语句
  public Statement prepare(Connection connection) throws SQLException {
    ErrorContext.instance().sql(boundSql.getSql());
    Statement statement = null;
    try {
      //实例化Statement
      statement = instantiateStatement(connection);
      //设置超时
      setStatementTimeout(statement);
      //设置读取条数
      setFetchSize(statement);
      return statement;
    } catch (SQLException e) {
      closeStatement(statement);
      throw e;
    } catch (Exception e) {
      closeStatement(statement);
      throw new ExecutorException("Error preparing statement.  Cause: " + e, e);
    }
  }
  //如何实例化Statement，交给子类去做
  protected abstract Statement instantiateStatement(Connection connection) throws SQLException;
 
  //设置超时，实际就是调用Statement.setQueryTimeout
  protected void setStatementTimeout(Statement stmt) throws SQLException {
    Integer timeout = mappedStatement.getTimeout();
    Integer defaultTimeout = configuration.getDefaultStatementTimeout();
    if (timeout != null) {
      stmt.setQueryTimeout(timeout);
    } else if (defaultTimeout != null) {
      stmt.setQueryTimeout(defaultTimeout);
    }
  }
  //设置读取条数，其实就是调用Statement.setFetchSize
  protected void setFetchSize(Statement stmt) throws SQLException {
    Integer fetchSize = mappedStatement.getFetchSize();
    if (fetchSize != null) {
      stmt.setFetchSize(fetchSize);
    }
  }
  //关闭Statement
  protected void closeStatement(Statement statement) {
    try {
      if (statement != null) {
        statement.close();
      }
    } catch (SQLException e) {
      //ignore
    }
  }
    
  protected void generateKeys(Object parameter) {
    KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
    ErrorContext.instance().store();
    keyGenerator.processBefore(executor, mappedStatement, null, parameter);
    ErrorContext.instance().recall();
  }
 
}

public class SimpleStatementHandler extends BaseStatementHandler {  
  
  public SimpleStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {  
    super(executor, mappedStatement, parameter, rowBounds, resultHandler, boundSql);  
  }  
  
  @Override  
  public int update(Statement statement) throws SQLException {  
    String sql = boundSql.getSql();  
    Object parameterObject = boundSql.getParameterObject();  
    KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();  
    int rows;  
    if (keyGenerator instanceof Jdbc3KeyGenerator) {  
      statement.execute(sql, Statement.RETURN_GENERATED_KEYS);  
      rows = statement.getUpdateCount();  
      keyGenerator.processAfter(executor, mappedStatement, statement, parameterObject);  
    } else if (keyGenerator instanceof SelectKeyGenerator) {  
      statement.execute(sql);  
      rows = statement.getUpdateCount();  
      keyGenerator.processAfter(executor, mappedStatement, statement, parameterObject);  
    } else {  
      statement.execute(sql);  
      rows = statement.getUpdateCount();  
    }  
    return rows;  
  }  
  
  @Override  
  public void batch(Statement statement) throws SQLException {  
    String sql = boundSql.getSql();  
    statement.addBatch(sql);  
  }  
  
  @Override  
  public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {  
    String sql = boundSql.getSql();  
    statement.execute(sql);  
    return resultSetHandler.<E>handleResultSets(statement);  
  }  
  
  @Override  
  protected Statement instantiateStatement(Connection connection) throws SQLException {  
    if (mappedStatement.getResultSetType() != null) {  
      return connection.createStatement(mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);  
    } else {  
      return connection.createStatement();  
    }  
  }  
  
  @Override  
  public void parameterize(Statement statement) throws SQLException {  
    // N/A  
  }  
  
}

posted on 2018-07-25 18:04 小勇DW3 阅读(3212) 评论(0) 编辑收藏举报

刷新页面返回顶部