Mybatis中的设计模式

最近在看《通用源码阅读指导书：Mybatis源码详解》，这本书一一介绍了Mybatis中的各个包的功能，同时也涉及讲了一些阅读源码的技巧，还讲了一些源码中涉及的设计模式，这是本篇文章介绍的内容

在多说一点这本书，Mybatis是大部分Java开发者都熟悉的一个框架，通过这本书去学习如何阅读源码非常合适，引用书中的一句话：”通过功能猜测源码要比通过源码猜测功能简单得多“，所以在熟悉这个框架的情况下更容易阅读它的源码，通过这本书，可以看到Mybatis是如何使用反射、代理、异常、插件、缓存、配置、注解、设计模式等

1. 装饰器模式

通常的使用场景是在一个核心基本类的基础上，提供大量的装饰类，从而使核心基本类经过不同的装饰类修饰后获得不同的功能。

1.1 例子

装饰器最经典的例子还是JDK本身的InputStream相关类, InputStream通过不断被装饰，提供的功能越来越多

InputStream in = new FileInputStream("/user/wangzheng/test.txt");
InputStream bin = new BufferedInputStream(in);
byte[] data = new byte[128];
while (bin.read(data) != -1) {
  //...
}

1.2 Mybatis实例

Mybatis的缓存功能大家应该都清楚，分为一级缓存和二级缓存，但讲到缓存，可能就要涉及到缓存大小、过期、是不是阻塞等这些操作，我们可以设计一个功能大而全的类，挑选自己想要的功能就行。但Mybatis不是这样设计的，它设计了多个装饰类，每个类负责一个功能，然后可以按需使用，分别维护。

这些装饰类如下：

• BlockingCache，阻塞缓存，当根据key获取不到value时，会阻塞等待
• FifoCache，先进先出缓存，会根据指定的大小淘汰缓存，按照FIFO的方式
• LoggingCache，日志缓存，会记录缓存的使用情况，命中率等
• LruCache，最近最少使用缓存，根据指定的大小淘汰缓存，按照LRU的方式
• ScheduledCache，定时清理缓存
• SerializedCache，序列化缓存，防止被取出来的value被修改
• SoftCache，软引用缓存
• SynchronizedCache，同步缓存，防止并发问题
• TransactionalCache，事务缓存，在事务中查询语句要放到事务结束后执行，不如会读取事务中的一些脏数据
• WeakCache，弱引用缓存

PerpetualCache是一个基础的缓存，其实就是一个HashMap

public class PerpetualCache implements Cache {

  // Cache的id，一般为所在的namespace
  private final String id;
  // 用来存储要缓存的信息
  private Map<Object, Object> cache = new HashMap<>();

  public PerpetualCache(String id) {
    this.id = id;
  }
  ...
}

LruCache是一个装饰器缓存，用来装饰传进来的缓存，可以是被装饰过的或者PerpetualCache

public class LruCache implements Cache {

  // 被装饰对象
  private final Cache delegate;
  // 使用LinkedHashMap保存的缓存数据的键
  private Map<Object, Object> keyMap;
  // 最近最少使用的数据的键
  private Object eldestKey;

  /**
   * LruCache构造方法
   * @param delegate 被装饰对象
   */
  public LruCache(Cache delegate) {
    this.delegate = delegate;
    setSize(1024);
  }
  ...
}

在使用阶段，Mybatis根据配置，一层层的给cache进行装饰

  private Cache setStandardDecorators(Cache cache) {
    try {
      MetaObject metaCache = SystemMetaObject.forObject(cache);
      // 设置缓存大小
      if (size != null && metaCache.hasSetter("size")) {
        metaCache.setValue("size", size);
      }
      // 如果定义了清理间隔，则使用定时清理装饰器装饰缓存
      if (clearInterval != null) {
        cache = new ScheduledCache(cache);
        ((ScheduledCache) cache).setClearInterval(clearInterval);
      }
      // 如果允许读写，则使用序列化装饰器装饰缓存
      if (readWrite) {
        cache = new SerializedCache(cache);
      }
      // 使用日志装饰器装饰缓存
      cache = new LoggingCache(cache);
      // 使用同步装饰器装饰缓存
      cache = new SynchronizedCache(cache);
      // 如果启用了阻塞功能，则使用阻塞装饰器装饰缓存
      if (blocking) {
        cache = new BlockingCache(cache);
      }
      // 返回被层层装饰的缓存
      return cache;
    } catch (Exception e) {
      throw new CacheException("Error building standard cache decorators.  Cause: " + e, e);
    }
  }

