Mybatis 懶加載的使用
什么是懶加載？懶加載的意思就是在使用的時候才去加載，不使用不去加載，相反的就叫饑餓加載或者立即加載，懶加載在Mybatis中一般是存在與聯合查詢的情況，比如查詢一個物件的同時連帶查詢相關的表對應的資料，在Mybatis中查詢可以通過ResultMap設定查詢物件回傳一個集合屬性，也就是說像這樣的：
@Data
public class User implements Serializable {
private int id;
private int age;
private String name;
private List<Order> orderList;
}
這里的orderList就是一個集合，在mapper.xml中配置如下：
<resultMap id="userMap" type="mybatis.model.User">
<id column="id" property="id"/>
<result property="age" column="age"/>
<result property="name" column="name"/>
<collection property="orderList" ofType="mybatis.model.Order" column="id" select="findByUid"/>
</resultMap>
<select id="findByUid" resultType="mybatis.model.Order">
select * from `order` where uid = #{id}
</select>
<select id="selectById" resultMap="userMap">
select * from user where id = #{id}
</select>
可以看到這里查詢User物件的時候還查詢了Order串列，這個用戶關聯的訂單資訊，如果只是這樣查詢那么結果是饑餓加載：
@Test
public void testLazyLoad(){
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user = mapper.selectById(1);
System.out.println(user.getName());
}
輸出結果，執行了兩個sql陳述句查詢，說明查詢User的同時也查詢了Order
09:52:56.575 [main] INFO mybatis.plugins.MyPlugin - 對方法進行增強....
==> Preparing: select * from user where id = ?
==> Parameters: 1(Integer)
<== Columns: id, age, name
<== Row: 1, 18, 靈犀
Cache Hit Ratio [mybatis.mapper.UserMapper]: 0.0
09:52:56.613 [main] INFO mybatis.plugins.MyPlugin - 對方法進行增強....
====> Preparing: select * from `order` where uid = ?
====> Parameters: 1(Integer)
<==== Columns: id, uid, order_name, price
<==== Row: 1, 1, 蘋果, 8.00
<==== Row: 3, 1, 筆記本電腦, 8000.00
<==== Total: 2
<== Total: 1
靈犀
Process finished with exit code 0
配置懶加載：
<resultMap id="userMap" type="mybatis.model.User">
<id column="id" property="id"/>
<result property="age" column="age"/>
<result property="name" column="name"/>
<collection property="orderList" ofType="mybatis.model.Order" column="id" select="findByUid" fetchType="lazy"/>
</resultMap>
這里的collection標簽中的fetchType屬性可以設定為lazy或者eager，默認就是eager饑餓加載，配置完之后執行：
09:56:22.649 [main] INFO mybatis.plugins.MyPlugin - 對方法進行增強....
==> Preparing: select * from user where id = ?
==> Parameters: 1(Integer)
<== Columns: id, age, name
<== Row: 1, 18, 靈犀
<== Total: 1
靈犀
可以看到只執行了查詢user的sql陳述句，而查詢訂單order的sql陳述句沒有執行，只有在使用orderList這個屬性的時候才會去執行sql查詢：
@Test
public void testLazyLoad(){
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user = mapper.selectById(1);
System.out.println(user.getName());
// 懶加載
System.out.println(user.getOrderList());
}
輸出結果：
09:58:02.681 [main] INFO mybatis.plugins.MyPlugin - 對方法進行增強....
==> Preparing: select * from user where id = ?
==> Parameters: 1(Integer)
<== Columns: id, age, name
<== Row: 1, 18, 靈犀
<== Total: 1
靈犀
Cache Hit Ratio [mybatis.mapper.UserMapper]: 0.0
09:58:02.746 [main] INFO mybatis.plugins.MyPlugin - 對方法進行增強....
==> Preparing: select * from `order` where uid = ?
==> Parameters: 1(Integer)
<== Columns: id, uid, order_name, price
<== Row: 1, 1, 蘋果, 8.00
<== Row: 3, 1, 筆記本電腦, 8000.00
<== Total: 2
[Order(id=1, uid=1, orderName=蘋果, price=8.00), Order(id=3, uid=1, orderName=筆記本電腦, price=8000.00)]
Process finished with exit code 0
可以看到執行查詢訂單的sql陳述句并且列印了訂單資訊
Mybatis 懶加載原理及原始碼決議
Mybatis懶加載的原理要搞清楚的話，就需要去找到回傳結果的時候看看Mybatis是如何封裝的，找到ResultSetHandler，因為這個介面就是專門用于結果集封裝的，默認實作為DefaultResultSetHandler，根據查詢資料流程不難發現封裝結果集的時候呼叫的是handleResultSets方法：
@Override
public List<Object> handleResultSets(Statement stmt) throws SQLException {
ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
final List<Object> multipleResults = new ArrayList<>();
int resultSetCount = 0;
// 獲取ResultSet的包裝器
ResultSetWrapper rsw = getFirstResultSet(stmt);
List<ResultMap> resultMaps = mappedStatement.getResultMaps();
int resultMapCount = resultMaps.size();
// 驗證結果數量
validateResultMapsCount(rsw, resultMapCount);
while (rsw != null && resultMapCount > resultSetCount) {
ResultMap resultMap = resultMaps.get(resultSetCount);
// 處理結果集
handleResultSet(rsw, resultMap, multipleResults, null);
rsw = getNextResultSet(stmt);
cleanUpAfterHandlingResultSet();
resultSetCount++;
}
點擊處理結果集的方法：
private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
try {
if (parentMapping != null) {
// 處理每行的資料
handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
} else {
if (resultHandler == null) {
DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
multipleResults.add(defaultResultHandler.getResultList());
} else {
handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
}
}
} finally {
// issue #228 (close resultsets)
closeResultSet(rsw.getResultSet());
}
}
點擊處理每行的資料方法：
public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
// 如果存在嵌套的結果集
if (resultMap.hasNestedResultMaps()) {
// 安全行約束檢查，如果是嵌套查詢需要關閉安全行約束條件
ensureNoRowBounds();
// 檢查結果處理器是否符合嵌套查詢約束
checkResultHandler();
// 執行嵌套查詢結果集處理
handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
} else {
// 簡單的結果集分裝處理
handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
}
}
由于我們寫的這個結果是簡單結果集，所以進入handleRowValuesForSimpleResultMap：
private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
throws SQLException {
DefaultResultContext<Object> resultContext = new DefaultResultContext<>();
ResultSet resultSet = rsw.getResultSet();
skipRows(resultSet, rowBounds);
while (shouldProcessMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next()) {
ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(resultSet, resultMap, null);
// 獲取每行的值
Object rowValue = https://www.cnblogs.com/redwinter/archive/2022/08/22/getRowValue(rsw, discriminatedResultMap, null);
storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);
}
}
挑重點，直接進入獲取每行值方法中：
private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, String columnPrefix) throws SQLException {
final ResultLoaderMap lazyLoader = new ResultLoaderMap();
// 創建結果值
Object rowValue = https://www.cnblogs.com/redwinter/archive/2022/08/22/createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
final MetaObject metaObject = configuration.newMetaObject(rowValue);
boolean foundValues = this.useConstructorMappings;
if (shouldApplyAutomaticMappings(resultMap, false)) {
foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
}
foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
foundValues = lazyLoader.size() > 0 || foundValues;
rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
}
return rowValue;
}
繼續進入獲取每行結果值的方法，createResultObject:
private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, ResultLoaderMap lazyLoader, String columnPrefix) throws SQLException {
this.useConstructorMappings = false; // reset previous mapping result
final List<Class<?>> constructorArgTypes = new ArrayList<>();
final List<Object> constructorArgs = new ArrayList<>();
// 創建結果物件 ，使用ObjectFactory 反射進行創建
Object resultObject = createResultObject(rsw, resultMap, constructorArgTypes, constructorArgs, columnPrefix);
if (resultObject != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
for (ResultMapping propertyMapping : propertyMappings) {
// issue gcode #109 && issue #149
// 檢查屬性是否是懶加載的屬性
if (propertyMapping.getNestedQueryId() != null && propertyMapping.isLazy()) {
// 使用動態代理創建一個代理物件作為結果物件回傳出去，默認使用javassist 進行創建
resultObject = configuration.getProxyFactory().createProxy(resultObject, lazyLoader, configuration, objectFactory, constructorArgTypes, constructorArgs);
break;
}
}
}
this.useConstructorMappings = resultObject != null && !constructorArgTypes.isEmpty(); // set current mapping result
return resultObject;
}
這里就先是通過反射創建出這個物件resultObject，然后遍歷去檢查這些屬性是否是懶加載的，如果是那么就通過代理工廠去創建一個代理物件，由于這里創建的是一個回傳物件，不是一個介面因此動態代理實作是通過cglib實作的，Mybatis這里使用javassist包下的代理進行創建代理物件，代理工廠默認就是JavassistProxyFactory:
static Object crateProxy(Class<?> type, MethodHandler callback, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
ProxyFactory enhancer = new ProxyFactory();
enhancer.setSuperclass(type);
try {
type.getDeclaredMethod(WRITE_REPLACE_METHOD);
// ObjectOutputStream will call writeReplace of objects returned by writeReplace
if (LogHolder.log.isDebugEnabled()) {
LogHolder.log.debug(WRITE_REPLACE_METHOD + " method was found on bean " + type + ", make sure it returns this");
}
} catch (NoSuchMethodException e) {
enhancer.setInterfaces(new Class[] { WriteReplaceInterface.class });
} catch (SecurityException e) {
// nothing to do here
}
Object enhanced;
Class<?>[] typesArray = constructorArgTypes.toArray(new Class[constructorArgTypes.size()]);
Object[] valuesArray = constructorArgs.toArray(new Object[constructorArgs.size()]);
try {
// 創建代理物件
enhanced = enhancer.create(typesArray, valuesArray);
} catch (Exception e) {
throw new ExecutorException("Error creating lazy proxy. Cause: " + e, e);
}
((Proxy) enhanced).setHandler(callback);
return enhanced;
}
實際上這里也是通過反射進行創建，只是在外面封裝成了ProxyFactory這個物件，當我們呼叫getOrderList方法的時候就會執行到invoke方法中，并且判斷是否是延遲加載的，如果是那么就會執行lazyLoader.load方法執行延遲加載，也就是執行sql查詢資料：
@Override
public Object invoke(Object enhanced, Method method, Method methodProxy, Object[] args) throws Throwable {
final String methodName = method.getName();
try {
synchronized (lazyLoader) {
if (WRITE_REPLACE_METHOD.equals(methodName)) {
Object original;
if (constructorArgTypes.isEmpty()) {
original = objectFactory.create(type);
} else {
original = objectFactory.create(type, constructorArgTypes, constructorArgs);
}
PropertyCopier.copyBeanProperties(type, enhanced, original);
if (lazyLoader.size() > 0) {
return new JavassistSerialStateHolder(original, lazyLoader.getProperties(), objectFactory, constructorArgTypes, constructorArgs);
} else {
return original;
}
} else {
if (lazyLoader.size() > 0 && !FINALIZE_METHOD.equals(methodName)) {
if (aggressive || lazyLoadTriggerMethods.contains(methodName)) {
lazyLoader.loadAll();
} else if (PropertyNamer.isSetter(methodName)) {
final String property = PropertyNamer.methodToProperty(methodName);
lazyLoader.remove(property);
//判斷方法是否是get方法
} else if (PropertyNamer.isGetter(methodName)) {
final String property = PropertyNamer.methodToProperty(methodName);
// 判斷屬性是否是延遲加載的，如果是那么執行加載
if (lazyLoader.hasLoader(property)) {
lazyLoader.load(property);
}
}
}
}
}
// 執行原方法
return methodProxy.invoke(enhanced, args);
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
}
}
load方法就會執行真正的查詢sql陳述句，將資料賦值給User物件，這樣就完成了真正的懶加載操作，所以Mybatis的懶加載實際上就是利用動態代理將物件的引數封裝進行了延遲加載，當需要時再去呼叫真正的查詢操作并回傳資料，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/502438.html
標籤：其他