Mybatis的執行分為兩個部分，第一部分是讀取配置檔案快取到Configuration物件，用以建立SqlSessionFactory，第二部分是SqlSession的執行過程。相對而言，SqlSessionFactory的建立比較容易理解，而SqlSession的執行過程遠遠不是那麼簡單了，它將包括許多複雜的技術，我們需要先討論反射技術和動態代理技術，這是揭示mybatis底層架構的基礎。

反射技術：

在java中，反射技術已經大行其道，並且通過不斷優化，java的可配置性等效能得到了巨大的提升。
首先，我們來寫一個列印“hello:world”的服務：程式碼如下：

public
 
 class Test {
    public void sayHello (String str) {
        System.err.println("hello:" + str);
    }
}

通過反射呼叫該方法，程式碼如下：

import java.lang.reflect.Method;

public class InvokeTest {
    public static void main(String[] args) throws Exception {
        //通過反射建立test物件
        Object test = Class.forName(Test.class.getName()).newInstance();
        //獲取服務方法：sayHello
 

        Method method = test.getClass().getMethod("sayHello", String.class);
        //反射呼叫方法
        method.invoke(test, "world");
    }
}

執行main行數，結果如下：

上述例子就是java反射機制的簡單應用，反射呼叫的最大好處就是配置性大大提高，就如同Spring IOC容器一樣，我們可以給很多配置引數，使得java應用程式能夠順利執行起來，大大提高java的靈活性和可配置性，降低模組之間的耦合。

JDK動態代理：

JDK的動態代理，是由JDK的java.lang.reflect.*包提供支援的，我們需要完成這麼幾個步驟：
1、 編寫服務類和介面，這個是真正的服務提供者，在JDK代理中介面是必須的
2、 編寫代理類，提供繫結和代理方法
JDK代理最大的缺點就是需要介面，而mybatis的Mapper就是一個介面，它採用的就是JDK的動態代理。我們先給一個服務介面，程式碼如下：

public interface HelloService {
    void sayHello(String str);
}

然後寫一個實現類，程式碼如下：

public class HelloServiceImpl implements HelloService {
    @Override
    public void sayHello(String str) {
        // TODO Auto-generated method stub
        System.out.println("Hello" + str);
    }

}

現在寫一個代理類，提供真實的繫結和代理方法。代理類的要求是實現InvocationHandler介面的代理方法，當一個物件被繫結後，執行其方法的時候就會進入到代理方法裡，程式碼如下：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class HelloServiceProxy implements InvocationHandler{

    /**
     * 真實的服務物件
     */
    private Object target;

    /**
     * 繫結一個委託物件並返回一個代理類
     * @param target
     * @return
     */
    public Object bind(Object target){
        this.target = target;
        Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
        return proxy;
    }

    /**
     * 通過代理物件呼叫方法首先進入這個方法
     * @param procy 代理物件
     * @param method 被呼叫方法
     * @param agrs 方法引數
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] arg) throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("我是JDK代理");
        Object result = null;
        //反射方法呼叫前
        System.out.println("開始呼叫方法");
        //執行方法，相當於呼叫HelloServiceImpl的sayHello方法
        result = method.invoke(target, "world");
        //反射方法呼叫後
        System.out.println("呼叫方法完成");
        return result;
    }

}

Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), this);
這段程式碼讓JDK產生一個代理物件，這個代理物件有三個引數：第一個引數target.getClass().getClassLoader()是類載入器，第二個引數target.getClass().getInterfaces()是介面（代理物件掛載哪個介面下），第三個引數this代表當前HelloServiceProxy類，換句話說是使用HelloServiceProxy的代理方法作為物件的代理執行者。
一旦繫結後，在進入代理物件方法呼叫的時候就會到HelloServiceProxy的代理方法上，代理方法有三個引數：第一個proxy是代理物件，第二個是當前呼叫的那個方法，第三個是方法引數。比方說，現在HelloServiceImpl物件（obj）用bind方法繫結後，返回其佔位，我們在呼叫proxy.sayHelo(“hello”)，那麼它就會進入到HelloServiceProxy的invoke()方法。而invoke引數中第一個便是代理物件proxy，方法是sayHello，引數是world。
讓我們測試一下動態代理，程式碼如下：

public class ProxyTest {
    public static void main(String[] args) {
        HelloServiceProxy HelloHandler = new HelloServiceProxy();
        HelloService procy = (HelloService) HelloHandler.bind(new HelloServiceImpl());
        procy.sayHello("World");
    }
}

執行結果如下：

CGLIB動態代理：

JDK提供的動態代理存在一個缺陷，就是必須提供接口才可以實現，為了克服這個缺陷，我們可以採用開源框架—CGLIB，它是一種流行的動態代理。
讓我們看看如何使用CGLIB動態代理。HelloService.java和HelloServiceImpl.java不需要改變，我們只需要實現CGLIB的代理類。實現MethodInterceptor的代理方法入下：

import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class HelloServiceCgLib implements MethodInterceptor{

    private Object target;
    /**
     * 建立代理物件
     * @param target
     * @return
     */
    public Object getInstance(Object target){
        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        //回撥方法
        enhancer.setCallback(this);
        //建立代理物件
        return enhancer.create();
    }

    @Override
    //回撥方法
    public Object intercept(Object obj, Method methoc, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("我是cglib動態代理");
        //反射方法呼叫前
        System.out.println("開始呼叫");
        Object returnObj = proxy.invokeSuper(obj, args);
        //反射方法呼叫之後
        System.out.println("電泳完成");

        return returnObj;
    }
}

我們的呼叫形式如下：

HelloServiceCgLib hello = new HelloServiceCgLib();
HelloServiceImpl proxyImpl = (HelloServiceImpl)hello.getInstance(HelloServiceImpl.class);
proxyImpl.sayHello("hello");

這樣便能實現CGLIB的動態代理。在mybatis中通常延時載入的時候才會用到CGLIB的動態代理。
以上便是mybatis用到的代理模式，有了這些基礎就可以更好的理解mybatis的運行了。

注：以上內容根據《深入淺出mybatis技術原理與實戰》一書整理編寫，感謝作者的辛勤勞作。