2. 模板模式

在模板模式中，需要使用一个抽象类定义一套操作的整体步骤（即模板），而抽象类的子类则完成每个步骤的具体实现。这样，抽象类的不同子类遵循了同样的一套模板。

2.1 例子

JDK中的AbstractList是大部分List、Queue、Stack的父类，其中的addAll方法使用了模板方法，将具体的add方法交给了子类实现

    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);
        boolean modified = false;
        for (E e : c) {
            add(index++, e);
            modified = true;
        }
        return modified;
    }

    public void add(int index, E element) {
        throw new UnsupportedOperationException();
    }

2.2 Mybatis实例

作为ORM框架，Mybatis会负责将Java对象写为数据库中的字段，或者是反过来。例如，会将Java中的String字段写为varchar，Integer字段写为int

那么，这些字段类型就需要一个映射，Mybatis就是通过不同TypeHandler来处理的，例如IntegerTypeHandler是来处理Integer的

BaseTypeHandler是一个特定类型处理的父类，这个父类中定义的一些模板方法，其中的setParameter定义了写到数据库的模板，统一处理了空值和非空值，getResult定义了从数据库读的模板，统一处理了异常，具体的实现由子类来负责

  @Override
  public void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {
    if (parameter == null) {
      if (jdbcType == null) {
        throw new TypeException("JDBC requires that the JdbcType must be specified for all nullable parameters.");
      }
      try {
        ps.setNull(i, jdbcType.TYPE_CODE);
      } catch (SQLException e) {
        throw new TypeException("Error setting null for parameter #" + i + " with JdbcType " + jdbcType + " . "
              + "Try setting a different JdbcType for this parameter or a different jdbcTypeForNull configuration property. "
              + "Cause: " + e, e);
      }
    } else {
      try {
        setNonNullParameter(ps, i, parameter, jdbcType);
      } catch (Exception e) {
        throw new TypeException("Error setting non null for parameter #" + i + " with JdbcType " + jdbcType + " . "
              + "Try setting a different JdbcType for this parameter or a different configuration property. "
              + "Cause: " + e, e);
      }
    }
  }

  @Override
  public T getResult(ResultSet rs, int columnIndex) throws SQLException {
    try {
      return getNullableResult(rs, columnIndex);
    } catch (Exception e) {
      throw new ResultMapException("Error attempting to get column #" + columnIndex + " from result set.  Cause: " + e, e);
    }
  }

  public abstract void setNonNullParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;

  /**
   * @param columnName Colunm name, when configuration <code>useColumnLabel</code> is <code>false</code>
   */
  public abstract T getNullableResult(ResultSet rs, String columnName) throws SQLException;

  public abstract T getNullableResult(ResultSet rs, int columnIndex) throws SQLException;

  public abstract T getNullableResult(CallableStatement cs, int columnIndex) throws SQLException;

2.3 技巧

• 类中的模板方法使用final, 避免子类重写它

• 类中的步骤方法使用abstrat或者抛出异常，强迫子类重写它

3. 责任链模式

3.1 例子

最经典的例子是Servlet的Filter，我们配置了多个Filter，这多个Filter会一个接一个执行，执行的过程中是可以中止的

	@Override
	public void doFilter( ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain )
			throws IOException, ServletException{
			doSomething();
			filterChain.doFilter( servletRequest, servletResponse );
	}

3.2 Mybatis实例

