第⼗部分：Mybatis源码剖析

10.1传统⽅式源码剖析：

//读取配置文件，读成字节输入流的，注意：现在还没解析
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
//这才是一切工作的开始
//2.解析配置文件，封装成Configuration对象，创建DefaultSqlSessionFactory对象
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
//3.生产了DefaultSqlSession实例对象，设置了事务不自动提交，完成了executor对象的创建
SqlSession sqlSession = sqlSessionFactory.openSession();

//（1）根据statementid来Configuration中map集合中获取到了指定的MappedStatement对象

//(2)将查询操作委派给Executor

 List<Object>objects=sqlSession.selectList("namespace.id");

 进⼊源码分析：

// 1.我们最初调用的build
public SqlSessionFactory build(InputStream inputStream) {//调用了重载方法return build(inputStream, null, null);
}

// 2.调用的重载方法
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {try {// 创建 XMLConfigBuilder, XMLConfigBuilder是专门解析mybatis的配置文件的类XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);// 执行 XML 解析// 创建 DefaultSqlSessionFactory 对象return build(parser.parse());} catch (Exception e) {throw ExceptionFactory.wrapException("Error building SqlSession.", e);} finally {ErrorContext.instance().reset();try {inputStream.close();} catch (IOException e) {// Intentionally ignore. Prefer previous error.}}
}

Configuration对象的结构和xml配置⽂件的对象⼏乎相同。

回顾⼀下xml中的配置标签有哪些：

properties (属性)，settings (设置)，typeAliases (类型别名)，typeHandlers (类型处理

器)，objectFactory (对象⼯⼚)，mappers (映射器)等 Configuration也有对应的对象属性来封

装它们

也就是说，初始化配置⽂件信息的本质就是创建Configuration对象，将解析的xml数据封装到

Configuration内部属性中

 

/**

* 解析 XML 成 Configuration 对象。

*/

public Configuration parse () {

//若已解析，抛出BuilderException异常

if (parsed) {

throw new BuilderException("Each XMLConfigBuilder can only be

used once.");

}

//标记已解析

parsed = true;

// 解析 XML configuration 节点

parseConfiguration(parser.evalNode("/configuration")); return configuration;

}

/**

*解析XML

*/

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.evalNode("objectFactory"));

// 解析 <objectWrapperFactory /> 标签

objectWrapperFactoryElement(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"));

// 解析 <typeHandlers /> 标签

typeHandlerElement(root.evalNode("typeHandlers"));

//解析<mappers />标签

mapperElement(root.evalNode("mappers"));

} catch (Exception e) {

throw new BuilderException("Error parsing SQL Mapper

Configuration.Cause:" + e, e);

}

}

<select id="getUser" resultType="user" >

select * from user where id=#{id}

</select>

 样的⼀个select标签会在初始化配置⽂件时被解析封装成⼀个MappedStatement对象，然后存储在

Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>

("Mapped Statements collection")

 在 XMLConfigBuilder 中的处理：

private void parseConfiguration(XNode root) {

try {

//省略其他标签的处理

mapperElement(root.evalNode("mappers"));

} catch (Exception e) {

throw new BuilderException("Error parsing SQL Mapper

Configuration.

Cause:" + e, e);

}

}

 到此对xml配置⽂件的解析就结束了，回到步骤2.中调⽤的重载build⽅法

// 5.调⽤的重载⽅法

public SqlSessionFactory build(Configuration config) {

//创建了 DefaultSqlSessionFactory 对象，传⼊ Configuration 对象。

return new DefaultSqlSessionFactory(config);

}

 

public class DefaultSqlSession implements SqlSession {

private final Configuration configuration;

private final Executor executor;

 

SqlSession sqlSession = factory.openSession();

List<User> list =

sqlSession.selectList("com.lagou.mapper.UserMapper.getUserByName");

 获得 sqlSession

//6. 进⼊ o penSession ⽅法。

public SqlSession openSession() {

//getDefaultExecutorType()传递的是SimpleExecutor

return

openSessionFromDataSource(configuration.getDefaultExecutorType(), null,

false);

}

//7. 进⼊penSessionFromDataSource。

//ExecutorType 为Executor的类型，TransactionIsolationLevel为事务隔离级别，

autoCommit是否开启事务

//openSession的多个重载⽅法可以指定获得的SeqSession的Executor类型和事务的处理

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()

}

//8.进⼊selectList⽅法，多个重载⽅法。

public <E > List < E > selectList(String statement) {

return this.selectList(statement, null);

public <E > List < E > selectList(String statement, Object parameter)

{

return this.selectList(statement, parameter, RowBounds.DEFAULT);

public <E > List < E > selectList(String statement, Object

parameter, RowBounds rowBounds) {

try {

//根据传⼊的全限定名+⽅法名从映射的Map中取出MappedStatement对象

MappedStatement ms =

configuration.getMappedStatement(statement);

//调⽤Executor中的⽅法处理

//RowBounds是⽤来逻辑分⻚

// wrapCollection(parameter)是⽤来装饰集合或者数组参数

return executor.query(ms, wrapCollection(parameter),

rowBounds, Executor.NO_RESULT_HANDLER);

} catch (Exception e) {

throw ExceptionFactory.wrapException("Error querying

database. Cause: + e, e);

} finally {

ErrorContext.instance().reset();

}

 源码剖析-executor

//此⽅法在SimpleExecutor的⽗类BaseExecutor中实现

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds

rowBounds, ResultHandler resultHandler) throws SQLException {

//根据传⼊的参数动态获得SQL语句，最后返回⽤BoundSql对象表示

BoundSql boundSql = ms.getBoundSql(parameter);

//为本次查询创建缓存的Key

CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);

return query(ms, parameter, rowBounds, resultHandler, key, boundSql);

}

//进⼊query的重载⽅法中 public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds

rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)

throws SQLException {

ErrorContext.instance().resource(ms.getResource()).activity("executing

a query").object(ms.getId());

if (closed) {

throw new ExecutorException("Executor was closed.");

}

if (queryStack == 0 && ms.isFlushCacheRequired()) {

clearLocalCache();

}

List<E> list;

try {

queryStack++;

list = resultHandler == null ? (List<E>) localCache.getObject(key)

: null;

if (list != null) {

handleLocallyCachedOutputParameters(ms, key, parameter,

boundSql);

} else {

//如果缓存中没有本次查找的值，那么从数据库中查询

list = queryFromDatabase(ms, parameter, rowBounds,

resultHandler, key, boundSql);

}

} finally {

queryStack--;

}

if (queryStack == 0) {

for (DeferredLoad deferredLoad : deferredLoads) {

deferredLoad.load();

}

// issue #601

deferredLoads.clear();

if (configuration.getLocalCacheScope() ==

LocalCacheScope.STATEMENT) { // issue #482 clearLocalCache();

}

}

return list;

}

//从数据库查询

private <E> List<E> queryFromDatabase(MappedStatement ms, Object

parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key,

BoundSql boundSql) throws SQLException {

List<E> list;

localCache.putObject(key, EXECUTION_PLACEHOLDER);

try {

//查询的⽅法

list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql); } finally {

localCache.removeObject(key);

}

//将查询结果放⼊缓存

localCache.putObject(key, list);

if (ms.getStatementType() == StatementType.CALLABLE) {

localOutputParameterCache.putObject(key, parameter);

}

return list;

}

// SimpleExecutor中实现⽗类的doQuery抽象⽅法

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();

//传⼊参数创建StatementHanlder对象来执⾏查询

StatementHandler handler =

configuration.newStatementHandler(wrapper, ms, parameter, rowBounds,

resultHandler, boundSql);

//创建jdbc中的statement对象

stmt = prepareStatement(handler, ms.getStatementLog());

// StatementHandler 进⾏处理

return handler.query(stmt, resultHandler);

} finally {

closeStatement(stmt);

}

}

