目錄
本博客着重介紹MyBatis執行Sql的流程，關於在執行過程中緩存、動態SQl生成等細節不在本博客中體現，相應內容後面再單獨寫博客分析吧。
還是以之前的查詢作為列子：
public class UserDaoTest {
private SqlSessionFactory sqlSessionFactory;
@Before
public void setUp() throws Exception{
ClassPathResource resource = new ClassPathResource("mybatis-config.xml");
InputStream inputStream = resource.getInputStream();
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
}
@Test
public void selectUserTest(){
String id = "{0003CCCA-AEA9-4A1E-A3CC-06D884BA3906}";
SqlSession sqlSession = sqlSessionFactory.openSession();
CbondissuerMapper cbondissuerMapper = sqlSession.getMapper(CbondissuerMapper.class);
Cbondissuer cbondissuer = cbondissuerMapper.selectByPrimaryKey(id);
System.out.println(cbondissuer);
sqlSession.close();
}
}之前提到拿到sqlSession之後就能進行各種CRUD操作了，所以我們就從sqlSession.getMapper這個方法開始分析，看下整個Sql的執行流程是怎麼樣的。
獲取Mapper
進入sqlSession.getMapper方法，會發現調的是Configration對象的getMapper方法：
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
//mapperRegistry實質上是一個Map，裏面註冊了啟動過程中解析的各種Mapper.xml
//mapperRegistry的key是接口的全限定名，比如com.csx.demo.spring.boot.dao.SysUserMapper
//mapperRegistry的Value是MapperProxyFactory,用於生成對應的MapperProxy（動態代理類）
return mapperRegistry.getMapper(type, sqlSession);
}進入getMapper方法：
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
//如果配置文件中沒有配置相關Mapper,直接拋異常
if (mapperProxyFactory == null) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
}
try {
//關鍵方法
return mapperProxyFactory.newInstance(sqlSession);
} catch (Exception e) {
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
}
}進入MapperProxyFactory的newInstance方法：
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;
}
//生成Mapper接口的動態代理類MapperProxy
@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);
}
}下面是動態代理類MapperProxy，調用Mapper接口的所有方法都會先調用到這個代理類的invoke方法（注意由於Mybatis中的Mapper接口沒有實現類，所以MapperProxy這個代理對象中沒有委託類，也就是說MapperProxy幹了代理類和委託類的事情）。好了下面重點看下invoke方法。
//MapperProxy代理類
public class MapperProxy<T> implements InvocationHandler, Serializable {
private static final long serialVersionUID = -6424540398559729838L;
private final SqlSession sqlSession;
private final Class<T> mapperInterface;
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())) {
return method.invoke(this, args);
} else if (isDefaultMethod(method)) {
return invokeDefaultMethod(proxy, method, args);
}
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
//獲取MapperMethod，並調用MapperMethod
final MapperMethod mapperMethod = cachedMapperMethod(method);
return mapperMethod.execute(sqlSession, args);
}
private MapperMethod cachedMapperMethod(Method method) {
MapperMethod mapperMethod = methodCache.get(method);
if (mapperMethod == null) {
mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
methodCache.put(method, mapperMethod);
}
return mapperMethod;
}
@UsesJava7
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);
}
/**
* Backport of java.lang.reflect.Method#isDefault()
*/
private boolean isDefaultMethod(Method method) {
return ((method.getModifiers()
& (Modifier.ABSTRACT | Modifier.PUBLIC | Modifier.STATIC)) == Modifier.PUBLIC)
&& method.getDeclaringClass().isInterface();
}
}所以這邊需要進入MapperMethod的execute方法：
public Object execute(SqlSession sqlSession, Object[] args) {
Object result;
//判斷是CRUD那種方法
switch (command.getType()) {
case INSERT: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.insert(command.getName(), param));
break;
}
case UPDATE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.update(command.getName(), param));
break;
}
case DELETE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.delete(command.getName(), param));
break;
}
case SELECT:
if (method.returnsVoid() && method.hasResultHandler()) {
executeWithResultHandler(sqlSession, args);
result = null;
} else if (method.returnsMany()) {
result = executeForMany(sqlSession, args);
} else if (method.returnsMap()) {
result = executeForMap(sqlSession, args);
} else if (method.returnsCursor()) {
result = executeForCursor(sqlSession, args);
} else {
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
}
break;
case FLUSH:
result = sqlSession.flushStatements();
break;
default:
throw new BindingException("Unknown execution method for: " + command.getName());
}
if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
throw new BindingException("Mapper method '" + command.getName()
+ " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
}
return result;
}然後，通過一層一層的調用，最終會來到doQuery方法， 這兒咱們就隨便找個Excutor看看doQuery方法的實現吧，我這兒選擇了SimpleExecutor:
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
Statement stmt = null;
try {
Configuration configuration = ms.getConfiguration();
//內部封裝了ParameterHandler和ResultSetHandler
StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
stmt = prepareStatement(handler, ms.getStatementLog());
//StatementHandler封裝了Statement, 讓 StatementHandler 去處理
return handler.<E>query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
}接下來，咱們看看StatementHandler 的一個實現類 PreparedStatementHandler（這也是我們最常用的，封裝的是PreparedStatement）, 看看它使怎麼去處理的：
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
//到此，原形畢露， PreparedStatement, 這個大家都已經滾瓜爛熟了吧
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
//結果交給了ResultSetHandler 去處理,處理完之後返回給客戶端
return resultSetHandler.<E> handleResultSets(ps);
}到此，整個調用流程結束。
簡單總結
這邊結合獲取SqlSession的流程，做下簡單的總結：
- SqlSessionFactoryBuilder解析配置文件，包括屬性配置、別名配置、攔截器配置、環境（數據源和事務管理器）、Mapper配置等；解析完這些配置後會生成一個Configration對象，這個對象中包含了MyBatis需要的所有配置，然後會用這個Configration對象創建一個SqlSessionFactory對象，這個對象中包含了Configration對象；
- 拿到SqlSessionFactory對象后，會調用SqlSessionFactory的openSesison方法，這個方法會創建一個Sql執行器（Executor組件中包含了Transaction對象），這個Sql執行器會代理你配置的攔截器方法。
- 獲得上面的Sql執行器后，會創建一個SqlSession（默認使用DefaultSqlSession）,這個SqlSession中也包含了Configration對象和上面創建的Executor對象，所以通過SqlSession也能拿到全局配置；
- 獲得SqlSession對象后就能執行各種CRUD方法了。
以上是獲得SqlSession的流程，下面總結下本博客中介紹的Sql的執行流程：
- 調用SqlSession的getMapper方法，獲得Mapper接口的動態代理對象MapperProxy，調用Mapper接口的所有方法都會調用到MapperProxy的invoke方法（動態代理機制）；
- MapperProxy的invoke方法中唯一做的就是創建一個MapperMethod對象，然後調用這個對象的execute方法，sqlSession會作為execute方法的入參；
- 往下，層層調下來會進入Executor組件（如果配置插件會對Executor進行動態代理）的query方法，這個方法中會創建一個StatementHandler對象，這個對象中同時會封裝ParameterHandler和ResultSetHandler對象。調用StatementHandler預編譯參數以及設置參數值，使用ParameterHandler來給sql設置參數。
Executor組件有兩個直接實現類，分別是BaseExecutor和CachingExecutor。CachingExecutor靜態代理了BaseExecutor。Executor組件封裝了Transction組件，Transction組件中又分裝了Datasource組件。
- 調用StatementHandler的增刪改查方法獲得結果，ResultSetHandler對結果進行封裝轉換，請求結束。
Executor、StatementHandler 、ParameterHandler、ResultSetHandler，Mybatis的插件會對上面的四個組件進行動態代理。
重要類
-
MapperProxyFactory
-
MapperProxy
-
MapperMethod
-
SqlSession：作為MyBatis工作的主要頂層API，表示和數據庫交互的會話，完成必要數據庫增刪改查功能；
-
Executor：MyBatis執行器，是MyBatis 調度的核心，負責SQL語句的生成和查詢緩存的維護；
StatementHandler 封裝了JDBC Statement操作，負責對JDBC statement 的操作，如設置參數、將Statement結果集轉換成List集合。
ParameterHandler 負責對用戶傳遞的參數轉換成JDBC Statement 所需要的參數，
ResultSetHandler 負責將JDBC返回的ResultSet結果集對象轉換成List類型的集合；
TypeHandler 負責java數據類型和jdbc數據類型之間的映射和轉換
MappedStatement MappedStatement維護了一條<select|update|delete|insert>節點的封裝，
SqlSource 負責根據用戶傳遞的parameterObject，動態地生成SQL語句，將信息封裝到BoundSql對象中，並返回
BoundSql 表示動態生成的SQL語句以及相應的參數信息Configuration MyBatis所有的配置信息都維持在Configuration對象之中。
參考
- https://www.cnblogs.com/dongying/p/4031382.html
- https://blog.csdn.net/qq_38409944/article/details/82494187
本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】
※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線
※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益
※自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象
※南投搬家前需注意的眉眉角角，別等搬了再說!