Mybatis的插件功能可能没有听说过，但PageHelper一定用过，它就是使用Mybatis的插件来实现的，有兴趣的读者可以看下这篇文章5分钟！彻底搞懂MyBatis插件+PageHelper原理 - 知乎 (zhihu.com)

通过一系列的拦截器插件，会对Mybatis的一些核心类进行增强，责任链模式使它很容易扩展，即是可拔插的

public class InterceptorChain {
    // 拦截器链
    private final List<Interceptor> interceptors = new ArrayList<>();

    // target是支持拦截的几个类的实例。该方法依次向所有拦截器插入这几个类的实例
    // 如果某个插件真的需要发挥作用，则返回一个代理对象即可。如果不需要发挥作用，则返回原对象即可

    /**
     * 向所有的拦截器链提供目标对象，由拦截器链给出替换目标对象的对象
     * @param target 目标对象，是MyBatis中支持拦截的几个类（ParameterHandler、ResultSetHandler、StatementHandler、Executor）的实例
     * @return 用来替换目标对象的对象
     */
    public Object pluginAll(Object target) {
        // 依次交给每个拦截器完成目标对象的替换工作
        for (Interceptor interceptor : interceptors) {
            target = interceptor.plugin(target);
        }
        return target;
    }

    /**
     * 向拦截器链增加一个拦截器
     * @param interceptor 要增加的拦截器
     */
    public void addInterceptor(Interceptor interceptor) {
        interceptors.add(interceptor);
    }

    /**
     * 获取拦截器列表
     * @return 拦截器列表
     */
    public List<Interceptor> getInterceptors() {
        return Collections.unmodifiableList(interceptors);
    }

}

3.3 一些区别

上面的两个责任链其实是有些区别的，Servlet的Filter需要主动调用FiterChain的doFilter方法，来确保继续执行下一个Filter，所以也可以不执行，使流程中止，而Mybatis的插件则不可以中止

4. 代理模式

代理模式（Proxy Pattern）是指建立某一个对象的代理对象，并且由代理对象控制对原对象的引用。

• 静态代理
• 动态代理，JDK、CGLIB

4.1 例子

下面是一个JDK动态代理的例子，实现InvocationHandler接口和使用Proxy.newProxyInstance，功能是为控制层增加一个耗时统计的功能

public class MetricsCollectorProxy {
  private MetricsCollector metricsCollector;

  public MetricsCollectorProxy() {
    this.metricsCollector = new MetricsCollector();
  }

  public Object createProxy(Object proxiedObject) {
    Class<?>[] interfaces = proxiedObject.getClass().getInterfaces();
    DynamicProxyHandler handler = new DynamicProxyHandler(proxiedObject);
    return Proxy.newProxyInstance(proxiedObject.getClass().getClassLoader(), interfaces, handler);
  }

  private class DynamicProxyHandler implements InvocationHandler {
    private Object proxiedObject;

    public DynamicProxyHandler(Object proxiedObject) {
      this.proxiedObject = proxiedObject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      long startTimestamp = System.currentTimeMillis();
      Object result = method.invoke(proxiedObject, args);
      long endTimeStamp = System.currentTimeMillis();
      long responseTime = endTimeStamp - startTimestamp;
      String apiName = proxiedObject.getClass().getName() + ":" + method.getName();
      RequestInfo requestInfo = new RequestInfo(apiName, responseTime, startTimestamp);
      metricsCollector.recordRequest(requestInfo);
      return result;
    }
  }
}

//MetricsCollectorProxy使用举例
MetricsCollectorProxy proxy = new MetricsCollectorProxy();
IUserController userController = (IUserController) proxy.createProxy(new UserController());

4.2 Mybatis实例

Mybatis中使用代理的地方很多，我这挑了一个从功能上我们最熟悉的例子

用Mybatis都知道，只需要写一个Mapper接口和xml文件，然后就可以根据Mapper接口的方法来执行xml文件中对应的SQL语句，那这块是怎么实现的呢？其实就是Mybatis自动帮我们生成了一个代理类