//创建Statement的⽅法

private Statement prepareStatement(StatementHandler handler, Log

statementLog) throws SQLException {

Statement stmt;

//条代码中的getConnection⽅法经过重重调⽤最后会调⽤openConnection⽅法，从连接池

中获 得连接。

Connection connection = getConnection(statementLog);

stmt = handler.prepare(connection, transaction.getTimeout());

handler.parameterize(stmt);

return stmt;

}

//从连接池获得连接的⽅法

protected void openConnection() throws SQLException {

if (log.isDebugEnabled()) {

log.debug("Opening JDBC Connection");

}

 

connection = dataSource.getConnection();

if (level != null) {

connection.setTransactionIsolation(level.getLevel());

}

}

(1、根据传递的参数，完成SQL语句的动态解析，⽣成BoundSql对象，供StatementHandler使⽤；

(2、为查询创建缓存，以提⾼性能

(3、创建JDBC的Statement连接对象，传递给*StatementHandler*对象，返回List查询结果。

public void parameterize(Statement statement) throws SQLException {

//使⽤ParameterHandler对象来完成对Statement的设值

parameterHandler.setParameters((PreparedStatement) statement);

}

/** ParameterHandler 类的 setParameters(PreparedStatement ps) 实现

* 对某⼀个Statement进⾏设置参数

* */

public void setParameters(PreparedStatement ps) throws SQLException {

ErrorContext.instance().activity("setting

parameters").object(mappedStatement.getParameterMap().getId());

List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();

if (parameterMappings != null) { for (int i = 0; i <

parameterMappings.size(); i++) { ParameterMapping parameterMapping =

parameterMappings.get(i); if (parameterMapping.getMode() != ParameterMode.OUT)

{ Object value; String propertyName = parameterMapping.getProperty();

if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448

ask first for additional params

value = boundSql.getAdditionalParameter(propertyName);

} else if (parameterObject == null) { value = null;

} else if

(typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) { value =

parameterObject;

} else {

MetaObject metaObject =

configuration.newMetaObject(parameterObject);

value = metaObject.getValue(propertyName); }

// 每⼀个 Mapping都有⼀个 TypeHandler，根据 TypeHandler 来对

preparedStatement 进 ⾏设置参数

TypeHandler typeHandler = parameterMapping.getTypeHandler();

JdbcType jdbcType = parameterMapping.getJdbcType();

if (value == null && jdbcType == null) jdbcType =

configuration.getJdbcTypeForNull();

//设置参数

typeHandler.setParameter(ps, i + 1, value, jdbcType);

}

}

}

}

public <E> List<E> query(Statement statement, ResultHandler resultHandler)

throws SQLException {

// 1.调⽤preparedStatemnt。execute()⽅法，然后将resultSet交给ResultSetHandler处

理

PreparedStatement ps = (PreparedStatement) statement;

ps.execute();

//2.使⽤ ResultHandler 来处理 ResultSet

return resultSetHandler.<E> handleResultSets(ps);

}

 从上述代码我们可以看出，StatementHandler 的List query(Statement statement, ResultHandler resultHandler)⽅法的实现，是调⽤了 ResultSetHandler 的 handleResultSets(Statement)⽅法。ResultSetHandler 的 handleResultSets(Statement)⽅法会将 Statement 语句执⾏后⽣成的 resultSet

public List<Object> handleResultSets(Statement stmt) throws SQLException {

ErrorContext.instance().activity("handling

results").object(mappedStatement.getId());

//多ResultSet的结果集合，每个ResultSet对应⼀个Object对象。⽽实际上，每 个 Object 是

List<Object> 对象。

//在不考虑存储过程的多ResultSet的情况，普通的查询，实际就⼀个ResultSet，也 就是说，

multipleResults最多就⼀个元素。

final List<Object> multipleResults = new ArrayList<>();

int resultSetCount = 0;

//获得⾸个ResultSet对象，并封装成ResultSetWrapper对象

ResultSetWrapper rsw = getFirstResultSet(stmt);

//获得ResultMap数组

//在不考虑存储过程的多ResultSet的情况，普通的查询，实际就⼀个ResultSet，也 就是

说，resultMaps就⼀个元素。

List<ResultMap> resultMaps = mappedStatement.getResultMaps();

int resultMapCount = resultMaps.size();

validateResultMapsCount(rsw, resultMapCount); // 校验

while (rsw != null && resultMapCount > resultSetCount) {

//获得ResultMap对象

ResultMap resultMap = resultMaps.get(resultSetCount);

//处理ResultSet，将结果添加到multipleResults中

handleResultSet(rsw, resultMap, multipleResults, null);

//获得下⼀个ResultSet对象，并封装成ResultSetWrapper对象

rsw = getNextResultSet(stmt);

//清理

cleanUpAfterHandlingResultSet();

// resultSetCount ++

resultSetCount++;

}

}

//因为'mappedStatement.resultSets'只在存储过程中使⽤，本系列暂时不考虑，忽略即可

String[] resultSets = mappedStatement.getResultSets();

if(resultSets!=null)

{

while (rsw != null && resultSetCount < resultSets.length) {

ResultMapping parentMapping =

nextResultMaps.get(resultSets[resultSetCount]);

if (parentMapping != null) {

String nestedResultMapId =

parentMapping.getNestedResultMapId();

ResultMap resultMap =

configuration.getResultMap(nestedResultMapId);

handleResultSet(rsw, resultMap, null, parentMapping);

}

rsw = getNextResultSet(stmt);

cleanUpAfterHandlingResultSet();

resultSetCount++;

}

}

//如果是multipleResults单元素，则取⾸元素返回

return collapseSingleResultList(multipleResults);

}

10.2 Mapper代理⽅式：

 

public static void main(String[] args) {

//前三步都相同

InputStream inputStream =

Resources.getResourceAsStream("sqlMapConfig.xml");

SqlSessionFactory factory = new

SqlSessionFactoryBuilder().build(inputStream);

SqlSession sqlSession = factory.openSession();

//这⾥不再调⽤SqlSession的api,⽽是获得了接⼝对象，调⽤接⼝中的⽅法。

UserMapper mapper = sqlSession.getMapper(UserMapper.class); //使用jdk动态代理对mapper接口产生代理对象

//代理对象调用接口中的任意方法，执行的都是动态代理中的invoke方法

List<User> list = mapper.getUserByName("tom");

}

 

 思考⼀个问题，通常的Mapper接⼝我们都没有实现的⽅法却可以使⽤，是为什么呢？答案很简单动态 代理

 

<mappers>

<mapper class="com.lagou.mapper.UserMapper"/>

<package name="com.lagou.mapper"/>

</mappers>

进⼊ sqlSession.getMapper(UserMapper.class )中

//DefaultSqlSession 中的 getMapper

public <T> T getMapper(Class<T> type) {

return configuration.<T>getMapper(type, this);

}

//configuration 中的给 g etMapper

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {

return mapperRegistry.getMapper(type, sqlSession);

}

//MapperRegistry 中的 g etMapper

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {

//从 MapperRegistry 中的 HashMap 中拿 MapperProxyFactory

final MapperProxyFactory<T> mapperProxyFactory =

(MapperProxyFactory<T>) knownMappers.get(type);

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 T newInstance(SqlSession sqlSession) {

//创建了 JDK动态代理的Handler类

final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession,

mapperInterface, methodCache);

//调⽤了重载⽅法

return newInstance(mapperProxy);

}

//MapperProxy 类，实现了 InvocationHandler 接⼝

public class MapperProxy<T> implements InvocationHandler, Serializable {

//省略部分源码

private final SqlSession sqlSession;

private final Class<T> mapperInterface;

private final Map<Method, MapperMethod> methodCache;

//构造，传⼊了 SqlSession，说明每个session中的代理对象的不同的！

public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface,

Map<Method, MapperMethod> methodCache) {

 

this.sqlSession = sqlSession;

this.mapperInterface = mapperInterface;

this.methodCache = methodCache;

}

//省略部分源码

 源码剖析-invoke()

public Object invoke(Object proxy, Method method, Object[] args) throws

Throwable {

try {

//如果是Object定义的⽅法，直接调⽤

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 对象

final MapperMethod mapperMethod = cachedMapperMethod(method);

//重点在这：MapperMethod最终调⽤了执⾏的⽅法

return mapperMethod.execute(sqlSession, args);

}

 进⼊execute⽅法：

public Object execute(SqlSession sqlSession, Object[] args) {

Object result;

//判断mapper中的⽅法类型，最终调⽤的还是SqlSession中的⽅法 switch

(command.getType()) {

case INSERT: {

//转换参数

Object param = method.convertArgsToSqlCommandParam(args);

//执⾏INSERT操作

// 转换 rowCount

result = rowCountResult(sqlSession.insert(command.getName(),

param));

break;

}

case UPDATE: {

//转换参数 Object param = method.convertArgsToSqlCommandParam(args);

// 转换 rowCount

result = rowCountResult(sqlSession.update(command.getName(),

param));

break;

}

case DELETE: {

//转换参数

Object param = method.convertArgsToSqlCommandParam(args);

// 转换 rowCount

result = rowCountResult(sqlSession.delete(command.getName(),

param));

break;

}

case SELECT:

//⽆返回，并且有ResultHandler⽅法参数，则将查询的结果，提交给 ResultHandler 进

⾏处理

if (method.returnsVoid() && method.hasResultHandler()) {

executeWithResultHandler(sqlSession, args);

result = null;

//执⾏查询，返回列表

} else if (method.returnsMany()) {

result = executeForMany(sqlSession, args);

//执⾏查询，返回Map

} else if (method.returnsMap()) {

result = executeForMap(sqlSession, args);

//执⾏查询，返回Cursor

} else if (method.returnsCursor()) {

result = executeForCursor(sqlSession, args);

//执⾏查询，返回单个对象

} else {

//转换参数

Object param = method.convertArgsToSqlCommandParam(args);

//查询单条

result = sqlSession.selectOne(command.getName(), param);

if (method.returnsOptional() &&

(result == null ||

!method.getReturnType().equals(result.getClass()))) {

result = Optional.ofNullable(result);

}

}

break;

case FLUSH:

result = sqlSession.flushStatements();

break;

default:

throw new BindingException("Unknown execution method for: " +

command.getName());

}

//返回结果为null，并且返回类型为基本类型，则抛出BindingException异常

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;

10.3 ⼆级缓存源码剖析：

<settings>

<setting name="cacheEnabled" value="true"/>

</settings>

 

<cache></cache>

<select id="findById" resultType="com.lagou.pojo.User" useCache="true">

select * from user where id = #{id}

</select>

// XMLConfigBuilder.parse()

public Configuration parse() {

if (parsed) {

throw new BuilderException("Each XMLConfigBuilder can only be used

once.");

}

parsed = true;

parseConfiguration(parser.evalNode("/configuration"));// 在这⾥

return configuration;

}

// parseConfiguration()

// 既然是在xml中添加的，那么我们就直接看关于mappers标签的解析

private void parseConfiguration(XNode root) {

try {

Properties settings =

settingsAsPropertiess(root.evalNode("settings"));

propertiesElement(root.evalNode("properties"));

loadCustomVfs(settings);

typeAliasesElement(root.evalNode("typeAliases"));

pluginElement(root.evalNode("plugins"));

objectFactoryElement(root.evalNode("objectFactory"));

objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));

reflectionFactoryElement(root.evalNode("reflectionFactory"));

settingsElement(settings);

// read it after objectFactory and objectWrapperFactory issue #631

environmentsElement(root.evalNode("environments"));

databaseIdProviderElement(root.evalNode("databaseIdProvider"));

typeHandlerElement(root.evalNode("typeHandlers"));

// 就是这⾥

mapperElement(root.evalNode("mappers"));

} catch (Exception e) {

throw new BuilderException("Error parsing SQL Mapper Configuration.

Cause: " + e, e);

}

}

// mapperElement()

private void mapperElement(XNode parent) throws Exception {

if (parent != null) {

for (XNode child : parent.getChildren()) {

if ("package".equals(child.getName())) {

String mapperPackage = child.getStringAttribute("name");

configuration.addMappers(mapperPackage);

} else {

String resource = child.getStringAttribute("resource");

String url = child.getStringAttribute("url");

String mapperClass = child.getStringAttribute("class"); // 按照我们本例的配置，则直接⾛该if判断

if (resource != null && url == null && mapperClass == null) {

ErrorContext.instance().resource(resource);

InputStream inputStream =

Resources.getResourceAsStream(resource);

XMLMapperBuilder mapperParser = new

XMLMapperBuilder(inputStream, configuration, resource,

configuration.getSqlFragments());

// ⽣成XMLMapperBuilder，并执⾏其parse⽅法

mapperParser.parse();

} else if (resource == null && url != null && mapperClass ==

null) {

ErrorContext.instance().resource(url);

InputStream inputStream = Resources.getUrlAsStream(url);

XMLMapperBuilder mapperParser = new

XMLMapperBuilder(inputStream, configuration, url,

configuration.getSqlFragments());

mapperParser.parse();

} else if (resource == null && url == null && mapperClass !=

null) {

Class<?> mapperInterface =

Resources.classForName(mapperClass);

configuration.addMapper(mapperInterface);

} else {

throw new BuilderException("A mapper element may only

specify a url, resource or class, but not more than one.");

}

}

}

}

}

// XMLMapperBuilder.parse()

public void parse() {

if (!configuration.isResourceLoaded(resource)) {

// 解析mapper属性

configurationElement(parser.evalNode("/mapper"));

configuration.addLoadedResource(resource);

bindMapperForNamespace();

}

parsePendingResultMaps();

parsePendingChacheRefs();

parsePendingStatements();

}

// configurationElement()private void configurationElement(XNode context) {

try {

String namespace = context.getStringAttribute("namespace");

if (namespace == null || namespace.equals("")) {

throw new BuilderException("Mapper's namespace cannot be empty");

}

builderAssistant.setCurrentNamespace(namespace);

cacheRefElement(context.evalNode("cache-ref"));

// 最终在这⾥看到了关于cache属性的处理

cacheElement(context.evalNode("cache"));

parameterMapElement(context.evalNodes("/mapper/parameterMap"));

resultMapElements(context.evalNodes("/mapper/resultMap"));

sqlElement(context.evalNodes("/mapper/sql"));

// 这⾥会将⽣成的Cache包装到对应的MappedStatement

buildStatementFromContext(context.evalNodes("select|insert|update|delete"));

} catch (Exception e) {

throw new BuilderException("Error parsing Mapper XML. Cause: " + e,

e);

}

}

// cacheElement()

private void cacheElement(XNode context) throws Exception {

if (context != null) {

//解析<cache/>标签的type属性，这⾥我们可以⾃定义cache的实现类，⽐如redisCache，

如果没有⾃定义，这⾥使⽤和⼀级缓存相同的PERPETUAL

String type = context.getStringAttribute("type", "PERPETUAL");

Class<? extends Cache> typeClass =

typeAliasRegistry.resolveAlias(type);

String eviction = context.getStringAttribute("eviction", "LRU");

Class<? extends Cache> evictionClass =

typeAliasRegistry.resolveAlias(eviction);

Long flushInterval = context.getLongAttribute("flushInterval");

Integer size = context.getIntAttribute("size");

boolean readWrite = !context.getBooleanAttribute("readOnly", false);

boolean blocking = context.getBooleanAttribute("blocking", false);

Properties props = context.getChildrenAsProperties();

// 构建Cache对象

builderAssistant.useNewCache(typeClass, evictionClass, flushInterval,

size, readWrite, blocking, props);

}

}

 先来看看是如何构建Cache对象的

public Cache useNewCache(Class<? extends Cache> typeClass, Class<? extends Cache> evictionClass,

Long flushInterval,

Integer size,

boolean readWrite,

boolean blocking,

Properties props) {

// 1.⽣成Cache对象

Cache cache = new CacheBuilder(currentNamespace)

//这⾥如果我们定义了<cache/>中的type，就使⽤⾃定义的Cache,否则使⽤和⼀级缓存相

同的PerpetualCache

.implementation(valueOrDefault(typeClass, PerpetualCache.class))

.addDecorator(valueOrDefault(evictionClass, LruCache.class))

.clearInterval(flushInterval)

.size(size)

.readWrite(readWrite)

.blocking(blocking)

.properties(props)

.build();

// 2.添加到Configuration中

configuration.addCache(cache);

// 3.并将cache赋值给MapperBuilderAssistant.currentCache

currentCache = cache;

return cache;

}

public int update(String statement, Object parameter) {

int var4;

try {

this.dirty = true;

MappedStatement ms = this.configuration.getMappedStatement(statement);

var4 = this.executor.update(ms, this.wrapCollection(parameter));

} catch (Exception var8) {

throw ExceptionFactory.wrapException("Error updating database. Cause:

" + var8, var8);

} finally {

ErrorContext.instance().reset();

}

return var4;

}

public int update(MappedStatement ms, Object parameterObject) throws

SQLException {

this.flushCacheIfRequired(ms);

return this.delegate.update(ms, parameterObject);

}

private void flushCacheIfRequired(MappedStatement ms) {

//获取MappedStatement对应的Cache，进⾏清空

Cache cache = ms.getCache();

//SQL需设置flushCache="true" 才会执⾏清空

if (cache != null && ms.isFlushCacheRequired()) {

this.tcm.clear(cache);

}

}

10.4 延迟加载源码剖析：

什么是延迟加载？

* 在⼀对多中，当我们有⼀个⽤户，它有个100个订单

在查询⽤户的时候，要不要把关联的订单查出来？

在查询订单的时候，要不要把关联的⽤户查出来？

* 回答

在查询⽤户时，⽤户下的订单应该是，什么时候⽤，什么时候查询。 (延迟加载)

在查询订单时，订单所属的⽤户信息应该是随着订单⼀起查询出来。（立即加载）

 

优点：

先从单表查询，需要时再从关联表去关联查询，⼤⼤提⾼数据库性能，因为查询单表要⽐关联查询多张表

速度要快。

* 缺点：

因为只有当需要⽤到数据时，才会进⾏数据库查询，这样在⼤批量数据查询时，因为查询⼯作也要消耗时

间，所以可能造成⽤户等待时间变⻓，造成⽤户体验下降。

* 在多表中：

⼀对多，多对多：通常情况下采⽤延迟加载

⼀对⼀（多对⼀）：通常情况下采⽤⽴即加载

* 注意：

延迟加载是基于嵌套查询来实现的

 

#联合查询
SELECT u.*,o.id oid,o.`ordertime`,o.`total`,o.`uid` FROM USER u LEFT JOIN orders o ON u.id=o.uid
#嵌套查询
#1.先查询用户信息
SELECT * FROM USER WHERE id=1
#2.再根据tom用户信息查询相关的订单信息
SELECT * FROM ORDER WHERE uid=1

 

<resultMap id="userMap" type="com.lagou.pojo.User"><id property="id" column="id"></id><result property="username" column="username"></result><collection property="orderList" ofType="com.lagou.pojo.Order"select="com.lagou.mapper.IOrderMapper.findOrderByUid" column="id" ><id property="id" column="oid"/><result property="orderTime" column="ordertime"/><result property="total" column="total"/></collection>
</resultMap>

<select id="findById" resultMap="userMap"  >select * from user where id = #{id}
</select>

IOrderMapper接口映射文件定义
<select id="findOrderByUid" resultType="com.lagou.pojo.Order">select * from orders where uid = #{uid}
</select>

@Test
public void test4() throws IOException {InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);SqlSession sqlSession = factory.openSession();User user = sqlSession.selectOne("com.lagou.mapper.IUserMapper.findById", 1);System.out.println(user.getUsername());}

<!--开启全局的延迟加载配置-->
<settings><setting name="lazyLoadingEnabled" value="true"/>
</settings>

<!-- 关闭⼀对⼀ 延迟加载 -->

<resultMap id="orderMap" type="order">

<id column="id" property="id"></id>

<result column="ordertime" property="ordertime"></result>

<result column="total" property="total"></result>

<!--

fetchType="lazy" 懒加载策略

fetchType="eager" ⽴即加载策略

-->

<association property="user" column="uid" javaType="user"

select="com.lagou.dao.UserMapper.findById" fetchType="eager">

</association>

</resultMap>

<select id="findAll" resultMap="orderMap">

SELECT * from orders

</select>

public class Configuration {

/** aggressiveLazyLoading：

* 当开启时，任何⽅法的调⽤都会加载该对象的所有属性。否则，每个属性会按需加载（参考

lazyLoadTriggerMethods).

* 默认为true

* */

protected boolean aggressiveLazyLoading;

/**

* 延迟加载触发⽅法

*/

protected Set<String> lazyLoadTriggerMethods = new HashSet<String>

(Arrays.asList(new String[] { "equals", "clone", "hashCode", "toString" }));

/** 是否开启延迟加载 */

protected boolean lazyLoadingEnabled = false;

/**

* 默认使⽤Javassist代理⼯⼚

* @param proxyFactory

*/

public void setProxyFactory(ProxyFactory proxyFactory) {

if (proxyFactory == null) {

proxyFactory = new JavassistProxyFactory();

}

this.proxyFactory = proxyFactory;

}

//省略...

}

 

<code class="language-Java">//#mark 创建结果对象

private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap,

ResultLoaderMap lazyLoader, String columnPrefix) throws SQLException {

this.useConstructorMappings = false; // reset previous mapping result

final List&lt;Class&lt;?&gt;&gt; constructorArgTypes = new

ArrayList&lt;Class&lt;?&gt;&gt;();

final List&lt;Object&gt; constructorArgs = new ArrayList&lt;Object&gt;();

//#mark 创建返回的结果映射的真实对象

Object resultObject = createResultObject(rsw, resultMap,

constructorArgTypes, constructorArgs, columnPrefix);

if (resultObject != null &amp;&amp; !hasTypeHandlerForResultObject(rsw,

resultMap.getType())) {

final List&lt;ResultMapping&gt; propertyMappings =

resultMap.getPropertyResultMappings();

for (ResultMapping propertyMapping : propertyMappings) {

// 判断属性有没配置嵌套查询，如果有就创建代理对象

if (propertyMapping.getNestedQueryId() != null &amp;&amp;

propertyMapping.isLazy()) {

//#mark 创建延迟加载代理对象

resultObject =

configuration.getProxyFactory().createProxy(resultObject, lazyLoader,

configuration, objectFactory, constructorArgTypes, constructorArgs);

break;

}

}

}

this.useConstructorMappings = resultObject != null &amp;&amp;

!constructorArgTypes.isEmpty(); // set current mapping result

return resultObject; }

 JavasisstProxyFactory实现

public class JavassistProxyFactory implements

org.apache.ibatis.executor.loader.ProxyFactory {

/**

* 接⼝实现

* @param target ⽬标结果对象

* @param lazyLoader 延迟加载对象

* @param configuration 配置

* @param objectFactory 对象⼯⼚

* @param constructorArgTypes 构造参数类型

* @param constructorArgs 构造参数值

* @return

*/

@Override

public Object createProxy(Object target, ResultLoaderMap lazyLoader,

Configuration configuration, ObjectFactory objectFactory, List&lt;Class&lt;?

&gt;&gt; constructorArgTypes, List&lt;Object&gt; constructorArgs) {

return EnhancedResultObjectProxyImpl.createProxy(target, lazyLoader,

configuration, objectFactory, constructorArgTypes, constructorArgs);

}

//省略...

/**

* 代理对象实现，核⼼逻辑执⾏

*/

private static class EnhancedResultObjectProxyImpl implements MethodHandler

{

/**

* 创建代理对象

* @param type

* @param callback

* @param constructorArgTypes

* @param constructorArgs

* @return

*/ static Object crateProxy(Class&lt;?&gt; type, MethodHandler callback,

List&lt;Class&lt;?&gt;&gt; constructorArgTypes, List&lt;Object&gt;

constructorArgs) {

ProxyFactory enhancer = new ProxyFactory();

enhancer.setSuperclass(type);

try {

//通过获取对象⽅法，判断是否存在该⽅法

type.getDeclaredMethod(WRITE_REPLACE_METHOD);

// ObjectOutputStream will call writeReplace of objects returned by

writeReplace

if (log.isDebugEnabled()) {

log.debug(WRITE_REPLACE_METHOD + &quot; method was found on bean

&quot; + type + &quot;, make sure it returns this&quot;);

}

} catch (NoSuchMethodException e) {

//没找到该⽅法，实现接⼝

enhancer.setInterfaces(new Class[]{WriteReplaceInterface.class});

} catch (SecurityException e) {

// nothing to do here

}

Object enhanced;

Class&lt;?&gt;[] 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(&quot;Error creating lazy proxy. Cause:

&quot; + e, e);

}

//设置代理执⾏器

((Proxy) enhanced).setHandler(callback);

return enhanced;

}

/**

* 代理对象执⾏

* @param enhanced 原对象

* @param method 原对象⽅法

* @param methodProxy 代理⽅法

* @param args ⽅法参数

* @return

* @throws Throwable */

@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() &gt; 0) {

return new JavassistSerialStateHolder(original,

lazyLoader.getProperties(), objectFactory, constructorArgTypes,

constructorArgs);

} else {

return original;

}

} else {

//延迟加载数量⼤于0

if (lazyLoader.size() &gt; 0 &amp;&amp;

!FINALIZE_METHOD.equals(methodName)) {

//aggressive ⼀次加载性所有需要要延迟加载属性或者包含触发延迟加载⽅法

if (aggressive || lazyLoadTriggerMethods.contains(methodName)) {

log.debug(&quot;==&gt; laze lod trigger method:&quot; +

methodName + &quot;,proxy method:&quot; + methodProxy.getName() + &quot;

class:&quot; + enhanced.getClass());

//⼀次全部加载

lazyLoader.loadAll();

} else if (PropertyNamer.isSetter(methodName)) {

//判断是否为set⽅法，set⽅法不需要延迟加载

final String property =

PropertyNamer.methodToProperty(methodName);

lazyLoader.remove(property);

} else if (PropertyNamer.isGetter(methodName)) {

final String property =

PropertyNamer.methodToProperty(methodName);

if (lazyLoader.hasLoader(property)) {

//延迟加载单个属性

lazyLoader.load(property);

log.debug(&quot;load one :&quot; + methodName);

}

}

}

}

}

return methodProxy.invoke(enhanced, args);

} catch (Throwable t) {

throw ExceptionUtil.unwrapThrowable(t);

}

}

}

 注意事项