Mybatis源码中的设计模式

Mybatis源码中的设计模式

虽然我们都知道有3类23种设计模式，但是大多停留在概念层面，Mybatis源码中使用了大量的设计模
式，观察设计模式在其中的应用，能够更深入的理解设计模式
Mybati s至少用到了以下的设计模式的使用：

接下来对Builder构建者模式、工厂模式、代理模式进行解读，先介绍模式自身的知识，然后解读在Mybatis中怎样应用了该模式。

Builder构建者模式

Builder模式的定义是"将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。”，它属于创建类模式，一般来说，如果一个对象的构建比较复杂，超出了构造函数所能包含的范围，就可以使用工厂模式和Builder模式，相对于工厂模式会产出一个完整的产品，Builder应用于更加复杂的对象的构建，甚至只会构建产品的一个部分，直白来说，就是使用多个简单的对象一步一步构建成一个复杂的对象

主要步骤：

1. 将需要构建的目标类分成多个部件（电脑可以分为主机、显示器、键盘、音箱等部件）；
2. 创建构建类；
3. 依次创建部件；
4. 将部件组装成目标对象
   Mybatis中的体现：
   SqlSessionFactory 的构建过程：
   Mybatis的初始化工作非常复杂，不是只用一个构造函数就能搞定的。所以使用了建造者模式，使用了大量的Builder，进行分层构造，核心对象Configuration使用了 XmlConfigBuilder来进行构造
   
   在Mybatis环境的初始化过程中，SqlSessionFactoryBuilder会调用XMLConfigBuilder读取所有的MybatisMapConfig.xml 和所有的 *Mapper.xml 文件，构建 Mybatis 运行的核心对象 Configuration对象，然后将该Configuration对象作为参数构建一个SqlSessionFactory对象。

private void parseConfiguration(XNode root) {
	try {
		//issue #117 read properties first
		//解析<properties />标签
		propertiesElement(root.evalNode("properties"));
		// 解析 <settings /> 标签
		Properties settings = settingsAsProperties(root.evalNode("settings"));
		//加载自定义的VFS实现类
		loadCustomVfs(settings);
		// 解析 <typeAliases /> 标签
		typeAliasesElement(root.evalNode("typeAliases"));
		//解析<plugins />标签
		pluginElement(root.evalNode("plugins"));
		// 解析 <objectFactory /> 标签
		objectFactoryElement(root.evaINode("obj ectFactory"));
		// 解析 <objectWrapper Factory /> 标签
		obj ectWrappe rFacto ryElement(root.evalNode("objectWrapperFactory"));
		// 解析 <reflectorFactory /> 标签
		reflectorFactoryElement(root.evalNode("reflectorFactory"));
		// 赋值 <settings /> 到 Configuration 属性
		settingsElement(settings);
		// read it after objectFactory and objectWrapperFactory issue #631
		// 解析 <environments /> 标签
		environmentsElement(root.evalNode("environments"));
		// 解析 <databaseIdProvider /> 标签
		databaseldProviderElement(root.evalNode("databaseldProvider"));
	}

其中 XMLConfigBuilder 在构建 Configuration 对象时，也会调用 XMLMapperBuilder 用于读取*Mapper 文件，而XMLMapperBuilder会使用XMLStatementBuilder来读取和build所有的SQL语句。

//解析<mappers />标签
mapperElement(root.evalNode("mappers"));

在这个过程中，有一个相似的特点，就是这些Builder会读取文件或者配置，然后做大量的XpathParser解析、配置或语法的解析、反射生成对象、存入结果缓存等步骤，这么多的工作都不是一个构造函数所能包括的，因此大量采用了 Builder模式来解决SqlSessionFactoryBuilder类根据不同的输入参数来构建SqlSessionFactory这个工厂对象

工厂模式

在Mybatis中比如SqlSessionFactory使用的是工厂模式，该工厂没有那么复杂的逻辑，是一个简单工厂模式。简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类可以看到，该Factory的openSession ()方法重载了很多个，分别支持autoCommit、Executor、Transaction等参数的输入，来构建核心的SqlSession对象。DefaultSqlSessionFactory的默认工厂实现里，有一个方法可以看出工厂怎么产出一个产品:

private SqlSession openSessionFromDataSource(ExecutorType execType,
	TransactionIsolationLevel level,boolean autoCommit){
	Transaction tx=null;
	try{
		final Environment environment=configuration.getEnvironment();
		final TransactionFactory transactionFactory=getTransactionFactoryFromEnvironment(environment);
		tx=transactionFactory.newTransaction(environment.getDataSource(),level,autoCommit);
		//根据参数创建制定类型的Executor
		final Executor executor=configuration.newExecutor(tx,execType);
		//返回的是 DefaultSqlSession
		return new DefaultSqlSession(configuration,executor,autoCommit);
	}catch(Exception e){
		closeTransaction(tx); // may have fetched a connection so lets call
		close()
		throw ExceptionFactory.wrapException("Error opening session. Cause: "+e,e);
	}finally{
		ErrorContext.instance().reset();
	}
}

这是一个openSession调用的底层方法，该方法先从configuration读取对应的环境配置，然后初始化TransactionFactory 获得一个 Transaction 对象，然后通过 Transaction 获取一个 Executor 对象，最后通过configuration、Executor、是否autoCommit三个参数构建了 SqlSession

代理模式

代理模式(Proxy Pattern):给某一个对象提供一个代理，并由代理对象控制对原对象的引用。代理模式的英文叫做Proxy，它是一种对象结构型模式，代理模式分为静态代理和动态代理，我们来介绍动态代理

代理模式可以认为是Mybatis的核心使用的模式，正是由于这个模式，我们只需要编写Mapper.java接口，不需要实现，由Mybati s后台帮我们完成具体SQL的执行。当我们使用Configuration的getMapper方法时，会调用mapperRegistry.getMapper方法，而该方法又
会调用mapperProxyFactory.newInstance(sqlSession)来生成一个具体的代理：

public class MapperProxyFactory<T> {
	private final Class<T> mapperInterface;
	private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();
	public MapperProxyFactory(Class<T> mapperInterface) {
		this.mapperInterface = mapperInterface;
	}
	public Class<T> getMapperInterface() {
		return mapperInterface;
	}
	public Map<Method, MapperMethod> getMethodCache() {
		return methodCache;
	@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<T>(sqlSession,mapperInterface, methodCache);
		return newInstance(mapperProxy);
	}
}

在这里，先通过T newInstance(SqlSession sqlSession)方法会得到一个MapperProxy对象，然后调用TnewInstance(MapperProxy mapperProxy)生成代理对象然后返回。而查看MapperProxy的代码，可以看到如下内容：

	public class MapperProxy<T> implements InvocationHandler, Serializable {
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		try {
			if (Object.class.equals(method.getDeclaringClass())) {
				return method.invoke(this, args);
			} else if (isDefaultMethod(method)) {
				return invokeDefaultMethod(proxy, method, args);
			}
		} catch (Throwable t) {
			throw ExceptionUtil.unwrapThrowable(t);
		}
		final MapperMethod mapperMethod = cachedMapperMethod(method);
		return mapperMethod.execute(sqlSession, args);
	}

非常典型的，该MapperProxy类实现了InvocationHandler接口，并且实现了该接口的invoke方法。通过这种方式，我们只需要编写Mapper.java接口类，当真正执行一个Mapper接口的时候，就会转发给MapperProxy.invoke方法，而该方法则会调用后续的
sqlSession.cud>executor.execute>prepareStatement 等一系列方法，完成 SQL 的执行和返回