最近在看《通用源码阅读指导书：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可以做到很流行，它的代码必然是有可取之处的，所以运用这些模式到自己的项目中，毫无疑问的会提供项目的质量，使用代码更容易扩展和维护，这也是我们学习设计模式的目的。