下面是一个实现了InvocationHandler的代理类，在invoke方法中，对Object方法和默认方法不处理，其他的方法则使用MapperMethod来处理，MapperMethod其实就是真正执行SQL语句的类，我们的Mapper接口生成了代理类MapperProxy，代理了MapperMethod这个类

public class MapperProxy<T> implements InvocationHandler, Serializable {

  private static final long serialVersionUID = -6424540398559729838L;
  private final SqlSession sqlSession;
  private final Class<T> mapperInterface;
  // 该Map的键为方法，值为MapperMethod对象。通过该属性，完成了MapperProxy内（即映射接口内）方法和MapperMethod的绑定
  private final Map<Method, MapperMethod> methodCache;

  public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
    this.sqlSession = sqlSession;
    this.mapperInterface = mapperInterface;
    this.methodCache = methodCache;
  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      if (Object.class.equals(method.getDeclaringClass())) { // 继承自Object的方法
        // 直接执行原有方法
        return method.invoke(this, args);
      } else if (method.isDefault()) { // 默认方法
        // 执行默认方法
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    // 找对对应的MapperMethod对象
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    // 调用MapperMethod中的execute方法
    return mapperMethod.execute(sqlSession, args);
  }

  private MapperMethod cachedMapperMethod(Method method) {
    return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
  }

  private Object invokeDefaultMethod(Object proxy, Method method, Object[] args)
      throws Throwable {
    final Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
        .getDeclaredConstructor(Class.class, int.class);
    if (!constructor.isAccessible()) {
      constructor.setAccessible(true);
    }
    final Class<?> declaringClass = method.getDeclaringClass();
    return constructor
        .newInstance(declaringClass,
            MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED
                | MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC)
        .unreflectSpecial(method, declaringClass).bindTo(proxy).invokeWithArguments(args);
  }

}

下面是生成MapperProxy的工厂，可以看到也是用了Proxy.newProxyInstance生成了代理类

public class MapperProxyFactory<T> {

  ...
  private final Class<T> mapperInterface;
  public MapperProxyFactory(Class<T> mapperInterface) {
    this.mapperInterface = mapperInterface;
  }

  @SuppressWarnings("unchecked")
  protected T newInstance(MapperProxy<T> mapperProxy) {
    // 三个参数分别是：
    // 创建代理对象的类加载器、要代理的接口、代理类的处理器（即具体的实现）。
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

}

这个是MapperRegistry的一个方法，通过这个方法将一个Mapper接口生成一个代理类

  public <T> void addMapper(Class<T> type) {
    // 要加入的肯定是接口，否则不添加
    if (type.isInterface()) {
      // 加入的是接口
      if (hasMapper(type)) {
        // 如果添加重复
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }
      boolean loadCompleted = false;
      try {
        knownMappers.put(type, new MapperProxyFactory<>(type));
        // It's important that the type is added before the parser is run
        // otherwise the binding may automatically be attempted by the
        // mapper parser. If the type is already known, it won't try.
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }

通过上面这几个类，就把Mapper接口对应的一系列的MapperMethod到上面，至于MapperMethod是怎么和SQL关联上的，有兴趣的读者可以自己去看一下，其实也很简单，根据方法名中xml文件取对应的SQL就可以，但还是涉及很多参数处理的东西

5. 其他模式

除了这些模式之外，Mybatis还用了很多其他的模式，因为也比较简单，所以就没列出来了，例如单例模式、建造者模式、工厂模式等

6. 总结

• 我们主要介绍了Mybatis的装饰器模式、模板模式、责任链模式、代理模式。

• 平时我们在学习设计模式的过程中，常常会见到一些和实际工程无关的例子代码，感觉这些设计模式只能用于这些例子，无法用于实际的项目。通过学习Mybatis的实际运用，可以加深我们对设计模式的理解

• 既然Mybatis可以做到很流行，它的代码必然是有可取之处的，所以运用这些模式到自己的项目中，毫无疑问的会提供项目的质量，使用代码更容易扩展和维护，这也是我们学习设计模式的目的。